� Everything You Learned Still Applies!

🎯 What is Node.js?

Node.js is a JavaScript runtime built on Chrome's V8 engine. It allows you to run JavaScript outside the browser — on your computer, on a server, anywhere! This means JavaScript is no longer limited to making web pages interactive; you can now build:

💻 Live Example: JS Refresher Code Running in Node.js

Here's a comprehensive example showcasing that all the JavaScript you learned works perfectly in Node.js:

Copy// ✅ ALL of this JavaScript works the same in Node.js!

// 📦 Variables & Arrow Functions
const greet = (name) => `Hello, ${name}!`;
console.log(greet('Node.js')); // Hello, Node.js!

// 🎨 Template Literals
const version = 20;
console.log(`Running on Node.js v${version}`);

// 🔢 Arrays & Modern Methods (map, filter, reduce)
const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(n => n * 2);
const evens = numbers.filter(n => n % 2 === 0);
const sum = numbers.reduce((acc, n) => acc + n, 0);
console.log('Doubled:', doubled);  // [2, 4, 6, 8, 10]
console.log('Evens:', evens);      // [2, 4]
console.log('Sum:', sum);          // 15

// 📦 Objects & Destructuring
const user = {
  name: 'Alice',
  age: 25,
  skills: ['JavaScript', 'Node.js', 'React']
};
const { name, skills } = user;
console.log(`${name} knows: ${skills.join(', ')}`);

// 🔄 Spread Operator
const moreSkills = [...skills, 'Express', 'MongoDB'];
console.log('Updated skills:', moreSkills);

// ⚡ Promises & Async/Await
const fetchData = (delay = 1000) => {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({ message: 'Data loaded!', timestamp: Date.now() });
    }, delay);
  });
};

async function main() {
  console.log('Fetching data...');
  const data = await fetchData(500);
  console.log('✅', data.message);
  
  // 🎯 Multiple async operations
  const results = await Promise.all([
    fetchData(300),
    fetchData(200),
    fetchData(100)
  ]);
  console.log(`Loaded ${results.length} items`);
}

main().catch(err => console.error('Error:', err));

// 🏗️ Classes (ES6+)
class TodoList {
  constructor() {
    this.todos = [];
  }
  
  add(task) {
    this.todos.push({ task, done: false });
    return this;
  }
  
  complete(index) {
    if (this.todos[index]) {
      this.todos[index].done = true;
    }
    return this;
  }
  
  list() {
    return this.todos;
  }
}

const myTodos = new TodoList();
myTodos.add('Learn Node.js').add('Build an API').complete(0);
console.log('My todos:', myTodos.list());

// 🎯 Try/Catch Error Handling
try {
  const result = JSON.parse('{"valid": "json"}');
  console.log('Parsed:', result);
} catch (error) {
  console.error('Parse error:', error.message);
}

📥 Installation & Setup

1️⃣ Download Node.js

Go to nodejs.org and download the LTS (Long Term Support) version. This is the recommended, stable version for most users.

2️⃣ Verify Installation

After installation, open your terminal/command prompt and verify Node.js is installed:

Copy# Check Node.js version
node --version
# Output: v20.x.x (or similar)

# Check npm (Node Package Manager) version
npm --version
# Output: 10.x.x (or similar)

▶️ Running Node.js

🖥️ Node.js REPL (Interactive Console)

The REPL (Read-Eval-Print Loop) is an interactive JavaScript console where you can test code quickly. Just type node in your terminal:

Copy# Start the Node.js REPL
node

# Now you can run JavaScript:
> 2 + 2
4
> const name = "Node.js"
undefined
> console.log(`Hello, ${name}!`)
Hello, Node.js!
undefined
> .exit   // Exit the REPL (or press Ctrl+C twice)

📄 Executing a JavaScript File

This is where the magic happens! You can now run JavaScript files without a browser. Create a file called app.js:

Copy// app.js
console.log('Hello from Node.js!');
console.log('JavaScript running outside the browser! 🚀');

const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((acc, n) => acc + n, 0);
console.log(`Sum: ${sum}`);

Run it with Node.js:

Copynode app.js

Output:

# Hello from Node.js!
# JavaScript running outside the browser! 🚀
# Sum: 15

📦 Module System

🧩 What is a Module?

In Node.js, every JavaScript file is a module. A module is simply a reusable piece of code that you can import into other files. This keeps your code organized and maintainable.

🔄 Modular Programming: Two Ways

Node.js supports two module systems:

📤 CommonJS: require() & module.exports

Step 1: Create a module file (math.js)

Copy// math.js
const add = (a, b) => a + b;
const subtract = (a, b) => a - b;
const multiply = (a, b) => a * b;

// Export functions so other files can use them
module.exports = {
  add,
  subtract,
  multiply
};

// Or export individually:
// module.exports.add = add;
// module.exports.subtract = subtract;

Step 2: Import and use the module (app.js)

Copy// app.js
const math = require('./math.js'); // ./ means "in the same directory"

console.log(math.add(5, 3));       // 8
console.log(math.subtract(10, 4)); // 6
console.log(math.multiply(3, 7));  // 21

// Or use destructuring:
const { add, multiply } = require('./math.js');
console.log(add(2, 2));      // 4
console.log(multiply(5, 5)); // 25

// counter.js
console.log('⚡ Counter module loaded!');

let count = 0;

module.exports = {
  increment: () => ++count,
  getCount: () => count
};

// app.js
const counter1 = require('./counter.js'); // Logs: "⚡ Counter module loaded!"
const counter2 = require('./counter.js'); // Nothing logged! (cached)
const counter3 = require('./counter.js'); // Nothing logged! (cached)

counter1.increment(); // count = 1
counter2.increment(); // count = 2 (same instance!)
counter3.increment(); // count = 3 (same instance!)

console.log(counter1.getCount()); // 3
console.log(counter2.getCount()); // 3
console.log(counter3.getCount()); // 3

// All three variables point to the SAME module instance!

// Your code in math.js:
const add = (a, b) => a + b;
module.exports = { add };

// What Node.js actually runs:
(function(exports, require, module, __filename, __dirname) {
  const add = (a, b) => a + b;
  module.exports = { add };
});

// See all cached modules
console.log(require.cache);

// Clear cache for a specific module (rarely needed!)
delete require.cache[require.resolve('./math.js')];

// Now the next require() will execute the file again
const math = require('./math.js');

✨ ES Modules: import & export

Step 1: Create a module file (math.js)

Copy// math.js
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;
export const multiply = (a, b) => a * b;

// Or export default:
export default {
  add,
  subtract,
  multiply
};

Step 2: Import and use the module (app.js)

Copy// app.js
import { add, multiply } from './math.js';

console.log(add(5, 3));      // 8
console.log(multiply(3, 7)); // 21

// Or import everything:
import * as math from './math.js';
console.log(math.add(2, 2)); // 4

// Or import default export:
import mathFunctions from './math.js';
console.log(mathFunctions.add(10, 5)); // 15

️✅ Valid: Imports must be at the top level
import { add } from './math.js';

// ❌ Invalid: Can't import conditionally (parse-time, not runtime!)
if (condition) {
  import { add } from './math.js'; // SyntaxError!
}

// ❌ Invalid: Can't import in functions
function doSomething() {
  import { add } from './math.js'; // SyntaxError!
}

// ✅ Valid: Use dynamic import() for conditional loading
if (condition) {
  const { add } = await import('./math.js'); // Works!
}

// counter.js
console.log('⚡ Counter module loaded!');

let count = 0;

export const increment = () => ++count;
export const getCount = () => count;

// app.js
import { increment as inc1, getCount as get1 } from './counter.js'; // Logs: "⚡"
import { increment as inc2, getCount as get2 } from './counter.js'; // Nothing!
import { increment as inc3, getCount as get3 } from './counter.js'; // Nothing!

inc1(); // count = 1
inc2(); // count = 2 (same instance!)
inc3(); // count = 3 (same instance!)

console.log(get1()); // 3
console.log(get2()); // 3
console.log(get3()); // 3

// counter.js
export let count = 0;

export function increment() {
  count++;
}

export function getCount() {
  return count;
}

// app.js
import { count, increment } from './counter.js';

console.log(count);  // 0

increment();
console.log(count);  // 1 (updated automatically! 🪄)

increment();
console.log(count);  // 2 (live binding in action!)

// Load module conditionally
if (userWantsAdvancedFeatures) {
  const advanced = await import('./advanced-features.js');
  advanced.doSomething();
}

// Load multiple modules dynamically
const modules = await Promise.all([
  import('./module1.js'),
  import('./module2.js'),
  import('./module3.js')
]);

// Lazy load heavy libraries
button.addEventListener('click', async () => {
  const { chart } = await import('./heavy-chart-library.js');
  chart.render();
});

📘 Node.js Built-in Modules

Node.js comes with many powerful built-in modules that you can use without installing anything. Let's explore some essential ones!

💻 os Module (Operating System)

Get information about your computer's operating system:

Copyconst os = require('os');

