fastify 3.20.2 → 3.21.3

package/docs/Validation-and-Serialization.md

@@ -14,7 +14,7 @@ Fastify uses a schema-based approach, and even if it is not mandatory we recomme
 
 ### Core concepts
 The validation and the serialization tasks are processed by two different, and customizable, actors:
-- [Ajv](https://www.npmjs.com/package/ajv) for the validation of a request
+- [Ajv v6](https://www.npmjs.com/package/ajv/v/6.12.6) for the validation of a request
 - [fast-json-stringify](https://www.npmjs.com/package/fast-json-stringify) for the serialization of a response's body
 
 These two separate entities share only the JSON schemas added to Fastify's instance through `.addSchema(schema)`.
@@ -120,7 +120,7 @@ fastify.register((instance, opts, done) => {
 
 
 ### Validation
-The route validation internally relies upon [Ajv](https://www.npmjs.com/package/ajv), which is a high-performance JSON Schema validator.
+The route validation internally relies upon [Ajv v6](https://www.npmjs.com/package/ajv/v/6.12.6) which is a high-performance JSON Schema validator.
 Validating the input is very easy: just add the fields that you need inside the route schema, and you are done!
 
 The supported validations are:
@@ -131,6 +131,8 @@ The supported validations are:
 
 All the validations can be a complete JSON Schema object (with a `type` property of `'object'` and a `'properties'` object containing parameters) or a simpler variation in which the `type` and `properties` attributes are forgone and the parameters are listed at the top level (see the example below).
 
+> ℹ If you need to use the lastest version of Ajv (v8) you should read how to do it in the [`schemaController`](Server.md#schema-controller) section. It is explained the easier way to avoid to implement a custom validator.
+
 Example:
 ```js
 const bodyJsonSchema = {
@@ -232,7 +234,7 @@ curl -X GET "http://localhost:3000/?ids=1
 {"statusCode":400,"error":"Bad Request","message":"querystring/hello should be array"}
 ```
 
-Using `coerceTypes` as 'array' should fix it:
+Using `coerceTypes` as 'array' will fix it:
 
 ```js
 const ajv = new Ajv({
@@ -253,12 +255,53 @@ curl -X GET "http://localhost:3000/?ids=1
 {"params":{"hello":["1"]}}
 ```
 
+You can also specify a custom schema validator for each parameter type (body, querystring, params, headers).
+
+For example, the following code disable type cohercion only for the `body` parameters, changing the ajv default options:
+
+```js
+const schemaCompilers = {
+  body: new Ajv({
+    removeAdditional: false,
+    coerceTypes: false,
+    allErrors: true
+  }),
+  params: new Ajv({
+    removeAdditional: false,
+    coerceTypes: true,
+    allErrors: true
+  }),
+  querystring: new Ajv({
+    removeAdditional: false,
+    coerceTypes: true,
+    allErrors: true
+  }),
+  headers: new Ajv({
+    removeAdditional: false,
+    coerceTypes: true,
+    allErrors: true
+  })
+}
+
+server.setValidatorCompiler(req => {
+    if (!req.httpPart) {
+      throw new Error('Missing httpPart')
+    }
+    const compiler = schemaCompilers[req.httpPart]
+    if (!compiler) {
+      throw new Error(`Missing compiler for ${req.httpPart}`)
+    }
+    return compiler.compile(req.schema)
+})
+```
+
 For further information see [here](https://ajv.js.org/coercion.html)
 
 <a name="ajv-plugins"></a>
 #### Ajv Plugins
 
-You can provide a list of plugins you want to use with Ajv:
+You can provide a list of plugins you want to use with the default `ajv` instance.  
+Note that the plugin must be **compatible with Ajv v6**.
 
 > Refer to [`ajv options`](Server.md#ajv) to check plugins format
 

package/fastify.js

@@ -399,6 +399,17 @@ function fastify (options) {
   // Delay configuring clientError handler so that it can access fastify state.
   server.on('clientError', options.clientErrorHandler.bind(fastify))
 
+  try {
+    const dc = require('diagnostics_channel')
+    const initChannel = dc.channel('fastify.initialization')
+    if (initChannel.hasSubscribers) {
+      initChannel.publish({ fastify })
+    }
+  } catch (e) {
+    // This only happens if `diagnostics_channel` isn't available, i.e. earlier
+    // versions of Node.js. In that event, we don't care, so ignore the error.
+  }
+
   return fastify
 
   function throwIfAlreadyStarted (msg) {

package/lib/contentTypeParser.js

@@ -67,9 +67,7 @@ ContentTypeParser.prototype.add = function (contentType, opts, parserFn) {
     this.customParsers[''] = parser
   } else {
     if (contentTypeIsString) {
-      if (contentType !== 'application/json' && contentType !== 'text/plain') {
-        this.parserList.unshift(contentType)
-      }
+      this.parserList.unshift(contentType)
     } else {
       this.parserRegExpList.unshift(contentType)
     }
@@ -83,10 +81,10 @@ ContentTypeParser.prototype.hasParser = function (contentType) {
 
 ContentTypeParser.prototype.existingParser = function (contentType) {
   if (contentType === 'application/json') {
-    return this.customParsers['application/json'].fn !== this[kDefaultJsonParse]
+    return this.customParsers['application/json'] && this.customParsers['application/json'].fn !== this[kDefaultJsonParse]
   }
   if (contentType === 'text/plain') {
-    return this.customParsers['text/plain'].fn !== defaultPlainTextParser
+    return this.customParsers['text/plain'] && this.customParsers['text/plain'].fn !== defaultPlainTextParser
   }
 
   return contentType in this.customParsers

package/lib/decorate.js

@@ -22,21 +22,35 @@ function decorate (instance, name, fn, dependencies) {
     throw new FST_ERR_DEC_ALREADY_PRESENT(name)
   }
 
-  if (dependencies) {
-    if (!Array.isArray(dependencies)) {
-      throw new FST_ERR_DEC_DEPENDENCY_INVALID_TYPE(name)
-    }
+  checkDependencies(instance, name, dependencies)
 
-    checkDependencies(instance, dependencies)
+  if (fn && (typeof fn.getter === 'function' || typeof fn.setter === 'function')) {
+    Object.defineProperty(instance, name, {
+      get: fn.getter,
+      set: fn.setter
+    })
+  } else {
+    instance[name] = fn
   }
+}
+
+function decorateConstructor (konstructor, name, fn, dependencies) {
+  const instance = konstructor.prototype
+  if (instance.hasOwnProperty(name) || konstructor.props.includes(name)) {
+    throw new FST_ERR_DEC_ALREADY_PRESENT(name)
+  }
+
+  checkDependencies(instance, name, dependencies)
 
   if (fn && (typeof fn.getter === 'function' || typeof fn.setter === 'function')) {
     Object.defineProperty(instance, name, {
       get: fn.getter,
       set: fn.setter
     })
-  } else {
+  } else if (fn) {
     instance[name] = fn
+  } else {
+    konstructor.props.push(name)
   }
 }
 
@@ -61,14 +75,24 @@ function checkExistence (instance, name) {
 }
 
 function checkRequestExistence (name) {
+  if (name && this[kRequest].props.includes(name)) return true
   return checkExistence(this[kRequest].prototype, name)
 }
 
 function checkReplyExistence (name) {
+  if (name && this[kReply].props.includes(name)) return true
   return checkExistence(this[kReply].prototype, name)
 }
 
-function checkDependencies (instance, deps) {
+function checkDependencies (instance, name, deps) {
+  if (deps === undefined || deps === null) {
+    return
+  }
+
+  if (!Array.isArray(deps)) {
+    throw new FST_ERR_DEC_DEPENDENCY_INVALID_TYPE(name)
+  }
+
   // eslint-disable-next-line no-var
   for (var i = 0; i !== deps.length; ++i) {
     if (!checkExistence(instance, deps[i])) {
@@ -80,14 +104,14 @@ function checkDependencies (instance, deps) {
 function decorateReply (name, fn, dependencies) {
   assertNotStarted(this, name)
   checkReferenceType(name, fn)
-  decorate(this[kReply].prototype, name, fn, dependencies)
+  decorateConstructor(this[kReply], name, fn, dependencies)
   return this
 }
 
 function decorateRequest (name, fn, dependencies) {
   assertNotStarted(this, name)
   checkReferenceType(name, fn)
-  decorate(this[kRequest].prototype, name, fn, dependencies)
+  decorateConstructor(this[kRequest], name, fn, dependencies)
   return this
 }
 

package/lib/reply.js

@@ -63,6 +63,7 @@ function Reply (res, request, log) {
   this[kReplyStartTime] = undefined
   this.log = log
 }
+Reply.props = []
 
 Object.defineProperties(Reply.prototype, {
   context: {
@@ -377,8 +378,8 @@ function preserializeHookEnd (err, request, reply, payload) {
 }
 
 function onSendHook (reply, payload) {
-  reply[kReplySent] = true
   if (reply.context.onSend !== null) {
+    reply[kReplySent] = true
     onSendHookRunner(
       reply.context.onSend,
       reply.request,
@@ -422,6 +423,8 @@ function onSendEnd (reply, payload) {
   }
 
   if (typeof payload.pipe === 'function') {
+    reply[kReplySent] = true
+
     sendStream(payload, res, reply)
     return
   }
@@ -573,12 +576,17 @@ function handleError (reply, error, cb) {
         message: { value: error.message || '' },
         statusCode: { value: statusCode }
       }))
+
+    if (serializerFn !== false && typeof payload !== 'string') {
+      throw new FST_ERR_REP_INVALID_PAYLOAD_TYPE(typeof payload)
+    }
   } catch (err) {
     // error is always FST_ERR_SCH_SERIALIZATION_BUILD because this is called from route/compileSchemasForSerialization
     reply.log.error({ err, statusCode: res.statusCode }, 'The serializer for the given status code failed')
     res.statusCode = 500
     payload = serializeError({
       error: statusCodes['500'],
+      code: err.code,
       message: err.message,
       statusCode: 500
     })
@@ -651,6 +659,8 @@ function onResponseCallback (err, request, reply) {
 }
 
 function buildReply (R) {
+  const props = [...R.props]
+
   function _Reply (res, request, log) {
     this.raw = res
     this[kReplyIsError] = false
@@ -662,8 +672,14 @@ function buildReply (R) {
     this[kReplyHeaders] = {}
     this[kReplyStartTime] = undefined
     this.log = log
+
+    // eslint-disable-next-line no-var
+    for (var i = 0; i < props.length; i++) {
+      this[props[i]] = null
+    }
   }
   _Reply.prototype = new R()
+  _Reply.props = props
   return _Reply
 }
 

package/lib/request.js

@@ -13,6 +13,7 @@ function Request (id, params, req, query, log, context) {
   this.log = log
   this.body = null
 }
+Request.props = []
 
 function getTrustProxyFn (tp) {
   if (typeof tp === 'function') {
@@ -43,6 +44,7 @@ function buildRequest (R, trustProxy) {
 }
 
 function buildRegularRequest (R) {
+  const props = [...R.props]
   function _Request (id, params, req, query, log, context) {
     this.id = id
     this.context = context
@@ -51,8 +53,14 @@ function buildRegularRequest (R) {
     this.query = query
     this.log = log
     this.body = null
+
+    // eslint-disable-next-line no-var
+    for (var i = 0; i < props.length; i++) {
+      this[props[i]] = null
+    }
   }
   _Request.prototype = new R()
+  _Request.props = props
 
   return _Request
 }

package/lib/route.js

@@ -143,12 +143,14 @@ function buildRouting (options) {
       }
     }
 
+    const path = opts.url || opts.path
+
     if (!opts.handler) {
-      throw new Error(`Missing handler function for ${opts.method}:${opts.url} route.`)
+      throw new Error(`Missing handler function for ${opts.method}:${path} route.`)
     }
 
     if (opts.errorHandler !== undefined && typeof opts.errorHandler !== 'function') {
-      throw new Error(`Error Handler for ${opts.method}:${opts.url} route, if defined, must be a function`)
+      throw new Error(`Error Handler for ${opts.method}:${path} route, if defined, must be a function`)
     }
 
     validateBodyLimitOption(opts.bodyLimit)
@@ -156,7 +158,6 @@ function buildRouting (options) {
     const prefix = this[kRoutePrefix]
 
     this.after((notHandledErr, done) => {
-      const path = opts.url || opts.path
       if (path === '/' && prefix.length && opts.method !== 'HEAD') {
         switch (opts.prefixTrailingSlash) {
           case 'slash':

package/lib/schema-controller.js

@@ -15,13 +15,18 @@ function buildSchemaController (parentSchemaCtrl, opts) {
     return new SchemaController(parentSchemaCtrl, opts)
   }
 
-  const option = Object.assign({
-    bucket: buildSchemas,
-    compilersFactory: {
-      buildValidator: ValidatorSelector(),
-      buildSerializer: serializerCompiler
-    }
-  }, opts)
+  let compilersFactory = {
+    buildValidator: ValidatorSelector(),
+    buildSerializer: serializerCompiler
+  }
+  if (opts && opts.compilersFactory) {
+    compilersFactory = Object.assign(compilersFactory, opts.compilersFactory)
+  }
+
+  const option = {
+    bucket: (opts && opts.bucket) || buildSchemas,
+    compilersFactory: compilersFactory
+  }
 
   return new SchemaController(undefined, option)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "3.20.2",
+  "version": "3.21.3",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -115,7 +115,7 @@
   },
   "homepage": "https://www.fastify.io/",
   "devDependencies": {
-    "@fastify/ajv-compiler-8": "github:fastify/ajv-compiler#ajv-8",
+    "@fastify/ajv-compiler-8": "npm:@fastify/ajv-compiler@^2.0.0",
     "@fastify/pre-commit": "^2.0.1",
     "@hapi/joi": "^17.1.1",
     "@sinonjs/fake-timers": "^7.0.0",
@@ -123,9 +123,9 @@
     "@types/pino": "^6.0.1",
     "@typescript-eslint/eslint-plugin": "^4.5.0",
     "@typescript-eslint/parser": "^4.5.0",
-    "JSONStream": "^1.3.5",
     "ajv": "^6.0.0",
     "ajv-errors": "^1.0.1",
+    "ajv-formats": "^2.1.1",
     "ajv-i18n": "^3.5.0",
     "ajv-merge-patch": "^4.1.0",
     "ajv-pack": "^0.3.1",
@@ -151,6 +151,7 @@
     "hsts": "^2.2.0",
     "http-errors": "^1.7.1",
     "ienoopen": "^1.1.0",
+    "JSONStream": "^1.3.5",
     "license-checker": "^25.0.1",
     "pem": "^1.14.4",
     "proxyquire": "^2.1.3",
@@ -193,7 +194,8 @@
       "lib/configValidator.js",
       "fastify.d.ts",
       "types/*",
-      "test/types/*"
+      "test/types/*",
+      "test/same-shape.test.js"
     ]
   },
   "tsd": {

package/test/bundler/README.md

@@ -0,0 +1,29 @@
+# Bundlers test stack
+
+In some cases developers bundle their apps for several targets, eg: serveless applications. 
+Even if it's not recommended by Fastify team; we need to ensure we do not break the build process. 
+Please note this might result in feature behaving differently like the version handling check for plugins.
+
+## Test bundlers
+
+The bundler test stack has been set appart than the rest of the Unit testing stack because it's not a 
+part of the fastify lib itself. Note that the tests run in CI only on NodeJs LTS version.
+Developers does not need to install every bundler to run unit tests.
+
+To run the bundler tests you'll need to first install the repository dependencies and after the bundler
+stack dependencies. See:
+
+```bash
+  # path: root of repository /fastify
+  npm i
+  cd test/bundler/webpack
+  npm i
+  npm run test # test command runs bundle before of starting the test
+```
+
+## Bundler test development
+
+To not break the fastify unit testing stack please name test files like this `*-test.js` and not `*.test.js`, 
+otherwise it can be catched by unit-test regex of fastify.
+Test need to ensure the build process works and the fastify application can be run, 
+no need to go in deep testing unless an issue is raised.

package/test/bundler/webpack/bundler-test.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const fastifySuccess = require('./dist/success')
+const fastifyFailPlugin = require('./dist/failPlugin')
+
+test('Bundled package should work', t => {
+  t.plan(1)
+  fastifySuccess.ready((err) => {
+    t.error(err)
+  })
+})
+
+// In the webpack bundle context the fastify package.json is not read
+// Because of this the version is set to `undefined`, this makes the plugin
+// version check not able to work properly. By then this test shouldn't work
+// in non-bundled environment but works in bundled environment
+test('Bundled package should work with bad plugin version, undefined version fallback', t => {
+  t.plan(1)
+  fastifyFailPlugin.ready((err) => {
+    t.error(err)
+  })
+})

package/test/bundler/webpack/package.json

@@ -0,0 +1,11 @@
+{
+  "version":"0.0.1",
+  "scripts": {
+    "bundle": "webpack",
+    "test": "npm run bundle && node bundler-test.js"
+  },
+  "devDependencies": {
+    "webpack": "^5.49.0",
+    "webpack-cli": "^4.7.2"
+  }
+}

package/test/bundler/webpack/src/fail-plugin-version.js

@@ -0,0 +1,14 @@
+const fp = require('fastify-plugin')
+const fastify = require('../../../../')({
+  logger: true
+})
+
+fastify.get('/', function (request, reply) {
+  reply.send({ hello: 'world' })
+})
+
+fastify.register(fp((instance, opts, done) => {
+  done()
+}, { fastify: '9.x' }))
+
+module.exports = fastify

package/test/bundler/webpack/src/index.js

@@ -0,0 +1,9 @@
+const fastify = require('../../../../')({
+  logger: true
+})
+// Declare a route
+fastify.get('/', function (request, reply) {
+  reply.send({ hello: 'world' })
+})
+
+module.exports = fastify

package/test/bundler/webpack/webpack.config.js

@@ -0,0 +1,13 @@
+const path = require('path')
+
+module.exports = {
+  entry: { success: './src/index.js', failPlugin: './src/fail-plugin-version.js' },
+  target: 'node',
+  output: {
+    path: path.resolve(__dirname, 'dist'),
+    filename: '[name].js',
+    library: {
+      type: 'commonjs2'
+    }
+  }
+}

package/test/custom-parser.test.js

@@ -1707,3 +1707,114 @@ test('cannot remove content type parsers after binding', t => {
     t.throws(() => fastify.removeContentTypeParser('application/json'))
   })
 })
+
+test('should be able to override the default json parser after removeAllContentTypeParsers', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.removeAllContentTypeParsers()
+
+  fastify.addContentTypeParser('application/json', function (req, payload, done) {
+    t.ok('called')
+    jsonParser(payload, function (err, body) {
+      done(err, body)
+    })
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      body: '{"hello":"world"}',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.same(body.toString(), JSON.stringify({ hello: 'world' }))
+      fastify.close()
+    })
+  })
+})
+
+test('should be able to override the default plain text parser after removeAllContentTypeParsers', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.removeAllContentTypeParsers()
+
+  fastify.addContentTypeParser('text/plain', function (req, payload, done) {
+    t.ok('called')
+    plainTextParser(payload, function (err, body) {
+      done(err, body)
+    })
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      body: 'hello world',
+      headers: {
+        'Content-Type': 'text/plain'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(body.toString(), 'hello world')
+      fastify.close()
+    })
+  })
+})
+
+test('should be able to add a custom content type parser after removeAllContentTypeParsers', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.removeAllContentTypeParsers()
+
+  fastify.addContentTypeParser('application/jsoff', function (req, payload, done) {
+    t.ok('called')
+    jsonParser(payload, function (err, body) {
+      done(err, body)
+    })
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      body: '{"hello":"world"}',
+      headers: {
+        'Content-Type': 'application/jsoff'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.same(body.toString(), JSON.stringify({ hello: 'world' }))
+      fastify.close()
+    })
+  })
+})

package/test/decorator.test.js

@@ -17,6 +17,15 @@ test('server methods should exist', t => {
   t.ok(fastify.hasDecorator)
 })
 
+test('should check if the given decoration already exist when null', t => {
+  t.plan(1)
+  const fastify = Fastify()
+  fastify.decorate('null', null)
+  fastify.ready(() => {
+    t.ok(fastify.hasDecorator('null'))
+  })
+})
+
 test('server methods should be encapsulated via .register', t => {
   t.plan(2)
   const fastify = Fastify()
@@ -425,6 +434,15 @@ test('hasRequestDecorator', t => {
     t.ok(fastify.hasRequestDecorator(requestDecoratorName))
   })
 
+  t.test('should check if the given request decoration already exist when null', t => {
+    t.plan(2)
+    const fastify = Fastify()
+
+    t.notOk(fastify.hasRequestDecorator(requestDecoratorName))
+    fastify.decorateRequest(requestDecoratorName, null)
+    t.ok(fastify.hasRequestDecorator(requestDecoratorName))
+  })
+
   t.test('should be plugin encapsulable', t => {
     t.plan(4)
     const fastify = Fastify()
@@ -481,6 +499,15 @@ test('hasReplyDecorator', t => {
     t.ok(fastify.hasReplyDecorator(replyDecoratorName))
   })
 
+  t.test('should check if the given reply decoration already exist when null', t => {
+    t.plan(2)
+    const fastify = Fastify()
+
+    t.notOk(fastify.hasReplyDecorator(replyDecoratorName))
+    fastify.decorateReply(replyDecoratorName, null)
+    t.ok(fastify.hasReplyDecorator(replyDecoratorName))
+  })
+
   t.test('should be plugin encapsulable', t => {
     t.plan(4)
     const fastify = Fastify()