fastify 3.9.2 → 3.12.0

package/test/skip-reply-send.test.js

@@ -0,0 +1,315 @@
+'use strict'
+
+const { test } = require('tap')
+const split = require('split2')
+const net = require('net')
+const Fastify = require('../fastify')
+
+process.removeAllListeners('warning')
+
+const lifecycleHooks = [
+  'onRequest',
+  'preParsing',
+  'preValidation',
+  'preHandler',
+  'preSerialization',
+  'onSend',
+  'onTimeout',
+  'onResponse',
+  'onError'
+]
+
+test('skip automatic reply.send() with reply.sent = true and a body', (t) => {
+  const stream = split(JSON.parse)
+  const app = Fastify({
+    logger: {
+      stream: stream
+    }
+  })
+
+  stream.on('data', (line) => {
+    t.notEqual(line.level, 40) // there are no errors
+    t.notEqual(line.level, 50) // there are no errors
+  })
+
+  app.get('/', (req, reply) => {
+    reply.sent = true
+    reply.raw.end('hello world')
+
+    return Promise.resolve('this will be skipped')
+  })
+
+  return app.inject({
+    method: 'GET',
+    url: '/'
+  }).then((res) => {
+    t.equal(res.statusCode, 200)
+    t.equal(res.body, 'hello world')
+  })
+})
+
+test('skip automatic reply.send() with reply.sent = true and no body', (t) => {
+  const stream = split(JSON.parse)
+  const app = Fastify({
+    logger: {
+      stream: stream
+    }
+  })
+
+  stream.on('data', (line) => {
+    t.notEqual(line.level, 40) // there are no error
+    t.notEqual(line.level, 50) // there are no error
+  })
+
+  app.get('/', (req, reply) => {
+    reply.sent = true
+    reply.raw.end('hello world')
+
+    return Promise.resolve()
+  })
+
+  return app.inject({
+    method: 'GET',
+    url: '/'
+  }).then((res) => {
+    t.equal(res.statusCode, 200)
+    t.equal(res.body, 'hello world')
+  })
+})
+
+test('skip automatic reply.send() with reply.sent = true and an error', (t) => {
+  const stream = split(JSON.parse)
+  const app = Fastify({
+    logger: {
+      stream: stream
+    }
+  })
+
+  let errorSeen = false
+
+  stream.on('data', (line) => {
+    if (line.level === 50) {
+      errorSeen = true
+      t.equal(line.err.message, 'kaboom')
+      t.equal(line.msg, 'Promise errored, but reply.sent = true was set')
+    }
+  })
+
+  app.get('/', (req, reply) => {
+    reply.sent = true
+    reply.raw.end('hello world')
+
+    return Promise.reject(new Error('kaboom'))
+  })
+
+  return app.inject({
+    method: 'GET',
+    url: '/'
+  }).then((res) => {
+    t.equal(errorSeen, true)
+    t.equal(res.statusCode, 200)
+    t.equal(res.body, 'hello world')
+  })
+})
+
+function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
+  const idx = hookOrHandler === 'handler' ? lifecycleHooks.indexOf('preHandler') : lifecycleHooks.indexOf(hookOrHandler)
+  const previousHooks = lifecycleHooks.slice(0, idx)
+  const nextHooks = lifecycleHooks.slice(idx + 1)
+
+  test(`Hijacking inside ${hookOrHandler} skips all the following hooks and handler execution`, t => {
+    t.plan(4)
+    const test = t.test
+
+    test('Sending a response using reply.raw => onResponse hook is called', t => {
+      const stream = split(JSON.parse)
+      const app = Fastify({
+        logger: {
+          stream: stream
+        }
+      })
+
+      stream.on('data', (line) => {
+        t.notEqual(line.level, 40) // there are no errors
+        t.notEqual(line.level, 50) // there are no errors
+      })
+
+      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.pass(`${h} should be called`)))
+
+      if (hookOrHandler === 'handler') {
+        app.get('/', (req, reply) => {
+          reply.hijack()
+          reply.raw.end(`hello from ${hookOrHandler}`)
+        })
+      } else {
+        app.addHook(hookOrHandler, async (req, reply) => {
+          reply.hijack()
+          reply.raw.end(`hello from ${hookOrHandler}`)
+        })
+        app.get('/', (req, reply) => t.fail('Handler should not be called'))
+      }
+
+      nextHooks.forEach(h => {
+        if (h === 'onResponse') {
+          app.addHook(h, async (req, reply) => t.pass(`${h} should be called`))
+        } else {
+          app.addHook(h, async (req, reply) => t.fail(`${h} should not be called`))
+        }
+      })
+
+      return app.inject({
+        method: 'GET',
+        url: '/'
+      }).then((res) => {
+        t.equal(res.statusCode, 200)
+        t.equal(res.body, `hello from ${hookOrHandler}`)
+      })
+    })
+
+    test('Sending a response using req.socket => onResponse not called', t => {
+      const stream = split(JSON.parse)
+      const app = Fastify({
+        logger: {
+          stream: stream
+        }
+      })
+      t.tearDown(() => app.close())
+
+      stream.on('data', (line) => {
+        t.notEqual(line.level, 40) // there are no errors
+        t.notEqual(line.level, 50) // there are no errors
+      })
+
+      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.pass(`${h} should be called`)))
+
+      if (hookOrHandler === 'handler') {
+        app.get('/', (req, reply) => {
+          reply.hijack()
+          req.socket.write('HTTP/1.1 200 OK\r\n\r\n')
+          req.socket.write(`hello from ${hookOrHandler}`)
+          req.socket.end()
+        })
+      } else {
+        app.addHook(hookOrHandler, async (req, reply) => {
+          reply.hijack()
+          req.socket.write('HTTP/1.1 200 OK\r\n\r\n')
+          req.socket.write(`hello from ${hookOrHandler}`)
+          req.socket.end()
+        })
+        app.get('/', (req, reply) => t.fail('Handler should not be called'))
+      }
+
+      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.fail(`${h} should not be called`)))
+
+      app.listen(0, err => {
+        t.error(err)
+        const client = net.createConnection({ port: (app.server.address()).port }, () => {
+          client.write('GET / HTTP/1.1\r\n\r\n')
+          client.once('data', data => {
+            t.match(data.toString(), new RegExp(`hello from ${hookOrHandler}`, 'i'))
+            client.end(() => t.end())
+          })
+        })
+      })
+    })
+
+    test('Throwing an error doesnt trigger any hooks', t => {
+      const stream = split(JSON.parse)
+      const app = Fastify({
+        logger: {
+          stream: stream
+        }
+      })
+      t.tearDown(() => app.close())
+
+      let errorSeen = false
+      stream.on('data', (line) => {
+        if (hookOrHandler === 'handler') {
+          if (line.level === 40) {
+            errorSeen = true
+            t.equal(line.err.code, 'FST_ERR_REP_ALREADY_SENT')
+          }
+        } else {
+          t.notEqual(line.level, 40) // there are no errors
+          t.notEqual(line.level, 50) // there are no errors
+        }
+      })
+
+      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.pass(`${h} should be called`)))
+
+      if (hookOrHandler === 'handler') {
+        app.get('/', (req, reply) => {
+          reply.hijack()
+          throw new Error('This wil be skipped')
+        })
+      } else {
+        app.addHook(hookOrHandler, async (req, reply) => {
+          reply.hijack()
+          throw new Error('This wil be skipped')
+        })
+        app.get('/', (req, reply) => t.fail('Handler should not be called'))
+      }
+
+      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.fail(`${h} should not be called`)))
+
+      return Promise.race([
+        app.inject({ method: 'GET', url: '/' }),
+        new Promise((resolve, reject) => setTimeout(resolve, 1000))
+      ]).then((err, res) => {
+        t.error(err)
+        if (hookOrHandler === 'handler') {
+          t.equal(errorSeen, true)
+        }
+      })
+    })
+
+    test('Calling reply.send() after hijacking logs a warning', t => {
+      const stream = split(JSON.parse)
+      const app = Fastify({
+        logger: {
+          stream: stream
+        }
+      })
+
+      let errorSeen = false
+
+      stream.on('data', (line) => {
+        if (line.level === 40) {
+          errorSeen = true
+          t.equal(line.err.code, 'FST_ERR_REP_ALREADY_SENT')
+        }
+      })
+
+      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.pass(`${h} should be called`)))
+
+      if (hookOrHandler === 'handler') {
+        app.get('/', (req, reply) => {
+          reply.hijack()
+          reply.send('hello from reply.send()')
+        })
+      } else {
+        app.addHook(hookOrHandler, async (req, reply) => {
+          reply.hijack()
+          reply.send('hello from reply.send()')
+        })
+        app.get('/', (req, reply) => t.fail('Handler should not be called'))
+      }
+
+      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.fail(`${h} should not be called`)))
+
+      return Promise.race([
+        app.inject({ method: 'GET', url: '/' }),
+        new Promise((resolve, reject) => setTimeout(resolve, 1000))
+      ]).then((err, res) => {
+        t.error(err)
+        t.equal(errorSeen, true)
+      })
+    })
+  })
+}
+
+testHandlerOrBeforeHandlerHook(test, 'onRequest')
+testHandlerOrBeforeHandlerHook(test, 'preParsing')
+testHandlerOrBeforeHandlerHook(test, 'preValidation')
+testHandlerOrBeforeHandlerHook(test, 'preHandler')
+testHandlerOrBeforeHandlerHook(test, 'handler')

