fastify 4.0.1 → 4.1.0

package/.eslintrc

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

package/README.md

@@ -56,7 +56,7 @@ developer experience with the least overhead and a powerful plugin architecture.
 It is inspired by Hapi and Express and as far as we know, it is one of the
 fastest web frameworks in town.
 
-This branch refers to the upcoming Fastify v4 release. Check out the
+This branch refers to the Fastify v4 release. Check out the
 [v3.x](https://github.com/fastify/fastify/tree/v3.x) branch for v3.
 
 ### Quick start
@@ -104,11 +104,11 @@ project as a dependency:
 
 Install with npm:
 ```sh
-npm i fastify@next
+npm i fastify
 ```
 Install with yarn:
 ```sh
-yarn add fastify@next
+yarn add fastify
 ```
 
 ### Example

package/build/build-error-serializer.js

@@ -1,3 +1,4 @@
+/* istanbul ignore file */
 'use strict'
 
 const FJS = require('fast-json-stringify')

package/docs/Guides/Database.md

@@ -37,7 +37,7 @@ fastify.get('/user/:id', function(req, reply) {
   )
 })
 
-fastify.listen(3000, err => {
+fastify.listen({ port: 3000 }, err => {
   if (err) throw err
   console.log(`server listening on ${fastify.server.address().port}`)
 })
@@ -64,7 +64,7 @@ fastify.get('/user/:id', function (req, reply) {
   )
 })
 
-fastify.listen(3000, err => {
+fastify.listen({ port: 3000 }, err => {
   if (err) throw err
   console.log(`server listening on ${fastify.server.address().port}`)
 })
@@ -98,7 +98,7 @@ fastify.post('/foo', function (req, reply) {
   })
 })
 
-fastify.listen(3000, err => {
+fastify.listen({ port: 3000 }, err => {
   if (err) throw err
   console.log(`server listening on ${fastify.server.address().port}`)
 })
@@ -145,7 +145,7 @@ fastify.get('/user/:id', function (req, reply) {
   })
 })
 
-fastify.listen(3000, err => {
+fastify.listen({ port: 3000 }, err => {
   if (err) throw err
 })
 ```
@@ -172,7 +172,7 @@ fastify.post('/foo', async function (req, reply) {
   return { status: 'ok' }
 })
 
-fastify.listen(3000, err => {
+fastify.listen({ port: 3000 }, err => {
   if (err) throw err
   console.log(`server listening on ${fastify.server.address().port}`)
 })

package/docs/Guides/Ecosystem.md

@@ -346,6 +346,9 @@ section.
   minification and transformation of responses.
 - [`fastify-mongo-memory`](https://github.com/chapuletta/fastify-mongo-memory)
   Fastify MongoDB in Memory Plugin for testing support.
+- [`fastify-mongodb-sanitizer`](https://github.com/KlemenKozelj/fastify-mongodb-sanitizer)
+  Fastify plugin that sanitizes client input to prevent
+  potential MongoDB query injection attacks.
 - [`fastify-mongoose-api`](https://github.com/jeka-kiselyov/fastify-mongoose-api)
   Fastify plugin to create REST API methods based on Mongoose MongoDB models.
 - [`fastify-mongoose-driver`](https://github.com/alex-ppg/fastify-mongoose)

package/docs/Guides/Migration-Guide-V4.md

@@ -14,14 +14,31 @@ Starting this version of Fastify, we have deprecated the use of `app.use()`. We
 have decided not to support the use of middlewares. Both
 [`@fastify/middie`](https://github.com/fastify/middie) and
 [`@fastify/express`](https://github.com/fastify/fastify-express) will still be
-there and maintained. Use Fastify's [hooks](./Reference/Hooks.md) instead.
+there and maintained. Use Fastify's [hooks](../Reference/Hooks.md) instead.
+
+### `reply.res` moved to `reply.raw`
+
+If you previously used the `reply.res` attribute to access the underlying Request
+object you'll instead need to depend on `reply.raw`.
+
+### Need to `return reply` to signal a "fork" of the promise chain
+
+In some situations, like when a response is sent asynchronously or when you're
+just not explicitly returning a response, you'll need to return the `reply`
+argument from your router handler.
+
+### `exposeHeadRoutes` true by default
+
+Starting from v4, all the `GET` routes will create a sibling `HEAD` route.
+You can revert this behaviour by setting the server's option `exposeHeadRoutes`
+to `false`.
 
 ## Non Breaking Changes
 
 ### Change of schema for multiple types
 
 
-Since Fastiy v4 has upgraded to Ajv v8. The "type" keywords with multiple types
+Since Fastify v4 has upgraded to Ajv v8. The "type" keywords with multiple types
 (other than with "null") are prohibited. Read more
 ['here'](https://ajv.js.org/strict-mode.html#strict-types)
 

package/docs/Reference/LTS.md

@@ -47,8 +47,8 @@ A "month" is defined as 30 consecutive days.
 | :------ | :----------- | :-------------- | :------------------- |
 | 1.0.0   | 2018-03-06   | 2019-09-01      | 6, 8, 9, 10, 11      |
 | 2.0.0   | 2019-02-25   | 2021-01-31      | 6, 8, 10, 12, 14     |
-| 3.0.0   | 2020-07-07   | TBD             | 10, 12, 14, 16, 18   |
-| 4.0.0   | TBD          | TBD             | 14, 16, 18           |
+| 3.0.0   | 2020-07-07   | 2023-06-30      | 10, 12, 14, 16, 18   |
+| 4.0.0   | 2022-06-08   | TBD             | 14, 16, 18           |
 
 ### CI tested operating systems
 <a id="supported-os"></a>

package/docs/Reference/Server.md

@@ -1278,7 +1278,7 @@ const fastify = Fastify({
      */
     bucket: function factory (parentSchemas) {
       return {
-        addSchema (inputSchema) {
+        add (inputSchema) {
           // This function must store the schema added by the user.
           // This function is invoked when `fastify.addSchema()` is called.
         },

package/docs/Reference/Type-Providers.md

@@ -30,11 +30,11 @@ $ npm i @fastify/type-provider-json-schema-to-ts
 ```
 
 ```typescript
-import { JsonSchemaToTsTypeProvider } from '@fastify/type-provider-json-schema-to-ts'
+import { JsonSchemaToTsProvider } from '@fastify/type-provider-json-schema-to-ts'
 
 import fastify from 'fastify'
 
-const server = fastify().withTypeProvider<JsonSchemaToTsTypeProvider>()
+const server = fastify().withTypeProvider<JsonSchemaToTsProvider>()
 
 server.get('/route', {
     schema: {
@@ -65,7 +65,8 @@ $ npm i @fastify/type-provider-typebox
 ```
 
 ```typescript
-import { TypeBoxTypeProvider, Type } from '@fastify/type-provider-typebox'
+import { TypeBoxTypeProvider } from '@fastify/type-provider-typebox'
+import { Type } from '@sinclair/typebox'
 
 import fastify from 'fastify'
 

package/fastify.d.ts

@@ -146,7 +146,7 @@ export type FastifyServerOptions<
   },
   schemaController?: {
     bucket?: (parentSchemas?: unknown) => {
-      addSchema(schema: unknown): FastifyInstance;
+      add(schema: unknown): FastifyInstance;
       getSchema(schemaId: string): unknown;
       getSchemas(): Record<string, unknown>;
     };

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.0.1'
+const VERSION = '4.1.0'
 
 const Avvio = require('avvio')
 const http = require('http')
@@ -237,35 +237,35 @@ function fastify (options) {
     getDefaultRoute: router.getDefaultRoute.bind(router),
     setDefaultRoute: router.setDefaultRoute.bind(router),
     // routes shorthand methods
-    delete: function _delete (url, opts, handler) {
-      return router.prepareRoute.call(this, 'DELETE', url, opts, handler)
+    delete: function _delete (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'DELETE', url, options, handler })
     },
-    get: function _get (url, opts, handler) {
-      return router.prepareRoute.call(this, 'GET', url, opts, handler)
+    get: function _get (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'GET', url, options, handler })
     },
-    head: function _head (url, opts, handler) {
-      return router.prepareRoute.call(this, 'HEAD', url, opts, handler)
+    head: function _head (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'HEAD', url, options, handler })
     },
-    patch: function _patch (url, opts, handler) {
-      return router.prepareRoute.call(this, 'PATCH', url, opts, handler)
+    patch: function _patch (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'PATCH', url, options, handler })
     },
-    post: function _post (url, opts, handler) {
-      return router.prepareRoute.call(this, 'POST', url, opts, handler)
+    post: function _post (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'POST', url, options, handler })
     },
-    put: function _put (url, opts, handler) {
-      return router.prepareRoute.call(this, 'PUT', url, opts, handler)
+    put: function _put (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'PUT', url, options, handler })
     },
-    options: function _options (url, opts, handler) {
-      return router.prepareRoute.call(this, 'OPTIONS', url, opts, handler)
+    options: function _options (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'OPTIONS', url, options, handler })
     },
-    all: function _all (url, opts, handler) {
-      return router.prepareRoute.call(this, supportedMethods, url, opts, handler)
+    all: function _all (url, options, handler) {
+      return router.prepareRoute.call(this, { method: supportedMethods, url, options, handler })
     },
     // extended route
-    route: function _route (opts) {
+    route: function _route (options) {
       // we need the fastify object that we are producing so we apply a lazy loading of the function,
       // otherwise we should bind it after the declaration
-      return router.route.call(this, opts)
+      return router.route.call(this, { options })
     },
     // expose logger instance
     log: logger,

package/lib/error-serializer.js

@@ -1,15 +1,183 @@
 // This file is autogenerated by build/build-error-serializer.js, do not edit
 /* istanbul ignore file */
 
-'use strict'
+  'use strict'
 
-const Serializer = require('fast-json-stringify/serializer')
-const buildAjv = require('fast-json-stringify/ajv')
+  
+
+class Serializer {
+  constructor (options = {}) {
+    switch (options.rounding) {
+      case 'floor':
+        this.parseInteger = Math.floor
+        break
+      case 'ceil':
+        this.parseInteger = Math.ceil
+        break
+      case 'round':
+        this.parseInteger = Math.round
+        break
+      default:
+        this.parseInteger = Math.trunc
+        break
+    }
+  }
 
-const serializer = new Serializer({"mode":"standalone"})
-const ajv = buildAjv({})
+  asAny (i) {
+    return JSON.stringify(i)
+  }
+
+  asNull () {
+    return 'null'
+  }
 
+  asInteger (i) {
+    if (typeof i === 'bigint') {
+      return i.toString()
+    } else if (Number.isInteger(i)) {
+      return '' + i
+    } else {
+      /* eslint no-undef: "off" */
+      const integer = this.parseInteger(i)
+      if (Number.isNaN(integer)) {
+        throw new Error(`The value "${i}" cannot be converted to an integer.`)
+      } else {
+        return '' + integer
+      }
+    }
+  }
+
+  asIntegerNullable (i) {
+    return i === null ? 'null' : this.asInteger(i)
+  }
+
+  asNumber (i) {
+    const num = Number(i)
+    if (Number.isNaN(num)) {
+      throw new Error(`The value "${i}" cannot be converted to a number.`)
+    } else {
+      return '' + num
+    }
+  }
+
+  asNumberNullable (i) {
+    return i === null ? 'null' : this.asNumber(i)
+  }
+
+  asBoolean (bool) {
+    return bool && 'true' || 'false' // eslint-disable-line
+  }
+
+  asBooleanNullable (bool) {
+    return bool === null ? 'null' : this.asBoolean(bool)
+  }
+
+  asDatetime (date, skipQuotes) {
+    const quotes = skipQuotes === true ? '' : '"'
+    if (date instanceof Date) {
+      return quotes + date.toISOString() + quotes
+    }
+    return this.asString(date, skipQuotes)
+  }
+
+  asDatetimeNullable (date, skipQuotes) {
+    return date === null ? 'null' : this.asDatetime(date, skipQuotes)
+  }
+
+  asDate (date, skipQuotes) {
+    const quotes = skipQuotes === true ? '' : '"'
+    if (date instanceof Date) {
+      return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(0, 10) + quotes
+    }
+    return this.asString(date, skipQuotes)
+  }
 
+  asDateNullable (date, skipQuotes) {
+    return date === null ? 'null' : this.asDate(date, skipQuotes)
+  }
+
+  asTime (date, skipQuotes) {
+    const quotes = skipQuotes === true ? '' : '"'
+    if (date instanceof Date) {
+      return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(11, 19) + quotes
+    }
+    return this.asString(date, skipQuotes)
+  }
+
+  asTimeNullable (date, skipQuotes) {
+    return date === null ? 'null' : this.asTime(date, skipQuotes)
+  }
+
+  asString (str, skipQuotes) {
+    const quotes = skipQuotes === true ? '' : '"'
+    if (str instanceof Date) {
+      return quotes + str.toISOString() + quotes
+    } else if (str === null) {
+      return quotes + quotes
+    } else if (str instanceof RegExp) {
+      str = str.source
+    } else if (typeof str !== 'string') {
+      str = str.toString()
+    }
+    // If we skipQuotes it means that we are using it as test
+    // no need to test the string length for the render
+    if (skipQuotes) {
+      return str
+    }
+
+    if (str.length < 42) {
+      return this.asStringSmall(str)
+    } else {
+      return JSON.stringify(str)
+    }
+  }
+
+  asStringNullable (str) {
+    return str === null ? 'null' : this.asString(str)
+  }
+
+  // magically escape strings for json
+  // relying on their charCodeAt
+  // everything below 32 needs JSON.stringify()
+  // every string that contain surrogate needs JSON.stringify()
+  // 34 and 92 happens all the time, so we
+  // have a fast case for them
+  asStringSmall (str) {
+    const l = str.length
+    let result = ''
+    let last = 0
+    let found = false
+    let surrogateFound = false
+    let point = 255
+    // eslint-disable-next-line
+    for (var i = 0; i < l && point >= 32; i++) {
+      point = str.charCodeAt(i)
+      if (point >= 0xD800 && point <= 0xDFFF) {
+        // The current character is a surrogate.
+        surrogateFound = true
+      }
+      if (point === 34 || point === 92) {
+        result += str.slice(last, i) + '\\'
+        last = i
+        found = true
+      }
+    }
+
+    if (!found) {
+      result = str
+    } else {
+      result += str.slice(last)
+    }
+    return ((point < 32) || (surrogateFound === true)) ? JSON.stringify(str) : '"' + result + '"'
+  }
+}
+
+  
+
+  const serializer = new Serializer({"mode":"standalone"})
+  
+
+  
     function main (input) {
       let json = ''
       json += anonymous0(input)
@@ -81,5 +249,5 @@ const ajv = buildAjv({})
     
     
 
-module.exports = main
-    
+  module.exports = main
+      

package/lib/reply.js

@@ -291,7 +291,7 @@ Reply.prototype.removeTrailer = function (key) {
 
 Reply.prototype.code = function (code) {
   const intValue = parseInt(code)
-  if (isNaN(intValue) || intValue < 100 || intValue > 600) {
+  if (isNaN(intValue) || intValue < 100 || intValue > 599) {
     throw new FST_ERR_BAD_STATUS_CODE(code || String(code))
   }
 
@@ -331,10 +331,12 @@ Reply.prototype.redirect = function (code, url) {
   }
 
   this.header('location', url).code(code).send()
+  return this
 }
 
 Reply.prototype.callNotFound = function () {
   notFound(this)
+  return this
 }
 
 Reply.prototype.getResponseTime = function () {

package/lib/route.js

@@ -113,7 +113,7 @@ function buildRouting (options) {
   }
 
   // Convert shorthand to extended route declaration
-  function prepareRoute (method, url, options, handler) {
+  function prepareRoute ({ method, url, options, handler }) {
     if (typeof url !== 'string') {
       throw new FST_ERR_INVALID_URL(typeof url)
     }
@@ -140,11 +140,11 @@ function buildRouting (options) {
       handler: handler || (options && options.handler)
     })
 
-    return route.call(this, options)
+    return route.call(this, { options })
   }
 
   // Route management
-  function route (options) {
+  function route ({ options }) {
     // Since we are mutating/assigning only top level props, it is fine to have a shallow copy using the spread operator
     const opts = { ...options }
 
@@ -176,30 +176,30 @@ function buildRouting (options) {
     if (path === '/' && prefix.length > 0 && opts.method !== 'HEAD') {
       switch (opts.prefixTrailingSlash) {
         case 'slash':
-          addNewRoute.call(this, path)
+          addNewRoute.call(this, { path })
           break
         case 'no-slash':
-          addNewRoute.call(this, '')
+          addNewRoute.call(this, { path: '' })
           break
         case 'both':
         default:
-          addNewRoute.call(this, '')
+          addNewRoute.call(this, { path: '' })
           // If ignoreTrailingSlash is set to true we need to add only the '' route to prevent adding an incomplete one.
           if (ignoreTrailingSlash !== true && (ignoreDuplicateSlashes !== true || !prefix.endsWith('/'))) {
-            addNewRoute.call(this, path, true)
+            addNewRoute.call(this, { path, prefixing: true })
           }
       }
     } else if (path[0] === '/' && prefix.endsWith('/')) {
       // Ensure that '/prefix/' + '/route' gets registered as '/prefix/route'
-      addNewRoute.call(this, path.slice(1))
+      addNewRoute.call(this, { path: path.slice(1) })
     } else {
-      addNewRoute.call(this, path)
+      addNewRoute.call(this, { path })
     }
 
     // chainable api
     return this
 
-    function addNewRoute (path, prefixing = false) {
+    function addNewRoute ({ path, prefixing = false }) {
       const url = prefix + path
 
       opts.url = url
@@ -326,7 +326,7 @@ function buildRouting (options) {
 
         if (shouldExposeHead && options.method === 'GET' && !headRouteExists) {
           const onSendHandlers = parseHeadOnSendHandlers(opts.onSend)
-          prepareRoute.call(this, 'HEAD', path, { ...opts, onSend: onSendHandlers })
+          prepareRoute.call(this, { method: 'HEAD', url: path, options: { ...opts, onSend: onSendHandlers } })
         } else if (headRouteExists && exposeHeadRoute) {
           warning.emit('FSTDEP007')
         }

package/lib/server.js

@@ -41,7 +41,15 @@ function createServer (options, httpHandler) {
       listenOptions.cb = cb
     }
 
-    const { host = 'localhost' } = listenOptions
+    // If we have a path specified, don't default host to 'localhost' so we don't end up listening
+    // on both path and host
+    // See https://github.com/fastify/fastify/issues/4007
+    let host
+    if (listenOptions.path == null) {
+      host = listenOptions.host ?? 'localhost'
+    } else {
+      host = listenOptions.host
+    }
     if (Object.prototype.hasOwnProperty.call(listenOptions, 'host') === false) {
       listenOptions.host = host
     }

package/lib/wrapThenable.js

@@ -11,9 +11,14 @@ function wrapThenable (thenable, reply) {
       return
     }
 
-    // this is for async functions that
-    // are using reply.send directly
-    if (payload !== undefined || reply.sent === false) {
+    // this is for async functions that are using reply.send directly
+    //
+    // since wrap-thenable will be called when using reply.send directly
+    // without actual return. the response can be sent already or
+    // the request may be terminated during the reply. in this situation,
+    // it require an extra checking of request.aborted to see whether
+    // the request is killed by client.
+    if (payload !== undefined || (reply.sent === false && reply.raw.headersSent === false && reply.request.raw.aborted === false)) {
       // we use a try-catch internally to avoid adding a catch to another
       // promise, increase promise perf by 10%
       try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -17,7 +17,7 @@
     "lint:markdown": "markdownlint-cli2",
     "lint:standard": "standard | snazzy",
     "lint:typescript": "eslint -c types/.eslintrc.json types/**/*.d.ts test/types/**/*.test-d.ts",
-    "prepublishOnly": "tap --no-check-coverage test/internals/version.test.js",
+    "prepublishOnly": "tap --no-check-coverage test/build/**.test.js",
     "test": "npm run lint && npm run unit && npm run test:typescript",
     "test:ci": "npm run unit -- -R terse --cov --coverage-report=lcovonly && npm run test:typescript",
     "test:report": "npm run lint && npm run unit:report && npm run test:typescript",
@@ -128,7 +128,7 @@
     "@fastify/pre-commit": "^2.0.2",
     "@sinclair/typebox": "^0.23.5",
     "@sinonjs/fake-timers": "^9.1.2",
-    "@types/node": "^17.0.38",
+    "@types/node": "^18.0.0",
     "@typescript-eslint/eslint-plugin": "^5.27.0",
     "@typescript-eslint/parser": "^5.27.0",
     "ajv": "^8.11.0",
@@ -146,7 +146,7 @@
     "eslint-plugin-n": "^15.2.0",
     "eslint-plugin-promise": "^6.0.0",
     "fast-json-body": "^1.1.0",
-    "fast-json-stringify": "^4.1.0",
+    "fast-json-stringify": "^4.2.0",
     "fastify-plugin": "^3.0.1",
     "fluent-json-schema": "^3.1.0",
     "form-data": "^4.0.0",
@@ -170,7 +170,7 @@
     "split2": "^4.1.0",
     "standard": "^17.0.0-2",
     "tap": "^16.2.0",
-    "tsd": "^0.20.0",
+    "tsd": "^0.21.0",
     "typescript": "^4.7.2",
     "undici": "^5.4.0",
     "x-xss-protection": "^2.0.0",
@@ -179,7 +179,7 @@
   "dependencies": {
     "@fastify/ajv-compiler": "^3.1.0",
     "@fastify/error": "^3.0.0",
-    "@fastify/fast-json-stringify-compiler": "^3.0.0",
+    "@fastify/fast-json-stringify-compiler": "^3.0.1",
     "abstract-logging": "^2.0.1",
     "avvio": "^8.1.3",
     "find-my-way": "^6.3.0",

package/test/404s.test.js

@@ -1320,7 +1320,7 @@ test('preHandler option for setNotFoundHandler', t => {
 
   // https://github.com/fastify/fastify/issues/2229
   t.test('preHandler hook in setNotFoundHandler should be called when callNotFound', { timeout: 40000 }, t => {
-    t.plan(2)
+    t.plan(3)
     const fastify = Fastify()
 
     fastify.setNotFoundHandler({
@@ -1333,7 +1333,7 @@ test('preHandler option for setNotFoundHandler', t => {
     })
 
     fastify.post('/', function (req, reply) {
-      reply.callNotFound()
+      t.equal(reply.callNotFound(), reply)
     })
 
     fastify.inject({

package/test/build/error-serializer.test.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const fs = require('fs')
+const path = require('path')
+
+const { code } = require('../../build/build-error-serializer')
+
+function unifyLineBreak (str) {
+  return str.toString().replace(/\r\n/g, '\n')
+}
+
+test('check generated code syntax', async (t) => {
+  t.plan(1)
+
+  // standard is a esm, we import it like this
+  const { default: standard } = await import('standard')
+  const result = await standard.lintText(code)
+
+  // if there are any invalid syntax
+  // fatal count will be greater than 0
+  t.equal(result[0].fatalErrorCount, 0)
+})
+
+test('ensure the current error serializer is latest', async (t) => {
+  t.plan(1)
+
+  const current = await fs.promises.readFile(path.resolve('lib/error-serializer.js'))
+
+  // line break should not be a problem depends on system
+  t.equal(unifyLineBreak(current), unifyLineBreak(code))
+})

package/test/{internals → build}/version.test.js

@@ -4,7 +4,7 @@ const fs = require('fs')
 const path = require('path')
 const t = require('tap')
 const test = t.test
-const fastify = require('../..')()
+const fastify = require('../../fastify')()
 
 test('should be the same as package.json', t => {
   t.plan(1)

package/test/internals/reply.test.js

@@ -233,6 +233,10 @@ test('within an instance', t => {
     reply.redirect('/')
   })
 
+  fastify.get('/redirect-async', async function (req, reply) {
+    return reply.redirect('/')
+  })
+
   fastify.get('/redirect-code', function (req, reply) {
     reply.redirect(301, '/')
   })
@@ -412,6 +416,14 @@ test('within an instance', t => {
       })
     })
 
+    test('redirect with async function to `/` - 10', t => {
+      t.plan(1)
+
+      http.get('http://localhost:' + fastify.server.address().port + '/redirect-async', function (response) {
+        t.equal(response.statusCode, 302)
+      })
+    })
+
     t.end()
   })
 })

package/test/listen.test.js

@@ -196,14 +196,28 @@ if (os.platform() !== 'win32') {
     const fastify = Fastify()
     t.teardown(fastify.close.bind(fastify))
 
-    const sockFile = path.join(os.tmpdir(), `${(Math.random().toString(16) + '0000000').substr(2, 8)}-server.sock`)
+    const sockFile = path.join(os.tmpdir(), `${(Math.random().toString(16) + '0000000').slice(2, 10)}-server.sock`)
     try {
       fs.unlinkSync(sockFile)
     } catch (e) { }
 
     fastify.listen({ path: sockFile }, (err, address) => {
       t.error(err)
-      t.equal(sockFile, fastify.server.address())
+      t.strictSame(fastify.addresses(), [sockFile])
+      t.equal(address, sockFile)
+    })
+  })
+} else {
+  test('listen on socket', t => {
+    t.plan(3)
+    const fastify = Fastify()
+    t.teardown(fastify.close.bind(fastify))
+
+    const sockFile = `\\\\.\\pipe\\${(Math.random().toString(16) + '0000000').slice(2, 10)}-server-sock`
+
+    fastify.listen({ path: sockFile }, (err, address) => {
+      t.error(err)
+      t.strictSame(fastify.addresses(), [sockFile])
       t.equal(address, sockFile)
     })
   })

package/test/reply-error.test.js

@@ -520,7 +520,13 @@ const invalidErrorCodes = [
   undefined,
   null,
   'error_code',
-  700 // out of the 100-600 range
+
+  // out of the 100-599 range:
+  0,
+  1,
+  99,
+  600,
+  700
 ]
 invalidErrorCodes.forEach((invalidCode) => {
   test(`should throw error if error code is ${invalidCode}`, t => {

package/test/stream.test.js

@@ -741,3 +741,76 @@ test('reply.send handles aborted requests', t => {
     }, 1)
   })
 })
+
+test('request terminated should not crash fastify', t => {
+  t.plan(10)
+
+  const spyLogger = {
+    level: 'error',
+    fatal: () => { },
+    error: () => {
+      t.fail('should not log an error')
+    },
+    warn: () => { },
+    info: () => { },
+    debug: () => { },
+    trace: () => { },
+    child: () => { return spyLogger }
+  }
+  const fastify = Fastify({
+    logger: spyLogger
+  })
+
+  fastify.get('/', async (req, reply) => {
+    const stream = new Readable()
+    stream._read = () => {}
+    reply.header('content-type', 'text/html; charset=utf-8')
+    reply.header('transfer-encoding', 'chunked')
+    stream.push('<h1>HTML</h1>')
+
+    reply.send(stream)
+
+    await new Promise((resolve) => { setTimeout(resolve, 100).unref() })
+
+    stream.push('<h1>should disply on second stream</h1>')
+    stream.push(null)
+    return reply
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+    t.teardown(() => { fastify.close() })
+
+    const port = fastify.server.address().port
+    const http = require('http')
+    const req = http.get(`http://localhost:${port}`, function (res) {
+      const { statusCode, headers } = res
+      t.equal(statusCode, 200)
+      t.equal(headers['content-type'], 'text/html; charset=utf-8')
+      t.equal(headers['transfer-encoding'], 'chunked')
+      res.on('data', function (chunk) {
+        t.equal(chunk.toString(), '<h1>HTML</h1>')
+      })
+
+      setTimeout(() => {
+        req.destroy()
+
+        // the server is not crash, we can connect it
+        http.get(`http://localhost:${port}`, function (res) {
+          const { statusCode, headers } = res
+          t.equal(statusCode, 200)
+          t.equal(headers['content-type'], 'text/html; charset=utf-8')
+          t.equal(headers['transfer-encoding'], 'chunked')
+          let payload = ''
+          res.on('data', function (chunk) {
+            payload += chunk.toString()
+          })
+          res.on('end', function () {
+            t.equal(payload, '<h1>HTML</h1><h1>should disply on second stream</h1>')
+            t.pass('should end properly')
+          })
+        })
+      }, 1)
+    })
+  })
+})

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

