Node.js Interview Questions — process.nextTick Starvation

// Event Loop Execution Order Demonstration
// Run this file and trace the output against the phase descriptions.
// Understanding why each line prints when it does is the interview answer.
const fs = require('fs');

console.log('1. Script Start — synchronous, runs first');

setTimeout(() => {
  // Timer phase — fires after Poll completes and timer threshold (minimum ~1ms) expires.
  // Outside an I/O callback, order vs setImmediate is not guaranteed.
  console.log('2. setTimeout (Timer Phase)');
}, 0);

setImmediate(() => {
  // Check phase — fires after Poll drains.
  // Outside an I/O callback, order vs setTimeout(0) is OS-dependent.
  console.log('3. setImmediate (Check Phase)');
});

fs.readFile(__filename, () => {
  // Poll phase callback — we are now inside an I/O callback.
  // Inside an I/O callback, the order changes:
  // setImmediate ALWAYS fires before setTimeout here.
  // This is deterministic, not OS-dependent.
  console.log('4. File Read Callback (Poll Phase)');

  setTimeout(() => console.log('5. Nested setTimeout — Timer Phase, after next Poll'), 0);
  setImmediate(() => console.log('6. Nested setImmediate — Check Phase, this loop iteration'));
});

process.nextTick(() => {
  // Not a phase — fires immediately after the current synchronous code
  // completes, before the event loop advances to Timers.
  // This is why recursive nextTick calls starve I/O.
  console.log('7. nextTick — fires between phases, highest priority');
});

Promise.resolve().then(() => {
  // Also a microtask — fires after nextTick queue drains, before next phase.
  // In Node.js 11+, Promise microtasks run after each nextTick queue flush.
  console.log('8. Promise.resolve().then — microtask after nextTick');
});

console.log('9. Script End — synchronous, runs before any callbacks');

// Memory-Efficient Stream Processing
// This pattern processes files of any size with constant memory overhead.
const fs   = require('fs');
const zlib = require('zlib');
const { pipeline } = require('stream/promises');
const path = require('path');

const sourceLog      = path.join(__dirname, 'massive_log.txt');
const compressedDest = path.join(__dirname, 'massive_log.txt.gz');

// ─── Recommended: pipeline() from stream/promises ───
// Advantages over .pipe():
//   - Propagates errors from any stream in the chain
//   - Destroys all streams on failure (prevents fd leaks)
//   - Returns a Promise — works with async/await and try/catch
async function compressLogFile(source, destination) {
  const readStream  = fs.createReadStream(source);        // reads in ~64KB chunks
  const gzipStream  = zlib.createGzip({ level: 6 });      // compresses each chunk
  const writeStream = fs.createWriteStream(destination);

  // pipeline() wires backpressure between all three streams.
  // If gzip falls behind, the read stream pauses automatically.
  // If the write stream fills, gzip pauses. No manual event wiring.
  await pipeline(readStream, gzipStream, writeStream);

  console.log(`Compressed: ${source} -> ${destination}`);
  return destination;
}

// ─── For comparison: what .pipe() looks like ───
// The key difference: if gzipStream emits an error, pipe() does NOT
// propagate it to writeStream or to the caller. Both streams keep running,
// the destination file is left in an incomplete state, and there is no
// indication anything went wrong unless you attach explicit error listeners.
function compressWithPipe(source, destination) {
  return new Promise((resolve, reject) => {
    const read  = fs.createReadStream(source);
    const gzip  = zlib.createGzip();
    const write = fs.createWriteStream(destination);

    // Must attach error listeners to EVERY stream individually with pipe()
    read.on('error', reject);
    gzip.on('error', reject);
    write.on('error', reject);
    write.on('finish', resolve);

    read.pipe(gzip).pipe(write);
  });
}

(async () => {
  try {
    await compressLogFile(sourceLog, compressedDest);
  } catch (err) {
    // pipeline() rejects with the first error from any stream.
    // All streams have already been destroyed at this point.
    console.error('Compression failed:', err.message);
    process.exit(1);
  }
})();

// Async/Await Pitfalls and Correct Patterns
// Each trap is shown with the wrong approach first, then the fix.

// ─────────────────────────────────────────────────────────────
// TRAP 1: .forEach() does NOT await Promises
// The most common source of silent async bugs in production Node.js code.
// ─────────────────────────────────────────────────────────────

// WRONG: This does not process users sequentially.
// Each async callback returns a Promise. forEach discards it immediately.
// The loop completes before any fetch resolves. results stays empty.
async function processUsersWrong(userIds) {
  const results = [];
  userIds.forEach(async (id) => {
    const user = await fetchUser(id); // forEach does NOT await this
    results.push(user);               // never executes before forEach returns
  });
  return results; // [] — always empty, no error thrown
}

