node-fastify 5.8.3

package/lib/handle-request.js

@@ -0,0 +1,195 @@
+'use strict'
+
+const diagnostics = require('node:diagnostics_channel')
+const ContentType = require('./content-type')
+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 { setErrorStatusCode } = require('./error-status')
+const {
+  kReplyIsError,
+  kRouteContext,
+  kFourOhFourContext,
+  kSupportedHTTPMethods
+} = require('./symbols')
+
+const channels = diagnostics.tracingChannel('fastify.request.handler')
+
+function handleRequest (err, request, reply) {
+  if (reply.sent === true) return
+  if (err != null) {
+    reply[kReplyIsError] = true
+    reply.send(err)
+    return
+  }
+
+  const method = request.method
+
+  if (this[kSupportedHTTPMethods].bodyless.has(method)) {
+    handler(request, reply)
+    return
+  }
+
+  if (this[kSupportedHTTPMethods].bodywith.has(method)) {
+    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 (isEmptyBody) {
+        // Request has no body to parse
+        handler(request, reply)
+        return
+      }
+
+      request[kRouteContext].contentTypeParser.run('', handler, request, reply)
+      return
+    }
+
+    const contentType = new ContentType(ctHeader)
+    if (contentType.isValid === false) {
+      reply[kReplyIsError] = true
+      reply.status(415).send(new FST_ERR_CTP_INVALID_MEDIA_TYPE())
+      return
+    }
+    request[kRouteContext].contentTypeParser.run(contentType.toString(), handler, request, reply)
+    return
+  }
+
+  // Return 404 instead of 405 see https://github.com/fastify/fastify/pull/862 for discussion
+  handler(request, reply)
+}
+
+function handler (request, reply) {
+  try {
+    if (request[kRouteContext].preValidation !== null) {
+      preValidationHookRunner(
+        request[kRouteContext].preValidation,
+        request,
+        reply,
+        preValidationCallback
+      )
+    } else {
+      preValidationCallback(null, request, reply)
+    }
+  } catch (err) {
+    preValidationCallback(err, request, reply)
+  }
+}
+
+function preValidationCallback (err, request, reply) {
+  if (reply.sent === true) return
+
+  if (err != null) {
+    reply[kReplyIsError] = true
+    reply.send(err)
+    return
+  }
+
+  const validationErr = validateSchema(reply[kRouteContext], request)
+  const isAsync = (validationErr && typeof validationErr.then === 'function') || false
+
+  if (isAsync) {
+    const cb = validationCompleted.bind(null, request, reply)
+    validationErr.then(cb, cb)
+  } else {
+    validationCompleted(request, reply, validationErr)
+  }
+}
+
+function validationCompleted (request, reply, validationErr) {
+  if (validationErr) {
+    if (reply[kRouteContext].attachValidation === false) {
+      reply.send(validationErr)
+      return
+    }
+
+    reply.request.validationError = validationErr
+  }
+
+  // preHandler hook
+  if (request[kRouteContext].preHandler !== null) {
+    preHandlerHookRunner(
+      request[kRouteContext].preHandler,
+      request,
+      reply,
+      preHandlerCallback
+    )
+  } else {
+    preHandlerCallback(null, request, reply)
+  }
+}
+
+function preHandlerCallback (err, request, reply) {
+  if (reply.sent) return
+
+  const context = request[kRouteContext]
+
+  if (!channels.hasSubscribers || context[kFourOhFourContext] === null) {
+    preHandlerCallbackInner(err, request, reply)
+  } else {
+    const store = {
+      request,
+      reply,
+      async: false,
+      route: {
+        url: context.config.url,
+        method: context.config.method
+      }
+    }
+    channels.start.runStores(store, preHandlerCallbackInner, undefined, err, request, reply, store)
+  }
+}
+
+function preHandlerCallbackInner (err, request, reply, store) {
+  const context = request[kRouteContext]
+
+  try {
+    if (err != null) {
+      reply[kReplyIsError] = true
+      if (store) {
+        store.error = err
+        // Set status code before publishing so subscribers see the correct value
+        setErrorStatusCode(reply, err)
+        channels.error.publish(store)
+      }
+      reply.send(err)
+      return
+    }
+
+    let result
+
+    try {
+      result = context.handler(request, reply)
+    } catch (err) {
+      if (store) {
+        store.error = err
+        // Set status code before publishing so subscribers see the correct value
+        setErrorStatusCode(reply, err)
+        channels.error.publish(store)
+      }
+
+      reply[kReplyIsError] = true
+      reply.send(err)
+      return
+    }
+
+    if (result !== undefined) {
+      if (result !== null && typeof result.then === 'function') {
+        wrapThenable(result, reply, store)
+      } else {
+        reply.send(result)
+      }
+    }
+  } finally {
+    if (store) channels.end.publish(store)
+  }
+}
+
+module.exports = handleRequest
+module.exports[Symbol.for('internals')] = { handler, preHandlerCallback }

