fastify 4.2.0 → 4.4.0

package/docs/Reference/Request.md

@@ -35,6 +35,19 @@ Request is a core Fastify object containing the following fields:
 - `connection` - Deprecated, use `socket` instead. The underlying connection of
   the incoming request.
 - `socket` - the underlying connection of the incoming request
+- [.getValidationFunction(schema | httpPart)](#getvalidationfunction) - 
+  Returns a validation function for the specified schema or http part,
+  if any of either are set or cached.
+- [.compileValidationSchema(schema, [httpPart])](#compilevalidationschema) -
+  Compiles the specified schema and returns a validation function
+  using the default (or customized) `ValidationCompiler`.
+  The optional `httpPart` is forwarded to the `ValidationCompiler`
+  if provided, defaults to `null`.
+- [.validateInput(data, schema | httpPart, [httpPart])](#validate) -
+  Validates the specified input by using the specified
+  schema and returns the serialized payload. If the optional
+  `httpPart` is provided, the function will use the serializer
+  function given for that HTTP Status Code. Defaults to `null`.
 - `context` - A Fastify internal object. You should not use it directly or
   modify it. It is useful to access one special key:
   - `context.config` - The route [`config`](./Routes.md#routes-config) object.
@@ -77,3 +90,161 @@ fastify.post('/:params', options, function (request, reply) {
   request.log.info('some info')
 })
 ```
+### .getValidationFunction(schema | httpPart)
+<a id="getvalidationfunction"></a>
+
+By calling this function using a provided `schema` or `httpPart`, 
+it will return a `validation` function that can be used to
+validate diverse inputs. It returns `undefined` if no
+serialization function was found using either of the provided inputs.
+
+```js
+const validate = request
+                  .getValidationFunction({
+                    type: 'object', 
+                    properties: { 
+                      foo: { 
+                        type: 'string' 
+                      } 
+                    } 
+                  })
+validate({ foo: 'bar' }) // true
+
+// or
+
+const validate = request
+                  .getValidationFunction('body')
+validate({ foo: 0.5 }) // false
+```
+
+See [.compilaValidationSchema(schema, [httpStatus])](#compilevalidationschema)
+for more information on how to compile validation function.
+
+### .compileValidationSchema(schema, [httpPart])
+<a id="compilevalidationschema"></a>
+
+This function will compile a validation schema and
+return a function that can be used to validate data.
+The function returned (a.k.a. _validation function_) is compiled
+by using the provided [`SchemaControler#ValidationCompiler`](./Server.md#schema-controller).
+A `WeakMap` is used to cached this, reducing compilation calls.
+
+The optional parameter `httpPart`, if provided, is forwarded directly
+the `ValidationCompiler`, so it can be used to compile the validation
+function if a custom `ValidationCompiler` is provided for the route.
+
+
+```js
+const validate = request
+                  .compileValidationSchema({
+                    type: 'object', 
+                    properties: { 
+                      foo: { 
+                        type: 'string' 
+                      } 
+                    } 
+                  })
+console.log(validate({ foo: 'bar' })) // true
+
+// or
+
+const validate = request
+                  .compileValidationSchema({
+                    type: 'object', 
+                    properties: { 
+                      foo: { 
+                        type: 'string' 
+                      } 
+                    } 
+                  }, 200)
+console.log(validate({ hello: 'world' })) // false
+```
+
+Note that you should be careful when using this function, as it will cache
+the compiled validation functions based on the schema provided. If the
+schemas provided are mutated or changed, the validation functions will not
+detect that the schema has been altered and for instance it will reuse the
+previously compiled validation function, as the cache is based on
+the reference of the schema (Object) previously provided.
+
+If there is a need to change the properties of a schema, always opt to create
+a totally new schema (object), otherwise the implementation will not benefit from
+the cache mechanism.
+
+Using the following schema as an example:
+```js
+const schema1 = {
+  type: 'object',
+  properties: {
+    foo: {
+      type: 'string'
+    }
+  }
+}
+```
+
+*Not*
+```js 
+const validate = request.compileValidationSchema(schema1)
+
+// Later on...
+schema1.properties.foo.type. = 'integer'
+const newValidate = request.compileValidationSchema(schema1)
+
+console.log(newValidate === validate) // true
+```
+
+*Instead*
+```js
+const validate = request.compileValidationSchema(schema1)
+
+// Later on...
+const newSchema = Object.assign({}, schema1)
+newSchema.properties.foo.type = 'integer'
+
+const newValidate = request.compileValidationSchema(newSchema)
+
+console.log(newValidate === validate) // false
+```
+
+### .validateInput(data, [schema | httpStatus], [httpStatus])
+<a id="validate"></a>
+
+This function will validate the input based on the provided schema,
+or HTTP part passed. If both are provided, the `httpPart` parameter
+will take precedence.
+
+If there is not a validation function for a given `schema`, a new validation
+function will be compiled, forwarding the `httpPart` if provided.
+
+```js
+request
+  .validateInput({ foo: 'bar'}, {  
+    type: 'object', 
+    properties: { 
+      foo: { 
+        type: 'string' 
+      } 
+    } 
+  }) // true
+
+// or
+
+request
+  .validateInput({ foo: 'bar'}, {
+    type: 'object', 
+    properties: { 
+      foo: { 
+        type: 'string' 
+      } 
+    } 
+  }, 'body') // true
+
+// or
+
+request
+  .validateInput({ hello: 'world'}, 'query') // false
+```
+
+See [.compileValidationSchema(schema, [httpStatus])](#compileValidationSchema)
+for more information on how to compile validation schemas.

package/docs/Reference/Routes.md

@@ -32,8 +32,10 @@ fastify.route(options)
 ### Routes options
 <a id="options"></a>
 
-*`method`: currently it supports `'DELETE'`, `'GET'`, `'HEAD'`, `'PATCH'`,
-  `'POST'`, `'PUT'` and `'OPTIONS'`. It could also be an array of methods.
+* `method`: currently it supports `'DELETE'`, `'GET'`, `'HEAD'`, `'PATCH'`,
+  `'POST'`, `'PUT'`, `'OPTIONS'`, `'SEARCH'`, `'TRACE'`, `'PROPFIND'`,
+  `'PROPPATCH'`, `'MKCOL'`, `'COPY'`, `'MOVE'`, `'LOCK'`  and `'UNLOCK'`.
+  It could also be an array of methods.
 * `url`: the path of the URL to match this route (alias: `path`).
 * `schema`: an object containing the schemas for the request and response. They
   need to be in [JSON Schema](https://json-schema.org/) format, check

package/docs/Reference/Server.md

@@ -890,7 +890,7 @@ fastify.ready().then(() => {
 Starts the server and internally waits for the `.ready()` event. The signature
 is `.listen([options][, callback])`. Both the `options` object and the
 `callback` parameters follow the [Node.js
-core][https://nodejs.org/api/net.html#serverlistenoptions-callback] parameter
+core](https://nodejs.org/api/net.html#serverlistenoptions-callback) parameter
 definitions.
 
 By default, the server will listen on the address(es) resolved by `localhost`
@@ -1402,6 +1402,9 @@ handlers. *async-await* is supported as well.
 *Note: If the error `statusCode` is less than 400, Fastify will automatically
 set it at 500 before calling the error handler.*
 
+*Also note* that `setErrorHandler` will ***not*** catch any error inside
+an `onResponse` hook because the response has already been sent to the client.
+
 ```js
 fastify.setErrorHandler(function (error, request, reply) {
   // Log error

package/docs/Reference/Type-Providers.md

@@ -70,14 +70,7 @@ import { Type } from '@sinclair/typebox'
 
 import fastify from 'fastify'
 
-const server = fastify({
-    ajv: {
-        customOptions: {
-            strict: 'log',
-            keywords: ['kind', 'modifier'],
-        },
-    },
-}).withTypeProvider<TypeBoxTypeProvider>()
+const server = fastify().withTypeProvider<TypeBoxTypeProvider>()
 
 server.get('/route', {
     schema: {
@@ -94,13 +87,6 @@ server.get('/route', {
 })
 ```
 
-TypeBox uses the properties `kind` and `modifier` internally. These properties
-are not strictly valid JSON schema which will cause `AJV@7` and newer versions
-to throw an invalid schema error. To remove the error it's either necessary to
-omit the properties by using
-[`Type.Strict()`](https://github.com/sinclairzx81/typebox#strict) or use the AJV
-options for adding custom keywords.
-
 See also the [TypeBox
 documentation](https://github.com/sinclairzx81/typebox#validation) on how to set
 up AJV to work with TypeBox.

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
@@ -403,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.
@@ -661,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.
@@ -1378,7 +1402,7 @@ 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
 

package/fastify.d.ts

@@ -194,7 +194,7 @@ export type { Chain as LightMyRequestChain, InjectOptions, Response as LightMyRe
 export { FastifyRequest, RequestGenericInterface } from './types/request'
 export { FastifyReply } from './types/reply'
 export { FastifyPluginCallback, FastifyPluginAsync, FastifyPluginOptions, FastifyPlugin } from './types/plugin'
-export { FastifyInstance, PrintRoutesOptions } from './types/instance'
+export { FastifyListenOptions, FastifyInstance, PrintRoutesOptions } from './types/instance'
 export { FastifyLoggerOptions, FastifyBaseLogger, FastifyLoggerInstance, FastifyLogFn, LogLevel } from './types/logger'
 export { FastifyContext, FastifyContextConfig } from './types/context'
 export { RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler } from './types/route'

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.2.0'
+const VERSION = '4.4.0'
 
 const Avvio = require('avvio')
 const http = require('http')
@@ -34,7 +34,7 @@ const {
 const { createServer, compileValidateHTTPVersion } = require('./lib/server')
 const Reply = require('./lib/reply')
 const Request = require('./lib/request')
-const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS']
+const { supportedMethods } = require('./lib/httpMethods')
 const decorator = require('./lib/decorate')
 const ContentTypeParser = require('./lib/contentTypeParser')
 const SchemaController = require('./lib/schema-controller')
@@ -621,7 +621,7 @@ function fastify (options) {
     // https://github.com/nodejs/node/blob/6ca23d7846cb47e84fd344543e394e50938540be/lib/_http_server.js#L666
 
     // If the socket is not writable, there is no reason to try to send data.
-    if (socket.writable && socket.bytesWritten === 0) {
+    if (socket.writable) {
       socket.write(`HTTP/1.1 400 Bad Request\r\nContent-Length: ${body.length}\r\nContent-Type: application/json\r\n\r\n${body}`)
     }
     socket.destroy(err)

package/lib/contentTypeParser.js

@@ -92,10 +92,18 @@ ContentTypeParser.prototype.existingParser = function (contentType) {
 }
 
 ContentTypeParser.prototype.getParser = function (contentType) {
+  if (contentType in this.customParsers) {
+    return this.customParsers[contentType]
+  }
+
+  if (this.cache.has(contentType)) {
+    return this.cache.get(contentType)
+  }
+
   // eslint-disable-next-line no-var
   for (var i = 0; i !== this.parserList.length; ++i) {
     const parserName = this.parserList[i]
-    if (contentType.indexOf(parserName) > -1) {
+    if (contentType.indexOf(parserName) !== -1) {
       const parser = this.customParsers[parserName]
       this.cache.set(contentType, parser)
       return parser
@@ -137,7 +145,7 @@ ContentTypeParser.prototype.remove = function (contentType) {
 }
 
 ContentTypeParser.prototype.run = function (contentType, handler, request, reply) {
-  const parser = this.cache.get(contentType) || this.getParser(contentType)
+  const parser = this.getParser(contentType)
   const resource = new AsyncResource('content-type-parser:run', request)
 
   if (parser === undefined) {

package/lib/context.js

@@ -10,7 +10,9 @@ const {
   kBodyLimit,
   kLogLevel,
   kContentTypeParser,
-  kRouteByFastify
+  kRouteByFastify,
+  kRequestValidateWeakMap,
+  kReplySerializeWeakMap
 } = require('./symbols.js')
 
 // Objects that holds the context of every request
@@ -24,6 +26,8 @@ function Context ({
   logLevel,
   logSerializers,
   attachValidation,
+  validatorCompiler,
+  serializerCompiler,
   replySerializer,
   schemaErrorFormatter,
   server,
@@ -54,6 +58,11 @@ function Context ({
   this.schemaErrorFormatter = schemaErrorFormatter || server[kSchemaErrorFormatter] || defaultSchemaErrorFormatter
   this[kRouteByFastify] = isFastify
 
+  this[kRequestValidateWeakMap] = null
+  this[kReplySerializeWeakMap] = null
+  this.validatorCompiler = validatorCompiler || null
+  this.serializerCompiler = serializerCompiler || null
+
   this.server = server
 }
 

package/lib/error-serializer.js

@@ -74,24 +74,24 @@ class Serializer {
     return bool === null ? 'null' : this.asBoolean(bool)
   }
 
-  asDatetime (date) {
-    const quotes = '"'
+  asDateTime (date) {
+    if (date === null) return '""'
     if (date instanceof Date) {
-      return quotes + date.toISOString() + quotes
+      return '"' + date.toISOString() + '"'
     }
-    return this.asString(date)
+    throw new Error(`The value "${date}" cannot be converted to a date-time.`)
   }
 
-  asDatetimeNullable (date) {
-    return date === null ? 'null' : this.asDatetime(date)
+  asDateTimeNullable (date) {
+    return date === null ? 'null' : this.asDateTime(date)
   }
 
   asDate (date) {
-    const quotes = '"'
+    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)
+    throw new Error(`The value "${date}" cannot be converted to a date.`)
   }
 
   asDateNullable (date) {
@@ -99,11 +99,11 @@ class Serializer {
   }
 
   asTime (date) {
-    const quotes = '"'
+    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)
+    throw new Error(`The value "${date}" cannot be converted to a time.`)
   }
 
   asTimeNullable (date) {

package/lib/errors.js

@@ -160,6 +160,14 @@ const codes = {
     'FST_ERR_BAD_TRAILER_VALUE',
     "Called reply.trailer('%s', fn) with an invalid type: %s. Expected a function."
   ),
+  FST_ERR_MISSING_SERIALIZATION_FN: createError(
+    'FST_ERR_MISSING_SERIALIZATION_FN',
+    'Missing serialization function. Key "%s"'
+  ),
+  FST_ERR_REQ_INVALID_VALIDATION_INVOCATION: createError(
+    'FST_ERR_REQ_INVALID_VALIDATION_INVOCATION',
+    'Invalid validation invocation. Missing validation function for HTTP part "%s" nor schema provided.'
+  ),
 
   /**
    * schemas

package/lib/handleRequest.js

@@ -18,14 +18,14 @@ function handleRequest (err, request, reply) {
   const method = request.raw.method
   const headers = request.headers
 
-  if (method === 'GET' || method === 'HEAD') {
+  if (method === 'GET' || method === 'HEAD' || method === 'SEARCH') {
     handler(request, reply)
     return
   }
 
   const contentType = headers['content-type']
 
-  if (method === 'POST' || method === 'PUT' || method === 'PATCH') {
+  if (method === 'POST' || method === 'PUT' || method === 'PATCH' || method === 'TRACE') {
     if (contentType === undefined) {
       if (
         headers['transfer-encoding'] === undefined &&

package/lib/httpMethods.js

@@ -0,0 +1,22 @@
+'use strict'
+
+module.exports = {
+  supportedMethods: [
+    'DELETE',
+    'GET',
+    'HEAD',
+    'PATCH',
+    'POST',
+    'PUT',
+    'OPTIONS',
+    'PROPFIND',
+    'PROPPATCH',
+    'MKCOL',
+    'COPY',
+    'MOVE',
+    'LOCK',
+    'UNLOCK',
+    'TRACE',
+    'SEARCH'
+  ]
+}