// routes/users.js
router.get('/:id', userController.getById);

// controllers/userController.js
exports.getById = async (req, res) => {
  const user = await userService.findById(req.params.id);
  if (!user) throw new NotFoundError('用户');
  res.json({ data: user });
};

// services/userService.js
exports.findById = async (id) => {
  const user = await userRepo.findById(id);
  return user;
};

// repositories/userRepository.js
exports.findById = async (id) => {
  return prisma.user.findUnique({ where: { id: Number(id) } });
};

npm install -D eslint @eslint/js prettier eslint-config-prettier

// eslint.config.js（Flat Config，ESLint 9+）
const js = require('@eslint/js');
const prettier = require('eslint-config-prettier');

module.exports = [
  js.configs.recommended,
  prettier,
  {
    languageOptions: {
      ecmaVersion: 2024,
      sourceType: 'commonjs',
      globals: {
        console: 'readonly',
        process: 'readonly',
        __dirname: 'readonly',
        module: 'readonly',
        require: 'readonly',
        exports: 'readonly',
      },
    },
    rules: {
      'no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
      'no-console': ['warn', { allow: ['warn', 'error'] }],
      'eqeqeq': 'error',
      'no-var': 'error',
      'prefer-const': 'error',
      'prefer-template': 'warn',
      'no-throw-literal': 'error',
      'no-return-await': 'error',
      'require-await': 'error',
    },
  },
];

// .prettierrc
{
  "semi": true,
  "singleQuote": true,
  "trailingComma": "all",
  "printWidth": 100,
  "tabWidth": 2,
  "endOfLine": "lf"
}

npm install -D husky lint-staged
npx husky init

// package.json
{
  "lint-staged": {
    "*.js": ["eslint --fix", "prettier --write"],
    "*.{json,md}": ["prettier --write"]
  }
}

# .husky/pre-commit
npx lint-staged

// config/index.js
require('dotenv').config();

const config = {
  env: process.env.NODE_ENV || 'development',
  port: Number(process.env.PORT) || 3000,
  
  database: {
    host: process.env.DB_HOST || 'localhost',
    port: Number(process.env.DB_PORT) || 5432,
    user: process.env.DB_USER || 'postgres',
    password: process.env.DB_PASSWORD || '',
    name: process.env.DB_NAME || 'mydb',
  },
  
  redis: {
    url: process.env.REDIS_URL || 'redis://localhost:6379',
  },
  
  jwt: {
    secret: process.env.JWT_SECRET,
    expiresIn: process.env.JWT_EXPIRES || '24h',
  },
  
  log: {
    level: process.env.LOG_LEVEL || 'info',
  },
};

// 启动时验证必需的配置
const required = ['JWT_SECRET', 'DATABASE_URL'];
for (const key of required) {
  if (!process.env[key]) {
    console.error(`缺少必需的环境变量: ${key}`);
    process.exit(1);
  }
}

module.exports = config;

{
  "scripts": {
    "audit": "npm audit",
    "audit:fix": "npm audit fix",
    "outdated": "npm outdated",
    "update:patch": "npm update",
    "update:minor": "npx npm-check-updates -u --target minor",
    "dedupe": "npm dedupe"
  }
}

// 结构化日志
logger.info({
  event: 'request',
  method: req.method,
  path: req.url,
  status: res.statusCode,
  duration: Date.now() - start,
  requestId: req.id,
  userId: req.user?.id,
  ip: req.ip,
  userAgent: req.headers['user-agent'],
});

// 健康检查端点
app.get('/health', async (req, res) => {
  const checks = {
    uptime: process.uptime(),
    status: 'ok',
    timestamp: new Date().toISOString(),
    checks: {
      database: await checkDatabase(),
      redis: await checkRedis(),
      memory: process.memoryUsage(),
    },
  };

  const isHealthy = Object.values(checks.checks).every(c => c.status === 'ok');
  res.status(isHealthy ? 200 : 503).json(checks);
});

// ❌ 反模式 1：回调地狱
fs.readFile('a', (err, a) => {
  fs.readFile('b', (err, b) => {
    fs.readFile('c', (err, c) => { });
  });
});

// ✅ 使用 async/await
const [a, b, c] = await Promise.all([
  fs.promises.readFile('a'),
  fs.promises.readFile('b'),
  fs.promises.readFile('c'),
]);

// ❌ 反模式 2：吞掉错误
try {
  await doSomething();
} catch (err) { } // 空 catch！

// ✅ 至少记录日志
try {
  await doSomething();
} catch (err) {
  logger.error({ err }, '操作失败');
  throw err; // 或者返回降级结果
}

// ❌ 反模式 3：回调和 Promise 混用
function bad(data, callback) {
  return new Promise((resolve, reject) => {
    try {
      const result = process(data);
      callback(null, result);   // 回调
      resolve(result);          // 又 resolve
    } catch (err) {
      callback(err);            // 回调
      reject(err);              // 又 reject
    }
  });
}

// ❌ 反模式 4：无限制的并发
for (const url of urls) {
  await fetch(url); // 顺序执行，太慢
}

// ❌ 反模式 5：每次请求都创建实例
app.get('/api/data', async (req, res) => {
  const client = new MongoClient(url); // 每次创建新连接！
  await client.connect();
});

// ✅ 使用连接池/单例
const client = new MongoClient(url);
await client.connect();