fastify 5.3.2 → 5.4.0

package/test/stream.3.test.js

@@ -1,11 +1,10 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const split = require('split2')
 const Fastify = require('..')
 
-test('Destroying streams prematurely', t => {
+test('Destroying streams prematurely', (t, testDone) => {
   t.plan(6)
 
   let fastify = null
@@ -18,7 +17,7 @@ test('Destroying streams prematurely', t => {
       }
     })
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
   const stream = require('node:stream')
   const http = require('node:http')
@@ -26,13 +25,14 @@ test('Destroying streams prematurely', t => {
   // 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)
+      t.assert.strictEqual(line.msg, 'stream closed prematurely')
+      t.assert.strictEqual(line.level, 30)
+      testDone()
     }
   })
 
   fastify.get('/', function (request, reply) {
-    t.pass('Received request')
+    t.assert.ok('Received request')
 
     let sent = false
     const reallyLongStream = new stream.Readable({
@@ -48,26 +48,26 @@ test('Destroying streams prematurely', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
 
     const port = fastify.server.address().port
 
     http.get(`http://localhost:${port}`, function (response) {
-      t.equal(response.statusCode, 200)
+      t.assert.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')
+        t.assert.ok('Response closed')
       })
     })
   })
 })
 
-test('Destroying streams prematurely should call close method', t => {
+test('Destroying streams prematurely should call close method', (t, testDone) => {
   t.plan(7)
 
   let fastify = null
@@ -80,7 +80,7 @@ test('Destroying streams prematurely should call close method', t => {
       }
     })
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
   const stream = require('node:stream')
   const http = require('node:http')
@@ -88,13 +88,13 @@ test('Destroying streams prematurely should call close method', t => {
   // 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)
+      t.assert.strictEqual(line.msg, 'stream closed prematurely')
+      t.assert.strictEqual(line.level, 30)
     }
   })
 
   fastify.get('/', function (request, reply) {
-    t.pass('Received request')
+    t.assert.ok('Received request')
 
     let sent = false
     const reallyLongStream = new stream.Readable({
@@ -106,30 +106,33 @@ test('Destroying streams prematurely should call close method', t => {
       }
     })
     reallyLongStream.destroy = undefined
-    reallyLongStream.close = () => t.ok('called')
+    reallyLongStream.close = () => {
+      t.assert.ok('called')
+      testDone()
+    }
     reply.send(reallyLongStream)
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     const port = fastify.server.address().port
 
     http.get(`http://localhost:${port}`, function (response) {
-      t.equal(response.statusCode, 200)
+      t.assert.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')
+        t.assert.ok('Response closed')
       })
     })
   })
 })
 
-test('Destroying streams prematurely should call close method when destroy is not a function', t => {
+test('Destroying streams prematurely should call close method when destroy is not a function', (t, testDone) => {
   t.plan(7)
 
   let fastify = null
@@ -142,7 +145,7 @@ test('Destroying streams prematurely should call close method when destroy is no
       }
     })
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
   const stream = require('node:stream')
   const http = require('node:http')
@@ -150,13 +153,13 @@ test('Destroying streams prematurely should call close method when destroy is no
   // 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)
+      t.assert.strictEqual(line.msg, 'stream closed prematurely')
+      t.assert.strictEqual(line.level, 30)
     }
   })
 
   fastify.get('/', function (request, reply) {
-    t.pass('Received request')
+    t.assert.ok('Received request')
 
     let sent = false
     const reallyLongStream = new stream.Readable({
@@ -168,24 +171,27 @@ test('Destroying streams prematurely should call close method when destroy is no
       }
     })
     reallyLongStream.destroy = true
-    reallyLongStream.close = () => t.ok('called')
+    reallyLongStream.close = () => {
+      t.assert.ok('called')
+      testDone()
+    }
     reply.send(reallyLongStream)
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     const port = fastify.server.address().port
 
     http.get(`http://localhost:${port}`, function (response) {
-      t.equal(response.statusCode, 200)
+      t.assert.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')
+        t.assert.ok('Response closed')
       })
     })
   })

package/test/trust-proxy.test.js

@@ -1,14 +1,10 @@
 'use strict'
 
 const { test, before } = require('node:test')
