fastify 4.25.2 → 4.26.1

package/lib/schema-controller.js

@@ -39,12 +39,10 @@ function buildSchemaController (parentSchemaCtrl, opts) {
 
 class SchemaController {
   constructor (parent, options) {
-    this.opts = options || (parent && parent.opts)
+    this.opts = options || parent?.opts
     this.addedSchemas = false
 
     this.compilersFactory = this.opts.compilersFactory
-    this.isCustomValidatorCompiler = this.opts.isCustomValidatorCompiler || false
-    this.isCustomSerializerCompiler = this.opts.isCustomSerializerCompiler || false
 
     if (parent) {
       this.schemaBucket = this.opts.bucket(parent.getSchemas())
@@ -55,6 +53,8 @@ class SchemaController {
       this.parent = parent
     } else {
       this.schemaBucket = this.opts.bucket()
+      this.isCustomValidatorCompiler = this.opts.isCustomValidatorCompiler || false
+      this.isCustomSerializerCompiler = this.opts.isCustomSerializerCompiler || false
     }
   }
 
@@ -72,13 +72,46 @@ class SchemaController {
     return this.schemaBucket.getSchemas()
   }
 
-  // Schema Controller compilers holder
   setValidatorCompiler (validatorCompiler) {
+    // Set up as if the fixed validator compiler had been provided
+    // by a custom 'options.compilersFactory.buildValidator' that
+    // always returns the same compiler object. This is required because:
+    //
+    // - setValidatorCompiler must immediately install a compiler to preserve
+    //   legacy behavior
+    // - setupValidator will recreate compilers from builders in some
+    //   circumstances, so we have to install this adapter to make it
+    //   behave the same if the legacy API is used
+    //
+    // The cloning of the compilersFactory object is necessary because
+    // we are aliasing the parent compilersFactory if none was provided
+    // to us (see constructor.)
+    this.compilersFactory = Object.assign(
+      {},
+      this.compilersFactory,
+      { buildValidator: () => validatorCompiler })
     this.validatorCompiler = validatorCompiler
     this.isCustomValidatorCompiler = true
   }
 
   setSerializerCompiler (serializerCompiler) {
+    // Set up as if the fixed serializer compiler had been provided
+    // by a custom 'options.compilersFactory.buildSerializer' that
+    // always returns the same compiler object. This is required because:
+    //
+    // - setSerializerCompiler must immediately install a compiler to preserve
+    //   legacy behavior
+    // - setupSerializer will recreate compilers from builders in some
+    //   circumstances, so we have to install this adapter to make it
+    //   behave the same if the legacy API is used
+    //
+    // The cloning of the compilersFactory object is necessary because
+    // we are aliasing the parent compilersFactory if none was provided
+    // to us (see constructor.)
+    this.compilersFactory = Object.assign(
+      {},
+      this.compilersFactory,
+      { buildSerializer: () => serializerCompiler })
     this.serializerCompiler = serializerCompiler
     this.isCustomSerializerCompiler = true
   }

package/lib/symbols.js

@@ -16,6 +16,7 @@ const keys = {
   kPluginNameChain: Symbol('fastify.pluginNameChain'),
   kRouteContext: Symbol('fastify.context'),
   kPublicRouteContext: Symbol('fastify.routeOptions'),
+  kGenReqId: Symbol('fastify.genReqId'),
   // Schema
   kSchemaController: Symbol('fastify.schemaController'),
   kSchemaHeaders: Symbol('headers-schema'),

package/lib/warnings.js

@@ -77,6 +77,11 @@ const FSTDEP019 = createDeprecation({
   message: 'reply.context property access is deprecated. Please use "request.routeOptions.config" or "request.routeOptions.schema" instead for accessing Route settings. The "reply.context" will be removed in `fastify@5`.'
 })
 
+const FSTDEP020 = createDeprecation({
+  code: 'FSTDEP020',
+  message: 'You are using the deprecated "reply.getResponseTime()" method. Use the "reply.elapsedTime" property instead. Method "reply.getResponseTime()" will be removed in `fastify@5`.'
+})
+
 const FSTWRN001 = createWarning({
   name: 'FastifyWarning',
   code: 'FSTWRN001',
@@ -107,6 +112,7 @@ module.exports = {
   FSTDEP017,
   FSTDEP018,
   FSTDEP019,
+  FSTDEP020,
   FSTWRN001,
   FSTWRN002
 }

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "fastify",
-  "version": "4.25.2",
+  "version": "4.26.1",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
   "types": "fastify.d.ts",
   "scripts": {
     "bench": "branchcmp -r 2 -g -s \"npm run benchmark\"",
-    "benchmark": "npx concurrently -k -s first \"node ./examples/benchmark/simple.js\" \"npx autocannon -c 100 -d 30 -p 10 localhost:3000/\"",
-    "benchmark:parser": "npx concurrently -k -s first \"node ./examples/benchmark/parser.js\" \"npx autocannon -c 100 -d 30 -p 10 -i ./examples/benchmark/body.json -H \"content-type:application/jsoff\" -m POST localhost:3000/\"",
+    "benchmark": "concurrently -k -s first \"node ./examples/benchmark/simple.js\" \"autocannon -c 100 -d 30 -p 10 localhost:3000/\"",
+    "benchmark:parser": "concurrently -k -s first \"node ./examples/benchmark/parser.js\" \"autocannon -c 100 -d 30 -p 10 -i ./examples/benchmark/body.json -H \"content-type:application/jsoff\" -m POST localhost:3000/\"",
     "build:validation": "node build/build-error-serializer.js && node build/build-validation.js",
     "coverage": "npm run unit -- --coverage-report=html",
     "coverage:ci": "c8 --reporter=lcov tap --coverage-report=html --no-browser --no-check-coverage",
@@ -141,7 +141,17 @@
   "bugs": {
     "url": "https://github.com/fastify/fastify/issues"
   },
-  "homepage": "https://www.fastify.dev/",
+  "homepage": "https://fastify.dev/",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/fastify"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/fastify"
+    }
+  ],
   "devDependencies": {
     "@fastify/pre-commit": "^2.0.2",
     "@sinclair/typebox": "^0.31.17",
@@ -154,8 +164,10 @@
     "ajv-formats": "^2.1.1",
     "ajv-i18n": "^4.2.0",
     "ajv-merge-patch": "^5.0.1",
+    "autocannon": "^7.14.0",
     "branch-comparer": "^1.1.0",
     "c8": "^8.0.1",
+    "concurrently": "^8.2.2",
     "cross-env": "^7.0.3",
     "eslint": "^8.51.0",
     "eslint-config-standard": "^17.1.0",
@@ -192,10 +204,10 @@
     "@fastify/error": "^3.4.0",
     "@fastify/fast-json-stringify-compiler": "^4.3.0",
     "abstract-logging": "^2.0.1",
-    "avvio": "^8.2.1",
+    "avvio": "^8.3.0",
     "fast-content-type-parse": "^1.1.0",
     "fast-json-stringify": "^5.8.0",
-    "find-my-way": "^7.7.0",
+    "find-my-way": "^8.0.0",
     "light-my-request": "^5.11.0",
     "pino": "^8.17.0",
     "process-warning": "^3.0.0",

package/test/async_hooks.test.js

@@ -0,0 +1,69 @@
+'use strict'
+
+const { createHook } = require('node:async_hooks')
+const t = require('tap')
+const Fastify = require('..')
+const sget = require('simple-get').concat
+
+const remainingIds = new Set()
+
+createHook({
+  init (asyncId, type, triggerAsyncId, resource) {
+    if (type === 'content-type-parser:run') {
+      remainingIds.add(asyncId)
+    }
+  },
+  destroy (asyncId) {
+    remainingIds.delete(asyncId)
+  }
+})
+
+const app = Fastify({ logger: false })
+
+app.get('/', function (request, reply) {
+  reply.send({ id: 42 })
+})
+
+app.post('/', function (request, reply) {
+  reply.send({ id: 42 })
+})
+
+app.listen({ port: 0 }, function (err, address) {
+  t.error(err)
+
+  sget({
+    method: 'POST',
+    url: 'http://localhost:' + app.server.address().port,
+    body: {
+      hello: 'world'
+    },
+    json: true
+  }, (err, response, body) => {
+    t.error(err)
+    t.equal(response.statusCode, 200)
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + app.server.address().port,
+      body: {
+        hello: 'world'
+      },
+      json: true
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+
+      sget({
+        method: 'GET',
+        url: 'http://localhost:' + app.server.address().port,
+        json: true
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        app.close()
+        t.equal(remainingIds.size, 0)
+        t.end()
+      })
+    })
+  })
+})

package/test/findRoute.test.js

@@ -0,0 +1,135 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('..')
+const fastifyPlugin = require('fastify-plugin')
+
+test('findRoute should return null when route cannot be found due to a different method', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler: (req, reply) => reply.send(typeof req.params.artistId)
+  })
+
+  t.equal(fastify.findRoute({
+    method: 'POST',
+    url: '/artists/:artistId'
+  }), null)
+})
+
+test('findRoute should return an immutable route to avoid leaking and runtime route modifications', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler: (req, reply) => reply.send(typeof req.params.artistId)
+  })
+
+  let route = fastify.findRoute({
+    method: 'GET',
+    url: '/artists/:artistId'
+  })
+
+  route.params = {
+    ...route.params,
+    id: ':id'
+  }
+
+  route = fastify.findRoute({
+    method: 'GET',
+    url: '/artists/:artistId'
+  })
+  t.same(route.params, { artistId: ':artistId' })
+})
+
+test('findRoute should return null when route cannot be found due to a different path', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler: (req, reply) => reply.send(typeof req.params.artistId)
+  })
+
+  t.equal(fastify.findRoute({
+    method: 'GET',
+    url: '/books/:bookId'
+  }), null)
+})
+
+test('findRoute should return the route when found', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  const handler = (req, reply) => reply.send(typeof req.params.artistId)
+
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler
+  })
+
+  const route = fastify.findRoute({
+    method: 'GET',
+    url: '/artists/:artistId'
+  })
+
+  t.same(route.params, { artistId: ':artistId' })
+})
+
+test('findRoute should work correctly when used within plugins', t => {
+  t.plan(1)
+  const fastify = Fastify()
+  const handler = (req, reply) => reply.send(typeof req.params.artistId)
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler
+  })
+
+  function validateRoutePlugin (instance, opts, done) {
+    const validateParams = function () {
+      return instance.findRoute({
+        method: 'GET',
+        url: '/artists/:artistId'
+      }) !== null
+    }
+    instance.decorate('validateRoutes', { validateParams })
+    done()
+  }
+
+  fastify.register(fastifyPlugin(validateRoutePlugin))
+
+  fastify.ready(() => {
+    t.equal(fastify.validateRoutes.validateParams(), true)
+  })
+})
+
+test('findRoute should not expose store', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler: (req, reply) => reply.send(typeof req.params.artistId)
+  })
+
+  const route = fastify.findRoute({
+    method: 'GET',
+    url: '/artists/:artistId'
+  })
+  t.equal(route.store, undefined)
+})