fastify 4.21.0 → 4.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.21.0",
+  "version": "4.22.1",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -14,10 +14,11 @@
     "coverage:ci": "c8 --reporter=lcov tap --coverage-report=html --no-browser --no-check-coverage",
     "coverage:ci-check-coverage": "c8 check-coverage --branches 100 --functions 100 --lines 100 --statements 100",
     "lint": "npm run lint:standard && npm run lint:typescript && npm run lint:markdown",
-    "lint:fix": "standard --fix",
+    "lint:fix": "standard --fix && npm run lint:typescript:fix",
     "lint:markdown": "markdownlint-cli2",
     "lint:standard": "standard | snazzy",
     "lint:typescript": "eslint -c types/.eslintrc.json types/**/*.d.ts test/types/**/*.test-d.ts",
+    "lint:typescript:fix": "npm run lint:typescript -- --fix",
     "prepublishOnly": "cross-env PREPUBLISH=true tap --no-check-coverage test/build/**.test.js && npm run test:validator:integrity",
     "test": "npm run lint && npm run unit && npm run test:typescript",
     "test:ci": "npm run unit -- --cov --coverage-report=lcovonly && npm run test:typescript",
@@ -133,11 +134,11 @@
   "homepage": "https://www.fastify.io/",
   "devDependencies": {
     "@fastify/pre-commit": "^2.0.2",
-    "@sinclair/typebox": "^0.29.1",
+    "@sinclair/typebox": "^0.31.1",
     "@sinonjs/fake-timers": "^11.0.0",
     "@types/node": "^20.1.0",
-    "@typescript-eslint/eslint-plugin": "^5.59.2",
-    "@typescript-eslint/parser": "^5.59.2",
+    "@typescript-eslint/eslint-plugin": "^6.3.0",
+    "@typescript-eslint/parser": "^6.3.0",
     "ajv": "^8.12.0",
     "ajv-errors": "^3.0.0",
     "ajv-formats": "^2.1.1",
@@ -161,7 +162,7 @@
     "joi": "^17.9.2",
     "json-schema-to-ts": "^2.9.1",
     "JSONStream": "^1.3.5",
-    "markdownlint-cli2": "^0.8.1",
+    "markdownlint-cli2": "^0.9.2",
     "proxyquire": "^2.1.3",
     "self-cert": "^2.0.0",
     "send": "^0.18.0",

package/test/bodyLimit.test.js

@@ -2,6 +2,7 @@
 
 const Fastify = require('..')
 const sget = require('simple-get').concat
+const zlib = require('zlib')
 const t = require('tap')
 const test = t.test
 
@@ -45,6 +46,74 @@ test('bodyLimit', t => {
   })
 })
 
