node-fastify 5.8.3

package/lib/logger-factory.js

@@ -0,0 +1,136 @@
+'use strict'
+
+const {
+  FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED,
+  FST_ERR_LOG_INVALID_LOGGER_CONFIG,
+  FST_ERR_LOG_INVALID_LOGGER_INSTANCE,
+  FST_ERR_LOG_INVALID_LOGGER
+} = require('./errors')
+
+/**
+ * Utility for creating a child logger with the appropriate bindings, logger factory
+ * and validation.
+ * @param {object} context
+ * @param {import('../fastify').FastifyBaseLogger} logger
+ * @param {import('../fastify').RawRequestDefaultExpression<any>} req
+ * @param {string} reqId
+ * @param {import('../types/logger.js').ChildLoggerOptions?} loggerOpts
+ *
+ * @returns {object} New logger instance, inheriting all parent bindings,
+ * with child bindings added.
+ */
+function createChildLogger (context, logger, req, reqId, loggerOpts) {
+  const loggerBindings = {
+    [context.requestIdLogLabel]: reqId
+  }
+  const child = context.childLoggerFactory.call(context.server, logger, loggerBindings, loggerOpts || {}, req)
+
+  // Optimization: bypass validation if the factory is our own default factory
+  if (context.childLoggerFactory !== defaultChildLoggerFactory) {
+    validateLogger(child, true) // throw if the child is not a valid logger
+  }
+
+  return child
+}
+
+/** Default factory to create child logger instance
+ *
+ * @param {import('../fastify.js').FastifyBaseLogger} logger
+ * @param {import('../types/logger.js').Bindings} bindings
+ * @param {import('../types/logger.js').ChildLoggerOptions} opts
+ *
+ * @returns {import('../types/logger.js').FastifyBaseLogger}
+ */
+function defaultChildLoggerFactory (logger, bindings, opts) {
+  return logger.child(bindings, opts)
+}
+
+/**
+ * Determines if a provided logger object meets the requirements
+ * of a Fastify compatible logger.
+ *
+ * @param {object} logger Object to validate.
+ * @param {boolean?} strict `true` if the object must be a logger (always throw if any methods missing)
+ *
+ * @returns {boolean} `true` when the logger meets the requirements.
+ *
+ * @throws {FST_ERR_LOG_INVALID_LOGGER} When the logger object is
+ * missing required methods.
+ */
+function validateLogger (logger, strict) {
+  const methods = ['info', 'error', 'debug', 'fatal', 'warn', 'trace', 'child']
+  const missingMethods = logger
+    ? methods.filter(method => !logger[method] || typeof logger[method] !== 'function')
+    : methods
+
+  if (!missingMethods.length) {
+    return true
+  } else if ((missingMethods.length === methods.length) && !strict) {
+    return false
+  } else {
+    throw FST_ERR_LOG_INVALID_LOGGER(missingMethods.join(','))
+  }
+}
+
+function createLogger (options) {
+  if (options.logger && options.loggerInstance) {
+    throw new FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED()
+  }
+
+  if (!options.loggerInstance && !options.logger) {
+    const nullLogger = require('abstract-logging')
+    const logger = nullLogger
+    logger.child = () => logger
+    return { logger, hasLogger: false }
+  }
+
+  const { createPinoLogger, serializers } = require('./logger-pino.js')
+
+  // check if the logger instance has all required properties
+  if (validateLogger(options.loggerInstance)) {
+    const logger = createPinoLogger({
+      logger: options.loggerInstance,
+      serializers: Object.assign({}, serializers, options.loggerInstance.serializers)
+    })
+    return { logger, hasLogger: true }
+  }
+
+  // if a logger instance is passed to logger, throw an exception
+  if (validateLogger(options.logger)) {
+    throw FST_ERR_LOG_INVALID_LOGGER_CONFIG()
+  }
+
+  if (options.loggerInstance) {
+    throw FST_ERR_LOG_INVALID_LOGGER_INSTANCE()
+  }
+
+  const localLoggerOptions = {}
+  if (Object.prototype.toString.call(options.logger) === '[object Object]') {
+    Reflect.ownKeys(options.logger).forEach(prop => {
+      Object.defineProperty(localLoggerOptions, prop, {
+        value: options.logger[prop],
+        writable: true,
+        enumerable: true,
+        configurable: true
+      })
+    })
+  }
+  localLoggerOptions.level = localLoggerOptions.level || 'info'
+  localLoggerOptions.serializers = Object.assign({}, serializers, localLoggerOptions.serializers)
+  options.logger = localLoggerOptions
+  const logger = createPinoLogger(options.logger)
+  return { logger, hasLogger: true }
+}
+
+function now () {
+  const ts = process.hrtime()
+  return (ts[0] * 1e3) + (ts[1] / 1e6)
+}
+
+module.exports = {
+  createChildLogger,
+  defaultChildLoggerFactory,
+  createLogger,
+  validateLogger,
+  now
+}

