fastify 4.27.0 → 4.28.0

package/lib/error-serializer.js

@@ -2,10 +2,8 @@
 /* istanbul ignore file */
 
   'use strict'
-  const { dependencies } = require('fast-json-stringify/lib/standalone')
-
-  const { Serializer, Validator } = dependencies
 
+  const Serializer = require('fast-json-stringify/lib/serializer')
   const serializerState = {"mode":"standalone"}
   const serializer = Serializer.restoreFromState(serializerState)
 
@@ -15,6 +13,18 @@
   module.exports = function anonymous(validator,serializer
 ) {
 
+    const JSON_STR_BEGIN_OBJECT = '{'
+    const JSON_STR_END_OBJECT = '}'
+    const JSON_STR_BEGIN_ARRAY = '['
+    const JSON_STR_END_ARRAY = ']'
+    const JSON_STR_COMMA = ','
+    const JSON_STR_COLONS = ':'
+    const JSON_STR_QUOTE = '"'
+    const JSON_STR_EMPTY_OBJECT = JSON_STR_BEGIN_OBJECT + JSON_STR_END_OBJECT
+    const JSON_STR_EMPTY_ARRAY = JSON_STR_BEGIN_ARRAY + JSON_STR_END_ARRAY
+    const JSON_STR_EMPTY_STRING = JSON_STR_QUOTE + JSON_STR_QUOTE
+    const JSON_STR_NULL = 'null'
+  
     
   
     // #
@@ -23,36 +33,83 @@
     ? input.toJSON()
     : input
   
-      if (obj === null) return '{}'
+      if (obj === null) return JSON_STR_EMPTY_OBJECT
 
-      let json = '{'
+      let value
+let json = JSON_STR_BEGIN_OBJECT
 let addComma = false
 
-      if (obj["statusCode"] !== undefined) {
-        !addComma && (addComma = true) || (json += ',')
+      value = obj["statusCode"]
+      if (value !== undefined) {
+        !addComma && (addComma = true) || (json += JSON_STR_COMMA)
         json += "\"statusCode\":"
-        json += serializer.asNumber(obj["statusCode"])
+        json += serializer.asNumber(value)
       }
 
-      if (obj["code"] !== undefined) {
-        !addComma && (addComma = true) || (json += ',')
+      value = obj["code"]
+      if (value !== undefined) {
+        !addComma && (addComma = true) || (json += JSON_STR_COMMA)
         json += "\"code\":"
-        json += serializer.asString(obj["code"])
+        
+        if (typeof value !== 'string') {
+          if (value === null) {
+            json += JSON_STR_EMPTY_STRING
+          } else if (value instanceof Date) {
+            json += JSON_STR_QUOTE + value.toISOString() + JSON_STR_QUOTE
+          } else if (value instanceof RegExp) {
+            json += serializer.asString(value.source)
+          } else {
+            json += serializer.asString(value.toString())
+          }
+        } else {
+          json += serializer.asString(value)
+        }
+        
       }
 
-      if (obj["error"] !== undefined) {
-        !addComma && (addComma = true) || (json += ',')
+      value = obj["error"]
+      if (value !== undefined) {
+        !addComma && (addComma = true) || (json += JSON_STR_COMMA)
         json += "\"error\":"
-        json += serializer.asString(obj["error"])
+        
+        if (typeof value !== 'string') {
+          if (value === null) {
+            json += JSON_STR_EMPTY_STRING
+          } else if (value instanceof Date) {
+            json += JSON_STR_QUOTE + value.toISOString() + JSON_STR_QUOTE
+          } else if (value instanceof RegExp) {
+            json += serializer.asString(value.source)
+          } else {
+            json += serializer.asString(value.toString())
+          }
+        } else {
+          json += serializer.asString(value)
+        }
+        
       }
 
-      if (obj["message"] !== undefined) {
-        !addComma && (addComma = true) || (json += ',')
+      value = obj["message"]
+      if (value !== undefined) {
+        !addComma && (addComma = true) || (json += JSON_STR_COMMA)
         json += "\"message\":"
-        json += serializer.asString(obj["message"])
+        
+        if (typeof value !== 'string') {
+          if (value === null) {
+            json += JSON_STR_EMPTY_STRING
+          } else if (value instanceof Date) {
+            json += JSON_STR_QUOTE + value.toISOString() + JSON_STR_QUOTE
+          } else if (value instanceof RegExp) {
+            json += serializer.asString(value.source)
+          } else {
+            json += serializer.asString(value.toString())
+          }
+        } else {
+          json += serializer.asString(value)
+        }
+        
       }
 
-    return json + '}'
+    return json + JSON_STR_END_OBJECT
   
     }
   

package/lib/reply.js

@@ -55,7 +55,7 @@ const {
   FST_ERR_MISSING_SERIALIZATION_FN,
   FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN
 } = require('./errors')
-const { FSTDEP010, FSTDEP013, FSTDEP019, FSTDEP020 } = require('./warnings')
+const { FSTDEP010, FSTDEP013, FSTDEP019, FSTDEP020, FSTDEP021 } = require('./warnings')
 
 const toString = Object.prototype.toString
 
@@ -457,9 +457,15 @@ Reply.prototype.type = function (type) {
   return this
 }
 
-Reply.prototype.redirect = function (code, url) {
-  if (typeof code === 'string') {
-    url = code
+Reply.prototype.redirect = function (url, code) {
+  if (typeof url === 'number') {
+    FSTDEP021()
+    const temp = code
+    code = url
+    url = temp
+  }
+
+  if (!code) {
     code = this[kReplyHasStatusCode] ? this.raw.statusCode : 302
   }
 

package/lib/route.js

@@ -168,7 +168,11 @@ function buildRouting (options) {
   }
 
   function hasRoute ({ options }) {
-    return findRoute(options) !== null
+    const normalizedMethod = options.method?.toUpperCase() ?? ''
+    return findRoute({
+      ...options,
+      method: normalizedMethod
+    }) !== null
   }
 
   function findRoute (options) {

package/lib/warnings.js

@@ -82,6 +82,11 @@ const FSTDEP020 = createDeprecation({
   message: 'You are using the deprecated "reply.getResponseTime()" method. Use the "reply.elapsedTime" property instead. Method "reply.getResponseTime()" will be removed in `fastify@5`.'
 })
 
+const FSTDEP021 = createDeprecation({
+  code: 'FSTDEP021',
+  message: 'The `reply.redirect()` method has a new signature: `reply.redirect(url: string, code?: number)`. It will be enforced in `fastify@v5`'
+})
+
 const FSTWRN001 = createWarning({
   name: 'FastifyWarning',
   code: 'FSTWRN001',
@@ -113,6 +118,7 @@ module.exports = {
   FSTDEP018,
   FSTDEP019,
   FSTDEP020,
+  FSTDEP021,
   FSTWRN001,
   FSTWRN002
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.27.0",
+  "version": "4.28.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",

package/test/close-pipelining.test.js

@@ -36,8 +36,15 @@ test('Should return 503 while closing - pipelining', async t => {
   await instance.close()
 })
 
-const isNodeVersionGte1819 = semver.gte(process.version, '18.19.0')
-test('Should not return 503 while closing - pipelining - return503OnClosing: false, skip Node >= v18.19.x', { skip: isNodeVersionGte1819 }, async t => {
+// default enable of idle closing idle connection is accidentally backported to 18.19.0 and fixed in 18.20.3
+// Refs: https://github.com/nodejs/node/releases/tag/v18.20.3
+const isNodeDefaultClosingIdleConnection =
+  (
+    semver.gte(process.version, '18.19.0') &&
+    semver.lt(process.version, '18.20.3')
+  ) ||
+  semver.gte(process.version, '19.0.0')
+test('Should not return 503 while closing - pipelining - return503OnClosing: false, skip when Node default closing idle connection', { skip: isNodeDefaultClosingIdleConnection }, async t => {
   const fastify = Fastify({
     return503OnClosing: false,
     forceCloseConnections: false
@@ -67,8 +74,8 @@ test('Should not return 503 while closing - pipelining - return503OnClosing: fal
   await instance.close()
 })
 
-test('Should close the socket abruptly - pipelining - return503OnClosing: false, skip Node < v18.19.x', { skip: !isNodeVersionGte1819 }, async t => {
-  // Since Node v18, we will always invoke server.closeIdleConnections()
+test('Should close the socket abruptly - pipelining - return503OnClosing: false, skip when Node not default closing idle connection', { skip: !isNodeDefaultClosingIdleConnection }, async t => {
+  // Since Node v19, we will always invoke server.closeIdleConnections()
   // therefore our socket will be closed
   const fastify = Fastify({
     return503OnClosing: false,

package/test/has-route.test.js

@@ -5,7 +5,7 @@ const test = t.test
 const Fastify = require('../fastify')
 
 test('hasRoute', t => {
-  t.plan(4)
+  t.plan(5)
   const test = t.test
   const fastify = Fastify()
 
@@ -74,4 +74,20 @@ test('hasRoute', t => {
       url: '/example/12345.png'
     }), true)
   })
+
+  test('hasRoute - finds a route even if method is not uppercased', t => {
+    t.plan(1)
+    fastify.route({
+      method: 'GET',
+      url: '/equal',
+      handler: function (req, reply) {
+        reply.send({ hello: 'world' })
+      }
+    })
+
+    t.equal(fastify.hasRoute({
+      method: 'get',
+      url: '/equal'
+    }), true)
+  })
 })

package/test/internals/reply.test.js

@@ -19,7 +19,7 @@ const {
 } = require('../../lib/symbols')
 const fs = require('node:fs')
 const path = require('node:path')
-const { FSTDEP010, FSTDEP019, FSTDEP020 } = require('../../lib/warnings')
+const { FSTDEP010, FSTDEP019, FSTDEP020, FSTDEP021 } = require('../../lib/warnings')
 
 const agent = new http.Agent({ keepAlive: false })
 
@@ -250,7 +250,7 @@ test('within an instance', t => {
   })
 
   fastify.get('/redirect-code', function (req, reply) {
-    reply.redirect(301, '/')
+    reply.redirect('/', 301)
   })
 
   fastify.get('/redirect-code-before-call', function (req, reply) {
@@ -258,7 +258,7 @@ test('within an instance', t => {
   })
 
   fastify.get('/redirect-code-before-call-overwrite', function (req, reply) {
-    reply.code(307).redirect(302, '/')
+    reply.code(307).redirect('/', 302)
   })
 
   fastify.get('/custom-serializer', function (req, reply) {
@@ -2094,6 +2094,36 @@ test('redirect to an invalid URL should not crash the server', async t => {
   await fastify.close()
 })
 
+test('redirect with deprecated signature should warn', t => {
+  t.plan(4)
+
+  process.removeAllListeners('warning')
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'DeprecationWarning')
+    t.equal(warning.code, FSTDEP021.code)
+  }
+
+  const fastify = Fastify()
+
+  fastify.get('/', (req, reply) => {
+    reply.redirect(302, '/new')
+  })
+
+  fastify.get('/new', (req, reply) => {
+    reply.send('new')
+  })
+
+  fastify.inject({ method: 'GET', url: '/' }, (err, res) => {
+    t.error(err)
+    t.pass()
+
+    process.removeListener('warning', onWarning)
+  })
+
+  FSTDEP021.emitted = false
+})
+
 test('invalid response headers should not crash the server', async t => {
   const fastify = Fastify()
   fastify.route({

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

@@ -29,7 +29,7 @@ const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectAssignable<() => { [key: string]: number | string | string[] | undefined }>(reply.getHeaders)
   expectAssignable<(key: string) => FastifyReply>(reply.removeHeader)
   expectAssignable<(key: string) => boolean>(reply.hasHeader)
-  expectType<{(statusCode: number, url: string): FastifyReply; (url: string): FastifyReply }>(reply.redirect)
+  expectType<{(statusCode: number, url: string): FastifyReply;(url: string, statusCode?: number): FastifyReply;}>(reply.redirect)
   expectType<() => FastifyReply>(reply.hijack)
   expectType<() => void>(reply.callNotFound)
   // Test reply.getResponseTime() deprecation

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

@@ -1052,7 +1052,7 @@ expectAssignable(server.withTypeProvider<InlineHandlerProvider>().get(
 // Handlers: Auxiliary
 // -------------------------------------------------------------------
 
-interface AuxiliaryHandlerProvider extends FastifyTypeProvider { output: 'handler-auxiliary' }
+interface AuxiliaryHandlerProvider extends FastifyTypeProvider { output: this['input'] }
 
 // Auxiliary handlers are likely shared for multiple routes and thus should infer as unknown due to potential varying parameters
 function auxiliaryHandler (request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction): void {
@@ -1063,7 +1063,7 @@ expectAssignable(server.withTypeProvider<AuxiliaryHandlerProvider>().get(
   '/',
   {
     onRequest: auxiliaryHandler,
-    schema: { body: null }
+    schema: { body: 'handler-auxiliary' }
   },
   (req) => {
     expectType<'handler-auxiliary'>(req.body)

package/types/reply.d.ts

@@ -57,9 +57,11 @@ export interface FastifyReply<
   getHeaders(): Record<HttpHeader, number | string | string[] | undefined>;
   removeHeader(key: HttpHeader): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
   hasHeader(key: HttpHeader): boolean;
-  // Note: should consider refactoring the argument order for redirect. statusCode is optional so it should be after the required url param
+  /**
+   * @deprecated The `reply.redirect()` method has a new signature: `reply.reply.redirect(url: string, code?: number)`. It will be enforced in `fastify@v5`'.
+   */
   redirect(statusCode: number, url: string): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
-  redirect(url: string): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
+  redirect(url: string, statusCode?: number): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
   hijack(): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
   callNotFound(): void;
   /**

package/types/route.d.ts

@@ -12,7 +12,7 @@ import {
   FastifyTypeProviderDefault,
   ResolveFastifyReplyReturnType
 } from './type-provider'
-import { ContextConfigDefault, HTTPMethods, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault } from './utils'
+import { ContextConfigDefault, HTTPMethods, NoInferCompat, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault } from './utils'
 
 export interface FastifyRouteConfig {
   url: string;
@@ -48,8 +48,8 @@ export interface RouteShorthandOptions<
   attachValidation?: boolean;
   exposeHeadRoute?: boolean;
 
-  validatorCompiler?: FastifySchemaCompiler<SchemaCompiler>;
-  serializerCompiler?: FastifySerializerCompiler<SchemaCompiler>;
+  validatorCompiler?: FastifySchemaCompiler<NoInferCompat<SchemaCompiler>>;
+  serializerCompiler?: FastifySerializerCompiler<NoInferCompat<SchemaCompiler>>;
   bodyLimit?: number;
   logLevel?: LogLevel;
   config?: Omit<FastifyRequestContext<ContextConfig>['config'], 'url' | 'method'>;
@@ -59,33 +59,33 @@ export interface RouteShorthandOptions<
   errorHandler?: (
     this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
     error: FastifyError,
-    request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider, ContextConfig, Logger>,
-    reply: FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>
+    request: FastifyRequest<RouteGeneric, RawServer, RawRequest, NoInferCompat<SchemaCompiler>, TypeProvider, ContextConfig, Logger>,
+    reply: FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider>
   ) => void;
   childLoggerFactory?: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
   schemaErrorFormatter?: SchemaErrorFormatter;
 
   // hooks
-  onRequest?: onRequestMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | onRequestMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
-  preParsing?: preParsingMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | preParsingMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
-  preValidation?: preValidationMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | preValidationMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
-  preHandler?: preHandlerMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | preHandlerMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
-  preSerialization?: preSerializationMetaHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | preSerializationMetaHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
-  onSend?: onSendMetaHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | onSendMetaHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
-  onResponse?: onResponseMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | onResponseMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
-  onTimeout?: onTimeoutMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | onTimeoutMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
-  onError?: onErrorMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, FastifyError, SchemaCompiler, TypeProvider, Logger>
-  | onErrorMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, FastifyError, SchemaCompiler, TypeProvider, Logger>[];
-  onRequestAbort?: onRequestAbortMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
-  | onRequestAbortMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
+  onRequest?: onRequestMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>
+  | onRequestMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>[];
+  preParsing?: preParsingMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>
+  | preParsingMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>[];
+  preValidation?: preValidationMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>
+  | preValidationMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>[];
+  preHandler?: preHandlerMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>
+  | preHandlerMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>[];
+  preSerialization?: preSerializationMetaHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>
+  | preSerializationMetaHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>[];
+  onSend?: onSendMetaHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>
+  | onSendMetaHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>[];
+  onResponse?: onResponseMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>
+  | onResponseMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>[];
+  onTimeout?: onTimeoutMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>
+  | onTimeoutMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>[];
+  onError?: onErrorMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, FastifyError, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>
+  | onErrorMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, FastifyError, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>[];
+  onRequestAbort?: onRequestAbortMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>
+  | onRequestAbortMetaHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>[];
 }
 /**
  * Route handler method declaration.
@@ -162,7 +162,7 @@ export interface RouteOptions<
 > extends RouteShorthandOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger> {
   method: HTTPMethods | HTTPMethods[];
   url: string;
-  handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>;
+  handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInferCompat<SchemaCompiler>, TypeProvider, Logger>;
 }
 
 export type RouteHandler<

package/types/utils.d.ts

@@ -88,3 +88,8 @@ type OmitIndexSignature<T> = {
  * Use this type only for input values, not for output values.
  */
 export type HttpHeader = keyof OmitIndexSignature<http.OutgoingHttpHeaders> | (string & Record<never, never>);
+
+// cheat for similar (same?) behavior as NoInfer but for TS <5.4
+export type NoInferCompat<SC> = {
+  [K in keyof SC]: SC[K]
+};