fastify 4.25.2 → 4.26.1

package/test/internals/reply.test.js

@@ -19,7 +19,7 @@ const {
 } = require('../../lib/symbols')
 const fs = require('node:fs')
 const path = require('node:path')
-const { FSTDEP019, FSTDEP010 } = require('../../lib/warnings')
+const { FSTDEP010, FSTDEP019, FSTDEP020 } = require('../../lib/warnings')
 
 const agent = new http.Agent({ keepAlive: false })
 
@@ -1598,7 +1598,40 @@ test('reply.getResponseTime() should return a number greater than 0 after the ti
   fastify.inject({ method: 'GET', url: '/' })
 })
 
-test('reply.getResponseTime() should return the time since a request started while inflight', t => {
+test('should emit deprecation warning when trying to use reply.getResponseTime() and should return the time since a request started while inflight', t => {
+  t.plan(5)
+  const fastify = Fastify()
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => {
+      reply.send('hello world')
+    }
+  })
+
+  process.removeAllListeners('warning')
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'DeprecationWarning')
+    t.equal(warning.code, FSTDEP020.code)
+  }
+
+  fastify.addHook('preValidation', (req, reply, done) => {
+    t.equal(reply.getResponseTime(), reply.getResponseTime())
+    done()
+  })
+
+  fastify.inject({ method: 'GET', url: '/' }, (err, res) => {
+    t.error(err)
+    t.pass()
+
+    process.removeListener('warning', onWarning)
+  })
+
+  FSTDEP020.emitted = false
+})
+
+test('reply.getResponseTime() should return the same value after a request is finished', t => {
   t.plan(1)
   const fastify = Fastify()
   fastify.route({
@@ -1609,19 +1642,61 @@ test('reply.getResponseTime() should return the time since a request started whi
     }
   })
 
+  fastify.addHook('onResponse', (req, reply) => {
+    t.equal(reply.getResponseTime(), reply.getResponseTime())
+    t.end()
+  })
+
+  fastify.inject({ method: 'GET', url: '/' })
+})
+
+test('reply.elapsedTime should return a number greater than 0 after the timer is initialised on the reply by setting up response listeners', t => {
+  t.plan(1)
+  const fastify = Fastify()
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => {
+      reply.send('hello world')
+    }
+  })
+
+  fastify.addHook('onResponse', (req, reply) => {
+    t.ok(reply.elapsedTime > 0)
+    t.end()
+  })
+
+  fastify.inject({ method: 'GET', url: '/' })
+})
+
+test('reply.elapsedTime should return the time since a request started while inflight', t => {
+  t.plan(1)
+  const fastify = Fastify()
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => {
+      reply.send('hello world')
+    }
+  })
+
+  let preValidationElapsedTime
+
   fastify.addHook('preValidation', (req, reply, done) => {
-    t.not(reply.getResponseTime(), reply.getResponseTime())
+    preValidationElapsedTime = reply.elapsedTime
+
     done()
   })
 
   fastify.addHook('onResponse', (req, reply) => {
+    t.ok(reply.elapsedTime > preValidationElapsedTime)
     t.end()
   })
 
   fastify.inject({ method: 'GET', url: '/' })
 })
 
-test('reply.getResponseTime() should return the same value after a request is finished', t => {
+test('reply.elapsedTime should return the same value after a request is finished', t => {
   t.plan(1)
   const fastify = Fastify()
   fastify.route({
@@ -1633,7 +1708,7 @@ test('reply.getResponseTime() should return the same value after a request is fi
   })
 
   fastify.addHook('onResponse', (req, reply) => {
-    t.equal(reply.getResponseTime(), reply.getResponseTime())
+    t.equal(reply.elapsedTime, reply.elapsedTime)
     t.end()
   })
 

package/test/plugin.4.test.js

@@ -22,7 +22,7 @@ test('pluginTimeout', t => {
       "fastify-plugin: Plugin did not start in time: 'function (app, opts, done) { -- // to no call done on purpose'. You may have forgotten to call 'done' function or to resolve a Promise")
     t.equal(err.code, 'FST_ERR_PLUGIN_TIMEOUT')
     t.ok(err.cause)
-    t.equal(err.cause.code, 'AVV_ERR_READY_TIMEOUT')
+    t.equal(err.cause.code, 'AVV_ERR_PLUGIN_EXEC_TIMEOUT')
   })
 })
 
@@ -40,7 +40,7 @@ test('pluginTimeout - named function', t => {
       "fastify-plugin: Plugin did not start in time: 'nameFunction'. You may have forgotten to call 'done' function or to resolve a Promise")
     t.equal(err.code, 'FST_ERR_PLUGIN_TIMEOUT')
     t.ok(err.cause)
-    t.equal(err.cause.code, 'AVV_ERR_READY_TIMEOUT')
+    t.equal(err.cause.code, 'AVV_ERR_PLUGIN_EXEC_TIMEOUT')
   })
 })
 
