Error Handling

// Synchronous throw — Express catches this in routes (NOT in async code)
app.get('/sync', (req, res) => {
  throw new Error('Sync error'); // caught by Express 4 for sync handlers only
});

// next(err) — works everywhere, always preferred
app.get('/data', async (req, res, next) => {
  try {
    const data = await db.query();
    res.json(data);
  } catch (err) {
    next(err); // forward to error handler
  }
});

// Pass an HTTP status with the error
app.get('/secret', (req, res, next) => {
  const err = new Error('Forbidden');
  err.status = 403;
  next(err);
});

// Minimal error handler
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(err.status || 500).json({
    error: {
      message: err.message,
      ...(process.env.NODE_ENV !== 'production' && { stack: err.stack }),
    },
  });
});

class AppError extends Error {
  constructor(message, status = 500, code = 'INTERNAL_ERROR') {
    super(message);
    this.name = 'AppError';
    this.status = status;
    this.code   = code;
  }
}

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

class ValidationError extends AppError {
  constructor(details) {
    super('Validation failed', 400, 'VALIDATION_ERROR');
    this.details = details;
  }
}

class UnauthorizedError extends AppError {
  constructor(msg = 'Unauthorized') {
    super(msg, 401, 'UNAUTHORIZED');
  }
}

app.get('/users/:id', async (req, res, next) => {
  try {
    const user = await db.users.findById(req.params.id);
    if (!user) throw new NotFoundError('User');
    res.json(user);
  } catch (err) { next(err); }
});

app.use((err, req, res, next) => {
  // Log every error with context
  console.error({
    message: err.message,
    status:  err.status,
    stack:   err.stack,
    url:     req.originalUrl,
    method:  req.method,
    ip:      req.ip,
  });

  // Operational errors: known, expected
  if (err instanceof AppError) {
    return res.status(err.status).json({
      error: {
        code:    err.code,
        message: err.message,
        ...(err.details && { details: err.details }),
      },
    });
  }

  // Programmer/unexpected errors: don't leak details
  res.status(500).json({ error: { code: 'INTERNAL_ERROR', message: 'Something went wrong' } });
});

const asyncHandler = fn => (req, res, next) =>
  Promise.resolve(fn(req, res, next)).catch(next);

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

// Alternative: wrap all routes in a router
const asyncRouter = express.Router();
['get', 'post', 'put', 'patch', 'delete'].forEach(method => {
  const original = asyncRouter[method].bind(asyncRouter);
  asyncRouter[method] = (path, ...handlers) => {
    original(path, ...handlers.map(h =>
      h.length === 4 ? h : (req, res, next) => Promise.resolve(h(req, res, next)).catch(next)
    ));
  };
});

// 1. Handle Multer file upload errors
app.use((err, req, res, next) => {
  if (err.code === 'LIMIT_FILE_SIZE') {
    return res.status(413).json({ error: 'File too large' });
  }
  next(err);
});

// 2. Handle database constraint errors (e.g., pg)
app.use((err, req, res, next) => {
  if (err.code === '23505') { // unique_violation in PostgreSQL
    return res.status(409).json({ error: 'Resource already exists' });
  }
  next(err);
});

// 3. Final catch-all
app.use((err, req, res, next) => {
  res.status(err.status || 500).json({ error: err.message });
});

// 404 — after all routes, before error handler
app.use((req, res, next) => {
  res.status(404).json({
    error: { code: 'NOT_FOUND', message: `Cannot ${req.method} ${req.path}` },
  });
});

// Or: create an error and forward it to the error handler
app.use((req, res, next) => {
  next(new NotFoundError(`Route ${req.method} ${req.path}`));
});

app.use((err, req, res, next) => {
  if (res.headersSent) {
    return next(err); // delegate to default Express error handler if headers already sent
  }
  res.status(500).json({ error: err.message });
});

const winston = require('winston');

app.use((err, req, res, next) => {
  winston.error({
    message: err.message,
    level:   err.status < 500 ? 'warn' : 'error',
    status:  err.status,
    method:  req.method,
    path:    req.originalUrl,
    ip:      req.ip,
    userId:  req.user?.id,
  });
  res.status(err.status || 500).json({ error: err.message });
});