fastify 3.27.4 → 4.0.0-alpha.3

package/lib/contentTypeParser.js

@@ -14,7 +14,8 @@ const {
   kBodyLimit,
   kRequestPayloadStream,
   kState,
-  kTestInternals
+  kTestInternals,
+  kReplyIsError
 } = require('./symbols')
 
 const {
@@ -28,7 +29,6 @@ const {
   FST_ERR_CTP_INVALID_CONTENT_LENGTH,
   FST_ERR_CTP_EMPTY_JSON_BODY
 } = require('./errors')
-const warning = require('./warnings')
 
 function ContentTypeParser (bodyLimit, onProtoPoisoning, onConstructorPoisoning) {
   this[kDefaultJsonParse] = getDefaultJsonParser(onProtoPoisoning, onConstructorPoisoning)
@@ -151,13 +151,7 @@ ContentTypeParser.prototype.run = function (contentType, handler, request, reply
       done
     )
   } else {
-    let result
-
-    if (parser.isDeprecatedSignature) {
-      result = parser.fn(request[kRequestPayloadStream], done)
-    } else {
-      result = parser.fn(request, request[kRequestPayloadStream], done)
-    }
+    const result = parser.fn(request, request[kRequestPayloadStream], done)
 
     if (result && typeof result.then === 'function') {
       result.then(body => done(null, body), done)
@@ -165,9 +159,10 @@ ContentTypeParser.prototype.run = function (contentType, handler, request, reply
   }
 
   function done (error, body) {
-    // We cannot use resource.bind() because it is broken in node v12.
+    // We cannot use resource.bind() because it is broken in node v12 and v14
     resource.runInAsyncScope(() => {
       if (error) {
+        reply[kReplyIsError] = true
         reply.send(error)
       } else {
         request.body = body
@@ -228,6 +223,7 @@ function rawBody (request, reply, options, parser, done) {
 
     if (err !== undefined) {
       err.statusCode = 400
+      reply[kReplyIsError] = true
       reply.code(err.statusCode).send(err)
       return
     }
@@ -279,12 +275,6 @@ function Parser (asString, asBuffer, bodyLimit, fn) {
   this.asBuffer = asBuffer
   this.bodyLimit = bodyLimit
   this.fn = fn
-
-  // Check for deprecation syntax
-  if (fn.length === (fn.constructor.name === 'AsyncFunction' ? 1 : 2)) {
-    warning.emit('FSTDEP003')
-    this.isDeprecatedSignature = true
-  }
 }
 
 function buildContentTypeParser (c) {

package/lib/context.js

@@ -1,15 +1,37 @@
 'use strict'
 
-const { kFourOhFourContext, kReplySerializerDefault } = require('./symbols.js')
+const {
+  kFourOhFourContext,
+  kReplySerializerDefault,
+  kSchemaErrorFormatter,
+  kErrorHandler,
+  kReply,
+  kRequest,
+  kBodyLimit,
+  kLogLevel,
+  kContentTypeParser
+} = require('./symbols.js')
 
 // Objects that holds the context of every request
 // Every route holds an instance of this object.
-function Context (schema, handler, Reply, Request, contentTypeParser, config, errorHandler, bodyLimit, logLevel, logSerializers, attachValidation, replySerializer, schemaErrorFormatter) {
+function Context ({
+  schema,
+  handler,
+  config,
+  errorHandler,
+  bodyLimit,
+  logLevel,
+  logSerializers,
+  attachValidation,
+  replySerializer,
+  schemaErrorFormatter,
+  server
+}) {
   this.schema = schema
   this.handler = handler
-  this.Reply = Reply
-  this.Request = Request
-  this.contentTypeParser = contentTypeParser
+  this.Reply = server[kReply]
+  this.Request = server[kRequest]
+  this.contentTypeParser = server[kContentTypeParser]
   this.onRequest = null
   this.onSend = null
   this.onError = null
@@ -17,15 +39,19 @@ function Context (schema, handler, Reply, Request, contentTypeParser, config, er
   this.preHandler = null
   this.onResponse = null
   this.config = config
-  this.errorHandler = errorHandler
+  this.errorHandler = errorHandler || server[kErrorHandler]
   this._middie = null
-  this._parserOptions = { limit: bodyLimit || null }
-  this.logLevel = logLevel
+  this._parserOptions = {
+    limit: bodyLimit || server[kBodyLimit]
+  }
+  this.logLevel = logLevel || server[kLogLevel]
   this.logSerializers = logSerializers
   this[kFourOhFourContext] = null
   this.attachValidation = attachValidation
   this[kReplySerializerDefault] = replySerializer
-  this.schemaErrorFormatter = schemaErrorFormatter || defaultSchemaErrorFormatter
+  this.schemaErrorFormatter = schemaErrorFormatter || server[kSchemaErrorFormatter] || defaultSchemaErrorFormatter
+
+  this.server = server
 }
 
 function defaultSchemaErrorFormatter (errors, dataVar) {
@@ -35,7 +61,7 @@ function defaultSchemaErrorFormatter (errors, dataVar) {
   // eslint-disable-next-line no-var
   for (var i = 0; i !== errors.length; ++i) {
     const e = errors[i]
-    text += dataVar + (e.dataPath || '') + ' ' + e.message + separator
+    text += dataVar + (e.instancePath || '') + ' ' + e.message + separator
   }
   return new Error(text.slice(0, -separator.length))
 }

package/lib/decorate.js

@@ -5,7 +5,8 @@
 const {
   kReply,
   kRequest,
-  kState
+  kState,
+  kHasBeenDecorated
 } = require('./symbols.js')
 
 const {
@@ -40,6 +41,7 @@ function decorateConstructor (konstructor, name, fn, dependencies) {
     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')) {

package/lib/error-handler.js

@@ -0,0 +1,158 @@
+'use strict'
+
+const statusCodes = require('http').STATUS_CODES
+const wrapThenable = require('./wrapThenable')
+const {
+  kReplyHeaders, kReplyNextErrorHandler, kReplyIsRunningOnErrorHook, kReplyHasStatusCode
+} = require('./symbols.js')
+
+const {
+  FST_ERR_REP_INVALID_PAYLOAD_TYPE
+} = 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.context
+  if (reply[kReplyNextErrorHandler] === false) {
+    fallbackErrorHandler(error, reply, function (reply, payload) {
+      try {
+        reply.raw.writeHead(reply.raw.statusCode, reply[kReplyHeaders])
+      } catch (error) {
+        reply.log.warn(
+          { req: reply.request, res: reply, err: error },
+          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)
+
+  delete reply[kReplyHeaders]['content-length']
+
+  const func = errorHandler.func
+
+  if (!func) {
+    reply[kReplyNextErrorHandler] = false
+    fallbackErrorHandler(error, reply, cb)
+    return
+  }
+
+  const result = func(error, reply.request, reply)
+  if (result !== undefined) {
+    if (result !== null && typeof result.then === 'function') {
+      wrapThenable(result, reply)
+    } else {
+      reply.send(result)
+    }
+  }
+}
+
+function defaultErrorHandler (error, request, reply) {
+  setErrorHeaders(error, reply)
+  if (!reply[kReplyHasStatusCode] || reply.statusCode === 200) {
+    const statusCode = error.statusCode || error.status
+    reply.code(statusCode >= 400 ? statusCode : 500)
+  }
+  if (reply.statusCode < 500) {
+    reply.log.info(
+      { res: reply, err: error },
+      error && error.message
+    )
+  } else {
+    reply.log.error(
+      { req: request, res: reply, err: error },
+      error && error.message
+    )
+  }
+  reply.send(error)
+}
+
+function fallbackErrorHandler (error, reply, cb) {
+  const res = reply.raw
+  const statusCode = reply.statusCode
+  let payload
+  try {
+    const serializerFn = getSchemaSerializer(reply.context, statusCode)
+    payload = (serializerFn === false)
+      ? serializeError({
+        error: statusCodes[statusCode + ''],
+        code: error.code,
+        message: error.message,
+        statusCode
+      })
+      : serializerFn(Object.create(error, {
+        error: { value: statusCodes[statusCode + ''] },
+        message: { value: error.message },
+        statusCode: { value: statusCode }
+      }))
+  } catch (err) {
+    // 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({
+      error: statusCodes['500'],
+      message: err.message,
+      statusCode: 500
+    })
+  }
+
+  if (typeof payload !== 'string' && !Buffer.isBuffer(payload)) {
+    payload = serializeError(new FST_ERR_REP_INVALID_PAYLOAD_TYPE(typeof payload))
+  }
+
+  reply[kReplyHeaders]['content-type'] = 'application/json; charset=utf-8'
+  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,257 @@
+// This file is autogenerated by build/build-error-serializer.js, do not edit
+/* istanbul ignore file */
+module.exports = $main
+    'use strict'
+  
+    
+function $pad2Zeros (num) {
+  const s = '00' + num
+  return s[s.length - 2] + s[s.length - 1]
+}
+
+function $asAny (i) {
+  return JSON.stringify(i)
+}
+
+function $asNull () {
+  return 'null'
+}
+
+function $asInteger (i) {
+  if (typeof i === 'bigint') {
+    return i.toString()
+  } else if (Number.isInteger(i)) {
+    return $asNumber(i)
+  } else {
+    /* eslint no-undef: "off" */
+    return $asNumber(parseInteger(i))
+  }
+}
+
+function $asIntegerNullable (i) {
+  return i === null ? null : $asInteger(i)
+}
+
+function $asNumber (i) {
+  const num = Number(i)
+  if (isNaN(num)) {
+    return 'null'
+  } else {
+    return '' + num
+  }
+}
+
+function $asNumberNullable (i) {
+  return i === null ? null : $asNumber(i)
+}
+
+function $asBoolean (bool) {
+  return bool && 'true' || 'false' // eslint-disable-line
+}
+
+function $asBooleanNullable (bool) {
+  return bool === null ? null : $asBoolean(bool)
+}
+
+function $asDatetime (date, skipQuotes) {
+  const quotes = skipQuotes === true ? '' : '"'
+  if (date instanceof Date) {
+    return quotes + date.toISOString() + quotes
+  } else if (date && typeof date.toISOString === 'function') {
+    return quotes + date.toISOString() + quotes
+  } else {
+    return $asString(date, skipQuotes)
+  }
+}
+
+function $asDate (date, skipQuotes) {
+  const quotes = skipQuotes === true ? '' : '"'
+  if (date instanceof Date) {
+    return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000 )).toISOString().slice(0, 10) + quotes
+  } else if (date && typeof date.format === 'function') {
+    return quotes + date.format('YYYY-MM-DD') + quotes
+  } else {
+    return $asString(date, skipQuotes)
+  }
+}
+
+function $asTime (date, skipQuotes) {
+  const quotes = skipQuotes === true ? '' : '"'
+  if (date instanceof Date) {
+    const hour = new Intl.DateTimeFormat('en', { hour: 'numeric', hour12: false }).format(date)
+    const minute = new Intl.DateTimeFormat('en', { minute: 'numeric' }).format(date)
+    const second = new Intl.DateTimeFormat('en', { second: 'numeric' }).format(date)
+    return quotes + $pad2Zeros(hour) + ':' + $pad2Zeros(minute) + ':' + $pad2Zeros(second) + quotes
+  } else if (date && typeof date.format === 'function') {
+    return quotes + date.format('HH:mm:ss') + quotes
+  } else {
+    return $asString(date, skipQuotes)
+  }
+}
+
+function $asString (str, skipQuotes) {
+  const quotes = skipQuotes === true ? '' : '"'
+  if (str instanceof Date) {
+    return quotes + str.toISOString() + quotes
+  } else if (str === null) {
+    return quotes + quotes
+  } else if (str instanceof RegExp) {
+    str = str.source
+  } else if (typeof str !== 'string') {
+    str = str.toString()
+  }
+  // If we skipQuotes it means that we are using it as test
+  // no need to test the string length for the render
+  if (skipQuotes) {
+    return str
+  }
+
+  if (str.length < 42) {
+    return $asStringSmall(str)
+  } else {
+    return JSON.stringify(str)
+  }
+}
+
+function $asStringNullable (str) {
+  return str === null ? null : $asString(str)
+}
+
+// magically escape strings for json
+// relying on their charCodeAt
+// everything below 32 needs JSON.stringify()
+// every string that contain surrogate needs JSON.stringify()
+// 34 and 92 happens all the time, so we
+// have a fast case for them
+function $asStringSmall (str) {
+  const l = str.length
+  let result = ''
+  let last = 0
+  let found = false
+  let surrogateFound = false
+  let point = 255
+  // eslint-disable-next-line
+  for (var i = 0; i < l && point >= 32; i++) {
+    point = str.charCodeAt(i)
+    if (point >= 0xD800 && point <= 0xDFFF) {
+      // The current character is a surrogate.
+      surrogateFound = true
+    }
+    if (point === 34 || point === 92) {
+      result += str.slice(last, i) + '\\'
+      last = i
+      found = true
+    }
+  }
+
+  if (!found) {
+    result = str
+  } else {
+    result += str.slice(last)
+  }
+  return ((point < 32) || (surrogateFound === true)) ? JSON.stringify(str) : '"' + result + '"'
+}
+
+
+    
+    /**
+     * Used by schemas that are dependant on calling 'ajv.validate' during runtime,
+     * it stores the value of the '$id' property of the schema (if it has it) inside
+     * a cache which is used to figure out if the schema was compiled into a validator
+     * by ajv on a previous call, if it was then the '$id' string will be used to 
+     * invoke 'ajv.validate', this allows:
+     * 
+     * 1. Schemas that depend on ajv.validate calls to leverage ajv caching system.
+     * 2. To avoid errors, since directly invoking 'ajv.validate' with the same 
+     * schema (that contains an '$id' property) twice will throw an error.
+     */
+    const $validateWithAjv = (function() {
+      const cache = new Set()
+
+      return function (schema, target) {
+        const id = schema.$id
+        
+        if (!id) {
+          return ajv.validate(schema, target)
+        }
+
+        const cached = cache.has(id)
+
+        if (cached) {
+          return ajv.validate(id, target)
+        } else {
+          cache.add(id)
+          return ajv.validate(schema, target)
+        }
+      }
+    })()
+
+
+    function parseInteger(int) { return Math.trunc(int) }
+    
+    function $main (input) {
+  
+      var obj = (input && typeof input.toJSON === 'function')
+    ? input.toJSON()
+    : input
+  
+      var json = '{'
+      var addComma = false
+  
+          var t = Number(obj["statusCode"])
+          if (!isNaN(t)) {
+            
+  if (addComma) {
+    json += ','
+  } else {
+    addComma = true
+  }
+
+            json += "\"statusCode\"" + ':' + t
+      
+      }
+    
+        if (obj["code"] !== undefined) {
+          
+  if (addComma) {
+    json += ','
+  } else {
+    addComma = true
+  }
+
+          json += "\"code\"" + ':'
+        json += $asString(obj["code"])
+      }
+    
+        if (obj["error"] !== undefined) {
+          
+  if (addComma) {
+    json += ','
+  } else {
+    addComma = true
+  }
+
+          json += "\"error\"" + ':'
+        json += $asString(obj["error"])
+      }
+    
+        if (obj["message"] !== undefined) {
+          
+  if (addComma) {
+    json += ','
+  } else {
+    addComma = true
+  }
+
+          json += "\"message\"" + ':'
+        json += $asString(obj["message"])
+      }
+    
+      json += '}'
+      return json
+    }
+    
+  
+    ;
+     return $main
+  

package/lib/errors.js

@@ -110,6 +110,11 @@ const codes = {
     500
   ),
 
+  FST_ERR_HOOK_TIMEOUT: createError(
+    'FST_ERR_HOOK_TIMEOUT',
+    "A callback for '%s' hook timed out. You may have forgotten to call 'done' function or to resolve a Promise"
+  ),
+
   /**
    * logger
   */
@@ -147,6 +152,14 @@ const codes = {
     'FST_ERR_BAD_STATUS_CODE',
     'Called reply with an invalid status code: %s'
   ),
+  FST_ERR_BAD_TRAILER_NAME: createError(
+    'FST_ERR_BAD_TRAILER_NAME',
+    'Called reply.trailer with an invalid header name: %s'
+  ),
+  FST_ERR_BAD_TRAILER_VALUE: createError(
+    'FST_ERR_BAD_TRAILER_VALUE',
+    "Called reply.trailer('%s', fn) with an invalid type: %s. Expected a function."
+  ),
 
   /**
    * schemas
@@ -172,14 +185,6 @@ const codes = {
     'Failed building the serialization schema for %s: %s, due to error %s'
   ),
 
-  /**
-   * wrapThenable
-   */
-  FST_ERR_PROMISE_NOT_FULFILLED: createError(
-    'FST_ERR_PROMISE_NOT_FULFILLED',
-    "Promise may not be fulfilled with 'undefined' when statusCode is not 204"
-  ),
-
   /**
    * http2
    */
@@ -199,6 +204,10 @@ const codes = {
   /**
    * router
    */
+  FST_ERR_DUPLICATED_ROUTE: createError(
+    'FST_ERR_DUPLICATED_ROUTE',
+    "Method '%s' already declared for route '%s'"
+  ),
   FST_ERR_BAD_URL: createError(
     'FST_ERR_BAD_URL',
     "'%s' is not a valid url component",
@@ -234,7 +243,40 @@ const codes = {
   FST_ERR_PLUGIN_VERSION_MISMATCH: createError(
     'FST_ERR_PLUGIN_VERSION_MISMATCH',
     "fastify-plugin: %s - expected '%s' fastify version, '%s' is installed"
-  )
+  ),
+
+  /**
+   *  Avvio Errors map
+   */
+  AVVIO_ERRORS_MAP: {
+    AVV_ERR_CALLBACK_NOT_FN: createError(
+      'FST_ERR_PLUGIN_CALLBACK_NOT_FN',
+      'fastify-plugin: %s'
+    ),
+    AVV_ERR_PLUGIN_NOT_VALID: createError(
+      'FST_ERR_PLUGIN_NOT_VALID',
+      'fastify-plugin: %s'
+    ),
+    AVV_ERR_ROOT_PLG_BOOTED: createError(
+      'FST_ERR_ROOT_PLG_BOOTED',
+      'fastify-plugin: %s'
+    ),
+    AVV_ERR_PARENT_PLG_LOADED: createError(
+      'FST_ERR_PARENT_PLUGIN_BOOTED',
+      'fastify-plugin: %s'
+    ),
+    AVV_ERR_READY_TIMEOUT: createError(
+      'FST_ERR_PLUGIN_TIMEOUT',
+      'fastify-plugin: %s'
+    )
+  },
+
+  //  Util function
+  appendStackTrace (oldErr, newErr) {
+    newErr.cause = oldErr
+
+    return newErr
+  }
 }
 
 module.exports = codes