fastify 3.26.0 → 4.0.0-alpha.1

package/lib/fourOhFour.js

@@ -9,21 +9,17 @@ const {
   kRoutePrefix,
   kCanSetNotFoundHandler,
   kFourOhFourLevelInstance,
-  kReply,
-  kRequest,
-  kContentTypeParser,
-  kBodyLimit,
-  kLogLevel,
   kFourOhFourContext,
-  kHooks,
-  kErrorHandler
+  kHooks
 } = require('./symbols.js')
 const { lifecycleHooks } = require('./hooks')
+const { buildErrorHandler } = require('./error-handler.js')
 const fourOhFourContext = {
   config: {
   },
   onSend: [],
-  onError: []
+  onError: [],
+  errorHandler: buildErrorHandler()
 }
 
 /**
@@ -34,10 +30,10 @@ const fourOhFourContext = {
  * kFourOhFourContext: the context in the reply object where the handler will be executed
  */
 function fourOhFour (options) {
-  const { logger, genReqId } = options
+  const { logger, genReqId, disableRequestLogging } = options
 
   // 404 router, used for handling encapsulated 404 handlers
-  const router = FindMyWay({ defaultRoute: fourOhFourFallBack })
+  const router = FindMyWay({ onBadUrl, defaultRoute: fourOhFourFallBack })
 
   return { router, setNotFoundHandler, setContext, arrange404 }
 
@@ -58,6 +54,26 @@ function fourOhFour (options) {
     })
   }
 
