工厂函数

const fastify = require('fastify')({
  ignoreTrailingSlash: true
})
 
// 注册 "/foo" 和 "/foo/"
fastify.get('/foo/', function (req, reply) {
  reply.send('foo')
})
 
// 注册 "/bar" 和 "/bar/"
fastify.get('/bar', function (req, reply) {
  reply.send('bar')
})
 

const fastify = require('fastify')({
  ignoreDuplicateSlashes: true
})
 
// 注册 "/foo/bar/"
fastify.get('///foo//bar//', function (req, reply) {
  reply.send('foo')
})
 

  fastify.get('/foo', function (req, res) {
    req.log.info({req}) // 记录序列化的请求对象
    res.send('foo')
  })
        

const pino = require('pino')();
 
const customLogger = {
  info: function (o, ...n) {},
  warn: function (o, ...n) {},
  error: function (o, ...n) {},
  fatal: function (o, ...n) {},
  trace: function (o, ...n) {},
  debug: function (o, ...n) {},
  child: function() {
    const child = Object.create(this);
    child.pino = pino.child(...arguments);
    return child;
  },
};
 
const fastify = require('fastify')({logger: customLogger});
 

// 用于复制禁用功能的钩子示例。
fastify.addHook('onRequest', (req, reply, done) => {
  req.log.info({ url: req.raw.url, id: req.id }, '收到请求')
  done()
})
 
fastify.addHook('onResponse', (req, reply, done) => {
  req.log.info({ url: req.raw.originalUrl, statusCode: reply.raw.statusCode }, '请求完成')
  done()
})
 

const serverFactory = (handler, opts) => {
  const server = http.createServer((req, res) => {
    handler(req, res)
  })
 
  return server
}
 
const fastify = Fastify({ serverFactory })
 
fastify.get('/', (req, reply) => {
  reply.send({ hello: 'world' })
})
 
fastify.listen({ port: 3000 })
 

fastify.get('/user/:username', (request, reply) => {
  // 给定URL：/USER/NodeJS
  console.log(request.params.username) // -> 'NodeJS'
})
 

fastify.get('/user/:id(^([0-9]+){4}$)', (request, reply) => {
  // 如果没有设置 allowUnsafeRegex = true，则会抛出错误
})
 

const fastify = require('fastify')({
  requestIdHeader: 'x-custom-id', // -> 如果存在，则使用 'X-Custom-Id' 头部
  //requestIdHeader: false, // -> 始终使用 genReqId
})
 

let i = 0
const fastify = require('fastify')({
  genReqId: function (req) { return i++ }
})
 

const fastify = Fastify({ trustProxy: true })
 

fastify.get('/', (request, reply) => {
  console.log(request.ip)
  console.log(request.ips)
  console.log(request.host)
  console.log(request.protocol)
})
 

const qs = require('qs')
const fastify = require('fastify')({
  querystringParser: str => qs.parse(str)
})
 

const querystring = require('fast-querystring')
const fastify = require('fastify')({
  querystringParser: str => querystring.parse(str.toLowerCase())
})
 

const customVersionStrategy = {
  storage: function () {
    const versions = {}
    return {
      get: (version) => { return versions[version] || null },
      set: (version, store) => { versions[version] = store }
    }
  },
  deriveVersion: (req, ctx) => {
    return req.headers['accept']
  }
}
 
const fastify = require('fastify')({
  constraints: {
    version: customVersionStrategy
  }
})
 

const fastify = require('fastify')({
  ajv: {
    customOptions: {
      removeAdditional: 'all' // 参见 [ajv options](https://ajv.js.org/options.html#removeadditional)
    },
    plugins: [
      require('ajv-merge-patch'),
      [require('ajv-keywords'), 'instanceof']
      // 使用方法：[插件, 插件选项] - 带有选项的插件
      // 使用方法：插件 - 不带选项的插件
    ]
  }
})
 

const fastify = require('fastify')({
  serializerOpts: {
    rounding: 'ceil'
  }
})
 

const fastify = require('fastify')({
  frameworkErrors: function (error, req, res) {
    if (error instanceof FST_ERR_BAD_URL) {
      res.code(400)
      return res.send("提供的 URL 不有效")
    } else if(error instanceof FST_ERR_ASYNC_CONSTRAINT) {
      res.code(400)
      return res.send("提供的头信息不有效")
    } else {
      res.send(err)
    }
  }
})
 

