fastify 5.2.2 → 5.3.1

package/test/stream.4.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const errors = require('http-errors')
 const JSONStream = require('JSONStream')
@@ -10,7 +9,7 @@ const split = require('split2')
 const Fastify = require('..')
 const { kDisableRequestLogging } = require('../lib/symbols.js')
 
-test('Destroying streams prematurely should call abort method', t => {
+test('Destroying streams prematurely should call abort method', (t, testDone) => {
   t.plan(7)
 
   let fastify = null
@@ -23,7 +22,7 @@ test('Destroying streams prematurely should call abort method', t => {
       }
     })
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
   const stream = require('node:stream')
   const http = require('node:http')
@@ -31,13 +30,14 @@ test('Destroying streams prematurely should call abort 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)
+      testDone()
     }
   })
 
   fastify.get('/', function (request, reply) {
-    t.pass('Received request')
+    t.assert.ok('Received request')
 
     let sent = false
     const reallyLongStream = new stream.Readable({
@@ -50,30 +50,30 @@ test('Destroying streams prematurely should call abort method', t => {
     })
     reallyLongStream.destroy = undefined
     reallyLongStream.close = undefined
-    reallyLongStream.abort = () => t.ok('called')
+    reallyLongStream.abort = () => t.assert.ok('called')
     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, log is disabled', t => {
+test('Destroying streams prematurely, log is disabled', (t, testDone) => {
   t.plan(4)
 
   let fastify = null
@@ -82,7 +82,7 @@ test('Destroying streams prematurely, log is disabled', t => {
       logger: false
     })
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
   const stream = require('node:stream')
   const http = require('node:http')
@@ -100,30 +100,33 @@ test('Destroying streams prematurely, log is disabled', t => {
       }
     })
     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')
       })
     })
   })
 })
 
-test('should respond with a stream1', t => {
+test('should respond with a stream1', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -135,25 +138,26 @@ test('should respond with a stream1', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     sget(`http://localhost:${fastify.server.address().port}`, function (err, response, body) {
-      t.error(err)
-      t.equal(response.headers['content-type'], 'application/json')
-      t.equal(response.statusCode, 200)
-      t.same(JSON.parse(body), [{ hello: 'world' }, { a: 42 }])
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'application/json')
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(JSON.parse(body), [{ hello: 'world' }, { a: 42 }])
+      testDone()
     })
   })
 })
 
