Client 1 → Thread 1 (blocked while reading DB) → Wasted RAM
Client 2 → Thread 2 (blocked while reading DB) → Wasted RAM
Client 3 → Thread 3 (blocked while reading DB) → Wasted RAM
...

┌─────────────────────────────────────────────────────────────────┐
│                                                                    │
│   Traditional Server (Multi-Threaded Blocking)                     │
│                                                                    │
│   Request 1 → ┌─[Thread 1]─────────────┐                         │
│               │  Wait for DB... idle... │  ← Wasted CPU & RAM    │
│               └─────────────────────────┘                         │
│   Request 2 → ┌─[Thread 2]─────────────┐                         │
│               │  Wait for DB... idle... │  ← Wasted               │
│               └─────────────────────────┘                         │
│                                                                    │
│   ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─│
│                                                                    │
│   Node.js Server (Single-Threaded Non-Blocking)                    │
│                                                                    │
│   Request 1 → ┌─[Event Loop]──────────────────────┐              │
│               │  Start DB call → move on          │              │
│               │  Start DB call → move on          │  ← Efficient  │
│               │  DB done → callback → response    │              │
│               └────────────────────────────────────┘              │
│                                                                    │
└─────────────────────────────────────────────────────────────────┘

flowchart LR
    subgraph Clients["🌐 Clients"]
        Browser["Browser"]
        Mobile["Mobile App"]
        IoT["IoT Device"]
    end

    subgraph Server["🖥️ Node.js Server"]
        EL["Event Loop"]
        ThreadPool["Thread Pool\n(libuv)"]
        JS["JavaScript\n(V8 Engine)"]
    end

    subgraph Resources["📦 Resources"]
        DB["Database"]
        FS["File System"]
        API["External API"]
    end

    Browser -->|"HTTP Request"| EL
    Mobile -->|"HTTP Request"| EL
    IoT -->|"HTTP Request"| EL

    EL -->|"Execute JS"| JS
    EL -->|"Heavy I/O"| ThreadPool
    ThreadPool --> DB
    ThreadPool --> FS
    ThreadPool --> API

    JS -->|"Response"| Browser
    JS -->|"Response"| Mobile
    JS -->|"Response"| IoT

    style Clients fill:#4f46e5,color:#fff
    style Server fill:#7c3aed,color:#fff
    style Resources fill:#059669,color:#fff
    style EL fill:#f59e0b,color:#fff
    style ThreadPool fill:#10b981,color:#fff
    style JS fill:#ef4444,color:#fff

┌─────────────────────────────────────────────────────┐
│                  Your Node.js App                    │
│  (app.js, routes, controllers, services, models)    │
├─────────────────────────────────────────────────────┤
│           Node.js Built-in APIs (JS)                │
│  fs | http | path | crypto | os | stream | events   │
├─────────────────────────────────────────────────────┤
│                   V8 Engine (C++)                   │
│   Compiles JavaScript → Machine Code                │
│   Manages Memory (Heap + Stack)                     │
├─────────────────────────────────────────────────────┤
│                   libuv (C Library)                  │
│   Event Loop | Thread Pool | Async I/O | Timers     │
└─────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────┐
│               Operating System                       │
│         Windows / macOS / Linux                      │
└─────────────────────────────────────────────────────┘

sequenceDiagram
    participant Client as 🌐 Client
    participant EL as Event Loop
    participant V8 as V8 Engine
    participant libuv as libuv (C++)
    participant OS as Operating System

    Client->>EL: HTTP Request

    EL->>V8: Execute request handler JS
    V8->>EL: Async operation (e.g., readFile)

    EL->>libuv: Delegate to Thread Pool
    Note over libuv: Thread Pool handles<br/>the I/O operation

    EL->>V8: Continue with next task<br/>(non-blocking!)
    V8->>EL: Execute more JS
    EL->>V8: More callbacks...

    libuv->>EL: I/O complete! 🔔
    EL->>V8: Execute callback
    V8->>EL: Generate response

    EL->>Client: HTTP Response

