Node.js Interview Questions

1// Node.js can handle 1000 concurrent DB queries despite being single-threaded
2// because it doesn't WAIT for each query - it fires all 1000 and handles
3// responses as they come back
4
5const http = require('http');
6
7http.createServer(async (req, res) => {
8  // This DB call is non-blocking - Node doesn't sit and wait
9  // It registers the callback and goes back to the event loop
10  const user = await db.findUser(req.url.split('/')[2]);
11  res.end(JSON.stringify(user));
12}).listen(3000);
13
14// While one request is waiting for the DB, Node.js is already
15// accepting and processing other incoming requests
16

1// math.js - exporting
2const add      = (a, b) => a + b;
3const subtract = (a, b) => a - b;
4
5module.exports = { add, subtract };   // export an object
6// OR: module.exports = add;          // export a single value
7
8// app.js - importing
9const { add, subtract } = require('./math');  // local file
10const fs      = require('fs');                // built-in core module
11const express = require('express');           // npm package
12
13console.log(add(2, 3));       // 5
14console.log(subtract(10, 4)); // 6
15
16// Each file gets these variables automatically in CommonJS:
17// __filename - absolute path to the current file
18// __dirname  - absolute path to the current file's directory
19// module     - the module object
20// exports    - shorthand for module.exports
21// require    - the function to load modules
22

1{
2  "name": "my-api",
3  "version": "1.0.0",
4  "description": "A sample REST API",
5  "main": "src/index.js",
6  "scripts": {
7    "start":   "node src/index.js",
8    "dev":     "nodemon src/index.js",
9    "test":    "jest --coverage",
10    "build":   "tsc"
11  },
12  "engines": {
13    "node": ">=18.0.0"
14  },
15  "dependencies": {
16    "express":  "^4.18.2",
17    "mongoose": "^8.0.0"
18  },
19  "devDependencies": {
20    "nodemon": "^3.0.0",
21    "jest":    "^29.0.0"
22  }
23}
24

1const http = require('http');
2
3const server = http.createServer((req, res) => {
4  // req = IncomingMessage - the incoming HTTP request
5  // res = ServerResponse  - the outgoing HTTP response
6
7  console.log(`${req.method} ${req.url}`);
8
9  // Simple router
10  if (req.url === '/' && req.method === 'GET') {
11    res.writeHead(200, { 'Content-Type': 'application/json' });
12    res.end(JSON.stringify({ message: 'Hello from Node.js!' }));
13
14  } else if (req.url === '/health') {
15    res.writeHead(200, { 'Content-Type': 'application/json' });
16    res.end(JSON.stringify({ status: 'ok' }));
17
18  } else {
19    res.writeHead(404, { 'Content-Type': 'application/json' });
20    res.end(JSON.stringify({ error: 'Route not found' }));
21  }
22});
23
24const PORT = process.env.PORT || 3000;
25server.listen(PORT, () => {
26  console.log(`Server running at http://localhost:${PORT}`);
27});
28
29// This is essentially what Express does internally - it just
30// adds routing, middleware, and body parsing on top
31

1const fs = require('fs');
2const fsp = require('fs/promises'); // promise-based API (Node 14+)
3
4// ─── Async callback style ────────────────────────────────────────────────
5fs.readFile('./data.json', 'utf8', (err, data) => {
6  if (err) return console.error(err);
7  console.log(JSON.parse(data));
8});
9
10fs.writeFile('./output.txt', 'Hello Node!', 'utf8', (err) => {
11  if (err) throw err;
12  console.log('File written successfully');
13});
14
15// ─── Promise / async-await style (preferred) ─────────────────────────────
16async function readConfig() {
17  const data = await fsp.readFile('./config.json', 'utf8');
18  return JSON.parse(data);
19}
20
21async function saveLog(message) {
22  await fsp.appendFile('./app.log', `${new Date().toISOString()} - ${message}\n`);
23}
24
25// Other common fs methods:
26// fs.existsSync(path)              - check if file/dir exists (sync is ok for startup)
27// fs.mkdirSync(path, { recursive: true }) - create directory tree
28// fs.readdirSync(path)             - list files in a directory
29// fs.unlinkSync(path)              - delete a file
30// fs.rename(oldPath, newPath, cb)  - rename / move a file
31// fs.statSync(path)                - get file metadata (size, modified date, etc.)
32// fs.createReadStream(path)        - read large files as a stream
33// fs.createWriteStream(path)       - write large files as a stream
34

