Node.js Architecture Explained: Event Loop, Async Code, and Scaling

// Simplified event loop phases
┌───────────────────────────┐
│   ┌─────────────────────┐  │
│   │   Timers            │  │  // setTimeout, setInterval
│   └─────────────────────┘  │
│   ┌─────────────────────┐  │
│   │   Pending Callbacks │  │  // I/O callbacks
│   └─────────────────────┘  │
│   ┌─────────────────────┐  │
│   │   Idle, Prepare     │  │  // Internal use
│   └─────────────────────┘  │
│   ┌─────────────────────┐  │
│   │   Poll              │  │  // Fetch new I/O events
│   └─────────────────────┘  │
│   ┌─────────────────────┐  │
│   │   Check             │  │  // setImmediate callbacks
│   └─────────────────────┘  │
│   ┌─────────────────────┐  │
│   │   Close Callbacks   │  │  // socket.on('close')
│   └─────────────────────┘  │
└───────────────────────────┘

// Example: Understanding execution order
console.log('1');

setTimeout(() => console.log('2'), 0);

Promise.resolve().then(() => console.log('3'));

console.log('4');

// Output: 1, 4, 3, 2
// Why: 
// - Synchronous code runs first (1, 4)
// - Microtasks (Promises) run before macrotasks (setTimeout)
// - Event loop processes callbacks

// Traditional callback
fs.readFile('file.txt', (err, data) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log(data);
});

// Promise-based
fs.promises.readFile('file.txt')
  .then(data => console.log(data))
  .catch(err => console.error(err));

// Async/await
async function readFile() {
  try {
    const data = await fs.promises.readFile('file.txt');
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

myEmitter.on('event', (data) => {
  console.log('Event received:', data);
});

myEmitter.emit('event', 'Hello World');

// Node.js handles I/O asynchronously
const http = require('http');

// This doesn't block
http.get('http://example.com', (res) => {
  res.on('data', (chunk) => {
    console.log(chunk);
  });
});

// This continues immediately
console.log('Request sent, continuing...');

// For CPU-intensive operations
const { Worker, isMainThread, parentPort } = require('worker_threads');

if (isMainThread) {
  const worker = new Worker(__filename);
  worker.postMessage('Start calculation');
  worker.on('message', (result) => {
    console.log('Result:', result);
  });
} else {
  parentPort.on('message', (msg) => {
    // Heavy computation
    const result = performHeavyCalculation();
    parentPort.postMessage(result);
  });
}

const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
  const numWorkers = os.cpus().length;
  
  for (let i = 0; i < numWorkers; i++) {
    cluster.fork();
  }
  
  cluster.on('exit', (worker) => {
    console.log(`Worker ${worker.id} died`);
    cluster.fork(); // Restart worker
  });
} else {
  // Worker process
  require('./server.js');
}

// PM2 for process management
// pm2 start app.js -i max

// Or use nginx/HAProxy for load balancing

// Bad: Blocks event loop
function heavyComputation() {
  let result = 0;
  for (let i = 0; i < 10000000000; i++) {
    result += i;
  }
  return result;
}

// Good: Use worker threads or break into chunks
function asyncHeavyComputation() {
  return new Promise((resolve) => {
    setImmediate(() => {
      // Process in chunks
      resolve(computeChunk());
    });
  });
}

// Bad: Loads entire file into memory
const data = fs.readFileSync('large-file.txt');

// Good: Stream processing
const stream = fs.createReadStream('large-file.txt');
stream.on('data', (chunk) => {
  processChunk(chunk);
});

// Always handle errors in async operations
async function fetchData() {
  try {
    const data = await fetch('http://api.example.com');
    return data;
  } catch (error) {
    // Log and handle error
    console.error('Fetch failed:', error);
    throw error;
  }
}

// Database connection pooling
const pool = mysql.createPool({
  connectionLimit: 10,
  host: 'localhost',
  user: 'user',
  password: 'password',
  database: 'mydb'
});

// Use Redis for caching
const redis = require('redis');
const client = redis.createClient();

async function getCachedData(key) {
  const cached = await client.get(key);
  if (cached) return JSON.parse(cached);
  
  const data = await fetchData();
  await client.setex(key, 3600, JSON.stringify(data));
  return data;
}

// Enable gzip compression
const compression = require('compression');
app.use(compression());

// Bad: Nested callbacks
fs.readFile('file1.txt', (err, data1) => {
  fs.readFile('file2.txt', (err, data2) => {
    fs.readFile('file3.txt', (err, data3) => {
      // Deep nesting
    });
  });
});

// Good: Use async/await
async function readFiles() {
  const [data1, data2, data3] = await Promise.all([
    fs.promises.readFile('file1.txt'),
    fs.promises.readFile('file2.txt'),
    fs.promises.readFile('file3.txt')
  ]);
}

// Always handle promise rejections
process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled Rejection:', reason);
  // Log and handle
});