fastify 4.28.0 → 5.0.0-alpha.2

package/lib/wrapThenable.js

@@ -5,44 +5,68 @@ const {
   kReplyHijacked
 } = require('./symbols')
 
-function wrapThenable (thenable, reply) {
+const diagnostics = require('dc-polyfill')
+const channels = diagnostics.tracingChannel('fastify.request.handler')
+
+function wrapThenable (thenable, reply, store) {
+  if (store) store.async = true
   thenable.then(function (payload) {
     if (reply[kReplyHijacked] === true) {
       return
     }
 
-    // this is for async functions that are using reply.send directly
-    //
-    // since wrap-thenable will be called when using reply.send directly
-    // without actual return. the response can be sent already or
-    // the request may be terminated during the reply. in this situation,
-    // it require an extra checking of request.aborted to see whether
-    // the request is killed by client.
-    if (payload !== undefined || (reply.sent === false && reply.raw.headersSent === false && reply.request.raw.aborted === false)) {
-      // we use a try-catch internally to avoid adding a catch to another
-      // promise, increase promise perf by 10%
-      try {
-        reply.send(payload)
-      } catch (err) {
-        reply[kReplyIsError] = true
-        reply.send(err)
+    if (store) {
+      channels.asyncStart.publish(store)
+    }
+
+    try {
+      // this is for async functions that are using reply.send directly
+      //
+      // since wrap-thenable will be called when using reply.send directly
+      // without actual return. the response can be sent already or
+      // the request may be terminated during the reply. in this situation,
+      // it require an extra checking of request.aborted to see whether
+      // the request is killed by client.
+      if (payload !== undefined || (reply.sent === false && reply.raw.headersSent === false && reply.request.raw.aborted === false)) {
+        // we use a try-catch internally to avoid adding a catch to another
+        // promise, increase promise perf by 10%
+        try {
+          reply.send(payload)
+        } catch (err) {
+          reply[kReplyIsError] = true
+          reply.send(err)
+        }
+      }
+    } finally {
+      if (store) {
+        channels.asyncEnd.publish(store)
       }
     }
   }, function (err) {
-    if (reply.sent === true) {
-      reply.log.error({ err }, 'Promise errored, but reply.sent = true was set')
-      return
+    if (store) {
+      store.error = err
+      channels.error.publish(store) // note that error happens before asyncStart
+      channels.asyncStart.publish(store)
     }
 
-    reply[kReplyIsError] = true
-
-    // try-catch allow to re-throw error in error handler for async handler
     try {
+      if (reply.sent === true) {
+        reply.log.error({ err }, 'Promise errored, but reply.sent = true was set')
+        return
+      }
+
+      reply[kReplyIsError] = true
+
       reply.send(err)
       // The following should not happen
       /* c8 ignore next 3 */
     } catch (err) {
+      // try-catch allow to re-throw error in error handler for async handler
       reply.send(err)
+    } finally {
+      if (store) {
+        channels.asyncEnd.publish(store)
+      }
     }
   })
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.28.0",
+  "version": "5.0.0-alpha.2",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -11,24 +11,22 @@
     "benchmark:parser": "concurrently -k -s first \"node ./examples/benchmark/parser.js\" \"autocannon -c 100 -d 30 -p 10 -i ./examples/benchmark/body.json -H \"content-type:application/jsoff\" -m POST localhost:3000/\"",
     "build:validation": "node build/build-error-serializer.js && node build/build-validation.js",
     "coverage": "npm run unit -- --coverage-report=html",
-    "coverage:ci": "c8 --reporter=lcov tap --coverage-report=html --no-browser --no-check-coverage",
-    "coverage:ci-check-coverage": "c8 check-coverage --branches 100 --functions 100 --lines 100 --statements 100",
-    "lint": "npm run lint:standard && npm run lint:typescript && npm run lint:markdown",
-    "lint:fix": "standard --fix && npm run lint:typescript:fix",
+    "coverage:ci": "tap --coverage-report=html --coverage-report=lcov --allow-incomplete-coverage",
+    "coverage:ci-check-coverage": "tap replay",
+    "lint": "npm run lint:eslint",
+    "lint:fix": "eslint --fix",
     "lint:markdown": "markdownlint-cli2",
-    "lint:standard": "standard | snazzy",
-    "lint:typescript": "eslint -c types/.eslintrc.json types/**/*.d.ts test/types/**/*.test-d.ts",
-    "lint:typescript:fix": "npm run lint:typescript -- --fix",
-    "prepublishOnly": "cross-env PREPUBLISH=true tap --no-check-coverage test/build/**.test.js && npm run test:validator:integrity",
+    "lint:eslint": "eslint",
+    "prepublishOnly": "cross-env PREPUBLISH=true tap --allow-incomplete-coverage test/build/**.test.js && npm run test:validator:integrity",
     "test": "npm run lint && npm run unit && npm run test:typescript",
-    "test:ci": "npm run unit -- --cov --coverage-report=lcovonly && npm run test:typescript",
+    "test:ci": "npm run unit -- --coverage-report=lcovonly && npm run test:typescript",
     "test:report": "npm run lint && npm run unit:report && npm run test:typescript",
     "test:validator:integrity": "npm run build:validation && git diff --quiet --ignore-all-space --ignore-blank-lines --ignore-cr-at-eol lib/error-serializer.js && git diff --quiet --ignore-all-space --ignore-blank-lines --ignore-cr-at-eol lib/configValidator.js",
     "test:typescript": "tsc test/types/import.ts && tsd",
-    "test:watch": "npm run unit -- --watch --cov --no-coverage-report --reporter=terse",
-    "unit": "c8 tap",
+    "test:watch": "npm run unit -- --watch --coverage-report=none --reporter=terse",
+    "unit": "tap",
     "unit:junit": "tap-mocha-reporter xunit < out.tap > test/junit-testresults.xml",
-    "unit:report": "tap --cov --coverage-report=html --coverage-report=cobertura | tee out.tap",
+    "unit:report": "tap --coverage-report=html --coverage-report=cobertura | tee out.tap",
     "citgm": "tap --jobs=1 --timeout=120"
   },
   "repository": {
@@ -153,79 +151,61 @@
     }
   ],
   "devDependencies": {
-    "@fastify/pre-commit": "^2.0.2",
-    "@sinclair/typebox": "^0.31.17",
-    "@sinonjs/fake-timers": "^11.1.0",
-    "@types/node": "^20.8.4",
-    "@typescript-eslint/eslint-plugin": "^6.7.5",
-    "@typescript-eslint/parser": "^6.7.5",
+    "@fastify/pre-commit": "^2.1.0",
+    "@sinclair/typebox": "^0.32.22",
+    "@sinonjs/fake-timers": "^11.2.2",
+    "@stylistic/eslint-plugin": "^2.1.0",
+    "@stylistic/eslint-plugin-js": "^2.1.0",
+    "@types/node": "^20.12.7",
     "ajv": "^8.12.0",
     "ajv-errors": "^3.0.0",
-    "ajv-formats": "^2.1.1",
+    "ajv-formats": "^3.0.1",
     "ajv-i18n": "^4.2.0",
     "ajv-merge-patch": "^5.0.1",
-    "autocannon": "^7.14.0",
+    "autocannon": "^7.15.0",
     "branch-comparer": "^1.1.0",
-    "c8": "^8.0.1",
     "concurrently": "^8.2.2",
     "cross-env": "^7.0.3",
-    "eslint": "^8.51.0",
-    "eslint-config-standard": "^17.1.0",
-    "eslint-import-resolver-node": "^0.3.9",
-    "eslint-plugin-import": "^2.28.1",
-    "eslint-plugin-n": "^16.2.0",
-    "eslint-plugin-promise": "^6.1.1",
+    "eslint": "^9.0.0",
     "fast-json-body": "^1.1.0",
     "fastify-plugin": "^4.5.1",
-    "fluent-json-schema": "^4.1.2",
-    "form-data": "^4.0.0",
+    "fluent-json-schema": "^4.2.1",
     "h2url": "^0.2.0",
     "http-errors": "^2.0.0",
-    "joi": "^17.11.0",
-    "json-schema-to-ts": "^2.9.2",
+    "joi": "^17.12.3",
+    "json-schema-to-ts": "^3.0.1",
     "JSONStream": "^1.3.5",
-    "markdownlint-cli2": "^0.10.0",
+    "markdownlint-cli2": "^0.13.0",
+    "neostandard": "^0.7.0",
     "node-forge": "^1.3.1",
     "proxyquire": "^2.1.3",
     "send": "^0.18.0",
     "simple-get": "^4.0.1",
-    "snazzy": "^9.0.0",
     "split2": "^4.2.0",
-    "standard": "^17.1.0",
-    "tap": "^16.3.9",
-    "tsd": "^0.29.0",
-    "typescript": "^5.2.2",
-    "undici": "^5.26.0",
+    "tap": "^19.0.0",
+    "tsd": "^0.31.0",
+    "typescript": "^5.4.5",
+    "undici": "^6.13.0",
     "vary": "^1.1.2",
-    "yup": "^1.3.2"
+    "yup": "^1.4.0"
   },
   "dependencies": {
     "@fastify/ajv-compiler": "^3.5.0",
-    "@fastify/error": "^3.4.0",
+    "@fastify/error": "^3.4.1",
     "@fastify/fast-json-stringify-compiler": "^4.3.0",
     "abstract-logging": "^2.0.1",
     "avvio": "^8.3.0",
-    "fast-content-type-parse": "^1.1.0",
-    "fast-json-stringify": "^5.8.0",
-    "find-my-way": "^8.0.0",
-    "light-my-request": "^5.11.0",
+    "dc-polyfill": "^0.1.6",
+    "fast-json-stringify": "^5.14.1",
+    "find-my-way": "^8.1.0",
+    "light-my-request": "^5.13.0",
     "pino": "^9.0.0",
     "process-warning": "^3.0.0",
     "proxy-addr": "^2.0.7",
-    "rfdc": "^1.3.0",
+    "rfdc": "^1.3.1",
     "secure-json-parse": "^2.7.0",
-    "semver": "^7.5.4",
-    "toad-cache": "^3.3.0"
-  },
-  "standard": {
-    "ignore": [
-      "lib/configValidator.js",
-      "lib/error-serializer.js",
-      "fastify.d.ts",
-      "types/*",
-      "test/types/*",
-      "test/same-shape.test.js"
-    ]
+    "semver": "^7.6.0",
+    "toad-cache": "^3.7.0"
   },
   "tsd": {
     "directory": "test/types"

package/test/404s.test.js

@@ -6,7 +6,6 @@ const fp = require('fastify-plugin')
 const sget = require('simple-get').concat
 const errors = require('http-errors')
 const split = require('split2')
-const FormData = require('form-data')
 const Fastify = require('..')
 const { getServerUrl } = require('./helper')
 
@@ -68,21 +67,18 @@ test('default 404', t => {
       })
     })
 
-    test('using post method and multipart/formdata', t => {
+    test('using post method and multipart/formdata', async t => {
       t.plan(3)
-      const form = FormData()
-      form.append('test-field', 'just some field')
+      const form = new FormData()
+      form.set('test-field', 'just some field')
 
-      sget({
+      const response = await fetch(getServerUrl(fastify) + '/notSupported', {
         method: 'POST',
-        url: getServerUrl(fastify) + '/notSupported',
-        body: form,
-        json: false
-      }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
-        t.equal(response.headers['content-type'], 'application/json; charset=utf-8')
+        body: form
       })
+      t.equal(response.status, 404)
+      t.equal(response.statusText, 'Not Found')
+      t.equal(response.headers.get('content-type'), 'application/json; charset=utf-8')
     })
   })
 })

package/test/async-await.test.js

@@ -24,8 +24,28 @@ const opts = {
   }
 }
 
