fastify 3.27.2 → 4.0.0-alpha.1

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

@@ -1,27 +1,27 @@
 'use strict'
 
 const { test } = require('tap')
-const Joi = require('@hapi/joi')
+const Joi = require('joi')
 const AJV = require('ajv')
 const S = require('fluent-json-schema')
 const Fastify = require('..')
 const ajvMergePatch = require('ajv-merge-patch')
 const ajvErrors = require('ajv-errors')
 
-const buildValidatorAJV8 = require('@fastify/ajv-compiler-8')
+const buildValidatorAJV6 = require('@fastify/ajv-compiler-6')
 
-test('Ajv8 usage instead of the bundle one', t => {
+test('Ajv6 usage instead of the bundle one', t => {
   t.plan(2)
 
-  t.test('use new ajv8 option', t => {
+  t.test('use old ajv6 option', t => {
     t.plan(2)
     const fastify = Fastify({
       ajv: {
-        customOptions: { strictRequired: true }
+        customOptions: { jsonPointers: true }
       },
       schemaController: {
         compilersFactory: {
-          buildValidator: buildValidatorAJV8()
+          buildValidator: buildValidatorAJV6()
         }
       }
     })
@@ -42,17 +42,17 @@ test('Ajv8 usage instead of the bundle one', t => {
     })
 
     fastify.ready(err => {
-      t.ok(err)
-      t.match(err.message, 'strictRequired', 'the new ajv8 option trigger a startup error')
+      t.error(err)
+      t.pass('the removed ajv6 option let the startup pass')
     })
   })
 
-  t.test('use new ajv8 option within a response schema', t => {
+  t.test('use old ajv6 option within a response schema', t => {
     t.plan(2)
     const fastify = Fastify({
       schemaController: {
         compilersFactory: {
-          buildValidator: buildValidatorAJV8()
+          buildValidator: buildValidatorAJV6()
         }
       }
     })
@@ -89,79 +89,11 @@ test('Ajv8 usage instead of the bundle one', t => {
   })
 })
 
-test('Ajv8 usage with plugins', t => {
-  t.plan(2)
-
-  t.test('use new ajv8 option', t => {
-    t.plan(3)
-    const fastify = Fastify({
-      ajv: {
-        customOptions: { validateFormats: true },
-        plugins: [require('ajv-formats')]
-      },
-      schemaController: {
-        compilersFactory: {
-          buildValidator: buildValidatorAJV8()
-        }
-      }
-    })
-
-    callIt(fastify, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 400)
-      t.equal(res.json().message, 'body must match format "date"')
-    })
-  })
-
-  t.test('use new ajv8 option - avoid check', t => {
-    t.plan(2)
-    const fastify = Fastify({
-      ajv: {
-        customOptions: { validateFormats: false }
-      },
-      schemaController: {
-        compilersFactory: {
-          buildValidator: buildValidatorAJV8()
-        }
-      }
-    })
-
-    callIt(fastify, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 200)
-    })
-  })
-
-  function callIt (fastify, cb) {
-    fastify.post('/', {
-      schema: {
-        body: {
-          type: 'object',
-          properties: {
-            foo: {
-              type: 'string',
-              format: 'date'
-            }
-          }
-        }
-      },
-      handler (req, reply) { reply.send({ ok: 1 }) }
-    })
-
-    fastify.inject({
-      method: 'POST',
-      url: '/',
-      payload: { foo: '99' }
-    }, cb)
-  }
-})
-
 test('Ajv plugins array parameter', t => {
   t.plan(3)
   const fastify = Fastify({
     ajv: {
       customOptions: {
-        jsonPointers: true,
         allErrors: true
       },
       plugins: [
@@ -509,7 +441,7 @@ test('setSchemaController in a plugin', t => {
   ajvInstance.addSchema(baseSchema)
   ajvInstance.addSchema(refSchema)
 
-  const fastify = Fastify()
+  const fastify = Fastify({ exposeHeadRoutes: false })
   fastify.register(schemaPlugin)
   fastify.get('/', {
     schema: {
@@ -760,7 +692,8 @@ test('multiple refs with the same ids', t => {
 
   fastify.addSchema(baseSchema)
   fastify.addSchema(refSchema)
-  fastify.get('/', {
+
+  fastify.head('/', {
     schema: {
       query: refSchema,
       response: {
@@ -772,7 +705,7 @@ test('multiple refs with the same ids', t => {
     }
   })
 
-  fastify.head('/', {
+  fastify.get('/', {
     schema: {
       query: refSchema,
       response: {

package/test/schema-validation.test.js

@@ -99,7 +99,7 @@ test('Basic validation test', t => {
     url: '/'
   }, (err, res) => {
     t.error(err)
-    t.same(res.json(), { statusCode: 400, error: 'Bad Request', message: "body should have required property 'work'" })
+    t.same(res.json(), { statusCode: 400, error: 'Bad Request', message: "body must have required property 'work'" })
     t.equal(res.statusCode, 400)
   })
 })
@@ -314,7 +314,7 @@ test('Triple $ref with a simple $id', t => {
   }, (err, res) => {
     t.error(err)
     t.equal(res.statusCode, 400)
-    t.same(res.json().message, "body should have required property 'foo'")
+    t.same(res.json().message, "body must have required property 'foo'")
   })
 })
 
@@ -348,6 +348,7 @@ test('Extending schema', t => {
             allOf: [
               { $ref: 'address.id#/definitions/address' },
               {
+                type: 'object',
                 properties: { type: { enum: ['residential', 'business'] } },
                 required: ['type']
               }
@@ -439,7 +440,7 @@ test('Should work with nested ids', t => {
   }, (err, res) => {
     t.error(err)
     t.equal(res.statusCode, 400)
-    t.equal(res.json().message, 'params.id should be number')
+    t.equal(res.json().message, 'params/id must be number')
   })
 })
 
@@ -536,7 +537,7 @@ test('JSON Schema validation keywords', t => {
     t.same(res.json(), {
       statusCode: 400,
       error: 'Bad Request',
-      message: 'params.ip should match format "ipv4"'
+      message: 'params/ip must match format "ipv4"'
     })
   })
 })
@@ -590,7 +591,7 @@ test('Nested id calls', t => {
     t.equal(res.statusCode, 400)
     t.same(res.json(), {
       error: 'Bad Request',
-      message: 'body.host.ip should match format "ipv4"',
+      message: 'body/host/ip must match format "ipv4"',
       statusCode: 400
     })
   })
@@ -692,7 +693,7 @@ test('Use shared schema and $ref with $id ($ref to $id)', t => {
     t.equal(res.statusCode, 400)
     t.same(res.json(), {
       error: 'Bad Request',
-      message: "body should have required property 'address'",
+      message: "body must have required property 'address'",
       statusCode: 400
     })
   })
@@ -712,8 +713,7 @@ test('Use items with $ref', t => {
 
   const body = {
     type: 'array',
-    items: { $ref: 'http://example.com/ref-to-external-validator.json#' },
-    default: []
+    items: { $ref: 'http://example.com/ref-to-external-validator.json#' }
   }
 
   fastify.post('/', {
@@ -809,7 +809,7 @@ test('Use $ref to /definitions', t => {
     t.equal(res.statusCode, 400)
     t.same(res.json(), {
       error: 'Bad Request',
-      message: 'body.test.id should be number',
+      message: 'body/test/id must be number',
       statusCode: 400
     })
   })

package/test/skip-reply-send.test.js

@@ -297,7 +297,7 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
       } else {
         app.addHook(hookOrHandler, async (req, reply) => {
           reply.hijack()
-          reply.send('hello from reply.send()')
+          return reply.send('hello from reply.send()')
         })
         app.get('/', (req, reply) => t.fail('Handler should not be called'))
       }

package/test/stream.test.js

@@ -14,7 +14,8 @@ const JSONStream = require('JSONStream')
 const send = require('send')
 const Readable = require('stream').Readable
 const split = require('split2')
-const { kDisableRequestLogging, kReplySent } = require('../lib/symbols.js')
+const semver = require('semver')
+const { kDisableRequestLogging } = require('../lib/symbols.js')
 
 function getUrl (app) {
   const { address, port } = app.server.address()
@@ -26,7 +27,7 @@ function getUrl (app) {
 }
 
 test('should respond with a stream', t => {
-  t.plan(8)
+  t.plan(6)
   const fastify = Fastify()
 
   fastify.get('/', function (req, reply) {
@@ -34,18 +35,13 @@ test('should respond with a stream', t => {
     reply.code(200).send(stream)
   })
 
-  fastify.get('/error', function (req, reply) {
-    const stream = fs.createReadStream('not-existing-file', 'utf8')
-    reply.code(200).send(stream)
-  })
-
   fastify.listen(0, err => {
     t.error(err)
     fastify.server.unref()
 
     sget(`http://localhost:${fastify.server.address().port}`, function (err, response, data) {
       t.error(err)
-      t.equal(response.headers['content-type'], 'application/octet-stream')
+      t.equal(response.headers['content-type'], undefined)
       t.equal(response.statusCode, 200)
 
       fs.readFile(__filename, (err, expected) => {
@@ -53,6 +49,21 @@ test('should respond with a stream', t => {
         t.equal(expected.toString(), data.toString())
       })
     })
+  })
+})
+
+test('should respond with a stream (error)', t => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.get('/error', function (req, reply) {
+    const stream = fs.createReadStream('not-existing-file', 'utf8')
+    reply.code(200).send(stream)
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.server.unref()
 
     sget(`http://localhost:${fastify.server.address().port}/error`, function (err, response) {
       t.error(err)
@@ -582,7 +593,7 @@ test('return a 404 if the stream emits a 404 error', t => {
   })
 })
 
-test('should support send module 200 and 404', { only: true }, t => {
+test('should support send module 200 and 404', { skip: semver.gte(process.versions.node, '17.0.0') }, t => {
   t.plan(8)
   const fastify = Fastify()
 
@@ -604,7 +615,7 @@ test('should support send module 200 and 404', { only: true }, t => {
 
     sget(url, function (err, response, data) {
       t.error(err)
-      t.equal(response.headers['content-type'], 'application/octet-stream')
+      t.equal(response.headers['content-type'], 'application/javascript; charset=UTF-8')
       t.equal(response.statusCode, 200)
 
       fs.readFile(__filename, (err, expected) => {
@@ -654,7 +665,7 @@ test('should mark reply as sent before pumping the payload stream into response
   const handleRequest = proxyquire('../lib/handleRequest', {
     './wrapThenable': (thenable, reply) => {
       thenable.then(function (payload) {
-        t.equal(reply[kReplySent], true)
+        t.equal(reply.sent, true)
       })
     }
   })
@@ -671,7 +682,7 @@ test('should mark reply as sent before pumping the payload stream into response
 
   fastify.get('/', async function (req, reply) {
     const stream = fs.createReadStream(__filename, 'utf8')
-    reply.code(200).send(stream)
+    return reply.code(200).send(stream)
   })
 
   fastify.inject({

package/test/throw.test.js

@@ -17,12 +17,15 @@ test('Fastify should throw on wrong options', t => {
 test('Fastify should throw on multiple assignment to the same route', t => {
   t.plan(1)
   const fastify = Fastify()
-  fastify.get('/', () => {})
+
   fastify.get('/', () => {})
 
-  fastify.ready(err => {
-    t.equal(err.message, "Method 'GET' already declared for route '/' with constraints '{}'")
-  })
+  try {
+    fastify.get('/', () => {})
+    t.fail('Should throw on duplicated route declaration')
+  } catch (error) {
+    t.equal(error.message, "Method 'GET' already declared for route '/'")
+  }
 })
 
 test('Fastify should throw for an invalid schema, printing the error route - headers', t => {
@@ -78,7 +81,7 @@ test('Fastify should throw for an invalid shorthand option type', t => {
     t.fail()
   } catch (e) {
     t.equal(e.code, 'FST_ERR_INIT_OPTS_INVALID')
-    t.match(e.message, /should be boolean/)
+    t.match(e.message, /must be boolean/)
     t.pass()
   }
 })

package/test/type-provider.test.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('..')
+
+test('Should export withTypeProvider function', t => {
+  t.plan(1)
+  try {
+    Fastify().withTypeProvider()
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('Should return same instance', t => {
+  t.plan(1)
+  const fastify = Fastify()
+  t.equal(fastify, fastify.withTypeProvider())
+})

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

@@ -7,7 +7,7 @@ import fastify, {
   LightMyRequestChain,
   LightMyRequestResponse,
   LightMyRequestCallback,
-  InjectOptions
+  InjectOptions, FastifyBaseLogger
 } from '../../fastify'
 import * as http from 'http'
 import * as https from 'https'
@@ -50,7 +50,9 @@ expectAssignable<InjectOptions>({ query: '' })
 fastify({ http2: true, https: {} }).inject().then((resp) => {
   expectAssignable<LightMyRequestResponse>(resp)
 })
-const lightMyRequestCallback: LightMyRequestCallback = (err: Error, response: LightMyRequestResponse) => {}
+const lightMyRequestCallback: LightMyRequestCallback = (err: Error, response: LightMyRequestResponse) => {
+  if (err) throw err
+}
 fastify({ http2: true, https: {} }).inject({}, lightMyRequestCallback)
 
 // server options
@@ -70,9 +72,9 @@ expectAssignable<FastifyInstance>(fastify({ serializerOpts: { rounding: 'ceil' }
 expectAssignable<FastifyInstance>(fastify({ serializerOpts: { ajv: { missingRefs: 'ignore' } } }))
 expectAssignable<FastifyInstance>(fastify({ serializerOpts: { schema: { } } }))
 expectAssignable<FastifyInstance>(fastify({ serializerOpts: { otherProp: { } } }))
-expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>(fastify({ logger: true }))
-expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyLoggerInstance>>(fastify({ logger: true }))
-expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyLoggerInstance>>(fastify({
+expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>>(fastify({ logger: true }))
+expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>>(fastify({ logger: true }))
+expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>>(fastify({
   logger: {
     level: 'info',
     genReqId: () => 'request-id',
@@ -103,6 +105,7 @@ expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerR
   }
 }))
 const customLogger = {
+  level: 'info',
   info: () => { },
   warn: () => { },
   error: () => { },
@@ -111,7 +114,7 @@ const customLogger = {
   debug: () => { },
   child: () => customLogger
 }
-expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyLoggerInstance>>(fastify({ logger: customLogger }))
+expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>>(fastify({ logger: customLogger }))
 expectAssignable<FastifyInstance>(fastify({ serverFactory: () => http.createServer() }))
 expectAssignable<FastifyInstance>(fastify({ caseSensitive: true }))
 expectAssignable<FastifyInstance>(fastify({ requestIdHeader: 'request-id' }))
@@ -174,24 +177,13 @@ expectAssignable<FastifyInstance>(fastify({ return503OnClosing: true }))
 expectAssignable<FastifyInstance>(fastify({
   ajv: {
     customOptions: {
-      nullable: false
+      removeAdditional: 'all'
     },
     plugins: [() => { }]
   }
 }))
 expectAssignable<FastifyInstance>(fastify({
   ajv: {
-    customOptions: {
-      nullable: false
-    },
-    plugins: [[() => { }, 'keyword']]
-  }
-}))
-expectAssignable<FastifyInstance>(fastify({
-  ajv: {
-    customOptions: {
-      nullable: false
-    },
     plugins: [[() => { }, ['keyword1', 'keyword2']]]
   }
 }))

package/test/types/import.js

@@ -0,0 +1,2 @@
+"use strict";
+exports.__esModule = true;

package/test/types/import.ts

@@ -0,0 +1 @@
+import { FastifyLogFn } from '../../fastify'

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

@@ -31,6 +31,7 @@ expectType<string>(server.printPlugins())
 
 expectAssignable<FastifyInstance>(
   server.setErrorHandler(function (error, request, reply) {
+    expectType<FastifyError>(error)
     expectAssignable<FastifyInstance>(this)
   })
 )
@@ -47,10 +48,14 @@ server.setErrorHandler(fastifyErrorHandler)
 async function asyncFastifyErrorHandler (this: FastifyInstance, error: FastifyError) {}
 server.setErrorHandler(asyncFastifyErrorHandler)
 
-function nodeJSErrorHandler (error: NodeJS.ErrnoException) {}
+function nodeJSErrorHandler (error: NodeJS.ErrnoException) {
+  if (error) { throw error }
+}
 server.setErrorHandler(nodeJSErrorHandler)
 
-function asyncNodeJSErrorHandler (error: NodeJS.ErrnoException) {}
+function asyncNodeJSErrorHandler (error: NodeJS.ErrnoException) {
+  if (error) { throw error }
+}
 server.setErrorHandler(asyncNodeJSErrorHandler)
 
 class CustomError extends Error {
@@ -82,20 +87,20 @@ expectError(server.setErrorHandler<CustomError, ReplyPayload>((error, request, r
   reply.send({ test: 'foo' })
 }))
 // typed sync error handler return error
-expectError(server.setErrorHandler<CustomError, ReplyPayload>((error, request, reply) => {
+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) => {
+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() }
@@ -110,7 +115,9 @@ server.setNotFoundHandler({ preValidation: notFoundpreValidationHandler }, notFo
 server.setNotFoundHandler({ preValidation: notFoundpreValidationAsyncHandler }, notFoundHandler)
 server.setNotFoundHandler({ preHandler: notFoundpreHandlerHandler, preValidation: notFoundpreValidationHandler }, notFoundHandler)
 
-function invalidErrorHandler (error: number) {}
+function invalidErrorHandler (error: number) {
+  if (error) throw error
+}
 expectError(server.setErrorHandler(invalidErrorHandler))
 
 server.setSchemaController({
@@ -148,16 +155,30 @@ expectError(server.setReplySerializer(invalidReplySerializer))
 function serializerWithInvalidReturn (payload: unknown, statusCode: number) {}
 expectError(server.setReplySerializer(serializerWithInvalidReturn))
 
-function invalidSchemaErrorFormatter () {}
+function invalidSchemaErrorFormatter (err: Error) {
+  if (err) { throw err }
+}
 expectError(server.setSchemaErrorFormatter(invalidSchemaErrorFormatter))
 
 // test listen method callback
-expectAssignable<void>(server.listen(3000, '', 0, (err, address) => {}))
-expectAssignable<void>(server.listen('3000', '', 0, (err, address) => {}))
-expectAssignable<void>(server.listen(3000, '', (err, address) => {}))
-expectAssignable<void>(server.listen('3000', '', (err, address) => {}))
-expectAssignable<void>(server.listen(3000, (err, address) => {}))
-expectAssignable<void>(server.listen('3000', (err, address) => {}))
+expectAssignable<void>(server.listen(3000, '', 0, (err, address) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<void>(server.listen('3000', '', 0, (err, address) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<void>(server.listen(3000, '', (err, address) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<void>(server.listen('3000', '', (err, address) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<void>(server.listen(3000, (err, address) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<void>(server.listen('3000', (err, address) => {
+  expectType<Error | null>(err)
+}))
 
 // test listen method callback types
 expectAssignable<void>(server.listen('3000', (err, address) => {