fastify 4.18.0 → 4.19.1

package/docs/Guides/Ecosystem.md

@@ -248,6 +248,8 @@ section.
   development servers that require Babel transformations of JavaScript sources.
 - [`fastify-bcrypt`](https://github.com/beliven-it/fastify-bcrypt) A Bcrypt hash
   generator & checker.
+- [`fastify-better-sqlite3`](https://github.com/punkish/fastify-better-sqlite3) 
+  Plugin for better-sqlite3.
 - [`fastify-blipp`](https://github.com/PavelPolyakov/fastify-blipp) Prints your
   routes to the console, so you definitely know which endpoints are available.
 - [`fastify-bookshelf`](https://github.com/butlerx/fastify-bookshelfjs) Fastify
@@ -258,6 +260,9 @@ section.
   to add [bree](https://github.com/breejs/bree) support.
 - [`fastify-bugsnag`](https://github.com/ZigaStrgar/fastify-bugsnag) Fastify plugin
   to add support for [Bugsnag](https://www.bugsnag.com/) error reporting.
+- [`fastify-cacheman`](https://gitlab.com/aalfiann/fastify-cacheman) 
+  Small and efficient cache provider for Node.JS with In-memory, File, Redis
+   and MongoDB engines for Fastify
 - [`fastify-casbin`](https://github.com/nearform/fastify-casbin) Casbin support
   for Fastify.
 - [`fastify-casbin-rest`](https://github.com/nearform/fastify-casbin-rest)

package/docs/Guides/Serverless.md

@@ -28,6 +28,7 @@ snippet of code.
 - [Google Cloud Functions](#google-cloud-functions)
 - [Google Cloud Run](#google-cloud-run)
 - [Netlify Lambda](#netlify-lambda)
+- [Platformatic Cloud](#platformatic-cloud)
 - [Vercel](#vercel)
 
 ## AWS
@@ -453,6 +454,47 @@ Add this command to your `package.json` *scripts*
 
 Then it should work fine
 
+## Platformatic Cloud
+
+[Platformatic](https://platformatic.dev) provides zero-configuration deployment
+for Node.js applications.
+To use it now, you should wrap your existing Fastify application inside a
+[Platformatic Service](https://oss.platformatic.dev/docs/reference/service/introduction),
+by running the following:
+
+
+```bash
+npm create platformatic@latest -- service
+```
+
+The wizard would ask you to fill in a few answers:
+
+```
+? Where would you like to create your project? .
+? Do you want to run npm install? yes
+? Do you want to use TypeScript? no
+? What port do you want to use? 3042
+[13:04:14] INFO: Configuration file platformatic.service.json successfully created.
+[13:04:14] INFO: Environment file .env successfully created.
+[13:04:14] INFO: Plugins folder "plugins" successfully created.
+[13:04:14] INFO: Routes folder "routes" successfully created.
+? Do you want to create the github action to deploy this application to Platformatic Cloud dynamic workspace? no
+? Do you want to create the github action to deploy this application to Platformatic Cloud static workspace? no
+```
+
+Then, head to [Platformatic Cloud](https://platformatic.cloud) and sign in
+with your GitHub account.
+Create your first application and a static workspace: be careful to download the
+API key as an env file, e.g. `yourworkspace.txt`.
+
+Then, you can easily deploy your application with the following commmand:
+
+```bash
+platformatic deploy --keys `yuourworkspace.txt`
+```
+
+Check out the [Full Guide](https://blog.platformatic.dev/how-to-migrate-a-fastify-app-to-platformatic-service)
+on how to wrap Fastify application in Platformatic.
 
 ## Vercel
 
@@ -506,4 +548,4 @@ async function routes (fastify, options) {
 }
 
 export default routes;
-```
+```

package/docs/Guides/Testing.md

@@ -1,12 +1,15 @@
-<h1 align="center">Fastify</h1>
+<h1 style="text-align: center;">Fastify</h1>
 
-## Testing
+# Testing
+<a id="testing"></a>
 
 Testing is one of the most important parts of developing an application. Fastify
 is very flexible when it comes to testing and is compatible with most testing
 frameworks (such as [Tap](https://www.npmjs.com/package/tap), which is used in
 the examples below).
 
+## Application
+
 Let's `cd` into a fresh directory called 'testing-example' and type `npm init
 -y` in our terminal.
 
@@ -345,3 +348,133 @@ test('should ...', {only: true}, t => ...)
 
 Now you should be able to step through your test file (and the rest of
 `Fastify`) in your code editor.
+
+
+
+## Plugins
+Let's `cd` into a fresh directory called 'testing-plugin-example' and type `npm init
+-y` in our terminal.
+
+Run `npm i fastify fastify-plugin && npm i tap -D`
+
+**plugin/myFirstPlugin.js**:
+
+```js
+const fP = require("fastify-plugin")
+
+async function myPlugin(fastify, options) {
+    fastify.decorateRequest("helloRequest", "Hello World")
+    fastify.decorate("helloInstance", "Hello Fastify Instance")
+}
+
+module.exports = fP(myPlugin)
+```
+
+A basic example of a Plugin. See [Plugin Guide](./Plugins-Guide.md)
+
+**test/myFirstPlugin.test.js**:
+
+```js
+const Fastify = require("fastify");
+const tap = require("tap");
+const myPlugin = require("../plugin/myFirstPlugin");
+
+tap.test("Test the Plugin Route", async t => {
+    // Create a mock fastify application to test the plugin
+    const fastify = Fastify()
+
+    fastify.register(myPlugin)
+
+    // Add an endpoint of your choice 
+    fastify.get("/", async (request, reply) => {
+        return ({ message: request.helloRequest })
+    })
+
+    // Use fastify.inject to fake a HTTP Request
+    const fastifyResponse = await fastify.inject({
+        method: "GET",
+        url: "/"
+    })
+    
+  console.log('status code: ', fastifyResponse.statusCode)
+  console.log('body: ', fastifyResponse.body)
+})
+```
+Learn more about [```fastify.inject()```](#benefits-of-using-fastifyinject).
+Run the test file in your terminal `node test/myFirstPlugin.test.js`
+
+```sh
+status code:  200
+body:  {"message":"Hello World"}
+```
+
+Now we can replace our `console.log` calls with actual tests!
+
+In your `package.json` change the "test" script to:
+
+`"test": "tap --reporter=list --watch"`
+
+Create the tap test for the endpoint.
+
+**test/myFirstPlugin.test.js**:
+
+```js
+const Fastify = require("fastify");
+const tap = require("tap");
+const myPlugin = require("../plugin/myFirstPlugin");
+
+tap.test("Test the Plugin Route", async t => {
+    // Specifies the number of test
+    t.plan(2)
+
+    const fastify = Fastify()
+
+    fastify.register(myPlugin)
+
+    fastify.get("/", async (request, reply) => {
+        return ({ message: request.helloRequest })
+    })
+
+    const fastifyResponse = await fastify.inject({
+        method: "GET",
+        url: "/"
+    })
+    
+    t.equal(fastifyResponse.statusCode, 200)
+    t.same(JSON.parse(fastifyResponse.body), { message: "Hello World" })
+})
+```
+
+Finally, run `npm test` in the terminal and see your test results!
+
+Test the ```.decorate()``` and ```.decorateRequest()```.
+
+**test/myFirstPlugin.test.js**:
+
+```js
+const Fastify = require("fastify");
+const tap = require("tap");
+const myPlugin = require("../plugin/myFirstPlugin");
+
+tap.test("Test the Plugin Route", async t => {
+    t.plan(5)
+    const fastify = Fastify()
+
+    fastify.register(myPlugin)
+
+    fastify.get("/", async (request, reply) => {
+        // Testing the fastify decorators
+        t.not(request.helloRequest, null) 
+        t.ok(request.helloRequest, "Hello World")
+        t.ok(fastify.helloInstance, "Hello Fastify Instance")
+        return ({ message: request.helloRequest })
+    })
+
+    const fastifyResponse = await fastify.inject({
+        method: "GET",
+        url: "/"
+    })
+    t.equal(fastifyResponse.statusCode, 200)
+    t.same(JSON.parse(fastifyResponse.body), { message: "Hello World" })
+})
+```

package/docs/Guides/Write-Plugin.md

@@ -1,4 +1,4 @@
-<h1 align="center">Fastify</h1>
+<h1 style="text-align: center;">Fastify</h1>
 
 # How to write a good plugin
 First, thank you for deciding to write a plugin for Fastify. Fastify is a
@@ -63,6 +63,8 @@ among different versions of its dependencies.
 We do not enforce any testing library. We use [`tap`](https://www.node-tap.org/)
 since it offers out-of-the-box parallel testing and code coverage, but it is up
 to you to choose your library of preference.
+We highly recommend you read the [Plugin Testing](./Testing.md#plugins) to 
+learn about how to test your plugins.
 
 ## Code Linter
 It is not mandatory, but we highly recommend you use a code linter in your

package/docs/Reference/Principles.md

@@ -0,0 +1,78 @@
+# Technical Principles
+
+Every decision in the Fastify framework and its official plugins is guided by
+the following technical principles:
+
+1. “Zero” overhead in production
+2. “Good” developer experience
+3. Works great for small & big projects alike
+4. Easy to migrate to microservices (or even serverless) and back
+5. Security & data validation
+6. If something could be a plugin, it likely should be
+7. Easily testable
+8. Do not monkeypatch core
+9. Semantic versioning & Long Term Support
+10. Specification adherence
+
+## "Zero" Overhead in Production
+
+Fastify aims to implement its features by adding as minimal overhead to your
+application as possible.
+This is usually delivered by implementing fast algorithms and data structures,
+as well as JavaScript-specific features.
+
+Given that JavaScript does not offer zero-overhead data structures, this principle
+is at odds with providing a great developer experience and providing more features,
+as usually those cost some overhead.
+
+## "Good" Developer Experience
+
+Fastify aims to provide the best developer experience at the performance point
+it is operating.
+It provides a great out-of-the-box experience that is flexible enough to be
+adapted to a variety of situations.
+
+As an example, this means that binary addons are forbidden because most JavaScript
+developers would not
+have access to a compiler.
+
+## Works great for small and big projects alike
+
+We recognize that most applications start small and become more complex over time.
+Fastify aims to grow with
+the complexity of your application, providing advanced features to structure
+your codebase.
+
+## Easy to migrate to microservices (or even serverless) and back
+
+How you deploy your routes should not matter. The framework should "just work".
+
+## Security and Data Validation
+
+Your web framework is the first point of contact with untrusted data, and it
+needs to act as the first line of defense for your system.
+
+## If something could be a plugin, it likely should
+
+We recognize that there are an infinite amount of use cases for an HTTP framework
+for Node.js. Catering to them in a single module would make the codebase unmaintainable.
+Therefore we provide hooks and options to allow you to customize the framework
+as you please.
+
+## Easily testable
+
+Testing Fastify applications should be a first-class concern.
+
+## Do not monkeypatch core
+
+Moonkeypatch Node.js APIs or installing globals that alter the behavior of the
+runtime makes building modular applications harder, and limit the use cases of Fastify.
+Other frameworks do this and we do not.
+
+## Semantic Versioning and Long Term Support
+
+We provide a clear Long Term Support strategy so developers can know when to upgrade.
+
+## Specification adherence
+
+In doubt, we chose the strict behavior as defined by the relevant Specifications.

package/docs/Reference/Request.md

@@ -27,6 +27,8 @@ Request is a core Fastify object containing the following fields:
 - `protocol` - the protocol of the incoming request (`https` or `http`)
 - `method` - the method of the incoming request
 - `url` - the URL of the incoming request
+- `originalUrl` - similar to `url`, this allows you to access the 
+  original `url` in case of internal re-routing 
 - `routerMethod` - the method defined for the router that is handling the
   request
 - `routerPath` - the path pattern defined for the router that is handling the

package/docs/Reference/Routes.md

@@ -112,6 +112,11 @@ fastify.route(options)
 * `config`: object used to store custom configuration.
 * `version`: a [semver](https://semver.org/) compatible string that defined the
   version of the endpoint. [Example](#version-constraints).
+* `constraints`: defines route restrictions based on request properties or
+  values, enabling customized matching using 
+  [find-my-way](https://github.com/delvedor/find-my-way) constraints. Includes 
+  built-in `version` and `host` constraints, with support for custom constraint
+  strategies.
 * `prefixTrailingSlash`: string used to determine how to handle passing `/` as a
   route with a prefix.
   * `both` (default): Will register both `/prefix` and `/prefix/`.

package/docs/Reference/Server.md

@@ -527,8 +527,8 @@ Defines the label used for the request identifier when logging the request.
 ### `genReqId`
 <a id="factory-gen-request-id"></a>
 
-Function for generating the request-id. It will receive the incoming request as
-a parameter. This function is expected to be error-free.
+Function for generating the request-id. It will receive the _raw_ incoming
+request as a parameter. This function is expected to be error-free.
 
 + Default: `value of 'request-id' header if provided or monotonically increasing
   integers`
@@ -856,6 +856,9 @@ is an instance-wide configuration.
 [server](https://nodejs.org/api/http.html#http_class_http_server) object as
 returned by the [**`Fastify factory function`**](#factory).
 
+>__Warning__: If utilized improperly, certain Fastify features could be disrupted.
+>It is recommended to only use it for attaching listeners.
+
 #### after
 <a id="after"></a>
 

package/docs/Reference/Type-Providers.md

@@ -11,15 +11,16 @@ keep associated types for each schema defined in your project.
 
 Type Providers are offered as additional packages you will need to install into
 your project. Each provider uses a different inference library under the hood;
-allowing you to select the library most appropriate for your needs. Type
+allowing you to select the library most appropriate for your needs. Official Type
 Provider packages follow a `@fastify/type-provider-{provider-name}` naming
-convention.
+convention, and there are several community ones available as well.
 
 The following inference packages are supported:
 
 - `json-schema-to-ts` -
   [github](https://github.com/ThomasAribart/json-schema-to-ts)
 - `typebox` - [github](https://github.com/sinclairzx81/typebox)
+- `zod` - [github](https://github.com/colinhacks/zod)
 
 ### Json Schema to Ts
 
@@ -91,6 +92,12 @@ See also the [TypeBox
 documentation](https://github.com/sinclairzx81/typebox#validation) on how to set
 up AJV to work with TypeBox.
 
+### Zod
+
+See [official documentation](https://github.com/turkerdev/fastify-type-provider-zod)
+for Zod type provider instructions.
+
+
 ### Scoped Type-Provider
 
 The provider types don't propagate globally. In encapsulated usage, one can

package/docs/Reference/TypeScript.md

@@ -111,7 +111,7 @@ generic types for route schemas and the dynamic properties located on the
 route-level `request` object.
 
 1. If you did not complete the previous example, follow steps 1-4 to get set up.
-2. Inside `index.ts`, define two interfaces `IQuerystring` and `IHeaders`:
+2. Inside `index.ts`, define three interfaces `IQuerystring`,`IHeaders` and `IReply`:
    ```typescript
    interface IQuerystring {
      username: string;
@@ -121,8 +121,14 @@ route-level `request` object.
    interface IHeaders {
      'h-Custom': string;
    }
+
+   interface IReply {
+     200: { success: boolean };
+     302: { url: string };
+     '4xx': { error: string };
+   }
    ```
-3. Using the two interfaces, define a new API route and pass them as generics.
+3. Using the three interfaces, define a new API route and pass them as generics.
    The shorthand route methods (i.e. `.get`) accept a generic object
    `RouteGenericInterface` containing five named properties: `Body`,
    `Querystring`, `Params`, `Headers` and `Reply`. The interfaces `Body`,
@@ -132,12 +138,20 @@ route-level `request` object.
    ```typescript
    server.get<{
      Querystring: IQuerystring,
-     Headers: IHeaders
+     Headers: IHeaders,
+     Reply: IReply
    }>('/auth', async (request, reply) => {
      const { username, password } = request.query
      const customerHeader = request.headers['h-Custom']
      // do something with request data
 
+     // chaining .statusCode/.code calls with .send allows type narrowing. For example:
+     // this works
+     reply.code(200).send({ success: true });
+     // but this gives a type error
+     reply.code(200).send('uh-oh');
+     // it even works for wildcards
+     reply.code(404).send({ error: 'Not found' });
      return `logged in!`
    })
    ```
@@ -154,7 +168,8 @@ route-level `request` object.
    ```typescript
    server.get<{
      Querystring: IQuerystring,
-     Headers: IHeaders
+     Headers: IHeaders,
+     Reply: IReply
    }>('/auth', {
      preValidation: (request, reply, done) => {
        const { username, password } = request.query
@@ -172,7 +187,7 @@ route-level `request` object.
    admin"}`
 
 🎉 Good work, now you can define interfaces for each route and have strictly
-typed request and reply instances. Other parts of the Fastify type system rely
+typed request and reply instances. Other parts of the Fastify type system rely 
 on generic properties. Make sure to reference the detailed type system
 documentation below to learn more about what is available.
 
@@ -493,7 +508,7 @@ Fastify Plugin in a TypeScript Project.
    `"compilerOptions"` object.
    ```json
    {
-     "compileOptions": {
+     "compilerOptions": {
        "declaration": true
      }
    }

package/fastify.d.ts

@@ -109,7 +109,7 @@ declare namespace fastify {
     requestIdHeader?: string | false,
     requestIdLogLabel?: string;
     jsonShorthand?: boolean;
-    genReqId?: <RequestGeneric extends RequestGenericInterface = RequestGenericInterface, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault>(req: FastifyRequest<RequestGeneric, RawServer, RawRequestDefaultExpression<RawServer>, FastifySchema, TypeProvider>) => string,
+    genReqId?: (req: RawRequestDefaultExpression<RawServer>) => string,
     trustProxy?: boolean | string | string[] | number | TrustProxyFunction,
     querystringParser?: (str: string) => { [key: string]: unknown },
     /**

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.18.0'
+const VERSION = '4.19.1'
 
 const Avvio = require('avvio')
 const http = require('http')
@@ -426,10 +426,13 @@ function fastify (options) {
       router.closeRoutes()
 
       hookRunnerApplication('preClose', fastify[kAvvioBoot], fastify, function () {
-        if (fastify[kState].listening) {
-          // No new TCP connections are accepted
-          instance.server.close(done)
+        // No new TCP connections are accepted.
+        // We must call close on the server even if we are not listening
+        // otherwise memory will be leaked.
+        // https://github.com/nodejs/node/issues/48604
+        instance.server.close(done)
 
+        if (fastify[kState].listening) {
           /* istanbul ignore next: Cannot test this without Node.js core support */
           if (forceCloseConnections === 'idle') {
             // Not needed in Node 19
@@ -653,6 +656,11 @@ function fastify (options) {
       errorStatus = http.STATUS_CODES[errorCode]
       body = `{"error":"${errorStatus}","message":"Client Timeout","statusCode":408}`
       errorLabel = 'timeout'
+    } else if (err.code === 'HPE_HEADER_OVERFLOW') {
+      errorCode = '431'
+      errorStatus = http.STATUS_CODES[errorCode]
+      body = `{"error":"${errorStatus}","message":"Exceeded maximum allowed HTTP header size","statusCode":431}`
+      errorLabel = 'header_overflow'
     } else {
       errorCode = '400'
       errorStatus = http.STATUS_CODES[errorCode]
@@ -692,10 +700,13 @@ function fastify (options) {
       const id = genReqId(req)
       const childLogger = logger.child({ reqId: id })
 
-      childLogger.info({ req }, 'incoming request')
-
       const request = new Request(id, null, req, null, childLogger, onBadUrlContext)
       const reply = new Reply(res, request, childLogger)
+
+      if (disableRequestLogging === false) {
+        childLogger.info({ req: request }, 'incoming request')
+      }
+
       return frameworkErrors(new FST_ERR_BAD_URL(path), request, reply)
     }
     const body = `{"error":"Bad Request","code":"FST_ERR_BAD_URL","message":"'${path}' is not a valid url component","statusCode":400}`
@@ -714,10 +725,13 @@ function fastify (options) {
           const id = genReqId(req)
           const childLogger = logger.child({ reqId: id })
 
-          childLogger.info({ req }, 'incoming request')
-
           const request = new Request(id, null, req, null, childLogger, onBadUrlContext)
           const reply = new Reply(res, request, childLogger)
+
+          if (disableRequestLogging === false) {
+            childLogger.info({ req: request }, 'incoming request')
+          }
+
           return frameworkErrors(new FST_ERR_ASYNC_CONSTRAINT(), request, reply)
         }
         const body = '{"error":"Internal Server Error","message":"Unexpected error from async constraint","statusCode":500}'
@@ -793,6 +807,7 @@ function fastify (options) {
       // only call isAsyncConstraint once
       if (isAsync === undefined) isAsync = router.isAsyncConstraint()
       if (rewriteUrl) {
+        req.originalUrl = req.url
         const url = rewriteUrl.call(fastify, req)
         if (typeof url === 'string') {
           req.url = url

package/lib/contentTypeParser.js

@@ -281,7 +281,7 @@ function getDefaultJsonParser (onProtoPoisoning, onConstructorPoisoning) {
   return defaultJsonParser
 
   function defaultJsonParser (req, body, done) {
-    if (body === '' || body == null) {
+    if (body === '' || body == null || (Buffer.isBuffer(body) && body.length === 0)) {
       return done(new FST_ERR_CTP_EMPTY_JSON_BODY(), undefined)
     }
     let json

package/lib/reply.js

@@ -357,7 +357,7 @@ Reply.prototype.compileSerializationSchema = function (schema, httpStatus = null
   })
 
   // We create a WeakMap to compile the schema only once
-  // Its done leazily to avoid add overhead by creating the WeakMap
+  // Its done lazily to avoid add overhead by creating the WeakMap
   // if it is not used
   // TODO: Explore a central cache for all the schemas shared across
   // encapsulated contexts
@@ -859,7 +859,7 @@ function notFound (reply) {
  * @param {object} context the request context
  * @param {object} data the JSON payload to serialize
  * @param {number} statusCode the http status code
- * @param {string} contentType the reply content type
+ * @param {string} [contentType] the reply content type
  * @returns {string} the serialized payload
  */
 function serialize (context, data, statusCode, contentType) {

package/lib/request.js

@@ -13,7 +13,8 @@ const {
   kOptions,
   kRequestCacheValidateFns,
   kRouteContext,
-  kPublicRouteContext
+  kPublicRouteContext,
+  kRequestOriginalUrl
 } = require('./symbols')
 const { FST_ERR_REQ_INVALID_VALIDATION_INVOCATION } = require('./errors')
 
@@ -149,6 +150,15 @@ Object.defineProperties(Request.prototype, {
       return this.raw.url
     }
   },
+  originalUrl: {
+    get () {
+      /* istanbul ignore else */
+      if (!this[kRequestOriginalUrl]) {
+        this[kRequestOriginalUrl] = this.raw.originalUrl || this.raw.url
+      }
+      return this[kRequestOriginalUrl]
+    }
+  },
   method: {
     get () {
       return this.raw.method
@@ -162,7 +172,7 @@ Object.defineProperties(Request.prototype, {
   },
   routerPath: {
     get () {
-      return this[kRouteContext].config.url
+      return this[kRouteContext].config?.url
     }
   },
   routeOptions: {
@@ -172,8 +182,8 @@ Object.defineProperties(Request.prototype, {
       const serverLimit = context.server.initialConfig.bodyLimit
       const version = context.server.hasConstraintStrategy('version') ? this.raw.headers['accept-version'] : undefined
       const options = {
-        method: context.config.method,
-        url: context.config.url,
+        method: context.config?.method,
+        url: context.config?.url,
         bodyLimit: (routeLimit || serverLimit),
         attachValidation: context.attachValidation,
         logLevel: context.logLevel,
@@ -186,12 +196,12 @@ Object.defineProperties(Request.prototype, {
   },
   routerMethod: {
     get () {
-      return this[kRouteContext].config.method
+      return this[kRouteContext].config?.method
     }
   },
   routeConfig: {
     get () {
-      return this[kRouteContext][kPublicRouteContext].config
+      return this[kRouteContext][kPublicRouteContext]?.config
     }
   },
   routeSchema: {
@@ -201,7 +211,7 @@ Object.defineProperties(Request.prototype, {
   },
   is404: {
     get () {
-      return this[kRouteContext].config.url === undefined
+      return this[kRouteContext].config?.url === undefined
     }
   },
   connection: {
@@ -283,7 +293,7 @@ Object.defineProperties(Request.prototype, {
       })
 
       // We create a WeakMap to compile the schema only once
-      // Its done leazily to avoid add overhead by creating the WeakMap
+      // Its done lazily to avoid add overhead by creating the WeakMap
       // if it is not used
       // TODO: Explore a central cache for all the schemas shared across
       // encapsulated contexts

package/lib/route.js

@@ -468,7 +468,6 @@ function buildRouting (options) {
 
     const request = new context.Request(id, params, req, query, childLogger, context)
     const reply = new context.Reply(res, request, childLogger)
-
     if (disableRequestLogging === false) {
       childLogger.info({ req: request }, 'incoming request')
     }