fastify 3.27.3 → 3.29.0

package/docs/Reference/Reply.md

@@ -13,6 +13,9 @@
   - [.getHeaders()](#getheaders)
   - [.removeHeader(key)](#removeheaderkey)
   - [.hasHeader(key)](#hasheaderkey)
+  - [.trailer(key, function)](#trailerkey-function)
+  - [.hasTrailer(key)](#hastrailerkey)
+  - [.removeTrailer(key)](#removetrailerkey)
   - [.redirect([code,] dest)](#redirectcode--dest)
   - [.callNotFound()](#callnotfound)
   - [.getResponseTime()](#getresponsetime)
@@ -47,6 +50,9 @@ object that exposes the following functions and properties:
 - `.getHeaders()` - Gets a shallow copy of all current response headers.
 - `.removeHeader(key)` - Remove the value of a previously set header.
 - `.hasHeader(name)` - Determine if a header has been set.
+- `.trailer(key, function)` - Sets a response trailer.
+- `.hasTrailer(key)` - Determine if a trailer has been set.
+- `.removeTrailer(key)` - Remove the value of a previously set trailer.
 - `.type(value)` - Sets the header `Content-Type`.
 - `.redirect([code,] dest)` - Redirect to the specified url, the status code is
   optional (default to `302`).
@@ -199,6 +205,49 @@ reply.getHeader('x-foo') // undefined
 
 Returns a boolean indicating if the specified header has been set.
 
+### .trailer(key, function)
+<a id="trailer"></a>
+
+Sets a response trailer. Trailer usually used when you want some header that require heavy resources to be sent after the `data`, for example `Server-Timing`, `Etag`. It can ensure the client get the response data as soon as possible.
+
+*Note: The header `Transfer-Encoding: chunked` will be added once you use the trailer. It is a hard requipment for using trailer in Node.js.*
+
+*Note: Currently, the computation function only supports synchronous function. That means `async-await` and `promise` are not supported.*
+
+```js
+reply.trailer('server-timing', function() {
+  return 'db;dur=53, app;dur=47.2'
+})
+
+const { createHash } = require('crypto')
+// trailer function also recieve two argument
+// @param {object} reply fastify reply
+// @param {string|Buffer|null} payload payload that already sent, note that it will be null when stream is sent
+reply.trailer('content-md5', function(reply, payload) {
+  const hash = createHash('md5')
+  hash.update(payload)
+  return hash.disgest('hex')
+})
+```
+
+### .hasTrailer(key)
+<a id="hasTrailer"></a>
+
+Returns a boolean indicating if the specified trailer has been set.
+
+### .removeTrailer(key)
+<a id="removeTrailer"></a>
+
+Remove the value of a previously set trailer.
+```js
+reply.trailer('server-timing', function() {
+  return 'db;dur=53, app;dur=47.2'
+})
+reply.removeTrailer('server-timing')
+reply.getTrailer('server-timing') // undefined
+```
+
+
 ### .redirect([code ,] dest)
 <a id="redirect"></a>
 

package/fastify.d.ts

@@ -9,7 +9,7 @@ import { FastifyLoggerInstance, FastifyLoggerOptions } from './types/logger'
 import { FastifyInstance } from './types/instance'
 import { FastifyServerFactory } from './types/serverFactory'
 import { Options as AjvOptions } from '@fastify/ajv-compiler'
-import { FastifyError } from 'fastify-error'
+import { FastifyError } from '@fastify/error'
 import { FastifyReply } from './types/reply'
 import { FastifySchemaValidationError } from './types/schema'
 import { ConstructorAction, ProtoAction } from "./types/content-type-parser";
@@ -163,7 +163,7 @@ export type FastifyServerOptions<
 
 type TrustProxyFunction = (address: string, hop: number) => boolean
 
-declare module 'fastify-error' {
+declare module '@fastify/error' {
   interface FastifyError {
     validation?: ValidationResult[];
   }
@@ -188,7 +188,7 @@ export { FastifyContext, FastifyContextConfig } from './types/context'
 export { RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler } from './types/route'
 export * from './types/register'
 export { FastifyBodyParser, FastifyContentTypeParser, AddContentTypeParser, hasContentTypeParser, getDefaultJsonParser, ProtoAction, ConstructorAction } from './types/content-type-parser'
-export { FastifyError } from 'fastify-error'
+export { FastifyError } from '@fastify/error'
 export { FastifySchema, FastifySchemaCompiler } from './types/schema'
 export { HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault, ContextConfigDefault, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault } from './types/utils'
 export * from './types/hooks'

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '3.27.3'
+const VERSION = '3.29.0'
 
 const Avvio = require('avvio')
 const http = require('http')

package/lib/errors.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const createError = require('fastify-error')
+const createError = require('@fastify/error')
 const codes = {
   /**
    * Basic
@@ -147,6 +147,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

package/lib/fourOhFour.js

@@ -37,7 +37,8 @@ function fourOhFour (options) {
   const { logger, genReqId } = options
 
   // 404 router, used for handling encapsulated 404 handlers
-  const router = FindMyWay({ defaultRoute: fourOhFourFallBack })
+  const router = FindMyWay({ onBadUrl: createOnBadUrl(), defaultRoute: fourOhFourFallBack })
+  let _onBadUrlHandler = null
 
   return { router, setNotFoundHandler, setContext, arrange404 }
 
@@ -45,6 +46,8 @@ function fourOhFour (options) {
     // Change the pointer of the fastify instance to itself, so register + prefix can add new 404 handler
     instance[kFourOhFourLevelInstance] = instance
     instance[kCanSetNotFoundHandler] = true
+    // we need to bind instance for the context
+    router.onBadUrl = router.onBadUrl.bind(instance)
   }
 
   function basic404 (request, reply) {
@@ -58,6 +61,18 @@ function fourOhFour (options) {
     })
   }
 
+  function createOnBadUrl () {
+    return function onBadUrl (path, req, res) {
+      const id = genReqId(req)
+      const childLogger = logger.child({ reqId: id })
+      const fourOhFourContext = this[kFourOhFourLevelInstance][kFourOhFourContext]
+      const request = new Request(id, null, req, null, childLogger, fourOhFourContext)
+      const reply = new Reply(res, request, childLogger)
+
+      _onBadUrlHandler(request, reply)
+    }
+  }
+
   function setContext (instance, context) {
     const _404Context = Object.assign({}, instance[kFourOhFourContext])
     _404Context.onSend = context.onSend
@@ -107,8 +122,12 @@ function fourOhFour (options) {
     if (handler) {
       this[kFourOhFourLevelInstance][kCanSetNotFoundHandler] = false
       handler = handler.bind(this)
+      // update onBadUrl handler
+      _onBadUrlHandler = handler
     } else {
       handler = basic404
+      // update onBadUrl handler
+      _onBadUrlHandler = basic404
     }
 
     this.after((notHandledErr, done) => {

package/lib/reply.js

@@ -16,6 +16,7 @@ const {
   kReplySerializerDefault,
   kReplyIsError,
   kReplyHeaders,
+  kReplyTrailers,
   kReplyHasStatusCode,
   kReplyIsRunningOnErrorHook,
   kDisableRequestLogging
@@ -47,7 +48,9 @@ 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')
 
@@ -60,6 +63,7 @@ function Reply (res, request, log) {
   this[kReplyIsRunningOnErrorHook] = false
   this.request = request
   this[kReplyHeaders] = {}
+  this[kReplyTrailers] = null
   this[kReplyHasStatusCode] = false
   this[kReplyStartTime] = undefined
   this.log = log
@@ -261,6 +265,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) {
@@ -416,18 +461,35 @@ function onSendEnd (reply, payload) {
   const req = reply.request
   const statusCode = res.statusCode
 
+  // 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) {
     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.
+    // < 200
+    // A sender MUST NOT send a Content-Length header field in any message
+    // that contains a Transfer-Encoding header field.
     // For HEAD we don't overwrite the `content-length`
-    if (statusCode >= 200 && statusCode !== 204 && statusCode !== 304 && req.method !== 'HEAD') {
+    if (statusCode >= 200 && statusCode !== 204 && statusCode !== 304 && req.method !== 'HEAD' && reply[kReplyTrailers] === null) {
       reply[kReplyHeaders]['content-length'] = '0'
     }
 
     res.writeHead(statusCode, reply[kReplyHeaders])
+    sendTrailer(payload, res, reply)
     // avoid ArgumentsAdaptorTrampoline from V8
     res.end(null, null, null)
     return
@@ -444,18 +506,23 @@ function onSendEnd (reply, payload) {
     throw new FST_ERR_REP_INVALID_PAYLOAD_TYPE(typeof payload)
   }
 
-  if (!reply[kReplyHeaders]['content-length']) {
-    reply[kReplyHeaders]['content-length'] = '' + Buffer.byteLength(payload)
-  } else if (req.raw.method !== 'HEAD' && reply[kReplyHeaders]['content-length'] !== Buffer.byteLength(payload)) {
-    reply[kReplyHeaders]['content-length'] = '' + Buffer.byteLength(payload)
+  if (reply[kReplyTrailers] === null) {
+    if (!reply[kReplyHeaders]['content-length']) {
+      reply[kReplyHeaders]['content-length'] = '' + Buffer.byteLength(payload)
+    } else if (req.raw.method !== 'HEAD' && reply[kReplyHeaders]['content-length'] !== Buffer.byteLength(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,6 +539,9 @@ 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) {
@@ -520,6 +590,22 @@ 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) {
@@ -684,6 +770,7 @@ function buildReply (R) {
     this[kReplySerializer] = null
     this.request = request
     this[kReplyHeaders] = {}
+    this[kReplyTrailers] = null
     this[kReplyStartTime] = undefined
     this[kReplyEndTime] = undefined
     this.log = log

package/lib/symbols.js

@@ -30,6 +30,7 @@ const keys = {
   kReplySerializer: Symbol('fastify.reply.serializer'),
   kReplyIsError: Symbol('fastify.reply.isError'),
   kReplyHeaders: Symbol('fastify.reply.headers'),
+  kReplyTrailers: Symbol('fastify.reply.trailers'),
   kReplyHasStatusCode: Symbol('fastify.reply.hasStatusCode'),
   kReplySent: Symbol('fastify.reply.sent'),
   kReplySentOverwritten: Symbol('fastify.reply.sentOverwritten'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "3.27.3",
+  "version": "3.29.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -127,9 +127,8 @@
     "@sinonjs/fake-timers": "^9.1.0",
     "@types/node": "^16.0.0",
     "@types/pino": "^6.0.1",
-    "@typescript-eslint/eslint-plugin": "^5.0.0",
-    "@typescript-eslint/parser": "^5.0.0",
-    "JSONStream": "^1.3.5",
+    "@typescript-eslint/eslint-plugin": "^5.21.0",
+    "@typescript-eslint/parser": "^5.21.0",
     "ajv": "^6.0.0",
     "ajv-errors": "^1.0.1",
     "ajv-formats": "^2.1.1",
@@ -140,11 +139,11 @@
     "cors": "^2.8.5",
     "coveralls": "^3.1.0",
     "dns-prefetch-control": "^0.3.0",
-    "eslint": "^8.0.1",
+    "eslint": "^8.14.0",
     "eslint-config-standard": "^17.0.0-1",
-    "eslint-import-resolver-node": "^0.3.2",
-    "eslint-plugin-import": "^2.25.4",
-    "eslint-plugin-n": "^14.0.0",
+    "eslint-import-resolver-node": "^0.3.6",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-n": "^15.2.0",
     "eslint-plugin-promise": "^6.0.0",
     "fast-json-body": "^1.1.0",
     "fastify-plugin": "^3.0.0",
@@ -157,6 +156,7 @@
     "hsts": "^2.2.0",
     "http-errors": "^2.0.0",
     "ienoopen": "^1.1.0",
+    "JSONStream": "^1.3.5",
     "license-checker": "^25.0.1",
     "pem": "^1.14.4",
     "proxyquire": "^2.1.3",
@@ -166,7 +166,7 @@
     "simple-get": "^4.0.0",
     "snazzy": "^9.0.0",
     "split2": "^4.1.0",
-    "standard": "^17.0.0-2",
+    "standard": "^17.0.0",
     "tap": "^15.1.1",
     "tap-mocha-reporter": "^5.0.1",
     "then-sleep": "^1.0.1",
@@ -178,15 +178,15 @@
   },
   "dependencies": {
     "@fastify/ajv-compiler": "^1.0.0",
+    "@fastify/error": "^2.0.0",
     "abstract-logging": "^2.0.0",
     "avvio": "^7.1.2",
     "fast-json-stringify": "^2.5.2",
-    "fastify-error": "^0.3.0",
-    "process-warning": "^1.0.0",
     "find-my-way": "^4.5.0",
     "flatstr": "^1.0.12",
     "light-my-request": "^4.2.0",
     "pino": "^6.13.0",
+    "process-warning": "^1.0.0",
     "proxy-addr": "^2.0.7",
     "rfdc": "^1.1.4",
     "secure-json-parse": "^2.0.0",

package/test/404s.test.js

@@ -1738,6 +1738,58 @@ test('400 in case of bad url (pre find-my-way v2.2.0 was a 404)', t => {
     })
   })
 
+  t.test('No route registered', t => {
+    t.plan(3)
+    const fastify = Fastify()
+    fastify.inject({
+      url: '/%c0',
+      method: 'GET'
+    }, (err, response) => {
+      t.error(err)
+      t.equal(response.statusCode, 404)
+      t.same(JSON.parse(response.payload), {
+        error: 'Not Found',
+        message: 'Route GET:/%c0 not found',
+        statusCode: 404
+      })
+    })
+  })
+
+  t.test('Only / is registered', t => {
+    t.plan(3)
+    const fastify = Fastify({ logger: true })
+    fastify.get('/', () => t.fail('we should not be here'))
+    fastify.inject({
+      url: '/%c0',
+      method: 'GET'
+    }, (err, response) => {
+      t.error(err)
+      t.equal(response.statusCode, 404)
+      t.same(JSON.parse(response.payload), {
+        error: 'Not Found',
+        message: 'Route GET:/%c0 not found',
+        statusCode: 404
+      })
+    })
+  })
+
+  t.test('customized 404', t => {
+    t.plan(3)
+    const fastify = Fastify({ logger: true })
+    fastify.get('/', () => t.fail('we should not be here'))
+    fastify.setNotFoundHandler(function (req, reply) {
+      reply.code(404).send('this was not found')
+    })
+    fastify.inject({
+      url: '/%c0',
+      method: 'GET'
+    }, (err, response) => {
+      t.error(err)
+      t.equal(response.statusCode, 404)
+      t.same(response.payload, 'this was not found')
+    })
+  })
+
   t.end()
 })
 

package/test/internals/reply.test.js

@@ -5,9 +5,8 @@ const test = t.test
 const sget = require('simple-get').concat
 const http = require('http')
 const NotFound = require('http-errors').NotFound
-const EventEmitter = require('events').EventEmitter
 const Reply = require('../../lib/reply')
-const { Writable } = require('stream')
+const { Readable, Writable } = require('stream')
 const {
   kReplyErrorHandlerCalled,
   kReplyHeaders,
@@ -40,30 +39,31 @@ test('Once called, Reply should return an object with methods', t => {
 test('reply.send will logStream error and destroy the stream', { only: true }, t => {
   t.plan(1)
   let destroyCalled
-  const payload = new EventEmitter()
+  const payload = new Readable({
+    read () {},
+    destroy (err, cb) {
+      destroyCalled = true
+      cb(err)
+    }
+  })
 
-  const response = {
+  const response = new Writable()
+  Object.assign(response, {
     setHeader: () => {},
     hasHeader: () => false,
     getHeader: () => undefined,
     writeHead: () => {},
-    end: () => {},
-    headersSent: true,
-    destroy: () => (destroyCalled = true),
-    on: () => {}
-  }
+    write: () => {},
+    headersSent: true
+  })
 
   const log = {
     warn: () => {}
   }
 
-  Object.assign(payload, {
-    pipe: () => {},
-    destroy: () => {}
-  })
   const reply = new Reply(response, { context: { onSend: null } }, log)
   reply.send(payload)
-  payload.emit('error', new Error('stream error'))
+  payload.destroy(new Error('stream error'))
 
   t.equal(destroyCalled, true, 'Error not logged and not streamed')
 })
@@ -75,6 +75,7 @@ test('reply.send throw with circular JSON', t => {
     hasHeader: () => false,
     getHeader: () => undefined,
     writeHead: () => {},
+    write: () => {},
     end: () => {}
   }
   const reply = new Reply(response, { context: { onSend: [] } })
@@ -92,6 +93,7 @@ test('reply.send returns itself', t => {
     hasHeader: () => false,
     getHeader: () => undefined,
     writeHead: () => {},
+    write: () => {},
     end: () => {}
   }
   const reply = new Reply(response, { context: { onSend: [] } })

package/test/logger.test.js

@@ -1481,6 +1481,26 @@ test('should not log incoming request and outgoing response when disabled', t =>
   })
 })
 
+test('should not log incoming request and outgoing response for 404 onBadUrl when disabled', t => {
+  t.plan(1)
+  const lines = []
+  const dest = new stream.Writable({
+    write: function (chunk, enc, cb) {
+      lines.push(JSON.parse(chunk))
+      cb()
+    }
+  })
+  const fastify = Fastify({ disableRequestLogging: true, logger: { level: 'info', stream: dest } })
+
+  fastify.inject({
+    url: '/%c0',
+    method: 'GET'
+  }, (e, res) => {
+    // it will log 1 line only because of basic404
+    t.same(lines.length, 1)
+  })
+})
+
 test('should pass when using unWritable props in the logger option', t => {
   t.plan(1)
   Fastify({