@@ -133,7 +133,7 @@ expectError(server.setErrorHandler(invalidErrorHandler))
 server.setSchemaController({
   bucket: (parentSchemas: unknown) => {
     return {
-      addSchema (schema: unknown) {
+      add (schema: unknown) {
         expectType<unknown>(schema)
         expectType<FastifyInstance>(server.addSchema({ type: 'null' }))
         return server.addSchema({ type: 'null' })

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

@@ -1,7 +1,21 @@
 import { expectAssignable, expectError, expectType } from 'tsd'
-import fastify, { FastifyInstance, FastifyPluginAsync } from '../../fastify'
+import { IncomingMessage, Server, ServerResponse } from 'http'
+import { Http2Server, Http2ServerRequest, Http2ServerResponse } from 'http2'
+import fastify, { FastifyInstance, FastifyError, FastifyLoggerInstance, FastifyPluginAsync, FastifyPluginCallback, FastifyPluginOptions, RawServerDefault } from '../../fastify'
 
-const testPluginOptsAsync: FastifyPluginAsync = async function (_instance, _opts) { }
+const testPluginCallback: FastifyPluginCallback = function (instance, opts, done) { }
+const testPluginAsync: FastifyPluginAsync = async function (instance, opts) { }
+
+const testPluginOpts: FastifyPluginCallback = function (instance, opts, done) { }
+const testPluginOptsAsync: FastifyPluginAsync = async function (instance, opts) { }
+
+const testPluginOptsWithType = (instance: FastifyInstance, opts: FastifyPluginOptions, done: (error?: FastifyError) => void) => { }
+const testPluginOptsWithTypeAsync = async (instance: FastifyInstance, opts: FastifyPluginOptions) => { }
+
+interface TestOptions extends FastifyPluginOptions {
+  option1: string;
+  option2: boolean;
+}
 
 // Type validation
 expectError(fastify().register(testPluginOptsAsync, { prefix: 1 }))
@@ -26,3 +40,64 @@ expectAssignable<FastifyInstance>(
     expectType<FastifyInstance>(instance)
   })
 )
+
+// With Http2
+const serverWithHttp2 = fastify({ http2: true })
+type ServerWithHttp2 = FastifyInstance<Http2Server, Http2ServerRequest, Http2ServerResponse>
+const testPluginWithHttp2: FastifyPluginCallback<TestOptions, Http2Server> = function (instance, opts, done) { }
+const testPluginWithHttp2Async: FastifyPluginAsync<TestOptions, Http2Server> = async function (instance, opts) { }
+const testPluginWithHttp2WithType = (instance: ServerWithHttp2, opts: FastifyPluginOptions, done: (error?: FastifyError) => void) => { }
+const testPluginWithHttp2WithTypeAsync = async (instance: ServerWithHttp2, opts: FastifyPluginOptions) => { }
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginCallback))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginAsync))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginOpts))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginOptsAsync))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginOptsWithType))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginOptsWithTypeAsync))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2Async))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2WithType))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2WithTypeAsync))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register((instance) => {
+  expectAssignable<FastifyInstance>(instance)
+}))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register((instance: ServerWithHttp2) => {
+  expectAssignable<ServerWithHttp2>(instance)
+}))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(async (instance) => {
+  expectAssignable<FastifyInstance>(instance)
+}))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(async (instance: ServerWithHttp2) => {
+  expectAssignable<ServerWithHttp2>(instance)
+}))
+
+// With Type Provider
+type TestTypeProvider = { input: 'test', output: 'test' }
+const serverWithTypeProvider = fastify().withTypeProvider<TestTypeProvider>()
+type ServerWithTypeProvider = FastifyInstance<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance, TestTypeProvider>
+const testPluginWithTypeProvider: FastifyPluginCallback<TestOptions, RawServerDefault, TestTypeProvider> = function (instance, opts, done) { }
+const testPluginWithTypeProviderAsync: FastifyPluginAsync<TestOptions, RawServerDefault, TestTypeProvider> = async function (instance, opts) { }
+const testPluginWithTypeProviderWithType = (instance: ServerWithTypeProvider, opts: FastifyPluginOptions, done: (error?: FastifyError) => void) => { }
+const testPluginWithTypeProviderWithTypeAsync = async (instance: ServerWithTypeProvider, opts: FastifyPluginOptions) => { }
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginCallback))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginAsync))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOpts))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOptsAsync))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOptsWithType))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOptsWithTypeAsync))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProvider))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProviderAsync))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProviderWithType))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProviderWithTypeAsync))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register((instance) => {
+  expectAssignable<FastifyInstance>(instance)
+}))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register((instance: ServerWithTypeProvider) => {
+  expectAssignable<ServerWithTypeProvider>(instance)
+}))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(async (instance) => {
+  expectAssignable<FastifyInstance>(instance)
+}))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(async (instance: ServerWithTypeProvider) => {
+  expectAssignable<ServerWithTypeProvider>(instance)
+}))