// RIGHT — Sequential: use for...of when order matters or each step depends on the prior
async function processUsersSequential(userIds) {
  const results = [];
  for (const id of userIds) {
    const user = await fetchUser(id); // actually waits for each fetch
    results.push(user);
  }
  return results; // [user1, user2, user3, ...] in order
}

// RIGHT — Parallel: use Promise.all when operations are independent
async function processUsersParallel(userIds) {
  // All fetches start simultaneously. Total time = slowest single fetch.
  return Promise.all(userIds.map(id => fetchUser(id)));
}

// ─────────────────────────────────────────────────────────────
// TRAP 2: Sequential awaits on independent operations waste latency.
// This is the most common performance bug in async request handlers.
// ─────────────────────────────────────────────────────────────

async function loadDashboardSlow(userId) {
  const profile       = await fetchProfile(userId);      // 100ms — waits for this
  const orders        = await fetchOrders(userId);       // 150ms — then waits for this
  const notifications = await fetchNotifications(userId); //  80ms — then this
  return { profile, orders, notifications };             // 330ms total
}

async function loadDashboardFast(userId) {
  const [profile, orders, notifications] = await Promise.all([
    fetchProfile(userId),       // 100ms ─┐
    fetchOrders(userId),        // 150ms ─┤ all start simultaneously
    fetchNotifications(userId)  //  80ms ─┘
  ]);
  return { profile, orders, notifications }; // 150ms total — 55% faster
}

// ─────────────────────────────────────────────────────────────
// TRAP 3: Promise.all fails fast — use allSettled for partial results.
// One widget failing should not blank the entire dashboard.
// ─────────────────────────────────────────────────────────────

async function loadWidgetsWithAllSettled(widgetConfigs) {
  const results = await Promise.allSettled(
    widgetConfigs.map(config => fetchWidgetData(config))
  );

  // allSettled always resolves — never rejects. Each result has status.
  return results.map((result, i) => ({
    widget: widgetConfigs[i].name,
    data:   result.status === 'fulfilled' ? result.value : null,
    error:  result.status === 'rejected'  ? result.reason.message : null
  }));
}

// ─────────────────────────────────────────────────────────────
// TRAP 4: Uncontrolled concurrency — Promise.all(10000 items) creates
// 10,000 simultaneous connections. Saturates pools and triggers rate limits.
// ─────────────────────────────────────────────────────────────
async function processLargeDatasetSafely(items) {
  const { default: pLimit } = await import('p-limit'); // npm install p-limit
  const limit = pLimit(10); // maximum 10 concurrent operations at any time

  return Promise.all(
    items.map(item => limit(() => processItem(item)))
  );
}

// Simulated helpers
async function fetchUser(id)          { return { id, name: `User ${id}` }; }
async function fetchProfile(id)       { return { id, bio: 'Engineer' }; }
async function fetchOrders(id)        { return [{ id: 1, total: 99 }]; }
async function fetchNotifications(id) { return [{ msg: 'Welcome' }]; }
async function fetchWidgetData(config){ return { type: config.name, value: 42 }; }
async function processItem(item)      { return { processed: item }; }

// Production-Aware Cluster Setup
// Includes the circuit breaker pattern that prevents fork-bomb on bad deploys.
const cluster = require('node:cluster');
const http    = require('node:http');
const os      = require('node:os');

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

  // Force round-robin on all platforms — Windows defaults to OS scheduling
  // which produces uneven distribution under bursty traffic.
  cluster.schedulingPolicy = cluster.SCHED_RR;

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

  // ─── Circuit breaker for worker restarts ───
  // Without this, a bad deploy that crashes every worker on startup
  // creates a fork-bomb: crash → fork → crash → fork → exponential process growth.
  const crashLog = [];
  const WINDOW_MS = 30_000;
  const MAX_CRASHES = 5;
  let backoffMs = 1_000;

  cluster.on('exit', (worker, code, signal) => {
    if (worker.exitedAfterDisconnect) {
      // Intentional shutdown (SIGTERM during rolling restart) — fork immediately.
      console.log(`Worker ${worker.id} gracefully exited. Replacing.`);
      cluster.fork();
      backoffMs = 1_000; // reset backoff on clean exit
      return;
    }

    // Unexpected crash — apply backoff and check circuit breaker.
    const now = Date.now();
    crashLog.push(now);
    const recentCrashes = crashLog.filter(t => now - t < WINDOW_MS);

    if (recentCrashes.length >= MAX_CRASHES) {
      console.error(
        `Circuit breaker: ${recentCrashes.length} crashes in ${WINDOW_MS / 1000}s. ` +
        'Stopping forks. Alert on-call.'
      );
      return;
    }

    console.warn(`Worker ${worker.process.pid} crashed (code: ${code}). Backoff: ${backoffMs}ms`);
    setTimeout(() => cluster.fork(), backoffMs);
    backoffMs = Math.min(backoffMs * 2, 30_000); // exponential backoff, capped at 30s
  });

} else {
  // Worker process — handles HTTP requests, each with its own event loop.
  const server = http.createServer((req, res) => {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end(`Handled by worker ${process.pid}\n`);
  });

  server.listen(3000, () => {
    console.log(`Worker ${process.pid} ready`);
  });

  // Graceful shutdown on SIGTERM — drain in-flight requests before exiting.
  // The primary sees exitedAfterDisconnect === true and forks a replacement
  // without applying backoff.
  process.on('SIGTERM', () => {
    server.close(() => {
      console.log(`Worker ${process.pid} drained and exiting.`);
      process.exit(0);
    });
    // Force exit after 30 seconds if connections are still open
    setTimeout(() => process.exit(0), 30_000).unref();
  });
}

