fastify 4.27.0 → 5.0.0-alpha.2

package/types/route.d.ts

@@ -1,6 +1,6 @@
 import { FastifyError } from '@fastify/error'
 import { ConstraintStrategy } from 'find-my-way'
-import { FastifyRequestContext } from './context'
+import { FastifyContextConfig } from './context'
 import { onErrorMetaHookHandler, onRequestAbortMetaHookHandler, onRequestMetaHookHandler, onResponseMetaHookHandler, onSendMetaHookHandler, onTimeoutMetaHookHandler, preHandlerMetaHookHandler, preParsingMetaHookHandler, preSerializationMetaHookHandler, preValidationMetaHookHandler } from './hooks'
 import { FastifyInstance } from './instance'
 import { FastifyBaseLogger, FastifyChildLoggerFactory, LogLevel } from './logger'
@@ -48,44 +48,44 @@ export interface RouteShorthandOptions<
   attachValidation?: boolean;
   exposeHeadRoute?: boolean;
 
-  validatorCompiler?: FastifySchemaCompiler<SchemaCompiler>;
-  serializerCompiler?: FastifySerializerCompiler<SchemaCompiler>;
+  validatorCompiler?: FastifySchemaCompiler<NoInfer<SchemaCompiler>>;
+  serializerCompiler?: FastifySerializerCompiler<NoInfer<SchemaCompiler>>;
   bodyLimit?: number;
   logLevel?: LogLevel;
-  config?: Omit<FastifyRequestContext<ContextConfig>['config'], 'url' | 'method'>;
+  config?: FastifyContextConfig & ContextConfig;
   version?: string;
   constraints?: RouteConstraint,
-  prefixTrailingSlash?: 'slash'|'no-slash'|'both';
+  prefixTrailingSlash?: 'slash' | 'no-slash' | 'both';
   errorHandler?: (
     this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
     error: FastifyError,
-    request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider, ContextConfig, Logger>,
-    reply: FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>
+    request: FastifyRequest<RouteGeneric, RawServer, RawRequest, NoInfer<SchemaCompiler>, TypeProvider, ContextConfig, Logger>,
+    reply: FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider>
   ) => void;
   childLoggerFactory?: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
   schemaErrorFormatter?: SchemaErrorFormatter;
 
   // hooks