package/types/register.d.ts

@@ -1,6 +1,8 @@
 import { FastifyPluginOptions, FastifyPluginCallback, FastifyPluginAsync } from './plugin'
 import { LogLevel } from './logger'
 import { FastifyInstance } from './instance'
+import { RawServerBase } from './utils'
+import { FastifyTypeProvider, RawServerDefault } from '../fastify'
 
 export interface RegisterOptions {
   prefix?: string;
@@ -15,17 +17,17 @@ export type FastifyRegisterOptions<Options> = (RegisterOptions & Options) | ((in
  *
  * Function for adding a plugin to fastify. The options are inferred from the passed in FastifyPlugin parameter.
  */
-export interface FastifyRegister<T = void> {
-  <Options extends FastifyPluginOptions>(
-    plugin: FastifyPluginCallback<Options>,
+export interface FastifyRegister<T = void, RawServer extends RawServerBase = RawServerDefault, TypeProviderDefault extends FastifyTypeProvider = FastifyTypeProvider> {
+  <Options extends FastifyPluginOptions, Server extends RawServerBase = RawServer, TypeProvider extends FastifyTypeProvider = TypeProviderDefault>(
+    plugin: FastifyPluginCallback<Options, Server, TypeProvider>,
     opts?: FastifyRegisterOptions<Options>
   ): T;
-  <Options extends FastifyPluginOptions>(
-    plugin: FastifyPluginAsync<Options>,
+  <Options extends FastifyPluginOptions, Server extends RawServerBase = RawServer, TypeProvider extends FastifyTypeProvider = TypeProviderDefault>(
+    plugin: FastifyPluginAsync<Options, Server, TypeProvider>,
     opts?: FastifyRegisterOptions<Options>
   ): T;
-  <Options extends FastifyPluginOptions>(
-    plugin: FastifyPluginCallback<Options> | FastifyPluginAsync<Options> | Promise<{ default: FastifyPluginCallback<Options> }> | Promise<{ default: FastifyPluginAsync<Options> }>,
+  <Options extends FastifyPluginOptions, Server extends RawServerBase = RawServer, TypeProvider extends FastifyTypeProvider = TypeProviderDefault>(
+    plugin: FastifyPluginCallback<Options, Server, TypeProvider> | FastifyPluginAsync<Options, Server, TypeProvider> | Promise<{ default: FastifyPluginCallback<Options, Server, TypeProvider> }> | Promise<{ default: FastifyPluginAsync<Options, Server, TypeProvider> }>,
     opts?: FastifyRegisterOptions<Options>
   ): T;
 }

package/types/schema.d.ts

@@ -41,7 +41,7 @@ export type FastifySerializerCompiler<T> = (routeSchema: FastifyRouteSchemaDef<T
 
 export interface FastifySchemaControllerOptions{
   bucket?: (parentSchemas?: unknown) => {
-    addSchema(schema: unknown): FastifyInstance;
+    add(schema: unknown): FastifyInstance;
     getSchema(schemaId: string): unknown;
     getSchemas(): Record<string, unknown>;
   };