-const sget = require('simple-get').concat
 const fastify = require('..')
 const helper = require('./helper')
-const { waitForCb } = require('./toolkit')
 
-const noop = () => {}
-
-const sgetForwardedRequest = (app, forHeader, path, protoHeader, testCaseDone) => {
+const fetchForwardedRequest = async (fastifyServer, forHeader, path, protoHeader) => {
   const headers = {
     'X-Forwarded-For': forHeader,
     'X-Forwarded-Host': 'example.com'
@@ -16,11 +12,10 @@ const sgetForwardedRequest = (app, forHeader, path, protoHeader, testCaseDone) =
   if (protoHeader) {
     headers['X-Forwarded-Proto'] = protoHeader
   }
-  sget({
-    method: 'GET',
-    headers,
-    url: 'http://localhost:' + app.server.address().port + path
-  }, testCaseDone || noop)
+
+  return fetch(fastifyServer + path, {
+    headers
+  })
 }
 
 const testRequestValues = (t, req, options) => {
@@ -52,8 +47,8 @@ before(async function () {
   [localhost] = await helper.getLoopbackHost()
 })
 
-test('trust proxy, not add properties to node req', (t, done) => {
-  t.plan(14)
+test('trust proxy, not add properties to node req', async t => {
+  t.plan(13)
   const app = fastify({
     trustProxy: true
   })
@@ -69,20 +64,14 @@ test('trust proxy, not add properties to node req', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-
-    const completion = waitForCb({ steps: 2 })
-
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxy', undefined, completion.stepIn)
-    sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxychain', undefined, completion.stepIn)
+  const fastifyServer = await app.listen({ port: 0 })
 
-    completion.patience.then(done)
-  })
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxy', undefined)
+  await fetchForwardedRequest(fastifyServer, '2.2.2.2, 1.1.1.1', '/trustproxychain', undefined)
 })
 
-test('trust proxy chain', (t, done) => {
-  t.plan(9)
+test('trust proxy chain', async t => {
+  t.plan(8)
   const app = fastify({
     trustProxy: [localhost, '192.168.1.1']
   })
@@ -93,14 +82,12 @@ test('trust proxy chain', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    sgetForwardedRequest(app, '192.168.1.1, 1.1.1.1', '/trustproxychain', undefined, done)
-  })
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '192.168.1.1, 1.1.1.1', '/trustproxychain', undefined)
 })
 
-test('trust proxy function', (t, done) => {
-  t.plan(9)
+test('trust proxy function', async t => {
+  t.plan(8)
   const app = fastify({
     trustProxy: (address) => address === localhost
   })
@@ -111,14 +98,12 @@ test('trust proxy function', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxyfunc', undefined, done)
-  })
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyfunc', undefined)
 })
 
-test('trust proxy number', (t, done) => {
-  t.plan(10)
+test('trust proxy number', async t => {
+  t.plan(9)
   const app = fastify({
     trustProxy: 1
   })
@@ -129,14 +114,12 @@ test('trust proxy number', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxynumber', undefined, done)
-  })
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '2.2.2.2, 1.1.1.1', '/trustproxynumber', undefined)
 })
 
-test('trust proxy IP addresses', (t, done) => {
-  t.plan(10)
+test('trust proxy IP addresses', async t => {
+  t.plan(9)
   const app = fastify({
     trustProxy: `${localhost}, 2.2.2.2`
   })
@@ -147,14 +130,12 @@ test('trust proxy IP addresses', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    sgetForwardedRequest(app, '3.3.3.3, 2.2.2.2, 1.1.1.1', '/trustproxyipaddrs', undefined, done)
-  })
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '3.3.3.3, 2.2.2.2, 1.1.1.1', '/trustproxyipaddrs', undefined)
 })
 
-test('trust proxy protocol', (t, done) => {
-  t.plan(31)
+test('trust proxy protocol', async t => {
+  t.plan(30)
   const app = fastify({
     trustProxy: true
   })
@@ -173,16 +154,9 @@ test('trust proxy protocol', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-
-    const completion = waitForCb({ steps: 3 })
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocol', 'lorem', completion.stepIn)
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxynoprotocol', undefined, completion.stepIn)
+  const fastifyServer = await app.listen({ port: 0 })
 
-    // Allow for sgetForwardedRequest requests above to finish
-    setTimeout(() => sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocols', 'ipsum, dolor', completion.stepIn))
-
-    completion.patience.then(done)
-  })
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyprotocol', 'lorem')
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxynoprotocol', undefined)
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyprotocols', 'ipsum, dolor')
 })

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

@@ -52,7 +52,6 @@ expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_DUPLICATE)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_VALIDATION_BUILD)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_SERIALIZATION_BUILD)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_RESPONSE_SCHEMA_NOT_NESTED_2XX)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_HTTP2_INVALID_VERSION)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_INIT_OPTS_INVALID)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DUPLICATED_ROUTE)

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

