TypeScript

Fastify 框架使用纯 JavaScript 编写，因此类型定义的维护并不容易；然而，从版本 2 开始，维护者和贡献者已经付出了巨大的努力来改进类型。

在 Fastify 版本 3 中更改了类型系统。新的类型系统引入了泛型约束和默认值，并且提供了一种新方法来定义模式类型，例如请求体、查询字符串等！随着团队致力于提高框架与类型定义的协同作用，有时 API 的某些部分可能没有类型或类型不正确。我们鼓励您贡献来帮助我们填补这些空白。请务必在开始之前阅读我们的 CONTRIBUTING.md 文件以确保一切顺利！

本节文档涵盖 Fastify 版本 3.x 的类型定义

插件可能包含或不包含类型定义。有关更多信息，请参阅插件。我们鼓励用户提交拉取请求来改进类型支持。

🚨 别忘了安装 @types/node

通过示例学习

了解 Fastify 类型系统的最佳方式是通过示例！以下四个示例如下，涵盖了最常见的 Fastify 开发场景。在示例之后提供了更详细、深入的类型系统文档。

开始使用

本示例将帮助您快速入门 Fastify 和 TypeScript。它会创建一个空白的 http Fastify 服务器。

创建一个新的 npm 项目，安装 Fastify，并作为同级依赖安装 typescript 和 Node.js 类型：


npm init -y
npm i fastify
npm i -D typescript @types/node

在 package.json 的 "scripts" 部分添加以下内容：


{
  "scripts": {
    "build": "tsc -p tsconfig.json",
    "start": "node index.js"
  }
}

初始化一个TypeScript配置文件：


npx tsc --init

或者使用其中一个推荐的。

注意：在tsconfig.json中将target属性设置为es2017或更高版本，以避免出现FastifyDeprecation 警告。

创建一个 index.ts 文件 - 这个文件将包含服务器代码

将以下代码块添加到你的文件中：


import fastify from 'fastify'
 
const server = fastify()
 
server.get('/ping', async (request, reply) => {
  return 'pong\n'
})
 
server.listen({ port: 8080 }, (err, address) => {
  if (err) {
    console.error(err)
    process.exit(1)
  }
  console.log(`Server listening at ${address}`)
})

运行 npm run build - 这将把 index.ts 编译成 index.js，可以使用Node.js执行。如果你遇到任何错误，请在fastify/help 中打开一个问题。
运行 npm run start 来启动Fastify服务器
你应该会在控制台看到 Server listening at http://127.0.0.1:8080
使用 curl localhost:8080/ping 测试你的服务器，它应该返回 pong 🏓

🎉 现在你已经有一个可以工作的TypeScript Fastify服务器！这个示例展示了3.x版本类型系统的简洁性。默认情况下，类型系统假设你在使用一个http服务器。后续的示例将展示如何创建更复杂的服务器（如https和http2），如何指定路由模式等！

有关使用TypeScript初始化Fastify的更多示例（例如启用HTTP2），请参阅此处详细API部分。

使用泛型

类型系统高度依赖于泛型属性来提供最准确的开发体验。虽然有些人可能会觉得这种开销有点繁琐，但权衡是值得的！本示例将深入介绍如何为路由模式和位于路由级 request 对象上的动态属性实现泛型类型。

如果您没有完成上一个示例，请按照步骤 1-4 进行设置。
在 index.ts 中，定义三个接口 IQuerystring, IHeaders 和 IReply：


 interface IQuerystring {
   username: string;
   password: string;
 }
 
 interface IHeaders {
   'h-Custom': string;
 }
 
 interface IReply {
   200: { success: boolean };
   302: { url: string };
   '4xx': { error: string };
 }

使用这三个接口，定义一个新的 API 路由并将它们作为泛型传递。简写路由方法（例如 .get）接受一个包含五个命名属性的泛型对象 RouteGenericInterface：Body, Querystring, Params, Headers 和 Reply。接口 Body, Querystring, Params 和 Headers 将通过路由方法传递到路由方法处理程序 request 实例，而 Reply 接口将传递给 reply 实例。


 server.get<{
   Querystring: IQuerystring,
   Headers: IHeaders,
   Reply: IReply
 }>('/auth', async (request, reply) => {
   const { username, password } = request.query;
   const customerHeader = request.headers['h-Custom'];
   // 对请求数据进行操作
 
   // 使用 .statusCode/.code 调用链允许类型缩小。例如：
   // 这个可以工作
   reply.code(200).send({ success: true });
   // 但是这个会引发类型错误
   reply.code(200).send('uh-oh');
   // 即使对于通配符也有效
   reply.code(404).send({ error: 'Not found' });
   return `已登录！`
 })

