fastify 6.0.0-alpha.5 → 6.0.0-alpha.6

package/lib/schemas.js

@@ -8,7 +8,8 @@ const {
   FST_ERR_SCH_MISSING_ID,
   FST_ERR_SCH_ALREADY_PRESENT,
   FST_ERR_SCH_DUPLICATE,
-  FST_ERR_SCH_CONTENT_MISSING_SCHEMA
+  FST_ERR_SCH_CONTENT_MISSING_SCHEMA,
+  FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN
 } = require('./errors')
 const ContentType = require('./content-type')
 
@@ -134,6 +135,40 @@ function generateFluentSchema (schema) {
   }
 }
 
+/**
+ * Resolve the right JSON Schema serialization function for a per-media-type
+ * (`content`) response schema map, given the response media type.
+ *
+ * @param {object} contentSchema the compiled per-content-type schema map
+ * @param {string} mediaType the response media type (lowercased)
+ * @param {string|number} statusCode the resolved http status key
+ * @param {boolean} failClosed whether to throw when no schema matches (used
+ *   for route response serialization) or return false (used by the error
+ *   handler, which falls back to the default error serializer)
+ * @returns {function|false} the serializer function, or false when no schema
+ *   applies and failClosed is false
+ */
+function getContentSerializer (contentSchema, mediaType, statusCode, failClosed) {
+  if (contentSchema[mediaType]) {
+    return contentSchema[mediaType]
+  }
+
+  // fallback to match all media-types
+  if (contentSchema['*/*']) {
+    return contentSchema['*/*']
+  }
+
+  // The response content-type is not declared in the route's content map. When
+  // serializing a route response, do not fall back to a raw JSON dump (which
+  // would bypass the response schema and expose every field); surface the
+  // misconfiguration instead.
+  if (failClosed) {
+    throw new FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN(statusCode, mediaType)
+  }
+
+  return false
+}
+
 /**
  * Search for the right JSON schema compiled function in the request context
  * setup by the route configuration `schema.response`.
@@ -142,11 +177,15 @@ function generateFluentSchema (schema) {
  * @param {object} context the request context
  * @param {number} statusCode the http status code
  * @param {string} [contentType] the reply content type
+ * @param {object} [opts] serialization options
+ * @param {boolean} [opts.failClosed] when true, throw when the response
+ *   content-type is not declared in the content map; otherwise return false
  * @returns {function|false} the right JSON Schema function to serialize
  * the reply or false if it is not set
  */