// System information
console.log('Platform:', os.platform());      // 'darwin', 'win32', 'linux'
console.log('Architecture:', os.arch());      // 'x64', 'arm64'
console.log('CPU Cores:', os.cpus().length);  // Number of CPU cores
console.log('Total Memory:', os.totalmem() / (1024**3), 'GB');
console.log('Free Memory:', os.freemem() / (1024**3), 'GB');
console.log('Home Directory:', os.homedir()); // User's home directory
console.log('Uptime:', os.uptime() / 3600, 'hours'); // System uptime

⌨️ readline/promises Module (User Input)

Read user input from the command line with simple async/await syntax:

Copyconst readline = require('readline/promises');

// Create interface for reading input
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

// Simple async function to get user info
async function getUserInfo() {
  const name = await rl.question('What is your name? ');
  const age = await rl.question('How old are you? ');
  
  console.log(`\nHello, ${name}! You are ${age} years old.`);
  
  rl.close();
}

getUserInfo();

📁 fs Module (File System)

The fs module lets you work with files and directories. It comes in three flavors:

📖 Reading Files (with fs/promises)

Copyconst fs = require('fs/promises');

async function readFile() {
  try {
    // Read entire file as string
    const data = await fs.readFile('example.txt', 'utf8');
    console.log('File contents:');
    console.log(data);
  } catch (error) {
    console.error('Error reading file:', error.message);
  }
}

readFile();

✍️ Writing Files (with fs/promises)

Copyconst fs = require('fs/promises');

async function writeFile() {
  try {
    const content = 'Hello from Node.js!\nThis is a new file.';
    
    // Write to file (creates file if it doesn't exist, overwrites if it does)
    await fs.writeFile('output.txt', content, 'utf8');
    console.log('File written successfully!');
    
    // Append to file (adds to the end)
    await fs.appendFile('output.txt', '\nAppended line!', 'utf8');
    console.log('Content appended!');
  } catch (error) {
    console.error('Error writing file:', error.message);
  }
}

writeFile();

📂 Working with Directories

Copyconst fs = require('fs/promises');

async function workWithDirectories() {
  try {
    // Create a directory
    await fs.mkdir('myFolder', { recursive: true }); // recursive: true won't error if exists
    console.log('Directory created!');
    
    // List files in a directory
    const files = await fs.readdir('.');
    console.log('Files in current directory:', files);
    
    // Check if file/directory exists
    try {
      await fs.access('myFolder');
      console.log('myFolder exists!');
    } catch {
      console.log('myFolder does not exist');
    }
    
    // Delete a file
    await fs.unlink('fileToDelete.txt');
    
    // Delete an empty directory
    await fs.rmdir('myFolder');
    
  } catch (error) {
    console.error('Error:', error.message);
  }
}

workWithDirectories();

🔥 Complete File System Example

Copyconst fs = require('fs/promises');
const os = require('os');

async function fileSystemDemo() {
  try {
    console.log('=== File System Demo ===\n');
    
    // 1. Write data to a file
    const userData = {
      name: 'John Doe',
      age: 30,
      platform: os.platform()
    };
    
    await fs.writeFile('user.json', JSON.stringify(userData, null, 2), 'utf8');
    console.log('✓ Created user.json');
    
    // 2. Read the file back
    const fileContent = await fs.readFile('user.json', 'utf8');
    const parsedData = JSON.parse(fileContent);
    console.log('✓ Read user data:', parsedData);
    
    // 3. Create a logs directory
    await fs.mkdir('logs', { recursive: true });
    console.log('✓ Created logs directory');
    
    // 4. Write a log file
    const logMessage = `[${new Date().toISOString()}] User data accessed\n`;
    await fs.appendFile('logs/app.log', logMessage, 'utf8');
    console.log('✓ Logged activity');
    
    // 5. List all files in current directory
    const files = await fs.readdir('.');
    console.log('✓ Files in current directory:', files);
    
  } catch (error) {
    console.error('❌ Error:', error.message);
  }
}

fileSystemDemo();

🌐 Building HTTP Servers

📡 The http Module

Node.js comes with a built-in http module that allows you to create web servers. A server listens for incoming HTTP requests and sends back responses. This is the foundation of all web applications!

🏗️ Creating Your First Server

Let's build a simple HTTP server step by step:

Copyconst http = require('http');

// Create a server
const server = http.createServer((req, res) => {
  // This callback runs for EVERY incoming request
  console.log('New request received!');
  
  // Set response headers
  res.statusCode = 200; // 200 = OK
  res.setHeader('Content-Type', 'text/plain');
  
  // Send response
  res.end('Hello from Node.js server!');
});

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

// Now open your browser and go to: http://localhost:3000

🔍 Understanding the Server Components

const server = http.createServer((req, res) => {
  console.log('Method:', req.method);
  console.log('URL:', req.url);
  console.log('HTTP Version:', req.httpVersion);
  console.log('User Agent:', req.headers['user-agent']);
  console.log('Client IP:', req.socket.remoteAddress);
  
  res.end('Request logged!');
});

const server = http.createServer((req, res) => {
  // Set status code
  res.statusCode = 200;
  
  // Set multiple headers
  res.setHeader('Content-Type', 'application/json');
  res.setHeader('X-Custom-Header', 'MyValue');
  
  // Alternative: use writeHead
  // res.writeHead(200, {
  //   'Content-Type': 'application/json',
  //   'X-Custom-Header': 'MyValue'
  // });
  
  // Write body in chunks (optional)
  res.write('{"message": "');
  res.write('Hello');
  res.write('"}');
  
  // Finish response
  res.end();
  
  // Or do it all in one:
  // res.end(JSON.stringify({ message: 'Hello' }));
});

📦 Reading Request Body (POST Data)

Reading the request body is more complex because Node.js streams data in chunks. This is efficient for large data but requires careful handling:

Copyconst http = require('http');

const server = http.createServer((req, res) => {
  if (req.method === 'POST') {
    let body = '';
    
    // Listen for 'data' event - fires when a chunk arrives
    req.on('data', (chunk) => {
      body += chunk.toString(); // Simply concatenate strings!
    });
    
    // Listen for 'end' event - fires when all chunks received
    req.on('end', () => {
      console.log('Complete body:', body);
      
      // Parse JSON if needed
      try {
        const data = JSON.parse(body);
        console.log('Parsed data:', data);
        
        res.statusCode = 200;
        res.setHeader('Content-Type', 'application/json');
        res.end(JSON.stringify({ 
          message: 'Data received!', 
          received: data 
        }));
      } catch (error) {
        res.statusCode = 400;
        res.end('Invalid JSON');
      }
    });
    
  } else {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/plain');
    res.end('Send a POST request with JSON data');
  }
});

server.listen(3000, () => {
  console.log('Server listening on port 3000');
});

# Test with cURL
curl -X POST http://localhost:3000 \
  -H "Content-Type: application/json" \
  -d '{"name":"John","age":30}'

🔄 Understanding the Chunk Process

📤 Sending Responses

The res object is used to send data back to the client:

Copyconst http = require('http');

const server = http.createServer((req, res) => {
  // 1. Set status code
  res.statusCode = 200; // 200 = OK, 404 = Not Found, 500 = Server Error
  
  // 2. Set headers (metadata about the response)
  res.setHeader('Content-Type', 'application/json');
  res.setHeader('X-Custom-Header', 'My Value');
  
  // 3. Send the response body and close connection
  const data = {
    message: 'Hello!',
    timestamp: new Date().toISOString()
  };
  res.end(JSON.stringify(data));
  
  // Note: res.end() MUST be called to complete the response!
});

server.listen(3000);

🛣️ Manual Routing with if/else

Before frameworks like Express (third-party module), routing was done manually with if/else statements. This is important to understand because it shows how routing really works:

Copyconst http = require('http');