1const path = require('path');
2
3// ✗ Bad - breaks on Windows
4const configPath = __dirname + '/config/database.json';
5
6// ✅ Good - works on all platforms
7const configPath = path.join(__dirname, 'config', 'database.json');
8
9// ─── Common path methods ─────────────────────────────────────────────────
10
11// path.join() - joins path segments with the correct separator
12path.join('/home', 'vishal', 'app', 'index.js');
13// '/home/vishal/app/index.js'
14
15// path.resolve() - resolves to an absolute path from left to right
16path.resolve('src', 'routes', 'user.js');
17// '/current/working/directory/src/routes/user.js'
18
19// path.basename() - filename from a path (with or without extension)
20path.basename('/home/vishal/app/index.js');       // 'index.js'
21path.basename('/home/vishal/app/index.js', '.js'); // 'index'
22
23// path.dirname() - directory part of a path
24path.dirname('/home/vishal/app/index.js'); // '/home/vishal/app'
25
26// path.extname() - file extension
27path.extname('photo.png');  // '.png'
28path.extname('archive.tar.gz'); // '.gz'
29
30// path.parse() - breaks a path into its components
31path.parse('/home/vishal/app/index.js');
32// { root: '/', dir: '/home/vishal/app', base: 'index.js',
33//   ext: '.js', name: 'index' }
34

1const fs = require('fs');
2
3// ✗ BLOCKING - freezes the server for all users until the file is read
4const data = fs.readFileSync('/large-file.txt', 'utf8');
5console.log('File read complete');
6console.log('This runs AFTER file is fully read');
7
8// ✅ NON-BLOCKING - server keeps serving requests while file is being read
9fs.readFile('/large-file.txt', 'utf8', (err, data) => {
10  if (err) throw err;
11  console.log('File read complete'); // runs later, when OS is done
12});
13console.log('This runs IMMEDIATELY - before the file is read');
14
15// ✅ NON-BLOCKING with async/await (cleaner)
16const { readFile } = require('fs/promises');
17async function loadFile() {
18  const data = await readFile('/large-file.txt', 'utf8'); // non-blocking
19  return data;
20}
21

1const fs = require('fs');
2
3// The callback always follows the pattern: (err, result)
4fs.readFile('./config.json', 'utf8', (err, data) => {
5  // ALWAYS check err first
6  if (err) {
7    console.error('Failed to read file:', err.message);
8    return; // stop execution - don't use data
9  }
10  // Only reach here if err is null
11  console.log(JSON.parse(data));
12});
13
14// Writing your own error-first callback functions
15function divideNumbers(a, b, callback) {
16  if (b === 0) {
17    // Error case - pass an Error as the first argument
18    return callback(new Error('Cannot divide by zero'));
19  }
20  // Success case - first arg is null, second is the result
21  callback(null, a / b);
22}
23
24divideNumbers(10, 2, (err, result) => {
25  if (err) return console.error(err.message);
26  console.log('Result:', result); // 5
27});
28
29divideNumbers(10, 0, (err, result) => {
30  if (err) return console.error(err.message); // 'Cannot divide by zero'
31  console.log(result); // never reached
32});
33

