fastify 5.11.3 → 6.0.0-alpha.0

package/test/types/fastify.tst.ts

@@ -1,8 +1,8 @@
+import Ajv, { ErrorObject as AjvErrorObject } from 'ajv'
 import * as http from 'node:http'
 import * as http2 from 'node:http2'
 import * as https from 'node:https'
 import { Socket } from 'node:net'
-import Ajv, { ErrorObject as AjvErrorObject } from 'ajv'
 import { expect } from 'tstyche'
 import fastify, {
   ConnectionError,
@@ -10,7 +10,6 @@ import fastify, {
   FastifyError,
   FastifyErrorCodes,
   FastifyInstance,
-  FastifyPlugin,
   FastifyPluginAsync,
   FastifyPluginCallback,
   InjectOptions,
@@ -127,9 +126,6 @@ expect(fastify({ pluginTimeout: 1000 })).type.toBeAssignableTo<FastifyInstance>(
 expect(fastify({ bodyLimit: 100 })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ handlerTimeout: 5000 })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ maxParamLength: 100 })).type.toBeAssignableTo<FastifyInstance>()
-expect(fastify({ disableRequestLogging: true })).type.toBeAssignableTo<FastifyInstance>()
-expect(fastify({ disableRequestLogging: (req) => req.url?.includes('/health') ?? false })).type.toBeAssignableTo<FastifyInstance>()
-expect(fastify({ requestIdLogLabel: 'request-id' })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ onProtoPoisoning: 'error' })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ onConstructorPoisoning: 'error' })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ serializerOpts: { rounding: 'ceil' } })).type.toBeAssignableTo<FastifyInstance>()
@@ -188,7 +184,7 @@ expect(fastify({ logger: customLogger })).type.toBeAssignableTo<
   FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>
 >()
 expect(fastify({ serverFactory: () => http.createServer() })).type.toBeAssignableTo<FastifyInstance>()
-expect(fastify({ caseSensitive: true })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ routerOptions: { caseSensitive: true } })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ requestIdHeader: 'request-id' })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ requestIdHeader: false })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({
@@ -198,45 +194,46 @@ expect(fastify({
   }
 })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ trustProxy: true })).type.toBeAssignableTo<FastifyInstance>()