-  onRequest?: onRequestMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | onRequestMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
-  preParsing?: preParsingMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | preParsingMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
-  preValidation?: preValidationMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | preValidationMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
-  preHandler?: preHandlerMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | preHandlerMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
-  preSerialization?: preSerializationMetaHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | preSerializationMetaHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
-  onSend?: onSendMetaHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | onSendMetaHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
-  onResponse?: onResponseMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | onResponseMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
-  onTimeout?: onTimeoutMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | onTimeoutMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
-  onError?: onErrorMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, FastifyError, SchemaCompiler, TypeProvider, Logger>
-  | onErrorMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, FastifyError, SchemaCompiler, TypeProvider, Logger>[];
-  onRequestAbort?: onRequestAbortMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | onRequestAbortMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
+  onRequest?: onRequestMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>
+  | onRequestMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>[];
+  preParsing?: preParsingMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>
+  | preParsingMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>[];
+  preValidation?: preValidationMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>
+  | preValidationMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>[];
+  preHandler?: preHandlerMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>
+  | preHandlerMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>[];
+  preSerialization?: preSerializationMetaHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>
+  | preSerializationMetaHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>[];
+  onSend?: onSendMetaHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>
+  | onSendMetaHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>[];
+  onResponse?: onResponseMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>
+  | onResponseMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>[];
+  onTimeout?: onTimeoutMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>
+  | onTimeoutMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>[];
+  onError?: onErrorMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, FastifyError, NoInfer<SchemaCompiler>, TypeProvider, Logger>
+  | onErrorMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, FastifyError, NoInfer<SchemaCompiler>, TypeProvider, Logger>[];
+  onRequestAbort?: onRequestAbortMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>
+  | onRequestAbortMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>[];
 }
 /**
  * Route handler method declaration.
@@ -119,7 +119,7 @@ export interface RouteShorthandOptionsWithHandler<
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
   Logger extends FastifyBaseLogger = FastifyBaseLogger
 > extends RouteShorthandOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger> {
-  handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>;
+  handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>;
 }
 
 /**
@@ -183,4 +183,4 @@ export type RouteHandler<
 export type DefaultRoute<Request, Reply> = (
   req: Request,
   res: Reply,
-) => void;
+) => void

package/types/schema.d.ts

@@ -1,6 +1,6 @@
 import { ValidatorFactory } from '@fastify/ajv-compiler'
 import { SerializerFactory } from '@fastify/fast-json-stringify-compiler'
-import { FastifyInstance } from '../fastify'
+import { FastifyInstance, SafePromiseLike } from '../fastify'
 /**
  * Schemas in Fastify follow the JSON-Schema standard. For this reason
  * we have opted to not ship strict schema based types. Instead we provide
@@ -33,7 +33,7 @@ export interface FastifySchemaValidationError {
 }
 
 export interface FastifyValidationResult {
-  (data: any): boolean | PromiseLike<any> | { error?: Error, value?: any }
+  (data: any): boolean | SafePromiseLike<any> | { error?: Error, value?: any }
   errors?: FastifySchemaValidationError[] | null;
 }
 
@@ -44,7 +44,7 @@ export type FastifySchemaCompiler<T> = (routeSchema: FastifyRouteSchemaDef<T>) =
 
 export type FastifySerializerCompiler<T> = (routeSchema: FastifyRouteSchemaDef<T>) => (data: any) => string
 
-export interface FastifySchemaControllerOptions{
+export interface FastifySchemaControllerOptions {
   bucket?: (parentSchemas?: unknown) => {
     add(schema: unknown): FastifyInstance;
     getSchema(schemaId: string): unknown;

package/types/serverFactory.d.ts

@@ -9,8 +9,8 @@ export type FastifyServerFactoryHandler<
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>
 > =
 RawServer extends http.Server | https.Server ?
-  (request: http.IncomingMessage & RawRequest, response: http.ServerResponse & RawReply) => void :
-  (request: http2.Http2ServerRequest & RawRequest, response: http2.Http2ServerResponse & RawReply) => void
+    (request: http.IncomingMessage & RawRequest, response: http.ServerResponse & RawReply) => void :
+    (request: http2.Http2ServerRequest & RawRequest, response: http2.Http2ServerResponse & RawReply) => void
 
 export interface FastifyServerFactory<
   RawServer extends RawServerBase = RawServerDefault

package/types/type-provider.d.ts

@@ -7,14 +7,15 @@ import { RecordKeysToLowercase } from './utils'
 // -----------------------------------------------------------------------------------------------
 
 export interface FastifyTypeProvider {
-  readonly input: unknown,
-  readonly output: unknown,
+  readonly schema: unknown,
+  readonly validator: unknown,
+  readonly serializer: unknown,
 }
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface FastifyTypeProviderDefault extends FastifyTypeProvider {}
 
-export type CallTypeProvider<F extends FastifyTypeProvider, I> = (F & { input: I })['output']
+export type CallValidatorTypeProvider<F extends FastifyTypeProvider, S> = (F & { schema: S })['validator']
+export type CallSerializerTypeProvider<F extends FastifyTypeProvider, S> = (F & { schema: S })['serializer']
 
 // -----------------------------------------------------------------------------------------------
 // FastifyRequestType
@@ -32,13 +33,13 @@ type KeysOf<T> = T extends any ? keyof T : never
 
 // Resolves Request types either from generic argument or Type Provider.
 type ResolveRequestParams<TypeProvider extends FastifyTypeProvider, SchemaCompiler extends FastifySchema, RouteGeneric extends RouteGenericInterface> =
-  UndefinedToUnknown<KeysOf<RouteGeneric['Params']> extends never ? CallTypeProvider<TypeProvider, SchemaCompiler['params']> : RouteGeneric['Params']>
+  UndefinedToUnknown<KeysOf<RouteGeneric['Params']> extends never ? CallValidatorTypeProvider<TypeProvider, SchemaCompiler['params']> : RouteGeneric['Params']>
 type ResolveRequestQuerystring<TypeProvider extends FastifyTypeProvider, SchemaCompiler extends FastifySchema, RouteGeneric extends RouteGenericInterface> =
-  UndefinedToUnknown<KeysOf<RouteGeneric['Querystring']> extends never ? CallTypeProvider<TypeProvider, SchemaCompiler['querystring']> : RouteGeneric['Querystring']>
+  UndefinedToUnknown<KeysOf<RouteGeneric['Querystring']> extends never ? CallValidatorTypeProvider<TypeProvider, SchemaCompiler['querystring']> : RouteGeneric['Querystring']>
 type ResolveRequestHeaders<TypeProvider extends FastifyTypeProvider, SchemaCompiler extends FastifySchema, RouteGeneric extends RouteGenericInterface> =
-  UndefinedToUnknown<KeysOf<RouteGeneric['Headers']> extends never ? CallTypeProvider<TypeProvider, SchemaCompiler['headers']> : RouteGeneric['Headers']>
+  UndefinedToUnknown<KeysOf<RouteGeneric['Headers']> extends never ? CallValidatorTypeProvider<TypeProvider, SchemaCompiler['headers']> : RouteGeneric['Headers']>
 type ResolveRequestBody<TypeProvider extends FastifyTypeProvider, SchemaCompiler extends FastifySchema, RouteGeneric extends RouteGenericInterface> =
-  UndefinedToUnknown<KeysOf<RouteGeneric['Body']> extends never ? CallTypeProvider<TypeProvider, SchemaCompiler['body']> : RouteGeneric['Body']>
+  UndefinedToUnknown<KeysOf<RouteGeneric['Body']> extends never ? CallValidatorTypeProvider<TypeProvider, SchemaCompiler['body']> : RouteGeneric['Body']>
 
 // The target request type. This type is inferenced on fastify 'requests' via generic argument assignment
 export interface FastifyRequestType<Params = unknown, Querystring = unknown, Headers = unknown, Body = unknown> {
@@ -63,8 +64,8 @@ export interface ResolveFastifyRequestType<TypeProvider extends FastifyTypeProvi
 // Resolves the Reply type by taking a union of response status codes and content-types
 type ResolveReplyFromSchemaCompiler<TypeProvider extends FastifyTypeProvider, SchemaCompiler extends FastifySchema> = {
   [K1 in keyof SchemaCompiler['response']]: SchemaCompiler['response'][K1] extends { content: { [keyof: string]: { schema: unknown } } } ? ({
-    [K2 in keyof SchemaCompiler['response'][K1]['content']]: CallTypeProvider<TypeProvider, SchemaCompiler['response'][K1]['content'][K2]['schema']>
-  } extends infer Result ? Result[keyof Result] : unknown) : CallTypeProvider<TypeProvider, SchemaCompiler['response'][K1]>
+    [K2 in keyof SchemaCompiler['response'][K1]['content']]: CallSerializerTypeProvider<TypeProvider, SchemaCompiler['response'][K1]['content'][K2]['schema']>
+  } extends infer Result ? Result[keyof Result] : unknown) : CallSerializerTypeProvider<TypeProvider, SchemaCompiler['response'][K1]>
 } extends infer Result ? Result[keyof Result] : unknown;
 
 // The target reply type. This type is inferenced on fastify 'replies' via generic argument assignment
@@ -83,13 +84,22 @@ export type ResolveFastifyReplyType<TypeProvider extends FastifyTypeProvider, Sc
 export type ResolveFastifyReplyReturnType<
   TypeProvider extends FastifyTypeProvider,
   SchemaCompiler extends FastifySchema,
-  RouteGeneric extends RouteGenericInterface,
+  RouteGeneric extends RouteGenericInterface
 > = ResolveFastifyReplyType<
 TypeProvider,
 SchemaCompiler,
 RouteGeneric
 > extends infer Return ?
-  (Return | void | Promise<Return | void>)
+    (Return | void | Promise<Return | void>)
 // review: support both async and sync return types
 // (Promise<Return> | Return | Promise<void> | void)
   : unknown
+
+/**
+ * This branded type is needed to indicate APIs that return Promise-likes which can
+ * safely "float" (not have rejections handled by calling code).
+ *
+ * Please refer to the following Github issue for more info:
+ * https://github.com/fastify/fastify/issues/5498
+ */
+export type SafePromiseLike<T> = PromiseLike<T> & { __linterBrands: 'SafePromiseLike' }

