fastify 2.4.1 → 2.7.1

package/docs/Routes.md

@@ -16,7 +16,7 @@ They need to be in
 
   * `body`: validates the body of the request if it is a POST or a
     PUT.
-  * `querystring`: validates the querystring. This can be a complete JSON
+  * `querystring` or `query`: validates the querystring. This can be a complete JSON
   Schema object, with the property `type` of `object` and `properties` object of parameters, or
   simply the values of what would be contained in the `properties` object as shown below.
   * `params`: validates the params.
@@ -216,16 +216,16 @@ fastify.listen(3000)
 ```
 ```js
 // routes/v1/users.js
-module.exports = function (fastify, opts, next) {
+module.exports = function (fastify, opts, done) {
   fastify.get('/user', handler_v1)
-  next()
+  done()
 }
 ```
 ```js
 // routes/v2/users.js
-module.exports = function (fastify, opts, next) {
+module.exports = function (fastify, opts, done) {
   fastify.get('/user', handler_v2)
-  next()
+  done()
 }
 ```
 Fastify will not complain because you are using the same name for two different routes, because at compilation time it will handle the prefix automatically *(this also means that the performance will not be affected at all!)*.
@@ -249,7 +249,7 @@ See the `prefixTrailingSlash` route option above to change this behaviour.
 
 <a name="custom-log-level"></a>
 ### Custom Log Level
-It could happen that you need different log levels in your routes, with Fastify achieve this is very straightforward.<br/>
+It could happen that you need different log levels in your routes, Fastify achieves this in a very straightforward way.<br/>
 You just need to pass the option `logLevel` to the plugin option or the route option with the [value](https://github.com/pinojs/pino/blob/master/docs/API.md#discussion-3) that you need.
 
 Be aware that if you set the `logLevel` at plugin level, also the [`setNotFoundHandler`](https://github.com/fastify/fastify/blob/master/docs/Server.md#setnotfoundhandler) and [`setErrorHandler`](https://github.com/fastify/fastify/blob/master/docs/Server.md#seterrorhandler) will be affected.

package/docs/Server.md

@@ -150,14 +150,14 @@ custom `onRequest` and `onResponse` hooks.
 
 ```js
 // Examples of hooks to replicate the disabled functionality.
-fastify.addHook('onRequest', (req, reply, next) => {
+fastify.addHook('onRequest', (req, reply, done) => {
   req.log.info({ url: req.req.url, id: req.id }, 'received request')
-  next()
+  done()
 })
 
-fastify.addHook('onResponse', (req, reply, next) => {
+fastify.addHook('onResponse', (req, reply, done) => {
   req.log.info({ url: req.req.originalUrl, statusCode: res.res.statusCode }, 'request completed')
-  next()
+  done()
 })
 ```
 
@@ -230,7 +230,7 @@ Especially in distributed systems, you may want to override the default id gener
 ```js
 let i = 0
 const fastify = require('fastify')({
-  genReqId: function (req) { return req.headers['request-id'] || i++ }
+  genReqId: function (req) { return i++ }
 })
 ```
 
@@ -352,6 +352,14 @@ fastify.get('/', (request, reply) => {
 })
 ```
 
+<a name="factory-return-503-on-closing"></a>
+### `return503OnClosing`
+
+Returns 503 after calling `close` server method.
+If `false`, the server routes the incoming request as usual.
+
++ Default: `true`
+
 ## Instance
 
 ### Server Methods
@@ -368,16 +376,16 @@ It is always executed before the method `fastify.ready`.
 
 ```js
 fastify
-  .register((instance, opts, next) => {
+  .register((instance, opts, done) => {
     console.log('Current plugin')
-    next()
+    done()
   })
   .after(err => {
     console.log('After current plugin')
   })
-  .register((instance, opts, next) => {
+  .register((instance, opts, done) => {
     console.log('Next plugin')
-    next()
+    done()
   })
   .ready(err => {
     console.log('Everything has been loaded')
@@ -516,6 +524,7 @@ Method to add routes to the server, it also has shorthand functions, check [here
 #### close
 `fastify.close(callback)`: call this function to close the server instance and run the [`'onClose'`](https://github.com/fastify/fastify/blob/master/docs/Hooks.md#on-close) hook.<br>
 Calling `close` will also cause the server to respond to every new incoming request with a `503` error and destroy that request.
+See [`return503OnClosing` flags](https://github.com/fastify/fastify/blob/master/docs/Server.md#factory-return-503-on-closing) for changing this behaviour.
 
 If it is called without any arguments, it will return a Promise:
 
@@ -551,24 +560,24 @@ The full path that will be prefixed to a route.
 Example:
 
 ```js
-fastify.register(function (instance, opts, next) {
+fastify.register(function (instance, opts, done) {
   instance.get('/foo', function (request, reply) {
     // Will log "prefix: /v1"
     request.log.info('prefix: %s', instance.prefix)
     reply.send({ prefix: instance.prefix })
   })
 
-  instance.register(function (instance, opts, next) {
+  instance.register(function (instance, opts, done) {
     instance.get('/bar', function (request, reply) {
       // Will log "prefix: /v1/v2"
       request.log.info('prefix: %s', instance.prefix)
       reply.send({ prefix: instance.prefix })
     })
 
-    next()
+    done()
   }, { prefix: '/v2' })
 
-  next()
+  done()
 }, { prefix: '/v1' })
 ```
 
@@ -585,6 +594,18 @@ Fake http injection (for testing purposes) [here](https://github.com/fastify/fas
 `fastify.addSchema(schemaObj)`, adds a shared schema to the Fastify instance. This allows you to reuse it everywhere in your application just by writing the schema id that you need.<br/>
 To learn more, see [shared schema example](https://github.com/fastify/fastify/blob/master/docs/Validation-and-Serialization.md#shared-schema) in the [Validation and Serialization](https://github.com/fastify/fastify/blob/master/docs/Validation-and-Serialization.md) documentation.
 
+<a name="set-reply-serializer"></a>
+#### setReplySerializer
+Set the reply serializer for all the routes. This will used as default if a [Reply.serializer(func)](https://github.com/fastify/fastify/blob/master/docs/Reply.md#serializerfunc) has not been set. The handler is fully encapsulated, so different plugins can set different error handlers.
+Note: the function parameter is called only for status `2xx`. Checkout the [`setErrorHandler`](https://github.com/fastify/fastify/blob/master/docs/Server.md#seterrorhandler) for errors.
+
+```js
+fastify.setReplySerializer(function (payload, statusCode){
+  // serialize the payload with a sync function
+  return `my serialized ${statusCode} content: ${payload}`
+})
+```
+
 <a name="set-schema-compiler"></a>
 #### setSchemaCompiler
 Set the schema compiler for all routes [here](https://github.com/fastify/fastify/blob/master/docs/Validation-and-Serialization.md#schema-compiler).
@@ -602,24 +623,24 @@ You can also register a [`preValidation`](https://www.fastify.io/docs/latest/Hoo
 
 ```js
 fastify.setNotFoundHandler({
-  preValidation: (req, reply, next) => {
+  preValidation: (req, reply, done) => {
     // your code
-    next()
+    done()
   },
-  preHandler: (req, reply, next) => {
+  preHandler: (req, reply, done) => {
     // your code
-    next()
+    done()
   }
 }, function (request, reply) {
     // Default not found handler with preValidation and preHandler hooks
 })
 
-fastify.register(function (instance, options, next) {
+fastify.register(function (instance, options, done) {
   instance.setNotFoundHandler(function (request, reply) {
     // Handle not found request without preValidation and preHandler hooks
     // to URLs that begin with '/v1'
   })
-  next()
+  done()
 }, { prefix: '/v1' })
 ```
 

package/docs/Serverless.md

@@ -2,6 +2,11 @@
 
 Run serverless applications and REST APIs using your existing Fastify application.
 
+### Contents
+
+- [AWS Lambda](#aws-lambda)
+- [Google Cloud Run](#google-cloud-run)
+
 ### Attention Readers:
 > Fastify is not designed to run on serverless environments.
 The Fastify framework is designed to make implementing a traditional HTTP/S server easy.
@@ -12,21 +17,20 @@ it is possible to use Fastify in a serverless environment.
 Again, keep in mind that this is not Fastify's intended use case and
 we do not test for such integration scenarios.
 
-
 ## AWS Lambda
 
 The sample provided allows you to easily build serverless web applications/services
 and RESTful APIs using Fastify on top of AWS Lambda and Amazon API Gateway.
 
-*Note: This is just one possible way.*
+*Note: Using [aws-lambda-fastify](https://github.com/fastify/aws-lambda-fastify) is just one possible way.*
 
 ### app.js
 
 ```js
 const fastify = require('fastify');
 
-function init(serverFactory) {
-  const app = fastify({ serverFactory });
+function init() {
+  const app = fastify();
   app.get('/', (request, reply) => reply.send({ hello: 'world' }));
   return app;
 }
@@ -43,11 +47,9 @@ if (require.main !== module) {
 }
 ```
 
-You can simply wrap your initialization code by offering to inject an optional [serverFactory](https://www.fastify.io/docs/latest/Server/#serverfactory).
-
 When executed in your lambda function we don't need to listen to a specific port,
 so we just export the wrapper function `init` in this case.
-The [`lambda.js`](https://www.fastify.io/docs/latest/Server/#lambda.js) file will use this export.
+The [`lambda.js`](https://www.fastify.io/docs/latest/Serverless/#lambda-js) file will use this export.
 
 When you execute your Fastify application like always,
 i.e. `node app.js` *(the detection for this could be `require.main === module`)*,
@@ -56,31 +58,28 @@ you can normally listen to your port, so you can still run your Fastify function
 ### lambda.js
 
 ```js
-const awsServerlessExpress = require('aws-serverless-express');
+const awsLambdaFastify = require('aws-lambda-fastify')
 const init = require('./app');
 
-let server;
-const serverFactory = (handler) => {
-  server = awsServerlessExpress.createServer(handler);
-  return server;
-}
-const app = init(serverFactory);
-
-exports.handler = (event, context, callback) => {
-  context.callbackWaitsForEmptyEventLoop = false;
-  app.ready((e) => {
-    if (e) return console.error(e.stack || e);
-    awsServerlessExpress.proxy(server, event, context, 'CALLBACK', callback);
-  });
-};
+const proxy = awsLambdaFastify(init())
+// or
+// const proxy = awsLambdaFastify(init(), { binaryMimeTypes: ['application/octet-stream'] })
+
+exports.handler = proxy;
+// or
+// exports.handler = (event, context, callback) => proxy(event, context, callback);
+// or
+// exports.handler = (event, context) => proxy(event, context);
+// or
+// exports.handler = async (event, context) => proxy(event, context);
 ```
 
-We define a custom `serverFactory` function, in which we create a new server with the help of [`aws-serverless-express`](https://github.com/awslabs/aws-serverless-express)
-(make sure you install the dependency `npm i --save aws-serverless-express`).
-Then we call the `init` function (imported from [`app.js`](https://www.fastify.io/docs/latest/Server/#app.js)) with the `serverFactory` function as the only parameter.
-Finally inside the lambda `handler` function we wait for the Fastify app to be `ready`
-and proxy all the incoming events (API Gateway requests) to the `proxy` function from [`aws-serverless-express`](https://github.com/awslabs/aws-serverless-express).
-
+We just require [aws-lambda-fastify](https://github.com/fastify/aws-lambda-fastify)
+(make sure you install the dependency `npm i --save aws-lambda-fastify`) and our
+[`app.js`](https://www.fastify.io/docs/latest/Serverless/#app-js) file and call the
+exported `awsLambdaFastify` function with the `app` as the only parameter.
+The resulting `proxy` function has the correct signature to be used as lambda `handler` function. 
+This way all the incoming events (API Gateway requests) are passed to the `proxy` function of [aws-lambda-fastify](https://github.com/fastify/aws-lambda-fastify).
 
 ### Example
 
@@ -91,3 +90,103 @@ An example deployable with [claudia.js](https://claudiajs.com/tutorials/serverle
 
 - API Gateway doesn't support streams yet, so you're not able to handle [streams](https://www.fastify.io/docs/latest/Reply/#streams). 
 - API Gateway has a timeout of 29 seconds, so it's important to provide a reply during this time.
+
+## Google Cloud Run
+
+Unlike AWS Lambda or Google Cloud Functions, Google Cloud Run is a serverless **container** environment. It's primary purpose is to provide an infrastucture-abstracted environment to run arbitrary containers. As a result, Fastify can be deployed to Google Cloud Run with little-to-no code changes from the way you would write your Fastify app normally.
+
+*Follow the steps below to deploy to Google Cloud Run if you are already familiar with gcloud or just follow their [quickstart](https://cloud.google.com/run/docs/quickstarts/build-and-deploy)*
+
+### Adjust Fastfiy server
+
+In order for Fastify to properly listen for requests within the container, be sure to set the correct port and address:
+
+```js
+function build() {
+  const fastify = Fastify({ trustProxy: true })
+  return fastify
+}
+
+async function start() {
+  // Google Cloud Run will set this environment variable for you, so
+  // you can also use it to detect if you are running in Cloud Run
+  const IS_GOOGLE_CLOUD_RUN = process.env.K_SERVICE !== undefined
+
+  // You must listen on the port Cloud Run provides
+  const port = process.env.PORT || 3000
+
+  // You must listen on all IPV4 addresses in Cloud Run
+  const address = IS_GOOGLE_CLOUD_RUN ? "0.0.0.0" : undefined
+
+  try {
+    const server = build()
+    const address = await server.listen(port, address)
+    console.log(`Listening on ${address}`)
+  } catch (err) {
+    console.error(err)
+    process.exit(1)
+  }
+}
+
+module.exports = build
+
+if (require.main === module) {
+  start()
+}
+```
+
+### Add a Dockerfile
+
+You can add any valid `Dockerfile` that packages and runs a Node app. A basic `Dockerfile` can be found in the official [gcloud docs](https://github.com/knative/docs/blob/2d654d1fd6311750cc57187a86253c52f273d924/docs/serving/samples/hello-world/helloworld-nodejs/Dockerfile).
+
+```Dockerfile
+# Use the official Node.js 10 image.
+# https://hub.docker.com/_/node
+FROM node:10
+
+# Create and change to the app directory.
+WORKDIR /usr/src/app
+
+# Copy application dependency manifests to the container image.
+# A wildcard is used to ensure both package.json AND package-lock.json are copied.
+# Copying this separately prevents re-running npm install on every code change.
+COPY package*.json ./
+
+# Install production dependencies.
+RUN npm install --only=production
+
+# Copy local code to the container image.
+COPY . .
+
+# Run the web service on container startup.
+CMD [ "npm", "start" ]
+```
+
+### Add a .dockerignore
+
+To keep build artifacts out of your container (which keeps it small and improves build times), add a `.dockerignore` file like the one below:
+
+```.dockerignore
+Dockerfile
+README.md
+node_modules
+npm-debug.log
+```
+
+### Submit build
+
+Next, submit your app to be built into a Docker image by running the following command (replacing `PROJECT-ID` and `APP-NAME` with your GCP project id and an app name:
+
+```bash
+gcloud builds submit --tag gcr.io/PROJECT-ID/APP-NAME
+```
+
+### Deploy Image
+
+After your image has built, you can deploy it with the following command:
+
+```bash
+gcloud beta run deploy --image gcr.io/PROJECT-ID/APP-NAME --platform managed
+```
+
+Your app will be accessible from the URL GCP provides.

package/docs/Validation-and-Serialization.md

@@ -4,9 +4,10 @@
 Fastify uses a schema-based approach, and even if it is not mandatory we recommend using [JSON Schema](http://json-schema.org/) to validate your routes and serialize your outputs. Internally, Fastify compiles the schema into a highly performant function.
 
 > ## ⚠  Security Notice
+> Treat the schema definition as application code.
 > As both validation and serialization features dynamically evaluate
-> code with `new Function()`, it is not safe to use them with
-> user-provided data. See [Ajv](http://npm.im/ajv) and
+> code with `new Function()`, it is not safe to use
+> user-provided schemas. See [Ajv](http://npm.im/ajv) and
 > [fast-json-stringify](http://npm.im/fast-json-stringify) for more
 > details.
 
@@ -14,7 +15,7 @@ Fastify uses a schema-based approach, and even if it is not mandatory we recomme
 ### Validation
 The route validation internally relies upon [Ajv](https://www.npmjs.com/package/ajv), which is a high-performance JSON schema validator. Validating the input is very easy: just add the fields that you need inside the route schema, and you are done! The supported validations are:
 - `body`: validates the body of the request if it is a POST or a PUT.
-- `querystring`: validates the query string. This can be a complete JSON Schema object (with a `type` property of `'object'` and a `'properties'` object containing parameters) or a simpler variation in which the `type` and `properties` attributes are forgone and the query parameters are listed at the top level (see the example below).
+- `querystring` or `query`: validates the query string. This can be a complete JSON Schema object (with a `type` property of `'object'` and a `'properties'` object containing parameters) or a simpler variation in which the `type` and `properties` attributes are forgone and the query parameters are listed at the top level (see the example below).
 - `params`: validates the route params.
 - `headers`: validates the request headers.
 
@@ -31,7 +32,7 @@ const bodyJsonSchema = {
       maxItems: 3,
       items: { type: 'integer' }
     },
-    nullableKey: { type: ['number', 'null'] },
+    nullableKey: { type: ['number', 'null'] }, // or { type: 'number', nullable: true }
     multipleTypesKey: { type: ['boolean', 'number'] },
     multipleRestrictedTypesKey: {
       oneOf: [
@@ -155,7 +156,7 @@ fastify.route({
   handler: () => {}
 })
 
-fastify.register((instance, opts, next) => {
+fastify.register((instance, opts, done) => {
 
   /**
    * In children's scope can use schemas defined in upper scope like 'greetings'.
@@ -179,7 +180,7 @@ fastify.register((instance, opts, next) => {
     handler: () => {}
   })
 
-  next()
+  done()
 })
 ```
 
@@ -219,16 +220,16 @@ The function `getSchemas` returns the shared schemas available in the selected s
 fastify.addSchema({ $id: 'one', my: 'hello' })
 fastify.get('/', (request, reply) => { reply.send(fastify.getSchemas()) })
 
-fastify.register((instance, opts, next) => {
+fastify.register((instance, opts, done) => {
   instance.addSchema({ $id: 'two', my: 'ciao' })
   instance.get('/sub', (request, reply) => { reply.send(instance.getSchemas()) })
 
-  instance.register((subinstance, opts, next) => {
+  instance.register((subinstance, opts, done) => {
     subinstance.addSchema({ $id: 'three', my: 'hola' })
     subinstance.get('/deep', (request, reply) => { reply.send(subinstance.getSchemas()) })
-    next()
+    done()
   })
-  next()
+  done()
 })
 ```
 This example will returns:
@@ -251,7 +252,8 @@ Fastify's [baseline ajv configuration](https://github.com/epoberezkin/ajv#option
   removeAdditional: true, // remove additional properties
   useDefaults: true, // replace missing properties and items with the values from corresponding default keyword
   coerceTypes: true, // change data type of data to match type keyword
-  allErrors: true    // check for all errors
+  allErrors: true,   // check for all errors
+  nullable: true     // support keyword "nullable" from Open API 3 specification.
 }
 ```
 
@@ -265,7 +267,8 @@ const ajv = new Ajv({
   removeAdditional: true,
   useDefaults: true,
   coerceTypes: true,
-  allErrors: true
+  allErrors: true,
+  nullable: true,
   // any other options
   // ...
 })

package/fastify.d.ts

@@ -69,9 +69,9 @@ declare namespace fastify {
   }
 
   type FastifyMiddleware<
-  HttpServer,
-  HttpRequest,
-  HttpResponse,
+  HttpServer = http.Server,
+  HttpRequest = http.IncomingMessage,
+  HttpResponse = http.ServerResponse,
   Query = DefaultQuery,
   Params = DefaultParams,
   Headers = DefaultHeaders,
@@ -84,9 +84,9 @@ declare namespace fastify {
   ) => void
 
   type FastifyMiddlewareWithPayload<
-  HttpServer,
-  HttpRequest,
-  HttpResponse,
+  HttpServer = http.Server,
+  HttpRequest = http.IncomingMessage,
+  HttpResponse = http.ServerResponse,
   Query = DefaultQuery,
   Params = DefaultParams,
   Headers = DefaultHeaders,
@@ -100,8 +100,8 @@ declare namespace fastify {
   ) => void
 
   type RequestHandler<
-  HttpRequest,
-  HttpResponse,
+  HttpRequest = http.IncomingMessage,
+  HttpResponse = http.ServerResponse,
   Query = DefaultQuery,
   Params = DefaultParams,
   Headers = DefaultHeaders,
@@ -130,7 +130,7 @@ declare namespace fastify {
    * fastify's wrapped version of node.js IncomingMessage
    */
   interface FastifyRequest<
-    HttpRequest,
+    HttpRequest = http.IncomingMessage,
     Query = DefaultQuery,
     Params = DefaultParams,
     Headers = DefaultHeaders,
@@ -166,6 +166,7 @@ declare namespace fastify {
     getHeader(name: string): string | undefined
     hasHeader(name: string): boolean
     callNotFound(): void
+    getResponseTime(): number
     type(contentType: string): FastifyReply<HttpResponse>
     redirect(url: string): FastifyReply<HttpResponse>
     redirect(statusCode: number, url: string): FastifyReply<HttpResponse>
@@ -178,6 +179,7 @@ declare namespace fastify {
   }
   type TrustProxyFunction = (addr: string, index: number) => boolean
   interface ServerOptions {
+    caseSensitive?: boolean,
     ignoreTrailingSlash?: boolean,
     bodyLimit?: number,
     pluginTimeout?: number,
@@ -196,7 +198,8 @@ declare namespace fastify {
       },
       deriveVersion<Context>(req: Object, ctx?: Context) : String,
     },
-    modifyCoreObjects?: boolean
+    modifyCoreObjects?: boolean,
+    return503OnClosing?: boolean
   }
   interface ServerOptionsAsSecure extends ServerOptions {
     https: http2.SecureServerOptions
@@ -264,9 +267,9 @@ declare namespace fastify {
    * Route configuration options such as "url" and "method"
    */
   interface RouteOptions<
-    HttpServer,
-    HttpRequest,
-    HttpResponse,
+    HttpServer = http.Server,
+    HttpRequest = http.IncomingMessage,
+    HttpResponse = http.ServerResponse,
     Query = DefaultQuery,
     Params = DefaultParams,
     Headers = DefaultHeaders,
@@ -313,7 +316,7 @@ declare namespace fastify {
       req: NodeJS.ReadableStream,
       res: http.ServerResponse
     },
-    headers: object,
+    headers: Record<string, string>,
     statusCode: number,
     statusMessage: string,
     payload: string,
@@ -658,6 +661,11 @@ declare namespace fastify {
      */
     setErrorHandler(handler: (error: FastifyError, request: FastifyRequest<HttpRequest>, reply: FastifyReply<HttpResponse>) => void): void
 
+    /**
+     * Set a function that will be called whenever an error happens
+     */
+    setReplySerializer(handler: (payload: string | object | Buffer | NodeJS.ReadableStream, statusCode: number) => string): void
+
     /**
      * Set the schema compiler for all routes.
      */

package/fastify.js

@@ -13,6 +13,7 @@ const {
   kHooks,
   kSchemas,
   kSchemaCompiler,
+  kReplySerializerDefault,
   kContentTypeParser,
   kReply,
   kRequest,
@@ -118,6 +119,7 @@ function build (options) {
     [kHooks]: new Hooks(),
     [kSchemas]: schemas,
     [kSchemaCompiler]: null,
+    [kReplySerializerDefault]: null,
     [kContentTypeParser]: new ContentTypeParser(bodyLimit, (options.onProtoPoisoning || defaultInitOptions.onProtoPoisoning)),
     [kReply]: Reply.buildReply(Reply),
     [kRequest]: Request.buildRequest(Request),
@@ -167,6 +169,7 @@ function build (options) {
     addSchema: addSchema,
     getSchemas: schemas.getSchemas.bind(schemas),
     setSchemaCompiler: setSchemaCompiler,
+    setReplySerializer: setReplySerializer,
     // custom parsers
     addContentTypeParser: ContentTypeParser.helpers.addContentTypeParser,
     hasContentTypeParser: ContentTypeParser.helpers.hasContentTypeParser,
@@ -242,6 +245,7 @@ function build (options) {
       fastify[kState].closing = true
       router.closeRoutes()
       if (fastify[kState].listening) {
+        // No new TCP connections are accepted
         instance.server.close(done)
       } else {
         done(null)
@@ -279,6 +283,16 @@ function build (options) {
     }
 
     if (fastify[kState].started) {
+      if (fastify[kState].closing) {
+        // Force to return an error
+        const error = new Error('Server is closed')
+        if (cb) {
+          cb(error)
+          return
+        } else {
+          return Promise.reject(error)
+        }
+      }
       return lightMyRequest(httpHandler, opts, cb)
     }
 
@@ -390,6 +404,13 @@ function build (options) {
     return this
   }
 
+  function setReplySerializer (replySerializer) {
+    throwIfAlreadyStarted('Cannot call "setReplySerializer" when fastify instance is already started!')
+
+    this[kReplySerializerDefault] = replySerializer
+    return this
+  }
+
   // wrapper that we expose to the user for configure the custom error handler
   function setErrorHandler (func) {
     throwIfAlreadyStarted('Cannot call "setErrorHandler" when fastify instance is already started!')

package/lib/context.js

@@ -1,10 +1,10 @@
 'use strict'
 
-const { kFourOhFourContext } = require('./symbols.js')
+const { kFourOhFourContext, kReplySerializerDefault } = require('./symbols.js')
 
 // Objects that holds the context of every request
 // Every route holds an instance of this object.
-function Context (schema, handler, Reply, Request, contentTypeParser, config, errorHandler, bodyLimit, logLevel, attachValidation) {
+function Context (schema, handler, Reply, Request, contentTypeParser, config, errorHandler, bodyLimit, logLevel, attachValidation, replySerializer) {
   this.schema = schema
   this.handler = handler
   this.Reply = Reply
@@ -22,14 +22,15 @@ function Context (schema, handler, Reply, Request, contentTypeParser, config, er
   this.logLevel = logLevel
   this[kFourOhFourContext] = null
   this.attachValidation = attachValidation
+  this[kReplySerializerDefault] = replySerializer
 }
 
 function defaultErrorHandler (error, request, reply) {
   var res = reply.res
   if (res.statusCode >= 500) {
-    res.log.error({ req: reply.request.raw, res: res, err: error }, error && error.message)
+    reply.log.error({ req: reply.request.raw, res: res, err: error }, error && error.message)
   } else if (res.statusCode >= 400) {
-    res.log.info({ res: res, err: error }, error && error.message)
+    reply.log.info({ res: res, err: error }, error && error.message)
   }
   reply.send(error)
 }