1const EventEmitter = require('events');
2
3const emitter = new EventEmitter();
4
5// on() - subscribe to an event (fires every time event is emitted)
6emitter.on('data', (chunk) => console.log('Received:', chunk));
7
8// once() - subscribe but fires only the first time
9emitter.once('connect', () => console.log('Connected!'));
10
11// emit() - publish / trigger an event
12emitter.emit('data', { id: 1, value: 'hello' });
13emitter.emit('connect');
14emitter.emit('connect'); // ignored - once() already fired
15
16// off() - remove a specific listener (important for memory leak prevention)
17const handler = (data) => console.log(data);
18emitter.on('update', handler);
19emitter.off('update', handler); // removes that specific handler
20
21// Custom class extending EventEmitter
22class OrderService extends EventEmitter {
23  async placeOrder(orderData) {
24    const order = await db.createOrder(orderData);
25    this.emit('order:created', order);   // notify listeners
26    this.emit('inventory:update', order.items);
27    return order;
28  }
29}
30
31const orderService = new OrderService();
32orderService.on('order:created', order => sendConfirmationEmail(order));
33orderService.on('inventory:update', items => updateInventory(items));
34
35// ⚠️ 'error' event is special - if emitted with no listener, Node.js throws
36emitter.on('error', (err) => console.error('Caught:', err.message)); // always add this
37

1console.log('1 - start');          // sync - runs immediately
2
3setTimeout(() => {
4  console.log('4 - setTimeout');   // macrotask queue
5}, 0);
6
7Promise.resolve().then(() => {
8  console.log('3 - promise');       // microtask queue
9});
10
11process.nextTick(() => {
12  console.log('2 - nextTick');      // nextTick queue (highest priority)
13});
14
15console.log('5 - end');            // sync - runs immediately
16
17// Output:
18// 1 - start
19// 5 - end
20// 2 - nextTick    ← nextTick drains before anything else
21// 3 - promise     ← Promise microtasks drain next
22// 4 - setTimeout  ← macrotask fires last
23

1const fs = require('fs');
2
3// Inside an I/O callback, order is always deterministic
4fs.readFile(__filename, () => {
5  setTimeout(    () => console.log('setTimeout'),  0);
6  setImmediate(  () => console.log('setImmediate'));
7  process.nextTick(() => console.log('nextTick'));
8  Promise.resolve().then(() => console.log('promise'));
9});
10// Output (always):
11// nextTick → promise → setImmediate → setTimeout
12

1// ⚠️ Microtask starvation - a dangerous pattern
2function recursiveNextTick() {
3  process.nextTick(recursiveNextTick);
4}
5recursiveNextTick();
6// The nextTick queue never empties → event loop never advances
7// setTimeout and I/O will NEVER run - the server is starved
8
9// ✅ Safe recursive async pattern
10function recursiveSafe() {
11  setImmediate(recursiveSafe); // yields to event loop each iteration
12}
13

1// CommonJS
2const { readFile } = require('fs');
3module.exports = { myFunction };
4
5// Conditional import - valid in CJS
6if (process.env.DEBUG) {
7  const debugTools = require('./debug');
8}
9
10// ES Modules
11import { readFile } from 'fs';
12export { myFunction };
13export default myFunction;
14
15// ESM __dirname equivalent
16import { fileURLToPath } from 'url';
17import { dirname } from 'path';
18const __filename = fileURLToPath(import.meta.url);
19const __dirname  = dirname(__filename);
20
21// Dynamic import - works in both CJS and ESM
22const module = await import('./lazy-module.mjs');
23

1// counter.js
2let count = 0;
3module.exports = { increment: () => ++count, getCount: () => count };
4
5// app.js
6const a = require('./counter');
7const b = require('./counter'); // returns cached object - NOT a new one
8
9a.increment();
10a.increment();
11console.log(b.getCount()); // 2 - same instance!
12console.log(a === b);      // true
13
14// Inspect the cache
15console.log(Object.keys(require.cache)); // all cached module paths
16
17// Force reload (rare - usually signals a design problem)
18delete require.cache[require.resolve('./counter')];
19const fresh = require('./counter'); // module code runs again
20