-expect(fastify({ querystringParser: () => ({ foo: 'bar' }) })).type.toBeAssignableTo<FastifyInstance>()
-expect(fastify({ querystringParser: () => ({ foo: { bar: 'fuzz' } }) })).type.toBeAssignableTo<FastifyInstance>()
-expect(fastify({ querystringParser: () => ({ foo: ['bar', 'fuzz'] }) })).type.toBeAssignableTo<FastifyInstance>()
-expect(fastify({ constraints: {} })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ routerOptions: { querystringParser: () => ({ foo: 'bar' }) } })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ routerOptions: { querystringParser: () => ({ foo: { bar: 'fuzz' } }) } })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ routerOptions: { querystringParser: () => ({ foo: ['bar', 'fuzz'] }) } })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ routerOptions: { constraints: {} } })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({
-  constraints: {
-    version: {
-      name: 'version',
-      storage: () => ({
-        get: () => () => { },
-        set: () => { },
-        del: () => { },
-        empty: () => { }
-      }),
-      validate () { },
-      deriveConstraint: () => 'foo'
-    },
-    host: {
-      name: 'host',
-      storage: () => ({
-        get: () => () => { },
-        set: () => { },
-        del: () => { },
-        empty: () => { }
-      }),
-      validate () { },
-      deriveConstraint: () => 'foo'
-    },
-    withObjectValue: {
-      name: 'withObjectValue',
-      storage: () => ({
-        get: () => () => { },
-        set: () => { },
-        del: () => { },
-        empty: () => { }
-      }),
-      validate () { },
-      deriveConstraint: () => { }
-
+  routerOptions: {
+    constraints: {
+      version: {
+        name: 'version',
+        storage: () => ({
+          get: () => () => { },
+          set: () => { },
+          del: () => { },
+          empty: () => { }
+        }),
+        validate () { },
+        deriveConstraint: () => 'foo'
+      },
+      host: {
+        name: 'host',
+        storage: () => ({
+          get: () => () => { },
+          set: () => { },
+          del: () => { },
+          empty: () => { }
+        }),
+        validate () { },
+        deriveConstraint: () => 'foo'
+      },
+      withObjectValue: {
+        name: 'withObjectValue',
+        storage: () => ({
+          get: () => () => { },
+          set: () => { },
+          del: () => { },
+          empty: () => { }
+        }),
+        validate () { },
+        deriveConstraint: () => { }
+      }
     }
   }
 })).type.toBeAssignableTo<FastifyInstance>()
@@ -322,7 +319,6 @@ fastify().then(fastifyInstance => expect(fastifyInstance).type.toBeAssignableTo<
 
 expect<FastifyPluginAsync>().type.toBeAssignableFrom(async () => { })
 expect<FastifyPluginCallback>().type.toBeAssignableFrom(() => { })
-expect<FastifyPlugin>().type.toBeAssignableFrom(() => { })
 
 const ajvErrorObject: AjvErrorObject = {
   keyword: '',
@@ -354,9 +350,9 @@ expect<RouteGenericInterface['Reply']>().type.toBe<unknown>()
 // ErrorCodes
 expect(fastify.errorCodes).type.toBe<FastifyErrorCodes>()
 
-fastify({ allowUnsafeRegex: true })
-fastify({ allowUnsafeRegex: false })
-expect(fastify).type.not.toBeCallableWith({ allowUnsafeRegex: 'invalid' })
+fastify({ routerOptions: { allowUnsafeRegex: true } })
+fastify({ routerOptions: { allowUnsafeRegex: false } })
+expect(fastify).type.not.toBeCallableWith({ routerOptions: { allowUnsafeRegex: 'invalid' } })
 
 expect(fastify({ allowErrorHandlerOverride: true })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ allowErrorHandlerOverride: false })).type.toBeAssignableTo<FastifyInstance>()

package/test/types/instance.tst.ts

@@ -314,13 +314,11 @@ type InitialConfig = Readonly<{
   https?: boolean | Readonly<{ allowHTTP1: boolean }>,
   ignoreTrailingSlash?: boolean,
   ignoreDuplicateSlashes?: boolean,
-  disableRequestLogging?: boolean | ((req: FastifyRequest) => boolean),
   maxParamLength?: number,
   onProtoPoisoning?: 'error' | 'remove' | 'ignore',
   onConstructorPoisoning?: 'error' | 'remove' | 'ignore',
   pluginTimeout?: number,
   requestIdHeader?: string | false,
-  requestIdLogLabel?: string,
   http2SessionTimeout?: number,
   useSemicolonDelimiter?: boolean,
   routerOptions?: FastifyRouterOptions<RawServerDefault>
@@ -328,9 +326,10 @@ type InitialConfig = Readonly<{
 
 expect(fastify().initialConfig).type.toBe<InitialConfig>()
 
-expect<FastifyRouterOptions<RawServerDefault>>().type.toBeAssignableTo<
-  FindMyWayConfig<FindMyWayVersion<RawServerDefault>>
->()
+// TODO: we accept wider types than find-my-way and it cannot be assign to a restricted types
+// expect<FastifyRouterOptions<RawServerDefault>>().type.toBeAssignableTo<
+//   FindMyWayConfig<FindMyWayVersion<RawServerDefault>>
+// >()
 
 fastify({
   routerOptions: {

package/test/types/logger.tst.ts

@@ -10,7 +10,6 @@ import fastify, {
   FastifyRequest,
   LogLevel
 } from '../../fastify.js'
-import { ResSerializerReply } from '../../types/logger.js'
 
 expect(fastify().log).type.toBe<FastifyBaseLogger>()
 
@@ -158,8 +157,7 @@ const serverWithPinoConfig = fastify({
         }
       },
       res (reply) {
-        expect(reply).type.toBe<ResSerializerReply<Server, FastifyReply>>()
-        expect(reply).type.toBeAssignableTo<Partial<FastifyReply> & Pick<FastifyReply, 'statusCode'>>()
+        expect(reply).type.toBe<Partial<FastifyReply>>()
         expect(reply).type.not.toBeAssignableTo<FastifyReply>()
         return {
           statusCode: 'statusCode'
@@ -194,8 +192,7 @@ const serverAutoInferredSerializerResponseObjectOption = fastify({
   logger: {
     serializers: {
       res (reply) {
-        expect(reply).type.toBe<ResSerializerReply<Server, FastifyReply>>()
-        expect(reply).type.toBeAssignableTo<Partial<FastifyReply> & Pick<FastifyReply, 'statusCode'>>()
+        expect(reply).type.toBe<Partial<FastifyReply>>()
         expect(reply).type.not.toBeAssignableTo<FastifyReply>()
         return {
           status: '200'
@@ -223,8 +220,7 @@ const serverAutoInferredSerializerObjectOption = fastify({
         }
       },
       res (reply) {
-        expect(reply).type.toBe<ResSerializerReply<Server, FastifyReply>>()
-        expect(reply).type.toBeAssignableTo<Partial<FastifyReply> & Pick<FastifyReply, 'statusCode'>>()
+        expect(reply).type.toBe<Partial<FastifyReply>>()
         expect(reply).type.not.toBeAssignableTo<FastifyReply>()
         return {
           statusCode: 'statusCode'

package/test/use-semicolon-delimiter.test.js

@@ -23,66 +23,6 @@ test('use semicolon delimiter default false', async (t) => {
   t.assert.deepStrictEqual(body, {})
 })
 
-test('use semicolon delimiter set to true', async (t) => {
-  t.plan(3)
-  const fastify = Fastify({
-    useSemicolonDelimiter: true
-  })
-
-  fastify.get('/1234', (req, reply) => {
-    reply.send(req.query)
-  })
-
-  const fastifyServer = await fastify.listen({ port: 0 })
-  t.after(() => { fastify.close() })
-
-  const result = await fetch(fastifyServer + '/1234;foo=bar')
-  t.assert.ok(result.ok)
-  t.assert.strictEqual(result.status, 200)
-  t.assert.deepStrictEqual(await result.json(), {
-    foo: 'bar'
-  })
-})
-
-test('use semicolon delimiter set to false', async (t) => {
-  t.plan(3)
-
-  const fastify = Fastify({
-    useSemicolonDelimiter: false
-  })
-
-  fastify.get('/1234;foo=bar', (req, reply) => {
-    reply.send(req.query)
-  })
-
-  const fastifyServer = await fastify.listen({ port: 0 })
-  t.after(() => { fastify.close() })
-
-  const result = await fetch(fastifyServer + '/1234;foo=bar')
-  t.assert.ok(result.ok)
-  t.assert.strictEqual(result.status, 200)
-  t.assert.deepStrictEqual(await result.json(), {})
-})
-
-test('use semicolon delimiter set to false return 404', async (t) => {
-  t.plan(2)
-
-  const fastify = Fastify({
-    useSemicolonDelimiter: false
-  })
-
-  fastify.get('/1234', (req, reply) => {
-    reply.send(req.query)
-  })
-
-  const fastifyServer = await fastify.listen({ port: 0 })
-  t.after(() => { fastify.close() })
-
-  const result = await fetch(fastifyServer + '/1234;foo=bar')
-  t.assert.ok(!result.ok)
-  t.assert.strictEqual(result.status, 404)
-})
-
 test('use routerOptions semicolon delimiter default false', async t => {
   t.plan(3)
 

package/types/context.d.ts

@@ -1,22 +1,2 @@
-import { FastifyRouteConfig } from './route'
-import { ContextConfigDefault } from './utils'
-
 export interface FastifyContextConfig {
 }
-
-/**
- * Route context object. Properties defined here will be available in the route's handler
- */
-export interface FastifyRequestContext<ContextConfig = ContextConfigDefault> {
-  /**
-   * @deprecated Use Request#routeOptions#config or Request#routeOptions#schema instead
-   */
-  config: FastifyContextConfig & FastifyRouteConfig & ContextConfig;
-}
-
-export interface FastifyReplyContext<ContextConfig = ContextConfigDefault> {
-  /**
-   * @deprecated Use Reply#routeOptions#config or Reply#routeOptions#schema instead
-   */
-  config: FastifyContextConfig & FastifyRouteConfig & ContextConfig;
-}

package/types/errors.d.ts

@@ -74,6 +74,7 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_ROUTE_HANDLER_NOT_FN' |
   'FST_ERR_ROUTE_MISSING_HANDLER' |
   'FST_ERR_ROUTE_METHOD_INVALID' |
+  'FST_ERR_ROUTE_METHOD_ALREADY_SUPPORTED' |
   'FST_ERR_ROUTE_METHOD_NOT_SUPPORTED' |
   'FST_ERR_ROUTE_LOG_LEVEL_INVALID' |
   'FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED' |
@@ -85,7 +86,7 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_ROUTE_MISSING_CONTENT' |
   'FST_ERR_REOPENED_CLOSE_SERVER' |
   'FST_ERR_REOPENED_SERVER' |
-  'FST_ERR_INSTANCE_ALREADY_LISTENING' |
+  'FST_ERR_INSTANCE_ALREADY_STARTED' |
   'FST_ERR_PLUGIN_VERSION_MISMATCH' |
   'FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE' |
   'FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER' |

package/types/instance.d.ts

@@ -701,15 +701,11 @@ export interface FastifyInstance<
     https?: boolean | Readonly<{ allowHTTP1: boolean }>,
     ignoreTrailingSlash?: boolean,
     ignoreDuplicateSlashes?: boolean,
-    /** @deprecated Use the `logController` option with `disableRequestLogging` or `isLogDisabled` override instead. Will be removed in `fastify@6`. */
-    disableRequestLogging?: boolean | ((req: FastifyRequest) => boolean),
     maxParamLength?: number,
     onProtoPoisoning?: ProtoAction,
     onConstructorPoisoning?: ConstructorAction,
     pluginTimeout?: number,
     requestIdHeader?: string | false,
-    /** @deprecated Use the `logController` option with `requestIdLogLabel` instead. Will be removed in `fastify@6`. */
-    requestIdLogLabel?: string,
     http2SessionTimeout?: number,
     useSemicolonDelimiter?: boolean,
     routerOptions?: FastifyRouterOptions<RawServer>

package/types/logger.d.ts

@@ -28,25 +28,10 @@ export interface FastifyBaseLogger extends Pick<BaseLogger, 'level' | 'info' | '
   child(bindings: Bindings, options?: ChildLoggerOptions): FastifyBaseLogger
 }
 
-// TODO delete FastifyLoggerInstance in the next major release. It seems that it is enough to have only FastifyBaseLogger.
-/**
- * @deprecated Use FastifyBaseLogger instead
- */
-export type FastifyLoggerInstance = FastifyBaseLogger
-
 export interface FastifyLoggerStreamDestination {
   write(msg: string): void;
 }
 
-// TODO: once node 18 is EOL, this type can be replaced with plain FastifyReply.
-/**
- * Specialized reply type used for the `res` log serializer, since only `statusCode` is passed in certain cases.
- */
-export type ResSerializerReply<
-  RawServer extends RawServerBase,
-  RawReply extends FastifyReply<RouteGenericInterface, RawServer>
-> = Partial<RawReply> & Pick<RawReply, 'statusCode'>
-
 /**
  * Fastify Custom Logger options.
  */
@@ -99,7 +84,7 @@ export interface FastifyLoggerOptions<
       stack: string;
       [key: string]: unknown;
     };
-    res?: (res: ResSerializerReply<RawServer, RawReply>) => {
+    res?: (res: Partial<RawReply>) => {
       statusCode?: string | number;
       [key: string]: unknown;
     };

package/types/plugin.d.ts

@@ -37,12 +37,3 @@ export type FastifyPluginAsync<
     TypeProvider>,
   opts: Options
 ) => Promise<void>
-
-/**
- * Generic plugin type.
- * @deprecated union type doesn't work well with type inference in TS and is therefore deprecated in favor of explicit types. Use `FastifyPluginCallback` or `FastifyPluginAsync` instead. To activate
- * plugins use `FastifyRegister`. https://fastify.dev/docs/latest/Reference/TypeScript/#register
- */
-export type FastifyPlugin<
-  Options extends FastifyPluginOptions = Record<never, never>
-> = FastifyPluginCallback<Options> | FastifyPluginAsync<Options>

package/types/request.d.ts

@@ -67,10 +67,6 @@ export interface FastifyRequest<RouteGeneric extends RouteGenericInterface = Rou
   /** in order for this to be used the user should ensure they have set the attachValidation option. */
   validationError?: Error & { validation: any; validationContext: string };
 
-  /**
-   * @deprecated Use `raw` property
-   */
-  readonly req: RawRequest & RouteGeneric['Headers']; // this enables the developer to extend the existing http(s|2) headers list
   /**
    * Derived from request socket metadata or forwarding headers.
    * Treat as untrusted input and validate before security-sensitive use.

package/lib/promise.js

@@ -1,23 +0,0 @@
-'use strict'
-
-const { kTestInternals } = require('./symbols')
-
-function withResolvers () {
-  let res, rej
-  const promise = new Promise((resolve, reject) => {
-    res = resolve
-    rej = reject
-  })
-  return { promise, resolve: res, reject: rej }
-}
-
-module.exports = {
-  // TODO(20.x): remove when node@20 is not supported
-  withResolvers: typeof Promise.withResolvers === 'function'
-    ? Promise.withResolvers.bind(Promise) // Promise.withResolvers must bind to itself
-    /* c8 ignore next */
-    : withResolvers, // Tested using the kTestInternals
-  [kTestInternals]: {
-    withResolvers
-  }
-}

package/test/internals/promise.test.js

@@ -1,63 +0,0 @@
-'use strict'
-
-const { test } = require('node:test')
-
-const { kTestInternals } = require('../../lib/symbols')
-const PonyPromise = require('../../lib/promise')
-
-test('withResolvers', async (t) => {
-  t.plan(3)
-  await t.test('resolve', async (t) => {
-    t.plan(1)
-    const { promise, resolve } = PonyPromise.withResolvers()
-    resolve(true)
-    t.assert.ok(await promise)
-  })
-  await t.test('reject', async (t) => {
-    t.plan(1)
-    const { promise, reject } = PonyPromise.withResolvers()
-    await t.assert.rejects(async () => {
-      reject(Error('reject'))
-      return promise
-    }, {
-      name: 'Error',
-      message: 'reject'
-    })
-  })
-  await t.test('thenable', async (t) => {
-    t.plan(1)
-    const { promise, resolve } = PonyPromise.withResolvers()
-    resolve(true)
-    promise.then((value) => {
-      t.assert.ok(value)
-    })
-  })
-})
-
-test('withResolvers - ponyfill', async (t) => {
-  await t.test('resolve', async (t) => {
-    t.plan(1)
-    const { promise, resolve } = PonyPromise[kTestInternals].withResolvers()
-    resolve(true)
-    t.assert.ok(await promise)
-  })
-  await t.test('reject', async (t) => {
-    t.plan(1)
-    const { promise, reject } = PonyPromise[kTestInternals].withResolvers()
-    await t.assert.rejects(async () => {
-      reject(Error('reject'))
-      return promise
-    }, {
-      name: 'Error',
-      message: 'reject'
-    })
-  })
-  await t.test('thenable', async (t) => {
-    t.plan(1)
-    const { promise, resolve } = PonyPromise.withResolvers()
-    resolve(true)
-    promise.then((value) => {
-      t.assert.ok(value)
-    })
-  })
-})