Node.js

const fs = require('fs');

// Error-first callback: first arg is always error (or null)
fs.readFile('data.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Failed to read:', err.message);
    return;
  }
  console.log(data);
});
// Code continues executing immediately while the file is being read
console.log('This prints before the file content');

const fs = require('fs').promises;

fs.readFile('data.txt', 'utf8')
  .then(data => console.log(data))
  .catch(err  => console.error(err.message));

// Chaining
fetchUser(userId)
  .then(user => fetchOrders(user.id))
  .then(orders => res.json(orders))
  .catch(next);

async function loadConfig() {
  try {
    const raw  = await fs.readFile('config.json', 'utf8');  // pause here until done
    const data = JSON.parse(raw);
    return data;
  } catch (err) {
    console.error('Config error:', err.message);
    throw err;  // re-throw so the caller knows
  }
}

// Parallel execution — don't await sequentially if tasks are independent
async function loadAll() {
  // BAD — sequential, takes 2x as long
  const users  = await fetchUsers();
  const orders = await fetchOrders();

  // GOOD — parallel, takes max(fetchUsers, fetchOrders)
  const [users, orders] = await Promise.all([fetchUsers(), fetchOrders()]);
}

// ❌ BLOCKING — readFileSync freezes the entire process until complete
const data = fs.readFileSync('huge-file.csv');
// While waiting here, ALL other incoming requests are blocked

// ✅ NON-BLOCKING — process continues; callback fires when ready
fs.readFile('huge-file.csv', 'utf8', (err, data) => {
  // Handle data here
});
// Other requests can be served while the file is reading

// ✅ MODERN — async/await, still non-blocking
const data = await fs.promises.readFile('huge-file.csv', 'utf8');

const fs      = require('fs/promises'); // file system (async API)
const path    = require('path');        // cross-platform path manipulation
const os      = require('os');          // system info
const crypto  = require('crypto');      // hashing, encryption
const http    = require('http');        // raw HTTP server
const events  = require('events');      // EventEmitter
const stream  = require('stream');      // stream base classes

// Path — always use path.join instead of string concatenation
path.join(__dirname, 'public', 'index.html'); // platform-safe
path.resolve('./relative');                   // absolute path
path.extname('file.ts');                      // '.ts'
path.basename('/foo/bar/file.ts');            // 'file.ts'
path.dirname('/foo/bar/file.ts');             // '/foo/bar'

// OS
os.cpus().length;       // number of CPU cores
os.totalmem();          // total RAM in bytes
os.freemem();           // free RAM in bytes
os.platform();          // 'linux', 'darwin', 'win32'
os.tmpdir();            // system temp directory

// Crypto
const hash = crypto.createHash('sha256').update('password').digest('hex');
const uuid = crypto.randomUUID();   // built-in UUID generation (Node 15.6+)
const rand = crypto.randomBytes(32).toString('hex'); // secure random token

require('dotenv').config(); // load .env into process.env — call at startup

const port      = parseInt(process.env.PORT || '3000', 10);
const dbUrl     = process.env.DATABASE_URL;
const jwtSecret = process.env.JWT_SECRET;

if (!jwtSecret) {
  throw new Error('JWT_SECRET environment variable is required');
}

// ESM — reconstruct __dirname (not available natively)
import { fileURLToPath } from 'url';
import { dirname }       from 'path';
const __filename = fileURLToPath(import.meta.url);
const __dirname  = dirname(__filename);

// Mixing: CJS can't import ESM with require(). ESM can import CJS with import.
// If a dependency is ESM-only, you must use ESM yourself or dynamic import():
const chalk = await import('chalk'); // dynamic import works in CJS too

setTimeout(()           => console.log('timeout'),   0);
setImmediate(()         => console.log('immediate'));
process.nextTick(()     => console.log('nextTick'));
Promise.resolve().then(() => console.log('promise'));

// Output (inside an I/O callback): nextTick → promise → immediate → timeout
// Note: timeout vs immediate order is NON-DETERMINISTIC outside an I/O callback

const { pipeline } = require('stream/promises'); // promisified pipeline (Node 15+)

// Piping streams — the most common pattern
// pipeline handles backpressure and error propagation automatically
await pipeline(
  fs.createReadStream('large-file.csv'),   // Readable
  csvParser(),                              // Transform (parse CSV rows)
  new WritableStream({ objectMode: true,   // Writable
    write(row, enc, cb) {
      db.insert(row).then(() => cb()).catch(cb);
    }
  })
);

// Consuming a readable with async iteration (Node 12+)
async function processLines(filePath) {
  const rl = readline.createInterface({ input: fs.createReadStream(filePath) });
  for await (const line of rl) {
    await processLine(line);  // one line at a time — constant memory usage
  }
}

// Piping HTTP response directly to a file (zero in-memory buffering)
app.get('/download/:file', async (req, res) => {
  const stream = fs.createReadStream(`./files/${req.params.file}`);
  stream.pipe(res);                        // stream file directly to HTTP response
});

// Creating a Transform stream
const { Transform } = require('stream');

const toUpperCase = new Transform({
  transform(chunk, encoding, callback) {
    callback(null, chunk.toString().toUpperCase()); // push transformed data
  }
});

fs.createReadStream('input.txt')
  .pipe(toUpperCase)
  .pipe(fs.createWriteStream('output.txt'));

