5. Express req and res Objects – Query, Params, Body, Headers Explained

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

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

app.get('/api/example', (req, res) => {
  // Request object contains everything about the request
  console.log('=== REQUEST OBJECT ===');
  console.log('Method:', req.method);      // GET, POST, PUT, DELETE
  console.log('URL:', req.url);             // /api/example?page=2
  console.log('Path:', req.path);           // /api/example
  console.log('Query:', req.query);         // { page: '2' }
  console.log('Params:', req.params);       // {}
  console.log('Headers:', req.headers);     // { host, user-agent, etc }
  console.log('IP:', req.ip);               // Client IP address
  console.log('Protocol:', req.protocol);   // http or https
  console.log('Hostname:', req.hostname);   // localhost
  
  res.json({ message: 'Check console for request details' });
});

app.listen(3000);

// Single parameter
app.get('/api/users/:userId', (req, res) => {
  const userId = req.params.userId;
  res.json({ userId });
});

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

// Optional parameter (using ?)
app.get('/api/products/:category?', (req, res) => {
  const category = req.params.category || 'all';
  res.json({ category });
});

// E-commerce routes with params
app.get('/api/products/:category/:productId', (req, res) => {
  const { category, productId } = req.params;
  
  // Fetch product from database
  const product = products.find(p => 
    p.category === category && p.id === parseInt(productId)
  );
  
  if (!product) {
    return res.status(404).json({ error: 'Product not found' });
  }
  
  res.json(product);
});

// Social media routes
app.get('/api/users/:userId/followers/:followerId', (req, res) => {
  const { userId, followerId } = req.params;
  res.json({ 
    message: `User ${followerId} follows user ${userId}`,
    userId, 
    followerId 
  });
});

// Blog routes
app.get('/api/blog/:year/:month/:slug', (req, res) => {
  const { year, month, slug } = req.params;
  res.json({ year, month, slug });
});

// Only numeric userId
app.get('/api/users/:userId(\\d+)', (req, res) => {
  const userId = parseInt(req.params.userId);
  res.json({ userId }); // Guaranteed to be number
});

// Only alphabetic name
app.get('/api/users/:name([a-zA-Z]+)', (req, res) => {
  res.json({ name: req.params.name });
});

// Email pattern
app.get('/api/users/:email([\\w\\.]+@[\\w\\.]+)', (req, res) => {
  res.json({ email: req.params.email });
});

// GET /api/search?q=express&page=2&limit=10
app.get('/api/search', (req, res) => {
  const { q, page = 1, limit = 10 } = req.query;
  
  res.json({
    query: q,
    page: parseInt(page),
    limit: parseInt(limit),
    results: []
  });
});

let products = [
  { id: 1, name: 'Laptop', price: 50000, category: 'electronics', brand: 'Dell', rating: 4.5 },
  { id: 2, name: 'Mouse', price: 500, category: 'electronics', brand: 'Logitech', rating: 4.2 },
  { id: 3, name: 'Shirt', price: 1000, category: 'clothing', brand: 'Nike', rating: 4.0 }
];

app.get('/api/products', (req, res) => {
  let {
    category,
    brand,
    minPrice,
    maxPrice,
    minRating,
    search,
    page = 1,
    limit = 10,
    sortBy = 'id',
    order = 'asc'
  } = req.query;
  
  let filtered = [...products];
  
  // Category filter
  if (category) {
    filtered = filtered.filter(p => p.category === category);
  }
  
  // Brand filter
  if (brand) {
    filtered = filtered.filter(p => p.brand === brand);
  }
  
  // Price range filter
  if (minPrice) {
    filtered = filtered.filter(p => p.price >= parseInt(minPrice));
  }
  if (maxPrice) {
    filtered = filtered.filter(p => p.price <= parseInt(maxPrice));
  }
  
  // Rating filter
  if (minRating) {
    filtered = filtered.filter(p => p.rating >= parseFloat(minRating));
  }
  
  // Search filter
  if (search) {
    const searchLower = search.toLowerCase();
    filtered = filtered.filter(p => 
      p.name.toLowerCase().includes(searchLower)
    );
  }
  
  // Sorting
  filtered.sort((a, b) => {
    const aVal = a[sortBy];
    const bVal = b[sortBy];
    
    if (order === 'asc') {
      return aVal > bVal ? 1 : -1;
    } else {
      return aVal < bVal ? 1 : -1;
    }
  });
  
  // Pagination
  const total = filtered.length;
  const startIndex = (parseInt(page) - 1) * parseInt(limit);
  const endIndex = startIndex + parseInt(limit);
  const paginated = filtered.slice(startIndex, endIndex);
  
  res.json({
    success: true,
    data: paginated,
    pagination: {
      page: parseInt(page),
      limit: parseInt(limit),
      total,
      totalPages: Math.ceil(total / parseInt(limit)),
      hasNext: endIndex < total,
      hasPrev: startIndex > 0
    },
    filters: { category, brand, minPrice, maxPrice, minRating, search }
  });
});