使用 npm run build 和 npm run start 构建并运行服务器代码
查询 API


 curl localhost:8080/auth?username=admin&password=Password123!

它应该返回 已登录! 6. 但等等，还有更多！通用接口也可以在路由级别的钩子方法中使用。通过添加一个 preValidation 钩子来修改之前的路由：


server.get<{
  Querystring: IQuerystring,
  Headers: IHeaders,
  Reply: IReply
}>('/auth', {
  preValidation: (request, reply, done) => {
    const { username, password } = request.query
    done(username !== 'admin' ? new Error('必须是管理员') : undefined) // 只验证 `admin` 账户
  }
}, async (request, reply) => {
  const customerHeader = request.headers['h-Custom']
  // 对请求数据进行处理
  return `已登录!`
})

构建并运行，然后使用不同于 admin 的 username 查询字符串选项来查询 API。API 现在应该返回一个 HTTP 500 错误 {"statusCode":500,"error":"内部服务器错误","message":"必须是管理员"}

🎉 很好，现在你可以为每个路由定义接口，并拥有严格类型化的请求和响应实例。Fastify 类型系统的其他部分依赖于泛型属性。请参考下面的详细类型系统文档以了解更多信息。

JSON Schema

为了验证您的请求和响应，您可以使用JSON Schema文件。如果您还不知道的话，为Fastify路由定义模式可以提高它们的吞吐量！更多相关信息请参阅验证与序列化文档。

此外，它还具有在处理程序中使用已定义类型的优点（包括预验证等）。

以下是一些实现此功能的方法。

Fastify 类型提供器

Fastify 提供了两个包装 json-schema-to-ts 和 typebox 的包：

还有一个由第三方提供的名为fastify-type-provider-zod的 zod 包装器。

它们简化了模式验证设置，您可以在类型提供器页面上了解更多关于它们的信息。

下面是使用 typebox、json-schema-to-typescript 和 json-schema-to-ts 包进行模式验证设置的方法（不使用类型提供器）。

TypeBox

一个有用的库，用于同时构建类型和模式的是 TypeBox 。使用 TypeBox 可以在代码中定义您的模式，并根据需要直接将其用作类型或模式。

当您想在一个 fastify 路由中验证某些负载时，可以按照以下步骤操作：

在项目中安装 typebox。


  npm i @sinclair/typebox

使用 Type 定义所需的模式，并使用 Static 创建相应的类型。


  import { Static, Type } from '@sinclair/typebox'
 
  export const User = Type.Object({
    name: Type.String(),
    mail: Type.Optional(Type.String({ format: 'email' })),
  })
 
  export type UserType = Static<typeof User>

在定义路由时使用已定义的类型和模式


import Fastify from 'fastify'
// ...
 
const fastify = Fastify()
 
fastify.post<{ Body: UserType, Reply: UserType }>(
  '/',
  {
    schema: {
      body: User,
      response: {
        200: User
      },
    },
  },
  (request, reply) => {
    // `name` 和 `mail` 类型会自动推断出来
    const { name, mail } = request.body;
    reply.status(200).send({ name, mail });
  }
)

json-schema-to-typescript

在上一个示例中，我们使用了 Typebox 来定义路由的类型和模式。许多用户已经在使用 JSON Schema 来定义这些属性，并且幸运的是有一种方法可以将现有的 JSON Schema 转换为 TypeScript 接口！

如果您没有完成“入门”示例，请返回并先执行步骤 1-4。
安装 json-schema-to-typescript 模块：


 npm i -D json-schema-to-typescript

创建一个名为 schemas 的新文件夹，并添加两个文件 headers.json 和 querystring.json。将以下模式定义复制并粘贴到相应的文件中：


 {
   "title": "Headers Schema",
   "type": "object",
   "properties": {
     "h-Custom": { "type": "string" }
   },
   "additionalProperties": false,
   "required": ["h-Custom"]
 }


 {
   "title": "Querystring Schema",
   "type": "object",
   "properties": {
     "username": { "type": "string" },
     "password": { "type": "string" }
   },
   "additionalProperties": false,
   "required": ["username", "password"]
 }