package/types/utils.d.ts

@@ -24,7 +24,7 @@ export type RawServerDefault = http.Server
  * The default request type based on the server type. Utilizes generic constraining.
  */
 export type RawRequestDefaultExpression<
-  RawServer extends RawServerBase = RawServerDefault,
+  RawServer extends RawServerBase = RawServerDefault
 > = RawServer extends http.Server | https.Server ? http.IncomingMessage
   : RawServer extends http2.Http2Server | http2.Http2SecureServer ? http2.Http2ServerRequest
     : never
@@ -50,41 +50,41 @@ export type ReplyDefault = unknown
  * Helpers for determining the type of the response payload based on the code
  */
 
-type StringAsNumber<T extends string> = T extends `${infer N extends number}` ? N : never;
-type CodeClasses = 1 | 2 | 3 | 4 | 5;
-type Digit = 0 |1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
-type HttpCodes = StringAsNumber<`${CodeClasses}${Digit}${Digit}`>;
-type HttpKeys = HttpCodes | `${Digit}xx`;
+type StringAsNumber<T extends string> = T extends `${infer N extends number}` ? N : never
+type CodeClasses = 1 | 2 | 3 | 4 | 5
+type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+type HttpCodes = StringAsNumber<`${CodeClasses}${Digit}${Digit}`>
+type HttpKeys = HttpCodes | `${Digit}xx`
 export type StatusCodeReply = {
-  // eslint-disable-next-line no-unused-vars
+
   [Key in HttpKeys]?: unknown;
-};
+}
 
 // weird TS quirk: https://stackoverflow.com/questions/58977876/generic-conditional-type-resolves-to-never-when-the-generic-type-is-set-to-never
 export type ReplyKeysToCodes<Key> = [Key] extends [never] ? number :
   Key extends HttpCodes ? Key :
     Key extends `${infer X extends CodeClasses}xx` ?