# Basic
GET /api/products

# Filter by category
GET /api/products?category=electronics

# Multiple filters
GET /api/products?category=electronics&minPrice=1000&maxPrice=50000

# Pagination
GET /api/products?page=2&limit=5

# Sorting
GET /api/products?sortBy=price&order=desc

# Search
GET /api/products?search=laptop

# All combined
GET /api/products?category=electronics&minPrice=1000&sortBy=rating&order=desc&page=1&limit=10

// MUST have these middleware BEFORE routes
app.use(express.json());           // For JSON body
app.use(express.urlencoded({ extended: true })); // For form data
app.use(express.text());           // For plain text
app.use(express.raw());            // For raw buffer

// Client sends: { "name": "Rahul", "email": "rahul@example.com" }
app.post('/api/users', (req, res) => {
  const { name, email } = req.body;
  
  if (!name || !email) {
    return res.status(400).json({ error: 'Name and email required' });
  }
  
  res.status(201).json({ 
    message: 'User created', 
    user: { name, email } 
  });
});

// HTML form submission
app.post('/api/contact', (req, res) => {
  const { name, email, message } = req.body;
  
  console.log('Contact form:', { name, email, message });
  
  res.json({ message: 'Message sent successfully!' });
});

// Client sends: { "user": { "name": "Rahul", "address": { "city": "Mumbai" } } }
app.post('/api/users/profile', (req, res) => {
  const { user } = req.body;
  const { name, address } = user;
  const { city } = address;
  
  res.json({ name, city });
});

// Client sends: { "users": [{ "name": "Rahul" }, { "name": "Priya" }] }
app.post('/api/users/bulk', (req, res) => {
  const { users } = req.body;
  
  if (!Array.isArray(users)) {
    return res.status(400).json({ error: 'Users must be an array' });
  }
  
  const createdUsers = users.map((user, index) => ({
    id: index + 1,
    ...user
  }));
  
  res.status(201).json(createdUsers);
});

const multer = require('multer');
const upload = multer({ dest: 'uploads/' });

// Form data with file
app.post('/api/upload', upload.single('image'), (req, res) => {
  // req.file contains file info
  // req.body contains text fields
  const { description } = req.body;
  const file = req.file;
  
  res.json({ 
    message: 'File uploaded', 
    description,
    file: { filename: file.filename, size: file.size }
  });
});

app.get('/api/headers', (req, res) => {
  // Common headers
  const userAgent = req.headers['user-agent'];
  const contentType = req.headers['content-type'];
  const authorization = req.headers['authorization'];
  const accept = req.headers['accept'];
  const acceptLanguage = req.headers['accept-language'];
  const origin = req.headers['origin'];
  const referer = req.headers['referer'];
  const host = req.headers['host'];
  
  res.json({
    userAgent,
    contentType,
    authorization,
    accept,
    acceptLanguage,
    origin,
    referer,
    host
  });
});

// Bearer token authentication
app.get('/api/protected', (req, res) => {
  const authHeader = req.headers['authorization'];
  
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({ error: 'No token provided' });
  }
  
  const token = authHeader.split(' ')[1];
  
  try {
    const decoded = jwt.verify(token, JWT_SECRET);
    res.json({ message: 'Protected data', user: decoded });
  } catch (error) {
    res.status(401).json({ error: 'Invalid token' });
  }
});

// Client sends: X-API-Key: abc123, X-Client-Version: 2.0
app.get('/api/custom-headers', (req, res) => {
  const apiKey = req.headers['x-api-key'];
  const clientVersion = req.headers['x-client-version'];
  
  if (!apiKey || apiKey !== 'abc123') {
    return res.status(401).json({ error: 'Invalid API key' });
  }
  
  res.json({ 
    message: 'Access granted', 
    clientVersion 
  });
});