package/lib/logger-pino.js

@@ -0,0 +1,68 @@
+'use strict'
+
+/**
+ * Code imported from `pino-http`
+ * Repo: https://github.com/pinojs/pino-http
+ * License: MIT (https://raw.githubusercontent.com/pinojs/pino-http/master/LICENSE)
+ */
+
+const pino = require('pino')
+const { serializersSym } = pino.symbols
+const {
+  FST_ERR_LOG_INVALID_DESTINATION
+} = require('./errors')
+
+function createPinoLogger (opts) {
+  if (opts.stream && opts.file) {
+    throw new FST_ERR_LOG_INVALID_DESTINATION()
+  } else if (opts.file) {
+    // we do not have stream
+    opts.stream = pino.destination(opts.file)
+    delete opts.file
+  }
+
+  const prevLogger = opts.logger
+  const prevGenReqId = opts.genReqId
+  let logger = null
+
+  if (prevLogger) {
+    opts.logger = undefined
+    opts.genReqId = undefined
+    // we need to tap into pino internals because in v5 it supports
+    // adding serializers in child loggers
+    if (prevLogger[serializersSym]) {
+      opts.serializers = Object.assign({}, opts.serializers, prevLogger[serializersSym])
+    }
+    logger = prevLogger.child({}, opts)
+    opts.logger = prevLogger
+    opts.genReqId = prevGenReqId
+  } else {
+    logger = pino(opts, opts.stream)
+  }
+
+  return logger
+}
+
+const serializers = {
+  req: function asReqValue (req) {
+    return {
+      method: req.method,
+      url: req.url,
+      version: req.headers && req.headers['accept-version'],
+      host: req.host,
+      remoteAddress: req.ip,
+      remotePort: req.socket ? req.socket.remotePort : undefined
+    }
+  },
+  err: pino.stdSerializers.err,
+  res: function asResValue (reply) {
+    return {
+      statusCode: reply.statusCode
+    }
+  }
+}
+
+module.exports = {
+  serializers,
+  createPinoLogger
+}

package/lib/noop-set.js

@@ -0,0 +1,10 @@
+'use strict'
+
+module.exports = function noopSet () {
+  return {
+    [Symbol.iterator]: function * () {},
+    add () {},
+    delete () {},
+    has () { return true }
+  }
+}

package/lib/plugin-override.js