function defaultClientErrorHandler (err, socket) {
  if (err.code === 'ECONNRESET') {
    return
  }
 
  const body = JSON.stringify({
    error: http.STATUS_CODES['400'],
    message: 'Client Error',
    statusCode: 400
  })
  this.log.trace({ err }, '客户端错误')
 
  if (socket.writable) {
    socket.end([
      'HTTP/1.1 400 Bad Request',
      `Content-Length: ${body.length}`,
      `Content-Type: application/json\r\n\r\n${body}`
    ].join('\r\n'))
  }
}

const fastify = require('fastify')({
  clientErrorHandler: function (err, socket) {
    const body = JSON.stringify({
      error: {
        message: '客户端错误',
        code: '400'
      }
    })
 
    // `this` 绑定到 fastify 实例
    this.log.trace({ err }, '客户端错误')
 
    // 处理器负责生成有效的 HTTP 响应
    socket.end([
      'HTTP/1.1 400 Bad Request',
      `Content-Length: ${body.length}`,
      `Content-Type: application/json\r\n\r\n${body}`
    ].join('\r\n'))
  }
})

// @param {object} req 原始Node.js HTTP请求对象（非FastifyRequest对象）。
// @this Fastify 根Fastify实例（非封装实例）。
// @returns {string} 请求应映射到的路径。
function rewriteUrl (req) {
  if (req.url === '/hi') {
    this.log.debug({ originalUrl: req.url, url: '/hello' }, '重写URL');
    return '/hello'
  } else {
    return req.url;
  }
}
 

const fastify = require('fastify')({
  useSemicolonDelimiter: true
})
 
fastify.get('/dev', async (request, reply) => {
  // 例如请求 `/dev;foo=bar`
  // 将产生以下查询参数结果 `{ foo = 'bar' }`
  return request.query
})

app.setErrorHandler(function freeSomeResources () {
  // 永远不执行，内存泄漏
})
 
app.setErrorHandler(function anotherErrorHandler () {
  // 覆盖前面的处理程序
})
 

fastify
  .register((instance, opts, done) => {
    console.log('当前插件')
    done()
  })
  .after(err => {
    console.log('当前插件之后')
  })
  .register((instance, opts, done) => {
    console.log('下一个插件')
    done()
  })
  .ready(err => {
    console.log('所有内容已加载')
  })
 

fastify.register(async (instance, opts) => {
  console.log('当前插件')
})
 
await fastify.after()
console.log('当前插件之后')
 
fastify.register(async (instance, opts) => {
  console.log('下一个插件')
})
 
await fastify.ready()
 
console.log('所有内容已加载')
 

fastify.ready(err => {
  if (err) throw err
})
 

fastify.ready().then(() => {
  console.log('启动成功!')
}, (err) => {
  console.log('发生错误', err)
})
 

server.listen({
  port: 9080,
  listenTextResolver: (address) => { return `Prometheus metrics server is listening at ${address}` }
})

fastify.listen((err, address) => {
  if (err) {
    fastify.log.error(err)
    process.exit(1)
  }
})
 

fastify.listen({ port: 3000, host: '127.0.0.1' }, (err, address) => {
  if (err) {
    fastify.log.error(err)
    process.exit(1)
  }
})
 

fastify.listen({ port: 3000, host: '127.0.0.1' }, (err, address) => {
  if (err) {
    fastify.log.error(err)
    process.exit(1)
  }
})
 

fastify.listen({ port: 3000 })
  .then((address) => console.log(`server listening on ${address}`))
  .catch(err => {
    console.log('Error starting server:', err)
    process.exit(1)
  })

fastify.listen({ port: 3000, host: '0.0.0.0' }, (err, address) => {
  if (err) {
    fastify.log.error(err)
    process.exit(1)
  }
})
 

fastify.listen({
  port: 0,
  host: 'localhost',
  exclusive: false,
  readableAll: false,
  writableAll: false,
  ipv6Only: false
}, (err) => {})
 

await fastify.listen({ port: 8080 })
const addresses = fastify.addresses()
// [
//   { port: 8080, family: 'IPv6', address: '::1' },
//   { port: 8080, family: 'IPv4', address: '127.0.0.1' }
// ]
 

fastify.routing(req, res)
 

const routeExists = fastify.hasRoute({
  url: '/',
  method: 'GET',
  constraints: { version: '1.0.0' } // 可选
})
 
if (routeExists === false) {
  // 添加路由
}
 

const route = fastify.findRoute({
  url: '/artists/:artistId',
  method: 'GET',
  constraints: { version: '1.0.0' } // 可选
})
 
if (route !== null) {
  // 执行一些路由检查
  console.log(route.params)   // `{artistId: ':artistId'}`
}

fastify.close().then(() => {
  console.log('成功关闭!')
}, (err) => {
  console.log('发生错误', err)
})
 