1const fs   = require('fs');
2const zlib = require('zlib');
3const { pipeline } = require('stream/promises');
4
5// ✗ Loads entire file into memory - bad for large files
6const data = fs.readFileSync('huge.csv');
7fs.writeFileSync('huge.csv.gz', zlib.gzipSync(data));
8
9// ✅ Pipe streams - memory stays constant no matter how large the file
10await pipeline(
11  fs.createReadStream('huge.csv'),  // Readable
12  zlib.createGzip(),                // Transform (compress)
13  fs.createWriteStream('huge.csv.gz') // Writable
14);
15// pipeline() automatically destroys all streams on error - use it over .pipe()
16

1// Creating buffers
2const buf1 = Buffer.alloc(10);               // 10 zero bytes (safe - always use this)
3const buf2 = Buffer.from('Hello Node.js');   // from a string (UTF-8)
4const buf3 = Buffer.from([0x48, 0x65, 0x6c]); // from a byte array
5
6// Reading
7console.log(buf2.toString());        // 'Hello Node.js'
8console.log(buf2.toString('hex'));   // '48656c6c6f...'
9console.log(buf2.length);           // byte length (not character count)
10
11// Buffers appear automatically in Node.js I/O
12const http = require('http');
13http.createServer((req, res) => {
14  const chunks = [];
15  req.on('data', chunk => chunks.push(chunk)); // each chunk is a Buffer
16  req.on('end', () => {
17    const body = Buffer.concat(chunks).toString();
18    res.end(body);
19  });
20}).listen(3000);
21
22// ⚠️ Never use Buffer.allocUnsafe() with user-facing data
23// It contains old (potentially sensitive) memory contents
24const unsafe = Buffer.allocUnsafe(10); // fast but uninitialized
25const safe   = Buffer.alloc(10);       // zero-filled - always prefer this
26

1// Same task in all three styles: read a file then query a DB
2
3// 1. Callbacks
4fs.readFile('config.json', (err, data) => {
5  if (err) return handleError(err);
6  db.query('SELECT * FROM users', (err2, rows) => {
7    if (err2) return handleError(err2);
8    console.log(rows);
9  });
10});
11
12// 2. Promises
13fs.promises.readFile('config.json')
14  .then(() => db.query('SELECT * FROM users'))
15  .then(rows => console.log(rows))
16  .catch(handleError);
17
18// 3. async/await
19async function loadData() {
20  try {
21    await fs.promises.readFile('config.json');
22    const rows = await db.query('SELECT * FROM users');
23    console.log(rows);
24  } catch (err) {
25    handleError(err);
26  }
27}
28

1// ✗ Callback hell
2getUser(id, (err, user) => {
3  if (err) return handleError(err);
4  getOrders(user.id, (err, orders) => {
5    if (err) return handleError(err);
6    getDetails(orders[0].id, (err, details) => {
7      if (err) return handleError(err);
8      sendEmail(user.email, details, (err) => {
9        if (err) return handleError(err);
10        console.log('Done!'); // buried 4 levels deep
11      });
12    });
13  });
14});
15
16// ✅ async/await - reads like synchronous code
17async function processOrder(id) {
18  try {
19    const user    = await getUser(id);
20    const orders  = await getOrders(user.id);
21    const details = await getDetails(orders[0].id);
22    await sendEmail(user.email, details);
23    console.log('Done!');
24  } catch (err) {
25    handleError(err);
26  }
27}
28

1// Promise.all - fails if any one fails
2const [user, orders] = await Promise.all([fetchUser(id), fetchOrders(id)]);
3
4// Promise.allSettled - always resolves, inspect each result
5const results = await Promise.allSettled([api1(), api2(), api3()]);
6results.forEach(r => r.status === 'fulfilled'
7  ? console.log('OK:', r.value)
8  : console.error('Failed:', r.reason));
9
10// Promise.race - implement a request timeout
11const withTimeout = (p, ms) => Promise.race([
12  p,
13  new Promise((_, rej) => setTimeout(() => rej(new Error('Timeout')), ms)),
14]);
15const data = await withTimeout(fetchData(), 5000);
16
17// Promise.any - first successful CDN wins
18const img = await Promise.any([
19  fetch('https://cdn1.example.com/img.png'),
20  fetch('https://cdn2.example.com/img.png'),
21]);
22