-test('return a 404 if the stream emits a 404 error', t => {
+test('return a 404 if the stream emits a 404 error', (t, testDone) => {
   t.plan(5)
 
   const fastify = Fastify()
 
   fastify.get('/', function (request, reply) {
-    t.pass('Received request')
+    t.assert.ok('Received request')
 
     const reallyLongStream = new Readable({
       read: function () {
@@ -167,15 +171,16 @@ test('return a 404 if the stream emits a 404 error', 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
 
     sget(`http://localhost:${port}`, function (err, response) {
-      t.error(err)
-      t.equal(response.headers['content-type'], 'application/json; charset=utf-8')
-      t.equal(response.statusCode, 404)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'application/json; charset=utf-8')
+      t.assert.strictEqual(response.statusCode, 404)
+      testDone()
     })
   })
 })

package/test/toolkit.js

@@ -30,3 +30,34 @@ exports.waitForCb = function (options) {
 
   return { stepIn, patience }
 }
+
+exports.partialDeepStrictEqual = function partialDeepStrictEqual (actual, expected) {
+  if (typeof expected !== 'object' || expected === null) {
+    return actual === expected
+  }
+
+  if (typeof actual !== 'object' || actual === null) {
+    return false
+  }
+
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual)) return false
+    if (expected.length > actual.length) return false
+
+    for (let i = 0; i < expected.length; i++) {
+      if (!partialDeepStrictEqual(actual[i], expected[i])) {
+        return false
+      }
+    }
+    return true
+  }
+
+  for (const key of Object.keys(expected)) {
+    if (!(key in actual)) return false
+    if (!partialDeepStrictEqual(actual[key], expected[key])) {
+      return false
+    }
+  }
+
+  return true
+}

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

@@ -522,6 +522,9 @@ expectError(server.decorateReply('typedTestReplyMethod', async function (x) {
   return 'foo'
 }))
 
+const foo = server.getDecorator<string>('foo')
+expectType<string>(foo)
+
 const versionConstraintStrategy = {
   name: 'version',
   storage: () => ({

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

@@ -45,6 +45,7 @@ const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectAssignable<((input: { [key: string]: unknown }, schema: { [key: string]: unknown }, httpStatus?: string) => unknown)>(reply.serializeInput)
   expectAssignable<((input: { [key: string]: unknown }, httpStatus: string) => unknown)>(reply.serializeInput)
   expectType<ContextConfigDefault & FastifyRouteConfig & FastifyContextConfig>(reply.routeOptions.config)
+  expectType<string>(reply.getDecorator<string>('foo'))
 }
 
 interface ReplyPayload {

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

@@ -92,6 +92,10 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectAssignable<(schema: { [key: string]: unknown }) => ExpectedGetValidationFunction>(request.getValidationFunction)
   expectAssignable<(input: { [key: string]: unknown }, schema: { [key: string]: unknown }, httpPart?: HTTPRequestPart) => boolean>(request.validateInput)
   expectAssignable<(input: { [key: string]: unknown }, httpPart?: HTTPRequestPart) => boolean>(request.validateInput)
+  expectType<string>(request.getDecorator<string>('foo'))
+  expectType<void>(request.setDecorator('foo', 'hello'))
+  expectType<void>(request.setDecorator<string>('foo', 'hello'))
+  expectError(request.setDecorator<string>('foo', true))
 }
 
 const getHandlerWithCustomLogger: RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, RouteGenericInterface, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault, CustomLoggerInterface> = function (request, _reply) {

package/test/types/type-provider.test-d.ts

@@ -1009,6 +1009,46 @@ expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{ Reply:
   }
 ))
 
+// -------------------------------------------------------------------
+// RouteGeneric Reply Type Return (Different Status Codes)
+// -------------------------------------------------------------------
+
+expectAssignable(server.get<{
+  Reply: {
+    200: string | { msg: string }
+    400: number
+    '5xx': { error: string }
+  }
+}>(
+  '/',
+  async (_, res) => {
+    const option = 1 as 1 | 2 | 3 | 4
+    switch (option) {
+      case 1: return 'hello'
+      case 2: return { msg: 'hello' }
+      case 3: return 400
+      case 4: return { error: 'error' }
+    }
+  }
+))
+
+// -------------------------------------------------------------------
+// RouteGeneric Reply Type Return: Non Assignable (Different Status Codes)
+// -------------------------------------------------------------------
+
+expectError(server.get<{
+  Reply: {
+    200: string | { msg: string }
+    400: number
+    '5xx': { error: string }
+  }
+}>(
+  '/',
+  async (_, res) => {
+    return true
+  }
+))
+
 // -------------------------------------------------------------------
 // FastifyPlugin: Auxiliary
 // -------------------------------------------------------------------

package/test/upgrade.test.js

@@ -6,14 +6,11 @@ const { connect } = require('node:net')
 const { once } = require('node:events')
 const dns = require('node:dns').promises
 
-describe('upgrade to both servers', async t => {
+describe('upgrade to both servers', async () => {
   const localAddresses = await dns.lookup('localhost', { all: true })
-  if (localAddresses.length === 1) {
-    t.skip('requires both IPv4 and IPv6')
-    return
-  }
+  const skip = localAddresses.length === 1 && 'requires both IPv4 and IPv6'
 
-  await test('upgrade IPv4 and IPv6', async t => {
+  await test('upgrade IPv4 and IPv6', { skip }, async t => {
     t.plan(2)
 
     const fastify = Fastify()

package/types/instance.d.ts

@@ -152,6 +152,8 @@ export interface FastifyInstance<
   decorateRequest: DecorationMethod<FastifyRequest, FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>>;
   decorateReply: DecorationMethod<FastifyReply, FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>>;
 
+  getDecorator<T>(name: string | symbol): T;
+
   hasDecorator(decorator: string | symbol): boolean;
   hasRequestDecorator(decorator: string | symbol): boolean;
   hasReplyDecorator(decorator: string | symbol): boolean;

package/types/reply.d.ts

@@ -77,4 +77,5 @@ export interface FastifyReply<
   ) => FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>;
   hasTrailer(key: string): boolean;
   removeTrailer(key: string): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>;
+  getDecorator<T>(name: string | symbol): T;
 }

package/types/request.d.ts

@@ -87,4 +87,6 @@ export interface FastifyRequest<RouteGeneric extends RouteGenericInterface = Rou
   compileValidationSchema(schema: { [key: string]: any }, httpPart?: HTTPRequestPart): ValidationFunction
   validateInput(input: any, schema: { [key: string]: any }, httpPart?: HTTPRequestPart): boolean
   validateInput(input: any, httpPart?: HTTPRequestPart): boolean
+  getDecorator<T>(name: string | symbol): T;
+  setDecorator<T = unknown>(name: string | symbol, value: T): void;
 }

package/types/type-provider.d.ts

@@ -1,6 +1,6 @@
 import { RouteGenericInterface } from './route'
 import { FastifySchema } from './schema'
-import { RecordKeysToLowercase } from './utils'
+import { HttpKeys, RecordKeysToLowercase } from './utils'
 
 // -----------------------------------------------------------------------------------------------
 // TypeProvider
@@ -80,6 +80,11 @@ export type ResolveFastifyReplyType<TypeProvider extends FastifyTypeProvider, Sc
 // FastifyReplyReturnType
 // -----------------------------------------------------------------------------------------------
 
+// Resolves the Reply return type by taking a union of response status codes in the generic argument
+type ResolveReplyReturnTypeFromRouteGeneric<RouteGeneric extends RouteGenericInterface> = RouteGeneric extends { Reply: infer Return }
+  ? keyof Return extends HttpKeys ? Return[keyof Return] | Return : Return
+  : unknown
+
 // The target reply return type. This type is inferenced on fastify 'routes' via generic argument assignment
 export type ResolveFastifyReplyReturnType<
   TypeProvider extends FastifyTypeProvider,
@@ -89,8 +94,12 @@ export type ResolveFastifyReplyReturnType<
 TypeProvider,
 SchemaCompiler,
 RouteGeneric
-> extends infer Return ?
-    (Return | void | Promise<Return | void>)
+> extends infer ReplyType
+  ? RouteGeneric['Reply'] extends ReplyType
+    ? ResolveReplyReturnTypeFromRouteGeneric<RouteGeneric> extends infer Return
+      ? Return | void | Promise<Return | void>
+      : unknown
+    : ReplyType | void | Promise<ReplyType | void>
 // review: support both async and sync return types
 // (Promise<Return> | Return | Promise<void> | void)
   : unknown