fastify.register(function (instance, opts, done) {
  instance.get('/foo', function (request, reply) {
    // 将记录 "前缀: /v1"
    request.log.info('前缀: %s', instance.prefix)
    reply.send({ prefix: instance.prefix })
  })
 
  instance.register(function (instance, opts, done) {
    instance.get('/bar', function (request, reply) {
      // 将记录 "前缀: /v1/v2"
      request.log.info('前缀: %s', instance.prefix)
      reply.send({ prefix: instance.prefix })
    })
 
    done()
  }, { prefix: '/v2' })
 
  done()
}, { prefix: '/v1' })
 

const fastify = require('fastify')()
fastify.register(require('@fastify/cookie'), {
  secret: 'my-secret',
  parseOptions: {}
})
 
fastify.ready(() => {
  fastify.hasPlugin('@fastify/cookie') // true
})
 

// 添加一个名为 'MKCOL' 的新 HTTP 方法，并支持请求体
fastify.addHttpMethod('MKCOL', { hasBody: true,  })
 
// 添加一个不支持请求体的新 HTTP 方法，例如 'COPY'
fastify.addHttpMethod('COPY')
 

fastify.addHttpMethod('MKCOL', { hasBody: true })
fastify.mkcol('/', (req, reply) => {
  // 处理 'MKCOL' 请求
})
 

fastify.setReplySerializer(function (payload, statusCode){
  // 使用同步函数序列化负载
  return `my serialized ${statusCode} content: ${payload}`
})

const fastify = Fastify({
  schemaController: {
    /**
     * 当调用 `fastify.register()` 时，此工厂函数将被调用。
     * 如果添加了一些模式，则可以接收父上下文的模式作为输入。
     * @param {object} parentSchemas 这些模式将由返回的 `bucket` 的 `getSchemas()` 方法函数返回。
     */
    bucket: function factory (parentSchemas) {
      return {
        add (inputSchema) {
          // 此函数必须存储用户添加的模式。
          // 当调用 `fastify.addSchema()` 时将调用此函数。
        },
        getSchema (schema$id) {
          // 此函数必须返回由 `schema$id` 请求的原始模式。
          // 当调用 `fastify.getSchema(id)` 时将调用此函数。
          return aSchema
        },
        getSchemas () {
          // 此函数必须返回所有路由模式 `$ref` 引用的模式。
          // 它必须返回一个 JSON，其中属性是模式 `$id`，值是原始 JSON 模式。
          const allTheSchemaStored = {
            'schema$id1': schema1,
            'schema$id2': schema2
          }
          return allTheSchemaStored
        }
      }
    },
 
    /**
     * 编译器工厂允许您完全控制 Fastify 生命周期中的验证器和序列化器，为您的编译器提供封装。
     */
    compilersFactory: {
      /**
       * 每当需要新的验证器实例时都会调用此工厂。仅在 `fastify.register()` 被调用且封装上下文中添加了新模式的情况下才会被调用。
       * 如果某些模式已被添加，则可以接收父上下文的模式作为输入参数。
       * @param {object} externalSchemas 这些模式将由 `bucket.getSchemas()` 返回。需要这些模式来解析外部引用 $ref。
       * @param {object} ajvServerOption 用于构建编译器的服务器端 `ajv` 选项
       */
      buildValidator: function factory (externalSchemas, ajvServerOption) {
        // 此工厂函数必须返回一个模式验证器编译器。详情请参阅 [模式验证器](./Validation-and-Serialization.md#schema-validator)
        const yourAjvInstance = new Ajv(ajvServerOption.customOptions)
        return function validatorCompiler ({ schema, method, url, httpPart }) {
          return yourAjvInstance.compile(schema)
        }
      },
 
      /**
       * 当需要新的序列化器实例时调用此工厂函数。
       * 只有在 `fastify.register()` 被调用且封装上下文中添加了新模式的情况下，才会被调用。
       * 如果某些模式已被添加，则可以接收父上下文中的模式作为输入参数。
       * @param {object} externalSchemas 这些模式将由 `bucket.getSchemas()` 返回。 用于解析外部引用 $ref。
       * @param {object} serializerOptsServerOption 服务器的 `serializerOpts` 选项，根据这些选项构建编译器
       */
      buildSerializer: function 工厂函数 (externalSchemas, serializerOptsServerOption) {
        // 此工厂函数必须返回一个模式序列化器编译器。
        // 详情请参阅 [模式序列化器](./Validation-and-Serialization.md#schema-serializer)
        return function 序列化器编译器 ({ schema, method, url, httpStatus, contentType }) {
          return data => JSON.stringify(data)
        }
      }
    }
  }
});

