fastify 4.0.3 → 4.2.1

package/docs/Reference/TypeScript.md

@@ -143,7 +143,7 @@ route-level `request` object.
    curl localhost:8080/auth?username=admin&password=Password123!
    ```
    And it should return back `logged in!`
-6. But wait theres more! The generic interfaces are also available inside route
+6. But wait there's more! The generic interfaces are also available inside route
    level hook methods. Modify the previous route by adding a `preValidation`
    hook:
    ```typescript
@@ -199,17 +199,18 @@ Below is how to setup schema validation using vanilla `typebox` and
 #### typebox
 
 A useful library for building types and a schema at once is
-[typebox](https://www.npmjs.com/package/@sinclair/typebox). With typebox you
-define your schema within your code and use them directly as types or schemas as
-you need them.
+[typebox](https://www.npmjs.com/package/@sinclair/typebox) along with 
+[fastify-type-provider-typebox](https://github.com/fastify/fastify-type-provider-typebox).
+With typebox you define your schema within your code and use them
+directly as types or schemas as you need them.
 
 When you want to use it for validation of some payload in a fastify route you
 can do it as follows:
 
-1. Install `typebox` in your project.
+1. Install `typebox` and `fastify-type-provider-typebox` in your project.
 
     ```bash
-    npm i @sinclair/typebox
+    npm i @sinclair/typebox @fastify/type-provider-typebox
     ```
 
 2. Define the schema you need with `Type` and create the respective type  with
@@ -218,40 +219,52 @@ can do it as follows:
     ```typescript
     import { Static, Type } from '@sinclair/typebox'
 
-    const User = Type.Object({
+    export const User = Type.Object({
       name: Type.String(),
-      mail: Type.Optional(Type.String({ format: "email" })),
-    });
-    type UserType = Static<typeof User>;
+      mail: Type.Optional(Type.String({ format: 'email' })),
+    })
+
+    export type UserType = Static<typeof User>
     ```
 
 3. Use the defined type and schema during the definition of your route
 
     ```typescript
-    const app = fastify();
+    import Fastify from 'fastify'
+    import { TypeBoxTypeProvider } from '@fastify/type-provider-typebox'
+    // ...
+
+    const fastify = Fastify().withTypeProvider<TypeBoxTypeProvider>()
 
-    app.post<{ Body: UserType; Reply: UserType }>(
-      "/",
+    app.post<{ Body: UserType, Reply: UserType }>(
+      '/',
       {
         schema: {
           body: User,
           response: {
-            200: User,
+            200: User
           },
         },
       },
       (request, reply) => {
-        const { body: user } = request;
-        /* user has type
-        * const user: StaticProperties<{
-        *  name: TString;
-        *  mail: TOptional<TString>;
-        * }>
-        */
-        //...
-        reply.status(200).send(user);
+        // The `name` and `mail` types are automatically inferred
+        const { name, mail } = request.body;
+        reply.status(200).send({ name, mail });
+      }
+    )
+    ```
+
+     **Note** For Ajv version 7 and above is required to use the `ajvTypeBoxPlugin`:
+
+    ```typescript
+    import Fastify from 'fastify'
+    import { ajvTypeBoxPlugin, TypeBoxTypeProvider } from '@fastify/type-provider-typebox'
+
+    const fastify = Fastify({
+      ajv: {
+        plugins: [ajvTypeBoxPlugin]
       }
-    );
+    }).withTypeProvider<TypeBoxTypeProvider>()
     ```
 
 #### Schemas in JSON Files
@@ -390,7 +403,7 @@ definitions.
 #### json-schema-to-ts
 
 If you do not want to generate types from your schemas, but want to use them
-diretly from your code, you can use the package
+directly from your code, you can use the package
 [json-schema-to-ts](https://www.npmjs.com/package/json-schema-to-ts).
 
 You can install it as dev-dependency.
@@ -648,6 +661,30 @@ However, there are a couple of suggestions to help improve this experience:
   [npm-check](https://www.npmjs.com/package/npm-check) to verify plugin
   dependencies are being used somewhere in your project.
 
+Note that using `require` will not load the type definitions properly and may
+cause type errors.
+TypeScript can only identify the types that are directly imported into code,
+which means that you can use require inline with import on top. For example:
+
+```typescript
+import 'plugin' // here will trigger the type augmentation.
+
+fastify.register(require('plugin'))
+```
+
+```typescript
+import plugin from 'plugin' //  here will trigger the type augmentation.
+
+fastify.register(plugin)
+```
+
+Or even explicit config on tsconfig
+```jsonc
+{
+  "types": ["plugin"] // we force TypeScript to import the types
+}
+```
+
 ## Code Completion In Vanilla JavaScript
 
 Vanilla JavaScript can use the published types to provide code completion (e.g.
@@ -1359,17 +1396,17 @@ A method for checking the existence of a type parser of a certain content type
 
 ##### fastify.FastifyError
 
-[src](https://github.com/fastify/fastify/blob/main/types/error.d.ts#L17)
+[src](https://github.com/fastify/fastify/blob/main/fastify.d.ts#L179)
 
 FastifyError is a custom error object that includes status code and validation
 results.
 
 It extends the Node.js `Error` type, and adds two additional, optional
-properties: `statusCode: number` and `validation: ValiationResult[]`.
+properties: `statusCode: number` and `validation: ValidationResult[]`.
 
 ##### fastify.ValidationResult
 
-[src](https://github.com/fastify/fastify/blob/main/types/error.d.ts#L4)
+[src](https://github.com/fastify/fastify/blob/main/fastify.d.ts#L184)
 
 The route validation internally relies upon Ajv, which is a high-performance
 JSON schema validator.

package/docs/Reference/Validation-and-Serialization.md

@@ -484,6 +484,17 @@ fastify.post('/the/url', {
 }, handler)
 ```
 
+##### .statusCode property
+
+All validation errors will be added a `.statusCode` property set to `400`. This guarantees
+that the default error handler will set the status code of the response to `400`.
+
+```js
+fastify.setErrorHandler(function (error, request, reply) {
+  request.log.error(error, `This error has status code ${error.statusCode}`)
+  reply.status(error.statusCode).send(error)
+})
+```
 
 ##### Validation messages with other validation libraries
 

package/docs/index.md

@@ -16,7 +16,7 @@ Complete newcomers to Fastify should first read our [Getting
 Started](./Guides/Getting-Started.md) guide.
 
 Developers experienced with Fastify should consult the [reference
-documentation](./Reference/index.md) directly to find the topic they are seeking
+documentation](./Reference/Index.md) directly to find the topic they are seeking
 more information about.
 
 ## Additional Documentation

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>;
     };
@@ -183,10 +183,10 @@ declare module '@fastify/error' {
 
 export interface ValidationResult {
   keyword: string;
-  dataPath: string;
+  instancePath: string;
   schemaPath: string;
   params: Record<string, string | string[]>;
-  message: string;
+  message?: string;
 }
 
 /* Export all additional types */

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.0.3'
+const VERSION = '4.2.1'
 
 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/integration/server.js

@@ -0,0 +1,27 @@
+const Fastify = require('../fastify')
+
+const fastify = Fastify()
+
+fastify.listen({
+  host: '::',
+  port: 3000
+})
+
+fastify.get('/', async function (request, reply) {
+  reply.code(200).send({ data: 'home page' })
+})
+
+fastify.post('/post/:id', async function (request, reply) {
+  const { id } = request.params
+  reply.code(201).send({ data: `${id}` })
+})
+
+fastify.put('/put/:id', async function (request, reply) {
+  const { id } = request.params
+  reply.code(200).send({ data: `${id}` })
+})
+
+fastify.delete('/delete/:id', async function (request, reply) {
+  const { id } = request.params
+  reply.code(204).send({ data: `${id}` })
+})

package/integration/test.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/bash
+
+set -e
+
+NUMBER=$RANDOM
+curl -i -X GET -H 'Content-Type: application/json' localhost:3000/ > GET
+if [[ ! $(cat GET | head -1| cut -f2 -d" ") == "200" || ! $(cat GET | tail -1| cut -f4 -d"\"") == "home page" ]] ; then
+exit 1
+fi;
+curl -i -X POST -H 'Content-Type: application/json' localhost:3000/post/$NUMBER --data {} > POST
+if [[ ! $(cat POST | head -1| cut -f2 -d" ") == "201" || ! $(cat POST | tail -1| cut -f4 -d"\"") == $(echo $NUMBER) ]]; then
+exit 1
+fi;
+curl -i -X PUT -H 'Content-Type: application/json' localhost:3000/put/$NUMBER --data {} > PUT
+if [[ ! $(cat PUT | head -1| cut -f2 -d" ") == "200" || ! $(cat PUT | tail -1| cut -f4 -d"\"") == $(echo $NUMBER) ]]; then
+exit 1
+fi;
+curl -i -X DELETE -H 'Content-Type: application/json' localhost:3000/delete/$NUMBER --data {} > DELETE
+if [[ ! $(cat DELETE | head -1| cut -f2 -d" ") == "204" ]]; then
+exit 1
+fi;
+
+rm -f GET POST PUT DELETE

package/lib/context.js

@@ -9,7 +9,8 @@ const {
   kRequest,
   kBodyLimit,
   kLogLevel,
-  kContentTypeParser
+  kContentTypeParser,
+  kRouteByFastify
 } = require('./symbols.js')
 
 // Objects that holds the context of every request
@@ -25,7 +26,8 @@ function Context ({
   attachValidation,
   replySerializer,
   schemaErrorFormatter,
-  server
+  server,
+  isFastify
 }) {
   this.schema = schema
   this.handler = handler
@@ -50,6 +52,7 @@ function Context ({
   this.attachValidation = attachValidation
   this[kReplySerializerDefault] = replySerializer
   this.schemaErrorFormatter = schemaErrorFormatter || server[kSchemaErrorFormatter] || defaultSchemaErrorFormatter
+  this[kRouteByFastify] = isFastify
 
   this.server = server
 }

package/lib/error-serializer.js

@@ -39,7 +39,7 @@ class Serializer {
     } else {
       /* eslint no-undef: "off" */
       const integer = this.parseInteger(i)
-      if (Number.isNaN(integer)) {
+      if (Number.isNaN(integer) || !Number.isFinite(integer)) {
         throw new Error(`The value "${i}" cannot be converted to an integer.`)
       } else {
         return '' + integer
@@ -55,6 +55,8 @@ class Serializer {
     const num = Number(i)
     if (Number.isNaN(num)) {
       throw new Error(`The value "${i}" cannot be converted to a number.`)
+    } else if (!Number.isFinite(num)) {
+      return null
     } else {
       return '' + num
     }
@@ -72,44 +74,44 @@ class Serializer {
     return bool === null ? 'null' : this.asBoolean(bool)
   }
 
-  asDatetime (date, skipQuotes) {
-    const quotes = skipQuotes === true ? '' : '"'
+  asDateTime (date) {
+    if (date === null) return '""'
     if (date instanceof Date) {
-      return quotes + date.toISOString() + quotes
+      return '"' + date.toISOString() + '"'
     }
-    return this.asString(date, skipQuotes)
+    throw new Error(`The value "${date}" cannot be converted to a date-time.`)
   }
 
-  asDatetimeNullable (date, skipQuotes) {
-    return date === null ? 'null' : this.asDatetime(date, skipQuotes)
+  asDateTimeNullable (date) {
+    return date === null ? 'null' : this.asDateTime(date)
   }
 
-  asDate (date, skipQuotes) {
-    const quotes = skipQuotes === true ? '' : '"'
+  asDate (date) {
+    if (date === null) return '""'
     if (date instanceof Date) {
-      return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(0, 10) + quotes
+      return '"' + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(0, 10) + '"'
     }
-    return this.asString(date, skipQuotes)
+    throw new Error(`The value "${date}" cannot be converted to a date.`)
   }
 
-  asDateNullable (date, skipQuotes) {
-    return date === null ? 'null' : this.asDate(date, skipQuotes)
+  asDateNullable (date) {
+    return date === null ? 'null' : this.asDate(date)
   }
 
-  asTime (date, skipQuotes) {
-    const quotes = skipQuotes === true ? '' : '"'
+  asTime (date) {
+    if (date === null) return '""'
     if (date instanceof Date) {
-      return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(11, 19) + quotes
+      return '"' + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(11, 19) + '"'
     }
-    return this.asString(date, skipQuotes)
+    throw new Error(`The value "${date}" cannot be converted to a time.`)
   }
 
-  asTimeNullable (date, skipQuotes) {
-    return date === null ? 'null' : this.asTime(date, skipQuotes)
+  asTimeNullable (date) {
+    return date === null ? 'null' : this.asTime(date)
   }
 
-  asString (str, skipQuotes) {
-    const quotes = skipQuotes === true ? '' : '"'
+  asString (str) {
+    const quotes = '"'
     if (str instanceof Date) {
       return quotes + str.toISOString() + quotes
     } else if (str === null) {
@@ -119,11 +121,6 @@ class Serializer {
     } 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)
@@ -185,7 +182,7 @@ class Serializer {
     }
     
     function anonymous0 (input) {
-      // main
+      // #
   
       var obj = (input && typeof input.toJSON === 'function')
     ? input.toJSON()

package/lib/handleRequest.js

@@ -90,7 +90,7 @@ function preValidationCallback (err, request, reply) {
   const result = validateSchema(reply.context, request)
   if (result) {
     if (reply.context.attachValidation === false) {
-      reply.code(400).send(result)
+      reply.send(result)
       return
     }
 

package/lib/reply.js

@@ -203,10 +203,8 @@ Reply.prototype.getHeaders = function () {
 
 Reply.prototype.hasHeader = function (key) {
   key = key.toLowerCase()
-  if (this[kReplyHeaders][key] !== undefined) {
-    return true
-  }
-  return this.raw.hasHeader(key)
+
+  return this[kReplyHeaders][key] !== undefined || this.raw.hasHeader(key)
 }
 
 Reply.prototype.removeHeader = function (key) {
@@ -216,25 +214,24 @@ Reply.prototype.removeHeader = function (key) {
   return this
 }
 
-Reply.prototype.header = function (key, value) {
-  const _key = key.toLowerCase()
-
-  // default the value to ''
-  value = value === undefined ? '' : value
+Reply.prototype.header = function (key, value = '') {
+  key = key.toLowerCase()
 
-  if (this[kReplyHeaders][_key] && _key === 'set-cookie') {
+  if (this[kReplyHeaders][key] && key === 'set-cookie') {
     // https://tools.ietf.org/html/rfc7230#section-3.2.2
-    if (typeof this[kReplyHeaders][_key] === 'string') {
-      this[kReplyHeaders][_key] = [this[kReplyHeaders][_key]]
+    if (typeof this[kReplyHeaders][key] === 'string') {
+      this[kReplyHeaders][key] = [this[kReplyHeaders][key]]
     }
+
     if (Array.isArray(value)) {
-      Array.prototype.push.apply(this[kReplyHeaders][_key], value)
+      this[kReplyHeaders][key].push(...value)
     } else {
-      this[kReplyHeaders][_key].push(value)
+      this[kReplyHeaders][key].push(value)
     }
   } else {
-    this[kReplyHeaders][_key] = value
+    this[kReplyHeaders][key] = value
   }
+
   return this
 }
 
@@ -245,6 +242,7 @@ Reply.prototype.headers = function (headers) {
     const key = keys[i]
     this.header(key, headers[key])
   }
+
   return this
 }
 
@@ -279,8 +277,7 @@ Reply.prototype.trailer = function (key, fn) {
 }
 
 Reply.prototype.hasTrailer = function (key) {
-  if (this[kReplyTrailers] === null) return false
-  return this[kReplyTrailers][key.toLowerCase()] !== undefined
+  return this[kReplyTrailers]?.[key.toLowerCase()] !== undefined
 }
 
 Reply.prototype.removeTrailer = function (key) {
@@ -330,11 +327,12 @@ Reply.prototype.redirect = function (code, url) {
     code = this[kReplyHasStatusCode] ? this.raw.statusCode : 302
   }
 
-  this.header('location', url).code(code).send()
+  return this.header('location', url).code(code).send()
 }
 
 Reply.prototype.callNotFound = function () {
   notFound(this)
+  return this
 }
 
 Reply.prototype.getResponseTime = function () {
@@ -483,9 +481,12 @@ function onSendEnd (reply, payload) {
   }
 
   if (reply[kReplyTrailers] === null) {
-    if (!reply[kReplyHeaders]['content-length']) {
-      reply[kReplyHeaders]['content-length'] = '' + Buffer.byteLength(payload)
-    } else if (req.raw.method !== 'HEAD' && reply[kReplyHeaders]['content-length'] !== Buffer.byteLength(payload)) {
+    const contentLength = reply[kReplyHeaders]['content-length']
+    if (!contentLength ||
+        (req.raw.method !== 'HEAD' &&
+         parseInt(contentLength, 10) !== Buffer.byteLength(payload)
+        )
+    ) {
       reply[kReplyHeaders]['content-length'] = '' + Buffer.byteLength(payload)
     }
   }