// JavaScript 内置错误类型
const errors = [
  new Error('通用错误'),
  new TypeError('类型错误'),
  new ReferenceError('引用错误'),
  new RangeError('范围错误'),
  new SyntaxError('语法错误'),
  new URIError('URI 错误'),
];

// Node.js 特有错误
const nodeErrors = [
  new EvalError('eval 错误'),
  // SystemError — 系统级错误（文件不存在、网络超时等）
];

// 基础自定义错误
class AppError extends Error {
  constructor(message, statusCode = 500, code = 'INTERNAL_ERROR') {
    super(message);
    this.name = 'AppError';
    this.statusCode = statusCode;
    this.code = code;
    this.isOperational = true; // 可预期的错误
    Error.captureStackTrace(this, this.constructor);
  }
}

// 业务错误类
class ValidationError extends AppError {
  constructor(message, details = []) {
    super(message, 400, 'VALIDATION_ERROR');
    this.name = 'ValidationError';
    this.details = details;
  }
}

class NotFoundError extends AppError {
  constructor(resource, id) {
    super(`${resource} 不存在 (ID: ${id})`, 404, 'NOT_FOUND');
    this.name = 'NotFoundError';
  }
}

class UnauthorizedError extends AppError {
  constructor(message = '未授权') {
    super(message, 401, 'UNAUTHORIZED');
    this.name = 'UnauthorizedError';
  }
}

class ForbiddenError extends AppError {
  constructor(message = '权限不足') {
    super(message, 403, 'FORBIDDEN');
    this.name = 'ForbiddenError';
  }
}

class ConflictError extends AppError {
  constructor(message) {
    super(message, 409, 'CONFLICT');
    this.name = 'ConflictError';
  }
}

// 使用
throw new ValidationError('参数验证失败', [
  { field: 'email', message: '邮箱格式不正确' },
  { field: 'name', message: '名称不能为空' },
]);

throw new NotFoundError('用户', 123);

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

// 异步路由包装器
const asyncHandler = (fn) => (req, res, next) => {
  Promise.resolve(fn(req, res, next)).catch(next);
};

// 路由示例
app.get('/api/users/:id', asyncHandler(async (req, res) => {
  const user = await db.users.findById(req.params.id);
  if (!user) {
    throw new NotFoundError('用户', req.params.id);
  }
  res.json({ data: user });
}));

app.post('/api/users', asyncHandler(async (req, res) => {
  const { valid, errors } = validateUser(req.body);
  if (!valid) {
    throw new ValidationError('参数验证失败', errors);
  }
  const user = await db.users.create(req.body);
  res.status(201).json({ data: user });
}));

// 404 处理（放在所有路由之后）
app.use((req, res) => {
  res.status(404).json({
    error: { code: 'NOT_FOUND', message: `Cannot ${req.method} ${req.url}` },
  });
});

// 全局错误处理中间件（放在最后）
app.use((err, req, res, next) => {
  // 日志记录
  const logger = req.log || console;
  
  if (err.isOperational) {
    // 可预期的业务错误 — warn 级别
    logger.warn({ err, requestId: req.id }, err.message);
  } else {
    // 不可预期的系统错误 — error 级别，需要报警
    logger.error({ err, requestId: req.id }, err.message);
    // 通知监控系统（Sentry 等）
  }

  const statusCode = err.statusCode || 500;
  const response = {
    error: {
      code: err.code || 'INTERNAL_ERROR',
      message: err.isOperational ? err.message : '服务器内部错误',
      ...(err.details && { details: err.details }),
      ...(process.env.NODE_ENV !== 'production' && !err.isOperational && { stack: err.stack }),
    },
  };

  res.status(statusCode).json(response);
});

const logger = require('./logger');

// 未捕获的同步异常
process.on('uncaughtException', (err, origin) => {
  logger.fatal({ err, origin }, '未捕获的异常');
  // 记录日志后优雅退出
  process.exit(1);
});

// 未处理的 Promise 拒绝
process.on('unhandledRejection', (reason, promise) => {
  logger.fatal({ reason, promise }, '未处理的 Promise 拒绝');
  // Node.js 15+ 会导致进程崩溃，建议主动退出
  process.exit(1);
});

// 警告事件
process.on('warning', (warning) => {
  logger.warn({ warning }, 'Node.js 警告');
});

const server = require('./app').listen(3000);

// 优雅退出函数
async function gracefulShutdown(signal) {
  logger.info({ signal }, '收到关闭信号，开始优雅退出...');

  // 1. 停止接收新连接
  server.close(() => {
    logger.info('HTTP 服务器已关闭');
  });

  // 2. 等待正在处理的请求完成（设置超时）
  const forceExitTimeout = setTimeout(() => {
    logger.error('强制退出（超时）');
    process.exit(1);
  }, 30000); // 30 秒超时

  // 3. 关闭数据库连接
  try {
    await db.disconnect();
    logger.info('数据库连接已关闭');
  } catch (err) {
    logger.error({ err }, '关闭数据库连接失败');
  }

  // 4. 关闭 Redis 连接
  try {
    await redis.quit();
    logger.info('Redis 连接已关闭');
  } catch (err) {
    logger.error({ err }, '关闭 Redis 连接失败');
  }

  // 5. 清理定时器
  clearTimeout(forceExitTimeout);

  logger.info('优雅退出完成');
  process.exit(0);
}

// 监听退出信号
process.on('SIGTERM', () => gracefulShutdown('SIGTERM')); // Docker/K8s 发送
process.on('SIGINT', () => gracefulShutdown('SIGINT'));   // Ctrl+C

# Dockerfile
# 使用 exec 形式确保 Node.js 进程是 PID 1
CMD ["node", "src/server.js"]
# 而不是
# CMD node src/server.js  # shell 形式，PID 1 是 sh，不传递信号