fastify 3.11.0 → 3.14.1

package/test/schema-feature.test.js

@@ -3,7 +3,7 @@
 const { test } = require('tap')
 const Fastify = require('..')
 const fp = require('fastify-plugin')
-const { kSchemas } = require('../lib/symbols.js')
+const { kSchemaController } = require('../lib/symbols.js')
 
 const echoParams = (req, reply) => { reply.send(req.params) }
 const echoBody = (req, reply) => { reply.send(req.body) }
@@ -38,7 +38,7 @@ test('The schemas should be added to an internal storage', t => {
   const fastify = Fastify()
   const schema = { $id: 'id', my: 'schema' }
   fastify.addSchema(schema)
-  t.deepEqual(fastify[kSchemas].store, { id: schema })
+  t.deepEqual(fastify[kSchemaController].schemaBucket.store, { id: schema })
 })
 
 test('The schemas should be accessible via getSchemas', t => {
@@ -121,8 +121,8 @@ test('Get compilers is empty when settle on routes', t => {
     url: '/'
   }, (err, res) => {
     t.error(err)
-    t.equal(fastify.validatorCompiler, null)
-    t.equal(fastify.serializerCompiler, null)
+    t.equal(fastify.validatorCompiler, undefined)
+    t.equal(fastify.serializerCompiler, undefined)
   })
 })
 
@@ -1159,3 +1159,133 @@ test('The schema compiler recreate itself if needed', t => {
 
   fastify.ready(err => { t.error(err) })
 })
+
+test('Schema controller setter', t => {
+  t.plan(2)
+  Fastify({ schemaController: {} })
+  t.pass('allow empty object')
+
+  try {
+    Fastify({ schemaController: { bucket: {} } })
+    t.fail('the bucket option must be a function')
+  } catch (err) {
+    t.is(err.message, "schemaController.bucket option should be a function, instead got 'object'")
+  }
+})
+
+test('Schema controller bucket', t => {
+  t.plan(10)
+
+  let added = 0
+  let builtBucket = 0
+
+  const initStoreQueue = []
+
+  function factoryBucket (storeInit) {
+    builtBucket++
+    t.deepEqual(initStoreQueue.pop(), storeInit)
+    const store = new Map(storeInit)
+    return {
+      add (schema) {
+        added++
+        store.set(schema.$id, schema)
+      },
+      getSchema (id) {
+        return store.get(id)
+      },
+      getSchemas () {
+        // what is returned by this function, will be the `storeInit` parameter
+        initStoreQueue.push(store)
+        return store
+      }
+    }
+  }
+
+  const fastify = Fastify({
+    schemaController: {
+      bucket: factoryBucket
+    }
+  })
+
+  fastify.register(async (instance) => {
+    instance.addSchema({ $id: 'b', type: 'string' })
+    instance.addHook('onReady', function (done) {
+      t.equals(instance.getSchemas().size, 2)
+      done()
+    })
+    instance.register(async (subinstance) => {
+      subinstance.addSchema({ $id: 'c', type: 'string' })
+      subinstance.addHook('onReady', function (done) {
+        t.equals(subinstance.getSchemas().size, 3)
+        done()
+      })
+    })
+  })
+
+  fastify.register(async (instance) => {
+    instance.addHook('onReady', function (done) {
+      t.equals(instance.getSchemas().size, 1)
+      done()
+    })
+  })
+
+  fastify.addSchema({ $id: 'a', type: 'string' })
+
+  fastify.ready(err => {
+    t.error(err)
+    t.equals(added, 3, 'three schema added')
+    t.equals(builtBucket, 4, 'one bucket built for every register call + 1 for the root instance')
+  })
+})
+
+test('setSchemaController per instance', t => {
+  t.plan(7)
+  const fastify = Fastify({})
+
+  fastify.register(async (instance1) => {
+    instance1.setSchemaController({
+      bucket: function factoryBucket (storeInit) {
+        t.pass('instance1 has created the bucket')
+        return {
+          add (schema) { t.fail('add is not called') },
+          getSchema (id) { t.fail('getSchema is not called') },
+          getSchemas () { t.fail('getSchemas is not called') }
+        }
+      }
+    })
+  })
+
+  fastify.register(async (instance2) => {
+    const bSchema = { $id: 'b', type: 'string' }
+
+    instance2.setSchemaController({
+      bucket: function factoryBucket (storeInit) {
+        t.pass('instance2 has created the bucket')
+        const map = {}
+        return {
+          add (schema) {
+            t.equals(schema.$id, bSchema.$id, 'add is called')
+            map[schema.$id] = schema
+          },
+          getSchema (id) {
+            t.pass('getSchema is called')
+            return map[id]
+          },
+          getSchemas () {
+            t.pass('getSchemas is called')
+          }
+        }
+      }
+    })
+
+    instance2.addSchema(bSchema)
+
+    instance2.addHook('onReady', function (done) {
+      instance2.getSchemas()
+      t.deepEquals(instance2.getSchema('b'), bSchema, 'the schema are loaded')
+      done()
+    })
+  })
+
+  fastify.ready(err => { t.error(err) })
+})

