fastify 3.27.4 → 4.0.0-alpha.3

package/lib/reply.js

@@ -1,23 +1,21 @@
 '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,
   kReplySerializerDefault,
   kReplyIsError,
   kReplyHeaders,
+  kReplyTrailers,
   kReplyHasStatusCode,
   kReplyIsRunningOnErrorHook,
+  kReplyNextErrorHandler,
   kDisableRequestLogging
 } = require('./symbols.js')
 const { hookRunner, hookIterator, onSendHookRunner } = require('./hooks')
@@ -25,17 +23,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',
@@ -47,19 +36,21 @@ const {
   FST_ERR_REP_ALREADY_SENT,
   FST_ERR_REP_SENT_VALUE,
   FST_ERR_SEND_INSIDE_ONERR,
-  FST_ERR_BAD_STATUS_CODE
+  FST_ERR_BAD_STATUS_CODE,
+  FST_ERR_BAD_TRAILER_NAME,
+  FST_ERR_BAD_TRAILER_VALUE
 } = require('./errors')
 const warning = require('./warnings')
 
 function Reply (res, request, log) {
   this.raw = res
-  this[kReplySent] = false
   this[kReplySerializer] = null
   this[kReplyErrorHandlerCalled] = false
   this[kReplyIsError] = false
   this[kReplyIsRunningOnErrorHook] = false
   this.request = request
   this[kReplyHeaders] = {}
+  this[kReplyTrailers] = null
   this[kReplyHasStatusCode] = false
   this[kReplyStartTime] = undefined
   this.log = log
@@ -72,28 +63,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 +96,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 +109,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 +129,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
       }
