node-fastify 5.8.3

package/lib/decorate.js

@@ -0,0 +1,152 @@
+'use strict'
+
+const {
+  kReply,
+  kRequest,
+  kState,
+  kHasBeenDecorated
+} = require('./symbols.js')
+
+const {
+  FST_ERR_DEC_ALREADY_PRESENT,
+  FST_ERR_DEC_MISSING_DEPENDENCY,
+  FST_ERR_DEC_AFTER_START,
+  FST_ERR_DEC_REFERENCE_TYPE,
+  FST_ERR_DEC_DEPENDENCY_INVALID_TYPE,
+  FST_ERR_DEC_UNDECLARED
+} = require('./errors')
+
+function decorate (instance, name, fn, dependencies) {
+  if (Object.hasOwn(instance, name)) {
+    throw new FST_ERR_DEC_ALREADY_PRESENT(name)
+  }
+
+  checkDependencies(instance, name, dependencies)
+
+  if (fn && (typeof fn.getter === 'function' || typeof fn.setter === 'function')) {
+    Object.defineProperty(instance, name, {
+      get: fn.getter,
+      set: fn.setter
+    })
+  } else {
+    instance[name] = fn
+  }
+}
+
+function getInstanceDecorator (name) {
+  if (!checkExistence(this, name)) {
+    throw new FST_ERR_DEC_UNDECLARED(name, 'instance')
+  }
+
+  if (typeof this[name] === 'function') {
+    return this[name].bind(this)
+  }
+
+  return this[name]
+}
+
+function decorateConstructor (konstructor, name, fn, dependencies) {
+  const instance = konstructor.prototype
+  if (Object.hasOwn(instance, name) || hasKey(konstructor, name)) {
+    throw new FST_ERR_DEC_ALREADY_PRESENT(name)
+  }
+
+  konstructor[kHasBeenDecorated] = true
+  checkDependencies(konstructor, name, dependencies)
+
+  if (fn && (typeof fn.getter === 'function' || typeof fn.setter === 'function')) {
+    Object.defineProperty(instance, name, {
+      get: fn.getter,
+      set: fn.setter
+    })
+  } else if (typeof fn === 'function') {
+    instance[name] = fn
+  } else {
+    konstructor.props.push({ key: name, value: fn })
+  }
+}
+
+function checkReferenceType (name, fn) {
+  if (typeof fn === 'object' && fn && !(typeof fn.getter === 'function' || typeof fn.setter === 'function')) {
+    throw new FST_ERR_DEC_REFERENCE_TYPE(name, typeof fn)
+  }
+}
+
+function decorateFastify (name, fn, dependencies) {
+  assertNotStarted(this, name)
+  decorate(this, name, fn, dependencies)
+  return this
+}
+
+function checkExistence (instance, name) {
+  if (name) {
+    return name in instance || (instance.prototype && name in instance.prototype) || hasKey(instance, name)
+  }
+
+  return instance in this
+}
+
+function hasKey (fn, name) {
+  if (fn.props) {
+    return fn.props.find(({ key }) => key === name)
+  }
+  return false
+}
+
+function checkRequestExistence (name) {
+  if (name && hasKey(this[kRequest], name)) return true
+  return checkExistence(this[kRequest].prototype, name)
+}
+
+function checkReplyExistence (name) {
+  if (name && hasKey(this[kReply], name)) return true
+  return checkExistence(this[kReply].prototype, name)
+}
+
+function checkDependencies (instance, name, deps) {
+  if (deps === undefined || deps === null) {
+    return
+  }
+
+  if (!Array.isArray(deps)) {
+    throw new FST_ERR_DEC_DEPENDENCY_INVALID_TYPE(name)
+  }
+
+  for (let i = 0; i !== deps.length; ++i) {
+    if (!checkExistence(instance, deps[i])) {
+      throw new FST_ERR_DEC_MISSING_DEPENDENCY(deps[i])
+    }
+  }
+}
+
+function decorateReply (name, fn, dependencies) {
+  assertNotStarted(this, name)
+  checkReferenceType(name, fn)
+  decorateConstructor(this[kReply], name, fn, dependencies)
+  return this
+}
+
+function decorateRequest (name, fn, dependencies) {
+  assertNotStarted(this, name)
+  checkReferenceType(name, fn)
+  decorateConstructor(this[kRequest], name, fn, dependencies)
+  return this
+}
+
+function assertNotStarted (instance, name) {
+  if (instance[kState].started) {
+    throw new FST_ERR_DEC_AFTER_START(name)
+  }
+}
+
+module.exports = {
+  add: decorateFastify,
+  exist: checkExistence,
+  existRequest: checkRequestExistence,
+  existReply: checkReplyExistence,
+  dependencies: checkDependencies,
+  decorateReply,
+  decorateRequest,
+  getInstanceDecorator,
+  hasKey
+}