package/test/schema-serialization.test.js

@@ -498,3 +498,45 @@ test('The schema changes the default error handler output', async t => {
   t.equals(res.statusCode, 500)
   t.deepEquals(res.json(), { error: 'Internal Server Error', message: '500 message', customId: 42 })
 })
+
+test('do not crash if status code serializer errors', async t => {
+  const fastify = Fastify()
+
+  const requiresFoo = {
+    properties: { foo: { type: 'string' } },
+    required: ['foo']
+  }
+
+  const someUserErrorType2 = {
+    properties: {
+      code: { type: 'number' }
+    },
+    required: ['code']
+  }
+
+  fastify.get(
+    '/',
+    {
+      schema: {
+        query: requiresFoo,
+        response: { 400: someUserErrorType2 }
+      }
+    },
+    (request, reply) => {
+      t.fail('handler, should not be called')
+    }
+  )
+
+  const res = await fastify.inject({
+    path: '/',
+    query: {
+      notfoo: true
+    }
+  })
+  t.equals(res.statusCode, 500)
+  t.deepEquals(res.json(), {
+    statusCode: 500,
+    error: 'Internal Server Error',
+    message: '"code" is required!'
+  })
+})

package/test/schema-special-usage.test.js

@@ -1,6 +1,8 @@
 'use strict'
 
 const { test } = require('tap')
+const AJV = require('ajv')
+const S = require('fluent-json-schema')
 const Fastify = require('..')
 const ajvMergePatch = require('ajv-merge-patch')
 
@@ -221,3 +223,235 @@ test('Should handle $patch keywords in body', t => {
     })
   })
 })