+const optsWithHostnameAndPort = {
+  schema: {
+    response: {
+      '2xx': {
+        type: 'object',
+        properties: {
+          hello: {
+            type: 'string'
+          },
+          hostname: {
+            type: 'string'
+          },
+          port: {
+            type: 'string'
+          }
+        }
+      }
+    }
+  }
+}
 test('async await', t => {
-  t.plan(11)
+  t.plan(13)
   const fastify = Fastify()
   try {
     fastify.get('/', opts, async function awaitMyFunc (req, reply) {
@@ -46,6 +66,16 @@ test('async await', t => {
     t.fail()
   }
 
+  try {
+    fastify.get('/await/hostname_port', optsWithHostnameAndPort, async function awaitMyFunc (req, reply) {
+      await sleep(200)
+      return { hello: 'world', hostname: req.hostname, port: req.port }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+
   fastify.listen({ port: 0 }, err => {
     t.error(err)
     t.teardown(() => { fastify.close() })
@@ -69,6 +99,20 @@ test('async await', t => {
       t.equal(response.headers['content-length'], '' + body.length)
       t.same(JSON.parse(body), { hello: 'world' })
     })
+
+    t.test('test for hostname and port in request', t => {
+      t.plan(4)
+      sget({
+        method: 'GET',
+        url: 'http://localhost:' + fastify.server.address().port + '/await/hostname_port'
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        const parsedBody = JSON.parse(body)
+        t.equal(parsedBody.hostname, 'localhost')
+        t.equal(parseInt(parsedBody.port), fastify.server.address().port)
+      })
+    })
   })
 })
 
@@ -135,7 +179,7 @@ test('server logs an error if reply.send is called and a value is returned via a
   const logger = pino(splitStream)
 
   const fastify = Fastify({
-    logger
+    loggerInstance: logger
   })
 
   fastify.get('/', async (req, reply) => {

package/test/build/error-serializer.test.js

@@ -4,6 +4,7 @@ const t = require('tap')
 const test = t.test
 const fs = require('node:fs')
 const path = require('node:path')
+const { loadESLint } = require('eslint')
 
 const { code } = require('../../build/build-error-serializer')
 
@@ -15,8 +16,9 @@ test('check generated code syntax', async (t) => {
   t.plan(1)
 
   // standard is a esm, we import it like this
-  const { default: standard } = await import('standard')
-  const result = await standard.lintText(code)
+  const Eslint = await loadESLint({ useFlatConfig: true })
+  const eslint = new Eslint()
+  const result = await eslint.lintText(code)
 
   // if there are any invalid syntax
   // fatal count will be greater than 0

package/test/check.test.js

@@ -0,0 +1,225 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const { S } = require('fluent-json-schema')
+const Fastify = require('..')
+const sget = require('simple-get').concat
+
+const BadRequestSchema = S.object()
+  .prop('statusCode', S.number())
+  .prop('error', S.string())
+  .prop('message', S.string())
+
+const InternalServerErrorSchema = S.object()
+  .prop('statusCode', S.number())
+  .prop('error', S.string())
+  .prop('message', S.string())
+
+const NotFoundSchema = S.object()
+  .prop('statusCode', S.number())
+  .prop('error', S.string())
+  .prop('message', S.string())
+
+const options = {
+  schema: {
+    body: {
+      type: 'object',
+      properties: {
+        id: { type: 'string' }
+      }
+    },
+    response: {
+      200: {
+        type: 'object',
+        properties: {
+          id: { type: 'string' }
+        }
+      },
+      400: {
+        description: 'Bad Request',
+        content: {
+          'application/json': {
+            schema: BadRequestSchema.valueOf()
+          }
+        }
+      },
+      404: {
+        description: 'Resource not found',
+        content: {
+          'application/json': {
+            schema: NotFoundSchema.valueOf(),
+            example: {
+              statusCode: 404,
+              error: 'Not Found',
+              message: 'Not Found'
+            }
+          }
+        }
+      },
+      500: {
+        description: 'Internal Server Error',
+        content: {
+          'application/json': {
+            schema: InternalServerErrorSchema.valueOf(),
+            example: {
+              message: 'Internal Server Error'
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+const handler = (request, reply) => {
+  console.log('in handler')
+  if (request.body.id === '400') {
+    return reply.status(400).send({
+      statusCode: 400,
+      error: 'Bad Request',
+      message: 'Custom message',
+      extra: 'This should not be in the response'
+    })
+  }
+
+  if (request.body.id === '404') {
+    return reply.status(404).send({
+      statusCode: 404,
+      error: 'Not Found',
+      message: 'Custom Not Found',
+      extra: 'This should not be in the response'
+    })
+  }
+
+  if (request.body.id === '500') {
+    reply.status(500).send({
+      statusCode: 500,
+      error: 'Internal Server Error',
+      message: 'Custom Internal Server Error',
+      extra: 'This should not be in the response'
+    })
+  }
+
+  reply.send({
+    id: request.body.id,
+    extra: 'This should not be in the response'
+  })
+}
+
+test('serialize the response for a Bad Request error, as defined on the schema', t => {
+  const fastify = Fastify({})
+
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.post('/', options, handler)
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    const url = `http://localhost:${fastify.server.address().port}/`
+
+    sget({
+      method: 'POST',
+      url,
+      json: true
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 400)
+      t.same(body, {
+        statusCode: 400,
+        error: 'Bad Request',
+        message: 'body must be object'
+      })
+      t.end()
+    })
+  })
+})
+
+// test('serialize the response for a Not Found error, as defined on the schema', t => {
+//   const fastify = Fastify({})
+
+//   t.teardown(fastify.close.bind(fastify))
+
+//   fastify.post('/', options, handler)
+
+//   fastify.listen({ port: 0 }, err => {
+//     t.error(err)
+
+//     const url = `http://localhost:${fastify.server.address().port}/`
+
+//     sget({
+//       method: 'POST',
+//       url,
+//       json: true,
+//       body: { id: '404' }
+//     }, (err, response, body) => {
+//       t.error(err)
+//       t.equal(response.statusCode, 404)
+//       t.same(body, {
+//         statusCode: 404,
+//         error: 'Not Found',
+//         message: 'Custom Not Found'
+//       })
+//       t.end()
+//     })
+//   })
+// })
+
+// test('serialize the response for a Internal Server Error error, as defined on the schema', t => {
+//   const fastify = Fastify({})
+
+//   t.teardown(fastify.close.bind(fastify))
+
+//   fastify.post('/', options, handler)
+
+//   fastify.listen({ port: 0 }, err => {
+//     t.error(err)
+
+//     const url = `http://localhost:${fastify.server.address().port}/`
+
+//     sget({
+//       method: 'POST',
+//       url,
+//       json: true,
+//       body: { id: '500' }
+//     }, (err, response, body) => {
+//       t.error(err)
+//       t.equal(response.statusCode, 500)
+//       t.same(body, {
+//         statusCode: 500,
+//         error: 'Internal Server Error',
+//         message: 'Custom Internal Server Error'
+//       })
+//       t.end()
+//     })
+//   })
+// })
+
+// test('serialize the success response, as defined on the schema', t => {
+//   const fastify = Fastify({})
+
+//   t.teardown(fastify.close.bind(fastify))
+
+//   fastify.post('/', options, handler)
+
+//   fastify.listen({ port: 0 }, err => {
+//     t.error(err)
+
+//     const url = `http://localhost:${fastify.server.address().port}/`
+
+//     sget({
+//       method: 'POST',
+//       url,
+//       json: true,
+//       body: { id: 'test' }
+//     }, (err, response, body) => {
+//       t.error(err)
+//       t.equal(response.statusCode, 200)
+//       t.same(body, {
+//         id: 'test'
+//       })
+//       t.end()
+//     })
+//   })
+// })

package/test/close-pipelining.test.js

@@ -4,7 +4,6 @@ const t = require('tap')
 const test = t.test
 const Fastify = require('..')
 const { Client } = require('undici')
-const semver = require('semver')
 
 test('Should return 503 while closing - pipelining', async t => {
   const fastify = Fastify({
@@ -36,46 +35,8 @@ test('Should return 503 while closing - pipelining', async t => {
   await instance.close()
 })
 
-// default enable of idle closing idle connection is accidentally backported to 18.19.0 and fixed in 18.20.3
-// Refs: https://github.com/nodejs/node/releases/tag/v18.20.3
-const isNodeDefaultClosingIdleConnection =
-  (
-    semver.gte(process.version, '18.19.0') &&
-    semver.lt(process.version, '18.20.3')
-  ) ||
-  semver.gte(process.version, '19.0.0')
-test('Should not return 503 while closing - pipelining - return503OnClosing: false, skip when Node default closing idle connection', { skip: isNodeDefaultClosingIdleConnection }, async t => {
-  const fastify = Fastify({
-    return503OnClosing: false,
-    forceCloseConnections: false
-  })
-
-  fastify.get('/', (req, reply) => {
-    fastify.close()
-    reply.send({ hello: 'world' })
-  })
-
-  await fastify.listen({ port: 0 })
-
-  const instance = new Client('http://localhost:' + fastify.server.address().port, {
-    pipelining: 2
-  })
-
-  const codes = [200, 200, 200]
-  const responses = await Promise.all([
-    instance.request({ path: '/', method: 'GET' }),
-    instance.request({ path: '/', method: 'GET' }),
-    instance.request({ path: '/', method: 'GET' })
-  ])
-  const actual = responses.map(r => r.statusCode)
-
-  t.same(actual, codes)
-
-  await instance.close()
-})
-
-test('Should close the socket abruptly - pipelining - return503OnClosing: false, skip when Node not default closing idle connection', { skip: !isNodeDefaultClosingIdleConnection }, async t => {
-  // Since Node v19, we will always invoke server.closeIdleConnections()
+test('Should close the socket abruptly - pipelining - return503OnClosing: false', async t => {
+  // Since Node v20, we will always invoke server.closeIdleConnections()
   // therefore our socket will be closed
   const fastify = Fastify({
     return503OnClosing: false,