fastify 4.2.1 → 4.3.0

package/docs/Guides/Ecosystem.md

@@ -169,6 +169,8 @@ section.
 - [`cls-rtracer`](https://github.com/puzpuzpuz/cls-rtracer) Fastify middleware
   for CLS-based request ID generation. An out-of-the-box solution for adding
   request IDs into your logs.
+- [`electron-server`](https://github.com/anonrig/electron-server) A plugin for 
+  using Fastify without the need of consuming a port on Electron apps.
 - [`fast-water`](https://github.com/tswayne/fast-water) A Fastify plugin for
   waterline. Decorates Fastify with waterline models.
 - [`fastify-405`](https://github.com/Eomm/fastify-405) Fastify plugin that adds

package/docs/Reference/HTTP2.md

@@ -2,9 +2,7 @@
 
 ## HTTP2
 
-_Fastify_ offers **experimental support** for HTTP2 starting from Node 8 LTS,
-which includes HTTP2 without a flag; HTTP2 is supported over either HTTPS or
-plaintext.
+_Fastify_ supports HTTP2 over either HTTPS (h2) or plaintext (h2c).
 
 Currently, none of the HTTP2-specific APIs are available through _Fastify_, but
 Node's `req` and `res` can be accessed through our `Request` and `Reply`

package/docs/Reference/Reply.md

@@ -20,6 +20,9 @@
   - [.callNotFound()](#callnotfound)
   - [.getResponseTime()](#getresponsetime)
   - [.type(contentType)](#typecontenttype)
+  - [.getSerializationFunction(schema | httpStatus)](#getserializationfunction)
+  - [.compileSerializationSchema(schema, httpStatus)](#compileserializationschema)
+  - [.serializeInput(data, [schema | httpStatus], [httpStatus])](#serializeinput)
   - [.serializer(func)](#serializerfunc)
   - [.raw](#raw)
   - [.sent](#sent)
@@ -60,6 +63,16 @@ object that exposes the following functions and properties:
 - `.serialize(payload)` - Serializes the specified payload using the default
   JSON serializer or using the custom serializer (if one is set) and returns the
   serialized payload.
+- `.getSerializationFunction(schema | httpStatus)` - Returns the serialization
+  function for the specified schema or http status, if any of either are set.
+- `.compileSerializationSchema(schema, httpStatus)` - Compiles the specified
+  schema and returns a serialization function using the default (or customized)
+  `SerializerCompiler`. The optional `httpStatus` is forwarded to the
+  `SerializerCompiler` if provided, default to `undefined`.
+- `.serializeInput(data, schema, [,httpStatus])` - Serializes the specified data
+  using the specified schema and returns the serialized payload.
+  If the optional `httpStatus` is provided, the function will use the serializer
+  function given for that HTTP Status Code. Default to `undefined`.
 - `.serializer(function)` - Sets a custom serializer for the payload.
 - `.send(payload)` - Sends the payload to the user, could be a plain text, a
   buffer, JSON, stream, or an Error object.
@@ -326,6 +339,169 @@ reply.type('text/html')
 If the `Content-Type` has a JSON subtype, and the charset parameter is not set,
 `utf-8` will be used as the charset by default.
 
+### .getSerializationFunction(schema | httpStatus)
+<a id="getserializationfunction"></a>
+
+By calling this function using a provided `schema` or `httpStatus`, 
+it will return a `serialzation` function that can be used to
+serialize diverse inputs. It returns `undefined` if no
+serialization function was found using either of the provided inputs.
+
+This heavily depends of the `schema#responses` attached to the route, or
+the serialization functions compiled by using `compileSerializationSchema`.
+
+```js
+const serialize = reply
+                  .getSerializationFunction({
+                    type: 'object', 
+                    properties: { 
+                      foo: { 
+                        type: 'string' 
+                      } 
+                    } 
+                  })
+serialize({ foo: 'bar' }) // '{"foo":"bar"}'
+
+// or
+
+const serialize = reply
+                  .getSerializationFunction(200)
+serialize({ foo: 'bar' }) // '{"foo":"bar"}'
+```
+
+See [.compileSerializationSchema(schema, [httpStatus])](#compileserializationschema)
+for more information on how to compile serialization schemas.
+
+### .compileSerializationSchema(schema, httpStatus)
+<a id="compileserializationschema"></a>
+
+This function will compile a serialization schema and
+return a function that can be used to serialize data.
+The function returned (a.k.a. _serialization function_) returned is compiled
+by using the provided `SerializerCompiler`. Also this is cached by using
+a `WeakMap` for reducing compilation calls.
+
+The optional paramater `httpStatus`, if provided, is forwarded directly
+the `SerializerCompiler`, so it can be used to compile the serialization
+function if a custom `SerializerCompiler` is used.
+
+This heavily depends of the `schema#responses` attached to the route, or
+the serialization functions compiled by using `compileSerializationSchema`.
+
+```js
+const serialize = reply
+                  .compileSerializationSchema({
+                    type: 'object', 
+                    properties: { 
+                      foo: { 
+                        type: 'string' 
+                      } 
+                    } 
+                  })
+serialize({ foo: 'bar' }) // '{"foo":"bar"}'
+
+// or
+
+const serialize = reply
+                  .compileSerializationSchema({
+                    type: 'object', 
+                    properties: { 
+                      foo: { 
+                        type: 'string' 
+                      } 
+                    } 
+                  }, 200)
+serialize({ foo: 'bar' }) // '{"foo":"bar"}'
+```
+
+Note that you should be careful when using this function, as it will cache
+the compiled serialization functions based on the schema provided. If the
+schemas provided is mutated or changed, the serialization functions will not
+detect that the schema has been altered and for instance it will reuse the
+previously compiled serialization function based on the reference of the schema
+previously provided.
+
+If there's a need to change the properties of a schema, always opt to create
+a totally new object, otherwise the implementation won't benefit from the cache
+mechanism.
+
+:Using the following schema as example:
+```js
+const schema1 = {
+  type: 'object',
+  properties: {
+    foo: {
+      type: 'string'
+    }
+  }
+}
+```
+
+*Not*
+```js 
+const serialize = reply.compileSerializationSchema(schema1)
+
+// Later on...
+schema1.properties.foo.type. = 'integer'
+const newSerialize = reply.compileSerializationSchema(schema1)
+
+console.log(newSerialize === serialize) // true
+```
+
+*Instead*
+```js
+const serialize = reply.compileSerializationSchema(schema1)
+
+// Later on...
+const newSchema = Object.assign({}, schema1)
+newSchema.properties.foo.type = 'integer'
+
+const newSerialize = reply.compileSerializationSchema(newSchema)
+
+console.log(newSerialize === serialize) // false
+```
+
+### .serializeInput(data, [schema | httpStatus], [httpStatus])
+<a id="serializeinput"></a>
+
+This function will serialize the input data based on the provided schema,
+or http status code. If both provided, the `httpStatus` will take presedence.
+
+If there is not a serialization function for a given `schema`, a new serialization
+function will be compiled forwarding the `httpStatus` if provided.
+
+```js
+reply
+  .serializeInput({ foo: 'bar'}, {  
+    type: 'object', 
+    properties: { 
+      foo: { 
+        type: 'string' 
+      } 
+    } 
+  }) // '{"foo":"bar"}'
+
+// or
+
+reply
+  .serializeInput({ foo: 'bar'}, {
+    type: 'object', 
+    properties: { 
+      foo: { 
+        type: 'string' 
+      } 
+    } 
+  }, 200) // '{"foo":"bar"}'
+
+// or
+
+reply
+  .serializeInput({ foo: 'bar'}, 200) // '{"foo":"bar"}'
+```
+
+See [.compileSerializationSchema(schema, [httpStatus])](#compileserializationschema)
+for more information on how to compile serialization schemas.
+
 ### .serializer(func)
 <a id="serializer"></a>
 

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/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.1'
+const VERSION = '4.3.0'
 
 const Avvio = require('avvio')
 const http = require('http')
@@ -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/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/reply.js

@@ -16,7 +16,11 @@ const {
   kReplyHasStatusCode,
   kReplyIsRunningOnErrorHook,
   kReplyNextErrorHandler,
-  kDisableRequestLogging
+  kDisableRequestLogging,
+  kSchemaResponse,
+  kReplySerializeWeakMap,
+  kSchemaController,
+  kOptions
 } = require('./symbols.js')
 const { hookRunner, hookIterator, onSendHookRunner } = require('./hooks')
 
@@ -38,7 +42,8 @@ const {
   FST_ERR_SEND_INSIDE_ONERR,
   FST_ERR_BAD_STATUS_CODE,
   FST_ERR_BAD_TRAILER_NAME,
-  FST_ERR_BAD_TRAILER_VALUE
+  FST_ERR_BAD_TRAILER_VALUE,
+  FST_ERR_MISSING_SERIALIZATION_FN
 } = require('./errors')
 const warning = require('./warnings')
 
@@ -299,6 +304,79 @@ Reply.prototype.code = function (code) {
 
 Reply.prototype.status = Reply.prototype.code
 
+Reply.prototype.getSerializationFunction = function (schemaOrStatus) {
+  let serialize
+
+  if (typeof schemaOrStatus === 'string' || typeof schemaOrStatus === 'number') {
+    serialize = this.context[kSchemaResponse]?.[schemaOrStatus]
+  } else if (typeof schemaOrStatus === 'object') {
+    serialize = this.context[kReplySerializeWeakMap]?.get(schemaOrStatus)
+  }
+
+  return serialize
+}
+
+Reply.prototype.compileSerializationSchema = function (schema, httpStatus = null) {
+  const { request } = this
+  const { method, url } = request
+
+  // Check if serialize function already compiled
+  if (this.context[kReplySerializeWeakMap]?.has(schema)) {
+    return this.context[kReplySerializeWeakMap].get(schema)
+  }
+
+  const serializerCompiler = this.context.serializerCompiler ||
+   this.server[kSchemaController].serializerCompiler ||
+  (
+    // We compile the schemas if no custom serializerCompiler is provided
+    // nor set
+    this.server[kSchemaController].setupSerializer(this.server[kOptions]) ||
+    this.server[kSchemaController].serializerCompiler
+  )
+
+  const serializeFn = serializerCompiler({
+    schema,
+    method,
+    url,
+    httpStatus
+  })
+
+  // We create a WeakMap to compile the schema only once
+  // Its done leazily 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
+  if (this.context[kReplySerializeWeakMap] == null) {
+    this.context[kReplySerializeWeakMap] = new WeakMap()
+  }
+
+  this.context[kReplySerializeWeakMap].set(schema, serializeFn)
+
+  return serializeFn
+}
+
+Reply.prototype.serializeInput = function (input, schema, httpStatus) {
+  let serialize
+  httpStatus = typeof schema === 'string' || typeof schema === 'number'
+    ? schema
+    : httpStatus
+
+  if (httpStatus != null) {
+    serialize = this.context[kSchemaResponse]?.[httpStatus]
+
+    if (serialize == null) throw new FST_ERR_MISSING_SERIALIZATION_FN(httpStatus)
+  } else {
+    // Check if serialize function already compiled
+    if (this.context[kReplySerializeWeakMap]?.has(schema)) {
+      serialize = this.context[kReplySerializeWeakMap].get(schema)
+    } else {
+      serialize = this.compileSerializationSchema(schema, httpStatus)
+    }
+  }
+
+  return serialize(input)
+}
+
 Reply.prototype.serialize = function (payload) {
   if (this[kReplySerializer] !== null) {
     return this[kReplySerializer](payload)