-function getSchemaSerializer (context, statusCode, contentType) {
+function getSchemaSerializer (context, statusCode, contentType, opts = {}) {
   const responseSchemaDef = context[kSchemaResponse]
+  const failClosed = opts.failClosed === true
   if (!responseSchemaDef) {
     return false
   }
@@ -154,16 +193,7 @@ function getSchemaSerializer (context, statusCode, contentType) {
     if (responseSchemaDef[statusCode].constructor === Object) {
       const ct = ContentType.from(contentType)
       if (ct.isValid) {
-        if (responseSchemaDef[statusCode][ct.mediaType]) {
-          return responseSchemaDef[statusCode][ct.mediaType]
-        }
-
-        // fallback to match all media-type
-        if (responseSchemaDef[statusCode]['*/*']) {
-          return responseSchemaDef[statusCode]['*/*']
-        }
-
-        return false
+        return getContentSerializer(responseSchemaDef[statusCode], ct.mediaType, statusCode, failClosed)
       }
     }
     return responseSchemaDef[statusCode]
@@ -173,16 +203,7 @@ function getSchemaSerializer (context, statusCode, contentType) {
     if (responseSchemaDef[fallbackStatusCode].constructor === Object) {
       const ct = ContentType.from(contentType)
       if (ct.isValid) {
-        if (responseSchemaDef[fallbackStatusCode][ct.mediaType]) {
-          return responseSchemaDef[fallbackStatusCode][ct.mediaType]
-        }
-
-        // fallback to match all media-type
-        if (responseSchemaDef[fallbackStatusCode]['*/*']) {
-          return responseSchemaDef[fallbackStatusCode]['*/*']
-        }
-
-        return false
+        return getContentSerializer(responseSchemaDef[fallbackStatusCode], ct.mediaType, fallbackStatusCode, failClosed)
       }
     }
 
@@ -192,16 +213,7 @@ function getSchemaSerializer (context, statusCode, contentType) {
     if (responseSchemaDef.default.constructor === Object) {
       const ct = ContentType.from(contentType)
       if (ct.isValid) {
-        if (responseSchemaDef.default[ct.mediaType]) {
-          return responseSchemaDef.default[ct.mediaType]
-        }
-
-        // fallback to match all media-type
-        if (responseSchemaDef.default['*/*']) {
-          return responseSchemaDef.default['*/*']
-        }
-
-        return false
+        return getContentSerializer(responseSchemaDef.default, ct.mediaType, 'default', failClosed)
       }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "6.0.0-alpha.5",
+  "version": "6.0.0-alpha.6",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -18,12 +18,13 @@
     "lint:fix": "eslint --fix",
     "lint:markdown": "markdownlint-cli2",
     "lint:eslint": "eslint",
-    "prepublishOnly": "cross-env PREPUBLISH=true borp --reporter=@jsumners/line-reporter && npm run test:validator:integrity && npm run build:sync-version",
+    "prepublishOnly": "npm run test:version && cross-env PREPUBLISH=true borp --reporter=@jsumners/line-reporter && npm run test:validator:integrity && npm run build:sync-version",
     "test": "npm run lint && npm run unit && npm run test:types",
     "test:ci": "npm run unit && npm run test:types",
     "test:report": "npm run lint && npm run unit:report && npm run test:types",
     "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/config-validator.js",
     "test:types": "tstyche",
+    "test:version": "node --test test/build/version.test.js",
     "test:watch": "npm run unit -- --watch --coverage-report=none --reporter=terse",
     "unit": "borp",
     "unit:report": "c8 --reporter html borp --reporter=@jsumners/line-reporter",
@@ -148,6 +149,10 @@
       "name": "Jean Michelet",
       "email": "jean.antoine.michelet@gmail.com",
       "url": "https://github.com/jean-michelet"
+    },
+    {
+      "name": "Antonio Tripodi",
+      "url": "https://github.com/Tony133"
     }
   ],
   "license": "MIT",
@@ -210,7 +215,7 @@
     "abstract-logging": "^2.0.1",
     "avvio": "^9.0.0",
     "fast-json-stringify": "^7.0.0",
-    "find-my-way": "^9.6.0",
+    "find-my-way": "^9.10.0",
     "light-my-request": "^6.0.0",
     "pino": "^9.14.0 || ^10.1.0",
     "process-warning": "^5.1.0",

package/test/close-disposable.test.js

@@ -0,0 +1,154 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('../fastify')
+
+test('addHook onClose supports AsyncDisposable objects', async t => {
+  const app = Fastify()
+  let disposed = false
+
+  const resource = {
+    async [Symbol.asyncDispose] () {
+      disposed = true
+    }
+  }
+
+  app.addHook('onClose', resource)
+  await app.ready()
+  t.assert.equal(disposed, false)
+
+  await app.close()
+  t.assert.equal(disposed, true)
+})
+
+test('addHook onClose supports synchronous Disposable objects', async t => {
+  const app = Fastify()
+  let disposed = false
+
+  const resource = {
+    [Symbol.dispose] () {
+      disposed = true
+    }
+  }
+
+  app.addHook('onClose', resource)
+  await app.ready()
+  t.assert.equal(disposed, false)
+
+  await app.close()
+  t.assert.equal(disposed, true)
+})
+
+test('addHook onClose prefers Symbol.asyncDispose over Symbol.dispose when both are present', async t => {
+  const app = Fastify()
+  let asyncDisposed = false
+  let syncDisposed = false
+
+  const resource = {
+    async [Symbol.asyncDispose] () {
+      asyncDisposed = true
+    },
+    [Symbol.dispose] () {
+      syncDisposed = true
+    }
+  }
+
+  app.addHook('onClose', resource)
+  await app.ready()
+  await app.close()
+
+  t.assert.equal(asyncDisposed, true)
+  t.assert.equal(syncDisposed, false)
+})
+
+test('addHook onClose propagates rejection from Symbol.asyncDispose', async t => {
+  const app = Fastify()
+  const customError = new Error('dispose async failed')
+
+  const resource = {
+    async [Symbol.asyncDispose] () {
+      throw customError
+    }
+  }
+
+  app.addHook('onClose', resource)
+  await app.ready()
+
+  await t.assert.rejects(app.close(), {
+    message: 'dispose async failed'
+  })
+})
+
+test('addHook onClose ignores fulfillment value from Symbol.asyncDispose', async t => {
+  const app = Fastify()
+
+  const resource = {
+    async [Symbol.asyncDispose] () {
+      return 'OK'
+    }
+  }
+
+  app.addHook('onClose', resource)
+  await app.ready()
+
+  await t.assert.doesNotReject(app.close())
+})
+
+test('addHook onClose propagates thrown error from Symbol.dispose', async t => {
+  const app = Fastify()
+  const customError = new Error('dispose sync failed')
+
+  const resource = {
+    [Symbol.dispose] () {
+      throw customError
+    }
+  }
+
+  app.addHook('onClose', resource)
+  await app.ready()
+
+  await t.assert.rejects(app.close(), {
+    message: 'dispose sync failed'
+  })
+})
+
+test('addHook onClose respects plugin execution order for disposables', async t => {
+  const app = Fastify()
+  const order = []
+
+  app.register(function childPlugin (instance, opts, done) {
+    instance.addHook('onClose', {
+      async [Symbol.asyncDispose] () {
+        order.push('child')
+      }
+    })
+    done()
+  })
+
+  app.addHook('onClose', {
+    async [Symbol.asyncDispose] () {
+      order.push('parent')
+    }
+  })
+
+  await app.ready()
+  await app.close()
+
+  t.assert.deepStrictEqual(order, ['child', 'parent'])
+})
+
+test('addHook onClose throws FST_ERR_HOOK_INVALID_HANDLER when non-function non-disposable is passed', t => {
+  const app = Fastify()
+
+  t.assert.throws(() => {
+    app.addHook('onClose', 'not-a-function-or-disposable')
+  }, {
+    code: 'FST_ERR_HOOK_INVALID_HANDLER'
+  })
+
+  t.assert.throws(() => {
+    app.addHook('onClose', { someProp: 123 })
+  }, {
+    code: 'FST_ERR_HOOK_INVALID_HANDLER'
+  })
+})

package/test/constrained-routes.test.js

@@ -607,7 +607,7 @@ test('Should allow registering constrained routes in a prefixed plugin', (t, don
 })
 
 test('Should allow registering a constrained GET route after a constrained HEAD route', (t, done) => {
-  t.plan(3)
+  t.plan(4)
   const fastify = Fastify()
 
   fastify.route({
@@ -637,7 +637,9 @@ test('Should allow registering a constrained GET route after a constrained HEAD
     }
   }, (err, res) => {
     t.assert.ifError(err)
-    t.assert.deepStrictEqual(res.payload, 'custom HEAD response')
+    // A HEAD response has no body, so check the headers set by the custom HEAD handler
+    t.assert.strictEqual(res.headers['content-type'], 'text/plain')
+    t.assert.strictEqual(res.headers['content-length'], String(Buffer.byteLength('custom HEAD response')))
     t.assert.strictEqual(res.statusCode, 200)
     done()
   })

package/test/content-parser.test.js

@@ -827,3 +827,42 @@ test('string body with invalid UTF-8 is not treated as a content-length mismatch
   t.assert.strictEqual(res.statusCode, 200)
   t.assert.strictEqual(res.body, 'a�b')
 })
+
+test('a synchronous throw in a custom parser is handled like a route error, not an uncaught exception', async t => {
+  await t.test('stream-mode parser', async t => {
+    t.plan(2)
+    const fastify = Fastify()
+    fastify.addContentTypeParser('application/json', function (req, payload, done) {
+      throw new Error('parser boom')
+    })
+    fastify.post('/', (req, reply) => reply.send('ok'))
+    const res = await fastify.inject({ method: 'POST', url: '/', headers: { 'content-type': 'application/json' }, payload: '{}' })
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(res.json().message, 'parser boom')
+  })
+
+  await t.test('parseAs string parser', async t => {
+    t.plan(2)
+    const fastify = Fastify()
+    fastify.addContentTypeParser('application/json', { parseAs: 'string' }, function (req, body, done) {
+      throw new Error('parser boom')
+    })
+    fastify.post('/', (req, reply) => reply.send('ok'))
+    const res = await fastify.inject({ method: 'POST', url: '/', headers: { 'content-type': 'application/json' }, payload: '{}' })
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(res.json().message, 'parser boom')
+  })
+
+  await t.test('a thrown error with a statusCode is preserved', async t => {
+    t.plan(1)
+    const fastify = Fastify()
+    fastify.addContentTypeParser('application/json', { parseAs: 'string' }, function (req, body, done) {
+      const err = new Error('too big')
+      err.statusCode = 413
+      throw err
+    })
+    fastify.post('/', (req, reply) => reply.send('ok'))
+    const res = await fastify.inject({ method: 'POST', url: '/', headers: { 'content-type': 'application/json' }, payload: '{}' })
+    t.assert.strictEqual(res.statusCode, 413)
+  })
+})

package/test/decorator.test.js

@@ -1328,3 +1328,32 @@ test('Request.setDecorator should update an existing decorator', (t, done) => {
     })
   })
 })
+
+test('getDecorator should evaluate a getter once', async t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  let calls = 0
+  fastify.decorate('value', {
+    getter () {
+      return ++calls
+    }
+  })
+
+  t.assert.strictEqual(fastify.getDecorator('value'), 1)
+  t.assert.strictEqual(calls, 1)
+})
+
+test('getDecorator should bind the function returned by a getter once', async t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  let calls = 0
+  fastify.decorate('method', {
+    getter () {
+      calls++
+      return function () { return this }
+    }
+  })
+
+  t.assert.strictEqual(fastify.getDecorator('method')(), fastify)
+  t.assert.strictEqual(calls, 1)
+})