const server = http.createServer((req, res) => {
  const { method, url } = req;
  
  // Home page
  if (url === '/' && method === 'GET') {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/html');
    res.end('
Welcome to my server!
About
');
  }
  
  // About page
  else if (url === '/about' && method === 'GET') {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/html');
    res.end('
About
This is a Node.js server
');
  }
  
  // API endpoint - Get users
  else if (url === '/api/users' && method === 'GET') {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'application/json');
    const users = [
      { id: 1, name: 'Alice' },
      { id: 2, name: 'Bob' }
    ];
    res.end(JSON.stringify(users));
  }
  
  // API endpoint - Create user
  else if (url === '/api/users' && method === 'POST') {
    let body = [];
    
    req.on('data', (chunk) => {
      body.push(chunk);
    });
    
    req.on('end', () => {
      const userData = JSON.parse(Buffer.concat(body).toString());
      
      res.statusCode = 201; // 201 = Created
      res.setHeader('Content-Type', 'application/json');
      res.end(JSON.stringify({ 
        message: 'User created!', 
        user: userData 
      }));
    });
  }
  
  // 404 - Not Found
  else {
    res.statusCode = 404;
    res.setHeader('Content-Type', 'text/html');
    res.end('
404 - Page Not Found
');
  }
});

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

🎯 Complete Server Example

Here's a complete server with all concepts combined:

Copyconst http = require('http');

// In-memory data store (normally you'd use a database)
const todos = [
  { id: 1, task: 'Learn Node.js', completed: false },
  { id: 2, task: 'Build a server', completed: true }
];

const server = http.createServer((req, res) => {
  const { method, url } = req;
  
  // Set CORS headers (allow requests from browsers)
  res.setHeader('Access-Control-Allow-Origin', '*');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
  
  // GET /api/todos - List all todos
  if (url === '/api/todos' && method === 'GET') {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'application/json');
    res.end(JSON.stringify({ todos }));
  }
  
  // POST /api/todos - Create a new todo
  else if (url === '/api/todos' && method === 'POST') {
    let body = [];
    
    req.on('data', (chunk) => body.push(chunk));
    
    req.on('end', () => {
      try {
        const data = JSON.parse(Buffer.concat(body).toString());
        const newTodo = {
          id: todos.length + 1,
          task: data.task,
          completed: false
        };
        todos.push(newTodo);
        
        res.statusCode = 201;
        res.setHeader('Content-Type', 'application/json');
        res.end(JSON.stringify({ message: 'Created!', todo: newTodo }));
      } catch (error) {
        res.statusCode = 400;
        res.end(JSON.stringify({ error: 'Invalid JSON' }));
      }
    });
  }
  
  // DELETE /api/todos/:id - Delete a todo
  else if (url.startsWith('/api/todos/') && method === 'DELETE') {
    const id = parseInt(url.split('/')[3]);
    const index = todos.findIndex(t => t.id === id);
    
    if (index !== -1) {
      todos.splice(index, 1);
      res.statusCode = 200;
      res.end(JSON.stringify({ message: 'Deleted!' }));
    } else {
      res.statusCode = 404;
      res.end(JSON.stringify({ error: 'Todo not found' }));
    }
  }
  
  // 404
  else {
    res.statusCode = 404;
    res.setHeader('Content-Type', 'application/json');
    res.end(JSON.stringify({ error: 'Endpoint not found' }));
  }
});

const PORT = 3000;
server.listen(PORT, () => {
  console.log(`🚀 Todo API running at http://localhost:${PORT}`);
  console.log('Endpoints:');
  console.log('  GET    /api/todos      - List all todos');
  console.log('  POST   /api/todos      - Create a todo');
  console.log('  DELETE /api/todos/:id  - Delete a todo');
});

// ❌ This gets messy FAST!
if (url === '/index.html') { /* read index.html */ }
else if (url === '/about.html') { /* read about.html */ }
else if (url === '/styles/main.css') { /* read main.css */ }
else if (url === '/js/script.js') { /* read script.js */ }
// ... hundreds of files? 😱

Copyconst http = require('http');
const fs = require('fs/promises'); // Using fs/promises directly

// Public folder
const PUBLIC_FOLDER = 'public';

const server = http.createServer(async (req, res) => {
    // Clean the URL (remove query strings)
    let filePath = req.url.split('?')[0];
    
    // Default to index.html if requesting root
    if (filePath === '/') 
        filePath = '/index.html';
    
    // Build full path
    let fullPath = PUBLIC_FOLDER + filePath;

    // Try to read and serve the file
    try {
        const content = await fs.readFile(fullPath);
        
        // Send response
        res.statusCode = 200;
        res.end(content);
    }
    // If file doesn't exist or can't be read
    catch (e) {
        console.log(e)
        res.statusCode = 404
        res.end("not found")
    }
});

const PORT = 3000;
server.listen(PORT, () => {
    console.log(`📁 Static file server running at http://localhost:${PORT}/`);
});

📦 npm & External Modules

So far, we've used Node.js built-in modules (like http, fs, os). But one of Node.js's superpowers is npm — the world's largest software registry with over 2 million packages! These are third-party/external modules created by developers worldwide.

🎬 Initializing a Project: npm init

Before installing packages, you need to initialize your project. This creates a package.json file — the heart of every Node.js project.

Copy# Initialize a new project (interactive)
npm init

# Quick init with defaults
npm init -y

# This creates package.json with your project metadata

📄 Understanding package.json

package.json is a JSON file that contains metadata about your project and lists all dependencies:

Copy{
  "name": "my-node-project",
  "version": "1.0.0",
  "description": "My awesome Node.js project",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": ["nodejs", "api"],
  "author": "Your Name",
  "license": "MIT",
  "dependencies": {
    "express": "^4.18.2"
  },
  "devDependencies": {
    "nodemon": "^3.0.1"
  }
}

📥 Installing Packages: npm install

Copy# Install a package and add to dependencies
npm install express
# or shorthand:
npm i express

# Install multiple packages
npm install express mongoose dotenv

# Install as a dev dependency (only for development)
npm install --save-dev nodemon
# or shorthand:
npm i -D nodemon

# Install all dependencies from package.json
npm install

# Install a specific version
npm install express@4.17.1

# Install globally (available everywhere on your system)
npm install -g nodemon

📦 What Happens When You Install?

Three things are created/updated:

# .gitignore
node_modules/
.env

🎯 npm Scripts

The scripts field in package.json lets you define custom commands. This is incredibly useful for common tasks!

Copy// package.json
{
  "scripts": {
    "start": "node server.js",
    "test": "jest",
    "build": "webpack"
  }
}

Run scripts with npm run:

Copy# Special script - can omit "run"
npm start
# Same as: node server.js

# Other scripts require "run"
npm run test
# Same as: jest

npm run build
# Same as: webpack

🔍 Useful npm Commands

npm list
npm list --depth=0

npm outdated

npm update
npm update express

npm uninstall express
npm uninstall -D nodemon

npm view express
npm info express

npm search mongodb
npm search testing

npm cache clean --force
npm cache verify

npm install express@4.18.0
npm install lodash@latest

📚 Popular npm Packages You Should Know

nodemon

📥 Installation

Install nodemon as a dev dependency in your project (you don't need it in production):

Copy# Install as dev dependency
npm install --save-dev nodemon

# or shorthand:
npm i -D nodemon

🚀 Usage with npm Scripts

Since we learned about npm scripts earlier, let's add a dev script to package.json:

Copy// package.json
{
  "scripts": {
    "start": "node server.js",      // For production
    "dev": "nodemon server.js"      // For development with auto-restart
  },
  "devDependencies": {
    "nodemon": "^3.0.1"
  }
}

Now run your development server with:

Copy# Start with auto-restart
npm run dev

# Output:
# [nodemon] 3.0.1
# [nodemon] to restart at any time, enter `rs`
# [nodemon] watching path(s): *.*
# [nodemon] watching extensions: js,mjs,json
# [nodemon] starting `node server.js`
# Server running on http://localhost:3000

Now when you save changes to your code, nodemon automatically restarts the server! 🎉

⚡ Visual Comparison

⚙️ npm Scripts Configuration

As you can see, using npm scripts makes it easy to run nodemon. You don't need to remember the exact commands - just use npm run dev!

🛠️ Advanced Configuration: nodemon.json

Create a nodemon.json file in your project root for advanced settings:

Copy// nodemon.json
{
  "watch": ["src"],                    // Only watch specific folders
  "ext": "js,json,html",               // Watch specific file types
  "ignore": ["test/*", "docs/*"],      // Ignore certain files/folders
  "delay": "1000",                     // Wait 1 second before restarting
  "env": {
    "NODE_ENV": "development",         // Set environment variables
    "PORT": "3000"
  }
}

🔐 Environment Variables

🤔 What Are Environment Variables?

Environment variables are key-value pairs stored in your operating system that your application can read at runtime. They're essential for storing configuration and secrets that change between environments (development, staging, production).

🔑 Accessing Environment Variables: process.env

Node.js provides the process.env object to access environment variables:

Copy// Access environment variables
console.log(process.env.NODE_ENV);      // 'development', 'production', etc.
console.log(process.env.PORT);          // '3000'
console.log(process.env.DATABASE_URL);  // Database connection string
console.log(process.env.API_KEY);       // Secret API key

// Provide default values
const PORT = process.env.PORT || 3000;
const NODE_ENV = process.env.NODE_ENV || 'development';

// Use in your code
const server = app.listen(PORT, () => {
  console.log(`Server running on port ${PORT} in ${NODE_ENV} mode`);
});

⚙️ Setting Environment Variables

# Linux/Mac
PORT=3000 NODE_ENV=production node app.js

# Windows (Command Prompt)
set PORT=3000 && node app.js

# Windows (PowerShell)
$env:PORT=3000; node app.js

# .env file
PORT=3000
NODE_ENV=development
DATABASE_URL=mongodb://localhost:27017/myapp
API_KEY=your_secret_api_key_here
JWT_SECRET=super_secret_token_key
STRIPE_SECRET_KEY=sk_test_xyz123

// package.json
{
  "scripts": {
    "start": "NODE_ENV=production node server.js",
    "dev": "NODE_ENV=development nodemon server.js"
  }
}

📦 Using the dotenv Package

The dotenv package automatically loads variables from your .env file into process.env. It's the industry standard!

1️⃣ Install dotenv:

Copynpm install dotenv

2️⃣ Create a .env file:

Copy# .env
PORT=3000
DATABASE_URL=mongodb://localhost:27017/myapp
API_KEY=abc123xyz456
NODE_ENV=development

3️⃣ Load in your application:

Copy// Load dotenv at the very top of your main file
require('dotenv').config();

// Now you can access environment variables
const PORT = process.env.PORT || 3000;
const DATABASE_URL = process.env.DATABASE_URL;
const API_KEY = process.env.API_KEY;

console.log('Starting server on port:', PORT);
console.log('Database:', DATABASE_URL);
// Never log API keys in production!

Copy// server.js
require('dotenv').config(); // Load .env file first!

const express = require('express');
const app = express();

// Use environment variables
const PORT = process.env.PORT || 3000;
const NODE_ENV = process.env.NODE_ENV || 'development';
const DATABASE_URL = process.env.DATABASE_URL;
const API_KEY = process.env.API_KEY;

// Example: Different behavior per environment
if (NODE_ENV === 'development') {
  // Detailed logging in development
  app.use((req, res, next) => {
    console.log(`${req.method} ${req.url}`);
    next();
  });
}

// Use API_KEY for external services
app.get('/weather', async (req, res) => {
  const response = await fetch(
    `https://api.weather.com/data?key=${API_KEY}`
  );
  const data = await response.json();
  res.json(data);
});

app.listen(PORT, () => {
  console.log(`✅ Server running on port ${PORT}`);
  console.log(`📊 Environment: ${NODE_ENV}`);
  console.log(`🗄️  Database: ${DATABASE_URL}`);
});

# .gitignore
.env
.env.local
.env.*.local
node_modules/

# .env.example (safe to commit)
PORT=3000
DATABASE_URL=your_database_url_here
API_KEY=your_api_key_here
NODE_ENV=development

Express Framework

📥 Installation

Copy# Install Express
npm install express

# Your package.json will have:
# "dependencies": {
#   "express": "^4.18.2"
# }

🚀 Your First Express Server

Compare how much simpler Express is compared to the raw http module:

const http = require('http');

const server = http.createServer((req, res) => {
  if (req.url === '/' && req.method === 'GET') {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('Hello World');
  } else {
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('Not Found');
  }
});

server.listen(3000, () => {
  console.log('Server running on port 3000');
});

Copyconst express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Hello World');
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

🛤️ Routing

Express makes defining routes incredibly simple. Each HTTP method has its own function:

Copyconst express = require('express');
const app = express();

// GET request
app.get('/users', (req, res) => {
  res.send('Get all users');
});

// POST request
app.post('/users', (req, res) => {
  res.send('Create a user');
});

// PUT request
app.put('/users/:id', (req, res) => {
  res.send(`Update user ${req.params.id}`);
});

// DELETE request
app.delete('/users/:id', (req, res) => {
  res.send(`Delete user ${req.params.id}`);
});

app.listen(3000);

📌 Route Parameters

Extract dynamic values from the URL using :paramName:

Copy// Route with parameters
app.get('/users/:id', (req, res) => {
  const userId = req.params.id;
  res.send(`User ID: ${userId}`);
});

// Multiple parameters
app.get('/users/:userId/posts/:postId', (req, res) => {
  const { userId, postId } = req.params;
  res.json({ userId, postId });
});

// Example: GET /users/123/posts/456
// Response: { "userId": "123", "postId": "456" }

🔍 Query Parameters

Access query strings with req.query:

Copyapp.get('/search', (req, res) => {
  const { q, page, limit } = req.query;
  res.json({ 
    query: q, 
    page: page || 1, 
    limit: limit || 10 
  });
});

// Example: GET /search?q=nodejs&page=2&limit=20
// Response: { "query": "nodejs", "page": "2", "limit": "20" }

🔧 Middleware

Middleware functions are executed before your route handlers. They can modify the request/response or terminate the request-response cycle.

Copyconst express = require('express');
const app = express();

// Custom logging middleware
app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`);
  next(); // Pass control to the next middleware/route
});

// Custom auth middleware (example)
const checkAuth = (req, res, next) => {
  const token = req.headers['authorization'];
  if (token === 'secret-token') {
    next(); // Authorized, continue
  } else {
    res.status(401).json({ error: 'Unauthorized' });
  }
};

// Apply middleware to specific route
app.get('/protected', checkAuth, (req, res) => {
  res.send('This is protected!');
});

app.listen(3000);

📦 Body Parsing with express.json()

To read JSON data from POST/PUT requests, use the built-in express.json() middleware:

Copyconst express = require('express');
const app = express();

// Enable JSON body parsing
app.use(express.json());

app.post('/users', (req, res) => {
  const userData = req.body; // Access the JSON body
  console.log('Received:', userData);
  
  res.status(201).json({
    message: 'User created',
    user: userData
  });
});

// Example request:
// POST /users
// Body: { "name": "Alice", "email": "alice@example.com" }
// Response: { "message": "User created", "user": { "name": "Alice", ... } }

📝 Parsing Text with express.text()

If you need to read plain text (not JSON) from the request body, use express.text():

Copyconst express = require('express');
const app = express();

// Parse text/plain bodies
app.use(express.text());

app.post('/message', (req, res) => {
  console.log('Received text:', req.body);
  // req.body is a string (not an object!)
  
  res.send(`You sent: ${req.body}`);
});

// Example request:
// POST /message
// Content-Type: text/plain
// Body: "Hello, this is plain text!"
// Response: "You sent: Hello, this is plain text!"

app.listen(3000);

🔗 Understanding Middleware: The Request Pipeline

Middleware is one of Express's most powerful features. Think of it as a queue of filters that every request passes through before reaching your route handler.

app.use((req, res, next) => {
  console.log('Request received');
  next(); // ✅ Passes control!
});

app.use((req, res, next) => {
  console.log('Request received');
  // ❌ No next()! Request hangs!
});

🛠️ Middleware Examples

const express = require('express');
const app = express();

// Custom logger middleware
app.use((req, res, next) => {
  const timestamp = new Date().toISOString();
  console.log(`[${timestamp}] ${req.method} ${req.url}`);
  next(); // ✅ Pass to next middleware
});

// This runs for EVERY request!
app.get('/users', (req, res) => {
  res.send('Users list');
});

// Authentication middleware
function requireAuth(req, res, next) {
  const token = req.headers.authorization;
  
  if (!token) {
    // ❌ No token - block request!
    return res.status(401).json({ 
      error: 'Unauthorized' 
    });
  }
  
  // ✅ Token exists - allow request
  req.user = { id: 123, name: 'Alice' };
  next();
}

// Protected route
app.get('/dashboard', requireAuth, (req, res) => {
  res.json({ 
    message: 'Welcome!',
    user: req.user // Added by middleware!
  });
});

app.use((req, res, next) => {
  const start = Date.now();
  
  // When response finishes
  res.on('finish', () => {
    const duration = Date.now() - start;
    console.log(`${req.method} ${req.url} - ${duration}ms`);
  });
  
  next();
});

// Error handler (must have 4 params!)
app.use((err, req, res, next) => {
  console.error('Error:', err.message);
  res.status(500).json({ 
    error: err.message 
  });
});

// Trigger error in route
app.get('/error', (req, res, next) => {
  const error = new Error('Something went wrong!');
  next(error); // Pass error to error handler
});

🎨 Types of Middleware

app.use(express.json());
app.use(logger);
app.use(cors());

const router = express.Router();
router.use(auth);
router.get('/admin', handler);

app.get('/admin', auth, (req, res) => {
  res.send('Admin page');
});

express.json()      // ← Parse JSON bodies
express.text()      // ← Parse text bodies
express.urlencoded()// ← Parse form data
express.static()    // ← Serve static files

const cors = require('cors');
const helmet = require('helmet');
app.use(cors());
app.use(helmet());

app.use((err, req, res, next) => {
  res.status(500).json({error: err.message});
});

📦 Built-in Middleware Deep Dive

Copyconst express = require('express');
const app = express();

app.use(express.json()); // Enable JSON parsing

app.post('/api/users', (req, res) => {
  // req.body is automatically parsed!
  console.log(req.body); // { name: 'Alice', age: 25 }
  res.json({ message: 'User created', data: req.body });
});

// Client sends:
// POST /api/users
// Content-Type: application/json
// Body: {"name": "Alice", "age": 25}

Copyapp.use(express.text());

app.post('/webhook', (req, res) => {
  console.log(req.body); // "Plain text message"
  res.send(`Received: ${req.body}`);
});

// Client sends:
// POST /webhook
// Content-Type: text/plain
// Body: Plain text message

Copyapp.use(express.urlencoded({ extended: true }));

app.post('/login', (req, res) => {
  console.log(req.body); // { username: 'alice', password: '12345' }
  res.send(`Welcome ${req.body.username}`);
});

// Client sends (HTML form):
// POST /login
// Content-Type: application/x-www-form-urlencoded
// Body: username=alice&password=12345

my-app/
  ├── server.js
  └── public/              ← Static files folder
      ├── index.html
      ├── style.css
      ├── script.js
      └── images/
          └── logo.png

Copyconst express = require('express');
const app = express();

// Serve all files from 'public' folder
app.use(express.static('public'));

// Now users can access:
// http://localhost:3000/index.html
// http://localhost:3000/style.css
// http://localhost:3000/script.js
// http://localhost:3000/images/logo.png

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

Copy<!DOCTYPE html>
<html>
<head>
  <title>My Website</title>
  <link rel="stylesheet" href="/style.css">
</head>
<body>
  <h1>Welcome to My Website!</h1>
  <img src="/images/logo.png" alt="Logo">
  <script src="/script.js"></script>
</body>
</html>

Copybody {
  font-family: Arial, sans-serif;
  background: #f0f0f0;
  margin: 0;
  padding: 20px;
}

h1 {
  color: #333;
}

Copyconsole.log('Website loaded!');

document.querySelector('h1').addEventListener('click', () => {
  alert('Hello from client-side JavaScript!');
});

Copyconst express = require('express');
const app = express();

// Serve static files from 'public' folder
app.use(express.static('public'));

// API endpoint (separate from static files)
app.get('/api/data', (req, res) => {
  res.json({ message: 'Hello from API!' });
});

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

Copyapp.use('/assets', express.static('public'));
// Files accessible at: http://localhost:3000/assets/style.css

Copyapp.use(express.static('public'));
app.use(express.static('uploads'));
// Express checks 'public' first, then 'uploads'

Copyapp.use(express.static('public', {
  maxAge: '1d', // Cache for 1 day
  etag: true     // Enable ETag headers
}));

const express = require('express');
const app = express();

app.use(express.json());  // ✅ Parse body first!

app.post('/users', (req, res) => {
  console.log(req.body);  // ✅ Works! Body is parsed
  res.json({ received: req.body });
});

const express = require('express');
const app = express();

app.post('/users', (req, res) => {
  console.log(req.body);  // ❌ undefined!
  res.json({ received: req.body });
});

app.use(express.json());  // ❌ Too late!

Copyconst express = require('express');
const app = express();

// 1️⃣ Application-level middleware (runs for ALL requests)
app.use((req, res, next) => {
  console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
  next(); // ✅ Pass control to next middleware
});

// 2️⃣ Built-in middleware
app.use(express.json()); // Parse JSON bodies

// 3️⃣ Custom authentication middleware
function requireAuth(req, res, next) {
  const token = req.headers.authorization;
  if (!token) {
    return res.status(401).json({ error: 'Unauthorized' });
  }
  req.user = { id: 123, name: 'Alice' }; // Attach user to request
  next(); // ✅ Authenticated, continue
}

// 4️⃣ Public route (no middleware)
app.get('/', (req, res) => {
  res.send('Welcome to the API!');
});

// 5️⃣ Protected route (uses requireAuth middleware)
app.get('/dashboard', requireAuth, (req, res) => {
  res.json({ 
    message: 'Dashboard',
    user: req.user // Available thanks to middleware!
  });
});

// 6️⃣ Multiple middleware in sequence
app.post('/admin', requireAuth, checkAdmin, (req, res) => {
  res.send('Admin panel');
});

function checkAdmin(req, res, next) {
  if (req.user.role !== 'admin') {
    return res.status(403).json({ error: 'Forbidden' });
  }
  next(); // ✅ Is admin, continue
}

// 7️⃣ Error-handling middleware (MUST be last!)
app.use((err, req, res, next) => {
  console.error('Error:', err.message);
  res.status(500).json({ error: 'Internal Server Error' });
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

🚨 Error Handling in Express

⚠️ Part 1: The Problem - Unhandled Errors Crash Your Server

Let's start by understanding what happens when errors are NOT handled properly:

Copyconst express = require('express');
const app = express();

app.use(express.json());

// In-memory data for testing
const todos = [
  { id: 1, task: 'Learn Node.js', completed: false },
  { id: 2, task: 'Build an API', completed: true }
];

// ❌ BAD: No error handling - this WILL crash your server!
app.get('/todos/:id', (req, res) => {
  const id = parseInt(req.params.id);
  const todo = todos.find(t => t.id === id);
  
  // What if todo is undefined? 💥 CRASH!
  res.json({
    task: todo.task,        // ❌ Cannot read property 'task' of undefined
    completed: todo.completed
  });
});

app.post('/todos', (req, res) => {
  const { task } = req.body;
  
  // What if task is missing? 💥 CRASH!
  const newTodo = {
    id: todos.length + 1,
    task: task.trim(),  // ❌ Cannot read property 'trim' of undefined
    completed: false
  };
  
  todos.push(newTodo);
  res.json(newTodo);
});

app.listen(3000, () => console.log('Server on port 3000'));

// Try these requests:
// GET /todos/999  →  💥 Server crashes! (todo is undefined)
// POST /todos with empty body  →  💥 Server crashes! (task is undefined)

✅ Part 2: Solution 1 - Try-Catch (Works, But Repetitive)

The first solution is to wrap your code in try-catch blocks. This prevents crashes, but you'll see the problem: it gets repetitive fast!

Copyconst express = require('express');
const app = express();

app.use(express.json());

const todos = [
  { id: 1, task: 'Learn Node.js', completed: false },
  { id: 2, task: 'Build an API', completed: true }
];

// ✅ BETTER: Handle errors with try-catch
app.get('/todos/:id', (req, res) => {
  try {
    const id = parseInt(req.params.id);
    
    // Validate ID
    if (isNaN(id)) {
      return res.status(400).json({ error: 'Invalid ID format' });
    }
    
    const todo = todos.find(t => t.id === id);
    
    // Check if todo exists BEFORE using it
    if (!todo) {
      return res.status(404).json({ error: 'Todo not found' });
    }
    
    res.json(todo);
  } catch (error) {
    console.error('Error:', error.message);
    res.status(500).json({ error: 'Something went wrong' });
  }
});

// ✅ BETTER: But we need try-catch in EVERY route!
app.post('/todos', (req, res) => {
  try {  // ⚠️ See the repetition?
    const { task } = req.body;
    
    // Validation
    if (!task || task.trim() === '') {
      return res.status(400).json({ error: 'Task is required' });
    }
    
    if (task.length > 100) {
      return res.status(400).json({ error: 'Task too long (max 100 chars)' });
    }
    
    const newTodo = {
      id: todos.length + 1,
      task: task.trim(),
      completed: false
    };
    
    todos.push(newTodo);
    res.status(201).json(newTodo);
  } catch (error) {  // ⚠️ Same code again!
    console.error('Error:', error.message);
    res.status(500).json({ error: 'Failed to create todo' });
  }
});

app.delete('/todos/:id', (req, res) => {
  try {  // ⚠️ And again!
    const id = parseInt(req.params.id);
    
    if (isNaN(id)) {
      return res.status(400).json({ error: 'Invalid ID' });
    }
    
    const index = todos.findIndex(t => t.id === id);
    
    if (index === -1) {
      return res.status(404).json({ error: 'Todo not found' });
    }
    
    todos.splice(index, 1);
    res.json({ message: 'Todo deleted' });
  } catch (error) {  // ⚠️ Repetitive!
    console.error('Error:', error.message);
    res.status(500).json({ error: 'Failed to delete' });
  }
});

app.listen(3000);

🎯 Part 3: Solution 2 - asyncHandler Wrapper (Best Practice! ⭐)

Instead of repeating try-catch in every route, we create a reusable wrapper function that automatically catches errors. Write the error handling logic ONCE, use it everywhere!

🧠 Understanding the Wrapper (Step-by-Step)

Copy// Step 1: The asyncHandler function
// This is the "wrapper" - you write it ONCE

const asyncHandler = (fn) => {
  // fn = your route handler function
  
  // Return a NEW function that Express will call
  return async (req, res, next) => {
    try {
      // Run your route handler
      await fn(req, res, next);
    } catch (error) {
      // If any error happens, pass it to error middleware
      next(error);
    }
  };
};

// Step 2: How to use it
// Instead of writing try-catch yourself:
app.get('/todos/:id', async (req, res) => {
  try {
    // your code...
  } catch (error) {
    // handle error...
  }
});

// Wrap your function with asyncHandler:
app.get('/todos/:id', asyncHandler(async (req, res) => {
  // Just write your code! No try-catch needed!
  // If error happens, asyncHandler catches it automatically
}));

📊 Visual Comparison: Before vs After

Copy// ❌ WITHOUT asyncHandler: Repetitive code

app.get('/todos/:id', async (req, res) => {
  try {  // 😫 Repetition
    const id = parseInt(req.params.id);
    const todo = todos.find(t => t.id === id);
    if (!todo) return res.status(404).json({ error: 'Not found' });
    res.json(todo);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.post('/todos', async (req, res) => {
  try {  // 😫 Repetition
    const { task } = req.body;
    if (!task) throw new Error('Task required');
    const newTodo = { id: todos.length + 1, task };
    todos.push(newTodo);
    res.json(newTodo);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.delete('/todos/:id', async (req, res) => {
  try {  // 😫 Repetition
    const id = parseInt(req.params.id);
    const index = todos.findIndex(t => t.id === id);
    if (index === -1) return res.status(404).json({ error: 'Not found' });
    todos.splice(index, 1);
    res.json({ message: 'Deleted' });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// You're writing try-catch in EVERY route! 😩

Copy// ✅ WITH asyncHandler: Clean and DRY!

const asyncHandler = (fn) => {
  return async (req, res, next) => {
    try {
      await fn(req, res, next);
    } catch (error) {
      next(error);
    }
  };
};

// Now all routes are clean - errors caught automatically!
app.get('/todos/:id', asyncHandler(async (req, res) => {
  const id = parseInt(req.params.id);
  const todo = todos.find(t => t.id === id);
  if (!todo) return res.status(404).json({ error: 'Not found' });
  res.json(todo);
}));

app.post('/todos', asyncHandler(async (req, res) => {
  const { task } = req.body;
  if (!task) throw new Error('Task required');  // Caught by wrapper!
  const newTodo = { id: todos.length + 1, task };
  todos.push(newTodo);
  res.json(newTodo);
}));

app.delete('/todos/:id', asyncHandler(async (req, res) => {
  const id = parseInt(req.params.id);
  const index = todos.findIndex(t => t.id === id);
  if (index === -1) return res.status(404).json({ error: 'Not found' });
  todos.splice(index, 1);
  res.json({ message: 'Deleted' });
}));

// 😊 Much cleaner! Write try-catch ONCE, use everywhere!

🛡️ Part 4: Error Handling Middleware (Centralized Error Responses)

Now that asyncHandler catches errors and passes them via next(error), we need error middleware to send proper responses to clients. This is where we handle ALL errors in ONE place!

Copy// Basic error middleware
app.use((err, req, res, next) => {
  // Log the error
  console.error('Error:', {
    message: err.message,
    stack: err.stack,
    path: req.path,
    method: req.method
  });
  
  // Send error response
  res.status(500).json({
    error: err.message || 'Internal Server Error'
  });
});

// Better: Environment-aware error middleware
app.use((err, req, res, next) => {
  console.error('❌ Error:', err.message);
  
  // In development: show full error details
  if (process.env.NODE_ENV === 'development') {
    res.status(err.statusCode || 500).json({
      error: err.message,
      stack: err.stack,  // Show stack trace in dev
      path: req.path
    });
  } else {
    // In production: hide sensitive details
    res.status(err.statusCode || 500).json({
      error: err.message || 'Something went wrong'
    });
  }
});

// Best: Advanced error middleware with 404 handler
const express = require('express');
const app = express();

// ... your routes ...

// 404 handler (no route matched)
app.use((req, res, next) => {
  res.status(404).json({
    error: 'Route not found',
    path: req.path
  });
});

// Error handler (MUST be LAST)
app.use((err, req, res, next) => {
  // Set default status code
  const statusCode = err.statusCode || 500;
  
  // Log error details
  console.error(`[${new Date().toISOString()}] Error:`, {
    message: err.message,
    statusCode,
    path: req.path,
    method: req.method
  });
  
  // Send appropriate response
  res.status(statusCode).json({
    success: false,
    error: process.env.NODE_ENV === 'development' 
      ? err.message 
      : 'An error occurred',
    ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
  });
});

✨ Part 5: Custom Error Classes (Enhancement, Not a Solution!)

Important: Custom error classes are NOT a catching solution! They help you CREATE better errors with proper status codes and messages. They work best when combined with asyncHandler from Part 3.

📦 Creating Custom Error Classes

Copy// errors/AppError.js - Base error class
class AppError extends Error {
  constructor(message, statusCode) {
    super(message);
    this.statusCode = statusCode;
    this.isOperational = true; // Mark as expected/operational error
    Error.captureStackTrace(this, this.constructor);
  }
}

module.exports = AppError;

// errors/NotFoundError.js - For 404 errors
const AppError = require('./AppError');

class NotFoundError extends AppError {
  constructor(resource) {
    super(`${resource} not found`, 404);
  }
}

module.exports = NotFoundError;

// errors/ValidationError.js - For 400 bad request errors
const AppError = require('./AppError');

class ValidationError extends AppError {
  constructor(message) {
    super(message, 400);
  }
}

module.exports = ValidationError;

🚫 Wrong Way: Using try-catch Everywhere (Still Repetitive!)

Copy// ❌ DON'T DO THIS - Still repetitive like Solution 1!

const todos = [
  { id: 1, task: 'Learn Node.js', completed: false },
  { id: 2, task: 'Build an API', completed: true }
];

app.get('/todos/:id', (req, res, next) => {
  try {  // ⚠️ Repetitive!
    const id = parseInt(req.params.id);
    
    if (isNaN(id)) {
      throw new ValidationError('ID must be a number');
    }
    
    const todo = todos.find(t => t.id === id);
    
    if (!todo) {
      throw new NotFoundError('Todo');
    }
    
    res.json(todo);
  } catch (error) {
    next(error);
  }
});

app.post('/todos', (req, res, next) => {
  try {  // ⚠️ Repetitive!
    const { task } = req.body;
    
    if (!task || task.trim() === '') {
      throw new ValidationError('Task cannot be empty');
    }
    
    const newTodo = {
      id: todos.length + 1,
      task: task.trim(),
      completed: false
    };
    
    todos.push(newTodo);
    res.status(201).json(newTodo);
  } catch (error) {
    next(error);
  }
});

// Problem: You're writing try-catch in EVERY route. This is Solution 1!

✅ Right Way: Combine with asyncHandler (Clean + Meaningful Errors)!

Use custom error classes WITH asyncHandler from Solution 2 – you get clean code AND meaningful error messages!

Copy// ✅ BEST APPROACH: Custom Errors + asyncHandler
// You get: Clean routes + Specific errors + Proper status codes

const asyncHandler = (fn) => {
  return async (req, res, next) => {
    try {
      await fn(req, res, next);
    } catch (error) {
      next(error);  // Catches thrown errors automatically!
    }
  };
};

// Now your routes are super clean:
app.get('/todos/:id', asyncHandler(async (req, res) => {
  const id = parseInt(req.params.id);
  
  // Just throw! asyncHandler catches it
  if (isNaN(id)) {
    throw new ValidationError('ID must be a number');
  }
  
  const todo = todos.find(t => t.id === id);
  
  if (!todo) {
    throw new NotFoundError('Todo');  // asyncHandler catches this too!
  }
  
  res.json(todo);
}));

app.post('/todos', asyncHandler(async (req, res) => {
  const { task } = req.body;
  
  // All these throws are caught by asyncHandler!
  if (!task || task.trim() === '') {
    throw new ValidationError('Task cannot be empty');
  }
  
  if (task.length > 100) {
    throw new ValidationError('Task too long');
  }
  
  const newTodo = {
    id: todos.length + 1,
    task: task.trim(),
    completed: false
  };
  
  todos.push(newTodo);
  res.status(201).json(newTodo);
}));

// Error middleware receives all errors
app.use((err, req, res, next) => {
  const statusCode = err.statusCode || 500;
  res.status(statusCode).json({
    success: false,
    error: err.message
  });
});

🎯 Part 6: Complete Production-Ready Example

Here's everything together: asyncHandler + Custom Error Classes + Error Middleware + 404 Handler. This is production-ready code!

Copy// server.js - Complete production-ready error handling
const express = require('express');
const app = express();

app.use(express.json());

// 1️⃣ Custom Error Classes
class AppError extends Error {
  constructor(message, statusCode) {
    super(message);
    this.statusCode = statusCode;
    this.isOperational = true;  // Mark as expected error
  }
}

class NotFoundError extends AppError {
  constructor(resource = 'Resource') {
    super(`${resource} not found`, 404);
  }
}

class ValidationError extends AppError {
  constructor(message) {
    super(message, 400);
  }
}

// 2️⃣ asyncHandler Wrapper
const asyncHandler = (fn) => {
  return async (req, res, next) => {
    try {
      await fn(req, res, next);
    } catch (error) {
      next(error);
    }
  };
};

// 3️⃣ Sample Data
const todos = [
  { id: 1, task: 'Learn Express', completed: false },
  { id: 2, task: 'Build API', completed: true }
];

// 4️⃣ Routes - Clean with asyncHandler + Custom Errors
app.get('/todos', asyncHandler(async (req, res) => {
  res.json(todos);
}));

app.get('/todos/:id', asyncHandler(async (req, res) => {
  const id = parseInt(req.params.id);
  
  if (isNaN(id)) {
    throw new ValidationError('ID must be a valid number');
  }
  
  const todo = todos.find(t => t.id === id);
  
  if (!todo) {
    throw new NotFoundError('Todo');
  }
  
  res.json(todo);
}));

app.post('/todos', asyncHandler(async (req, res) => {
  const { task } = req.body;
  
  if (!task || task.trim() === '') {
    throw new ValidationError('Task is required');
  }
  
  if (task.length > 100) {
    throw new ValidationError('Task too long (max 100 characters)');
  }
  
  const newTodo = {
    id: todos.length + 1,
    task: task.trim(),
    completed: false
  };
  
  todos.push(newTodo);
  res.status(201).json(newTodo);
}));

// 5️⃣ 404 Handler (no route matched)
app.use((req, res) => {
  res.status(404).json({
    success: false,
    error: 'Route not found',
    path: req.path
  });
});

// 6️⃣ Error Middleware (MUST be LAST and have 4 parameters!)
// Note: app.use() has a special overload that accepts (err, req, res, next)
// When Express sees 4 parameters, it treats this as error handling middleware
app.use((err, req, res, next) => {
  // Use statusCode from custom error or default to 500
  const statusCode = err.statusCode || 500;
  
  // Log error
  console.error(`[${statusCode}] ${err.message}`);
  
  // Send response
  res.status(statusCode).json({
    success: false,
    error: err.message || 'Internal Server Error'
  });
});

app.listen(3000, () => console.log('✅ Server running on port 3000'));

// Test it:
// GET  /todos              →  200: Returns all todos
// GET  /todos/1            →  200: Returns todo 1
// GET  /todos/999          →  404: Todo not found
// GET  /todos/abc          →  400: ID must be a valid number
// POST /todos (no body)    →  400: Task is required
// GET  /invalid-route      →  404: Route not found

✅ Input Validation

🤔 Why Validate Input?

🔧 Manual Validation

Copy// Basic manual validation
app.post('/users', (req, res) => {
  const { name, email, age } = req.body;
  const errors = [];
  
  // Check required fields
  if (!name || name.trim() === '') {
    errors.push('Name is required');
  }
  
  if (!email || email.trim() === '') {
    errors.push('Email is required');
  } else if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
    errors.push('Email must be valid');
  }
  
  // Check types and ranges
  if (age !== undefined) {
    const ageNum = parseInt(age);
    if (isNaN(ageNum)) {
      errors.push('Age must be a number');
    } else if (ageNum < 0 || ageNum > 150) {
      errors.push('Age must be between 0 and 150');
    }
  }
  
  // Check length
  if (name && name.length > 100) {
    errors.push('Name must be less than 100 characters');
  }
  
  // Return errors if any
  if (errors.length > 0) {
    return res.status(400).json({
      success: false,
      errors
    });
  }
  
  // Create user
  const newUser = { name: name.trim(), email: email.trim(), age };
  res.status(201).json({ success: true, data: newUser });
});

📦 express-validator Library

express-validator is the most popular validation library for Express. It's built on top of validator.js and provides a clean, middleware-based API.

Copy# Install express-validator
npm install express-validator

🎯 Basic Usage

Copyconst express = require('express');
const { body, validationResult } = require('express-validator');
const app = express();

app.use(express.json());

// POST /users with validation
app.post('/users',
  // Validation middleware
  body('name')
    .trim()
    .notEmpty().withMessage('Name is required')
    .isLength({ min: 2, max: 100 }).withMessage('Name must be 2-100 characters'),
  
  body('email')
    .trim()
    .notEmpty().withMessage('Email is required')
    .isEmail().withMessage('Email must be valid')
    .normalizeEmail(),
  
  body('age')
    .optional()
    .isInt({ min: 0, max: 150 }).withMessage('Age must be between 0 and 150')
    .toInt(),
  
  // Route handler
  (req, res) => {
    // Check for validation errors
    const errors = validationResult(req);
    
    if (!errors.isEmpty()) {
      return res.status(400).json({
        success: false,
        errors: errors.array()
      });
    }
    
    // Data is valid!
    const { name, email, age } = req.body;
    res.status(201).json({
      success: true,
      data: { name, email, age }
    });
  }
);

app.listen(3000);

📋 Common Validation Rules

♻️ Reusable Validation Middleware

Copy// validators/userValidators.js
const { body, param, validationResult } = require('express-validator');

// Reusable validation rules
const userValidationRules = () => {
  return [
    body('name')
      .trim()
      .notEmpty().withMessage('Name is required')
      .isLength({ min: 2, max: 100 }).withMessage('Name must be 2-100 characters'),
    
    body('email')
      .trim()
      .notEmpty().withMessage('Email is required')
      .isEmail().withMessage('Email must be valid')
      .normalizeEmail(),
    
    body('age')
      .optional()
      .isInt({ min: 0, max: 150 }).withMessage('Age must be between 0 and 150')
      .toInt()
  ];
};

// Middleware to check validation result
const validate = (req, res, next) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({
      success: false,
      errors: errors.array().map(err => ({
        field: err.path,
        message: err.msg
      }))
    });
  }
  next();
};

module.exports = {
  userValidationRules,
  validate
};

// routes/users.js - Clean usage
const { userValidationRules, validate } = require('../validators/userValidators');

app.post('/users', userValidationRules(), validate, (req, res) => {
  // Data is validated!
  const { name, email, age } = req.body;
  res.status(201).json({ success: true, data: { name, email, age } });
});

🔥 Advanced Validation Examples

Copyconst { body, param } = require('express-validator');

// Custom validation function
const userExists = async (value) => {
  const user = await database.findUserByEmail(value);
  if (user) {
    throw new Error('Email already exists');
  }
  return true;
};

// Password confirmation
const passwordMatch = (value, { req }) => {
  if (value !== req.body.password) {
    throw new Error('Passwords do not match');
  }
  return true;
};

// Registration endpoint with advanced validation
app.post('/register',
  body('email')
    .isEmail().withMessage('Invalid email')
    .normalizeEmail()
    .custom(userExists).withMessage('Email already registered'),
  
  body('password')
    .isLength({ min: 8 }).withMessage('Password must be at least 8 characters')
    .matches(/\d/).withMessage('Password must contain a number')
    .matches(/[A-Z]/).withMessage('Password must contain uppercase letter'),
  
  body('confirmPassword')
    .custom(passwordMatch).withMessage('Passwords do not match'),
  
  body('role')
    .optional()
    .isIn(['user', 'admin', 'moderator']).withMessage('Invalid role'),
  
  validate,
  
  async (req, res) => {
    const { email, password, role } = req.body;
    // Create user...
    res.status(201).json({ success: true });
  }
);

// Validate URL parameters
app.get('/users/:id',
  param('id')
    .isInt().withMessage('User ID must be an integer')
    .toInt(),
  
  validate,
  
  (req, res) => {
    const userId = req.params.id; // Already converted to integer
    res.json({ id: userId });
  }
);

📊 Logging Best Practices

🤔 Why Move Beyond console.log()?

📊 Log Levels Explained

logger.error('Database connection failed');

logger.warn('API rate limit approaching');

logger.info('Server started on port 3000');

logger.debug('Query executed:', query);

📦 Winston: Professional Logging

Winston is the most popular logging library for Node.js. It supports multiple transports (console, file, cloud), log levels, and formatting.

Copy# Install winston
npm install winston

🎯 Basic Winston Setup

Copy// logger.js
const winston = require('winston');

const logger = winston.createLogger({
  level: 'info', // Minimum level to log
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [
    // Write to console
    new winston.transports.Console({
      format: winston.format.combine(
        winston.format.colorize(),
        winston.format.simple()
      )
    }),
    // Write to file
    new winston.transports.File({ 
      filename: 'logs/error.log', 
      level: 'error' 
    }),
    new winston.transports.File({ 
      filename: 'logs/combined.log' 
    })
  ]
});

module.exports = logger;

// Usage in your app
const logger = require('./logger');

logger.info('Server starting...');
logger.error('Database connection failed', { error: err.message });
logger.warn('High memory usage detected');
logger.debug('Request payload:', req.body);

🚀 Production-Ready Logger

Copy// config/logger.js
const winston = require('winston');

const isDevelopment = process.env.NODE_ENV === 'development';

const logger = winston.createLogger({
  level: isDevelopment ? 'debug' : 'info',
  format: winston.format.combine(
    winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  defaultMeta: { service: 'api-server' },
  transports: [
    // Console output (pretty in dev, JSON in prod)
    new winston.transports.Console({
      format: isDevelopment
        ? winston.format.combine(
            winston.format.colorize(),
            winston.format.printf(({ timestamp, level, message, ...meta }) => {
              return `${timestamp} [${level}]: ${message} ${
                Object.keys(meta).length ? JSON.stringify(meta, null, 2) : ''
              }`;
            })
          )
        : winston.format.json()
    }),
    
    // File outputs
    new winston.transports.File({ 
      filename: 'logs/error.log', 
      level: 'error',
      maxsize: 5242880, // 5MB
      maxFiles: 5
    }),
    new winston.transports.File({ 
      filename: 'logs/combined.log',
      maxsize: 5242880,
      maxFiles: 5
    })
  ]
});

module.exports = logger;

// app.js - Use in Express
const express = require('express');
const logger = require('./config/logger');

const app = express();

// Log every request
app.use((req, res, next) => {
  logger.info(`${req.method} ${req.path}`, {
    ip: req.ip,
    userAgent: req.get('user-agent')
  });
  next();
});

// Use in routes
app.get('/users', async (req, res) => {
  try {
    logger.debug('Fetching users from database');
    const users = await database.getUsers();
    logger.info(`Retrieved ${users.length} users`);
    res.json(users);
  } catch (error) {
    logger.error('Failed to fetch users', {
      error: error.message,
      stack: error.stack
    });
    res.status(500).json({ error: 'Failed to fetch users' });
  }
});

// Log unhandled errors
process.on('unhandledRejection', (reason, promise) => {
  logger.error('Unhandled Rejection:', { reason, promise });
});

process.on('uncaughtException', (error) => {
  logger.error('Uncaught Exception:', { error: error.message, stack: error.stack });
  process.exit(1);
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  logger.info(`Server started successfully`, { port: PORT, env: process.env.NODE_ENV });
});

📝 What to Log (and What NOT to Log)

📤 API Response Patterns

🤔 Why Consistent Responses Matter

✅ Standard Response Format

Copy// Standard success response
{
  "success": true,
  "data": { /* your data here */ },
  "message": "Optional success message"
}

// Standard error response
{
  "success": false,
  "error": "Error message",
  "errors": [ /* optional array of detailed errors */ ]
}

// Paginated response
{
  "success": true,
  "data": [ /* array of items */ ],
  "pagination": {
    "page": 1,
    "limit": 10,
    "total": 100,
    "totalPages": 10
  }
}

🔧 Response Helper Functions

Copy// utils/response.js
class ApiResponse {
  static success(res, data, message = null, statusCode = 200) {
    return res.status(statusCode).json({
      success: true,
      data,
      ...(message && { message })
    });
  }

  static error(res, message, statusCode = 500, errors = null) {
    return res.status(statusCode).json({
      success: false,
      error: message,
      ...(errors && { errors })
    });
  }

  static paginated(res, data, page, limit, total) {
    return res.status(200).json({
      success: true,
      data,
      pagination: {
        page: parseInt(page),
        limit: parseInt(limit),
        total,
        totalPages: Math.ceil(total / limit),
        hasNext: page * limit < total,
        hasPrev: page > 1
      }
    });
  }

  static created(res, data, message = 'Resource created successfully') {
    return this.success(res, data, message, 201);
  }

  static noContent(res) {
    return res.status(204).send();
  }

  static badRequest(res, message, errors = null) {
    return this.error(res, message, 400, errors);
  }

  static unauthorized(res, message = 'Unauthorized') {
    return this.error(res, message, 401);
  }

  static forbidden(res, message = 'Forbidden') {
    return this.error(res, message, 403);
  }

  static notFound(res, message = 'Resource not found') {
    return this.error(res, message, 404);
  }
}

module.exports = ApiResponse;

// Usage in routes
const ApiResponse = require('./utils/response');

// Success
app.get('/users', async (req, res) => {
  const users = await database.getUsers();
  return ApiResponse.success(res, users);
});

// Created
app.post('/users', async (req, res) => {
  const user = await database.createUser(req.body);
  return ApiResponse.created(res, user);
});

// Not found
app.get('/users/:id', async (req, res) => {
  const user = await database.getUser(req.params.id);
  if (!user) {
    return ApiResponse.notFound(res, 'User not found');
  }
  return ApiResponse.success(res, user);
});

// Validation errors
app.post('/users', validate, async (req, res) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return ApiResponse.badRequest(res, 'Validation failed', errors.array());
  }
  // ...
});

📊 HTTP Status Codes Reference

🎯 Complete API Example with Best Practices

Copy// Complete REST API with proper responses
const express = require('express');
const { body, validationResult } = require('express-validator');
const ApiResponse = require('./utils/response');
const asyncHandler = require('./utils/asyncHandler');

const app = express();
app.use(express.json());

// Mock database
let todos = [
  { id: 1, title: 'Learn Node.js', completed: false },
  { id: 2, title: 'Build API', completed: false }
];
let nextId = 3;

// GET /todos - List with pagination
app.get('/todos', asyncHandler(async (req, res) => {
  const page = parseInt(req.query.page) || 1;
  const limit = parseInt(req.query.limit) || 10;
  const start = (page - 1) * limit;
  const end = start + limit;
  
  const paginatedTodos = todos.slice(start, end);
  
  return ApiResponse.paginated(res, paginatedTodos, page, limit, todos.length);
}));

// GET /todos/:id - Get single todo
app.get('/todos/:id', asyncHandler(async (req, res) => {
  const todo = todos.find(t => t.id === parseInt(req.params.id));
  
  if (!todo) {
    return ApiResponse.notFound(res, 'Todo not found');
  }
  
  return ApiResponse.success(res, todo);
}));

// POST /todos - Create todo
app.post('/todos',
  body('title').trim().notEmpty().withMessage('Title is required'),
  asyncHandler(async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return ApiResponse.badRequest(res, 'Validation failed', errors.array());
    }
    
    const newTodo = {
      id: nextId++,
      title: req.body.title,
      completed: false
    };
    
    todos.push(newTodo);
    return ApiResponse.created(res, newTodo, 'Todo created successfully');
  })
);

// PUT /todos/:id - Update todo
app.put('/todos/:id',
  body('title').optional().trim().notEmpty(),
  body('completed').optional().isBoolean(),
  asyncHandler(async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return ApiResponse.badRequest(res, 'Validation failed', errors.array());
    }
    
    const todo = todos.find(t => t.id === parseInt(req.params.id));
    
    if (!todo) {
      return ApiResponse.notFound(res, 'Todo not found');
    }
    
    if (req.body.title !== undefined) todo.title = req.body.title;
    if (req.body.completed !== undefined) todo.completed = req.body.completed;
    
    return ApiResponse.success(res, todo, 'Todo updated successfully');
  })
);

// DELETE /todos/:id - Delete todo
app.delete('/todos/:id', asyncHandler(async (req, res) => {
  const index = todos.findIndex(t => t.id === parseInt(req.params.id));
  
  if (index === -1) {
    return ApiResponse.notFound(res, 'Todo not found');
  }
  
  todos.splice(index, 1);
  return ApiResponse.noContent(res);
}));

// 404 handler
app.use((req, res) => {
  return ApiResponse.notFound(res, 'Endpoint not found');
});

// Error handler
app.use((err, req, res, next) => {
  console.error(err);
  return ApiResponse.error(res, err.message || 'Internal server error', err.statusCode || 500);
});

app.listen(3000, () => console.log('API running on port 3000'));

🎯 Complete Todo REST API with Express

Here's a complete, production-ready Todo API built with Express:

Copyconst express = require('express');
const app = express();

// Middleware
app.use(express.json()); // Parse JSON bodies

// In-memory database (use a real DB in production)
let todos = [
  { id: 1, title: 'Learn Node.js', completed: false },
  { id: 2, title: 'Build an API', completed: false }
];
let nextId = 3;

// GET /todos - Get all todos
app.get('/todos', (req, res) => {
  res.json(todos);
});

// GET /todos/:id - Get one todo
app.get('/todos/:id', (req, res) => {
  const todo = todos.find(t => t.id === parseInt(req.params.id));
  if (!todo) {
    return res.status(404).json({ error: 'Todo not found' });
  }
  res.json(todo);
});

// POST /todos - Create a todo
app.post('/todos', (req, res) => {
  const { title } = req.body;
  
  if (!title) {
    return res.status(400).json({ error: 'Title is required' });
  }
  
  const newTodo = {
    id: nextId++,
    title,
    completed: false
  };
  
  todos.push(newTodo);
  res.status(201).json(newTodo);
});

// PUT /todos/:id - Update a todo
app.put('/todos/:id', (req, res) => {
  const todo = todos.find(t => t.id === parseInt(req.params.id));
  
  if (!todo) {
    return res.status(404).json({ error: 'Todo not found' });
  }
  
  const { title, completed } = req.body;
  if (title !== undefined) todo.title = title;
  if (completed !== undefined) todo.completed = completed;
  
  res.json(todo);
});

// DELETE /todos/:id - Delete a todo
app.delete('/todos/:id', (req, res) => {
  const index = todos.findIndex(t => t.id === parseInt(req.params.id));
  
  if (index === -1) {
    return res.status(404).json({ error: 'Todo not found' });
  }
  
  const deleted = todos.splice(index, 1)[0];
  res.json({ message: 'Todo deleted', todo: deleted });
});

// Start server
app.listen(3000, () => {
  console.log('Todo API running on http://localhost:3000');
});

✅ Express Best Practices

npm install dotenv
require('dotenv').config();

// routes/users.js
const router = express.Router();
module.exports = router;

app.use((err, req, res, next) => {
  res.status(500).json({error: err.message});
});

app.get('/users', async (req, res) => {
  const users = await db.getUsers();
  res.json(users);
});

What You Can Build

Now that you know Node.js, the possibilities are endless! Here are some of the most popular things you can build:

🎯 Your Next Steps