fastify 6.0.0-alpha.4 → 6.0.0-alpha.6

package/test/types/fastify.tst.ts

@@ -3,6 +3,7 @@ import * as http from 'node:http'
 import * as http2 from 'node:http2'
 import * as https from 'node:https'
 import { Socket } from 'node:net'
+import pino from 'pino'
 import { expect } from 'tstyche'
 import fastify, {
   ConnectionError,
@@ -180,6 +181,10 @@ const customLogger = {
   debug: () => { },
   child: () => customLogger
 }
+const pinoLogger = pino()
+const pinoLoggerServer: FastifyInstance = fastify({ loggerInstance: pinoLogger })
+
+expect(pinoLoggerServer).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ logger: customLogger })).type.toBeAssignableTo<
   FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>
 >()
@@ -356,5 +361,9 @@ fastify({ routerOptions: { allowUnsafeRegex: true } })
 fastify({ routerOptions: { allowUnsafeRegex: false } })
 expect(fastify).type.not.toBeCallableWith({ routerOptions: { allowUnsafeRegex: 'invalid' } })
 
+fastify({ routerOptions: { compile: true } })
+fastify({ routerOptions: { compile: false } })
+expect(fastify).type.not.toBeCallableWith({ routerOptions: { compile: 'invalid' } })
+
 expect(fastify({ allowErrorHandlerOverride: true })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ allowErrorHandlerOverride: false })).type.toBeAssignableTo<FastifyInstance>()

package/test/types/instance.tst.ts

@@ -29,7 +29,7 @@ expect(server.addSchema({ schemas: [] })).type.toBe<FastifyInstance>()
 expect(server.pluginName).type.toBe<string>()
 
 expect(server.getSchemas()).type.toBe<Record<string, unknown>>()
-expect(server.addresses()).type.toBe<AddressInfo[]>()
+expect(server.addresses()).type.toBe<Array<AddressInfo | string>>()
 expect(server.getSchema('SchemaId')).type.toBe<unknown>()
 expect(server.printRoutes()).type.toBe<string>()
 expect(server.printPlugins()).type.toBe<string>()

package/test/types/route.tst.ts

