《TypeScript编程实战》5.2 中间件与请求上下文

import { Hono } from 'hono'
import type { MiddlewareHandler } from 'hono'

const timing: MiddlewareHandler = async (c, next) => {
  const start = performance.now()
  console.log('→ 进入', c.req.path)

  await next()   // 交出控制权，等待下游全部执行完

  const ms = (performance.now() - start).toFixed(2)
  c.header('x-response-time', `${ms}ms`)
  console.log('← 离开', c.req.path, `${ms}ms`)
}

const app = new Hono()
app.use('*', timing)

app.addHook('onRequest', async (req) => {
  // 最早执行：请求已到达，body 尚未解析
  // 适合：请求 ID 注入、限流、IP 黑名单
})

app.addHook('preParsing', async (req) => {
  // body 流已就绪但尚未解析
})

app.addHook('preHandler', async (req, reply) => {
  // body / query / params 均已解析并校验通过
  // 适合：鉴权、权限校验、事务开启
})

app.addHook('onSend', async (req, reply, payload) => {
  // 响应即将发出，可改写 header 或 payload
  return payload
})

app.addHook('onResponse', async (req, reply) => {
  // 响应已发出，适合记录耗时
})

import { AsyncLocalStorage } from 'node:async_hooks'
import { randomUUID } from 'node:crypto'

export interface RequestContext {
  requestId: string
  userId?: string
  startedAt: number
}

export const als = new AsyncLocalStorage<RequestContext>()

export function currentContext(): RequestContext | undefined {
  return als.getStore()
}

// Fastify 插件：为每个请求建立独立上下文
app.addHook('onRequest', async (req) => {
  const ctx: RequestContext = {
    requestId: req.headers['x-request-id'] as string ?? randomUUID(),
    startedAt: Date.now(),
  }
  // run 之后的整个异步调用链都能读到这个 store
  return als.run(ctx, async () => {
    req.log = req.log.child({ requestId: ctx.requestId })
  })
})

import { als } from './context'

export function log(level: 'info' | 'error', msg: string, extra: object = {}) {
  const ctx = als.getStore()
  const line = JSON.stringify({
    level,
    msg,
    requestId: ctx?.requestId ?? '-',
    userId: ctx?.userId ?? '-',
    ...extra,
  })
  process.stdout.write(line + '\n')
}

import type { FastifyRequest } from 'fastify'

interface AuthUser {
  id: string
  roles: Array<'admin' | 'user'>
}

// 声明合并：让 req.user 在所有 handler 里都有类型
declare module 'fastify' {
  interface FastifyRequest {
    user?: AuthUser
  }
}

app.decorateRequest('user', undefined)

app.addHook('preHandler', async (req, reply) => {
  const token = req.headers.authorization?.replace(/^Bearer\s+/i, '')
  if (!token) {
    return reply.code(401).send({ message: '缺少凭证' })
  }

  const payload = verifyToken(token)   // 失败会抛出，交给错误处理器
  req.user = { id: payload.sub, roles: payload.roles }
})

app.get('/me', async (req) => {
  // 类型上 user 是可选，需要收窄；用断言函数把它变成必需
  const user = req.user
  if (!user) throw new Error('unreachable: 鉴权钩子应已拦截')
  return user
})

function authed<P extends Record<string, unknown>>(
  schema: P,
  handler: (req: FastifyRequest<{ Params: P }>, user: AuthUser) => Promise<unknown>,
) {
  return {
    schema,
    handler: async (req: FastifyRequest<{ Params: P }>) => {
      if (!req.user) throw new Error('unreachable')
      return handler(req, req.user)
    },
  }
}

import rateLimit from '@fastify/rate-limit'

await app.register(rateLimit, {
  max: 100,
  timeWindow: '1 minute',
  keyGenerator: (req) => req.user?.id ?? req.ip,
  errorResponseBuilder: (req, ctx) => ({
    message: `请求过于频繁，请 ${ctx.after} 后重试`,
    retryAfter: ctx.after,
  }),
})

app.setErrorHandler((err, req, reply) => {
  req.log.error({ err }, '请求处理失败')

  // 业务错误：显式分类，对外暴露细节
  if (err instanceof AppError) {
    return reply.code(err.status).send({
      code: err.code,
      message: err.message,
      requestId: currentContext()?.requestId,
    })
  }

  // 校验错误：Fastify 自带 statusCode 400
  if (err.validation) {
    return reply.code(400).send({ code: 'VALIDATION', message: err.message })
  }

  // 未知错误：不泄漏堆栈，只回 requestId 便于对账
  return reply.code(500).send({
    code: 'INTERNAL',
    message: '服务器内部错误',
    requestId: currentContext()?.requestId,
  })
})