@@ -167,22 +162,14 @@ Reply.prototype.send = function (payload) {
     if (hasContentType === false) {
       this[kReplyHeaders]['content-type'] = CONTENT_TYPE.JSON
     } else {
-      // If hasContentType === true, we have a JSON mimetype
+      // If user doesn't set charset, we will set charset to utf-8
       if (contentType.indexOf('charset') === -1) {
-        // If we have simply application/json instead of a custom json mimetype
-        if (contentType.indexOf('/json') > -1) {
-          this[kReplyHeaders]['content-type'] = CONTENT_TYPE.JSON
+        const customContentType = contentType.trim()
+        if (customContentType.endsWith(';')) {
+          // custom content-type is ended with ';'
+          this[kReplyHeaders]['content-type'] = `${customContentType} charset=utf-8`
         } else {
-          const currContentType = this[kReplyHeaders]['content-type']
-          // We extract the custom mimetype part (e.g. 'hal+' from 'application/hal+json')
-          const customJsonType = currContentType.substring(
-            currContentType.indexOf('/'),
-            currContentType.indexOf('json') + 4
-          )
-
-          // We ensure we set the header to the proper JSON content-type if necessary
-          // (e.g. 'application/hal+json' instead of 'application/json')
-          this[kReplyHeaders]['content-type'] = CONTENT_TYPE.JSON.replace('/json', customJsonType)
+          this[kReplyHeaders]['content-type'] = `${customContentType}; charset=utf-8`
         }
       }
     }
@@ -261,6 +248,47 @@ Reply.prototype.headers = function (headers) {
   return this
 }
 
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Trailer#directives
+// https://httpwg.org/specs/rfc7230.html#chunked.trailer.part
+const INVALID_TRAILERS = new Set([
+  'transfer-encoding',
+  'content-length',
+  'host',
+  'cache-control',
+  'max-forwards',
+  'te',
+  'authorization',
+  'set-cookie',
+  'content-encoding',
+  'content-type',
+  'content-range',
+  'trailer'
+])
+
+Reply.prototype.trailer = function (key, fn) {
+  key = key.toLowerCase()
+  if (INVALID_TRAILERS.has(key)) {
+    throw new FST_ERR_BAD_TRAILER_NAME(key)
+  }
+  if (typeof fn !== 'function') {
+    throw new FST_ERR_BAD_TRAILER_VALUE(key, typeof fn)
+  }
+  if (this[kReplyTrailers] === null) this[kReplyTrailers] = {}
+  this[kReplyTrailers][key] = fn
+  return this
+}
+
+Reply.prototype.hasTrailer = function (key) {
+  if (this[kReplyTrailers] === null) return false
+  return this[kReplyTrailers][key.toLowerCase()] !== undefined
+}
+
+Reply.prototype.removeTrailer = function (key) {
+  if (this[kReplyTrailers] === null) return this
+  this[kReplyTrailers][key.toLowerCase()] = undefined
+  return this
+}
+
 Reply.prototype.code = function (code) {
   const intValue = parseInt(code)
   if (isNaN(intValue) || intValue < 100 || intValue > 600) {
@@ -379,8 +407,6 @@ function preserializeHookEnd (err, request, reply, payload) {
     return
   }
 
-  flatstr(payload)
-
   onSendHook(reply, payload)
 }
 
@@ -390,7 +416,6 @@ function wrapSeralizationError (error, reply) {
 
 function onSendHook (reply, payload) {
   if (reply.context.onSend !== null) {
-    reply[kReplySent] = true
     onSendHookRunner(
       reply.context.onSend,
       reply.request,
@@ -416,9 +441,21 @@ function onSendEnd (reply, payload) {
   const req = reply.request
   const statusCode = res.statusCode
 
-  if (payload === undefined || payload === null) {
-    reply[kReplySent] = true
+  // we check if we need to update the trailers header and set it
+  if (reply[kReplyTrailers] !== null) {
+    const trailerHeaders = Object.keys(reply[kReplyTrailers])
+    let header = ''
+    for (const trailerName of trailerHeaders) {
+      if (typeof reply[kReplyTrailers][trailerName] !== 'function') continue
+      header += ' '
+      header += trailerName
+    }
+    // it must be chunked for trailer to work
+    reply.header('Transfer-Encoding', 'chunked')
+    reply.header('Trailer', header.trim())
+  }
 
+  if (payload === undefined || payload === null) {
     // 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.
@@ -428,14 +465,13 @@ function onSendEnd (reply, payload) {
     }
 
     res.writeHead(statusCode, reply[kReplyHeaders])
+    sendTrailer(payload, res, reply)
     // avoid ArgumentsAdaptorTrampoline from V8
     res.end(null, null, null)
     return
   }
 
   if (typeof payload.pipe === 'function') {
-    reply[kReplySent] = true
-
     sendStream(payload, res, reply)
     return
   }
@@ -450,12 +486,13 @@ function onSendEnd (reply, payload) {
     reply[kReplyHeaders]['content-length'] = '' + Buffer.byteLength(payload)
   }
 
-  reply[kReplySent] = true
-
   res.writeHead(statusCode, reply[kReplyHeaders])
-
+  // write payload first
+  res.write(payload)
+  // then send trailers
+  sendTrailer(payload, res, reply)
   // avoid ArgumentsAdaptorTrampoline from V8
-  res.end(payload, null, null)
+  res.end(null, null, null)
 }
 
 function logStreamError (logger, err, res) {
@@ -472,10 +509,13 @@ function sendStream (payload, res, reply) {
   let sourceOpen = true
   let errorLogged = false
 
+  // set trailer when stream ended
+  sendStreamTrailer(payload, res, reply)
+
   eos(payload, { readable: true, writable: false }, function (err) {
     sourceOpen = false
     if (err != null) {
-      if (res.headersSent) {
+      if (res.headersSent || reply.request.raw.aborted === true) {
         if (!errorLogged) {
           errorLogged = true
           logStreamError(reply.log, err, res)
@@ -520,9 +560,24 @@ function sendStream (payload, res, reply) {
   payload.pipe(res)
 }
 
+function sendTrailer (payload, res, reply) {
+  if (reply[kReplyTrailers] === null) return
+  const trailerHeaders = Object.keys(reply[kReplyTrailers])
+  const trailers = {}
+  for (const trailerName of trailerHeaders) {
+    if (typeof reply[kReplyTrailers][trailerName] !== 'function') continue
+    trailers[trailerName] = reply[kReplyTrailers][trailerName](reply, payload)
+  }
+  res.addTrailers(trailers)
+}
+
+function sendStreamTrailer (payload, res, reply) {
+  if (reply[kReplyTrailers] === null) return
+  payload.on('end', () => sendTrailer(null, 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,
@@ -536,89 +591,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
-      })
-      : 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()
 
@@ -679,11 +651,11 @@ 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] = {}
+    this[kReplyTrailers] = null
     this[kReplyStartTime] = undefined
     this[kReplyEndTime] = undefined
     this.log = log
@@ -696,15 +668,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')
@@ -745,31 +716,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
   }
 })