nodejs

Node.js runtime patterns, streams, worker threads, clustering, event loop optimization, and production-grade server architecture

インストールへ移動

リポジトリ: InugamiDev/ultrathink-oss
ソースの最終更新活動: 2026年4月13日 15:28
検出された SKILL.md の言語: 英語
スター: 43
フォーク: 10

インストール方法

デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。

Codex または Claude でインストールこの Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。

直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。

npx skills add https://github.com/InugamiDev/ultrathink-oss --skill nodejs

コマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。

ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。

ソースファイルを確認

インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。

SKILL.md

ソースの指示 · 読み取り専用プレビュー

検索に戻るインストールに戻る

design-kit

Unified design foundations — design system architecture, tokens, component specs, visual principles, creative vision, figma integration, plus brand design system loader (66 real brands via DESIGN.md). Absorbs design, design-system, design-systems, design-principles, design-router, creative-vision, figma, design-md.

2026-05-14

preview

Render, summarize, and present markdown documents and structured content in multiple output modes

2026-05-14

ultra-ui

Ultra UI skill - combines Google's DESIGN.md spec (machine-readable design tokens) with the ui-ux-pro-max knowledge base (91 styles, 161 palettes, 73 font pairings, 161 products, 104 UX guidelines, 25 chart types). Generates lint-clean DESIGN.md files, validates token references and WCAG contrast, exports Tailwind/DTCG tokens, and diffs design systems version-over-version.

2026-05-14

このリポジトリのすべてを見る

Node.js Domain Skill

Purpose

Provide expert-level guidance on Node.js runtime patterns, server architecture, performance optimization, and production deployment. This skill covers the entire Node.js ecosystem from event loop internals to clustering strategies.

Key Patterns

1. Event Loop Awareness

The event loop is single-threaded. Never block it.

// BAD: Blocking the event loop
const data = fs.readFileSync('/large-file.json');
const parsed = JSON.parse(data); // Blocks for large files

// GOOD: Non-blocking with streams
const stream = fs.createReadStream('/large-file.json');
const parsed = await pipeline(stream, new JSONParseStream());

Phases to understand:

Timers: setTimeout, setInterval callbacks
Pending callbacks: I/O callbacks deferred from previous cycle
Poll: Retrieve new I/O events; execute I/O callbacks
Check: setImmediate callbacks
Close: socket.on('close') callbacks

Use setImmediate() to yield to the event loop during CPU-intensive synchronous work:

function processLargeArray(array, callback) {
  const CHUNK = 1000;
  let index = 0;

  function doChunk() {
    const limit = Math.min(index + CHUNK, array.length);
    for (; index < limit; index++) {
      processItem(array[index]);
    }
    if (index < array.length) {
      setImmediate(doChunk); // Yield to event loop
    } else {
      callback();
    }
  }
  doChunk();
}

2. Streams

Always prefer streams for large data. The four stream types:

import { Readable, Writable, Transform, pipeline } from 'node:stream';
import { pipeline as pipelineAsync } from 'node:stream/promises';

// Transform stream for processing data chunks
class CSVToJSON extends Transform {
  constructor() {
    super({ objectMode: true });
    this.headers = null;
  }

  _transform(chunk, encoding, callback) {
    const line = chunk.toString().trim();
    if (!this.headers) {
      this.headers = line.split(',');
      return callback();
    }
    const values = line.split(',');
    const obj = Object.fromEntries(
      this.headers.map((h, i) => [h, values[i]])
    );
    this.push(obj);
    ();
  }
}


 (
  fs.(),
   (),
   ({
    : ,
    () {
      (, .(obj) + );
    }
  }),
  fs.()
);

Backpressure handling: Always respect writable.write() returning false:

async function* generateData() {
  for (let i = 0; i < 1_000_000; i++) {
    yield Buffer.from(`line ${i}\n`);
  }
}

// pipeline handles backpressure automatically
await pipelineAsync(
  Readable.from(generateData()),
  fs.createWriteStream('output.txt')
);

3. Worker Threads

Use for CPU-intensive operations. NOT for I/O (the event loop handles I/O efficiently).

// worker-pool.js
import { Worker } from 'node:worker_threads';
import { cpus } from 'node:os';

class WorkerPool {
  #workers = [];
  #queue = [];
  #activeWorkers = 0;

  constructor(workerPath, poolSize = cpus().length - 1) {
    this.workerPath = workerPath;
    this.poolSize = poolSize;
  }

  async execute(data) {
    return new Promise((resolve, reject) => {
      const task = { data, resolve, reject };

      if (this.#activeWorkers < this.poolSize) {
        this.#runTask(task);
      } else {
        this.#queue.push(task);
      }
    });
  }

  #runTask(task) {
    this.#activeWorkers++;
    const worker = new Worker(this.workerPath, {
      workerData: task.data
    });

    worker.on('message',  {
      task.(result);
      .#activeWorkers--;
       (.#queue. > ) {
        .#(.#queue.());
      }
    });

    worker.(,  {
      task.(err);
      .#activeWorkers--;
       (.#queue. > ) {
        .#(.#queue.());
      }
    });
  }

   () {
    
     (.#activeWorkers > ) {
        ( (r, ));
    }
  }
}


 pool =  ();
 results =  .(
  files.( pool.({ : file }))
);