在 package.json 中添加一个 compile-schemas 脚本：


{
  "scripts": {
    "compile-schemas": "json2ts -i schemas -o types"
  }
}

json2ts 是一个包含在 json-schema-to-typescript 中的 CLI 工具。schemas 是输入路径，而 types 是输出路径。 5. 运行 npm run compile-schemas。应在 types 目录中创建两个新的文件。 6. 更新 index.ts 以包含以下代码：


   import fastify from 'fastify'
 
   // 正常导入 json 模式
   import QuerystringSchema from './schemas/querystring.json'
   import HeadersSchema from './schemas/headers.json'
 
   // 导入生成的接口
   import { QuerystringSchema as QuerystringSchemaInterface } from './types/querystring'
   import { HeadersSchema as HeadersSchemaInterface } from './types/headers'
 
   const server = fastify()
 
   server.get<{
     Querystring: QuerystringSchemaInterface,
     Headers: HeadersSchemaInterface
   }>('/auth', {
     schema: {
       querystring: QuerystringSchema,
       headers: HeadersSchema
     },
     preValidation: (request, reply, done) => {
       const { username, password } = request.query
       done(username !== 'admin' ? new Error('必须是管理员') : undefined)
     }
     // 或者如果使用异步方法
     //  preValidation: async (request, reply) => {
     //    const { username, password } = request.query
     //    if (username !== "admin") throw new Error("必须是管理员");
     //  }
   }, async (request, reply) => {
     const customerHeader = request.headers['h-Custom']
     // 对请求数据进行处理
     return `已登录！`
   })


server.route<{
     Querystring: QuerystringSchemaInterface,
     Headers: HeadersSchemaInterface
   }>({
     method: 'GET',
     url: '/auth2',
     schema: {
       querystring: QuerystringSchema,
       headers: HeadersSchema
     },
     preHandler: (request, reply, done) => {
       const { username, password } = request.query
       const customerHeader = request.headers['h-Custom']
       done()
     },
     handler: (request, reply) => {
       const { username, password } = request.query
       const customerHeader = request.headers['h-Custom']
       reply.status(200).send({username});
     }
   })
 
server.listen({ port: 8080 }, (err, address) => {
     if (err) {
       console.error(err)
       process.exit(0)
     }
     console.log(`服务器正在监听 ${address}`)
   })

特别注意文件顶部的导入语句。虽然看起来有些冗余，但你需要同时导入模式文件和生成的接口。

做得很好！现在你可以使用 JSON 模式和 TypeScript 定义了。

json-schema-to-ts

如果您不想从模式生成类型，而是希望直接在代码中使用它们，可以使用包 json-schema-to-ts 。

您可以将其安装为开发依赖项。


npm i -D json-schema-to-ts

在您的代码中，您可以像定义普通对象一样定义模式。但请注意，如模块文档所述，需要将它声明为 const 类型。


const todo = {
  type: 'object',
  properties: {
    name: { type: 'string' },
    description: { type: 'string' },
    done: { type: 'boolean' },
  },
  required: ['name'],
} as const; // 不要忘记使用 const !

通过提供的类型 FromSchema，您可以从模式构建一个类型，并在处理程序中使用它。


import { FromSchema } from "json-schema-to-ts";
fastify.post<{ Body: FromSchema<typeof todo> }>(
  '/todo',
  {
    schema: {
      body: todo,
      response: {
        201: {
          type: 'string',
        },
      },
    }
  },
  async (request, reply): Promise<void> => {
 
    /*
    request.body 的类型为
    {
      [x: string]: unknown;
      description?: string;
      done?: boolean;
      name: string;
    }
    */
 
    request.body.name // 不会抛出类型错误
    request.body.notthere // 会抛出类型错误
 
    reply.status(201).send();
  },
);

插件

Fastify 最具辨识度的功能之一是其庞大的插件生态系统。Fastify 支持各种类型的插件，并利用了声明合并模式（声明合并）。本示例分为三个部分：创建一个 TypeScript Fastify 插件、为 Fastify 插件创建类型定义，以及在 TypeScript 项目中使用 Fastify 插件。

创建一个TypeScript Fastify插件

初始化一个新的npm项目并安装所需的依赖项


 npm init -y
 npm i fastify fastify-plugin
 npm i -D typescript @types/node