package/lib/head-route.js

@@ -0,0 +1,45 @@
+'use strict'
+function headRouteOnSendHandler (req, reply, payload, done) {
+  // If payload is undefined
+  if (payload === undefined) {
+    reply.header('content-length', '0')
+    done(null, null)
+    return
+  }
+
+  // node:stream
+  if (typeof payload.resume === 'function') {
+    payload.on('error', (err) => {
+      reply.log.error({ err }, 'Error on Stream found for HEAD route')
+    })
+    payload.resume()
+    done(null, null)
+    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)
+
+  done(null, null)
+}
+
+function parseHeadOnSendHandlers (onSendHandlers) {
+  if (onSendHandlers == null) return headRouteOnSendHandler
+  return Array.isArray(onSendHandlers)
+    ? [...onSendHandlers, headRouteOnSendHandler]
+    : [onSendHandlers, headRouteOnSendHandler]
+}
+
+module.exports = {
+  parseHeadOnSendHandlers
+}

package/lib/hooks.js

@@ -0,0 +1,429 @@
+'use strict'
+
+const applicationHooks = [
+  'onRoute',
+  'onRegister',
+  'onReady',
+  'onListen',
+  'preClose',
+  'onClose'
+]
+const lifecycleHooks = [
+  'onTimeout',
+  'onRequest',
+  'preParsing',
+  'preValidation',
+  'preSerialization',
+  'preHandler',
+  'onSend',
+  'onResponse',
+  'onError',
+  'onRequestAbort'
+]
+const supportedHooks = lifecycleHooks.concat(applicationHooks)
+const {
+  FST_ERR_HOOK_INVALID_TYPE,
+  FST_ERR_HOOK_INVALID_HANDLER,
+  FST_ERR_SEND_UNDEFINED_ERR,
+  FST_ERR_HOOK_TIMEOUT,
+  FST_ERR_HOOK_NOT_SUPPORTED,
+  AVVIO_ERRORS_MAP,
+  appendStackTrace
+} = require('./errors')
+
+const {
+  kChildren,
+  kHooks,
+  kRequestPayloadStream
+} = require('./symbols')
+
+function Hooks () {
+  this.onRequest = []
+  this.preParsing = []
+  this.preValidation = []
+  this.preSerialization = []
+  this.preHandler = []
+  this.onResponse = []
+  this.onSend = []
+  this.onError = []
+  this.onRoute = []
+  this.onRegister = []
+  this.onReady = []
+  this.onListen = []
+  this.onTimeout = []
+  this.onRequestAbort = []
+  this.preClose = []
+}
+
+Hooks.prototype = Object.create(null)
+
+Hooks.prototype.validate = function (hook, fn) {
+  if (typeof hook !== 'string') throw new FST_ERR_HOOK_INVALID_TYPE()
+  if (Array.isArray(this[hook]) === false) {
+    throw new FST_ERR_HOOK_NOT_SUPPORTED(hook)
+  }
+  if (typeof fn !== 'function') throw new FST_ERR_HOOK_INVALID_HANDLER(hook, Object.prototype.toString.call(fn))
+}
+
+Hooks.prototype.add = function (hook, fn) {
+  this.validate(hook, fn)
+  this[hook].push(fn)
+}
+
+function buildHooks (h) {
+  const hooks = new Hooks()
+  hooks.onRequest = h.onRequest.slice()
+  hooks.preParsing = h.preParsing.slice()
+  hooks.preValidation = h.preValidation.slice()
+  hooks.preSerialization = h.preSerialization.slice()
+  hooks.preHandler = h.preHandler.slice()
+  hooks.onSend = h.onSend.slice()
+  hooks.onResponse = h.onResponse.slice()
+  hooks.onError = h.onError.slice()
+  hooks.onRoute = h.onRoute.slice()
+  hooks.onRegister = h.onRegister.slice()
+  hooks.onTimeout = h.onTimeout.slice()
+  hooks.onRequestAbort = h.onRequestAbort.slice()
+  hooks.onReady = []
+  hooks.onListen = []
+  hooks.preClose = []
+  return hooks
+}
+
+function hookRunnerApplication (hookName, boot, server, cb) {
+  const hooks = server[kHooks][hookName]
+  let i = 0
+  let c = 0
+
+  next()
+
+  function exit (err) {
+    const hookFnName = hooks[i - 1]?.name
+    const hookFnFragment = hookFnName ? ` "${hookFnName}"` : ''
+
+    if (err) {
+      if (err.code === 'AVV_ERR_READY_TIMEOUT') {
+        err = appendStackTrace(err, new FST_ERR_HOOK_TIMEOUT(hookName, hookFnFragment))
+      } else {
+        err = AVVIO_ERRORS_MAP[err.code] != null
+          ? appendStackTrace(err, new AVVIO_ERRORS_MAP[err.code](err.message))
+          : err
+      }
+
+      cb(err)
+      return
+    }
+    cb()
+  }
+
+  function next (err) {
+    if (err) {
+      exit(err)
+      return
+    }
+
+    if (i === hooks.length && c === server[kChildren].length) {
+      if (i === 0 && c === 0) { // speed up start
+        exit()
+      } else {
+        // This is the last function executed for every fastify instance
+        boot(function manageTimeout (err, done) {
+          // this callback is needed by fastify to provide an hook interface without the error
+          // as first parameter and managing it on behalf the user
+          exit(err)
+
+          // this callback is needed by avvio to continue the loading of the next `register` plugins
+          done(err)
+        })
+      }
+      return
+    }
+
+    if (i === hooks.length && c < server[kChildren].length) {
+      const child = server[kChildren][c++]
+      hookRunnerApplication(hookName, boot, child, next)
+      return
+    }
+
+    boot(wrap(hooks[i++], server))
+    next()
+  }
+
+  function wrap (fn, server) {
+    return function (err, done) {
+      if (err) {
+        done(err)
+        return
+      }
+
+      if (fn.length === 1) {
+        try {
+          fn.call(server, done)
+        } catch (error) {
+          done(error)
+        }
+        return
+      }
+
+      try {
+        const ret = fn.call(server)
+        if (ret && typeof ret.then === 'function') {
+          ret.then(done, done)
+          return
+        }
+      } catch (error) {
+        err = error
+      }
+
+      done(err) // auto done
+    }
+  }
+}
+
+function onListenHookRunner (server) {
+  const hooks = server[kHooks].onListen
+  const hooksLen = hooks.length
+
+  let i = 0
+  let c = 0
+
+  next()
+
+  function next (err) {
+    err && server.log.error(err)
+
+    if (
+      i === hooksLen
+    ) {
+      while (c < server[kChildren].length) {
+        const child = server[kChildren][c++]
+        onListenHookRunner(child)
+      }
+      return
+    }
+
+    wrap(hooks[i++], server, next)
+  }
+
+  async function wrap (fn, server, done) {
+    if (fn.length === 1) {
+      try {
+        fn.call(server, done)
+      } catch (e) {
+        done(e)
+      }
+      return
+    }
+    try {
+      const ret = fn.call(server)
+      if (ret && typeof ret.then === 'function') {
+        ret.then(done, done)
+        return
+      }
+      done()
+    } catch (error) {
+      done(error)
+    }
+  }
+}
+
+function hookRunnerGenerator (iterator) {
+  return function hookRunner (functions, request, reply, cb) {
+    let i = 0
+
+    function next (err) {
+      if (err || i === functions.length) {
+        cb(err, request, reply)
+        return
+      }
+
+      let result
+      try {
+        result = iterator(functions[i++], request, reply, next)
+      } catch (error) {
+        cb(error, request, reply)
+        return
+      }
+      if (result && typeof result.then === 'function') {
+        result.then(handleResolve, handleReject)
+      }
+    }
+
+    function handleResolve () {
+      next()
+    }
+
+    function handleReject (err) {
+      if (!err) {
+        err = new FST_ERR_SEND_UNDEFINED_ERR()
+      }
+
+      cb(err, request, reply)
+    }
+
+    next()
+  }
+}
+
+function onResponseHookIterator (fn, request, reply, next) {
+  return fn(request, reply, next)
+}
+
+const onResponseHookRunner = hookRunnerGenerator(onResponseHookIterator)
+const preValidationHookRunner = hookRunnerGenerator(hookIterator)
+const preHandlerHookRunner = hookRunnerGenerator(hookIterator)
+const onTimeoutHookRunner = hookRunnerGenerator(hookIterator)
+const onRequestHookRunner = hookRunnerGenerator(hookIterator)
+
+function onSendHookRunner (functions, request, reply, payload, cb) {
+  let i = 0
+
+  function next (err, newPayload) {
+    if (err) {
+      cb(err, request, reply, payload)
+      return
+    }
+
+    if (newPayload !== undefined) {
+      payload = newPayload
+    }
+
+    if (i === functions.length) {
+      cb(null, request, reply, payload)
+      return
+    }
+
+    let result
+    try {
+      result = functions[i++](request, reply, payload, next)
+    } catch (error) {
+      cb(error, request, reply)
+      return
+    }
+    if (result && typeof result.then === 'function') {
+      result.then(handleResolve, handleReject)
+    }
+  }
+
+  function handleResolve (newPayload) {
+    next(null, newPayload)
+  }
+
+  function handleReject (err) {
+    if (!err) {
+      err = new FST_ERR_SEND_UNDEFINED_ERR()
+    }
+
+    cb(err, request, reply, payload)
+  }
+
+  next()
+}
+
+const preSerializationHookRunner = onSendHookRunner
+
+function preParsingHookRunner (functions, request, reply, cb) {
+  let i = 0
+
+  function next (err, newPayload) {
+    if (reply.sent) {
+      return
+    }
+
+    if (newPayload !== undefined) {
+      request[kRequestPayloadStream] = newPayload
+    }
+
+    if (err || i === functions.length) {
+      cb(err, request, reply)
+      return
+    }
+
+    let result
+    try {
+      result = functions[i++](request, reply, request[kRequestPayloadStream], next)
+    } catch (error) {
+      cb(error, request, reply)
+      return
+    }
+
+    if (result && typeof result.then === 'function') {
+      result.then(handleResolve, handleReject)
+    }
+  }
+
+  function handleResolve (newPayload) {
+    next(null, newPayload)
+  }
+
+  function handleReject (err) {
+    if (!err) {
+      err = new FST_ERR_SEND_UNDEFINED_ERR()
+    }
+
+    cb(err, request, reply)
+  }
+
+  next()
+}
+
+function onRequestAbortHookRunner (functions, request, cb) {
+  let i = 0
+
+  function next (err) {
+    if (err || i === functions.length) {
+      cb(err, request)
+      return
+    }
+
+    let result
+    try {
+      result = functions[i++](request, next)
+    } catch (error) {
+      cb(error, request)
+      return
+    }
+    if (result && typeof result.then === 'function') {
+      result.then(handleResolve, handleReject)
+    }
+  }
+
+  function handleResolve () {
+    next()
+  }
+
+  function handleReject (err) {
+    if (!err) {
+      err = new FST_ERR_SEND_UNDEFINED_ERR()
+    }
+
+    cb(err, request)
+  }
+
+  next()
+}
+
+function hookIterator (fn, request, reply, next) {
+  if (reply.sent === true) return undefined
+  return fn(request, reply, next)
+}
+
+module.exports = {
+  Hooks,
+  buildHooks,
+  hookRunnerGenerator,
+  preParsingHookRunner,
+  onResponseHookRunner,
+  onSendHookRunner,
+  preSerializationHookRunner,
+  onRequestAbortHookRunner,
+  hookIterator,
+  hookRunnerApplication,
+  onListenHookRunner,
+  preHandlerHookRunner,
+  preValidationHookRunner,
+  onRequestHookRunner,
+  onTimeoutHookRunner,
+  lifecycleHooks,
+  supportedHooks
+}

package/lib/initial-config-validation.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const validate = require('./config-validator')
+const deepClone = require('rfdc')({ circles: true, proto: false })
+const { FST_ERR_INIT_OPTS_INVALID } = require('./errors')
+
+function validateInitialConfig (options) {
+  const opts = deepClone(options)
+
+  if (!validate(opts)) {
+    const error = new FST_ERR_INIT_OPTS_INVALID(JSON.stringify(validate.errors.map(e => e.message)))
+    error.errors = validate.errors
+    throw error
+  }
+
+  return deepFreezeObject(opts)
+}
+
+function deepFreezeObject (object) {
+  const properties = Object.getOwnPropertyNames(object)
+
+  for (const name of properties) {
+    const value = object[name]
+
+    if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
+      continue
+    }
+
+    object[name] = value && typeof value === 'object' ? deepFreezeObject(value) : value
+  }
+
+  return Object.freeze(object)
+}
+
+module.exports = validateInitialConfig
+module.exports.defaultInitOptions = validate.defaultInitOptions
+module.exports.utils = { deepFreezeObject }