1// Pattern 1: try/catch
2async function getUser(id) {
3  try {
4    const user = await db.findById(id);
5    if (!user) throw new Error('User not found');
6    return user;
7  } catch (err) {
8    logger.error('getUser failed', { id, error: err.message });
9    throw err; // re-throw so caller knows
10  }
11}
12
13// Pattern 2: error wrapper - avoids repetitive try/catch
14const to = p => p.then(data => [null, data]).catch(err => [err, null]);
15
16async function handler(req, res) {
17  const [err, user] = await to(getUser(req.params.id));
18  if (err) return res.status(404).json({ error: err.message });
19  res.json(user);
20}
21
22// Pattern 3: Express async wrapper - catches async errors and forwards to error middleware
23const asyncHandler = fn => (req, res, next) =>
24  Promise.resolve(fn(req, res, next)).catch(next);
25
26app.get('/users/:id', asyncHandler(async (req, res) => {
27  const user = await getUser(req.params.id); // if throws, goes to error middleware
28  res.json(user);
29}));
30

1// Add at the very top of your app entry file
2process.on('unhandledRejection', (reason, promise) => {
3  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
4  // Log to Sentry/Datadog, then exit
5});
6
7process.on('uncaughtException', (err) => {
8  console.error('Uncaught Exception:', err);
9  process.exit(1); // MUST exit - state is unknown after this
10});
11
12// ─── Most common causes ──────────────────────────────────────────────────
13
14// 1. Missing await
15async function bad() { fetchData(); } // ✗ no await
16async function good() { await fetchData(); } // ✅
17
18// 2. .then() without .catch()
19somePromise.then(process);               // ✗
20somePromise.then(process).catch(logErr); // ✅
21
22// 3. async event handler - EventEmitter doesn't catch async errors
23emitter.on('data', async (chunk) => { await processChunk(chunk); });          // ✗
24emitter.on('data', (chunk) => processChunk(chunk).catch(err => emitter.emit('error', err))); // ✅
25

1// .env file - never commit to git (.gitignore it)
2// DATABASE_URL=postgres://user:pass@localhost:5432/mydb
3// JWT_SECRET=super-secret-key
4// PORT=3000
5// NODE_ENV=development
6
7require('dotenv').config(); // loads .env into process.env
8
9const port  = process.env.PORT || 3000;
10const dbUrl = process.env.DATABASE_URL;
11
12// ✅ Validate required vars at startup - fail fast with a clear message
13function validateEnv() {
14  const required = ['DATABASE_URL', 'JWT_SECRET'];
15  const missing  = required.filter(k => !process.env[k]);
16  if (missing.length) throw new Error(`Missing env vars: ${missing.join(', ')}`);
17}
18validateEnv(); // crash immediately if anything is missing
19
20// Use envalid for typed, validated env vars
21const { cleanEnv, str, port: portVal } = require('envalid');
22const env = cleanEnv(process.env, {
23  DATABASE_URL: str(),
24  PORT:         portVal({ default: 3000 }),
25  NODE_ENV:     str({ choices: ['development', 'test', 'production'] }),
26});
27

1const express = require('express');
2const app = express();
3
4// 1. Application-level - runs for every request
5app.use((req, res, next) => {
6  console.log(`${req.method} ${req.url}`);
7  next(); // MUST call next() or the request hangs forever
8});
9
10// 2. Built-in middleware
11app.use(express.json());            // parse JSON request bodies
12app.use(express.static('public'));  // serve static files
13
14// 3. Route-specific middleware
15const authenticate = (req, res, next) => {
16  const token = req.headers.authorization?.split(' ')[1];
17  if (!token) return res.status(401).json({ error: 'No token' });
18  try {
19    req.user = jwt.verify(token, process.env.JWT_SECRET);
20    next();
21  } catch { res.status(401).json({ error: 'Invalid token' }); }
22};
23
24app.get('/profile', authenticate, (req, res) => res.json(req.user));
25
26// 4. Error-handling middleware - 4 args, registered last
27app.use((err, req, res, next) => {
28  res.status(err.status || 500).json({ error: err.message });
29});
30
31// Flow: Request → logger → json parser → authenticate → route handler → Error handler → Response
32