@@ -273,3 +273,6 @@ expectType<FastifyErrorCodes>(fastify.errorCodes)
 fastify({ allowUnsafeRegex: true })
 fastify({ allowUnsafeRegex: false })
 expectError(fastify({ allowUnsafeRegex: 'invalid' }))
+
+expectAssignable<FastifyInstance>(fastify({ allowErrorHandlerOverride: true }))
+expectAssignable<FastifyInstance>(fastify({ allowErrorHandlerOverride: false }))

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

@@ -12,7 +12,7 @@ interface TestOptions extends FastifyPluginOptions {
 }
 const testOptions: TestOptions = {
   option1: 'a',
-  option2: false,
+  option2: false
 }
 const testPluginOpts: FastifyPluginCallback<TestOptions> = function (instance, opts, done) {
   expectType<TestOptions>(opts)

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

@@ -50,7 +50,7 @@ const testPluginWithHttp2WithType = (instance: ServerWithHttp2, opts: FastifyPlu
 const testPluginWithHttp2WithTypeAsync = async (instance: ServerWithHttp2, opts: FastifyPluginOptions) => { }
 const testOptions: TestOptions = {
   option1: 'a',
-  option2: false,
+  option2: false
 }
 expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginCallback))
 expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginAsync))

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

@@ -78,6 +78,7 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<FastifySchema | undefined>(request.routeOptions.schema)
   expectType<RouteHandlerMethod>(request.routeOptions.handler)
   expectType<string | undefined>(request.routeOptions.url)
+  expectType<string | undefined>(request.routeOptions.version)
 
   expectType<RequestHeadersDefault & RawRequestDefaultExpression['headers']>(request.headers)
   request.headers = {}

package/test/url-rewriting.test.js

@@ -2,10 +2,9 @@
 
 const { test } = require('node:test')
 const Fastify = require('..')
-const sget = require('simple-get').concat
 