@@ -60,7 +60,7 @@ test('pluginTimeout default', t => {
       "fastify-plugin: Plugin did not start in time: 'function (app, opts, done) { -- // default time elapsed without calling done'. You may have forgotten to call 'done' function or to resolve a Promise")
     t.equal(err.code, 'FST_ERR_PLUGIN_TIMEOUT')
     t.ok(err.cause)
-    t.equal(err.cause.code, 'AVV_ERR_READY_TIMEOUT')
+    t.equal(err.cause.code, 'AVV_ERR_PLUGIN_EXEC_TIMEOUT')
   })
 
   t.teardown(clock.uninstall)

package/test/pretty-print.test.js

@@ -220,7 +220,7 @@ test('pretty print - empty plugins', t => {
   fastify.ready(() => {
     const tree = fastify.printPlugins()
     t.equal(typeof tree, 'string')
-    t.match(tree, 'bound root')
+    t.match(tree, /root \d+ ms\n└── bound _after \d+ ms/m)
   })
 })
 

package/test/schema-serialization.test.js

@@ -593,6 +593,47 @@ test('Custom setSerializerCompiler returns bad serialized output', t => {
   })
 })
 
+test('Custom setSerializerCompiler with addSchema', t => {
+  t.plan(6)
+  const fastify = Fastify({ exposeHeadRoutes: false })
+
+  const outSchema = {
+    $id: 'test',
+    type: 'object',
+    whatever: 'need to be parsed by the custom serializer'
+  }
+
+  fastify.setSerializerCompiler(({ schema, method, url, httpStatus }) => {
+    t.equal(method, 'GET')
+    t.equal(url, '/foo/:id')
+    t.equal(httpStatus, '200')
+    t.same(schema, outSchema)
+    return _data => JSON.stringify({ id: 2 })
+  })
+
+  // provoke re-creation of serialization compiler in setupSerializer
+  fastify.addSchema({ $id: 'dummy', type: 'object' })
+
+  fastify.get('/foo/:id', {
+    handler (_req, reply) {
+      reply.send({ id: 1 })
+    },
+    schema: {
+      response: {
+        200: outSchema
+      }
+    }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/foo/123'
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.payload, JSON.stringify({ id: 2 }))
+  })
+})
+
 test('Custom serializer per route', async t => {
   const fastify = Fastify()
 

package/test/schema-validation.test.js

@@ -106,7 +106,7 @@ test('Basic validation test', t => {
 })
 
 test('External AJV instance', t => {
-  t.plan(4)
+  t.plan(5)
 
   const fastify = Fastify()
   const ajv = new AJV()
@@ -118,6 +118,7 @@ test('External AJV instance', t => {
   fastify.addSchema(schemaBRefToA)
 
   fastify.setValidatorCompiler(({ schema, method, url, httpPart }) => {
+    t.pass('custom validator compiler called')
     return ajv.compile(schema)
   })
 
@@ -151,7 +152,7 @@ test('External AJV instance', t => {
 })
 
 test('Encapsulation', t => {
-  t.plan(19)
+  t.plan(21)
 
   const fastify = Fastify()
   const ajv = new AJV()
@@ -164,6 +165,7 @@ test('Encapsulation', t => {
 
   fastify.register((instance, opts, done) => {
     const validator = ({ schema, method, url, httpPart }) => {
+      t.pass('custom validator compiler called')
       return ajv.compile(schema)
     }
     instance.setValidatorCompiler(validator)
@@ -271,7 +273,7 @@ test('Encapsulation', t => {
 })
 
 test('Triple $ref with a simple $id', t => {
-  t.plan(6)
+  t.plan(7)
 
   const fastify = Fastify()
   const ajv = new AJV()
@@ -285,6 +287,7 @@ test('Triple $ref with a simple $id', t => {
   fastify.addSchema(schemaCRefToB)
 
   fastify.setValidatorCompiler(({ schema, method, url, httpPart }) => {
+    t.pass('custom validator compiler called')
     return ajv.compile(schema)
   })
 
@@ -1024,19 +1027,125 @@ test("The same $id in route's schema must not overwrite others", t => {
 
 test('Custom validator compiler should not mutate schema', async t => {
   t.plan(2)
-  class Headers {}
+  class Headers { }
   const fastify = Fastify()
 
   fastify.setValidatorCompiler(({ schema, method, url, httpPart }) => {
     t.type(schema, Headers)
-    return () => {}
+    return () => { }
   })
 
   fastify.get('/', {
     schema: {
       headers: new Headers()
     }
-  }, () => {})
+  }, () => { })
+
+  await fastify.ready()
+})
+
+test('Custom validator builder override by custom validator compiler', async t => {
+  t.plan(3)
+  const ajvDefaults = {
+    removeAdditional: true,
+    coerceTypes: true,
+    allErrors: true
+  }
+  const ajv1 = new AJV(ajvDefaults).addKeyword({ keyword: 'extended_one', type: 'object', validator: () => true })
+  const ajv2 = new AJV(ajvDefaults).addKeyword({ keyword: 'extended_two', type: 'object', validator: () => true })
+  const fastify = Fastify({ schemaController: { compilersFactory: { buildValidator: () => (routeSchemaDef) => ajv1.compile(routeSchemaDef.schema) } } })
+
+  fastify.setValidatorCompiler((routeSchemaDef) => ajv2.compile(routeSchemaDef.schema))
+
+  fastify.post('/two/:id', {
+    schema: {
+      params: {
+        type: 'object',
+        extended_two: true,
+        properties: {
+          id: { type: 'number' }
+        },
+        required: ['id']
+      }
+    },
+    handler: (req, _reply) => {
+      t.same(typeof req.params.id, 'number')
+      t.same(req.params.id, 43)
+      return 'ok'
+    }
+  })
 
   await fastify.ready()
+
+  const two = await fastify.inject({
+    method: 'POST',
+    url: '/two/43'
+  })
+  t.equal(two.statusCode, 200)
+})
+
+test('Custom validator builder override by custom validator compiler in child instance', async t => {
+  t.plan(6)
+  const ajvDefaults = {
+    removeAdditional: true,
+    coerceTypes: true,
+    allErrors: true
+  }
+  const ajv1 = new AJV(ajvDefaults).addKeyword({ keyword: 'extended_one', type: 'object', validator: () => true })
+  const ajv2 = new AJV(ajvDefaults).addKeyword({ keyword: 'extended_two', type: 'object', validator: () => true })
+  const fastify = Fastify({ schemaController: { compilersFactory: { buildValidator: () => (routeSchemaDef) => ajv1.compile(routeSchemaDef.schema) } } })
+
+  fastify.register((embedded, _opts, done) => {
+    embedded.setValidatorCompiler((routeSchemaDef) => ajv2.compile(routeSchemaDef.schema))
+    embedded.post('/two/:id', {
+      schema: {
+        params: {
+          type: 'object',
+          extended_two: true,
+          properties: {
+            id: { type: 'number' }
+          },
+          required: ['id']
+        }
+      },
+      handler: (req, _reply) => {
+        t.same(typeof req.params.id, 'number')
+        t.same(req.params.id, 43)
+        return 'ok'
+      }
+    })
+    done()
+  })
+
+  fastify.post('/one/:id', {
+    schema: {
+      params: {
+        type: 'object',
+        extended_one: true,
+        properties: {
+          id: { type: 'number' }
+        },
+        required: ['id']
+      }
+    },
+    handler: (req, _reply) => {
+      t.same(typeof req.params.id, 'number')
+      t.same(req.params.id, 42)
+      return 'ok'
+    }
+  })
+
+  await fastify.ready()
+
+  const one = await fastify.inject({
+    method: 'POST',
+    url: '/one/42'
+  })
+  t.equal(one.statusCode, 200)
+
+  const two = await fastify.inject({
+    method: 'POST',
+    url: '/two/43'
+  })
+  t.equal(two.statusCode, 200)
 })

package/test/serialize-response.test.js

@@ -0,0 +1,187 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const { S } = require('fluent-json-schema')
+const Fastify = require('../fastify')
+const sjson = require('secure-json-parse')
+
+const BadRequestSchema = S.object()
+  .prop('statusCode', S.number())
+  .prop('error', S.string())
+  .prop('message', S.string())
+
+const InternalServerErrorSchema = S.object()
+  .prop('statusCode', S.number())
+  .prop('error', S.string())
+  .prop('message', S.string())
+
+const NotFoundSchema = S.object()
+  .prop('statusCode', S.number())
+  .prop('error', S.string())
+  .prop('message', S.string())
+
+const options = {
+  schema: {
+    body: {
+      type: 'object',
+      properties: {
+        id: { type: 'string' }
+      }
+    },
+    response: {
+      200: {
+        type: 'object',
+        properties: {
+          id: { type: 'string' }
+        }
+      },
+      400: {
+        description: 'Bad Request',
+        content: {
+          'application/json': {
+            schema: BadRequestSchema.valueOf()
+          }
+        }
+      },
+      404: {
+        description: 'Resource not found',
+        content: {
+          'application/json': {
+            schema: NotFoundSchema.valueOf(),
+            example: {
+              statusCode: 404,
+              error: 'Not Found',
+              message: 'Not Found'
+            }
+          }
+        }
+      },
+      500: {
+        description: 'Internal Server Error',
+        content: {
+          'application/json': {
+            schema: InternalServerErrorSchema.valueOf(),
+            example: {
+              message: 'Internal Server Error'
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+const handler = (request, reply) => {
+  if (request.body.id === '400') {
+    return reply.status(400).send({
+      statusCode: 400,
+      error: 'Bad Request',
+      message: 'Custom message',
+      extra: 'This should not be in the response'
+    })
+  }
+
+  if (request.body.id === '404') {
+    return reply.status(404).send({
+      statusCode: 404,
+      error: 'Not Found',
+      message: 'Custom Not Found',
+      extra: 'This should not be in the response'
+    })
+  }
+
+  if (request.body.id === '500') {
+    reply.status(500).send({
+      statusCode: 500,
+      error: 'Internal Server Error',
+      message: 'Custom Internal Server Error',
+      extra: 'This should not be in the response'
+    })
+  }
+
+  reply.send({
+    id: request.body.id,
+    extra: 'This should not be in the response'
+  })
+}
+
+test('serialize the response for a Bad Request error, as defined on the schema', async t => {
+  t.plan(2)
+
+  const fastify = Fastify({})
+
+  fastify.post('/', options, handler)
+  const response = await fastify.inject({
+    method: 'POST',
+    url: '/'
+  })
+
+  t.equal(response.statusCode, 400)
+  t.same(sjson(response.body), {
+    statusCode: 400,
+    error: 'Bad Request',
+    message: 'body must be object'
+  })
+})
+
+test('serialize the response for a Not Found error, as defined on the schema', async t => {
+  t.plan(2)
+
+  const fastify = Fastify({})
+
+  fastify.post('/', options, handler)
+
+  const response = await fastify.inject({
+    method: 'POST',
+    url: '/',
+    body: { id: '404' }
+  })
+
+  t.equal(response.statusCode, 404)
+  t.same(sjson(response.body), {
+    statusCode: 404,
+    error: 'Not Found',
+    message: 'Custom Not Found'
+  })
+})
+
+test('serialize the response for a Internal Server Error error, as defined on the schema', async t => {
+  t.plan(2)
+
+  const fastify = Fastify({})
+
+  fastify.post('/', options, handler)
+
+  const response = await fastify.inject({
+    method: 'POST',
+    url: '/',
+    body: { id: '500' }
+  })
+
+  t.equal(response.statusCode, 500)
+  t.same(sjson(response.body), {
+    statusCode: 500,
+    error: 'Internal Server Error',
+    message: 'Custom Internal Server Error'
+  })
+})
+
+test('serialize the success response, as defined on the schema', async t => {
+  t.plan(2)
+
+  const fastify = Fastify({})
+
+  fastify.post('/', options, handler)
+
+  const response = await fastify.inject({
+    method: 'POST',
+    url: '/',
+    body: { id: 'test' }
+  })
+
+  t.equal(response.statusCode, 200)
+  t.same(sjson(response.body), {
+    id: 'test'
+  })
+})

package/test/types/instance.test-d.ts

@@ -51,6 +51,18 @@ expectAssignable<FastifyInstance>(
   })
 )
 
+expectAssignable<FastifyInstance>(
+  server.setGenReqId(function (req) {
+    expectType<RawRequestDefaultExpression>(req)
+    return 'foo'
+  })
+)
+
+function fastifySetGenReqId (req: RawRequestDefaultExpression) {
+  return 'foo'
+}
+server.setGenReqId(fastifySetGenReqId)
+
 function fastifyErrorHandler (this: FastifyInstance, error: FastifyError) {}
 server.setErrorHandler(fastifyErrorHandler)
 
@@ -330,7 +342,8 @@ type InitialConfig = Readonly<{
   pluginTimeout?: number,
   requestIdHeader?: string | false,
   requestIdLogLabel?: string,
-  http2SessionTimeout?: number
+  http2SessionTimeout?: number,
+  useSemicolonDelimiter?: boolean
 }>
 
 expectType<InitialConfig>(fastify().initialConfig)

package/test/types/reply.test-d.ts

@@ -1,5 +1,5 @@
 import { Buffer } from 'buffer'
-import { expectAssignable, expectError, expectType } from 'tsd'
+import { expectAssignable, expectDeprecated, expectError, expectType } from 'tsd'
 import fastify, { FastifyReplyContext, FastifyReply, FastifyRequest, FastifySchema, FastifySchemaCompiler, FastifyTypeProviderDefault, RawRequestDefaultExpression, RouteHandler, RouteHandlerMethod } from '../../fastify'
 import { FastifyInstance } from '../../types/instance'
 import { FastifyLoggerInstance } from '../../types/logger'
@@ -19,6 +19,7 @@ const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectType<<Code extends number>(statusCode: Code) => DefaultFastifyReplyWithCode<Code>>(reply.code)
   expectType<<Code extends number>(statusCode: Code) => DefaultFastifyReplyWithCode<Code>>(reply.status)
   expectType<(payload?: unknown) => FastifyReply>(reply.code(100 as number).send)
+  expectType<number>(reply.elapsedTime)
   expectType<number>(reply.statusCode)
   expectType<boolean>(reply.sent)
   expectType<((payload?: unknown) => FastifyReply)>(reply.send)
@@ -31,7 +32,8 @@ const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectType<{(statusCode: number, url: string): FastifyReply; (url: string): FastifyReply }>(reply.redirect)
   expectType<() => FastifyReply>(reply.hijack)
   expectType<() => void>(reply.callNotFound)
-  expectType<() => number>(reply.getResponseTime)
+  // Test reply.getResponseTime() deprecation
+  expectDeprecated(reply.getResponseTime)
   expectType<(contentType: string) => FastifyReply>(reply.type)
   expectType<(fn: (payload: any) => string) => FastifyReply>(reply.serializer)
   expectType<(payload: any) => string | ArrayBuffer | Buffer>(reply.serialize)

package/test/types/request.test-d.ts

@@ -1,4 +1,3 @@
-import pino from 'pino'
 import { expectAssignable, expectType } from 'tsd'
 import fastify, {
   ContextConfigDefault,
@@ -83,6 +82,7 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<FastifySchema>(request.routeSchema)
   expectType<FastifySchema>(request.routeOptions.schema)
   expectType<RouteHandlerMethod>(request.routeOptions.handler)
+  expectType<string | undefined>(request.routeOptions.url)
 
   expectType<RequestHeadersDefault & RawRequestDefaultExpression['headers']>(request.headers)
   request.headers = {}

package/test/types/route.test-d.ts

@@ -3,7 +3,8 @@ import * as http from 'http'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import fastify, { FastifyInstance, FastifyReply, FastifyRequest, RouteHandlerMethod } from '../../fastify'
 import { RequestPayload } from '../../types/hooks'
-import { HTTPMethods } from '../../types/utils'
+import { FindMyWayFindResult } from '../../types/instance'
+import { HTTPMethods, RawServerDefault } from '../../types/utils'
 
 /*
  * Testing Fastify HTTP Routes and Route Shorthands.
@@ -453,6 +454,19 @@ expectType<boolean>(fastify().hasRoute({
   }
 }))
 
+expectType<Omit<FindMyWayFindResult<RawServerDefault>, 'store'>>(
+  fastify().findRoute({
+    url: '/',
+    method: 'get'
+  })
+)
+
+// we should not expose store
+expectError(fastify().findRoute({
+  url: '/',
+  method: 'get'
+}).store)
+
 expectType<FastifyInstance>(fastify().route({
   url: '/',
   method: 'get',