-      StringAsNumber<`${X}${Digit}${Digit}`> : number;
+      StringAsNumber<`${X}${Digit}${Digit}`> : number
 
 export type CodeToReplyKey<Code extends number> = `${Code}` extends `${infer FirstDigit extends CodeClasses}${number}`
   ? `${FirstDigit}xx`
-  : never;
+  : never
 
 export type RecordKeysToLowercase<Input> = Input extends Record<string, unknown>
   ? {
-    [Key in keyof Input as Key extends string
-      ? Lowercase<Key>
-      : Key
-    ]: Input[Key];
-  }
-  : Input;
+      [Key in keyof Input as Key extends string
+        ? Lowercase<Key>
+        : Key
+      ]: Input[Key];
+    }
+  : Input
 
 type OmitIndexSignature<T> = {
   [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K];
-};
+}
 
 /**
  * HTTP header strings
  * Use this type only for input values, not for output values.
  */
-export type HttpHeader = keyof OmitIndexSignature<http.OutgoingHttpHeaders> | (string & Record<never, never>);
+export type HttpHeader = keyof OmitIndexSignature<http.OutgoingHttpHeaders> | (string & Record<never, never>)

package/.c8rc.json

@@ -1,8 +0,0 @@
-{
-  "exclude": [
-    "lib/configValidator.js",
-    "lib/error-serializer.js",
-    "build/build-error-serializer.js",
-    "test/*"
-  ]
-}

package/.eslintrc

@@ -1,4 +0,0 @@
-{
-  "root": true,
-  "extends": "standard"
-}

package/test/default-route.test.js