@@ -0,0 +1,90 @@
+'use strict'
+
+const {
+  kAvvioBoot,
+  kChildren,
+  kRoutePrefix,
+  kLogLevel,
+  kLogSerializers,
+  kHooks,
+  kSchemaController,
+  kContentTypeParser,
+  kReply,
+  kRequest,
+  kFourOhFour,
+  kPluginNameChain,
+  kErrorHandlerAlreadySet
+} = require('./symbols.js')
+
+const Reply = require('./reply')
+const Request = require('./request')
+const SchemaController = require('./schema-controller')
+const ContentTypeParser = require('./content-type-parser.js')
+const { buildHooks } = require('./hooks')
+const pluginUtils = require('./plugin-utils.js')
+
+// Function that runs the encapsulation magic.
+// Everything that need to be encapsulated must be handled in this function.
+module.exports = function override (old, fn, opts) {
+  const shouldSkipOverride = pluginUtils.registerPlugin.call(old, fn)
+
+  const fnName = pluginUtils.getPluginName(fn) || pluginUtils.getFuncPreview(fn)
+  if (shouldSkipOverride) {
+    // after every plugin registration we will enter a new name
+    old[kPluginNameChain].push(fnName)
+    return old
+  }
+
+  const instance = Object.create(old)
+  old[kChildren].push(instance)
+  instance.ready = old[kAvvioBoot].bind(instance)
+  instance[kChildren] = []
+
+  instance[kReply] = Reply.buildReply(instance[kReply])
+  instance[kRequest] = Request.buildRequest(instance[kRequest])
+
+  instance[kContentTypeParser] = ContentTypeParser.helpers.buildContentTypeParser(instance[kContentTypeParser])
+  instance[kHooks] = buildHooks(instance[kHooks])
+  instance[kRoutePrefix] = buildRoutePrefix(instance[kRoutePrefix], opts.prefix)
+  instance[kLogLevel] = opts.logLevel || instance[kLogLevel]
+  instance[kSchemaController] = SchemaController.buildSchemaController(old[kSchemaController])
+  instance.getSchema = instance[kSchemaController].getSchema.bind(instance[kSchemaController])
+  instance.getSchemas = instance[kSchemaController].getSchemas.bind(instance[kSchemaController])
+
+  // Track the registered and loaded plugins since the root instance.
+  // It does not track the current encapsulated plugin.
+  instance[pluginUtils.kRegisteredPlugins] = Object.create(instance[pluginUtils.kRegisteredPlugins])
+
+  // Track the plugin chain since the root instance.
+  // When an non-encapsulated plugin is added, the chain will be updated.
+  instance[kPluginNameChain] = [fnName]
+  instance[kErrorHandlerAlreadySet] = false
+
+  if (instance[kLogSerializers] || opts.logSerializers) {
+    instance[kLogSerializers] = Object.assign(Object.create(instance[kLogSerializers]), opts.logSerializers)
+  }
+
+  if (opts.prefix) {
+    instance[kFourOhFour].arrange404(instance)
+  }
+
+  for (const hook of instance[kHooks].onRegister) hook.call(old, instance, opts)
+
+  return instance
+}
+
+function buildRoutePrefix (instancePrefix, pluginPrefix) {
+  if (!pluginPrefix) {
+    return instancePrefix
+  }
+
+  // Ensure that there is a '/' between the prefixes
+  if (instancePrefix.endsWith('/') && pluginPrefix[0] === '/') {
+    // Remove the extra '/' to avoid: '/first//second'
+    pluginPrefix = pluginPrefix.slice(1)
+  } else if (pluginPrefix[0] !== '/') {
+    pluginPrefix = '/' + pluginPrefix
+  }
+
+  return instancePrefix + pluginPrefix
+}

package/lib/plugin-utils.js