-test('Should rewrite url', (t, done) => {
-  t.plan(5)
+test('Should rewrite url', async t => {
+  t.plan(4)
   const fastify = Fastify({
     rewriteUrl (req) {
       t.assert.strictEqual(req.url, '/this-would-404-without-url-rewrite')
@@ -22,24 +21,19 @@ test('Should rewrite url', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    t.assert.ifError(err)
-
-    t.after(() => fastify.close())
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/this-would-404-without-url-rewrite'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      t.assert.strictEqual(response.statusCode, 200)
-      done()
-    })
-  })
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  t.after(() => fastify.close())
+
+  const result = await fetch(`${fastifyServer}/this-would-404-without-url-rewrite`)
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
 })
 
-test('Should not rewrite if the url is the same', (t, done) => {
-  t.plan(4)
+test('Should not rewrite if the url is the same', async t => {
+  t.plan(3)
   const fastify = Fastify({
     rewriteUrl (req) {
       t.assert.strictEqual(req.url, '/this-would-404-without-url-rewrite')
@@ -56,22 +50,18 @@ test('Should not rewrite if the url is the same', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    t.assert.ifError(err)
-    t.after(() => fastify.close())
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/this-would-404-without-url-rewrite'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 404)
-      done()
-    })
-  })
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  t.after(() => fastify.close())
+
+  const result = await fetch(`${fastifyServer}/this-would-404-without-url-rewrite`)
+
+  t.assert.ok(!result.ok)
+  t.assert.strictEqual(result.status, 404)
 })
 
-test('Should throw an error', (t, done) => {
-  t.plan(5)
+test('Should throw an error', async t => {
+  t.plan(2)
   const fastify = Fastify({
     rewriteUrl (req) {
       t.assert.strictEqual(req.url, '/this-would-404-without-url-rewrite')
@@ -88,23 +78,20 @@ test('Should throw an error', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    t.assert.ifError(err)
-    t.after(() => fastify.close())
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/this-would-404-without-url-rewrite'
-    }, (err, response, body) => {
-      t.assert.strictEqual(err.code, 'ECONNRESET')
-      t.assert.strictEqual(response, undefined)
-      t.assert.strictEqual(body, undefined)
-      done()
-    })
-  })
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  t.after(() => fastify.close())
+
+  try {
+    await fetch(`${fastifyServer}/this-would-404-without-url-rewrite`)
+    t.assert.fail('Expected fetch to throw an error')
+  } catch (err) {
+    t.assert.ok(err instanceof Error)
+  }
 })
 
-test('Should rewrite url but keep originalUrl unchanged', (t, done) => {
-  t.plan(7)
+test('Should rewrite url but keep originalUrl unchanged', async t => {
+  t.plan(6)
   const fastify = Fastify({
     rewriteUrl (req) {
       t.assert.strictEqual(req.url, '/this-would-404-without-url-rewrite')
@@ -122,18 +109,14 @@ test('Should rewrite url but keep originalUrl unchanged', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    t.assert.ifError(err)
-    t.after(() => fastify.close())
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/this-would-404-without-url-rewrite'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      const parsedBody = JSON.parse(body)
-      t.assert.deepStrictEqual(parsedBody, { hello: 'world', hostname: 'localhost', port: fastify.server.address().port })
-      t.assert.strictEqual(response.statusCode, 200)
-      done()
-    })
-  })
+  await fastify.listen({ port: 0 })
+  const port = fastify.server.address().port
+
+  t.after(() => fastify.close())
+
+  const result = await fetch(`http://localhost:${port}/this-would-404-without-url-rewrite`)
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), { hello: 'world', hostname: 'localhost', port })
 })

package/test/use-semicolon-delimiter.test.js

@@ -13,7 +13,7 @@ test('use semicolon delimiter default false', (t, done) => {
     reply.send(req.query)
   })
 
-  fastify.listen({ port: 0, }, err => {
+  fastify.listen({ port: 0 }, err => {
     t.assert.ifError(err)
     sget({
       method: 'GET',

package/types/errors.d.ts

@@ -51,7 +51,6 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_SCH_VALIDATION_BUILD' |
   'FST_ERR_SCH_SERIALIZATION_BUILD' |
   'FST_ERR_SCH_RESPONSE_SCHEMA_NOT_NESTED_2XX' |
-  'FST_ERR_HTTP2_INVALID_VERSION' |
   'FST_ERR_INIT_OPTS_INVALID' |
   'FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE' |
   'FST_ERR_DUPLICATED_ROUTE' |

package/types/request.d.ts

@@ -32,6 +32,7 @@ export interface RequestRouteOptions<ContextConfig = ContextConfigDefault, Schem
   config: FastifyContextConfig & FastifyRouteConfig & ContextConfig;
   schema?: SchemaCompiler; // it is empty for 404 requests
   handler: RouteHandlerMethod;
+  version?: string;
 }
 
 /**

package/.taprc

@@ -1,7 +0,0 @@
-# vim: set filetype=yaml :
-node-arg:
-  - '--allow-natives-syntax'
-
-include:
-  - 'test/**/*.test.js'
-  - 'test/**/*.test.mjs'

package/test/http2/missing-http2-module.test.js

@@ -1,17 +0,0 @@
-'use strict'
-
-const { test } = require('node:test')
-const proxyquire = require('proxyquire')
-const server = proxyquire('../../lib/server', { 'node:http2': null })
-const Fastify = proxyquire('../..', { './lib/server.js': server })
-
-test('should throw when http2 module cannot be found', t => {
-  t.plan(2)
-  try {
-    Fastify({ http2: true })
-    t.assert.fail('fastify did not throw expected error')
-  } catch (err) {
-    t.assert.strictEqual(err.code, 'FST_ERR_HTTP2_INVALID_VERSION')
-    t.assert.strictEqual(err.message, 'HTTP2 is available only from node >= 8.8.1')
-  }
-})