1const { exec, spawn, fork } = require('child_process');
2
3// exec - simple shell command, buffered output
4exec('ls -la', (err, stdout) => {
5  if (err) return console.error(err);
6  console.log(stdout);
7});
8
9// spawn - streaming output (better for large output)
10const ls = spawn('ls', ['-la', '/tmp']);
11ls.stdout.on('data', data => process.stdout.write(data));
12ls.on('close', code => console.log(`Exited: ${code}`));
13
14// fork - another Node.js file with IPC messaging
15const child = fork('./worker.js');
16child.send({ task: 'compute', data: [1, 2, 3] });
17child.on('message', result => console.log('Result:', result));
18
19// worker.js
20process.on('message', ({ data }) => {
21  process.send({ result: data.reduce((a, b) => a + b, 0) });
22});
23

1const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');
2
3if (isMainThread) {
4  const worker = new Worker(__filename, { workerData: { n: 1_000_000 } });
5  worker.on('message', result => console.log('Sum:', result));
6  worker.on('error',   err    => console.error(err));
7  console.log('Main thread stays responsive while worker computes');
8} else {
9  // Worker thread - CPU-heavy work runs here without blocking the event loop
10  let sum = 0;
11  for (let i = 0; i < workerData.n; i++) sum += i;
12  parentPort.postMessage(sum);
13}
14// Without Workers, the for loop would block ALL incoming HTTP requests
15

1const cluster = require('cluster');
2const http    = require('http');
3const os      = require('os');
4
5if (cluster.isPrimary) {
6  console.log(`Primary ${process.pid} - forking ${os.cpus().length} workers`);
7  for (let i = 0; i < os.cpus().length; i++) cluster.fork();
8
9  cluster.on('exit', (worker) => {
10    console.log(`Worker ${worker.process.pid} died - restarting`);
11    cluster.fork(); // auto-restart crashed workers
12  });
13} else {
14  http.createServer((req, res) => {
15    res.end(`Handled by worker PID ${process.pid}`);
16  }).listen(3000);
17  console.log(`Worker ${process.pid} ready`);
18}
19// On an 8-core machine: 8 Node.js processes all on port 3000
20// OS distributes connections across them with round-robin
21

1// Detection - monitor heap size over time
2setInterval(() => {
3  const { heapUsed } = process.memoryUsage();
4  console.log(`Heap: ${(heapUsed / 1024 / 1024).toFixed(1)} MB`);
5}, 5000);
6
7// Take a heap snapshot for Chrome DevTools analysis
8const v8 = require('v8');
9const file = v8.writeHeapSnapshot();
10console.log('Heap snapshot:', file); // open in Chrome DevTools → Memory tab
11
12// Use clinic.js for automated profiling
13// $ npm i -g clinic
14// $ clinic doctor -- node app.js
15
16// ✗ Classic unbounded cache leak
17const cache = {};
18app.get('/data/:id', async (req, res) => {
19  if (!cache[req.params.id]) cache[req.params.id] = await fetchData(req.params.id);
20  res.json(cache[req.params.id]); // cache grows forever!
21});
22
23// ✅ LRU cache with eviction
24const { LRUCache } = require('lru-cache');
25const cache = new LRUCache({ max: 500, ttl: 5 * 60 * 1000 }); // 500 items, 5 min TTL
26