@@ -1,88 +0,0 @@
-'use strict'
-
-const t = require('tap')
-const test = t.test
-const Fastify = require('..')
-const { FSTDEP014 } = require('../lib/warnings')
-
-// Silence the standard warning logs. We will test the messages explicitly.
-process.removeAllListeners('warning')
-
-test('setDefaultRoute should emit a deprecation warning', t => {
-  t.plan(2)
-
-  const fastify = Fastify()
-  const defaultRoute = (req, res) => {
-    res.end('hello from defaultRoute')
-  }
-
-  process.on('warning', onWarning)
-  function onWarning (warning) {
-    t.equal(warning.name, 'DeprecationWarning')
-    t.equal(warning.code, FSTDEP014.code)
-  }
-
-  t.teardown(() => {
-    process.removeListener('warning', onWarning)
-    FSTDEP014.emitted = false
-  })
-
-  fastify.setDefaultRoute(defaultRoute)
-})
-
-test('getDefaultRoute should emit a deprecation warning', t => {
-  t.plan(2)
-
-  const fastify = Fastify()
-
-  process.on('warning', onWarning)
-  function onWarning (warning) {
-    t.equal(warning.name, 'DeprecationWarning')
-    t.equal(warning.code, FSTDEP014.code)
-  }
-
-  t.teardown(() => {
-    process.removeListener('warning', onWarning)
-    FSTDEP014.emitted = false
-  })
-
-  fastify.getDefaultRoute()
-})
-
-test('should fail if defaultRoute is not a function', t => {
-  t.plan(1)
-
-  const fastify = Fastify()
-  const defaultRoute = {}
-
-  fastify.get('/', () => {})
-
-  try {
-    fastify.setDefaultRoute(defaultRoute)
-  } catch (error) {
-    t.equal(error.code, 'FST_ERR_DEFAULT_ROUTE_INVALID_TYPE')
-  }
-})
-
-test('correctly sets, returns, and calls defaultRoute', t => {
-  t.plan(3)
-
-  const fastify = Fastify()
-  const defaultRoute = (req, res) => {
-    res.end('hello from defaultRoute')
-  }
-
-  fastify.setDefaultRoute(defaultRoute)
-  const returnedDefaultRoute = fastify.getDefaultRoute()
-  t.equal(returnedDefaultRoute, defaultRoute)
-
-  fastify.get('/', () => {})
-
-  fastify.inject({
-    method: 'GET',
-    url: '/random'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.body, 'hello from defaultRoute')
-  })
-})

package/test/listen.deprecated.test.js