在package.json文件的 "scripts"部分添加一个 build 脚本，并在 "types" 部分添加 'index.d.ts'
```
{
  "types": "index.d.ts",
  "scripts": {
    "build": "tsc -p tsconfig.json"
  }
}
```


3. 初始化一个TypeScript配置文件：
```bash
 npx typescript --init

文件生成后，在 "compilerOptions" 对象中启用 "declaration" 选项。


 {
   "compilerOptions": {
     "declaration": true
   }
 }

创建一个 index.ts 文件 - 这个文件将包含插件代码
将以下代码添加到 index.ts


 import { FastifyPluginCallback, FastifyPluginAsync } from 'fastify'
 import fp from 'fastify-plugin'
 
 // 使用声明合并，向适当的 fastify 接口添加您的插件属性
 // 如果在这里定义了属性类型，则在调用 decorate{,Request,Reply} 时会进行类型检查
 declare module 'fastify' {
   interface FastifyRequest {
     myPluginProp: string
   }
   interface FastifyReply {
     myPluginProp: number
   }
 }
 
 // 定义选项
 export interface MyPluginOptions {
   myPluginOption: string
 }
 
 // 使用回调定义插件
 const myPluginCallback: FastifyPluginCallback<MyPluginOptions> = (fastify, options, done) => {
   fastify.decorateRequest('myPluginProp', 'super_secret_value')
   fastify.decorateReply('myPluginProp', options.myPluginOption)
 
   done()
 }
 
 // 使用 promise 定义插件
 const myPluginAsync: FastifyPluginAsync<MyPluginOptions> = async (fastify, options) => {
   fastify.decorateRequest('myPluginProp', 'super_secret_value')
   fastify.decorateReply('myPluginProp', options.myPluginOption)
 }

// 使用 fastify-plugin 导出插件


export default fp(myPluginCallback, '3.x')

或者


// export default fp(myPluginAsync, '3.x')

运行 npm run build 编译插件代码，生成 JavaScript 源文件和类型定义文件。
完成插件后，您可以发布到 npm 或本地使用。

您不需要将插件发布到 npm 才能使用它。您可以在 Fastify 项目中包含它，并像引用任何代码一样引用它！作为 TypeScript 用户，请确保声明覆盖存在于您的项目编译过程中会包含的某个位置，以便 TypeScript 解释器可以处理它。

注意：锚点链接中的“publish to npm”需要根据上下文翻译为“发布到-npm”，并替换为实际中文标题对应的格式。

为 Fastify 插件创建类型定义

本指南适用于用 JavaScript 编写的 Fastify 插件。以下步骤介绍了如何为使用您插件的用户提供 TypeScript 支持。

初始化一个新的 npm 项目并安装所需的依赖项


 npm init -y
 npm i fastify-plugin

创建两个文件 index.js 和 index.d.ts
修改 package.json 文件，将这些文件包含在 main 和 types 属性下（名称不必显式为 index，但建议使用相同的文件名）：


 {
   "main": "index.js",
   "types": "index.d.ts"
 }

打开 index.js 并添加以下代码：


 // 对于您编写的任何插件，强烈建议使用 fastify-plugin
 const fp = require('fastify-plugin')
 
 function myPlugin (instance, options, done) {
 
   // 使用名为 myPluginFunc 的自定义函数装饰 Fastify 实例
   instance.decorate('myPluginFunc', (input) => {
     return input.toUpperCase()
   })
 
   done()
 }
 
 module.exports = fp(myPlugin, {
   fastify: '5.x',
   name: 'my-plugin' // 此名称由 fastify-plugin 用于推导属性名
 })

打开 index.d.ts 并添加以下代码：


 import { FastifyPluginCallback } from 'fastify'
 
 interface PluginOptions {
   //...
 }
 
 // 可选地，您可以添加任何其他导出。
 // 在这里我们导出了我们添加的装饰器。
 export interface myPluginFunc {
   (input: string): string
 }
 
 // 最重要的是，使用声明合并将自定义属性添加到 Fastify 类型系统中
 declare module 'fastify' {
   interface FastifyInstance {
     myPluginFunc: myPluginFunc
   }
 }
 
  // fastify-plugin 自动添加命名导出，因此请确保也添加以下类型声明
 // 变量名由 `options.name` 属性派生而来，如果缺少 `module.exports.myPlugin`
 export const myPlugin: FastifyPluginCallback<PluginOptions>
 
 // fastify-plugin 自动在导出的插件上添加 `.default` 属性。请参阅下方注释
 export default myPlugin

注意: fastify-plugin（https://github.com/fastify/fastify-plugin ）版本 2.3.0 及以上，会自动为导出的插件添加 .default 属性和一个命名导出。请确保在你的类型定义中使用 export default 和 export const myPlugin 来提供最佳的开发体验。你可以查看 @fastify/swagger 以获取完整示例。

完成这些文件后，插件现在可以被任何 TypeScript 项目所使用了！

Fastify 插件系统允许开发者装饰 Fastify 实例以及请求/响应实例。有关更多信息，请参阅这篇关于声明合并和泛型继承的博客文章。

使用插件

在 TypeScript 中使用 Fastify 插件与 JavaScript 中一样简单。通过 import/from 导入插件即可，但有一个例外情况用户需要注意。

Fastify 插件使用声明合并来修改现有的 Fastify 类型接口（请参阅前面的两个示例以获取更多详细信息）。声明合并并不十分“智能”，这意味着如果插件类型定义在 TypeScript 解释器的作用域内，则无论是否实际使用该插件，这些插件类型都会被包含不管是否使用了该插件。这是使用 TypeScript 的一个不幸的限制，并且目前无法避免。

不过有一些建议可以帮助改善这种体验：

确保启用了 ESLint 中的 no-unused-vars 规则，并确保导入的所有插件都被实际加载。
使用诸如 depcheck 或 npm-check 这样的模块来验证项目中是否使用了插件依赖项。

请注意，使用 require 将无法正确加载类型定义，并可能导致类型错误。 TypeScript 只能识别直接导入代码中的类型，这意味着您可以将 require 与 import 结合使用。例如：


import 'plugin' // 这里会触发类型扩展。
 
fastify.register(require('plugin'))


import plugin from 'plugin' // 这里会触发类型扩展。
 
fastify.register(plugin)

或者在 tsconfig 中显式配置


{
  "types": ["plugin"] // 我们强制 TypeScript 导入这些类型
}

纯JavaScript中的代码补全

纯JavaScript可以使用发布的类型来提供代码补全（例如Intellisense ），方法是遵循TypeScript JSDoc 参考。

例如：


/**  @type {import('fastify').FastifyPluginAsync<{ optionA: boolean, optionB: string }>} */
module.exports = async function (fastify, { optionA, optionB }) {
  fastify.get('/look', () => 'at me');
}

API 类型系统文档

本节详细介绍了 Fastify 3.x 版本中所有可用的类型。

所有 http、https 和 http2 类型均从 @types/node 推断得出。

泛型通过其默认值以及约束值进行记录。阅读以下文章以获取更多关于 TypeScript 泛型的信息。

如何导入

Fastify API 的核心是 fastify() 方法。在 JavaScript 中，你可以使用 const fastify = require('fastify') 进行导入。而在 TypeScript 中，则推荐使用 import/from 语法以解决类型问题。Fastify 类型系统支持几种不同的导入方法。

import fastify from 'fastify'

解决了类型，但不能通过点表示法访问
示例：


 import fastify from 'fastify'
 
 const f = fastify()
 f.listen({ port: 8080 }, () => { console.log('运行中') })

使用解构语法可以访问类型：


 import fastify, { FastifyInstance } from 'fastify'
 
 const f: FastifyInstance = fastify()
 f.listen({ port: 8080 }, () => { console.log('运行中') })

解构也可以用于主 API 方法：


 import { fastify, FastifyInstance } from 'fastify'
 
 const f: FastifyInstance = fastify()
 f.listen({ port: 8080 }, () => { console.log('运行中') })

import * as Fastify from 'fastify'

解决了类型，并且可以通过点表示法访问
调用主 Fastify API 方法需要稍微不同的语法（见示例）
示例：


 import * as Fastify from 'fastify'
 
 const f: Fastify.FastifyInstance = Fastify.fastify()
 f.listen({ port: 8080 }, () => { console.log('运行中') })

const fastify = require(‘fastify’)

这种语法有效，可以按预期导入 fastify；但是类型将不会被解析
示例：


 const fastify = require('fastify')
 
 const f = fastify()
 f.listen({ port: 8080 }, () => { console.log('运行中') })

解构语法支持，并且可以正确解析类型


 const { fastify } = require('fastify')
 
  const f = fastify();
  f.listen({ port: 8080 }, () => {
    console.log('运行中');
  });

泛型

许多类型定义共享相同的泛型参数；它们都在本节中详细记录。

大多数定义依赖于 @types/node 模块的 http, https, 和 http2

RawServer

底层 Node.js 服务器类型

默认值：http.Server

约束条件：http.Server, https.Server, http2.Http2Server, http2.Http2SecureServer

强制泛型参数：RawRequest, RawReply

RawRequest

底层 Node.js 请求类型

默认值：RawRequestDefaultExpression

约束条件：http.IncomingMessage, http2.Http2ServerRequest

由 RawServer 强制执行

RawReply

底层 Node.js 响应类型

默认值：RawReplyDefaultExpression

约束条件：http.ServerResponse, http2.Http2ServerResponse

由 RawServer 强制执行

Logger

Fastify 日志工具

默认值：FastifyLoggerOptions

由 RawServer 强制执行

RawBody

用于 content-type-parser 方法的泛型参数。

约束条件：string | Buffer

Fastify

（由于提供的原文仅包含一个标题，没有具体内容和链接，因此无法进行进一步的锚点替换和其他部分的翻译。如果有更多内容需要翻译，请提供完整文档。）

TypeScript

通过示例学习

开始使用

使用泛型

JSON Schema

Fastify 类型提供器

TypeBox

json-schema-to-typescript

json-schema-to-ts

插件

创建一个TypeScript Fastify插件

为 Fastify 插件创建类型定义

使用插件

纯JavaScript中的代码补全

API 类型系统文档

如何导入

泛型

RawServer

RawRequest

RawReply

Logger

RawBody

Fastify

fastify< RawRequest, RawReply, Logger>(opts?: FastifyServerOptions): FastifyInstance

示例 1：标准 HTTP 服务器

示例 2：HTTPS 服务器

示例 3：HTTP2 服务器

示例4：扩展HTTP服务器

示例5：指定日志类型

fastify.HTTPMethods

fastify.RawServerBase

fastify.RawServerDefault

fastify.FastifyServerOptions< RawServer, Logger>

fastify.HTTPMethods

fastify.RawServerBase

fastify.RawServerDefault

fastify.FastifyServerOptions< RawServer, Logger>

fastify.FastifyInstance< RawServer, RawRequest, RequestGeneric, Logger>

请求

fastify.FastifyRequest< RequestGeneric, RawServer, RawRequest>

示例

fastify.RequestGenericInterface

fastify.RawRequestDefaultExpression<RawServer>

回复

fastify.FastifyReply<RequestGeneric, RawServer, RawRequest, RawReply, ContextConfig>

示例

fastify.RawReplyDefaultExpression< RawServer>

插件

fastify.FastifyPluginCallback< Options>

fastify.FastifyPluginAsync< Options>

fastify.FastifyPlugin< Options>

fastify.FastifyPluginOptions

注册

fastify.FastifyRegister(plugin: FastifyPluginCallback, opts: FastifyRegisterOptions)

fastify.FastifyRegister(plugin: FastifyPluginAsync, opts: FastifyRegisterOptions)

fastify.FastifyRegister(plugin: FastifyPlugin, opts: FastifyRegisterOptions)

fastify.FastifyRegisterOptions

日志记录器

fastify.FastifyLoggerOptions< RawServer, RawRequest, RawReply>

fastify.FastifyLogFn

fastify.LogLevel

上下文

fastify.FastifyRequestContext

fastify.FastifyReplyContext

路由

fastify.RouteHandlerMethod< RawServer, RawRequest, RawReply, RequestGeneric, ContextConfig>

fastify.RouteOptions< RawServer, RawRequest, RawReply, RequestGeneric, ContextConfig>

fastify.RouteShorthandMethod< RawServer, RawRequest, RawReply>

fastify.RouteShorthandOptions< RawServer, RawRequest, RawReply, RequestGeneric, ContextConfig>

fastify.RouteShorthandOptionsWithHandler< RawServer, RawRequest, RawReply, RequestGeneric, ContextConfig>

解析器

RawBody

fastify.FastifyBodyParser< RawBody, RawServer, RawRequest>

fastify.FastifyContentTypeParser< RawServer, RawRequest>

fastify.AddContentTypeParser< RawServer, RawRequest>

fastify.hasContentTypeParser

错误

fastify.FastifyError

fastify.ValidationResult

回调钩子