function writeWithBackpressure(readable, writable) {
  readable.on('data', (chunk) => {
    const canContinue = writable.write(chunk);
    if (!canContinue) {
      readable.pause();                    // pause the readable
      writable.once('drain', () => readable.resume()); // resume when writable is ready
    }
  });
}

// main.js
const { Worker, isMainThread, workerData, parentPort } = require('worker_threads');

if (isMainThread) {
  // Main thread: spawn a worker
  function runWorker(data) {
    return new Promise((resolve, reject) => {
      const worker = new Worker(__filename, { workerData: data });
      worker.on('message', resolve);
      worker.on('error', reject);
      worker.on('exit', code => {
        if (code !== 0) reject(new Error(`Worker stopped with exit code ${code}`));
      });
    });
  }

  app.get('/compute', async (req, res, next) => {
    try {
      const result = await runWorker({ input: req.query.n });
      res.json({ result });
    } catch (err) {
      next(err);
    }
  });
} else {
  // Worker thread: perform CPU work
  const result = heavyComputation(workerData.input);
  parentPort.postMessage(result);
}

// Share a buffer between main and worker without copying
const sharedBuffer = new SharedArrayBuffer(4);
const arr = new Int32Array(sharedBuffer);

const worker = new Worker('./worker.js', { workerData: { sharedBuffer } });
// Both threads read/write arr[0] directly — use Atomics for safe access

Atomics.add(arr, 0, 1);                    // atomic increment
Atomics.wait(arr, 0, 0);                   // wait until arr[0] changes from 0
Atomics.notify(arr, 0, 1);                 // wake one waiting thread

const EventEmitter = require('events');

class OrderService extends EventEmitter {
  async create(orderData) {
    const order = await db.createOrder(orderData);
    this.emit('order:created', order);  // fire event
    return order;
  }

  async ship(orderId) {
    const order = await db.shipOrder(orderId);
    this.emit('order:shipped', order);
    return order;
  }
}

const orderService = new OrderService();

// Subscribe to events — decoupled side effects
orderService.on('order:created', (order) => emailService.sendConfirmation(order));
orderService.on('order:created', (order) => inventoryService.reserve(order));
orderService.on('order:shipped', (order) => notificationService.push(order.userId, 'Shipped!'));

// once() — one-time listener
orderService.once('order:created', () => console.log('First order ever!'));

// Catch unhandled errors at the process level — last safety net
process.on('uncaughtException', (err) => {
  logger.error('Uncaught exception', err);
  process.exit(1);  // state is now undefined — must exit
});

process.on('unhandledRejection', (reason, promise) => {
  logger.error('Unhandled rejection', { reason, promise });
  process.exit(1);
});

// Graceful shutdown — finish in-flight requests before dying
const server = app.listen(3000);

async function gracefulShutdown(signal) {
  logger.info(`${signal} received, starting graceful shutdown`);
  server.close(async () => {           // stop accepting new TCP connections
    try {
      await db.pool.end();             // let ongoing DB queries finish, then close
      await redisClient.quit();
      logger.info('Graceful shutdown complete');
      process.exit(0);
    } catch (err) {
      logger.error('Error during shutdown', err);
      process.exit(1);
    }
  });
  // Force kill if it takes too long (e.g., stuck queries)
  setTimeout(() => {
    logger.warn('Forcing exit after timeout');
    process.exit(1);
  }, 30_000).unref(); // .unref() so this timer doesn't keep the process alive by itself
}

process.on('SIGTERM', () => gracefulShutdown('SIGTERM')); // Docker/K8s stop
process.on('SIGINT',  () => gracefulShutdown('SIGINT'));  // Ctrl+C

import cluster from 'cluster';
import { cpus } from 'os';
import { createServer } from './app.js';

if (cluster.isPrimary) {
  const numWorkers = cpus().length;
  console.log(`Primary ${process.pid} starting ${numWorkers} workers`);

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

  // Auto-restart dead workers
  cluster.on('exit', (worker, code, signal) => {
    console.warn(`Worker ${worker.process.pid} died (${signal || code}), restarting`);
    cluster.fork();
  });

  // IPC between primary and workers
  cluster.on('message', (worker, msg) => {
    if (msg.type === 'cache:invalidate') {
      for (const id in cluster.workers) {
        cluster.workers[id].send(msg);
      }
    }
  });
} else {
  createServer().listen(3000);
  console.log(`Worker ${process.pid} started`);
}

// 1. Global cache that grows without bound
const cache = {};
app.get('/item/:id', (req, res) => {
  cache[req.params.id] = bigObject; // never evicted — LEAK
});
// Fix: use a proper LRU cache
const LRU = require('lru-cache');
const cache = new LRU({ max: 1000, ttl: 1000 * 60 * 5 }); // 1000 items, 5min TTL

// 2. Event listeners never removed
class SomeService {
  init() {
    this.handler = (data) => this.process(data);
    globalEventBus.on('event', this.handler); // holds reference to 'this'
  }
  destroy() {
    globalEventBus.off('event', this.handler); // MUST remove
  }
}

// 3. Closures capturing large objects
function createHandler(largeBuffer) {
  return (req, res) => {
    // largeBuffer stays in memory as long as this function exists
    res.send(largeBuffer.slice(0, 10));
  };
}

// 4. Streams not consumed — Node buffers them
const readable = getReadableStream();
// If you never pipe or consume, data events buffer up → OOM
readable.resume(); // drain without processing if you don't need the data