4. Clustering

Use the cluster module or PM2 for multi-process scaling:

import cluster from 'node:cluster';
import { cpus } from 'node:os';
import process from 'node:process';

const WORKERS = parseInt(process.env.WEB_CONCURRENCY) || cpus().length;

if (cluster.isPrimary) {
  console.log(`Primary ${process.pid} starting ${WORKERS} workers`);

  for (let i = 0; i < WORKERS; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.error(`Worker ${worker.process.pid} died (${signal || code})`);
    if (code !== 0) {
      console.log('Starting replacement worker...');
      cluster.fork();
    }
  });
} else {
  // Workers share the TCP connection
  const app = createServer();
  app.listen(process.env.PORT || );
  .();
}

5. Graceful Shutdown

Always implement graceful shutdown in production:

class GracefulServer {
  #server;
  #connections = new Set();
  #isShuttingDown = false;

  constructor(app) {
    this.#server = app.listen(process.env.PORT || 3000);
    this.#server.on('connection', (conn) => {
      this.#connections.add(conn);
      conn.on('close', () => this.#connections.delete(conn));
    });

    process.on('SIGTERM', () => this.shutdown());
    process.on('SIGINT', () => this.shutdown());
  }

  async shutdown() {
    if (this.#isShuttingDown) return;
    this.#isShuttingDown = true;

    console.log('Graceful shutdown initiated...');

    // Stop accepting new connections
    this.#server.close( {
      .();
      process.();
    });

    
     ( conn  .#connections) {
      conn.();
    }

    
    ( {
      .();
       ( conn  .#connections) {
        conn.();
      }
      process.();
    }, );
  }
}

Best Practices

Use node: protocol for built-in modules: import fs from 'node:fs/promises'
Prefer node:fs/promises over callback-based fs
Use AbortController for cancellable operations
Set --max-old-space-size appropriately for memory-intensive apps
Enable source maps in production: --enable-source-maps
Use node --watch for development (Node 18+)
Validate environment variables at startup with libraries like envalid
Use structured logging (pino, winston) -- never console.log in production
Set proper keep-alive timeouts on HTTP servers (must exceed load balancer timeout)
Always handle unhandledRejection and uncaughtException**

process.on('unhandledRejection', (reason, promise) => {
  logger.error({ reason, promise }, 'Unhandled rejection');
  // In production, trigger graceful shutdown
});

process.on('uncaughtException', (error) => {
  logger.fatal({ error }, 'Uncaught exception');
  // Must exit -- state is unreliable after uncaught exception
  process.exit(1);
});

Common Pitfalls

Pitfall	Impact	Fix
Blocking event loop with `JSON.parse` on large payloads	All requests stall	Use streaming JSON parser or worker threads
Not handling backpressure in streams	Memory exhaustion	Use `pipeline()`, check `.write()` return value
Memory leaks from event listeners	OOM crashes	Remove listeners on cleanup, use `AbortController`
Using `cluster` with stateful sessions	Inconsistent state	Use Redis for session storage
Not setting `server.keepAliveTimeout`	502 errors behind load balancers	Set higher than LB timeout (e.g., 65s)
Sync operations in async context	Degraded throughput	Audit for sync calls: `readFileSync`, `execSync`
Ignoring `ERR_USE_AFTER_CLOSE`	Silent failures	Always check stream state before operations

Performance Checklist

No synchronous I/O in request handlers
Streams used for files > 10MB
Worker threads for CPU tasks > 50ms
Connection pooling for databases
Graceful shutdown implemented
Memory leak monitoring in place
HTTP keep-alive configured correctly
Clustering or PM2 for multi-core utilization

name	nodejs
description	Node.js runtime patterns, streams, worker threads, clustering, event loop optimization, and production-grade server architecture
layer	domain
category	backend
triggers	["node.js","nodejs","express","worker threads","node streams","clustering","event loop","node performance"]
inputs	["Backend architecture requirements","Performance bottleneck descriptions","Scaling requirements"]
outputs	["Node.js implementation patterns","Performance optimization strategies","Production deployment configurations"]
linksTo	["websockets","message-queues","microservices","graphql","prisma","drizzle","redis"]

name	nodejs
description	Node.js runtime patterns, streams, worker threads, clustering, event loop optimization, and production-grade server architecture
layer	domain
category	backend
triggers	["node.js","nodejs","express","worker threads","node streams","clustering","event loop","node performance"]
inputs	["Backend architecture requirements","Performance bottleneck descriptions","Scaling requirements"]
outputs	["Node.js implementation patterns","Performance optimization strategies","Production deployment configurations"]
linksTo	["websockets","message-queues","microservices","graphql","prisma","drizzle","redis"]

nodejs

ソース情報

インストール方法

ソースファイルを確認

このリポジトリの他の Skills

このリポジトリの他の Skills

Node.js Domain Skill

Purpose

Key Patterns

1. Event Loop Awareness

2. Streams

3. Worker Threads

4. Clustering

5. Graceful Shutdown

Best Practices

Common Pitfalls

Performance Checklist