package/lib/error-handler.js

@@ -0,0 +1,173 @@
+'use strict'
+
+const statusCodes = require('node:http').STATUS_CODES
+const wrapThenable = require('./wrap-thenable.js')
+const { setErrorStatusCode } = require('./error-status.js')
+const {
+  kReplyHeaders,
+  kReplyNextErrorHandler,
+  kReplyIsRunningOnErrorHook,
+  kRouteContext,
+  kDisableRequestLogging
+} = require('./symbols.js')
+
+const {
+  FST_ERR_REP_INVALID_PAYLOAD_TYPE,
+  FST_ERR_FAILED_ERROR_SERIALIZATION
+} = require('./errors')
+
+const { getSchemaSerializer } = require('./schemas')
+
+const serializeError = require('./error-serializer')
+
+const rootErrorHandler = {
+  func: defaultErrorHandler,
+  toJSON () {
+    return this.func.name.toString() + '()'
+  }
+}
+
+function handleError (reply, error, cb) {
+  reply[kReplyIsRunningOnErrorHook] = false
+
+  const context = reply[kRouteContext]
+  if (reply[kReplyNextErrorHandler] === false) {
+    fallbackErrorHandler(error, reply, function (reply, payload) {
+      try {
+        reply.raw.writeHead(reply.raw.statusCode, reply[kReplyHeaders])
+      } catch (error) {
+        if (!reply.log[kDisableRequestLogging]) {
+          reply.log.warn(
+            { req: reply.request, res: reply, err: error },
+            error?.message
+          )
+        }
+        reply.raw.writeHead(reply.raw.statusCode)
+      }
+      reply.raw.end(payload)
+    })
+    return
+  }
+  const errorHandler = reply[kReplyNextErrorHandler] || context.errorHandler
+
+  // In case the error handler throws, we set the next errorHandler so we can error again
+  reply[kReplyNextErrorHandler] = Object.getPrototypeOf(errorHandler)
+
+  // we need to remove content-type to allow content-type guessing for serialization
+  delete reply[kReplyHeaders]['content-type']
+  delete reply[kReplyHeaders]['content-length']
+
+  const func = errorHandler.func
+
+  if (!func) {
+    reply[kReplyNextErrorHandler] = false
+    fallbackErrorHandler(error, reply, cb)
+    return
+  }
+
+  try {
+    const result = func(error, reply.request, reply)
+    if (result !== undefined) {
+      if (result !== null && typeof result.then === 'function') {
+        wrapThenable(result, reply)
+      } else {
+        reply.send(result)
+      }
+    }
+  } catch (err) {
+    reply.send(err)
+  }
+}
+
+function defaultErrorHandler (error, request, reply) {
+  setErrorHeaders(error, reply)
+  setErrorStatusCode(reply, error)
+  if (reply.statusCode < 500) {
+    if (!reply.log[kDisableRequestLogging]) {
+      reply.log.info(
+        { res: reply, err: error },
+        error?.message
+      )
+    }
+  } else {
+    if (!reply.log[kDisableRequestLogging]) {
+      reply.log.error(
+        { req: request, res: reply, err: error },
+        error?.message
+      )
+    }
+  }
+  reply.send(error)
+}
+
+function fallbackErrorHandler (error, reply, cb) {
+  const res = reply.raw
+  const statusCode = reply.statusCode
+  reply[kReplyHeaders]['content-type'] = reply[kReplyHeaders]['content-type'] ?? 'application/json; charset=utf-8'
+  let payload
+  try {
+    const serializerFn = getSchemaSerializer(reply[kRouteContext], statusCode, reply[kReplyHeaders]['content-type'])
+    if (serializerFn === false) {
+      payload = serializeError({
+        error: statusCodes[statusCode + ''],
+        code: error.code,
+        message: error.message,
+        statusCode
+      })
+    } else {
+      payload = serializerFn(Object.create(error, {
+        error: { value: statusCodes[statusCode + ''] },
+        message: { value: error.message },
+        statusCode: { value: statusCode }
+      }))
+    }
+  } catch (err) {
+    if (!reply.log[kDisableRequestLogging]) {
+      // error is always FST_ERR_SCH_SERIALIZATION_BUILD because this is called from route/compileSchemasForSerialization
+      reply.log.error({ err, statusCode: res.statusCode }, 'The serializer for the given status code failed')
+    }
+    reply.code(500)
+    payload = serializeError(new FST_ERR_FAILED_ERROR_SERIALIZATION(err.message, error.message))
+  }
+
+  if (typeof payload !== 'string' && !Buffer.isBuffer(payload)) {
+    payload = serializeError(new FST_ERR_REP_INVALID_PAYLOAD_TYPE(typeof payload))
+  }
+
+  reply[kReplyHeaders]['content-length'] = '' + Buffer.byteLength(payload)
+
+  cb(reply, payload)
+}
+
+function buildErrorHandler (parent = rootErrorHandler, func) {
+  if (!func) {
+    return parent
+  }
+
+  const errorHandler = Object.create(parent)
+  errorHandler.func = func
+  return errorHandler
+}
+
+function setErrorHeaders (error, reply) {
+  const res = reply.raw
+  let statusCode = res.statusCode
+  statusCode = (statusCode >= 400) ? statusCode : 500
+  // treat undefined and null as same
+  if (error != null) {
+    if (error.headers !== undefined) {
+      reply.headers(error.headers)
+    }
+    if (error.status >= 400) {
+      statusCode = error.status
+    } else if (error.statusCode >= 400) {
+      statusCode = error.statusCode
+    }
+  }
+  res.statusCode = statusCode
+}
+
+module.exports = {
+  buildErrorHandler,
+  handleError
+}