+  function onBadUrl (path, req, res) {
+    const { url, method } = req
+    const message = `Route ${method}:${url} not found`
+    const body = `{"error":"Not Found","message":"${message}","statusCode":404}`
+
+    // simulate normal route logging
+    if (!disableRequestLogging) {
+      const id = genReqId(req)
+      const childLogger = logger.child({ reqId: id })
+      childLogger.info({ req }, 'incoming request')
+      childLogger.info({ req }, message)
+    }
+
+    res.writeHead(404, {
+      'Content-Type': 'application/json',
+      'Content-Length': body.length
+    })
+    res.end(body)
+  }
+
   function setContext (instance, context) {
     const _404Context = Object.assign({}, instance[kFourOhFourContext])
     _404Context.onSend = context.onSend
@@ -118,17 +134,12 @@ function fourOhFour (options) {
   }
 
   function _setNotFoundHandler (prefix, opts, handler, avvio, routeHandler) {
-    const context = new Context(
-      opts.schema,
+    const context = new Context({
+      schema: opts.schema,
       handler,
-      this[kReply],
-      this[kRequest],
-      this[kContentTypeParser],
-      opts.config || {},
-      this[kErrorHandler],
-      this[kBodyLimit],
-      this[kLogLevel]
-    )
+      config: opts.config || {},
+      server: this
+    })
 
     avvio.once('preReady', () => {
       const context = this[kFourOhFourContext]

package/lib/handleRequest.js

@@ -3,12 +3,14 @@
 const { validate: validateSchema } = require('./validation')
 const { hookRunner, hookIterator } = require('./hooks')
 const wrapThenable = require('./wrapThenable')
-
-const { kReplyIsError } = require('./symbols')
+const {
+  kReplyIsError
+} = require('./symbols')
 
 function handleRequest (err, request, reply) {
   if (reply.sent === true) return
   if (err != null) {
+    reply[kReplyIsError] = true
     reply.send(err)
     return
   }
@@ -55,7 +57,7 @@ function handleRequest (err, request, reply) {
   }
 
   // Return 404 instead of 405 see https://github.com/fastify/fastify/pull/862 for discussion
-  reply.code(404).send(new Error('Not Found'))
+  handler(request, reply)
 }
 
 function handler (request, reply) {
@@ -77,11 +79,10 @@ function handler (request, reply) {
 }
 
 function preValidationCallback (err, request, reply) {
-  if (reply.sent === true ||
-    reply.raw.writableEnded === true ||
-    reply.raw.writable === false) return
+  if (reply.sent === true) return
 
   if (err != null) {
+    reply[kReplyIsError] = true
     reply.send(err)
     return
   }
@@ -111,11 +112,10 @@ function preValidationCallback (err, request, reply) {
 }
 
 function preHandlerCallback (err, request, reply) {
-  if (reply.sent ||
-    reply.raw.writableEnded === true ||
-    reply.raw.writable === false) return
+  if (reply.sent) return
 
   if (err != null) {
+    reply[kReplyIsError] = true
     reply.send(err)
     return
   }
@@ -125,10 +125,7 @@ function preHandlerCallback (err, request, reply) {
   try {
     result = reply.context.handler(request, reply)
   } catch (err) {
-    if (!(err instanceof Error)) {
-      reply[kReplyIsError] = true
-    }
-
+    reply[kReplyIsError] = true
     reply.send(err)
     return
   }

package/lib/hooks.js

@@ -21,11 +21,13 @@ const supportedHooks = lifecycleHooks.concat(applicationHooks)
 const {
   FST_ERR_HOOK_INVALID_TYPE,
   FST_ERR_HOOK_INVALID_HANDLER,
-  FST_ERR_SEND_UNDEFINED_ERR
+  FST_ERR_SEND_UNDEFINED_ERR,
+  FST_ERR_HOOK_TIMEOUT,
+  AVVIO_ERRORS_MAP,
+  appendStackTrace
 } = require('./errors')
 
 const {
-  kReplyIsError,
   kChildren,
   kHooks
 } = require('./symbols')
@@ -84,6 +86,14 @@ function hookRunnerApplication (hookName, boot, server, cb) {
 
   function exit (err) {
     if (err) {
+      if (err.code === 'AVV_ERR_READY_TIMEOUT') {
+        err = appendStackTrace(err, new FST_ERR_HOOK_TIMEOUT(hookName))
+      } else {
+        err = AVVIO_ERRORS_MAP[err.code] != null
+          ? appendStackTrace(err, new AVVIO_ERRORS_MAP[err.code](err.message))
+          : err
+      }
+
       cb(err)
       return
     }
@@ -178,9 +188,8 @@ function hookRunner (functions, runner, request, reply, cb) {
   function handleReject (err) {
     if (!err) {
       err = new FST_ERR_SEND_UNDEFINED_ERR()
-    } else if (!(err instanceof Error)) {
-      reply[kReplyIsError] = true
     }
+
     cb(err, request, reply)
   }
 
@@ -201,11 +210,7 @@ function onSendHookRunner (functions, request, reply, payload, cb) {
     }
 
     if (i === functions.length) {
-      try {
-        cb(null, request, reply, payload)
-      } catch (err) {
-        handleReject(err)
-      }
+      cb(null, request, reply, payload)
       return
     }
 

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/pluginOverride.js

@@ -39,10 +39,7 @@ module.exports = function override (old, fn, opts) {
   instance[kChildren] = []
 
   instance[kReply] = Reply.buildReply(instance[kReply])
-  instance[kReply].prototype.server = instance
-
   instance[kRequest] = Request.buildRequest(instance[kRequest])
-  instance[kRequest].prototype.server = instance
 
   instance[kContentTypeParser] = ContentTypeParser.helpers.buildContentTypeParser(instance[kContentTypeParser])
   instance[kHooks] = buildHooks(instance[kHooks])

package/lib/pluginUtils.js

@@ -102,9 +102,10 @@ function checkVersion (fn) {
   if (!meta) return
 
   const requiredVersion = meta.fastify
-  if (!requiredVersion) return
 
-  if (!semver.satisfies(this.version, requiredVersion)) throw new FST_ERR_PLUGIN_VERSION_MISMATCH(meta.name, requiredVersion, this.version)
+  if (requiredVersion && !semver.satisfies(this.version, requiredVersion)) {
+    throw new FST_ERR_PLUGIN_VERSION_MISMATCH(meta.name, requiredVersion, this.version)
+  }
 }
 
 function registerPluginName (fn) {

package/lib/reply.js

@@ -1,15 +1,11 @@
 'use strict'
 
 const eos = require('stream').finished
-const statusCodes = require('http').STATUS_CODES
-const flatstr = require('flatstr')
-const FJS = require('fast-json-stringify')
+
 const {
-  kSchemaResponse,
   kFourOhFourContext,
   kReplyErrorHandlerCalled,
-  kReplySent,
-  kReplySentOverwritten,
+  kReplyHijacked,
   kReplyStartTime,
   kReplyEndTime,
   kReplySerializer,
@@ -18,6 +14,7 @@ const {
   kReplyHeaders,
   kReplyHasStatusCode,
   kReplyIsRunningOnErrorHook,
+  kReplyNextErrorHandler,
   kDisableRequestLogging
 } = require('./symbols.js')
 const { hookRunner, hookIterator, onSendHookRunner } = require('./hooks')
@@ -25,17 +22,8 @@ const { hookRunner, hookIterator, onSendHookRunner } = require('./hooks')
 const internals = require('./handleRequest')[Symbol.for('internals')]
 const loggerUtils = require('./logger')
 const now = loggerUtils.now
-const wrapThenable = require('./wrapThenable')
-
-const serializeError = FJS({
-  type: 'object',
-  properties: {
-    statusCode: { type: 'number' },
-    code: { type: 'string' },
-    error: { type: 'string' },
-    message: { type: 'string' }
-  }
-})
+const { handleError } = require('./error-handler')
+const { getSchemaSerializer } = require('./schemas')
 
 const CONTENT_TYPE = {
   JSON: 'application/json; charset=utf-8',
@@ -53,7 +41,6 @@ const warning = require('./warnings')
 
 function Reply (res, request, log) {
   this.raw = res
-  this[kReplySent] = false
   this[kReplySerializer] = null
   this[kReplyErrorHandlerCalled] = false
   this[kReplyIsError] = false
@@ -72,28 +59,30 @@ Object.defineProperties(Reply.prototype, {
       return this.request.context
     }
   },
-  res: {
+  server: {
     get () {
-      warning.emit('FSTDEP002')
-      return this.raw
+      return this.request.context.server
     }
   },
   sent: {
     enumerable: true,
     get () {
-      return this[kReplySent]
+      // We are checking whether reply was hijacked or the response has ended.
+      return (this[kReplyHijacked] || this.raw.writableEnded) === true
     },
     set (value) {
+      warning.emit('FSTDEP010')
+
       if (value !== true) {
         throw new FST_ERR_REP_SENT_VALUE()
       }
 
-      if (this[kReplySent]) {
+      // We throw only if sent was overwritten from Fastify
+      if (this.sent && this[kReplyHijacked]) {
         throw new FST_ERR_REP_ALREADY_SENT()
       }
 
-      this[kReplySentOverwritten] = true
-      this[kReplySent] = true
+      this[kReplyHijacked] = true
     }
   },
   statusCode: {
@@ -103,15 +92,11 @@ Object.defineProperties(Reply.prototype, {
     set (value) {
       this.code(value)
     }
-  },
-  server: {
-    value: null,
-    writable: true
   }
 })
 
 Reply.prototype.hijack = function () {
-  this[kReplySent] = true
+  this[kReplyHijacked] = true
   return this
 }
 
@@ -120,12 +105,13 @@ Reply.prototype.send = function (payload) {
     throw new FST_ERR_SEND_INSIDE_ONERR()
   }
 
-  if (this[kReplySent]) {
+  if (this.sent) {
     this.log.warn({ err: new FST_ERR_REP_ALREADY_SENT() }, 'Reply already sent')
     return this
   }
 
   if (payload instanceof Error || this[kReplyIsError] === true) {
+    this[kReplyIsError] = false
     onErrorHook(this, payload, onSendHook)
     return this
   }
@@ -139,7 +125,12 @@ Reply.prototype.send = function (payload) {
   const hasContentType = contentType !== undefined
 
   if (payload !== null) {
-    if (Buffer.isBuffer(payload) || typeof payload.pipe === 'function') {
+    if (typeof payload.pipe === 'function') {
+      onSendHook(this, payload)
+      return this
+    }
+
+    if (Buffer.isBuffer(payload)) {
       if (hasContentType === false) {
         this[kReplyHeaders]['content-type'] = CONTENT_TYPE.OCTET
       }
@@ -365,22 +356,29 @@ function preserializeHookEnd (err, request, reply, payload) {
     return
   }
 
-  if (reply[kReplySerializer] !== null) {
-    payload = reply[kReplySerializer](payload)
-  } else if (reply.context && reply.context[kReplySerializerDefault]) {
-    payload = reply.context[kReplySerializerDefault](payload, reply.raw.statusCode)
-  } else {
-    payload = serialize(reply.context, payload, reply.raw.statusCode)
+  try {
+    if (reply[kReplySerializer] !== null) {
+      payload = reply[kReplySerializer](payload)
+    } else if (reply.context && reply.context[kReplySerializerDefault]) {
+      payload = reply.context[kReplySerializerDefault](payload, reply.raw.statusCode)
+    } else {
+      payload = serialize(reply.context, payload, reply.raw.statusCode)
+    }
+  } catch (e) {
+    wrapSeralizationError(e, reply)
+    onErrorHook(reply, e)
+    return
   }
 
-  flatstr(payload)
-
   onSendHook(reply, payload)
 }
 
+function wrapSeralizationError (error, reply) {
+  error.serialization = reply.context.config
+}
+
 function onSendHook (reply, payload) {
   if (reply.context.onSend !== null) {
-    reply[kReplySent] = true
     onSendHookRunner(
       reply.context.onSend,
       reply.request,
@@ -407,8 +405,6 @@ function onSendEnd (reply, payload) {
   const statusCode = res.statusCode
 
   if (payload === undefined || payload === null) {
-    reply[kReplySent] = true
-
     // according to https://tools.ietf.org/html/rfc7230#section-3.3.2
     // we cannot send a content-length for 304 and 204, and all status code
     // < 200.
@@ -424,8 +420,6 @@ function onSendEnd (reply, payload) {
   }
 
   if (typeof payload.pipe === 'function') {
-    reply[kReplySent] = true
-
     sendStream(payload, res, reply)
     return
   }
@@ -440,8 +434,6 @@ function onSendEnd (reply, payload) {
     reply[kReplyHeaders]['content-length'] = '' + Buffer.byteLength(payload)
   }
 
-  reply[kReplySent] = true
-
   res.writeHead(statusCode, reply[kReplyHeaders])
 
   // avoid ArgumentsAdaptorTrampoline from V8
@@ -511,8 +503,7 @@ function sendStream (payload, res, reply) {
 }
 
 function onErrorHook (reply, error, cb) {
-  reply[kReplySent] = true
-  if (reply.context.onError !== null && reply[kReplyErrorHandlerCalled] === true) {
+  if (reply.context.onError !== null && !reply[kReplyNextErrorHandler]) {
     reply[kReplyIsRunningOnErrorHook] = true
     onSendHookRunner(
       reply.context.onError,
@@ -526,89 +517,6 @@ function onErrorHook (reply, error, cb) {
   }
 }
 
-function handleError (reply, error, cb) {
-  reply[kReplyIsRunningOnErrorHook] = false
-  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
-
-  const errorHandler = reply.context.errorHandler
-  if (errorHandler && reply[kReplyErrorHandlerCalled] === false) {
-    reply[kReplySent] = false
-    reply[kReplyIsError] = false
-    reply[kReplyErrorHandlerCalled] = true
-    // remove header is needed in here, because when we pipe to a stream
-    // `undefined` value header will directly passed to node response
-    reply.removeHeader('content-length')
-    const result = errorHandler(error, reply.request, reply)
-    if (result !== undefined) {
-      if (result !== null && typeof result.then === 'function') {
-        wrapThenable(result, reply)
-      } else {
-        reply.send(result)
-      }
-    }
-    return
-  }
-
-  let payload
-  try {
-    const serializerFn = getSchemaSerializer(reply.context, statusCode)
-    payload = (serializerFn === false)
-      ? serializeError({
-          error: statusCodes[statusCode + ''],
-          code: error.code,
-          message: error.message || '',
-          statusCode: statusCode
-        })
-      : serializerFn(Object.create(error, {
-        error: { value: statusCodes[statusCode + ''] },
-        message: { value: error.message || '' },
-        statusCode: { value: statusCode }
-      }))
-
-    if (serializerFn !== false && typeof payload !== 'string') {
-      throw new FST_ERR_REP_INVALID_PAYLOAD_TYPE(typeof payload)
-    }
-  } 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')
-    res.statusCode = 500
-    payload = serializeError({
-      error: statusCodes['500'],
-      code: err.code,
-      message: err.message,
-      statusCode: 500
-    })
-  }
-
-  flatstr(payload)
-  reply[kReplyHeaders]['content-type'] = CONTENT_TYPE.JSON
-  reply[kReplyHeaders]['content-length'] = '' + Buffer.byteLength(payload)
-
-  if (cb) {
-    cb(reply, payload)
-    return
-  }
-
-  reply[kReplySent] = true
-  res.writeHead(res.statusCode, reply[kReplyHeaders])
-  res.end(payload)
-}
-
 function setupResponseListeners (reply) {
   reply[kReplyStartTime] = now()
 
@@ -669,8 +577,7 @@ function buildReply (R) {
     this.raw = res
     this[kReplyIsError] = false
     this[kReplyErrorHandlerCalled] = false
-    this[kReplySent] = false
-    this[kReplySentOverwritten] = false
+    this[kReplyHijacked] = false
     this[kReplySerializer] = null
     this.request = request
     this[kReplyHeaders] = {}
@@ -686,15 +593,14 @@ function buildReply (R) {
       this[prop.key] = prop.value
     }
   }
-  _Reply.prototype = new R()
+  Object.setPrototypeOf(_Reply.prototype, R.prototype)
+  Object.setPrototypeOf(_Reply, R)
+  _Reply.parent = R
   _Reply.props = props
   return _Reply
 }
 
 function notFound (reply) {
-  reply[kReplySent] = false
-  reply[kReplyIsError] = false
-
   if (reply.context[kFourOhFourContext] === null) {
     reply.log.warn('Trying to send a NotFound error inside a 404 handler. Sending basic 404 response.')
     reply.code(404).send('404 Not Found')
@@ -735,31 +641,6 @@ function serialize (context, data, statusCode) {
   return JSON.stringify(data)
 }
 
-/**
- * Search for the right JSON schema compiled function in the request context
- * setup by the route configuration `schema.response`.
- * It will look for the exact match (eg 200) or generic (eg 2xx)
- *
- * @param {object} context the request context
- * @param {number} statusCode the http status code
- * @returns {function|boolean} the right JSON Schema function to serialize
- * the reply or false if it is not set
- */
-function getSchemaSerializer (context, statusCode) {
-  const responseSchemaDef = context[kSchemaResponse]
-  if (!responseSchemaDef) {
-    return false
-  }
-  if (responseSchemaDef[statusCode]) {
-    return responseSchemaDef[statusCode]
-  }
-  const fallbackStatusCode = (statusCode + '')[0] + 'xx'
-  if (responseSchemaDef[fallbackStatusCode]) {
-    return responseSchemaDef[fallbackStatusCode]
-  }
-  return false
-}
-
 function noop () { }
 
 module.exports = Reply

package/lib/request.js

@@ -3,6 +3,9 @@
 const proxyAddr = require('proxy-addr')
 const semver = require('semver')
 const warning = require('./warnings')
+const {
+  kHasBeenDecorated
+} = require('./symbols')
 
 function Request (id, params, req, query, log, context) {
   this.id = id
@@ -11,7 +14,7 @@ function Request (id, params, req, query, log, context) {
   this.raw = req
   this.query = query
   this.log = log
-  this.body = null
+  this.body = undefined
 }
 Request.props = []
 
@@ -52,7 +55,7 @@ function buildRegularRequest (R) {
     this.raw = req
     this.query = query
     this.log = log
-    this.body = null
+    this.body = undefined
 
     // eslint-disable-next-line no-var
     var prop
@@ -62,8 +65,10 @@ function buildRegularRequest (R) {
       this[prop.key] = prop.value
     }
   }
-  _Request.prototype = new R()
+  Object.setPrototypeOf(_Request.prototype, Request.prototype)
+  Object.setPrototypeOf(_Request, Request)
   _Request.props = props
+  _Request.parent = R
 
   return _Request
 }
@@ -78,6 +83,9 @@ function buildRequestWithTrustProxy (R, trustProxy) {
   const _Request = buildRegularRequest(R)
   const proxyFn = getTrustProxyFn(trustProxy)
 
+  // This is a more optimized version of decoration
+  _Request[kHasBeenDecorated] = true
+
   Object.defineProperties(_Request.prototype, {
     ip: {
       get () {
@@ -113,10 +121,9 @@ function buildRequestWithTrustProxy (R, trustProxy) {
 }
 
 Object.defineProperties(Request.prototype, {
-  req: {
+  server: {
     get () {
-      warning.emit('FSTDEP001')
-      return this.raw
+      return this.context.server
     }
   },
   url: {
@@ -187,10 +194,6 @@ Object.defineProperties(Request.prototype, {
     set (headers) {
       this.additionalHeaders = headers
     }
-  },
-  server: {
-    value: null,
-    writable: true
   }
 })