@@ -0,0 +1,169 @@
+'use strict'
+
+const semver = require('semver')
+const assert = require('node:assert')
+const kRegisteredPlugins = Symbol.for('registered-plugin')
+const {
+  kTestInternals
+} = require('./symbols.js')
+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.js')
+
+const rcRegex = /-(?:rc|pre|alpha).+$/u
+
+function getMeta (fn) {
+  return fn[Symbol.for('plugin-meta')]
+}
+
+function getPluginName (func) {
+  const display = getDisplayName(func)
+  if (display) {
+    return display
+  }
+
+  // let's see if this is a file, and in that case use that
+  // this is common for plugins
+  const cache = require.cache
+  // cache is undefined inside SEA
+  if (cache) {
+    const keys = Object.keys(cache)
+
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i]
+      if (cache[key].exports === func) {
+        return key
+      }
+    }
+  }
+
+  // if not maybe it's a named function, so use that
+  if (func.name) {
+    return func.name
+  }
+
+  return null
+}
+
+function getFuncPreview (func) {
+  // takes the first two lines of the function if nothing else works
+  return func.toString().split('\n', 2).map(s => s.trim()).join(' -- ')
+}
+
+function getDisplayName (fn) {
+  return fn[Symbol.for('fastify.display-name')]
+}
+
+function shouldSkipOverride (fn) {
+  return !!fn[Symbol.for('skip-override')]
+}
+
+function checkDependencies (fn) {
+  const meta = getMeta(fn)
+  if (!meta) return
+
+  const dependencies = meta.dependencies
+  if (!dependencies) return
+  assert(Array.isArray(dependencies), 'The dependencies should be an array of strings')
+
+  dependencies.forEach(dependency => {
+    assert(
+      this[kRegisteredPlugins].indexOf(dependency) > -1,
+      `The dependency '${dependency}' of plugin '${meta.name}' is not registered`
+    )
+  })
+}
+
+function checkDecorators (fn) {
+  const meta = getMeta(fn)
+  if (!meta) return
+
+  const { decorators, name } = meta
+  if (!decorators) return
+
+  if (decorators.fastify) _checkDecorators(this, 'Fastify', decorators.fastify, name)
+  if (decorators.reply) _checkDecorators(this, 'Reply', decorators.reply, name)
+  if (decorators.request) _checkDecorators(this, 'Request', decorators.request, name)
+}
+
+const checks = {
+  Fastify: exist,
+  Request: existRequest,
+  Reply: existReply
+}
+
+function _checkDecorators (that, instance, decorators, name) {
+  assert(Array.isArray(decorators), 'The decorators should be an array of strings')
+
+  decorators.forEach(decorator => {
+    const withPluginName = typeof name === 'string' ? ` required by '${name}'` : ''
+    if (!checks[instance].call(that, decorator)) {
+      throw new FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE(decorator, withPluginName, instance)
+    }
+  })
+}
+
+function checkVersion (fn) {
+  const meta = getMeta(fn)
+  if (meta?.fastify == null) return
+
+  const requiredVersion = meta.fastify
+
+  const fastifyRc = rcRegex.test(this.version)
+  if (fastifyRc === true && semver.gt(this.version, semver.coerce(requiredVersion)) === true) {
+    // A Fastify release candidate phase is taking place. In order to reduce
+    // the effort needed to test plugins with the RC, we allow plugins targeting
+    // the prior Fastify release to be loaded.
+    return
+  }
+  if (requiredVersion && semver.satisfies(this.version, requiredVersion, { includePrerelease: fastifyRc }) === false) {
+    // We are not in a release candidate phase. Thus, we must honor the semver
+    // ranges defined by the plugin's metadata. Which is to say, if the plugin
+    // expects an older version of Fastify than the _current_ version, we will
+    // throw an error.
+    throw new FST_ERR_PLUGIN_VERSION_MISMATCH(meta.name, requiredVersion, this.version)
+  }
+}
+
+function registerPluginName (fn) {
+  const meta = getMeta(fn)
+  if (!meta) return
+
+  const name = meta.name
+  if (!name) return
+  this[kRegisteredPlugins].push(name)
+  return name
+}
+
+function checkPluginHealthiness (fn, pluginName) {
+  if (fn.constructor.name === 'AsyncFunction' && fn.length === 3) {
+    throw new FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER(pluginName)
+  }
+}
+
+function registerPlugin (fn) {
+  const pluginName = registerPluginName.call(this, fn) || getPluginName(fn)
+  checkPluginHealthiness.call(this, fn, pluginName)
+  checkVersion.call(this, fn)
+  checkDecorators.call(this, fn)
+  checkDependencies.call(this, fn)
+  return shouldSkipOverride(fn)
+}
+
+module.exports = {
+  getPluginName,
+  getFuncPreview,
+  kRegisteredPlugins,
+  getDisplayName,
+  registerPlugin
+}
+
+module.exports[kTestInternals] = {
+  shouldSkipOverride,
+  getMeta,
+  checkDecorators,
+  checkDependencies
+}

package/lib/promise.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const { kTestInternals } = require('./symbols')
+
+function withResolvers () {
+  let res, rej
+  const promise = new Promise((resolve, reject) => {
+    res = resolve
+    rej = reject
+  })
+  return { promise, resolve: res, reject: rej }
+}
+
+module.exports = {
+  // TODO(20.x): remove when node@20 is not supported
+  withResolvers: typeof Promise.withResolvers === 'function'
+    ? Promise.withResolvers.bind(Promise) // Promise.withResolvers must bind to itself
+    /* c8 ignore next */
+    : withResolvers, // Tested using the kTestInternals
+  [kTestInternals]: {
+    withResolvers
+  }
+}