package/test/diagnostics-channel/error-status.test.js

@@ -96,9 +96,12 @@ test('Error.status property support', (t, done) => {
   const err = new Error('winter is coming')
   err.status = 418
 
-  diagnostics.subscribe('tracing:fastify.request.handler:error', (msg) => {
+  const channel = diagnostics.channel('tracing:fastify.request.handler:error')
+  const handler = (msg) => {
     t.assert.strictEqual(msg.error.message, 'winter is coming')
-  })
+  }
+  channel.subscribe(handler)
+  t.after(() => channel.unsubscribe(handler))
 
   fastify.get('/', () => {
     return Promise.reject(err)
@@ -121,3 +124,33 @@ test('Error.status property support', (t, done) => {
     done()
   })
 })
+
+test('diagnostics channel error event should report 500 for error with statusCode >= 600', async (t) => {
+  t.plan(4)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  let diagnosticsStatusCode
+  let diagnosticsError
+
+  const channel = diagnostics.channel('tracing:fastify.request.handler:error')
+  const handler = (msg) => {
+    diagnosticsStatusCode = msg.reply.statusCode
+    diagnosticsError = msg.error
+  }
+  channel.subscribe(handler)
+  t.after(() => channel.unsubscribe(handler))
+
+  fastify.get('/', async () => {
+    const err = new Error('custom invalid status')
+    err.statusCode = 600
+    throw err
+  })
+
+  const res = await fastify.inject('/')
+
+  t.assert.strictEqual(res.statusCode, 500)
+  t.assert.strictEqual(diagnosticsStatusCode, 500, 'diagnostics channel should report 500 when statusCode >= 600')
+  t.assert.strictEqual(diagnosticsStatusCode, res.statusCode, 'diagnostics status should match response status')
+  t.assert.strictEqual(diagnosticsError.message, 'custom invalid status')
+})