fastify.setNotFoundHandler({
  preValidation: (req, reply, done) => {
    // 你的代码
    done()
  },
  preHandler: (req, reply, done) => {
    // 你的代码
    done()
  }
}, function (request, reply) {
    // 带有preValidation和preHandler钩子的默认404处理程序
})
 
fastify.register(function (instance, options, done) {
  instance.setNotFoundHandler(function (request, reply) {
    // 不带preValidation和preHandler钩子处理以'/v1'开头的URL请求
  })
  done()
}, { prefix: '/v1' })
 

 
Fastify 在启动时调用 setNotFoundHandler 来添加默认的 404 处理程序，此操作发生在插件注册之前。如果您希望增强默认 404 处理程序的行为（例如通过使用插件），您可以在已注册插件的上下文中调用 `fastify.setNotFoundHandler()`。
 
> ℹ️ 注意：
> 请求对象中的一些配置属性在自定义未找到处理程序内部将为 undefined。例如：`request.routeOptions.url`，`routeOptions.method` 和 `routeOptions.config`。
> 此方法的设计目的是允许调用通用的 404 路由。
> 若要返回特定路由定制化的 404 响应，您可以在响应本身中实现。
 

fastify.setErrorHandler(function (error, request, reply) {
  // 记录错误
  this.log.error(error)
  // 发送错误响应
  reply.status(409).send({ ok: false })
})
 

const statusCode = error.statusCode
if (statusCode >= 500) {
  log.error(error)
} else if (statusCode >= 400) {
  log.info(error)
} else {
  log.error(error)
}
 

const fastify = require('fastify')({
  childLoggerFactory: function (logger, bindings, opts, rawReq) {
    // 如果需要，从请求中计算额外的绑定
    bindings.traceContext = rawReq.headers['x-cloud-trace-context']
    return logger.child(bindings, opts)
  }
})
 

const fastify = require('fastify')({
  genReqId: (req) => {
    return 'base'
  }
})
 
fastify.register((instance, opts, done) => {
  instance.setGenReqId((req) => {
    // 自定义请求ID，用于 `/webhooks`
    return 'webhooks-id'
  })
  done()
}, { prefix: '/webhooks' })
 
fastify.register((instance, opts, done) => {
  instance.setGenReqId((req) => {
    // 自定义请求ID，用于 `/observability`
    return 'observability-id'
  })
  done()
}, { prefix: '/observability' })

const customResponseTypeStrategy = {
  // 约束策略名称，在路由处理器的 `constraints` 选项中引用
  name: 'accept',
  // 存储工厂，用于在 find-my-way 路由树中存储路由
  storage: function () {
    let handlers = {}
    return {
      get: (type) => { return handlers[type] || null },
      set: (type, store) => { handlers[type] = store }
    }
  },
  // 获取每个传入请求的约束值的函数
  deriveConstraint: (req, ctx) => {
    return req.headers['accept']
  },
  // 可选标志，标记没有约束处理程序是否可以匹配具有此约束值的请求
  mustMatchWhenDerived: true
}
 
const router = Fastify();
router.addConstraintStrategy(customResponseTypeStrategy);

fastify.get('/test', () => {})
fastify.get('/test/hello', () => {})
fastify.get('/testing', () => {})
fastify.get('/testing/:param', () => {})
fastify.put('/update', () => {})
 
fastify.ready(() => {
  console.log(fastify.printRoutes())
  // └── /
  //     ├── test (GET)
  //     │   ├── /hello (GET)
  //     │   └── ing (GET)
  //     │       └── /
  //     │           └── :param (GET)
  //     └── update (PUT)
})
 

console.log(fastify.printRoutes({ method: 'GET' }))
// └── /
//     └── test (GET)
//         ├── /hello (GET)
//         └── ing (GET)
//             └── /
//                 └── :param (GET)
 
console.log(fastify.printRoutes({ method: 'PUT' }))
// └── /
//     └── update (PUT)
 

