fastify 5.6.1 → 5.6.2

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '5.6.1'
+const VERSION = '5.6.2'
 
 const Avvio = require('avvio')
 const http = require('node:http')
@@ -40,17 +40,16 @@ const Reply = require('./lib/reply')
 const Request = require('./lib/request')
 const Context = require('./lib/context.js')
 const decorator = require('./lib/decorate')
-const ContentTypeParser = require('./lib/contentTypeParser')
+const ContentTypeParser = require('./lib/content-type-parser.js')
 const SchemaController = require('./lib/schema-controller')
 const { Hooks, hookRunnerApplication, supportedHooks } = require('./lib/hooks')
 const { createChildLogger, defaultChildLoggerFactory, createLogger } = require('./lib/logger-factory')
-const pluginUtils = require('./lib/pluginUtils')
-const { getGenReqId, reqIdGenFactory } = require('./lib/reqIdGenFactory')
+const pluginUtils = require('./lib/plugin-utils.js')
+const { getGenReqId, reqIdGenFactory } = require('./lib/req-id-gen-factory.js')
 const { buildRouting, validateBodyLimitOption, buildRouterOptions } = require('./lib/route')
-const build404 = require('./lib/fourOhFour')
-const getSecuredInitialConfig = require('./lib/initialConfigValidation')
-const override = require('./lib/pluginOverride')
-const noopSet = require('./lib/noop-set')
+const build404 = require('./lib/four-oh-four')
+const getSecuredInitialConfig = require('./lib/initial-config-validation.js')
+const override = require('./lib/plugin-override')
 const {
   appendStackTrace,
   AVVIO_ERRORS_MAP,
@@ -63,7 +62,6 @@ const { defaultInitOptions } = getSecuredInitialConfig
 const {
   FST_ERR_ASYNC_CONSTRAINT,
   FST_ERR_BAD_URL,
-  FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE,
   FST_ERR_OPTIONS_NOT_OBJ,
   FST_ERR_QSP_NOT_FN,
   FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN,
@@ -83,99 +81,17 @@ const { FSTWRN004 } = require('./lib/warnings.js')
 
 const initChannel = diagnostics.channel('fastify.initialization')
 
-function defaultBuildPrettyMeta (route) {
-  // return a shallow copy of route's sanitized context
-
-  const cleanKeys = {}
-  const allowedProps = ['errorHandler', 'logLevel', 'logSerializers']
-
-  allowedProps.concat(supportedHooks).forEach(k => {
-    cleanKeys[k] = route.store[k]
-  })
-
-  return Object.assign({}, cleanKeys)
-}
-
 /**
  * @param {import('./fastify.js').FastifyServerOptions} options
  */
-function fastify (options) {
-  // Options validations
-  if (options && typeof options !== 'object') {
-    throw new FST_ERR_OPTIONS_NOT_OBJ()
-  } else {
-    // Shallow copy options object to prevent mutations outside of this function
-    options = Object.assign({}, options)
-  }
-
-  if (
-    (options.querystringParser && typeof options.querystringParser !== 'function') ||
-    (
-      options.routerOptions?.querystringParser &&
-      typeof options.routerOptions.querystringParser !== 'function'
-    )
-  ) {
-    throw new FST_ERR_QSP_NOT_FN(typeof (options.querystringParser ?? options.routerOptions.querystringParser))
-  }
-
-  if (options.schemaController && options.schemaController.bucket && typeof options.schemaController.bucket !== 'function') {
-    throw new FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN(typeof options.schemaController.bucket)
-  }
-
-  validateBodyLimitOption(options.bodyLimit)
-
-  const requestIdHeader = typeof options.requestIdHeader === 'string' && options.requestIdHeader.length !== 0 ? options.requestIdHeader.toLowerCase() : (options.requestIdHeader === true && 'request-id')
-  const genReqId = reqIdGenFactory(requestIdHeader, options.genReqId)
-  const requestIdLogLabel = options.requestIdLogLabel || 'reqId'
-  const bodyLimit = options.bodyLimit || defaultInitOptions.bodyLimit
-  const disableRequestLogging = options.disableRequestLogging || false
-
-  const ajvOptions = Object.assign({
-    customOptions: {},
-    plugins: []
-  }, options.ajv)
-  const frameworkErrors = options.frameworkErrors
-
-  // Ajv options
-  if (!ajvOptions.customOptions || Object.prototype.toString.call(ajvOptions.customOptions) !== '[object Object]') {
-    throw new FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ(typeof ajvOptions.customOptions)
-  }
-  if (!ajvOptions.plugins || !Array.isArray(ajvOptions.plugins)) {
-    throw new FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR(typeof ajvOptions.plugins)
-  }
-
-  // Instance Fastify components
-
-  const { logger, hasLogger } = createLogger(options)
-
-  // Update the options with the fixed values
-  options.connectionTimeout = options.connectionTimeout || defaultInitOptions.connectionTimeout
-  options.keepAliveTimeout = options.keepAliveTimeout || defaultInitOptions.keepAliveTimeout
-  options.maxRequestsPerSocket = options.maxRequestsPerSocket || defaultInitOptions.maxRequestsPerSocket
-  options.requestTimeout = options.requestTimeout || defaultInitOptions.requestTimeout
-  options.logger = logger
-  options.requestIdHeader = requestIdHeader
-  options.requestIdLogLabel = requestIdLogLabel
-  options.disableRequestLogging = disableRequestLogging
-  options.ajv = ajvOptions
-  options.clientErrorHandler = options.clientErrorHandler || defaultClientErrorHandler
-  options.allowErrorHandlerOverride = options.allowErrorHandlerOverride ?? defaultInitOptions.allowErrorHandlerOverride
-
-  const initialConfig = getSecuredInitialConfig(options)
-
-  // exposeHeadRoutes have its default set from the validator
-  options.exposeHeadRoutes = initialConfig.exposeHeadRoutes
-
-  options.routerOptions = buildRouterOptions(options, {
-    defaultRoute,
-    onBadUrl,
-    ignoreTrailingSlash: defaultInitOptions.ignoreTrailingSlash,
-    ignoreDuplicateSlashes: defaultInitOptions.ignoreDuplicateSlashes,
-    maxParamLength: defaultInitOptions.maxParamLength,
-    allowUnsafeRegex: defaultInitOptions.allowUnsafeRegex,
-    buildPrettyMeta: defaultBuildPrettyMeta,
-    useSemicolonDelimiter: defaultInitOptions.useSemicolonDelimiter
-  })
+function fastify (serverOptions) {
+  const {
+    options,
+    genReqId,
+    disableRequestLogging,
+    hasLogger,
+    initialConfig
+  } = processOptions(serverOptions, defaultRoute, onBadUrl)
 
   // Default router
   const router = buildRouting({
@@ -188,23 +104,14 @@ function fastify (options) {
   // HTTP server and its handler
   const httpHandler = wrapRouting(router, options)
 
-  // we need to set this before calling createServer
-  options.http2SessionTimeout = initialConfig.http2SessionTimeout
-  const { server, listen } = createServer(options, httpHandler)
-
-  const serverHasCloseAllConnections = typeof server.closeAllConnections === 'function'
-  const serverHasCloseIdleConnections = typeof server.closeIdleConnections === 'function'
-  const serverHasCloseHttp2Sessions = typeof server.closeHttp2Sessions === 'function'
-
-  let forceCloseConnections = options.forceCloseConnections
-  if (forceCloseConnections === 'idle' && !serverHasCloseIdleConnections) {
-    throw new FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE()
-  } else if (typeof forceCloseConnections !== 'boolean') {
-    /* istanbul ignore next: only one branch can be valid in a given Node.js version */
-    forceCloseConnections = serverHasCloseIdleConnections ? 'idle' : false
-  }
-
-  const keepAliveConnections = !serverHasCloseAllConnections && forceCloseConnections === true ? new Set() : noopSet()
+  const {
+    server,
+    listen,
+    forceCloseConnections,
+    serverHasCloseAllConnections,
+    serverHasCloseHttp2Sessions,
+    keepAliveConnections
+  } = createServer(options, httpHandler)
 
   const setupResponseListeners = Reply.setupResponseListeners
   const schemaController = SchemaController.buildSchemaController(null, options.schemaController)
@@ -241,7 +148,7 @@ function fastify (options) {
     [kOptions]: options,
     [kChildren]: [],
     [kServerBindings]: [],
-    [kBodyLimit]: bodyLimit,
+    [kBodyLimit]: options.bodyLimit,
     [kRoutePrefix]: '',
     [kLogLevel]: '',
     [kLogSerializers]: null,
@@ -250,10 +157,10 @@ function fastify (options) {
     [kSchemaErrorFormatter]: null,
     [kErrorHandler]: buildErrorHandler(),
     [kErrorHandlerAlreadySet]: false,
-    [kChildLoggerFactory]: defaultChildLoggerFactory,
+    [kChildLoggerFactory]: options.childLoggerFactory || defaultChildLoggerFactory,
     [kReplySerializerDefault]: null,
     [kContentTypeParser]: new ContentTypeParser(
-      bodyLimit,
+      options.bodyLimit,
       (options.onProtoPoisoning || defaultInitOptions.onProtoPoisoning),
       (options.onConstructorPoisoning || defaultInitOptions.onConstructorPoisoning)
     ),
@@ -307,7 +214,7 @@ function fastify (options) {
       return router.findRoute(options)
     },
     // expose logger instance
-    log: logger,
+    log: options.logger,
     // type provider
     withTypeProvider,
     // hooks
@@ -529,7 +436,6 @@ function fastify (options) {
   router.setup(options, {
     avvio,
     fourOhFour,
-    logger,
     hasLogger,
     setupResponseListeners,
     throwIfAlreadyStarted,
@@ -716,46 +622,6 @@ function fastify (options) {
     return this
   }
 
-  function defaultClientErrorHandler (err, socket) {
-    // In case of a connection reset, the socket has been destroyed and there is nothing that needs to be done.
-    // https://nodejs.org/api/http.html#http_event_clienterror
-    if (err.code === 'ECONNRESET' || socket.destroyed) {
-      return
-    }
-
-    let body, errorCode, errorStatus, errorLabel
-
-    if (err.code === 'ERR_HTTP_REQUEST_TIMEOUT') {
-      errorCode = '408'
-      errorStatus = http.STATUS_CODES[errorCode]
-      body = `{"error":"${errorStatus}","message":"Client Timeout","statusCode":408}`
-      errorLabel = 'timeout'
-    } else if (err.code === 'HPE_HEADER_OVERFLOW') {
-      errorCode = '431'
-      errorStatus = http.STATUS_CODES[errorCode]
-      body = `{"error":"${errorStatus}","message":"Exceeded maximum allowed HTTP header size","statusCode":431}`
-      errorLabel = 'header_overflow'
-    } else {
-      errorCode = '400'
-      errorStatus = http.STATUS_CODES[errorCode]
-      body = `{"error":"${errorStatus}","message":"Client Error","statusCode":400}`
-      errorLabel = 'error'
-    }
-
-    // Most devs do not know what to do with this error.
-    // In the vast majority of cases, it's a network error and/or some
-    // config issue on the load balancer side.
-    this.log.trace({ err }, `client ${errorLabel}`)
-    // Copying standard node behavior
-    // https://github.com/nodejs/node/blob/6ca23d7846cb47e84fd344543e394e50938540be/lib/_http_server.js#L666
-
-    // If the socket is not writable, there is no reason to try to send data.
-    if (socket.writable) {
-      socket.write(`HTTP/1.1 ${errorCode} ${errorStatus}\r\nContent-Length: ${body.length}\r\nContent-Type: application/json\r\n\r\n${body}`)
-    }
-    socket.destroy(err)
-  }
-
   // If the router does not match any route, every request will land here
   // req and res are Node.js core objects
   function defaultRoute (req, res) {
@@ -770,9 +636,9 @@ function fastify (options) {
   }
 
   function onBadUrl (path, req, res) {
-    if (frameworkErrors) {
+    if (options.frameworkErrors) {
       const id = getGenReqId(onBadUrlContext.server, req)
-      const childLogger = createChildLogger(onBadUrlContext, logger, req, id)
+      const childLogger = createChildLogger(onBadUrlContext, options.logger, req, id)
 
       const request = new Request(id, null, req, null, childLogger, onBadUrlContext)
       const reply = new Reply(res, request, childLogger)
@@ -781,7 +647,7 @@ function fastify (options) {
         childLogger.info({ req: request }, 'incoming request')
       }
 
-      return frameworkErrors(new FST_ERR_BAD_URL(path), request, reply)
+      return options.frameworkErrors(new FST_ERR_BAD_URL(path), request, reply)
     }
     const body = `{"error":"Bad Request","code":"FST_ERR_BAD_URL","message":"'${path}' is not a valid url component","statusCode":400}`
     res.writeHead(400, {
@@ -795,9 +661,9 @@ function fastify (options) {
     if (isAsync === false) return undefined
     return function onAsyncConstraintError (err) {
       if (err) {
-        if (frameworkErrors) {
+        if (options.frameworkErrors) {
           const id = getGenReqId(onBadUrlContext.server, req)
-          const childLogger = createChildLogger(onBadUrlContext, logger, req, id)
+          const childLogger = createChildLogger(onBadUrlContext, options.logger, req, id)
 
           const request = new Request(id, null, req, null, childLogger, onBadUrlContext)
           const reply = new Reply(res, request, childLogger)
@@ -806,7 +672,7 @@ function fastify (options) {
             childLogger.info({ req: request }, 'incoming request')
           }
 
-          return frameworkErrors(new FST_ERR_ASYNC_CONSTRAINT(), request, reply)
+          return options.frameworkErrors(new FST_ERR_ASYNC_CONSTRAINT(), request, reply)
         }
         const body = '{"error":"Internal Server Error","message":"Unexpected error from async constraint","statusCode":500}'
         res.writeHead(500, {
@@ -847,7 +713,10 @@ function fastify (options) {
   function setSchemaController (schemaControllerOpts) {
     throwIfAlreadyStarted('Cannot call "setSchemaController"!')
     const old = this[kSchemaController]
-    const schemaController = SchemaController.buildSchemaController(old, Object.assign({}, old.opts, schemaControllerOpts))
+    const schemaController = SchemaController.buildSchemaController(
+      old,
+      Object.assign({}, old.opts, schemaControllerOpts)
+    )
     this[kSchemaController] = schemaController
     this.getSchema = schemaController.getSchema.bind(schemaController)
     this.getSchemas = schemaController.getSchemas.bind(schemaController)
@@ -889,7 +758,9 @@ function fastify (options) {
 
   function printRoutes (opts = {}) {
     // includeHooks:true - shortcut to include all supported hooks exported by fastify.Hooks
-    opts.includeMeta = opts.includeHooks ? opts.includeMeta ? supportedHooks.concat(opts.includeMeta) : supportedHooks : opts.includeMeta
+    opts.includeMeta = opts.includeHooks
+      ? opts.includeMeta ? supportedHooks.concat(opts.includeMeta) : supportedHooks
+      : opts.includeMeta
     return router.printRoutes(opts)
   }
 
@@ -943,6 +814,145 @@ function fastify (options) {
   }
 }
 
+function processOptions (options, defaultRoute, onBadUrl) {
+  // Options validations
+  if (options && typeof options !== 'object') {
+    throw new FST_ERR_OPTIONS_NOT_OBJ()
+  } else {
+    // Shallow copy options object to prevent mutations outside of this function
+    options = Object.assign({}, options)
+  }
+
+  if (
+    (options.querystringParser && typeof options.querystringParser !== 'function') ||
+    (
+      options.routerOptions?.querystringParser &&
+      typeof options.routerOptions.querystringParser !== 'function'
+    )
+  ) {
+    throw new FST_ERR_QSP_NOT_FN(typeof (options.querystringParser ?? options.routerOptions.querystringParser))
+  }
+
+  if (options.schemaController && options.schemaController.bucket && typeof options.schemaController.bucket !== 'function') {
+    throw new FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN(typeof options.schemaController.bucket)
+  }
+
+  validateBodyLimitOption(options.bodyLimit)
+
+  const requestIdHeader = typeof options.requestIdHeader === 'string' && options.requestIdHeader.length !== 0 ? options.requestIdHeader.toLowerCase() : (options.requestIdHeader === true && 'request-id')
+  const genReqId = reqIdGenFactory(requestIdHeader, options.genReqId)
+  const requestIdLogLabel = options.requestIdLogLabel || 'reqId'
+  options.bodyLimit = options.bodyLimit || defaultInitOptions.bodyLimit
+  const disableRequestLogging = options.disableRequestLogging || false
+
+  const ajvOptions = Object.assign({
+    customOptions: {},
+    plugins: []
+  }, options.ajv)
+
+  if (!ajvOptions.customOptions || Object.prototype.toString.call(ajvOptions.customOptions) !== '[object Object]') {
+    throw new FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ(typeof ajvOptions.customOptions)
+  }
+  if (!ajvOptions.plugins || !Array.isArray(ajvOptions.plugins)) {
+    throw new FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR(typeof ajvOptions.plugins)
+  }
+
+  const { logger, hasLogger } = createLogger(options)
+
+  // Update the options with the fixed values
+  options.connectionTimeout = options.connectionTimeout || defaultInitOptions.connectionTimeout
+  options.keepAliveTimeout = options.keepAliveTimeout || defaultInitOptions.keepAliveTimeout
+  options.maxRequestsPerSocket = options.maxRequestsPerSocket || defaultInitOptions.maxRequestsPerSocket
+  options.requestTimeout = options.requestTimeout || defaultInitOptions.requestTimeout
+  options.logger = logger
+  options.requestIdHeader = requestIdHeader
+  options.requestIdLogLabel = requestIdLogLabel
+  options.disableRequestLogging = disableRequestLogging
+  options.ajv = ajvOptions
+  options.clientErrorHandler = options.clientErrorHandler || defaultClientErrorHandler
+  options.allowErrorHandlerOverride = options.allowErrorHandlerOverride ?? defaultInitOptions.allowErrorHandlerOverride
+
+  const initialConfig = getSecuredInitialConfig(options)
+
+  // exposeHeadRoutes have its default set from the validator
+  options.exposeHeadRoutes = initialConfig.exposeHeadRoutes
+
+  // we need to set this before calling createServer
+  options.http2SessionTimeout = initialConfig.http2SessionTimeout
+
+  options.routerOptions = buildRouterOptions(options, {
+    defaultRoute,
+    onBadUrl,
+    ignoreTrailingSlash: defaultInitOptions.ignoreTrailingSlash,
+    ignoreDuplicateSlashes: defaultInitOptions.ignoreDuplicateSlashes,
+    maxParamLength: defaultInitOptions.maxParamLength,
+    allowUnsafeRegex: defaultInitOptions.allowUnsafeRegex,
+    buildPrettyMeta: defaultBuildPrettyMeta,
+    useSemicolonDelimiter: defaultInitOptions.useSemicolonDelimiter
+  })
+
+  return {
+    options,
+    genReqId,
+    disableRequestLogging,
+    hasLogger,
+    initialConfig
+  }
+}
+
+function defaultBuildPrettyMeta (route) {
+  // return a shallow copy of route's sanitized context
+
+  const cleanKeys = {}
+  const allowedProps = ['errorHandler', 'logLevel', 'logSerializers']
+
+  allowedProps.concat(supportedHooks).forEach(k => {
+    cleanKeys[k] = route.store[k]
+  })
+
+  return Object.assign({}, cleanKeys)
+}
+
+function defaultClientErrorHandler (err, socket) {
+  // In case of a connection reset, the socket has been destroyed and there is nothing that needs to be done.
+  // https://nodejs.org/api/http.html#http_event_clienterror
+  if (err.code === 'ECONNRESET' || socket.destroyed) {
+    return
+  }
+
+  let body, errorCode, errorStatus, errorLabel
+
+  if (err.code === 'ERR_HTTP_REQUEST_TIMEOUT') {
+    errorCode = '408'
+    errorStatus = http.STATUS_CODES[errorCode]
+    body = `{"error":"${errorStatus}","message":"Client Timeout","statusCode":408}`
+    errorLabel = 'timeout'
+  } else if (err.code === 'HPE_HEADER_OVERFLOW') {
+    errorCode = '431'
+    errorStatus = http.STATUS_CODES[errorCode]
+    body = `{"error":"${errorStatus}","message":"Exceeded maximum allowed HTTP header size","statusCode":431}`
+    errorLabel = 'header_overflow'
+  } else {
+    errorCode = '400'
+    errorStatus = http.STATUS_CODES[errorCode]
+    body = `{"error":"${errorStatus}","message":"Client Error","statusCode":400}`
+    errorLabel = 'error'
+  }
+
+  // Most devs do not know what to do with this error.
+  // In the vast majority of cases, it's a network error and/or some
+  // config issue on the load balancer side.
+  this.log.trace({ err }, `client ${errorLabel}`)
+  // Copying standard node behavior
+  // https://github.com/nodejs/node/blob/6ca23d7846cb47e84fd344543e394e50938540be/lib/_http_server.js#L666
+
+  // If the socket is not writable, there is no reason to try to send data.
+  if (socket.writable) {
+    socket.write(`HTTP/1.1 ${errorCode} ${errorStatus}\r\nContent-Length: ${body.length}\r\nContent-Type: application/json\r\n\r\n${body}`)
+  }
+  socket.destroy(err)
+}
+
 function validateSchemaErrorFormatter (schemaErrorFormatter) {
   if (typeof schemaErrorFormatter !== 'function') {
     throw new FST_ERR_SCHEMA_ERROR_FORMATTER_NOT_FN(typeof schemaErrorFormatter)

package/lib/{contentTypeParser.js → content-type-parser.js}

@@ -121,7 +121,8 @@ ContentTypeParser.prototype.getParser = function (contentType) {
       (
         caseInsensitiveContentType.length === parserListItem.length ||
         caseInsensitiveContentType.charCodeAt(parserListItem.length) === 59 /* `;` */ ||
-        caseInsensitiveContentType.charCodeAt(parserListItem.length) === 32 /* ` ` */
+        caseInsensitiveContentType.charCodeAt(parserListItem.length) === 32 /* ` ` */ ||
+        caseInsensitiveContentType.charCodeAt(parserListItem.length) === 9  /* `\t` */
       )
     ) {
       parser = this.customParsers.get(parserListItem)

package/lib/error-handler.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const statusCodes = require('node:http').STATUS_CODES
-const wrapThenable = require('./wrapThenable')
+const wrapThenable = require('./wrap-thenable.js')
 const {
   kReplyHeaders,
   kReplyNextErrorHandler,
@@ -82,7 +82,7 @@ function handleError (reply, error, cb) {
 function defaultErrorHandler (error, request, reply) {
   setErrorHeaders(error, reply)
   if (!reply[kReplyHasStatusCode] || reply.statusCode === 200) {
-    const statusCode = error.statusCode || error.status
+    const statusCode = error && (error.statusCode || error.status)
     reply.code(statusCode >= 400 ? statusCode : 500)
   }
   if (reply.statusCode < 500) {

package/lib/{fourOhFour.js → four-oh-four.js}

@@ -19,7 +19,7 @@ const {
   FST_ERR_NOT_FOUND
 } = require('./errors')
 const { createChildLogger } = require('./logger-factory')
-const { getGenReqId } = require('./reqIdGenFactory.js')
+const { getGenReqId } = require('./req-id-gen-factory.js')
 
 /**
  * Each fastify instance have a:
@@ -150,7 +150,9 @@ function fourOhFour (options) {
           .map(h => h.bind(this))
         context[hook] = toSet.length ? toSet : null
       }
-      context.errorHandler = opts.errorHandler ? buildErrorHandler(this[kErrorHandler], opts.errorHandler) : this[kErrorHandler]
+      context.errorHandler = opts.errorHandler
+        ? buildErrorHandler(this[kErrorHandler], opts.errorHandler)
+        : this[kErrorHandler]
     })
 
     if (this[kFourOhFourContext] !== null && prefix === '/') {

package/lib/{handleRequest.js → handle-request.js}

@@ -3,7 +3,7 @@
 const diagnostics = require('node:diagnostics_channel')
 const { validate: validateSchema } = require('./validation')
 const { preValidationHookRunner, preHandlerHookRunner } = require('./hooks')
-const wrapThenable = require('./wrapThenable')
+const wrapThenable = require('./wrap-thenable')
 const {
   kReplyIsError,
   kRouteContext,

package/lib/{headRoute.js → head-route.js}

@@ -7,6 +7,7 @@ function headRouteOnSendHandler (req, reply, payload, done) {
     return
   }
 
+  // node:stream
   if (typeof payload.resume === 'function') {
     payload.on('error', (err) => {
       reply.log.error({ err }, 'Error on Stream found for HEAD route')
@@ -16,6 +17,15 @@ function headRouteOnSendHandler (req, reply, payload, done) {
     return
   }
 
+  // node:stream/web
+  if (typeof payload.getReader === 'function') {
+    payload.cancel('Stream cancelled by HEAD route').catch((err) => {
+      reply.log.error({ err }, 'Error on Stream found for HEAD route')
+    })
+    done(null, null)
+    return
+  }
+
   const size = '' + Buffer.byteLength(payload)
 
   reply.header('content-length', size)
@@ -25,7 +35,9 @@ function headRouteOnSendHandler (req, reply, payload, done) {
 
 function parseHeadOnSendHandlers (onSendHandlers) {
   if (onSendHandlers == null) return headRouteOnSendHandler
-  return Array.isArray(onSendHandlers) ? [...onSendHandlers, headRouteOnSendHandler] : [onSendHandlers, headRouteOnSendHandler]
+  return Array.isArray(onSendHandlers)
+    ? [...onSendHandlers, headRouteOnSendHandler]
+    : [onSendHandlers, headRouteOnSendHandler]
 }
 
 module.exports = {

package/lib/{initialConfigValidation.js → initial-config-validation.js}

@@ -1,6 +1,6 @@
 'use strict'
 
-const validate = require('./configValidator')
+const validate = require('./config-validator')
 const deepClone = require('rfdc')({ circles: true, proto: false })
 const { FST_ERR_INIT_OPTS_INVALID } = require('./errors')
 

package/lib/{pluginOverride.js → plugin-override.js}

@@ -19,9 +19,9 @@ const {
 const Reply = require('./reply')
 const Request = require('./request')
 const SchemaController = require('./schema-controller')
-const ContentTypeParser = require('./contentTypeParser')
+const ContentTypeParser = require('./content-type-parser.js')
 const { buildHooks } = require('./hooks')
-const pluginUtils = require('./pluginUtils')
+const pluginUtils = require('./plugin-utils.js')
 
 // Function that runs the encapsulation magic.
 // Everything that need to be encapsulated must be handled in this function.

package/lib/{pluginUtils.js → plugin-utils.js}

@@ -6,12 +6,12 @@ const kRegisteredPlugins = Symbol.for('registered-plugin')
 const {
   kTestInternals
 } = require('./symbols.js')
-const { exist, existReply, existRequest } = require('./decorate')
+const { exist, existReply, existRequest } = require('./decorate.js')
 const {
   FST_ERR_PLUGIN_VERSION_MISMATCH,
   FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE,
   FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER
-} = require('./errors')
+} = require('./errors.js')
 
 const rcRegex = /-(?:rc|pre|alpha).+$/u
 

package/lib/reply.js

@@ -31,7 +31,7 @@ const {
   preSerializationHookRunner
 } = require('./hooks')
 
-const internals = require('./handleRequest')[Symbol.for('internals')]
+const internals = require('./handle-request.js')[Symbol.for('internals')]
 const loggerUtils = require('./logger-factory')
 const now = loggerUtils.now
 const { handleError } = require('./error-handler')
@@ -166,7 +166,9 @@ Reply.prototype.send = function (payload) {
       if (!hasContentType) {
         this[kReplyHeaders]['content-type'] = CONTENT_TYPE.OCTET
       }
-      const payloadToSend = Buffer.isBuffer(payload) ? payload : Buffer.from(payload.buffer, payload.byteOffset, payload.byteLength)
+      const payloadToSend = Buffer.isBuffer(payload)
+        ? payload
+        : Buffer.from(payload.buffer, payload.byteOffset, payload.byteLength)
       onSendHook(this, payloadToSend)
       return this
     }
@@ -681,7 +683,7 @@ function logStreamError (logger, err, res) {
 
 function sendWebStream (payload, res, reply) {
   if (payload.locked) {
-    throw FST_ERR_REP_READABLE_STREAM_LOCKED()
+    throw new FST_ERR_REP_READABLE_STREAM_LOCKED()
   }
   const nodeStream = Readable.fromWeb(payload)
   sendStream(nodeStream, res, reply)

package/lib/request.js

@@ -226,6 +226,11 @@ Object.defineProperties(Request.prototype, {
   },
   hostname: {
     get () {
+      // Check for IPV6 Host
+      if (this.host[0] === '[') {
+        return this.host.slice(0, this.host.indexOf(']') + 1)
+      }
+
       return this.host.split(':', 1)[0]
     }
   },