fastify 3.23.0 → 3.25.0

package/test/schema-feature.test.js

@@ -3,6 +3,7 @@
 const { test } = require('tap')
 const Fastify = require('..')
 const fp = require('fastify-plugin')
+const Ajv = require('ajv')
 const { kSchemaController } = require('../lib/symbols.js')
 
 const echoParams = (req, reply) => { reply.send(req.params) }
@@ -1289,3 +1290,463 @@ test('setSchemaController per instance', t => {
 
   fastify.ready(err => { t.error(err) })
 })
+
+test('setSchemaController: Inherits correctly parent schemas with a customized validator instance', async t => {
+  t.plan(5)
+  const customAjv = new Ajv({ coerceTypes: false })
+  const server = Fastify()
+  const someSchema = {
+    $id: 'some',
+    type: 'array',
+    items: {
+      type: 'string'
+    }
+  }
+  const errorResponseSchema = {
+    $id: 'error_response',
+    type: 'object',
+    properties: {
+      statusCode: {
+        type: 'integer'
+      },
+      message: {
+        type: 'string'
+      }
+    }
+  }
+
+  server.addSchema(someSchema)
+  server.addSchema(errorResponseSchema)
+
+  server.register((instance, _, done) => {
+    instance.setSchemaController({
+      compilersFactory: {
+        buildValidator: function (externalSchemas) {
+          const schemaKeys = Object.keys(externalSchemas)
+          t.equal(schemaKeys.length, 2, 'Contains same number of schemas')
+          t.hasStrict([someSchema, errorResponseSchema], Object.values(externalSchemas), 'Contains expected schemas')
+          for (const key of schemaKeys) {
+            if (customAjv.getSchema(key) == null) {
+              customAjv.addSchema(externalSchemas[key], key)
+            }
+          }
+          return function validatorCompiler ({ schema }) {
+            return customAjv.compile(schema)
+          }
+        }
+      }
+    })
+
+    instance.get(
+      '/',
+      {
+        schema: {
+          querystring: {
+            msg: {
+              $ref: 'some#'
+            }
+          },
+          response: {
+            '4xx': {
+              $ref: 'error_response#'
+            }
+          }
+        }
+      },
+      (req, reply) => {
+        reply.send({ noop: 'noop' })
+      }
+    )
+
+    done()
+  })
+
+  const res = await server.inject({
+    method: 'GET',
+    url: '/',
+    query: {
+      msg: 'string'
+    }
+  })
+  const json = res.json()
+
+  t.equal(json.message, 'querystring.msg should be array')
+  t.equal(json.statusCode, 400)
+  t.equal(res.statusCode, 400, 'Should not coearce the string into array')
+})
+
+test('setSchemaController: Inherits buildSerializer from parent if not present within the instance', async t => {
+  t.plan(6)
+  const customAjv = new Ajv({ coerceTypes: false })
+  const someSchema = {
+    $id: 'some',
+    type: 'array',
+    items: {
+      type: 'string'
+    }
+  }
+  const errorResponseSchema = {
+    $id: 'error_response',
+    type: 'object',
+    properties: {
+      statusCode: {
+        type: 'integer'
+      },
+      message: {
+        type: 'string'
+      }
+    }
+  }
+  let rootSerializerCalled = 0
+  let rootValidatorCalled = 0
+  let childValidatorCalled = 0
+  const rootBuildSerializer = function (externalSchemas) {
+    rootSerializerCalled++
+    return function serializer () {
+      return data => {
+        return JSON.stringify({
+          statusCode: data.statusCode,
+          message: data.message
+        })
+      }
+    }
+  }
+  const rootBuildValidator = function (externalSchemas) {
+    rootValidatorCalled++
+    return function validatorCompiler ({ schema }) {
+      return customAjv.compile(schema)
+    }
+  }
+  const server = Fastify({
+    schemaController: {
+      compilersFactory: {
+        buildValidator: rootBuildValidator,
+        buildSerializer: rootBuildSerializer
+      }
+    }
+  })
+
+  server.addSchema(someSchema)
+  server.addSchema(errorResponseSchema)
+
+  server.register((instance, _, done) => {
+    instance.setSchemaController({
+      compilersFactory: {
+        buildValidator: function (externalSchemas) {
+          childValidatorCalled++
+          const schemaKeys = Object.keys(externalSchemas)
+          for (const key of schemaKeys) {
+            if (customAjv.getSchema(key) == null) {
+              customAjv.addSchema(externalSchemas[key], key)
+            }
+          }
+          return function validatorCompiler ({ schema }) {
+            return customAjv.compile(schema)
+          }
+        }
+      }
+    })
+
+    instance.get(
+      '/',
+      {
+        schema: {
+          querystring: {
+            msg: {
+              $ref: 'some#'
+            }
+          },
+          response: {
+            '4xx': {
+              $ref: 'error_response#'
+            }
+          }
+        }
+      },
+      (req, reply) => {
+        reply.send({ noop: 'noop' })
+      }
+    )
+
+    done()
+  })
+
+  const res = await server.inject({
+    method: 'GET',
+    url: '/',
+    query: {
+      msg: 'string'
+    }
+  })
+  const json = res.json()
+
+  t.equal(json.statusCode, 400)
+  t.equal(json.message, 'querystring.msg should be array')
+  t.equal(rootSerializerCalled, 1, 'Should be called from the child')
+  t.equal(rootValidatorCalled, 0, 'Should not be called from the child')
+  t.equal(childValidatorCalled, 1, 'Should be called from the child')
+  t.equal(res.statusCode, 400, 'Should not coerce the string into array')
+})
+
+test('setSchemaController: Inherits buildValidator from parent if not present within the instance', async t => {
+  t.plan(6)
+  const customAjv = new Ajv({ coerceTypes: false })
+  const someSchema = {
+    $id: 'some',
+    type: 'array',
+    items: {
+      type: 'string'
+    }
+  }
+  const errorResponseSchema = {
+    $id: 'error_response',
+    type: 'object',
+    properties: {
+      statusCode: {
+        type: 'integer'
+      },
+      message: {
+        type: 'string'
+      }
+    }
+  }
+  let rootSerializerCalled = 0
+  let rootValidatorCalled = 0
+  let childSerializerCalled = 0
+  const rootBuildSerializer = function (externalSchemas) {
+    rootSerializerCalled++
+    return function serializer () {
+      return data => JSON.stringify(data)
+    }
+  }
+  const rootBuildValidator = function (externalSchemas) {
+    rootValidatorCalled++
+    const schemaKeys = Object.keys(externalSchemas)
+    for (const key of schemaKeys) {
+      if (customAjv.getSchema(key) == null) {
+        customAjv.addSchema(externalSchemas[key], key)
+      }
+    }
+    return function validatorCompiler ({ schema }) {
+      return customAjv.compile(schema)
+    }
+  }
+  const server = Fastify({
+    schemaController: {
+      compilersFactory: {
+        buildValidator: rootBuildValidator,
+        buildSerializer: rootBuildSerializer
+      }
+    }
+  })
+
+  server.register((instance, _, done) => {
+    instance.register((subInstance, _, subDone) => {
+      subInstance.setSchemaController({
+        compilersFactory: {
+          buildSerializer: function (externalSchemas) {
+            childSerializerCalled++
+            return function serializerCompiler () {
+              return data => {
+                return JSON.stringify({
+                  statusCode: data.statusCode,
+                  message: data.message
+                })
+              }
+            }
+          }
+        }
+      })
+
+      subInstance.get(
+        '/',
+        {
+          schema: {
+            querystring: {
+              msg: {
+                $ref: 'some#'
+              }
+            },
+            response: {
+              '4xx': {
+                $ref: 'error_response#'
+              }
+            }
+          }
+        },
+        (req, reply) => {
+          reply.send({ noop: 'noop' })
+        }
+      )
+
+      subDone()
+    })
+
+    done()
+  })
+
+  server.addSchema(someSchema)
+  server.addSchema(errorResponseSchema)
+
+  const res = await server.inject({
+    method: 'GET',
+    url: '/',
+    query: {
+      msg: ['string']
+    }
+  })
+  const json = res.json()
+
+  t.equal(json.statusCode, 400)
+  t.equal(json.message, 'querystring.msg should be array')
+  t.equal(rootSerializerCalled, 0, 'Should be called from the child')
+  t.equal(rootValidatorCalled, 1, 'Should not be called from the child')
+  t.equal(childSerializerCalled, 1, 'Should be called from the child')
+  t.equal(res.statusCode, 400, 'Should not coearce the string into array')
+})
+
+test('Should throw if not default validator passed', async t => {
+  t.plan(4)
+  const customAjv = new Ajv({ coerceTypes: false })
+  const someSchema = {
+    $id: 'some',
+    type: 'array',
+    items: {
+      type: 'string'
+    }
+  }
+  const anotherSchema = {
+    $id: 'another',
+    type: 'integer'
+  }
+  const plugin = fp(function (pluginInstance, _, pluginDone) {
+    pluginInstance.setSchemaController({
+      compilersFactory: {
+        buildValidator: function (externalSchemas) {
+          const schemaKeys = Object.keys(externalSchemas)
+          t.equal(schemaKeys.length, 2)
+          t.same(schemaKeys, ['some', 'another'])
+
+          for (const key of schemaKeys) {
+            if (customAjv.getSchema(key) == null) {
+              customAjv.addSchema(externalSchemas[key], key)
+            }
+          }
+          return function validatorCompiler ({ schema }) {
+            return customAjv.compile(schema)
+          }
+        }
+      }
+    })
+
+    pluginDone()
+  })
+  const server = Fastify()
+
+  server.addSchema(someSchema)
+
+  server.register((instance, opts, done) => {
+    instance.addSchema(anotherSchema)
+
+    instance.register(plugin, {})
+
+    instance.post(
+      '/',
+      {
+        schema: {
+          query: {
+            msg: {
+              $ref: 'some#'
+            }
+          },
+          headers: {
+            'x-another': {
+              $ref: 'another#'
+            }
+          }
+        }
+      },
+      (req, reply) => {
+        reply.send({ noop: 'noop' })
+      }
+    )
+
+    done()
+  })
+
+  try {
+    const res = await server.inject({
+      method: 'POST',
+      url: '/',
+      query: {
+        msg: ['string']
+      }
+    })
+
+    t.equal(res.json().message, 'querystring.msg should be array')
+    t.equal(res.statusCode, 400, 'Should not coearce the string into array')
+  } catch (err) {
+    t.error(err)
+  }
+})
+
+test('Should throw if not default validator passed', async t => {
+  t.plan(2)
+  const someSchema = {
+    $id: 'some',
+    type: 'array',
+    items: {
+      type: 'string'
+    }
+  }
+  const anotherSchema = {
+    $id: 'another',
+    type: 'integer'
+  }
+
+  const server = Fastify()
+
+  server.addSchema(someSchema)
+
+  server.register((instance, opts, done) => {
+    instance.addSchema(anotherSchema)
+
+    instance.post(
+      '/',
+      {
+        schema: {
+          query: {
+            msg: {
+              $ref: 'some#'
+            }
+          },
+          headers: {
+            'x-another': {
+              $ref: 'another#'
+            }
+          }
+        }
+      },
+      (req, reply) => {
+        reply.send({ noop: 'noop' })
+      }
+    )
+
+    done()
+  })
+
+  try {
+    const res = await server.inject({
+      method: 'POST',
+      url: '/',
+      query: {
+        msg: ['string']
+      }
+    })
+
+    t.equal(res.json().message, 'querystring.msg should be array')
+    t.equal(res.statusCode, 400, 'Should not coearce the string into array')
+  } catch (err) {
+    t.error(err)
+  }
+})