app.get('/api/device', (req, res) => {
  const userAgent = req.headers['user-agent'];
  
  let device = 'unknown';
  let browser = 'unknown';
  let os = 'unknown';
  
  // Detect mobile
  if (/mobile/i.test(userAgent)) {
    device = 'mobile';
  } else if (/tablet/i.test(userAgent)) {
    device = 'tablet';
  } else {
    device = 'desktop';
  }
  
  // Detect browser
  if (/chrome/i.test(userAgent)) {
    browser = 'Chrome';
  } else if (/firefox/i.test(userAgent)) {
    browser = 'Firefox';
  } else if (/safari/i.test(userAgent) && !/chrome/i.test(userAgent)) {
    browser = 'Safari';
  } else if (/edg/i.test(userAgent)) {
    browser = 'Edge';
  }
  
  // Detect OS
  if (/windows/i.test(userAgent)) {
    os = 'Windows';
  } else if (/mac/i.test(userAgent)) {
    os = 'macOS';
  } else if (/linux/i.test(userAgent)) {
    os = 'Linux';
  } else if (/android/i.test(userAgent)) {
    os = 'Android';
  } else if (/iphone|ipad|ipod/i.test(userAgent)) {
    os = 'iOS';
  }
  
  res.json({ device, browser, os, userAgent });
});

npm install cookie-parser

const express = require('express');
const cookieParser = require('cookie-parser');

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

app.get('/api/get-cookies', (req, res) => {
  // All cookies
  const allCookies = req.cookies;
  
  // Specific cookie
  const sessionId = req.cookies.sessionId;
  const theme = req.cookies.theme;
  
  res.json({ 
    allCookies,
    sessionId,
    theme
  });
});

app.get('/api/set-cookies', (req, res) => {
  // Basic cookie
  res.cookie('theme', 'dark');
  
  // Cookie with options
  res.cookie('sessionId', 'abc123', {
    httpOnly: true,      // Not accessible by JavaScript
    secure: true,        // HTTPS only
    maxAge: 24 * 60 * 60 * 1000, // 1 day
    sameSite: 'strict'   // CSRF protection
  });
  
  // Multiple cookies
  res.cookie('preferences', JSON.stringify({ language: 'hi', notifications: true }), {
    maxAge: 30 * 24 * 60 * 60 * 1000 // 30 days
  });
  
  res.json({ message: 'Cookies set!' });
});

app.get('/api/clear-cookies', (req, res) => {
  res.clearCookie('sessionId');
  res.clearCookie('theme');
  res.clearCookie('preferences');
  
  res.json({ message: 'Cookies cleared!' });
});

// Login endpoint
app.post('/api/login', async (req, res) => {
  const { email, password } = req.body;
  
  const user = await db.users.findOne({ email });
  
  if (!user || !(await bcrypt.compare(password, user.password))) {
    return res.status(401).json({ error: 'Invalid credentials' });
  }
  
  const token = jwt.sign({ id: user.id }, JWT_SECRET, { expiresIn: '1h' });
  
  // Set cookie instead of sending JSON token
  res.cookie('authToken', token, {
    httpOnly: true,
    secure: process.env.NODE_ENV === 'production',
    maxAge: 60 * 60 * 1000, // 1 hour
    sameSite: 'strict'
  });
  
  res.json({ message: 'Login successful', user: { id: user.id, email: user.email } });
});

// Protected route using cookie
app.get('/api/profile', (req, res) => {
  const token = req.cookies.authToken;
  
  if (!token) {
    return res.status(401).json({ error: 'Not authenticated' });
  }
  
  try {
    const decoded = jwt.verify(token, JWT_SECRET);
    res.json({ message: 'Profile data', userId: decoded.id });
  } catch (error) {
    res.status(401).json({ error: 'Invalid or expired token' });
  }
});

// Logout endpoint
app.post('/api/logout', (req, res) => {
  res.clearCookie('authToken');
  res.json({ message: 'Logged out successfully' });
});