+test('bodyLimit is applied to decoded content', t => {
+  t.plan(9)
+
+  const body = { x: 'x'.repeat(30000) }
+  const json = JSON.stringify(body)
+  const encoded = zlib.gzipSync(json)
+
+  const fastify = Fastify()
+
+  fastify.addHook('preParsing', async (req, reply, payload) => {
+    t.equal(req.headers['content-length'], `${encoded.length}`)
+    const unzip = zlib.createGunzip()
+    Object.defineProperty(unzip, 'receivedEncodedLength', {
+      get () {
+        return unzip.bytesWritten
+      }
+    })
+    payload.pipe(unzip)
+    return unzip
+  })
+
+  fastify.post('/body-limit-40k', {
+    bodyLimit: 40000,
+    onError: async (req, res, err) => {
+      t.fail('should not be called')
+    }
+  }, (request, reply) => {
+    reply.send({ x: request.body.x })
+  })
+
+  fastify.post('/body-limit-20k', {
+    bodyLimit: 20000,
+    onError: async (req, res, err) => {
+      t.equal(err.code, 'FST_ERR_CTP_BODY_TOO_LARGE')
+      t.equal(err.statusCode, 413)
+    }
+  }, (request, reply) => {
+    reply.send({ x: 'handler should not be called' })
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/body-limit-40k',
+    headers: {
+      'content-encoding': 'gzip',
+      'content-type': 'application/json'
+    },
+    payload: encoded
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 200)
+    t.same(res.json(), body)
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/body-limit-20k',
+    headers: {
+      'content-encoding': 'gzip',
+      'content-type': 'application/json'
+    },
+    payload: encoded
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 413)
+  })
+})
+
 test('default request.routeOptions.bodyLimit should be 1048576', t => {
   t.plan(4)
   const fastify = Fastify()

package/test/build/error-serializer.test.js

@@ -23,9 +23,9 @@ test('check generated code syntax', async (t) => {
   t.equal(result[0].fatalErrorCount, 0)
 })
 
-const isPrebublish = !!process.env.PREPUBLISH
+const isPrepublish = !!process.env.PREPUBLISH
 
-test('ensure the current error serializer is latest', { skip: !isPrebublish }, async (t) => {
+test('ensure the current error serializer is latest', { skip: !isPrepublish }, async (t) => {
   t.plan(1)
 
   const current = await fs.promises.readFile(path.resolve('lib/error-serializer.js'))

package/test/custom-http-server.test.js

@@ -10,8 +10,9 @@ const dns = require('dns').promises
 
 test('Should support a custom http server', async t => {
   const localAddresses = await dns.lookup('localhost', { all: true })
+  const minPlan = localAddresses.length - 1 || 1
 
-  t.plan((localAddresses.length - 1) + 3)
+  t.plan(minPlan + 3)
 
   const serverFactory = (handler, opts) => {
     t.ok(opts.serverFactory, 'it is called once for localhost')

package/test/https/custom-https-server.test.js

@@ -12,8 +12,9 @@ t.before(buildCertificate)
 
 test('Should support a custom https server', async t => {
   const localAddresses = await dns.lookup('localhost', { all: true })
+  const minPlan = localAddresses.length - 1 || 1
 
-  t.plan((localAddresses.length - 1) + 3)
+  t.plan(minPlan + 3)
 
   const serverFactory = (handler, opts) => {
     t.ok(opts.serverFactory, 'it is called once for localhost')

package/test/internals/plugin.test.js

@@ -29,6 +29,21 @@ test('getPluginName should return plugin name if the file is cached', t => {
   t.equal(pluginName, expectedPluginName)
 })
 
+test('getPluginName should not throw when require.cache is undefined', t => {
+  t.plan(1)
+  function example () {
+    console.log('is just an example')
+  }
+  const cache = require.cache
+  require.cache = undefined
+  t.teardown(() => {
+    require.cache = cache
+  })
+  const pluginName = pluginUtilsPublic.getPluginName(example)
+
+  t.equal(pluginName, 'example')
+})
+
 test("getMeta should return the object stored with the 'plugin-meta' symbol", t => {
   t.plan(1)
 
@@ -122,7 +137,7 @@ test('checkDependencies should check if the given dependency is present in the i
   }
 
   function context () {}
-  context[pluginUtilsPublic.registeredPlugins] = ['plugin']
+  context[pluginUtilsPublic.kRegisteredPlugins] = ['plugin']
 
   try {
     pluginUtils.checkDependencies.call(context, fn)
@@ -143,7 +158,7 @@ test('checkDependencies should check if the given dependency is present in the i
   }
 
   function context () {}
-  context[pluginUtilsPublic.registeredPlugins] = []
+  context[pluginUtilsPublic.kRegisteredPlugins] = []
 
   try {
     pluginUtils.checkDependencies.call(context, fn)

package/test/plugin.test.js

@@ -1247,3 +1247,29 @@ test('hasPlugin returns true when using no encapsulation', async t => {
 
   await fastify.ready()
 })
+
+test('hasPlugin returns true when using encapsulation', async t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  const pluginCallback = function (server, options, done) {
+    done()
+  }
+  const pluginName = 'awesome-plugin'
+  const plugin = fp(pluginCallback, { name: pluginName })
+
+  fastify.register(plugin)
+
+  fastify.register(async (server) => {
+    t.ok(server.hasPlugin(pluginName))
+  })
+
+  fastify.register(async function foo (server) {
+    server.register(async function bar (server) {
+      t.ok(server.hasPlugin(pluginName))
+    })
+  })
+
+  await fastify.ready()
+})

package/test/post-empty-body.test.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const { test } = require('tap')
+const fastify = require('../')
+const { request, setGlobalDispatcher, Agent } = require('undici')
+
+setGlobalDispatcher(new Agent({
+  keepAliveTimeout: 10,
+  keepAliveMaxTimeout: 10
+}))
+
+test('post empty body', async t => {
+  const app = fastify()
+  t.teardown(app.close.bind(app))
+
+  app.post('/bug', async (request, reply) => {
+  })
+
+  await app.listen({ port: 0 })
+
+  const res = await request(`http://127.0.0.1:${app.server.address().port}/bug`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ foo: 'bar' })
+  })
+
+  t.equal(res.statusCode, 200)
+  t.equal(await res.body.text(), '')
+})

package/test/types/fastify.test-d.ts

@@ -10,7 +10,6 @@ import fastify, {
   InjectOptions, FastifyBaseLogger,
   RawRequestDefaultExpression,
   RouteGenericInterface,
-  ValidationResult,
   FastifyErrorCodes,
   FastifyError
 } from '../../fastify'
@@ -18,7 +17,7 @@ import { ErrorObject as AjvErrorObject } from 'ajv'
 import * as http from 'http'
 import * as https from 'https'
 import * as http2 from 'http2'
-import { expectType, expectError, expectAssignable } from 'tsd'
+import { expectType, expectError, expectAssignable, expectNotAssignable } from 'tsd'
 import { FastifyLoggerInstance } from '../../types/logger'
 import { Socket } from 'net'
 
@@ -244,7 +243,13 @@ const ajvErrorObject: AjvErrorObject = {
   params: {},
   message: ''
 }
-expectAssignable<ValidationResult>(ajvErrorObject)
+expectNotAssignable<AjvErrorObject>({
+  keyword: '',
+  instancePath: '',
+  schemaPath: '',
+  params: '',
+  message: ''
+})
 
 expectAssignable<FastifyError['validation']>([ajvErrorObject])
 expectAssignable<FastifyError['validationContext']>('body')

package/test/types/hooks.test-d.ts

@@ -392,3 +392,16 @@ server.addHook('preClose', function (done) {
 server.addHook('preClose', async function () {
   expectType<FastifyInstance>(this)
 })
+
+expectError(server.addHook('onClose', async function (instance, done) {}))
+expectError(server.addHook('onError', async function (request, reply, error, done) {}))
+expectError(server.addHook('onReady', async function (done) {}))
+expectError(server.addHook('onRequest', async function (request, reply, done) {}))
+expectError(server.addHook('onRequestAbort', async function (request, done) {}))
+expectError(server.addHook('onResponse', async function (request, reply, done) {}))
+expectError(server.addHook('onSend', async function (request, reply, payload, done) {}))
+expectError(server.addHook('onTimeout', async function (request, reply, done) {}))
+expectError(server.addHook('preClose', async function (done) {}))
+expectError(server.addHook('preHandler', async function (request, reply, done) {}))
+expectError(server.addHook('preSerialization', async function (request, reply, payload, done) {}))
+expectError(server.addHook('preValidation', async function (request, reply, done) {}))

package/test/types/instance.test-d.ts

@@ -6,7 +6,8 @@ import fastify, {
   FastifyInstance,
   RawReplyDefaultExpression,
   RawRequestDefaultExpression,
-  RawServerDefault
+  RawServerDefault,
+  RouteGenericInterface
 } from '../../fastify'
 import { HookHandlerDoneFunction } from '../../types/hooks'
 import { FastifyReply } from '../../types/reply'
@@ -257,9 +258,13 @@ expectNotDeprecated(server.listen({ port: 3000, host: '::/0', ipv6Only: true },
 
 expectAssignable<void>(server.routing({} as RawRequestDefaultExpression, {} as RawReplyDefaultExpression))
 
-expectType<FastifyInstance>(fastify().get('/', {
+expectType<FastifyInstance>(fastify().get<RouteGenericInterface, { contextKey: string }>('/', {
   handler: () => {},
   errorHandler: (error, request, reply) => {
+    expectAssignable<FastifyError>(error)
+    expectAssignable<FastifyRequest>(request)
+    expectAssignable<{ contextKey: string }>(request.routeConfig)
+    expectAssignable<FastifyReply>(reply)
     expectAssignable<void>(server.errorHandler(error, request, reply))
   }
 }))

package/test/types/request.test-d.ts

@@ -83,7 +83,7 @@ const getHandler: RouteHandler = function (request, _reply) {
   request.headers = {}
 
   expectType<RequestQuerystringDefault>(request.query)
-  expectType<any>(request.id)
+  expectType<string>(request.id)
   expectType<FastifyLoggerInstance>(request.log)
   expectType<RawRequestDefaultExpression['socket']>(request.socket)
   expectType<Error & { validation: any; validationContext: string } | undefined>(request.validationError)

package/test/types/type-provider.test-d.ts

@@ -3,7 +3,8 @@ import fastify, {
   HookHandlerDoneFunction,
   FastifyRequest,
   FastifyReply,
-  FastifyInstance
+  FastifyInstance,
+  FastifyError
 } from '../../fastify'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import { IncomingHttpHeaders } from 'http'
@@ -79,6 +80,14 @@ expectAssignable(server.withTypeProvider<TypeBoxProvider>().get(
         y: Type.Number(),
         z: Type.Number()
       })
+    },
+    errorHandler: (error, request, reply) => {
+      expectType<FastifyError>(error)
+      expectAssignable<FastifyRequest>(request)
+      expectType<number>(request.body.x)
+      expectType<number>(request.body.y)
+      expectType<number>(request.body.z)
+      expectAssignable<FastifyReply>(reply)
     }
   },
   (req) => {
@@ -108,6 +117,14 @@ expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get(
           z: { type: 'boolean' }
         }
       } as const
+    },
+    errorHandler: (error, request, reply) => {
+      expectType<FastifyError>(error)
+      expectAssignable<FastifyRequest>(request)
+      expectType<number | undefined>(request.body.x)
+      expectType<string | undefined>(request.body.y)
+      expectType<boolean | undefined>(request.body.z)
+      expectAssignable<FastifyReply>(reply)
     }
   },
   (req) => {
@@ -135,6 +152,14 @@ expectAssignable(server.withTypeProvider<TypeBoxProvider>().withTypeProvider<Jso
           z: { type: 'boolean' }
         }
       } as const
+    },
+    errorHandler: (error, request, reply) => {
+      expectType<FastifyError>(error)
+      expectAssignable<FastifyRequest>(request)
+      expectType<number | undefined>(request.body.x)
+      expectType<string | undefined>(request.body.y)
+      expectType<boolean | undefined>(request.body.z)
+      expectAssignable<FastifyReply>(reply)
     }
   },
   (req) => {

package/types/hooks.d.ts

@@ -190,7 +190,7 @@ interface DoneFuncWithErrOrRes {
  *  Note: the hook is NOT called if the payload is a string, a Buffer, a stream or null.
  */
 export interface preSerializationHookHandler<
-  PreSerializationPayload,
+  PreSerializationPayload = unknown,
   RawServer extends RawServerBase = RawServerDefault,
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
@@ -210,7 +210,7 @@ export interface preSerializationHookHandler<
 }
 
 export interface preSerializationAsyncHookHandler<
-  PreSerializationPayload,
+  PreSerializationPayload = unknown,
   RawServer extends RawServerBase = RawServerDefault,
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
@@ -233,7 +233,7 @@ export interface preSerializationAsyncHookHandler<
  * Note: If you change the payload, you may only change it to a string, a Buffer, a stream, or null.
  */
 export interface onSendHookHandler<
-  OnSendPayload,
+  OnSendPayload = unknown,
   RawServer extends RawServerBase = RawServerDefault,
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
@@ -253,7 +253,7 @@ export interface onSendHookHandler<
 }
 
 export interface onSendAsyncHookHandler<
-  OnSendPayload,
+  OnSendPayload = unknown,
   RawServer extends RawServerBase = RawServerDefault,
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
@@ -432,6 +432,66 @@ export interface onRequestAbortAsyncHookHandler<
   ): Promise<unknown>;
 }
 
+export type LifecycleHook = 'onRequest'
+| 'preParsing'
+| 'preValidation'
+| 'preHandler'
+| 'preSerialization'
+| 'onSend'
+| 'onResponse'
+| 'onRequest'
+| 'onError'
+| 'onTimeout'
+| 'onRequestAbort'
+
+export type LifecycleHookLookup<K extends LifecycleHook> = K extends 'onRequest'
+  ? onRequestHookHandler
+  : K extends 'preParsing'
+    ? preParsingHookHandler
+    : K extends 'preValidation'
+      ? preValidationHookHandler
+      : K extends 'preHandler'
+        ? preHandlerHookHandler
+        : K extends 'preSerialization'
+          ? preSerializationHookHandler
+          : K extends 'onSend'
+            ? onSendHookHandler
+            : K extends 'onResponse'
+              ? onResponseHookHandler
+              : K extends 'onRequest'
+                ? onRequestHookHandler
+                : K extends 'onError'
+                  ? onErrorHookHandler
+                  : K extends 'onTimeout'
+                    ? onTimeoutHookHandler
+                    : K extends 'onRequestAbort'
+                      ? onRequestAbortHookHandler
+                      : never
+
+export type LifecycleHookAsyncLookup<K extends LifecycleHook> = K extends 'onRequest'
+  ? onRequestAsyncHookHandler
+  : K extends 'preParsing'
+    ? preParsingAsyncHookHandler
+    : K extends 'preValidation'
+      ? preValidationAsyncHookHandler
+      : K extends 'preHandler'
+        ? preHandlerAsyncHookHandler
+        : K extends 'preSerialization'
+          ? preSerializationAsyncHookHandler
+          : K extends 'onSend'
+            ? onSendAsyncHookHandler
+            : K extends 'onResponse'
+              ? onResponseAsyncHookHandler
+              : K extends 'onRequest'
+                ? onRequestAsyncHookHandler
+                : K extends 'onError'
+                  ? onErrorAsyncHookHandler
+                  : K extends 'onTimeout'
+                    ? onTimeoutAsyncHookHandler
+                    : K extends 'onRequestAbort'
+                      ? onRequestAbortAsyncHookHandler
+                      : never
+
 // Application Hooks
 
 /**
@@ -555,3 +615,43 @@ export interface preCloseAsyncHookHandler<
     this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
   ): Promise<unknown>;
 }
+
+export type ApplicationHook = 'onRoute'
+| 'onRegister'
+| 'onReady'
+| 'onClose'
+| 'preClose'
+
+export type ApplicationHookLookup<K extends ApplicationHook> = K extends 'onRegister'
+  ? onRegisterHookHandler
+  : K extends 'onReady'
+    ? onReadyHookHandler
+    : K extends 'onClose'
+      ? onCloseHookHandler
+      : K extends 'preClose'
+        ? preCloseHookHandler
+        : K extends 'onRoute'
+          ? onRouteHookHandler
+          : never
+
+export type ApplicationHookAsyncLookup<K extends ApplicationHook> = K extends 'onRegister'
+  ? onRegisterHookHandler
+  : K extends 'onReady'
+    ? onReadyAsyncHookHandler
+    : K extends 'onClose'
+      ? onCloseAsyncHookHandler
+      : K extends 'preClose'
+        ? preCloseAsyncHookHandler
+        : never
+
+export type HookLookup <K extends ApplicationHook | LifecycleHook> = K extends ApplicationHook
+  ? ApplicationHookLookup<K>
+  : K extends LifecycleHook
+    ? LifecycleHookLookup<K>
+    : never
+
+export type HookAsyncLookup <K extends ApplicationHook | LifecycleHook> = K extends ApplicationHook
+  ? ApplicationHookAsyncLookup<K>
+  : K extends LifecycleHook
+    ? LifecycleHookAsyncLookup<K>
+    : never