fastify 5.10.0 → 5.11.1

package/fastify.d.ts

@@ -69,6 +69,7 @@ declare namespace fastify {
     Logger extends FastifyBaseLogger = FastifyBaseLogger
   > = FastifyServerOptions<Server, Logger> & {
     https: https.ServerOptions | null
+    http2?: false
   }
 
   export type FastifyHttpOptions<
@@ -76,9 +77,12 @@ declare namespace fastify {
     Logger extends FastifyBaseLogger = FastifyBaseLogger
   > = FastifyServerOptions<Server, Logger> & {
     http?: http.ServerOptions | null
+    http2?: false
   }
 
-  type FindMyWayVersion<RawServer extends RawServerBase> = RawServer extends http.Server ? HTTPVersion.V1 : HTTPVersion.V2
+  type FindMyWayVersion<RawServer extends RawServerBase> = RawServer extends http.Server
+    ? HTTPVersion.V1
+    : HTTPVersion.V2
   type FindMyWayConfigForServer<RawServer extends RawServerBase> = FindMyWayConfig<FindMyWayVersion<RawServer>>
 
   export interface ConnectionError extends Error {
@@ -163,15 +167,39 @@ declare namespace fastify {
     };
     return503OnClosing?: boolean,
     ajv?: Parameters<BuildCompilerFromPool>[1],
-    frameworkErrors?: <RequestGeneric extends RequestGenericInterface = RequestGenericInterface, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault, SchemaCompiler extends FastifySchema = FastifySchema>(
+    frameworkErrors?: <
+      RequestGeneric extends RequestGenericInterface = RequestGenericInterface,
+      TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+      SchemaCompiler extends FastifySchema = FastifySchema
+    >(
       error: FastifyError,
-      req: FastifyRequest<RequestGeneric, RawServer, RawRequestDefaultExpression<RawServer>, FastifySchema, TypeProvider>,
-      res: FastifyReply<RequestGeneric, RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, FastifyContextConfig, SchemaCompiler, TypeProvider>
+      req: FastifyRequest<
+        RequestGeneric,
+        RawServer,
+        RawRequestDefaultExpression<RawServer>,
+        FastifySchema,
+        TypeProvider
+      >,
+      res: FastifyReply<
+        RequestGeneric,
+        RawServer,
+        RawRequestDefaultExpression<RawServer>,
+        RawReplyDefaultExpression<RawServer>,
+        FastifyContextConfig,
+        SchemaCompiler,
+        TypeProvider
+      >
     ) => void,
     rewriteUrl?: (
       // The RawRequestDefaultExpression, RawReplyDefaultExpression, and FastifyTypeProviderDefault parameters
       // should be narrowed further but those generic parameters are not passed to this FastifyServerOptions type
-      this: FastifyInstance<RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, Logger, FastifyTypeProviderDefault>,
+      this: FastifyInstance<
+        RawServer,
+        RawRequestDefaultExpression<RawServer>,
+        RawReplyDefaultExpression<RawServer>,
+        Logger,
+        FastifyTypeProviderDefault
+      >,
       req: RawRequestDefaultExpression<RawServer>
     ) => string,
     schemaErrorFormatter?: SchemaErrorFormatter,
@@ -198,13 +226,25 @@ declare namespace fastify {
     FastifyListenOptions, FastifyInstance, PrintRoutesOptions, // './types/instance'
     FastifyLoggerOptions, FastifyBaseLogger, FastifyLoggerInstance, FastifyLogFn, LogLevel, // './types/logger'
     FastifyRequestContext, FastifyContextConfig, FastifyReplyContext, // './types/context'
-    RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler, RouteGenericInterface, // './types/route'
+    RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions,
+    RouteShorthandOptionsWithHandler, RouteGenericInterface, // './types/route'
     FastifyRegister, FastifyRegisterOptions, RegisterOptions, // './types/register'
-    FastifyBodyParser, FastifyContentTypeParser, AddContentTypeParser, hasContentTypeParser, getDefaultJsonParser, ProtoAction, ConstructorAction, // './types/content-type-parser'
+    FastifyBodyParser, FastifyContentTypeParser, AddContentTypeParser, hasContentTypeParser, getDefaultJsonParser,
+    ProtoAction, ConstructorAction, // './types/content-type-parser'
     FastifyError, // '@fastify/error'
     FastifySchema, FastifySchemaValidationError, FastifySchemaCompiler, FastifySerializerCompiler, // './types/schema'
-    HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault, ContextConfigDefault, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault, // './types/utils'
-    DoneFuncWithErrOrRes, HookHandlerDoneFunction, RequestPayload, onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onListenAsyncHookHandler, onListenHookHandler, onRegisterHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler, onRequestAbortHookHandler, onRequestAbortAsyncHookHandler, preCloseAsyncHookHandler, preCloseHookHandler, // './types/hooks'
+    HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault,
+    ContextConfigDefault, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault,
+    // './types/utils'
+    DoneFuncWithErrOrRes, HookHandlerDoneFunction, RequestPayload, onCloseAsyncHookHandler, onCloseHookHandler,
+    onErrorAsyncHookHandler, onErrorHookHandler, onReadyAsyncHookHandler, onReadyHookHandler,
+    onListenAsyncHookHandler, onListenHookHandler, onRegisterHookHandler, onRequestAsyncHookHandler,
+    onRequestHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler,
+    onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler,
+    preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler,
+    preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler,
+    preValidationHookHandler, onRequestAbortHookHandler, onRequestAbortAsyncHookHandler, preCloseAsyncHookHandler,
+    preCloseHookHandler, // './types/hooks'
     FastifyServerFactory, FastifyServerFactoryHandler, // './types/serverFactory'
     FastifyTypeProvider, FastifyTypeProviderDefault, SafePromiseLike, // './types/type-provider'
     FastifyErrorCodes // './types/errors'
@@ -232,7 +272,8 @@ declare function fastify<
   Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
-> (opts: fastify.FastifyHttp2SecureOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & SafePromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+> (opts: fastify.FastifyHttp2SecureOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger,
+  TypeProvider> & SafePromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
 
 declare function fastify<
   Server extends http2.Http2Server,
@@ -240,7 +281,8 @@ declare function fastify<
   Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
-> (opts: fastify.FastifyHttp2Options<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & SafePromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+> (opts: fastify.FastifyHttp2Options<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger,
+  TypeProvider> & SafePromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
 
 declare function fastify<
   Server extends https.Server,
@@ -248,7 +290,8 @@ declare function fastify<
   Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
-> (opts: fastify.FastifyHttpsOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & SafePromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+> (opts: fastify.FastifyHttpsOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger,
+  TypeProvider> & SafePromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
 
 declare function fastify<
   Server extends http.Server,
@@ -256,7 +299,8 @@ declare function fastify<
   Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
-> (opts?: fastify.FastifyHttpOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & SafePromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+> (opts?: fastify.FastifyHttpOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger,
+  TypeProvider> & SafePromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
 
 // CJS export
 // const fastify = require('fastify')

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '5.10.0'
+const VERSION = '5.11.0'
 
 const Avvio = require('avvio')
 const http = require('node:http')
@@ -80,7 +80,7 @@ const {
 } = errorCodes
 
 const { buildErrorHandler } = require('./lib/error-handler.js')
-const { FSTWRN004, FSTDEP023, FSTDEP024 } = require('./lib/warnings.js')
+const { FSTWRN004, FSTDEP023, FSTDEP024, FSTDEP025 } = require('./lib/warnings.js')
 
 const initChannel = diagnostics.channel('fastify.initialization')
 
@@ -143,7 +143,9 @@ function fastify (serverOptions) {
         'OPTIONS',
         'PATCH',
         'PUT',
-        'POST'
+        'POST',
+        // RFC 10008
+        'QUERY'
       ])
     },
     [kOptions]: options,
@@ -200,6 +202,9 @@ function fastify (serverOptions) {
     options: function _options (url, options, handler) {
       return router.prepareRoute.call(this, { method: 'OPTIONS', url, options, handler })
     },
+    query: function _query (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'QUERY', url, options, handler })
+    },
     all: function _all (url, options, handler) {
       return router.prepareRoute.call(this, { method: this.supportedMethods, url, options, handler })
     },
@@ -387,7 +392,7 @@ function fastify (serverOptions) {
           if (forceCloseConnections === 'idle' && options.serverFactory) {
             instance.server.closeIdleConnections()
             /* istanbul ignore next: Cannot test this without Node.js core support */
-          } else if (serverHasCloseAllConnections && forceCloseConnections) {
+          } else if (serverHasCloseAllConnections && forceCloseConnections === true) {
             instance.server.closeAllConnections()
           } else if (forceCloseConnections === true) {
             for (const conn of fastify[kKeepAliveConnections]) {
@@ -818,11 +823,18 @@ function fastify (serverOptions) {
     return this
   }
 
-  function addHttpMethod (method, { hasBody = false } = {}) {
+  function addHttpMethod (method, { hasBody = false, overrideExisting = false } = {}) {
     if (typeof method !== 'string' || http.METHODS.indexOf(method) === -1) {
       throw new FST_ERR_ROUTE_METHOD_INVALID()
     }
 
+    const alreadyExists = this[kSupportedHTTPMethods].bodyless.has(method) ||
+      this[kSupportedHTTPMethods].bodywith.has(method)
+
+    if (alreadyExists && !overrideExisting) {
+      FSTDEP025(method)
+    }
+
     if (hasBody === true) {
       this[kSupportedHTTPMethods].bodywith.add(method)
       this[kSupportedHTTPMethods].bodyless.delete(method)

package/lib/content-type.js

@@ -3,15 +3,37 @@
 const { LruMap: Lru } = require('toad-cache')
 
 /**
- * keyValuePairsReg is used to split the parameters list into associated
- * key value pairings. The leading `(?:^|;)\s*` anchor ensures the regex
- * only attempts matches at parameter boundaries, preventing quadratic
- * backtracking on malformed input.
+ * keyValuePairsReg matches a single `parameter-name "=" parameter-value`
+ * at a parameter boundary, following RFC 9110 §5.6.6 grammar:
+ *
+ *   parameter       = parameter-name "=" parameter-value
+ *   parameter-name  = token
+ *   parameter-value = ( token / quoted-string )
+ *   quoted-string   = DQUOTE *( qdtext / quoted-pair ) DQUOTE
+ *   qdtext          = HTAB / SP / %x21 / %x23-5B / %x5D-7E / obs-text
+ *   quoted-pair     = "\" ( HTAB / SP / VCHAR / obs-text )
+ *   obs-text        = %x80-FF
+ *
+ * The value alternative accepts either a bare token or a full quoted-string
+ * whose content matches the qdtext / quoted-pair character ranges. Because
+ * the quoted-string branch is aware of `\"` as an escape, embedded `"` and
+ * `;` characters inside a quoted value do not terminate the value.
  *
  * @see https://httpwg.org/specs/rfc9110.html#parameter
  * @type {RegExp}
  */
-const keyValuePairsReg = /(?:^|;)\s*([\w!#$%&'*+.^`|~-]+)=([^;]*)/gm
+const keyValuePairsReg = /(?:^|;)\s*([\w!#$%&'*+.^`|~-]+)=("(?:[\t\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\t\u0020-\u00ff])*"|[\w!#$%&'*+.^`|~-]+)/gu
+
+/**
+ * quotedPairReg matches a quoted-pair (a backslash followed by a single
+ * quoted-pair-allowed octet) inside a quoted-string value. Per RFC 9110
+ * §5.6.4, recipients that process the value of a quoted-string MUST handle
+ * a quoted-pair as if it were replaced by the octet following the backslash.
+ *
+ * @see https://httpwg.org/specs/rfc9110.html#quoted.string
+ * @type {RegExp}
+ */
+const quotedPairReg = /\\([\t\u0020-\u00ff])/gu
 
 /**
  * typeNameReg is used to validate that the first part of the media-type
@@ -140,21 +162,17 @@ class ContentType {
       const key = matches[1].toLowerCase()
       // Parameter values might or might not be case-sensitive,
       // depending on the semantics of the parameter name.
-      const value = matches[2]
-      if (value[0] === '"') {
-        if (value.at(-1) !== '"') {
-          this.#parameters.set(key, 'invalid quoted string')
-          matches = keyValuePairsReg.exec(paramsList)
-          continue
+      let value = matches[2]
+      if (value.charCodeAt(0) === 0x22 /* " */) {
+        // Strip the surrounding DQUOTEs and unescape quoted-pairs per
+        // RFC 9110 §5.6.4. The regex guarantees the value starts and ends
+        // with `"` and only contains permitted qdtext / quoted-pair octets.
+        value = value.slice(1, -1)
+        if (value.indexOf('\\') !== -1) {
+          value = value.replace(quotedPairReg, '$1')
         }
-        // We should probably verify the value matches a quoted string
-        // (https://httpwg.org/specs/rfc9110.html#rule.quoted-string) value.
-        // But we are not really doing much with the parameter values, so we
-        // are omitting that at this time.
-        this.#parameters.set(key, value.slice(1, value.length - 1))
-      } else {
-        this.#parameters.set(key, value)
       }
+      this.#parameters.set(key, value)
       matches = keyValuePairsReg.exec(paramsList)
     }
   }

package/lib/errors.js

@@ -455,6 +455,16 @@ const codes = {
     500,
     TypeError
   ),
+  FST_ERR_ROUTE_MISSING_CONTENT_TYPE: createError(
+    'FST_ERR_ROUTE_MISSING_CONTENT_TYPE',
+    "Method '%s' must provide a 'Content-Type' header.",
+    400
+  ),
+  FST_ERR_ROUTE_MISSING_CONTENT: createError(
+    'FST_ERR_ROUTE_MISSING_CONTENT',
+    "Method '%s' must provide a request body.",
+    400
+  ),
 
   /**
    *  again listen when close server

package/lib/handle-request.js

@@ -4,7 +4,11 @@ const diagnostics = require('node:diagnostics_channel')
 const wrapThenable = require('./wrap-thenable')
 const { validate: validateSchema } = require('./validation')
 const { preValidationHookRunner, preHandlerHookRunner } = require('./hooks')
-const { FST_ERR_CTP_INVALID_MEDIA_TYPE } = require('./errors')
+const {
+  FST_ERR_CTP_INVALID_MEDIA_TYPE,
+  FST_ERR_ROUTE_MISSING_CONTENT_TYPE,
+  FST_ERR_ROUTE_MISSING_CONTENT
+} = require('./errors')
 const { setErrorStatusCode } = require('./error-status')
 const {
   kReplyIsError,
@@ -37,13 +41,30 @@ function handleRequest (err, request, reply) {
     const headers = request.headers
     const ctHeader = headers['content-type']
 
-    if (ctHeader === undefined) {
-      const contentLength = headers['content-length']
-      const transferEncoding = headers['transfer-encoding']
-      const isEmptyBody = transferEncoding === undefined &&
-        (contentLength === undefined || contentLength === '0')
+    if (method === 'QUERY') {
+      if (ctHeader === undefined) {
+        // https://datatracker.ietf.org/doc/html/rfc10008#section-2
+        // Servers MUST fail the request if the Content-Type request field
+        // ([HTTP], Section 8.3) is missing or is inconsistent with the
+        // request content.
+        reply[kReplyIsError] = true
+        reply.status(400).send(new FST_ERR_ROUTE_MISSING_CONTENT_TYPE(method))
+        return
+      }
 
-      if (isEmptyBody) {
+      if (isEmptyBody(headers)) {
+        // https://datatracker.ietf.org/doc/html/rfc10008#section-2
+        // Servers MUST fail the request if the Content-Type request field
+        // ([HTTP], Section 8.3) is missing or is inconsistent with the
+        // request content.
+        reply[kReplyIsError] = true
+        reply.status(400).send(new FST_ERR_ROUTE_MISSING_CONTENT(method))
+        return
+      }
+    }
+
+    if (ctHeader === undefined) {
+      if (isEmptyBody(headers)) {
         // Request has no body to parse
         handler(request, reply)
         return
@@ -88,6 +109,13 @@ function handler (request, reply) {
   }
 }
 
+function isEmptyBody (headers) {
+  const contentLength = headers['content-length']
+  const transferEncoding = headers['transfer-encoding']
+  return transferEncoding === undefined &&
+    (contentLength === undefined || contentLength === '0')
+}
+
 function preValidationCallback (err, request, reply) {
   if (reply.sent === true) return
 

package/lib/hooks.js

@@ -306,7 +306,11 @@ function onSendHookRunner (functions, request, reply, payload, cb) {
   }
 
   function handleResolve (newPayload) {
-    next(null, newPayload)
+    try {
+      next(null, newPayload)
+    } catch (err) {
+      cb(err, request, reply, payload)
+    }
   }
 
   function handleReject (err) {

package/lib/route.js

@@ -179,7 +179,7 @@ function buildRouting (options) {
 
   function findRoute (options) {
     const route = router.find(
-      options.method,
+      options.method?.toUpperCase() ?? '',
       options.url || '',
       options.constraints
     )

package/lib/schemas.js

@@ -149,7 +149,7 @@ function getSchemaSerializer (context, statusCode, contentType) {
   }
   if (responseSchemaDef[statusCode]) {
     if (responseSchemaDef[statusCode].constructor === Object) {
-      const ct = new ContentType(contentType)
+      const ct = ContentType.from(contentType)
       if (ct.isValid) {
         if (responseSchemaDef[statusCode][ct.mediaType]) {
           return responseSchemaDef[statusCode][ct.mediaType]
@@ -168,7 +168,7 @@ function getSchemaSerializer (context, statusCode, contentType) {
   const fallbackStatusCode = (statusCode + '')[0] + 'xx'
   if (responseSchemaDef[fallbackStatusCode]) {
     if (responseSchemaDef[fallbackStatusCode].constructor === Object) {
-      const ct = new ContentType(contentType)
+      const ct = ContentType.from(contentType)
       if (ct.isValid) {
         if (responseSchemaDef[fallbackStatusCode][ct.mediaType]) {
           return responseSchemaDef[fallbackStatusCode][ct.mediaType]
@@ -187,7 +187,7 @@ function getSchemaSerializer (context, statusCode, contentType) {
   }
   if (responseSchemaDef.default) {
     if (responseSchemaDef.default.constructor === Object) {
-      const ct = new ContentType(contentType)
+      const ct = ContentType.from(contentType)
       if (ct.isValid) {
         if (responseSchemaDef.default[ct.mediaType]) {
           return responseSchemaDef.default[ct.mediaType]

package/lib/validation.js

@@ -138,7 +138,7 @@ function validateParam (validatorFunction, request, paramName) {
   function answer (ret) {
     if (ret === false) return validatorFunction.errors
     if (ret && ret.error) return ret.error
-    if (ret && ret.value) request[paramName] = ret.value
+    if (ret && typeof ret === 'object' && 'value' in ret) request[paramName] = ret.value
     return false
   }
 }

package/lib/warnings.js

@@ -9,9 +9,10 @@ const { createWarning } = require('process-warning')
  *   - FSTDEP022
  *   - FSTDEP023
  *   - FSTDEP024
+ *   - FSTDEP025
  *
  * Deprecation Codes FSTDEP001 - FSTDEP021 were used by v4 and MUST NOT be reused.
- *                             - FSTDEP022 is used by v5 and MUST NOT be reused.
+ *                             - FSTDEP022 - FSTDEP025 are used by v5 and MUST NOT be reused.
  * Warning Codes FSTWRN001 - FSTWRN002 were used by v4 and MUST NOT be reused.
  */
 
@@ -64,6 +65,13 @@ const FSTDEP024 = createWarning({
   unlimited: true
 })
 
+const FSTDEP025 = createWarning({
+  name: 'FastifyDeprecation',
+  code: 'FSTDEP025',
+  message: 'Calling addHttpMethod for existing method "%s" without { overrideExisting: true } is deprecated. In Fastify v6, this will throw an error.',
+  unlimited: true
+})
+
 module.exports = {
   FSTWRN001,
   FSTWRN003,
@@ -71,5 +79,6 @@ module.exports = {
   FSTSEC001,
   FSTDEP022,
   FSTDEP023,
-  FSTDEP024
+  FSTDEP024,
+  FSTDEP025
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "5.10.0",
+  "version": "5.11.1",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -191,7 +191,7 @@
     "joi": "^18.0.1",
     "json-schema-to-ts": "^3.0.1",
     "JSONStream": "^1.3.5",
-    "markdownlint-cli2": "^0.22.0",
+    "markdownlint-cli2": "^0.23.0",
     "neostandard": "^0.12.0",
     "node-forge": "^1.3.1",
     "proxyquire": "^2.1.3",

package/test/close.test.js

@@ -704,3 +704,42 @@ test('preClose execution order', (t, done) => {
     })
   })
 })
+
+test('does not destroy connections with in-flight requests (forceCloseConnections - idle)', { skip: noSupport }, async t => {
+  const fastify = Fastify({ forceCloseConnections: 'idle' })
+
+  fastify.get('/', async () => {
+    // the server starts closing while this request is still being served
+    fastify.close()
+    await sleep(200)
+    return { hello: 'world' }
+  })
+
+  await fastify.listen({ port: 0 })
+
+  const client = new Client('http://localhost:' + fastify.server.address().port)
+  t.after(() => client.close())
+
+  const response = await client.request({ path: '/', method: 'GET' })
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(await response.body.json(), { hello: 'world' })
+})
+
+test('does not destroy connections with in-flight requests (default options)', async t => {
+  const fastify = Fastify()
+
+  fastify.get('/', async () => {
+    fastify.close()
+    await sleep(200)
+    return { hello: 'world' }
+  })
+
+  await fastify.listen({ port: 0 })
+
+  const client = new Client('http://localhost:' + fastify.server.address().port)
+  t.after(() => client.close())
+
+  const response = await client.request({ path: '/', method: 'GET' })
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(await response.body.json(), { hello: 'world' })
+})

package/test/content-type.test.js

@@ -161,12 +161,11 @@ describe('ContentType class', () => {
     t.assert.equal(found.mediaType, 'application/json')
     t.assert.equal(found.type, 'application')
     t.assert.equal(found.subtype, 'json')
-    t.assert.equal(found.parameters.size, 3)
+    t.assert.equal(found.parameters.size, 2)
 
     const expected = [
       ['charset', 'utf-8'],
-      ['foo', 'BaR'],
-      ['baz', 'invalid quoted string']
+      ['foo', 'BaR']
     ]
     t.assert.deepStrictEqual(
       Array.from(found.parameters.entries()),
@@ -175,9 +174,37 @@ describe('ContentType class', () => {
 
     t.assert.equal(
       found.toString(),
-      'application/json; charset="utf-8"; foo="BaR"; baz="invalid quoted string"'
+      'application/json; charset="utf-8"; foo="BaR"'
     )
   })
+
+  test('preserves a semicolon inside a quoted parameter value', (t) => {
+    // RFC 9110 §5.6.6: ';' is a literal qdtext octet inside a quoted-string
+    // and does not terminate the parameter value.
+    const found = new ContentType('application/json; name="foo;bar"; charset=utf-8')
+    t.assert.equal(found.isValid, true)
+    t.assert.equal(found.mediaType, 'application/json')
+    t.assert.equal(found.parameters.get('name'), 'foo;bar')
+    t.assert.equal(found.parameters.get('charset'), 'utf-8')
+  })
+
+  test('does not leak a fake parameter out of a quoted value', (t) => {
+    // A `key=value;` sequence inside a quoted-string is opaque content of the
+    // enclosing value, not a subsequent parameter.
+    const found = new ContentType('application/json; name="a=b;charset=fake"; boundary=xyz')
+    t.assert.equal(found.isValid, true)
+    t.assert.equal(found.parameters.get('name'), 'a=b;charset=fake')
+    t.assert.equal(found.parameters.get('boundary'), 'xyz')
+    t.assert.equal(found.parameters.has('charset'), false)
+  })
+
+  test('unescapes a quoted-pair inside a quoted-string', (t) => {
+    // RFC 9110 §5.6.4: a quoted-pair MUST be handled as if replaced by
+    // the octet following the backslash.
+    const found = new ContentType('application/json; name="he said \\"hi\\""')
+    t.assert.equal(found.isValid, true)
+    t.assert.equal(found.parameters.get('name'), 'he said "hi"')
+  })
 })
 
 describe('ContentType class cache', () => {

package/test/find-route.test.js

@@ -66,6 +66,22 @@ test('findRoute should return null when when url is not passed', t => {
   }), null)
 })
 
+test('findRoute should return null when method is not passed', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler: (req, reply) => reply.send(typeof req.params.artistId)
+  })
+
+  t.assert.strictEqual(fastify.findRoute({
+    url: '/artists/:artistId'
+  }), null)
+})
+
 test('findRoute should return null when route cannot be found due to a different path', t => {
   t.plan(1)
   const fastify = Fastify()
@@ -103,6 +119,25 @@ test('findRoute should return the route when found', t => {
   t.assert.strictEqual(route.params.artistId, ':artistId')
 })
 
+test('findRoute should find a route even if method is not uppercased', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler: (req, reply) => reply.send(typeof req.params.artistId)
+  })
+
+  const route = fastify.findRoute({
+    method: 'get',
+    url: '/artists/:artistId'
+  })
+  t.assert.notStrictEqual(route, null)
+  t.assert.strictEqual(route.params.artistId, ':artistId')
+})
+
 test('findRoute should work correctly when used within plugins', (t, done) => {
   t.plan(1)
   const fastify = Fastify()