package/test/stream.test.js

@@ -16,6 +16,15 @@ const Readable = require('stream').Readable
 const split = require('split2')
 const { kDisableRequestLogging, kReplySent } = require('../lib/symbols.js')
 
+function getUrl (app) {
+  const { address, port } = app.server.address()
+  if (address === '::1') {
+    return `http://[${address}]:${port}`
+  } else {
+    return `http://${address}:${port}`
+  }
+}
+
 test('should respond with a stream', t => {
   t.plan(8)
   const fastify = Fastify()
@@ -573,7 +582,7 @@ test('return a 404 if the stream emits a 404 error', t => {
   })
 })
 
-test('should support send module 200 and 404', t => {
+test('should support send module 200 and 404', { only: true }, t => {
   t.plan(8)
   const fastify = Fastify()
 
@@ -591,7 +600,9 @@ test('should support send module 200 and 404', t => {
     t.error(err)
     fastify.server.unref()
 
-    sget(`http://localhost:${fastify.server.address().port}`, function (err, response, data) {
+    const url = getUrl(fastify)
+
+    sget(url, function (err, response, data) {
       t.error(err)
       t.equal(response.headers['content-type'], 'application/octet-stream')
       t.equal(response.statusCode, 200)
@@ -602,7 +613,7 @@ test('should support send module 200 and 404', t => {
       })
     })
 
-    sget(`http://localhost:${fastify.server.address().port}/error`, function (err, response) {
+    sget(url + '/error', function (err, response) {
       t.error(err)
       t.equal(response.statusCode, 404)
     })

package/test/trust-proxy.test.js

@@ -1,9 +1,10 @@
 'use strict'
 
 const t = require('tap')
-const test = t.test
+const { test, before } = t
 const sget = require('simple-get').concat
 const fastify = require('..')
+const dns = require('dns').promises
 
 const sgetForwardedRequest = (app, forHeader, path, protoHeader) => {
   const headers = {
@@ -38,6 +39,13 @@ const testRequestValues = (t, req, options) => {
   }
 }
 
+let localhost
+
+before(async function () {
+  const lookup = await dns.lookup('localhost')
+  localhost = lookup.address
+})
+
 test('trust proxy, not add properties to node req', (t) => {
   t.plan(8)
   const app = fastify({
@@ -49,7 +57,7 @@ test('trust proxy, not add properties to node req', (t) => {
   })
 
   app.get('/trustproxychain', function (req, reply) {
-    testRequestValues(t, req, { ip: '2.2.2.2', ips: ['127.0.0.1', '1.1.1.1', '2.2.2.2'] })
+    testRequestValues(t, req, { ip: '2.2.2.2', ips: [localhost, '1.1.1.1', '2.2.2.2'] })
     reply.code(200).send({ ip: req.ip, hostname: req.hostname })
   })
 
@@ -66,7 +74,7 @@ test('trust proxy, not add properties to node req', (t) => {
 test('trust proxy chain', (t) => {
   t.plan(3)
   const app = fastify({
-    trustProxy: ['127.0.0.1', '192.168.1.1']
+    trustProxy: [localhost, '192.168.1.1']
   })
 
   app.get('/trustproxychain', function (req, reply) {
@@ -86,7 +94,7 @@ test('trust proxy chain', (t) => {
 test('trust proxy function', (t) => {
   t.plan(3)
   const app = fastify({
-    trustProxy: (address) => address === '127.0.0.1'
+    trustProxy: (address) => address === localhost
   })
   app.get('/trustproxyfunc', function (req, reply) {
     testRequestValues(t, req, { ip: '1.1.1.1' })
@@ -108,7 +116,7 @@ test('trust proxy number', (t) => {
     trustProxy: 1
   })
   app.get('/trustproxynumber', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', ips: ['127.0.0.1', '1.1.1.1'] })
+    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'] })
     reply.code(200).send({ ip: req.ip, hostname: req.hostname })
   })
 
@@ -124,10 +132,10 @@ test('trust proxy number', (t) => {
 test('trust proxy IP addresses', (t) => {
   t.plan(4)
   const app = fastify({
-    trustProxy: '127.0.0.1, 2.2.2.2'
+    trustProxy: `${localhost}, 2.2.2.2`
   })
   app.get('/trustproxyipaddrs', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', ips: ['127.0.0.1', '1.1.1.1'] })
+    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'] })
     reply.code(200).send({ ip: req.ip, hostname: req.hostname })
   })
 

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

@@ -3,7 +3,8 @@ import fastify, {
   FastifyError,
   FastifyInstance,
   RawReplyDefaultExpression,
-  RawRequestDefaultExpression
+  RawRequestDefaultExpression,
+  RawServerDefault
 } from '../../fastify'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import { FastifyRequest } from '../../types/request'
@@ -51,6 +52,50 @@ server.setErrorHandler(nodeJSErrorHandler)
 function asyncNodeJSErrorHandler (error: NodeJS.ErrnoException) {}
 server.setErrorHandler(asyncNodeJSErrorHandler)
 
+class CustomError extends Error {
+  private __brand: any;
+}
+interface ReplyPayload {
+  Reply: {
+    test: boolean;
+  };
+}
+// typed sync error handler
+server.setErrorHandler<CustomError, ReplyPayload>((error, request, reply) => {
+  expectType<CustomError>(error)
+  expectType<((payload?: ReplyPayload['Reply']) => FastifyReply<RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>, ReplyPayload>)>(reply.send)
+})
+// typed async error handler send
+server.setErrorHandler<CustomError, ReplyPayload>(async (error, request, reply) => {
+  expectType<CustomError>(error)
+  expectType<((payload?: ReplyPayload['Reply']) => FastifyReply<RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>, ReplyPayload>)>(reply.send)
+})
+// typed async error handler return
+server.setErrorHandler<CustomError, ReplyPayload>(async (error, request, reply) => {
+  expectType<CustomError>(error)
+  return { test: true }
+})
+// typed sync error handler send error
+expectError(server.setErrorHandler<CustomError, ReplyPayload>((error, request, reply) => {
+  expectType<CustomError>(error)
+  reply.send({ test: 'foo' })
+}))
+// typed sync error handler return error
+expectError(server.setErrorHandler<CustomError, ReplyPayload>((error, request, reply) => {
+  expectType<CustomError>(error)
+  return { test: 'foo' }
+}))
+// typed async error handler send error
+expectError(server.setErrorHandler<CustomError, ReplyPayload>(async (error, request, reply) => {
+  expectType<CustomError>(error)
+  reply.send({ test: 'foo' })
+}))
+// typed async error handler return error
+expectError(server.setErrorHandler<CustomError, ReplyPayload>(async (error, request, reply) => {
+  expectType<CustomError>(error)
+  return { test: 'foo' }
+}))
+
 function notFoundHandler (request: FastifyRequest, reply: FastifyReply) {}
 function notFoundpreHandlerHandler (request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction) { done() }
 async function notFoundpreHandlerAsyncHandler (request: FastifyRequest, reply: FastifyReply) {}
@@ -90,6 +135,12 @@ expectAssignable<void>(server.listen('3000', '', (err, address) => {}))
 expectAssignable<void>(server.listen(3000, (err, address) => {}))
 expectAssignable<void>(server.listen('3000', (err, address) => {}))
 
+// test listen method callback types
+expectAssignable<void>(server.listen('3000', (err, address) => {
+  expectAssignable<Error|null>(err)
+  expectAssignable<string>(address)
+}))
+
 // test listen method promise
 expectAssignable<PromiseLike<string>>(server.listen(3000))
 expectAssignable<PromiseLike<string>>(server.listen('3000'))

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

@@ -1,5 +1,5 @@
 import { expectType } from 'tsd'
-import fastify, { RouteHandler, RawRequestDefaultExpression, RequestBodyDefault, RequestGenericInterface } from '../../fastify'
+import fastify, { RouteHandler, RawRequestDefaultExpression, RequestBodyDefault, RequestGenericInterface, FastifyContext, ContextConfigDefault, FastifyContextConfig } from '../../fastify'
 import { RequestParamsDefault, RequestHeadersDefault, RequestQuerystringDefault } from '../../types/utils'
 import { FastifyLoggerInstance } from '../../types/logger'
 import { FastifyRequest } from '../../types/request'
@@ -50,6 +50,8 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<RawRequestDefaultExpression>(request.raw)
   expectType<RequestBodyDefault>(request.body)
   expectType<RequestParamsDefault>(request.params)
+  expectType<FastifyContext<ContextConfigDefault>>(request.context)
+  expectType<FastifyContextConfig>(request.context.config)
 
   expectType<RequestHeadersDefault & RawRequestDefaultExpression['headers']>(request.headers)
   request.headers = {}
@@ -72,6 +74,8 @@ const postHandler: Handler = function (request) {
   expectType<number>(request.params.id)
   expectType<string>(request.headers['x-foobar'])
   expectType<FastifyInstance>(request.server)
+  expectType<FastifyContext<ContextConfigDefault>>(request.context)
+  expectType<FastifyContextConfig>(request.context.config)
 }
 
 function putHandler (request: CustomRequest, reply: FastifyReply) {
@@ -84,6 +88,8 @@ function putHandler (request: CustomRequest, reply: FastifyReply) {
   expectType<number>(request.params.id)
   expectType<string>(request.headers['x-foobar'])
   expectType<FastifyInstance>(request.server)
+  expectType<FastifyContext<ContextConfigDefault>>(request.context)
+  expectType<FastifyContextConfig>(request.context.config)
 }
 
 const server = fastify()