@@ -58,6 +58,15 @@ const asyncPreHandler = async (request: FastifyRequest) => {
 
 fastify().get('/', { preHandler: asyncPreHandler }, async () => 'this is an example')
 
+fastify().route({
+  method: 'GET',
+  url: '/',
+  onRequest: async function () {
+    expect(this).type.toBe<FastifyInstance>()
+  },
+  handler: async () => 'ok'
+})
+
 fastify().get(
   '/',
   { config: { foo: 'bar', bar: 100, includeMessage: true } },
@@ -74,6 +83,22 @@ fastify().get(
   }
 )
 
+fastify().get(
+  '/',
+  { logLevel: 'info', logSerializers: { test: (value: number) => 'X' + value } },
+  routeHandler
+)
+
+fastify().route({
+  method: 'GET',
+  url: '/',
+  logSerializers: {
+    // serializers may return objects as well as strings
+    req: (req: FastifyRequest) => ({ url: req.url })
+  },
+  handler: routeHandler
+})
+
 type LowerCaseHTTPMethods = 'delete' | 'get' | 'head' | 'patch' | 'post' | 'put' |
   'options' | 'query' | 'propfind' | 'proppatch' | 'mkcol' | 'copy' | 'move' | 'lock' |
   'unlock' | 'trace' | 'search' | 'mkcalendar' | 'report'
@@ -495,6 +520,12 @@ expect(fastify().hasRoute({
   method: 'GET'
 })).type.toBe<boolean>()
 
+fastify().hasRoute({
+  url: '/',
+  // @ts-expect-error  Type 'string[]' is not assignable to type 'HTTPMethods'.
+  method: ['GET', 'POST']
+})
+
 expect(fastify().hasRoute({
   url: '/',
   method: 'GET',
@@ -539,6 +570,12 @@ expect(
   })
 ).type.toBe<Omit<FindMyWayFindResult<RawServerDefault>, 'store'>>()
 
+fastify().findRoute({
+  url: '/',
+  // @ts-expect-error  Type 'string[]' is not assignable to type 'HTTPMethods'.
+  method: ['GET', 'POST']
+})
+
 // we should not expose store
 expect(fastify().findRoute({
   url: '/',

package/test/types/using.tst.ts

@@ -12,3 +12,23 @@ test("has 'Symbol.dispose'", async () => {
   expect(app).type.toBeAssignableTo<FastifyInstance>()
   expect(app[Symbol.asyncDispose]).type.toBe<() => Promise<undefined>>()
 })
+
+test("addHook('onClose') accepts AsyncDisposable", () => {
+  const app = fastify()
+
+  const asyncDisposable: AsyncDisposable = {
+    async [Symbol.asyncDispose] () {}
+  }
+
+  expect(app.addHook('onClose', asyncDisposable)).type.toBeAssignableTo<FastifyInstance>()
+})
+
+test("addHook('onClose') accepts Disposable", () => {
+  const app = fastify()
+
+  const syncDisposable: Disposable = {
+    [Symbol.dispose] () {}
+  }
+
+  expect(app.addHook('onClose', syncDisposable)).type.toBeAssignableTo<FastifyInstance>()
+})

package/test/validation-error-handling.test.js

@@ -252,6 +252,26 @@ test('attached validationError exposes the same message sent by the default hand
   t.assert.strictEqual(notAttached.statusCode, 400)
 })
 
+test('default validation errors are FST_ERR_VALIDATION errors without a stack trace', async (t) => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  let validationError
+  fastify.post('/', { schema, attachValidation: true }, function (req, reply) {
+    validationError = req.validationError
+    reply.code(400).send()
+  })
+
+  await fastify.inject({ method: 'POST', payload: { hello: 'michelangelo' }, url: '/' })
+
+  t.assert.ok(validationError instanceof Fastify.errorCodes.FST_ERR_VALIDATION)
+  t.assert.ok(validationError instanceof Error)
+  t.assert.strictEqual(validationError.name, 'FastifyError')
+  t.assert.strictEqual(validationError.message, "body must have required property 'name'")
+  t.assert.strictEqual(validationError.stack, undefined)
+})
+
 test('should respect when attachValidation is explicitly set to false', async (t) => {
   t.plan(2)
 
@@ -303,7 +323,7 @@ test('Attached validation error should take precedence over setErrorHandler', as
     url: '/'
   })
 
-  t.assert.deepStrictEqual(response.payload, "Attached: Error: body must have required property 'name'")
+  t.assert.deepStrictEqual(response.payload, "Attached: FastifyError [FST_ERR_VALIDATION]: body must have required property 'name'")
   t.assert.strictEqual(response.statusCode, 400)
 })
 

package/types/errors.d.ts

@@ -83,7 +83,6 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_ROUTE_HANDLER_TIMEOUT_OPTION_NOT_INT' |
   'FST_ERR_ROUTE_REWRITE_NOT_STR' |
   'FST_ERR_ROUTE_MISSING_CONTENT_TYPE' |
-  'FST_ERR_ROUTE_MISSING_CONTENT' |
   'FST_ERR_REOPENED_CLOSE_SERVER' |
   'FST_ERR_REOPENED_SERVER' |
   'FST_ERR_INSTANCE_ALREADY_STARTED' |

package/types/instance.d.ts

@@ -130,7 +130,7 @@ export interface FastifyInstance<
   version: string;
   log: Logger;
   listeningOrigin: string;
-  addresses(): AddressInfo[]
+  addresses(): Array<AddressInfo | string>
   withTypeProvider<Provider extends FastifyTypeProvider>(): FastifyInstance<RawServer, RawRequest, RawReply, Logger,
     Provider>;
 
@@ -215,13 +215,13 @@ export interface FastifyInstance<
     RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
     ContextConfig = ContextConfigDefault,
     SchemaCompiler extends FastifySchema = FastifySchema
-  >(opts: Pick<RouteOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>, 'method' | 'url' | 'constraints'>): boolean;
+  >(opts: Pick<RouteOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>, 'url' | 'constraints'> & { method: HTTPMethods }): boolean;
 
   findRoute<
     RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
     ContextConfig = ContextConfigDefault,
     SchemaCompiler extends FastifySchema = FastifySchema
-  >(opts: Pick<RouteOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>, 'method' | 'url' | 'constraints'>): Omit<FindMyWayFindResult<RawServer>, 'store'>;
+  >(opts: Pick<RouteOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>, 'url' | 'constraints'> & { method: HTTPMethods }): Omit<FindMyWayFindResult<RawServer>, 'store'>;
 
   // addHook: overloads
 
@@ -485,6 +485,10 @@ export interface FastifyInstance<
   /**
   * Triggered when fastify.close() is invoked to stop the server. It is useful when plugins need a "shutdown" event, for example to close an open connection to a database.
   */
+  addHook(
+    name: 'onClose',
+    hook: AsyncDisposable | Disposable,
+  ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
   addHook<
     Fn extends onCloseHookHandler | onCloseAsyncHookHandler = onCloseHookHandler
   >(
@@ -579,7 +583,7 @@ export interface FastifyInstance<
    * which allows for modifying or adding child logger bindings and logger options, or
    * returning a completely custom child logger implementation.
    */
-  childLoggerFactory: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
+  childLoggerFactory: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, FastifyBaseLogger, TypeProvider>;
 
   /**
    * Hook function that is called when creating a child logger instance for each request
@@ -598,7 +602,7 @@ export interface FastifyInstance<
    * }
    * ```
    */
-  setChildLoggerFactory(factory: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, Logger,
+  setChildLoggerFactory(factory: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, FastifyBaseLogger,
     TypeProvider>): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
 
   /**

package/types/route.d.ts

@@ -46,7 +46,8 @@ export interface RouteConstraint {
 /**
  * Route shorthand options for the various shorthand methods
  */
-type RouteShorthandHook<T extends (...args: any) => any> = (...args: Parameters<T>) => void | Promise<unknown>
+type RouteShorthandHook<T extends (this: any, ...args: any) => any> =
+  (this: ThisParameterType<T>, ...args: Parameters<T>) => void | Promise<unknown>
 
 export interface RouteShorthandOptions<
   RawServer extends RawServerBase = RawServerDefault,
@@ -67,6 +68,7 @@ export interface RouteShorthandOptions<
   bodyLimit?: number;
   handlerTimeout?: number;
   logLevel?: LogLevel;
+  logSerializers?: Record<string, (value: any) => any>;
   config?: FastifyContextConfig & ContextConfig;
   constraints?: RouteConstraint,
   prefixTrailingSlash?: 'slash' | 'no-slash' | 'both';
@@ -78,7 +80,7 @@ export interface RouteShorthandOptions<
     reply: FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, NoInfer<SchemaCompiler>,
       TypeProvider>
   ) => void;
-  childLoggerFactory?: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
+  childLoggerFactory?: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, FastifyBaseLogger, TypeProvider>;
   schemaErrorFormatter?: SchemaErrorFormatter;
 
   // hooks