flowchart TB
    subgraph JS_Layer["JavaScript Layer"]
        AppCode["Application Code\n(routes, middleware, services)"]
        NodeAPI["Node.js Standard Library\n(fs, http, path, crypto, os)"]
    end

    subgraph Cpp_Layer["C++ Layer (Bindings)"]
        Bindings["Node.js Bindings\n(Bridges JS ↔ C++)"]
    end

    subgraph Engine_Layer["Engine Layer"]
        V8["V8 JavaScript Engine\n(Compile + Execute + GC)"]
        libuv_arch["libuv\n(Event Loop + Thread Pool + Async I/O)"]
    end

    subgraph System["System Layer"]
        Kernel["OS Kernel\n(epoll / kqueue / IOCP)"]
        Hardware["Hardware\n(CPU / RAM / Disk / Network)"]
    end

    AppCode --> NodeAPI
    NodeAPI --> Bindings
    Bindings --> V8
    Bindings --> libuv_arch
    libuv_arch --> Kernel
    V8 --> Kernel
    Kernel --> Hardware

    style JS_Layer fill:#4f46e5,color:#fff
    style Cpp_Layer fill:#7c3aed,color:#fff
    style Engine_Layer fill:#059669,color:#fff
    style System fill:#dc2626,color:#fff
    style V8 fill:#f59e0b,color:#fff
    style libuv_arch fill:#10b981,color:#fff

flowchart TD
    Step1["1️⃣ Write code in app.js\nconsole.log('Hello Node!')"]
    Step2["2️⃣ Run: node app.js"]
    Step3["3️⃣ Node.js parses app.js"]
    Step4["4️⃣ V8 compiles JS to\nmachine code"]
    Step5["5️⃣ V8 executes the code"]
    Step6["6️⃣ console.log outputs\nto stdout (terminal)"]
    Step7["7️⃣ Process exits\n(event loop has nothing to do)"]

    Step1 --> Step2 --> Step3 --> Step4 --> Step5 --> Step6 --> Step7

    style Step1 fill:#4f46e5,color:#fff
    style Step2 fill:#6366f1,color:#fff
    style Step3 fill:#818cf8,color:#fff
    style Step4 fill:#7c3aed,color:#fff
    style Step5 fill:#059669,color:#fff
    style Step6 fill:#10b981,color:#fff
    style Step7 fill:#dc2626,color:#fff

// app.js — A basic HTTP server
const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello, Node.js!\n');
});

server.listen(3000, () => {
  console.log('Server running at http://localhost:3000/');
});

// Import the file system module
const fs = require('fs');    // CommonJS syntax
// import fs from 'fs';      // ES Module syntax

// Read a file synchronously (blocking)
const data = fs.readFileSync('notes.txt', 'utf-8');
console.log(data);            // Prints file contents
console.log('Done!');         // Runs AFTER file is read

// Read a file asynchronously (non-blocking)
fs.readFile('notes.txt', 'utf-8', (err, data) => {
  if (err) {
    console.error('Error reading file:', err.message);
    return;
  }
  console.log(data);          // Prints file contents
});
console.log('Done!');         // Runs IMMEDIATELY, BEFORE file is read

const http = require('http');

// Create a server with basic routing
const server = http.createServer((req, res) => {
  const { method, url } = req;

  // Parse the URL
  const [path, queryString] = url.split('?');

  // Set common headers
  res.setHeader('Content-Type', 'application/json');

  // Simple router
  if (method === 'GET' && path === '/') {
    res.writeHead(200);
    res.end(JSON.stringify({ message: 'Welcome to Node.js!' }));

  } else if (method === 'GET' && path === '/users') {
    const users = [
      { id: 1, name: 'Alice' },
      { id: 2, name: 'Bob' },
    ];
    res.writeHead(200);
    res.end(JSON.stringify(users));

  } else if (method === 'POST' && path === '/users') {
    let body = '';

    // Data comes in chunks
    req.on('data', (chunk) => {
      body += chunk.toString();
    });

    req.on('end', () => {
      const newUser = JSON.parse(body);
      console.log('Created user:', newUser);
      res.writeHead(201);
      res.end(JSON.stringify({ success: true, user: newUser }));
    });

  } else {
    // 404 handler
    res.writeHead(404);
    res.end(JSON.stringify({ error: 'Route not found' }));
  }
});