// Layered Error Handling Pattern
// This is the structure I reach for in every Express service.
// Each layer has a specific job and they compose cleanly.

// ─── Layer 1: Custom error classes with domain context ───
// isOperational: true = expected failure — log and respond, keep running
// isOperational: false/absent = bug — log full stack, restart process
class AppError extends Error {
  constructor(message, statusCode, errorCode) {
    super(message);
    this.name        = this.constructor.name;
    this.statusCode  = statusCode;
    this.errorCode   = errorCode;
    this.isOperational = true; // the flag that matters at process level
    Error.captureStackTrace(this, this.constructor);
  }
}

class ValidationError extends AppError {
  constructor(message, fieldName) {
    super(message, 422, 'VALIDATION_ERROR');
    this.fieldName = fieldName;
  }
}

class NotFoundError extends AppError {
  constructor(resourceType, resourceId) {
    super(`${resourceType} with ID ${resourceId} not found`, 404, 'NOT_FOUND');
  }
}

class ExternalServiceError extends AppError {
  constructor(serviceName, originalError) {
    super(`${serviceName} is unavailable`, 503, 'EXTERNAL_SERVICE_ERROR');
    this.originalError = originalError;
  }
}

// ─── Layer 2: asyncHandler wrapper for Express routes ───
// Wraps async route handlers so Promise rejections flow to Express
// error middleware via next(). Without this, async throws are unhandled.
const asyncHandler = (fn) => (req, res, next) => {
  Promise.resolve(fn(req, res, next)).catch(next);
};

// ─── Layer 3: Global Express error middleware ───
// Must be registered LAST, after all routes and other middleware.
// The four-argument signature (err, req, res, next) is how Express
// identifies error-handling middleware.
function globalErrorHandler(err, req, res, next) {
  const timestamp = new Date().toISOString();

  if (err.isOperational) {
    // Expected failure — log for visibility, respond to client
    console.warn(`[${timestamp}] ${err.name} [${err.errorCode}]: ${err.message}`);
    return res.status(err.statusCode).json({
      success:  false,
      error: { code: err.errorCode, message: err.message }
    });
  }

  // Unexpected bug — hide internals from client, log full stack for debugging
  console.error(`[${timestamp}] CRITICAL ${err.name}: ${err.stack}`);
  // In production: Sentry.captureException(err), DataDog.error(err), etc.
  return res.status(500).json({
    success: false,
    error: { code: 'INTERNAL_ERROR', message: 'An unexpected error occurred.' }
  });
}

// ─── Layer 4: Process-level safety net ───
// These handlers catch what slipped through all other layers.
// They should be last-resort, not first-line defense.
process.on('unhandledRejection', (reason, promise) => {
  // In Node 15+, this crashes the process by default.
  // Here we log with context before the crash.
  console.error('Unhandled Promise Rejection:', reason);
  // Optionally: emit to monitoring, then let the process manager restart
});

process.on('uncaughtException', (error) => {
  console.error('Uncaught Exception — this is a bug:', error.stack);
  // Give logging a moment to flush before exiting.
  // Your process manager (PM2, systemd) will restart the process.
  setTimeout(() => process.exit(1), 1000);
});

module.exports = {
  AppError,
  ValidationError,
  NotFoundError,
  ExternalServiceError,
  asyncHandler,
  globalErrorHandler
};