fastify 5.2.1 → 5.3.0

package/test/trust-proxy.test.js

@@ -4,6 +4,7 @@ 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 = () => {}
 
@@ -69,18 +70,14 @@ test('trust proxy, not add properties to node req', (t, done) => {
   })
 
   app.listen({ port: 0 }, (err) => {
-    app.server.unref()
     t.assert.ifError(err)
 
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxy', undefined, completed)
-    sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxychain', undefined, completed)
+    const completion = waitForCb({ steps: 2 })
 
-    let pending = 2
-    function completed () {
-      if (--pending === 0) {
-        done()
-      }
-    }
+    sgetForwardedRequest(app, '1.1.1.1', '/trustproxy', undefined, completion.stepIn)
+    sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxychain', undefined, completion.stepIn)
+
+    completion.patience.then(done)
   })
 })
 
@@ -89,6 +86,7 @@ test('trust proxy chain', (t, done) => {
   const app = fastify({
     trustProxy: [localhost, '192.168.1.1']
   })
+  t.after(() => app.close())
 
   app.get('/trustproxychain', function (req, reply) {
     testRequestValues(t, req, { ip: '1.1.1.1', host: 'example.com', port: app.server.address().port })
@@ -96,9 +94,7 @@ test('trust proxy chain', (t, done) => {
   })
 
   app.listen({ port: 0 }, (err) => {
-    app.server.unref()
     t.assert.ifError(err)
-    t.after(() => app.close())
     sgetForwardedRequest(app, '192.168.1.1, 1.1.1.1', '/trustproxychain', undefined, done)
   })
 })
@@ -108,15 +104,15 @@ test('trust proxy function', (t, done) => {
   const app = fastify({
     trustProxy: (address) => address === localhost
   })
+  t.after(() => app.close())
+
   app.get('/trustproxyfunc', function (req, reply) {
     testRequestValues(t, req, { ip: '1.1.1.1', host: 'example.com', port: app.server.address().port })
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   app.listen({ port: 0 }, (err) => {
-    app.server.unref()
     t.assert.ifError(err)
-    t.after(() => app.close())
     sgetForwardedRequest(app, '1.1.1.1', '/trustproxyfunc', undefined, done)
   })
 })
@@ -126,15 +122,15 @@ test('trust proxy number', (t, done) => {
   const app = fastify({
     trustProxy: 1
   })
+  t.after(() => app.close())
+
   app.get('/trustproxynumber', function (req, reply) {
     testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'], host: 'example.com', port: app.server.address().port })
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   app.listen({ port: 0 }, (err) => {
-    app.server.unref()
     t.assert.ifError(err)
-    t.after(() => app.close())
     sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxynumber', undefined, done)
   })
 })
@@ -144,15 +140,15 @@ test('trust proxy IP addresses', (t, done) => {
   const app = fastify({
     trustProxy: `${localhost}, 2.2.2.2`
   })
+  t.after(() => app.close())
+
   app.get('/trustproxyipaddrs', function (req, reply) {
     testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'], host: 'example.com', port: app.server.address().port })
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   app.listen({ port: 0 }, (err) => {
-    app.server.unref()
     t.assert.ifError(err)
-    t.after(() => app.close())
     sgetForwardedRequest(app, '3.3.3.3, 2.2.2.2, 1.1.1.1', '/trustproxyipaddrs', undefined, done)
   })
 })
@@ -162,6 +158,8 @@ test('trust proxy protocol', (t, done) => {
   const app = fastify({
     trustProxy: true
   })
+  t.after(() => app.close())
+
   app.get('/trustproxyprotocol', function (req, reply) {
     testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'lorem', host: 'example.com', port: app.server.address().port })
     reply.code(200).send({ ip: req.ip, host: req.host })
@@ -175,14 +173,16 @@ test('trust proxy protocol', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  t.after(() => app.close())
-
   app.listen({ port: 0 }, (err) => {
-    app.server.unref()
     t.assert.ifError(err)
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocol', 'lorem')
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxynoprotocol')
+
+    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)
+
     // Allow for sgetForwardedRequest requests above to finish
-    setTimeout(() => sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocols', 'ipsum, dolor', done))
+    setTimeout(() => sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocols', 'ipsum, dolor', completion.stepIn))
+
+    completion.patience.then(done)
   })
 })

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

@@ -36,6 +36,7 @@ expectType<unknown>(server.getSchema('SchemaId'))
 expectType<string>(server.printRoutes())
 expectType<string>(server.printPlugins())
 expectType<string>(server.listeningOrigin)
+expectType<string[]>(server.supportedMethods)
 
 expectAssignable<FastifyInstance>(
   server.setErrorHandler(function (error, request, reply) {
@@ -521,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

@@ -1,53 +1,52 @@
 'use strict'
 
-const { test, skip } = require('tap')
+const { describe, test } = require('node:test')
 const Fastify = require('..')
 const { connect } = require('node:net')
 const { once } = require('node:events')
 const dns = require('node:dns').promises
 
-async function setup () {
+describe('upgrade to both servers', async () => {
   const localAddresses = await dns.lookup('localhost', { all: true })
-  if (localAddresses.length === 1) {
-    skip('requires both IPv4 and IPv6')
-    return
-  }
+  const skip = localAddresses.length === 1 && 'requires both IPv4 and IPv6'
 
-  test('upgrade to both servers', async t => {
+  await test('upgrade IPv4 and IPv6', { skip }, async t => {
     t.plan(2)
-    const app = Fastify()
-    app.server.on('upgrade', (req, socket, head) => {
-      t.pass(`upgrade event ${JSON.stringify(socket.address())}`)
+
+    const fastify = Fastify()
+    fastify.server.on('upgrade', (req, socket, head) => {
+      t.assert.ok(`upgrade event ${JSON.stringify(socket.address())}`)
       socket.end()
     })
-    app.get('/', (req, res) => {
+
+    fastify.get('/', (req, res) => {
+      res.send()
     })
-    await app.listen()
-    t.teardown(app.close.bind(app))
+
+    await fastify.listen()
+    t.after(() => fastify.close())
 
     {
-      const client = connect(app.server.address().port, '127.0.0.1')
-      client.write('GET / HTTP/1.1\r\n')
-      client.write('Upgrade: websocket\r\n')
-      client.write('Connection: Upgrade\r\n')
-      client.write('Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==\r\n')
-      client.write('Sec-WebSocket-Protocol: com.xxx.service.v1\r\n')
-      client.write('Sec-WebSocket-Version: 13\r\n\r\n')
-      client.write('\r\n\r\n')
-      await once(client, 'close')
+      const clientIPv4 = connect(fastify.server.address().port, '127.0.0.1')
+      clientIPv4.write('GET / HTTP/1.1\r\n')
+      clientIPv4.write('Upgrade: websocket\r\n')
+      clientIPv4.write('Connection: Upgrade\r\n')
+      clientIPv4.write('Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==\r\n')
+      clientIPv4.write('Sec-WebSocket-Protocol: com.xxx.service.v1\r\n')
+      clientIPv4.write('Sec-WebSocket-Version: 13\r\n\r\n')
+      clientIPv4.write('\r\n\r\n')
+      await once(clientIPv4, 'close')
     }
 
     {
-      const client = connect(app.server.address().port, '::1')
-      client.write('GET / HTTP/1.1\r\n')
-      client.write('Upgrade: websocket\r\n')
-      client.write('Connection: Upgrade\r\n')
-      client.write('Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==\r\n')
-      client.write('Sec-WebSocket-Protocol: com.xxx.service.v1\r\n')
-      client.write('Sec-WebSocket-Version: 13\r\n\r\n')
-      await once(client, 'close')
+      const clientIPv6 = connect(fastify.server.address().port, '::1')
+      clientIPv6.write('GET / HTTP/1.1\r\n')
+      clientIPv6.write('Upgrade: websocket\r\n')
+      clientIPv6.write('Connection: Upgrade\r\n')
+      clientIPv6.write('Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==\r\n')
+      clientIPv6.write('Sec-WebSocket-Protocol: com.xxx.service.v1\r\n')
+      clientIPv6.write('Sec-WebSocket-Version: 13\r\n\r\n')
+      await once(clientIPv6, 'close')
     }
   })
-}
-
-setup()
+})

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;
@@ -548,6 +550,10 @@ export interface FastifyInstance<
    * Remove all content type parsers, including the default ones
    */
   removeAllContentTypeParsers: removeAllContentTypeParsers
+  /**
+   * Returns an array of strings containing the list of supported HTTP methods
+   */
+  supportedMethods: string[]
   /**
    * Add a non-standard HTTP method
    *

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