// Start the server
const PORT = 3000;
server.listen(PORT, () => {
  console.log(`🚀 Server listening on http://localhost:${PORT}`);
});

const http = require('http');
const fs = require('fs');
const path = require('path');

const PORT = 3000;
const PUBLIC_DIR = path.join(__dirname, 'public');

// Map file extensions to MIME types
const MIME_TYPES = {
  '.html': 'text/html',
  '.css':  'text/css',
  '.js':   'application/javascript',
  '.json': 'application/json',
  '.png':  'image/png',
  '.jpg':  'image/jpeg',
  '.svg':  'image/svg+xml',
  '.ico':  'image/x-icon',
};

const server = http.createServer((req, res) => {
  // Security: Prevent directory traversal attacks
  const sanitizedPath = path.normalize(req.url).replace(/^(\.\.[/\\])+/, '');

  // Resolve the file path
  const filePath = path.join(PUBLIC_DIR, sanitizedPath);

  // Get file extension for MIME type
  const ext = path.extname(filePath);
  const contentType = MIME_TYPES[ext] || 'application/octet-stream';

  // Read and serve the file
  fs.readFile(filePath, (err, data) => {
    if (err) {
      if (err.code === 'ENOENT') {
        // File not found → 404
        res.writeHead(404, { 'Content-Type': 'text/html' });
        res.end('<h1>404 - File Not Found</h1>');
      } else {
        // Server error → 500
        res.writeHead(500);
        res.end('500 Internal Server Error');
      }
      return;
    }

    // Success → serve the file
    res.writeHead(200, { 'Content-Type': contentType });
    res.end(data);
  });
});

server.listen(PORT, () => {
  console.log(`📁 Static server serving ${PUBLIC_DIR}`);
  console.log(`   http://localhost:${PORT}`);
});

// mini-express.js — A simplified Express.js core built with http module
class MiniExpress {
  constructor() {
    this.routes = [];
    this.middlewares = [];
  }

  use(fn) {
    this.middlewares.push(fn);
  }

  get(path, handler) {
    this.routes.push({ method: 'GET', path, handler });
  }

  post(path, handler) {
    this.routes.push({ method: 'POST', path, handler });
  }

  // Match routes using path-to-regexp style matching
  matchRoute(method, url) {
    for (const route of this.routes) {
      if (route.method !== method) continue;

      // Simple path matching (supports :params)
      const routeParts = route.path.split('/');
      const urlParts = url.split('/');

      if (routeParts.length !== urlParts.length) continue;

      const params = {};
      let matched = true;

      for (let i = 0; i < routeParts.length; i++) {
        if (routeParts[i].startsWith(':')) {
          params[routeParts[i].slice(1)] = urlParts[i];
        } else if (routeParts[i] !== urlParts[i]) {
          matched = false;
          break;
        }
      }

      if (matched) return { handler: route.handler, params };
    }
    return null;
  }

  handleRequest(req, res) {
    const { method, url } = req;

    // Enhanced response object
    res.json = (data) => {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify(data));
    };

    res.status = (code) => {
      res.statusCode = code;
      return res;
    };

    // Parse query string
    const urlObj = new URL(url, `http://${req.headers.host}`);
    req.query = Object.fromEntries(urlObj.searchParams);

    // Run middlewares
    let idx = 0;
    const next = () => {
      if (idx < this.middlewares.length) {
        this.middlewares[idx++](req, res, next);
      } else {
        this.finalHandler(req, res);
      }
    };
    next();
  }

  finalHandler(req, res) {
    const matched = this.matchRoute(req.method, req.url.split('?')[0]);

    if (matched) {
      req.params = matched.params;
      matched.handler(req, res);
    } else {
      res.status(404).json({ error: 'Not Found' });
    }
  }

  listen(port, callback) {
    const server = http.createServer((req, res) => this.handleRequest(req, res));
    server.listen(port, callback);
  }
}

// ─── USAGE ──────────────────────────────────────────
const app = new MiniExpress();

// Middleware: Logger
app.use((req, res, next) => {
  console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
  next();
});

// Middleware: JSON Body Parser
app.use((req, res, next) => {
  if (req.method === 'POST' || req.method === 'PUT') {
    let body = '';
    req.on('data', chunk => body += chunk);
    req.on('end', () => {
      try { req.body = JSON.parse(body); }
      catch { req.body = {}; }
      next();
    });
  } else {
    next();
  }
});