+
+test("serializer read validator's schemas", t => {
+  t.plan(4)
+  const ajvInstance = new AJV()
+
+  const baseSchema = {
+    $id: 'http://example.com/schemas/base',
+    definitions: {
+      hello: { type: 'string' }
+    },
+    type: 'object',
+    properties: {
+      hello: { $ref: '#/definitions/hello' }
+    }
+  }
+
+  const refSchema = {
+    $id: 'http://example.com/schemas/ref',
+    type: 'object',
+    properties: {
+      hello: { $ref: 'http://example.com/schemas/base#/definitions/hello' }
+    }
+  }
+
+  ajvInstance.addSchema(baseSchema)
+  ajvInstance.addSchema(refSchema)
+
+  const fastify = Fastify({
+    schemaController: {
+      bucket: function factory (storeInit) {
+        t.notOk(storeInit, 'is is always empty because fastify.addSchema is not called')
+        return {
+          getSchemas () {
+            return {
+              [baseSchema.$id]: ajvInstance.getSchema(baseSchema.$id).schema,
+              [refSchema.$id]: ajvInstance.getSchema(refSchema.$id).schema
+            }
+          }
+        }
+      }
+    }
+  })
+
+  fastify.setValidatorCompiler(function ({ schema }) {
+    return ajvInstance.compile(schema)
+  })
+
+  fastify.get('/', {
+    schema: {
+      response: {
+        '2xx': ajvInstance.getSchema('http://example.com/schemas/ref').schema
+      }
+    },
+    handler (req, res) { res.send({ hello: 'world', evict: 'this' }) }
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.error(err)
+    t.equals(res.statusCode, 200)
+    t.deepEquals(res.json(), { hello: 'world' })
+  })
+})
+
+test('setSchemaController in a plugin', t => {
+  t.plan(5)
+  const baseSchema = {
+    $id: 'urn:schema:base',
+    definitions: {
+      hello: { type: 'string' }
+    },
+    type: 'object',
+    properties: {
+      hello: { $ref: '#/definitions/hello' }
+    }
+  }
+
+  const refSchema = {
+    $id: 'urn:schema:ref',
+    type: 'object',
+    properties: {
+      hello: { $ref: 'urn:schema:base#/definitions/hello' }
+    }
+  }
+
+  const ajvInstance = new AJV()
+  ajvInstance.addSchema(baseSchema)
+  ajvInstance.addSchema(refSchema)
+
+  const fastify = Fastify()
+  fastify.register(schemaPlugin)
+  fastify.get('/', {
+    schema: {
+      query: ajvInstance.getSchema('urn:schema:ref').schema,
+      response: {
+        '2xx': ajvInstance.getSchema('urn:schema:ref').schema
+      }
+    },
+    handler (req, res) {
+      res.send({ hello: 'world', evict: 'this' })
+    }
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.error(err)
+    t.equals(res.statusCode, 200)
+    t.deepEquals(res.json(), { hello: 'world' })
+  })
+
+  async function schemaPlugin (server) {
+    server.setSchemaController({
+      bucket () {
+        t.pass('the bucket is created')
+        return {
+          addSchema (source) {
+            ajvInstance.addSchema(source)
+          },
+          getSchema (id) {
+            return ajvInstance.getSchema(id).schema
+          },
+          getSchemas () {
+            return {
+              'urn:schema:base': baseSchema,
+              'urn:schema:ref': refSchema
+            }
+          }
+        }
+      }
+    })
+    server.setValidatorCompiler(function ({ schema }) {
+      t.pass('the querystring schema is compiled')
+      return ajvInstance.compile(schema)
+    })
+  }
+  schemaPlugin[Symbol.for('skip-override')] = true
+})
+
+test('side effect on schema let the server crash', async t => {
+  const firstSchema = {
+    $id: 'example1',
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string'
+      }
+    }
+  }
+
+  const reusedSchema = {
+    $id: 'example2',
+    type: 'object',
+    properties: {
+      name: {
+        oneOf: [
+          {
+            $ref: 'example1'
+          }
+        ]
+      }
+    }
+  }
+
+  const fastify = Fastify()
+  fastify.addSchema(firstSchema)
+
+  fastify.post('/a', {
+    handler: async () => 'OK',
+    schema: {
+      body: reusedSchema,
+      response: { 200: reusedSchema }
+    }
+  })
+  fastify.post('/b', {
+    handler: async () => 'OK',
+    schema: {
+      body: reusedSchema,
+      response: { 200: reusedSchema }
+    }
+  })
+
+  await fastify.ready()
+})
+
+test('only response schema trigger AJV pollution', async t => {
+  const ShowSchema = S.object().id('ShowSchema').prop('name', S.string())
+  const ListSchema = S.array().id('ListSchema').items(S.ref('ShowSchema#'))
+
+  const fastify = Fastify()
+  fastify.addSchema(ListSchema)
+  fastify.addSchema(ShowSchema)
+
+  const routeResponseSchemas = {
+    schema: { response: { 200: S.ref('ListSchema#') } }
+  }
+
+  fastify.register(
+    async (app) => { app.get('/resource/', routeResponseSchemas, () => ({})) },
+    { prefix: '/prefix1' }
+  )
+  fastify.register(
+    async (app) => { app.get('/resource/', routeResponseSchemas, () => ({})) },
+    { prefix: '/prefix2' }
+  )
+
+  await fastify.ready()
+})
+
+test('only response schema trigger AJV pollution #2', async t => {
+  const ShowSchema = S.object().id('ShowSchema').prop('name', S.string())
+  const ListSchema = S.array().id('ListSchema').items(S.ref('ShowSchema#'))
+
+  const fastify = Fastify()
+  fastify.addSchema(ListSchema)
+  fastify.addSchema(ShowSchema)
+
+  const routeResponseSchemas = {
+    schema: {
+      params: S.ref('ListSchema#'),
+      response: { 200: S.ref('ListSchema#') }
+    }
+  }
+
+  fastify.register(
+    async (app) => { app.get('/resource/', routeResponseSchemas, () => ({})) },
+    { prefix: '/prefix1' }
+  )
+  fastify.register(
+    async (app) => { app.get('/resource/', routeResponseSchemas, () => ({})) },
+    { prefix: '/prefix2' }
+  )
+
+  await fastify.ready()
+})