app.get('/api/request-info', (req, res) => {
  const requestInfo = {
    // Basic info
    method: req.method,           // GET, POST, PUT, DELETE
    url: req.url,                  // Full URL with query string
    path: req.path,                // URL without query string
    originalUrl: req.originalUrl,  // Original URL (with base)
    baseUrl: req.baseUrl,          // Mounted path
    
    // Client info
    ip: req.ip,                    // Client IP address
    ips: req.ips,                  // Proxy IPs
    hostname: req.hostname,        // Host name
    protocol: req.protocol,        // http or https
    secure: req.secure,            // true if HTTPS
    
    // Request data
    params: req.params,            // Route parameters
    query: req.query,              // Query string
    body: req.body,                // Request body (needs parser)
    headers: req.headers,          // HTTP headers
    cookies: req.cookies,          // Cookies (needs cookie-parser)
    
    // Timing
    timestamp: new Date().toISOString(),
    time: Date.now()
  };
  
  res.json(requestInfo);
});

app.use((req, res, next) => {
  const start = Date.now();
  
  console.log(`[${new Date().toISOString()}]`);
  console.log(`  Method: ${req.method}`);
  console.log(`  URL: ${req.url}`);
  console.log(`  IP: ${req.ip}`);
  console.log(`  User-Agent: ${req.headers['user-agent']}`);
  
  if (Object.keys(req.params).length) {
    console.log(`  Params:`, req.params);
  }
  if (Object.keys(req.query).length) {
    console.log(`  Query:`, req.query);
  }
  if (req.body && Object.keys(req.body).length) {
    console.log(`  Body:`, req.body);
  }
  
  res.on('finish', () => {
    const duration = Date.now() - start;
    console.log(`  Response: ${res.statusCode} - ${duration}ms`);
    console.log('---');
  });
  
  next();
});

app.get('/api/response', (req, res) => {
  // 1. res.send() - Auto-detects content type
  res.send('Hello World');           // text/html
  res.send({ message: 'Hello' });    // application/json
  res.send('<h1>Hello</h1>');        // text/html
  
  // 2. res.json() - Always JSON
  res.json({ message: 'Hello' });
  
  // 3. res.status() - Set HTTP status
  res.status(201).json({ message: 'Created' });
  
  // 4. res.set() - Set headers
  res.set('X-Custom-Header', 'Value');
  res.set({
    'X-Header-1': 'Value1',
    'X-Header-2': 'Value2'
  });
  
  // 5. res.type() - Set Content-Type
  res.type('json');   // application/json
  res.type('html');   // text/html
  res.type('text');   // text/plain
  
  // 6. res.append() - Append to header
  res.append('Link', '<http://localhost/>');
  
  // 7. res.location() - Set Location header
  res.location('/api/users/123');
  
  // 8. res.redirect() - Redirect
  res.redirect('/new-page');
  res.redirect(301, '/permanent-redirect');
  
  // 9. res.sendFile() - Send file
  res.sendFile(__dirname + '/public/index.html');
  
  // 10. res.download() - Download file
  res.download('/path/to/file.pdf', 'custom-name.pdf');
  
  // 11. res.end() - End response (no data)
  res.end();
});

app.get('/api/send-examples', (req, res) => {
  // String → text/html
  res.send('Hello World');
  
  // Object → application/json
  res.send({ name: 'Rahul', age: 25 });
  
  // Array → application/json
  res.send([1, 2, 3, 4, 5]);
  
  // Buffer → application/octet-stream
  const buffer = Buffer.from('Hello');
  res.send(buffer);
  
  // HTML → text/html
  res.send('<h1>Hello</h1><p>World</p>');
  
  // Number → error (use status instead)
  // res.send(404); // ❌ Error!
  res.status(404).send('Not Found'); // ✅ Correct
});

app.get('/api/json-examples', (req, res) => {
  // Simple object
  res.json({ message: 'Hello World' });
  
  // Array
  res.json([1, 2, 3, 4, 5]);
  
  // Nested object
  res.json({
    success: true,
    data: {
      user: { id: 1, name: 'Rahul' },
      posts: [{ id: 1, title: 'Post 1' }]
    },
    timestamp: new Date().toISOString()
  });
  
  // With status
  res.status(201).json({ message: 'Created' });
  
  // Pretty print (in development)
  res.json({ name: 'Rahul', age: 25, city: 'Mumbai' });
});

// utils/response.js
class ApiResponse {
  static success(res, data, message = 'Success', statusCode = 200) {
    return res.status(statusCode).json({
      success: true,
      message,
      data,
      timestamp: new Date().toISOString()
    });
  }
  