// Routes
app.get('/users/:id', (req, res) => {
  res.json({ userId: req.params.id, query: req.query });
});

app.post('/users', (req, res) => {
  res.status(201).json({ created: req.body });
});

app.listen(3000, () => console.log('🚀 MiniExpress running on :3000'));

node app.js
│
├─ 1. Initialize V8 Engine
├─ 2. Parse JavaScript → AST
├─ 3. Compile AST → Bytecode
├─ 4. Execute Bytecode
│     │
│     ├─ Sync operations → Execute immediately
│     ├─ Async operations → Delegate to libuv
│     │
│     └─ Error? → Throws exception or crashes
│
├─ 5. Enter Event Loop (if pending operations)
│     └─ Loop until nothing pending
│
└─ 6. Exit process

// ❌ MISTAKE 1: Not handling errors in async code
const fs = require('fs');
fs.readFile('missing.txt', 'utf-8', (err, data) => {
  // Missing error check! If file doesn't exist, data is undefined
  console.log(data.toUpperCase()); // 💥 TypeError: Cannot read property of undefined
});

// ✅ CORRECT: Always check for errors first
fs.readFile('missing.txt', 'utf-8', (err, data) => {
  if (err) {
    console.error('Failed to read file:', err.message);
    return;
  }
  console.log(data.toUpperCase());
});

// ❌ MISTAKE 2: Blocking the Event Loop
const http = require('http');
const server = http.createServer((req, res) => {
  // This takes 5 seconds and blocks ALL other requests!
  const end = Date.now() + 5000;
  while (Date.now() < end) {}  // Busy wait
  res.end('Done');
});

// ✅ CORRECT: Use async operations or offload to Worker Threads
const { Worker } = require('worker_threads');

// ❌ MISTAKE 3: Using fs.readFileSync inside request handler
app.get('/data', (req, res) => {
  const data = fs.readFileSync('big-file.json'); // ⛔ Blocks ALL users!
  res.json(JSON.parse(data));
});

// ✅ CORRECT: Use async version
app.get('/data', async (req, res) => {
  const data = await fs.promises.readFile('big-file.json', 'utf-8');
  res.json(JSON.parse(data));
});

// ❌ MISTAKE 4: Forgetting process exits if Event Loop is idle
node -e "console.log('Hello')"
// Prints "Hello" and then exits immediately

// If you want it to stay alive, keep something pending:
node -e "console.log('Hi'); setInterval(() => {}, 1000)"

// Expected output:
// GET /?name=Alice → "Hello, Alice!"
// GET /           → "Hello, World!"
// Use only the built-in 'http' module

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });

  if (req.url === '/data') {
    const data = fs.readFileSync('data.json');       // Bug 1: 'fs' not imported
    res.end(data);                                     // Bug 2: data is Buffer, need toString()
  }

  if (req.url === '/time') {
    setInterval(() => {                                // Bug 3: setInterval never clears
      res.end(new Date().toISOString());               // Bug 4: Can't res.end() twice
    }, 1000);
  }

  res.end(JSON.stringify({ error: 'Not found' }));    // Bug 5: Always runs this too!
});

server.listen(3000);

// ─── RUNNING NODE ────────────────────────────────────
node app.js               // Run file
node --watch app.js       // Auto-restart
node -e "console.log(1)"  // Run inline

// ─── BUILT-IN MODULES (most common) ─────────────────
const fs = require('fs');         // File system
const http = require('http');     // HTTP server/client
const path = require('path');     // File paths
const os = require('os');         // OS info
const crypto = require('crypto'); // Cryptography

// ─── BASIC HTTP SERVER ───────────────────────────────
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({ ok: true }));
});
server.listen(3000);

// ─── READING FILES ───────────────────────────────────
fs.readFile('file.txt', 'utf-8', (err, data) => {});
const data = await fs.promises.readFile('file.txt', 'utf-8');

// ─── GLOBAL OBJECTS ──────────────────────────────────
console.log(__dirname);  // Current directory path
console.log(__filename); // Current file path
console.log(process);    // Process information