package/lib/error-serializer.js

@@ -0,0 +1,134 @@
+// This file is autogenerated by build/build-error-serializer.js, do not edit
+/* c8 ignore start */
+
+  'use strict'
+
+  const Serializer = require('fast-json-stringify/lib/serializer')
+  const serializerState = {"mode":"standalone"}
+  const serializer = Serializer.restoreFromState(serializerState)
+
+  const validator = null
+
+
+  module.exports = function anonymous(validator,serializer
+) {
+
+    
+const {
+  asString,
+  asNumber,
+  asBoolean,
+  asDateTime,
+  asDate,
+  asTime,
+  asUnsafeString
+} = serializer
+
+const asInteger = serializer.asInteger.bind(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'
+  
+    
+  
+    // #
+    function anonymous0 (input) {
+      const obj = (input && typeof input.toJSON === 'function')
+    ? input.toJSON()
+    : input
+  
+      if (obj === null) return JSON_STR_EMPTY_OBJECT
+
+      let value
+let json = JSON_STR_BEGIN_OBJECT
+let addComma = false
+
+      value = obj["statusCode"]
+      if (value !== undefined) {
+        !addComma && (addComma = true) || (json += JSON_STR_COMMA)
+        json += "\"statusCode\":"
+        json += asNumber(value)
+      }
+
+      value = obj["code"]
+      if (value !== undefined) {
+        !addComma && (addComma = true) || (json += JSON_STR_COMMA)
+        json += "\"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 += asString(value.source)
+          } else {
+            json += asString(value.toString())
+          }
+        } else {
+          json += asString(value)
+        }
+        
+      }
+
+      value = obj["error"]
+      if (value !== undefined) {
+        !addComma && (addComma = true) || (json += JSON_STR_COMMA)
+        json += "\"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 += asString(value.source)
+          } else {
+            json += asString(value.toString())
+          }
+        } else {
+          json += asString(value)
+        }
+        
+      }
+
+      value = obj["message"]
+      if (value !== undefined) {
+        !addComma && (addComma = true) || (json += JSON_STR_COMMA)
+        json += "\"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 += asString(value.source)
+          } else {
+            json += asString(value.toString())
+          }
+        } else {
+          json += asString(value)
+        }
+        
+      }
+
+    return json + JSON_STR_END_OBJECT
+  
+    }
+  
+    const main = anonymous0
+    return main
+    
+}(validator, serializer)
+/* c8 ignore stop */

package/lib/error-status.js

@@ -0,0 +1,14 @@
+'use strict'
+
+const {
+  kReplyHasStatusCode
+} = require('./symbols')
+
+function setErrorStatusCode (reply, err) {
+  if (!reply[kReplyHasStatusCode] || reply.statusCode === 200) {
+    const statusCode = err && (err.statusCode || err.status)
+    reply.code(statusCode >= 400 ? statusCode : 500)
+  }
+}
+
+module.exports = { setErrorStatusCode }