  static error(res, message, statusCode = 400, details = null) {
    return res.status(statusCode).json({
      success: false,
      error: {
        message,
        statusCode,
        ...(details && { details })
      },
      timestamp: new Date().toISOString()
    });
  }
  
  static paginated(res, data, page, limit, total, message = 'Success') {
    return res.status(200).json({
      success: true,
      message,
      data,
      pagination: {
        page: parseInt(page),
        limit: parseInt(limit),
        total,
        totalPages: Math.ceil(total / limit),
        hasNext: page * limit < total,
        hasPrev: page > 1
      },
      timestamp: new Date().toISOString()
    });
  }
}

module.exports = ApiResponse;

// Using ApiResponse
const ApiResponse = require('../utils/response');

app.get('/api/users', async (req, res) => {
  const users = await db.users.find();
  ApiResponse.success(res, users, 'Users fetched successfully');
});

app.post('/api/users', async (req, res) => {
  const { name, email } = req.body;
  
  if (!name || !email) {
    return ApiResponse.error(res, 'Name and email required', 400);
  }
  
  const user = await db.users.create({ name, email });
  ApiResponse.success(res, user, 'User created', 201);
});

app.get('/api/users/paginated', async (req, res) => {
  const { page = 1, limit = 10 } = req.query;
  const users = await db.users.find()
    .skip((page - 1) * limit)
    .limit(limit);
  const total = await db.users.countDocuments();
  
  ApiResponse.paginated(res, users, page, limit, total);
});

app.get('/api/status-examples', (req, res) => {
  // 2xx – Success
  res.status(200).json({ message: 'OK' });                    // Success
  res.status(201).json({ message: 'Created' });               // Created
  res.status(202).json({ message: 'Accepted' });              // Accepted
  res.status(204).send();                                      // No Content
  
  // 3xx – Redirection
  res.status(301).redirect('/new-url');                        // Moved Permanently
  res.status(302).redirect('/temporary');                      // Found
  res.status(304).send();                                      // Not Modified
  
  // 4xx – Client Error
  res.status(400).json({ error: 'Bad Request' });              // Bad Request
  res.status(401).json({ error: 'Unauthorized' });             // Unauthorized
  res.status(403).json({ error: 'Forbidden' });                // Forbidden
  res.status(404).json({ error: 'Not Found' });                // Not Found
  res.status(409).json({ error: 'Conflict' });                 // Conflict
  res.status(422).json({ error: 'Unprocessable Entity' });     // Validation error
  res.status(429).json({ error: 'Too Many Requests' });        // Rate limit
  
  // 5xx – Server Error
  res.status(500).json({ error: 'Internal Server Error' });    // Server error
  res.status(502).json({ error: 'Bad Gateway' });              // Bad Gateway
  res.status(503).json({ error: 'Service Unavailable' });      // Service unavailable
});

// utils/statusCodes.js
const HttpStatus = {
  // 2xx
  OK: 200,
  CREATED: 201,
  ACCEPTED: 202,
  NO_CONTENT: 204,
  
  // 3xx
  MOVED_PERMANENTLY: 301,
  FOUND: 302,
  NOT_MODIFIED: 304,
  
  // 4xx
  BAD_REQUEST: 400,
  UNAUTHORIZED: 401,
  FORBIDDEN: 403,
  NOT_FOUND: 404,
  CONFLICT: 409,
  UNPROCESSABLE_ENTITY: 422,
  TOO_MANY_REQUESTS: 429,
  
  // 5xx
  INTERNAL_SERVER_ERROR: 500,
  BAD_GATEWAY: 502,
  SERVICE_UNAVAILABLE: 503
};

module.exports = HttpStatus;

// Using status codes
const HttpStatus = require('../utils/statusCodes');

app.post('/api/users', async (req, res) => {
  const { email } = req.body;
  
  const existingUser = await db.users.findOne({ email });
  if (existingUser) {
    return res.status(HttpStatus.CONFLICT).json({
      error: 'Email already exists'
    });
  }
  
  const user = await db.users.create(req.body);
  res.status(HttpStatus.CREATED).json(user);
});

app.get('/api/custom-headers', (req, res) => {
  // Single header
  res.set('X-Custom-Header', 'CustomValue');
  
  // Multiple headers
  res.set({
    'X-API-Version': '1.0.0',
    'X-RateLimit-Limit': '100',
    'X-RateLimit-Remaining': '95',
    'X-RateLimit-Reset': '1640995200000',
    'Cache-Control': 'no-cache',
    'Content-Security-Policy': "default-src 'self'"
  });
  
  // Append to header
  res.append('Link', '<http://localhost/>');
  res.append('Link', '<http://localhost/api>');
  
  res.json({ message: 'Custom headers set' });
});