1// ✗ Blocking the event loop with heavy CPU work
2app.get('/fibonacci', (req, res) => {
3  const result = fibonacci(parseInt(req.query.n)); // freezes all other requests!
4  res.json({ result });
5});
6
7// ✅ Offload to Worker Thread
8const { Worker } = require('worker_threads');
9app.get('/fibonacci', (req, res) => {
10  const worker = new Worker('./fib-worker.js', { workerData: { n: parseInt(req.query.n) } });
11  worker.on('message', result => res.json({ result }));
12  worker.on('error',   err    => res.status(500).json({ error: err.message }));
13});
14
15// ✅ DB connection pool
16const { Pool } = require('pg');
17const pool = new Pool({ max: 20, idleTimeoutMillis: 30_000 });
18app.get('/users', async (req, res) => {
19  const { rows } = await pool.query('SELECT id, name FROM users LIMIT 50');
20  res.json(rows);
21});
22

1const helmet   = require('helmet');
2const rateLimit = require('express-rate-limit');
3const cors     = require('cors');
4const bcrypt   = require('bcrypt');
5
6app.use(helmet()); // sets 11 security headers in one line
7app.use(cors({ origin: ['https://myapp.com'] })); // whitelist only
8
9app.use(rateLimit({
10  windowMs: 15 * 60 * 1000, // 15 minutes
11  max: 100,                  // 100 requests per IP
12  message: 'Too many requests - slow down',
13}));
14
15// Centralised error handler - never expose stack traces in production
16app.use((err, req, res, next) => {
17  res.status(err.status || 500).json({
18    error: process.env.NODE_ENV === 'production' ? 'Internal Server Error' : err.message,
19  });
20});
21
22// Password hashing
23const hash  = await bcrypt.hash(plainPassword, 12);
24const valid = await bcrypt.compare(plainPassword, hash);
25

1let server;
2let isShuttingDown = false;
3
4// Reject new requests during shutdown
5app.use((req, res, next) => {
6  if (isShuttingDown) {
7    res.set('Connection', 'close');
8    return res.status(503).json({ error: 'Server shutting down' });
9  }
10  next();
11});
12
13server = app.listen(3000, () => console.log('Listening on 3000'));
14
15async function shutdown(signal) {
16  console.log(`${signal} received - graceful shutdown starting`);
17  isShuttingDown = true;
18
19  server.close(async () => {
20    try {
21      await db.pool.end();      // drain DB pool
22      await redis.quit();       // close Redis
23      await queue.close();      // drain message queue
24      console.log('Clean exit');
25      process.exit(0);
26    } catch (err) {
27      console.error(err);
28      process.exit(1);
29    }
30  });
31
32  // Force exit after 30s if drain takes too long
33  setTimeout(() => { console.error('Forced exit'); process.exit(1); }, 30_000);
34}
35
36process.on('SIGTERM', () => shutdown('SIGTERM')); // Kubernetes pod termination
37process.on('SIGINT',  () => shutdown('SIGINT'));  // Ctrl+C
38

1const { z } = require('zod');
2
3const createUserSchema = z.object({
4  name:  z.string().min(2).max(100),
5  email: z.string().email(),
6});
7
8// Versioned, validated, paginated route with consistent response shapes
9app.post('/api/v1/users', authenticate, async (req, res, next) => {
10  const parsed = createUserSchema.safeParse(req.body);
11  if (!parsed.success)
12    return res.status(400).json({ error: { code: 'VALIDATION_ERROR', details: parsed.error.errors } });
13
14  try {
15    const user = await userService.create(parsed.data);
16    res.status(201).json({ data: user });  // 201 for creation
17  } catch (err) { next(err); }
18});
19
20// Health check - checked by Kubernetes every 10s
21app.get('/health', async (req, res) => {
22  const db    = await pool.query('SELECT 1').then(() => true).catch(() => false);
23  const cache = await redis.ping().then(() => true).catch(() => false);
24  const ok    = db && cache;
25  res.status(ok ? 200 : 503).json({ status: ok ? 'ok' : 'degraded', checks: { db, cache } });
26});
27