console.log(fastify.printRoutes({ commonPrefix: false }))
// ├── /test (GET)
// │   ├── /hello (GET)
// │   └── ing (GET)
// │       └── /:param (GET)
// └── /update (PUT)
 
 

  fastify.get('/test', () => {})
  fastify.get('/test/hello', () => {})
 
  const onTimeout = () => {}
 
  fastify.addHook('onRequest', () => {})
  fastify.addHook('onTimeout', onTimeout)
 
  console.log(fastify.printRoutes({ includeHooks: true, includeMeta: ['errorHandler'] }))
  // └── /
  //     └── test (GET)
  //         • (onTimeout) ["onTimeout()"]
  //         • (onRequest) ["anonymous()"]
  //         • (errorHandler) "defaultErrorHandler()"
  //         test (HEAD)
  //         • (onTimeout) ["onTimeout()"]
  //         • (onRequest) ["anonymous()"]
  //         • (onSend) ["headRouteOnSendHandler()"]
  //         • (errorHandler) "defaultErrorHandler()"
  //         └── /hello (GET)
  //             • (onTimeout) ["onTimeout()"]
  //             • (onRequest) ["anonymous()"]
  //             • (errorHandler) "defaultErrorHandler()"
  //             /hello (HEAD)
  //             • (onTimeout) ["onTimeout()"]
  //             • (onRequest) ["anonymous()"]
  //             • (onSend) ["headRouteOnSendHandler()"]
  //             • (errorHandler) "defaultErrorHandler()" 
 

console.log(fastify.printRoutes({ includeHooks: true }))
  // └── /
  //     └── test (GET)
  //         • (onTimeout) ["onTimeout()"]
  //         • (onRequest) ["anonymous()"]
  //         test (HEAD)
  //         • (onTimeout) ["onTimeout()"]
  //         • (onRequest) ["anonymous()"]
  //         • (onSend) ["headRouteOnSendHandler()"]
  //         └── /hello (GET)
  //             • (onTimeout) ["onTimeout()"]
  //             • (onRequest) ["anonymous()"]
  //             /hello (HEAD)
  //             • (onTimeout) ["onTimeout()"]
  //             • (onRequest) ["anonymous()"]
  //             • (onSend) ["headRouteOnSendHandler()"]
 

fastify.register(async function foo (instance) {
  instance.register(async function bar () {})
})
fastify.register(async function baz () {})
 
fastify.ready(() => {
  console.error(fastify.printPlugins())
  // 将输出以下内容到 stderr：
  // └── root
  //     ├── foo
  //     │   └── bar
  //     └── baz
})
 

// getDefaultJsonParser 的两个参数分别用于原型中毒和构造函数中毒配置。可能的值为 'ignore', 'remove', 'error'。ignore 会跳过所有验证，类似于直接调用 JSON.parse()。有关更多信息，请参阅
// [`secure-json-parse` 文档](https://github.com/fastify/secure-json-parse#api)
 
fastify.addContentTypeParser('text/json', { asString: true }, fastify.getDefaultJsonParser('ignore', 'ignore'))

fastify.hasContentTypeParser('text/json')
 
fastify.hasContentTypeParser(/^.+\/json$/)
 

fastify.removeContentTypeParser('application/json')
 
fastify.removeContentTypeParser(['application/json', 'text/plain'])
 

fastify.addContentTypeParser('text/json', { asString: true }, fastify.defaultTextParser)
 

fastify.get('/', {
  errorHandler: (error, request, reply) => {
    if (error.code === 'SOMETHING_SPECIFIC') {
      reply.send({ custom: 'response' })
      return
    }
 
    fastify.errorHandler(error, request, response)
  }
}, handler)
 

test('Uses app and closes it afterwards', async () => {
  await using app = fastify();
  // 使用 app 进行操作。
})
 

const { readFileSync } = require('node:fs')
const Fastify = require('fastify')
 
const fastify = Fastify({
  https: {
    allowHTTP1: true,
    key: readFileSync('./fastify.key'),
    cert: readFileSync('./fastify.cert')
  },
  logger: { level: 'trace'},
  ignoreTrailingSlash: true,
  maxParamLength: 200,
  caseSensitive: true,
  trustProxy: '127.0.0.1,192.168.1.1/24',
})
 
console.log(fastify.initialConfig)
/*
将打印：
{
  caseSensitive: true,
  https: { allowHTTP1: true },
  ignoreTrailingSlash: true,
  maxParamLength: 200
}
*/
 
fastify.register(async (instance, opts) => {
  instance.get('/', async (request, reply) => {
    return instance.initialConfig
    /*
    将返回：
    {
      caseSensitive: true,
      https: { allowHTTP1: true },
      ignoreTrailingSlash: true,
      maxParamLength: 200
    }
    */
  })
 
  instance.get('/error', async (request, reply) => {
    // 因为 initialConfig 是只读的，不能被修改，所以会抛出错误
    instance.initialConfig.https.allowHTTP1 = false
 
    return instance.initialConfig
  })
})
 
// 开始监听。
fastify.listen({ port: 3000 }, (err) => {
  if (err) {
    fastify.log.error(err)
    process.exit(1)
  }
})