package/test/stream.test.js

@@ -58,10 +58,10 @@ test('should trigger the onSend hook', t => {
     reply.send(fs.createReadStream(__filename, 'utf8'))
   })
 
-  fastify.addHook('onSend', (req, reply, payload, next) => {
+  fastify.addHook('onSend', (req, reply, payload, done) => {
     t.ok(payload._readableState)
     reply.header('Content-Type', 'application/javascript')
-    next()
+    done()
   })
 
   fastify.inject({
@@ -83,7 +83,7 @@ test('should trigger the onSend hook only twice if pumping the stream fails, fir
   })
 
   let counter = 0
-  fastify.addHook('onSend', (req, reply, payload, next) => {
+  fastify.addHook('onSend', (req, reply, payload, done) => {
     if (counter === 0) {
       t.ok(payload._readableState)
     } else if (counter === 1) {
@@ -91,7 +91,7 @@ test('should trigger the onSend hook only twice if pumping the stream fails, fir
       t.strictEqual(error.statusCode, 500)
     }
     counter++
-    next()
+    done()
   })
 
   fastify.listen(0, err => {
@@ -114,7 +114,7 @@ test('onSend hook stream', t => {
     reply.send({ hello: 'world' })
   })
 
-  fastify.addHook('onSend', (req, reply, payload, next) => {
+  fastify.addHook('onSend', (req, reply, payload, done) => {
     const gzStream = zlib.createGzip()
 
     reply.header('Content-Encoding', 'gzip')
@@ -123,7 +123,7 @@ test('onSend hook stream', t => {
       gzStream,
       t.error
     )
-    next(null, gzStream)
+    done(null, gzStream)
   })
 
   fastify.inject({

package/test/throw.test.js

@@ -60,9 +60,9 @@ test('Fastify should throw for an invalid schema, printing the error route - bod
   }
 
   const fastify = Fastify()
-  fastify.register((instance, opts, next) => {
+  fastify.register((instance, opts, done) => {
     instance.post('/form', { schema: { body: badSchema } }, () => {})
-    next()
+    done()
   }, { prefix: 'hello' })
 
   fastify.ready(err => {
@@ -155,11 +155,11 @@ test('Should not throw on duplicate decorator encapsulation', t => {
 
   fastify.decorate('foo2', foo2Obj)
 
-  fastify.register(function (fastify, opts, next) {
+  fastify.register(function (fastify, opts, done) {
     t.notThrow(() => {
       fastify.decorate('foo2', foo2Obj)
     })
-    next()
+    done()
   })
 
   fastify.ready()

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

@@ -1,4 +1,4 @@
-import fastify, { FastifyError, FastifyInstance } from '../../fastify'
+import fastify, { FastifyError, FastifyInstance, ValidationResult } from '../../fastify'
 import { expectAssignable, expectError, expectType } from 'tsd'
 
 const server = fastify()
@@ -28,6 +28,8 @@ expectAssignable<FastifyInstance>(
   })
 )
 
+expectType<ValidationResult[] | undefined>(FastifyError().validation)
+
 function fastifyErrorHandler (this: FastifyInstance, error: FastifyError) {}
 server.setErrorHandler(fastifyErrorHandler)
 
@@ -43,8 +45,8 @@ server.setReplySerializer(function (payload, statusCode) {
   return 'serialized'
 })
 
-function invalidReplySerialzer (payload: number, statusCode: string) {}
-expectError(server.setReplySerializer(invalidReplySerialzer))
+function invalidReplySerializer (payload: number, statusCode: string) {}
+expectError(server.setReplySerializer(invalidReplySerializer))
 
 function serializerWithInvalidReturn (payload: unknown, statusCode: number) {}
 expectError(server.setReplySerializer(serializerWithInvalidReturn))

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

@@ -10,10 +10,10 @@ interface TestOptions extends FastifyPluginOptions {
   option1: string;
   option2: boolean;
 }
-const testPluginOpts: FastifyPluginCallback<TestOptions> = function (instance, opts, next) { }
+const testPluginOpts: FastifyPluginCallback<TestOptions> = function (instance, opts, done) { }
 const testPluginOptsAsync: FastifyPluginAsync<TestOptions> = async function (instance, opts) { }
 
-const testPluginOptsWithType = (instance: FastifyInstance, opts: FastifyPluginOptions, next: (error?: FastifyError) => void) => { }
+const testPluginOptsWithType = (instance: FastifyInstance, opts: FastifyPluginOptions, done: (error?: FastifyError) => void) => { }
 const testPluginOptsWithTypeAsync = async (instance: FastifyInstance, opts: FastifyPluginOptions) => { }
 
 expectError(fastify().register(testPluginOpts, {})) // error because missing required options from generic declaration
@@ -22,14 +22,14 @@ expectError(fastify().register(testPluginOptsAsync, {})) // error because missin
 expectAssignable<FastifyInstance>(fastify().register(testPluginOpts, { option1: '', option2: true }))
 expectAssignable<FastifyInstance>(fastify().register(testPluginOptsAsync, { option1: '', option2: true }))
 
-expectAssignable<FastifyInstance>(fastify().register(function (instance, opts, next) { }))
-expectAssignable<FastifyInstance>(fastify().register(function (instance, opts, next) { }, () => { }))
-expectAssignable<FastifyInstance>(fastify().register(function (instance, opts, next) { }, { logLevel: 'info', prefix: 'foobar' }))
+expectAssignable<FastifyInstance>(fastify().register(function (instance, opts, done) { }))
+expectAssignable<FastifyInstance>(fastify().register(function (instance, opts, done) { }, () => { }))
+expectAssignable<FastifyInstance>(fastify().register(function (instance, opts, done) { }, { logLevel: 'info', prefix: 'foobar' }))
 
 expectAssignable<FastifyInstance>(fastify().register(import('./dummy-plugin')))
 expectAssignable<FastifyInstance>(fastify().register(import('./dummy-plugin'), { foo: 1 }))
 
-const testPluginCallback: FastifyPluginCallback = function (instance, opts, next) { }
+const testPluginCallback: FastifyPluginCallback = function (instance, opts, done) { }
 expectAssignable<FastifyInstance>(fastify().register(testPluginCallback, {}))
 
 const testPluginAsync: FastifyPluginAsync = async function (instance, opts) { }
@@ -39,7 +39,7 @@ expectAssignable<FastifyInstance>(fastify().register(function (instance, opts):
 expectAssignable<FastifyInstance>(fastify().register(async function (instance, opts) { }, () => { }))
 expectAssignable<FastifyInstance>(fastify().register(async function (instance, opts) { }, { logLevel: 'info', prefix: 'foobar' }))
 
-expectError(fastify().register(function (instance, opts, next) { }, { logLevel: '' })) // must use a valid logLevel
+expectError(fastify().register(function (instance, opts, done) { }, { logLevel: '' })) // must use a valid logLevel
 
 const httpsServer = fastify({ https: {} })
 expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(httpsServer)

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

@@ -21,6 +21,7 @@ const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectType<(key: string) => void>(reply.removeHeader)
   expectType<(key: string) => boolean>(reply.hasHeader)
   expectType<{(statusCode: number, url: string): FastifyReply; (url: string): FastifyReply }>(reply.redirect)
+  expectType<() => FastifyReply>(reply.hijack)
   expectType<() => void>(reply.callNotFound)
   expectType<() => number>(reply.getResponseTime)
   expectType<(contentType: string) => FastifyReply>(reply.type)

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

@@ -36,6 +36,21 @@ expectAssignable<FastifyInstance>(server.setValidatorCompiler(({ schema }) => {
   return new Ajv().compile(schema)
 }))
 
+expectAssignable<FastifyInstance>(server.setSerializerCompiler(() => {
+  return data => JSON.stringify(data)
+}))
+
+expectAssignable<FastifyInstance>(server.post('/test', {
+  validatorCompiler: ({ schema }) => {
+    return data => {
+      if (!data || data.constructor !== Object) {
+        return { error: new Error('value is not an object') }
+      }
+      return { value: data }
+    }
+  }
+}, async req => req.body))
+
 expectError(server.get(
   '/unknown-schema-prop',
   {

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

@@ -219,7 +219,7 @@ test('should respect when attachValidation is explicitly set to false', t => {
   })
 })
 
-test('Attached validation error should take precendence over setErrorHandler', t => {
+test('Attached validation error should take precedence over setErrorHandler', t => {
   t.plan(3)
 
   const fastify = Fastify()
@@ -692,7 +692,7 @@ test('plugin override', t => {
     }
   })
 
-  fastify.register((instance, opts, next) => {
+  fastify.register((instance, opts, done) => {
     instance.setSchemaErrorFormatter((errors, dataVar) => {
       return new Error('C')
     })
@@ -708,12 +708,12 @@ test('plugin override', t => {
 
     instance.post('/c', { schema }, echoBody)
 
-    instance.register((subinstance, opts, next) => {
+    instance.register((subinstance, opts, done) => {
       subinstance.post('/stillC', { schema }, echoBody)
-      next()
+      done()
     })
 
-    next()
+    done()
   })
 
   fastify.post('/b', { schema }, echoBody)

package/test/versioned-routes.test.js

@@ -404,7 +404,7 @@ test('test log stream', t => {
   })
 })
 
-test('Should register a versioned route with custome versioning strategy', t => {
+test('Should register a versioned route with custom versioning strategy', t => {
   t.plan(8)
 
   const versioning = {

package/types/content-type-parser.d.ts

@@ -5,7 +5,7 @@ import { RouteGenericInterface } from './route'
 type ContentTypeParserDoneFunction = (err: Error | null, body?: any) => void
 
 /**
- * Body parser method that operatoes on request body
+ * Body parser method that operators on request body
  */
 export type FastifyBodyParser<
   RawBody extends string | Buffer,

package/types/instance.d.ts

@@ -1,6 +1,6 @@
 import { Chain as LightMyRequestChain, InjectOptions, Response as LightMyRequestResponse, CallbackFunc as LightMyRequestCallback } from 'light-my-request'
-import { RouteOptions, RouteShorthandMethod, RouteGenericInterface } from './route'
-import { FastifySchemaCompiler, FastifySchemaValidationError } from './schema'
+import { RouteOptions, RouteShorthandMethod, RouteGenericInterface, DefaultRoute } from './route'
+import { FastifySchemaCompiler, FastifySchemaValidationError, FastifySerializerCompiler } from './schema'
 import { RawServerBase, RawRequestDefaultExpression, RawServerDefault, RawReplyDefaultExpression, ContextConfigDefault } from './utils'
 import { FastifyLoggerInstance } from './logger'
 import { FastifyRegister } from './register'
@@ -59,6 +59,9 @@ export interface FastifyInstance<
 
   register: FastifyRegister<FastifyInstance<RawServer, RawRequest, RawReply, Logger> & PromiseLike<undefined>>;
 
+  getDefaultRoute: DefaultRoute<RawRequest, RawReply>;
+  setDefaultRoute(defaultRoute: DefaultRoute<RawRequest, RawReply>): void;
+
   route<
     RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
     ContextConfig = ContextConfigDefault
@@ -332,7 +335,7 @@ export interface FastifyInstance<
   /**
    * Set the schema serializer for all routes.
    */
-  setSerializerCompiler(schemaCompiler: FastifySchemaCompiler): FastifyInstance<RawServer, RawRequest, RawReply, Logger>;
+  setSerializerCompiler(schemaCompiler: FastifySerializerCompiler): FastifyInstance<RawServer, RawRequest, RawReply, Logger>;
 
   /**
   * Set the reply serializer for all routes.

package/types/plugin.d.ts

@@ -11,7 +11,7 @@ export type FastifyPluginOptions = Record<string, any>
 export type FastifyPluginCallback<Options extends FastifyPluginOptions = Record<never, never>, Server extends RawServerBase = RawServerDefault> = (
   instance: FastifyInstance<Server, RawRequestDefaultExpression<Server>, RawReplyDefaultExpression<Server>>,
   opts: Options,
-  next: (err?: Error) => void
+  done: (err?: Error) => void
 ) => void
 
 /**

package/types/reply.d.ts

@@ -40,6 +40,7 @@ export interface FastifyReply<
   // Note: should consider refactoring the argument order for redirect. statusCode is optional so it should be after the required url param
   redirect(statusCode: number, url: string): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig>;
   redirect(url: string): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig>;
+  hijack(): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig>;
   callNotFound(): void;
   getResponseTime(): number;
   type(contentType: string): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig>;

package/types/route.d.ts

@@ -1,7 +1,7 @@
 import { FastifyInstance } from './instance'
 import { FastifyRequest, RequestGenericInterface } from './request'
 import { FastifyReply, ReplyGenericInterface } from './reply'
-import { FastifySchema, FastifySchemaCompiler, FastifySchemaValidationError } from './schema'
+import { FastifySchema, FastifySchemaCompiler, FastifySchemaValidationError, FastifySerializerCompiler } from './schema'
 import { HTTPMethods, RawServerBase, RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, ContextConfigDefault } from './utils'
 import { LogLevel } from './logger'
 import { preValidationHookHandler, preHandlerHookHandler, preSerializationHookHandler, onRequestHookHandler, preParsingHookHandler, onResponseHookHandler, onSendHookHandler, onErrorHookHandler, onTimeoutHookHandler } from './hooks'
@@ -21,8 +21,9 @@ export interface RouteShorthandOptions<
 > {
   schema?: FastifySchema;
   attachValidation?: boolean;
+  exposeHeadRoute?: boolean;
   validatorCompiler?: FastifySchemaCompiler;
-  serializerCompiler?: FastifySchemaCompiler;
+  serializerCompiler?: FastifySerializerCompiler;
   bodyLimit?: number;
   logLevel?: LogLevel;
   config?: ContextConfig;
@@ -121,3 +122,8 @@ export type RouteHandler<
   request: FastifyRequest<RouteGeneric, RawServer, RawRequest>,
   reply: FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig>
 ) => void | Promise<RouteGeneric['Reply'] | void>
+
+export type DefaultRoute<Request, Reply> = (
+  req: Request,
+  res: Reply,
+) => void;

package/types/schema.d.ts

@@ -26,6 +26,7 @@ export interface FastifySchemaValidationError {
 }
 
 export interface FastifyValidationResult {
+  (data: any): boolean | PromiseLike<any> | { error?: Error, value?: any }
   errors?: FastifySchemaValidationError[] | null;
 }
 
@@ -33,3 +34,5 @@ export interface FastifyValidationResult {
  * Compiler for FastifySchema Type
  */
 export type FastifySchemaCompiler = (routeSchema: FastifyRouteSchemaDef) => FastifyValidationResult
+
+export type FastifySerializerCompiler = (routeSchema: FastifyRouteSchemaDef) => (data: any) => string