// CORS headers
app.use((req, res, next) => {
  res.set({
    'Access-Control-Allow-Origin': '*',
    'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, PATCH',
    'Access-Control-Allow-Headers': 'Content-Type, Authorization',
    'Access-Control-Allow-Credentials': 'true'
  });
  
  if (req.method === 'OPTIONS') {
    return res.sendStatus(200);
  }
  next();
});

app.get('/api/redirect-examples', (req, res) => {
  // Default redirect (302 Found)
  res.redirect('/new-page');
  
  // Permanent redirect (301 Moved Permanently)
  res.redirect(301, '/permanent-page');
  
  // Back to previous page
  res.redirect('back');
  
  // External URL
  res.redirect('https://google.com');
  
  // Relative path
  res.redirect('/api/users');
  
  // With query params
  res.redirect('/login?redirect=/dashboard');
});

// Real-world usage
app.get('/old-products', (req, res) => {
  // SEO friendly permanent redirect
  res.redirect(301, '/api/products');
});

app.get('/github', (req, res) => {
  res.redirect('https://github.com/yourusername');
});

app.get('/login', (req, res) => {
  const { redirect } = req.query;
  
  if (redirect) {
    res.cookie('redirectAfterLogin', redirect);
  }
  
  res.sendFile(__dirname + '/public/login.html');
});

app.post('/login', async (req, res) => {
  // After successful login
  const redirectUrl = req.cookies.redirectAfterLogin || '/dashboard';
  res.clearCookie('redirectAfterLogin');
  res.redirect(redirectUrl);
});

const path = require('path');

app.get('/api/download/:filename', (req, res) => {
  const { filename } = req.params;
  const filePath = path.join(__dirname, 'uploads', filename);
  
  // Download with original name
  res.download(filePath);
  
  // Download with custom name
  res.download(filePath, 'custom-name.pdf');
  
  // Download with options
  res.download(filePath, 'report.pdf', (err) => {
    if (err) {
      console.error('Download error:', err);
      res.status(404).json({ error: 'File not found' });
    }
  });
});

// Generate CSV on the fly
app.get('/api/export/users', async (req, res) => {
  const users = await db.users.find();
  
  let csv = 'ID,Name,Email\n';
  users.forEach(user => {
    csv += `${user.id},${user.name},${user.email}\n`;
  });
  
  res.setHeader('Content-Type', 'text/csv');
  res.setHeader('Content-Disposition', 'attachment; filename=users.csv');
  res.send(csv);
});

// Generate PDF report
app.get('/api/export/report', async (req, res) => {
  const PDFDocument = require('pdfkit');
  const doc = new PDFDocument();
  
  res.setHeader('Content-Type', 'application/pdf');
  res.setHeader('Content-Disposition', 'attachment; filename=report.pdf');
  
  doc.pipe(res);
  doc.fontSize(25).text('Monthly Report', { align: 'center' });
  doc.moveDown();
  doc.fontSize(12).text(`Generated on: ${new Date().toLocaleDateString()}`);
  doc.end();
});

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

// ✅ Add body parser
app.use(express.json());
app.post('/api/users', (req, res) => {
  console.log(req.body); // Works!
});

// ❌ Wrong – mixing params and query
app.get('/api/users/:id?page=2', (req, res) => {
  // This doesn't work!
});

// ✅ Correct – params for dynamic URL, query for filters
app.get('/api/users/:id', (req, res) => {
  const id = req.params.id;      // URL parameter
  const page = req.query.page;    // Query parameter
});

// ❌ Error: Cannot set headers after they are sent
app.get('/api/users/:id', (req, res) => {
  res.json({ message: 'First' });
  res.json({ message: 'Second' }); // Error!
});

// ✅ Send once
app.get('/api/users/:id', (req, res) => {
  res.json({ message: 'Only once' });
});

// ❌ No error handling
app.get('/api/users/:id', (req, res) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  res.json(user); // If user not found, sends null
});

// ✅ Handle not found
app.get('/api/users/:id', (req, res) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  
  if (!user) {
    return res.status(404).json({ error: 'User not found' });
  }
  
  res.json(user);
});