@@ -1,229 +0,0 @@
-'use strict'
-
-// Tests for deprecated `.listen` signature. This file should be
-// removed when the deprecation is complete.
-
-const { test, before } = require('tap')
-const Fastify = require('..')
-const helper = require('./helper')
-
-let localhost
-let localhostForURL
-
-process.removeAllListeners('warning')
-
-before(async () => {
-  [localhost, localhostForURL] = await helper.getLoopbackHost()
-})
-
-test('listen accepts a port and a callback', t => {
-  t.plan(2)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen(0, (err) => {
-    t.equal(fastify.server.address().address, localhost)
-    t.error(err)
-  })
-})
-
-test('listen accepts a port and a callback with (err, address)', t => {
-  t.plan(2)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen(0, (err, address) => {
-    t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
-    t.error(err)
-  })
-})
-
-test('listen accepts a port, address, and callback', t => {
-  t.plan(1)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen(0, localhost, (err) => {
-    t.error(err)
-  })
-})
-
-test('listen accepts options, backlog and a callback', t => {
-  t.plan(1)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen({
-    port: 0,
-    host: 'localhost'
-  }, 511, (err) => {
-    t.error(err)
-  })
-})
-
-test('listen accepts options (no port), backlog and a callback', t => {
-  t.plan(1)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen({
-    host: 'localhost'
-  }, 511, (err) => {
-    t.error(err)
-  })
-})
-
-test('listen accepts options (no host), backlog and a callback', t => {
-  t.plan(1)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen({
-    port: 0
-  }, 511, (err) => {
-    t.error(err)
-  })
-})
-
-test('listen accepts options (no port, no host), backlog and a callback', t => {
-  t.plan(1)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen({
-    ipv6Only: false
-  }, 511, (err) => {
-    t.error(err)
-  })
-})
-
-test('listen accepts a port, address and a callback with (err, address)', t => {
-  t.plan(2)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen(0, localhost, (err, address) => {
-    t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
-    t.error(err)
-  })
-})
-
-test('listen accepts a port, address, backlog and callback', t => {
-  t.plan(1)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen(0, localhost, 511, (err) => {
-    t.error(err)
-  })
-})
-
-test('listen accepts a port, address, backlog and callback with (err, address)', t => {
-  t.plan(2)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen(0, localhost, 511, (err, address) => {
-    t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
-    t.error(err)
-  })
-})
-
-test('listen without callback (port zero)', t => {
-  t.plan(1)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen(0)
-    .then(() => {
-      t.equal(fastify.server.address().address, localhost)
-    })
-})
-
-test('listen without callback (port not given)', t => {
-  t.plan(1)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen()
-    .then(() => {
-      t.equal(fastify.server.address().address, localhost)
-    })
-})
-
-test('listen null without callback with (address)', t => {
-  t.plan(1)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen(null)
-    .then(address => {
-      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
-    })
-})
-
-test('listen without port without callback with (address)', t => {
-  t.plan(1)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen()
-    .then(address => {
-      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
-    })
-})
-
-test('listen with undefined without callback with (address)', t => {
-  t.plan(1)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen(undefined)
-    .then(address => {
-      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
-    })
-})
-
-test('listen when firstArg is string(pipe) and without backlog', async t => {
-  t.plan(1)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  const address = await fastify.listen('\\\\.\\pipe\\testPipe')
-  t.equal(address, '\\\\.\\pipe\\testPipe')
-})
-
-test('listen when firstArg is string(pipe) and with backlog', async t => {
-  t.plan(1)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  const address = await fastify.listen('\\\\.\\pipe\\testPipe2', 511)
-  t.equal(address, '\\\\.\\pipe\\testPipe2')
-})
-
-test('listen when firstArg is { path: string(pipe) } and with backlog and callback', t => {
-  t.plan(2)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen({ path: '\\\\.\\pipe\\testPipe3' }, 511, (err, address) => {
-    t.error(err)
-    t.equal(address, '\\\\.\\pipe\\testPipe3')
-  })
-})
-
-test('listen accepts a port as string, and callback', t => {
-  t.plan(2)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  const port = 3000
-  fastify.listen(port.toString(), localhost, (err) => {
-    t.equal(fastify.server.address().port, port)
-    t.error(err)
-  })
-})
-
-test('listen accepts a port as string, address and callback', t => {
-  t.plan(3)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  const port = 3000
-  fastify.listen(port.toString(), localhost, (err) => {
-    t.equal(fastify.server.address().port, port)
-    t.equal(fastify.server.address().address, localhost)
-    t.error(err)
-  })
-})
-
-test('listen with invalid port string without callback with (address)', t => {
-  t.plan(1)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen('-1')
-    .then(address => {
-      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
-    })
-})

package/test/unsupported-httpversion.test.js

@@ -1,31 +0,0 @@
-'use strict'
-
-const net = require('node:net')
-const t = require('tap')
-const Fastify = require('../fastify')
-
-t.test('Will return 505 HTTP error if HTTP version (2.0 when server is 1.1) is not supported', t => {
-  const fastify = Fastify()
-
-  t.teardown(fastify.close.bind(fastify))
-
-  fastify.get('/', (req, reply) => {
-    reply.send({ hello: 'world' })
-  })
-
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-
-    const port = fastify.server.address().port
-    const client = net.createConnection({ port }, () => {
-      client.write('GET / HTTP/2.0\r\nHost: example.com\r\n\r\n')
-
-      client.once('data', data => {
-        t.match(data.toString(), /505 HTTP Version Not Supported/i)
-        client.end(() => {
-          t.end()
-        })
-      })
-    })
-  })
-})