package/test/schema-validation.test.js

@@ -178,7 +178,7 @@ test('Encapsulation', t => {
 
   fastify.register((instance, opts, done) => {
     instance.post('/clean', function (req, reply) {
-      t.equals(instance.validatorCompiler, null)
+      t.equals(instance.validatorCompiler, undefined)
       reply.send({ foo: 'bar' })
     })
     done()

package/test/stream.test.js

@@ -263,6 +263,68 @@ test('Destroying streams prematurely should call close method', t => {
   })
 })
 
+test('Destroying streams prematurely should call close method when destroy is not a function', t => {
+  t.plan(7)
+
+  let fastify = null
+  const logStream = split(JSON.parse)
+  try {
+    fastify = Fastify({
+      logger: {
+        stream: logStream,
+        level: 'info'
+      }
+    })
+  } catch (e) {
+    t.fail()
+  }
+  const stream = require('stream')
+  const http = require('http')
+
+  // Test that "premature close" errors are logged with level warn
+  logStream.on('data', line => {
+    if (line.res) {
+      t.equal(line.msg, 'stream closed prematurely')
+      t.equal(line.level, 30)
+    }
+  })
+
+  fastify.get('/', function (request, reply) {
+    t.pass('Received request')
+
+    let sent = false
+    const reallyLongStream = new stream.Readable({
+      read: function () {
+        if (!sent) {
+          this.push(Buffer.from('hello\n'))
+        }
+        sent = true
+      }
+    })
+    reallyLongStream.destroy = true
+    reallyLongStream.close = () => t.ok('called')
+    reply.send(reallyLongStream)
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.server.unref()
+
+    const port = fastify.server.address().port
+
+    http.get(`http://localhost:${port}`, function (response) {
+      t.strictEqual(response.statusCode, 200)
+      response.on('readable', function () {
+        response.destroy()
+      })
+      // Node bug? Node never emits 'close' here.
+      response.on('aborted', function () {
+        t.pass('Response closed')
+      })
+    })
+  })
+})
+
 test('Destroying streams prematurely should call abort method', t => {
   t.plan(7)
 
@@ -418,3 +480,31 @@ test('should support send module 200 and 404', t => {
     })
   })
 })
+
+test('should destroy stream when response is ended', t => {
+  t.plan(4)
+  const stream = require('stream')
+  const fastify = Fastify()
+
+  fastify.get('/error', function (req, reply) {
+    const reallyLongStream = new stream.Readable({
+      read: function () {},
+      destroy: function (err, callback) {
+        t.ok('called')
+        callback(err)
+      }
+    })
+    reply.code(200).send(reallyLongStream)
+    reply.raw.end(Buffer.from('hello\n'))
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.server.unref()
+
+    sget(`http://localhost:${fastify.server.address().port}/error`, function (err, response) {
+      t.error(err)
+      t.strictEqual(response.statusCode, 200)
+    })
+  })
+})

package/test/throw.test.js

@@ -21,7 +21,7 @@ test('Fastify should throw on multiple assignment to the same route', t => {
   fastify.get('/', () => {})
 
   fastify.ready(err => {
-    t.is(err.message, "Method 'GET' already declared for route '/'")
+    t.is(err.message, "Method 'GET' already declared for route '/' with constraints '{}'")
   })
 })
 

package/test/types/content-type-parser.test-d.ts

@@ -1,5 +1,5 @@
-import fastify from '../../fastify'
-import { expectType } from 'tsd'
+import fastify, { FastifyContentTypeParser } from '../../fastify'
+import { expectError, expectType } from 'tsd'
 import { IncomingMessage } from 'http'
 import { FastifyRequest } from '../../types/request'
 
@@ -56,3 +56,9 @@ expectType<void>(fastify().addContentTypeParser<Buffer>('bodyContentType', { par
   expectType<Buffer>(body)
   return null
 }))
+
+expectType<FastifyContentTypeParser>(fastify().getDefaultJsonParser('error', 'ignore'))
+
+expectError(fastify().getDefaultJsonParser('error', 'skip'))
+
+expectError(fastify().getDefaultJsonParser('nothing', 'ignore'))

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

@@ -98,6 +98,33 @@ expectAssignable<FastifyInstance>(fastify({
     deriveVersion: () => 'foo'
   }
 }))
+expectAssignable<FastifyInstance>(fastify({ constraints: {} }))
+expectAssignable<FastifyInstance>(fastify({
+  constraints: {
+    version: {
+      name: 'version',
+      storage: () => ({
+        get: () => () => {},
+        set: () => { },
+        del: () => { },
+        empty: () => { }
+      }),
+      validate () {},
+      deriveConstraint: () => 'foo'
+    },
+    host: {
+      name: 'host',
+      storage: () => ({
+        get: () => () => {},
+        set: () => { },
+        del: () => { },
+        empty: () => { }
+      }),
+      validate () {},
+      deriveConstraint: () => 'foo'
+    }
+  }
+}))
 expectAssignable<FastifyInstance>(fastify({ return503OnClosing: true }))
 expectAssignable<FastifyInstance>(fastify({
   ajv: {

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

@@ -1,5 +1,8 @@
-import fastify, { FastifyError, FastifyInstance, ValidationResult } from '../../fastify'
+import fastify, { FastifyContentTypeParser, FastifyError, FastifyInstance, ValidationResult } from '../../fastify'
 import { expectAssignable, expectError, expectType } from 'tsd'
+import { FastifyRequest } from '../../types/request'
+import { FastifyReply } from '../../types/reply'
+import { HookHandlerDoneFunction } from '../../types/hooks'
 
 const server = fastify()
 
@@ -15,6 +18,8 @@ expectAssignable<FastifyInstance>(server.addSchema({
 
 expectType<Record<string, unknown>>(server.getSchemas())
 expectType<unknown>(server.getSchema('SchemaId'))
+expectType<string>(server.printRoutes())
+expectType<string>(server.printPlugins())
 
 expectAssignable<FastifyInstance>(
   server.setErrorHandler(function (error, request, reply) {
@@ -36,6 +41,19 @@ server.setErrorHandler(fastifyErrorHandler)
 function nodeJSErrorHandler (error: NodeJS.ErrnoException) {}
 server.setErrorHandler(nodeJSErrorHandler)
 
+function notFoundHandler (request: FastifyRequest, reply: FastifyReply) {}
+function notFoundpreHandlerHandler (request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction) { done() }
+async function notFoundpreHandlerAsyncHandler (request: FastifyRequest, reply: FastifyReply) {}
+function notFoundpreValidationHandler (request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction) { done() }
+async function notFoundpreValidationAsyncHandler (request: FastifyRequest, reply: FastifyReply) {}
+
+server.setNotFoundHandler(notFoundHandler)
+server.setNotFoundHandler({ preHandler: notFoundpreHandlerHandler }, notFoundHandler)
+server.setNotFoundHandler({ preHandler: notFoundpreHandlerAsyncHandler }, notFoundHandler)
+server.setNotFoundHandler({ preValidation: notFoundpreValidationHandler }, notFoundHandler)
+server.setNotFoundHandler({ preValidation: notFoundpreValidationAsyncHandler }, notFoundHandler)
+server.setNotFoundHandler({ preHandler: notFoundpreHandlerHandler, preValidation: notFoundpreValidationHandler }, notFoundHandler)
+
 function invalidErrorHandler (error: number) {}
 expectError(server.setErrorHandler(invalidErrorHandler))
 
@@ -84,3 +102,27 @@ expectType<FastifyInstance>(fastify().get('/', {
     expectAssignable<void>(server.errorHandler(error, request, reply))
   }
 }))
+
+type InitialConfig = Readonly<{
+  connectionTimeout?: number,
+  keepAliveTimeout?: number,
+  bodyLimit?: number,
+  caseSensitive?: boolean,
+  http2?: boolean,
+  https?: boolean | Readonly<{ allowHTTP1: boolean }>,
+  ignoreTrailingSlash?: boolean,
+  disableRequestLogging?: boolean,
+  maxParamLength?: number,
+  onProtoPoisoning?: 'error' | 'remove' | 'ignore',
+  onConstructorPoisoning?: 'error' | 'remove' | 'ignore',
+  pluginTimeout?: number,
+  requestIdHeader?: string,
+  requestIdLogLabel?: string,
+  http2SessionTimeout?: number
+}>
+
+expectType<InitialConfig>(fastify().initialConfig)
+
+expectType<FastifyContentTypeParser>(server.defaultTextParser)
+
+expectType<FastifyContentTypeParser>(server.getDefaultJsonParser('ignore', 'error'))