fastify 4.23.2 → 4.24.0

package/test/constrained-routes.test.js

@@ -256,6 +256,91 @@ test('Should allow registering custom constrained routes outside constructor', t
   })
 })
 
+test('Custom constrained routes registered also for HEAD method generated by fastify', t => {
+  t.plan(3)
+
+  const constraint = {
+    name: 'secret',
+    storage: function () {
+      const secrets = {}
+      return {
+        get: (secret) => { return secrets[secret] || null },
+        set: (secret, store) => { secrets[secret] = store }
+      }
+    },
+    deriveConstraint: (req, ctx) => {
+      return req.headers['x-secret']
+    },
+    validate () { return true }
+  }
+
+  const fastify = Fastify({ constraints: { secret: constraint } })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { secret: 'mySecret' },
+    handler: (req, reply) => {
+      reply.send('from mySecret - my length is 31')
+    }
+  })
+
+  fastify.inject({
+    method: 'HEAD',
+    url: '/',
+    headers: {
+      'X-Secret': 'mySecret'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.headers['content-length'], '31')
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Custom constrained routes registered with addConstraintStrategy apply also for HEAD method generated by fastify', t => {
+  t.plan(3)
+
+  const constraint = {
+    name: 'secret',
+    storage: function () {
+      const secrets = {}
+      return {
+        get: (secret) => { return secrets[secret] || null },
+        set: (secret, store) => { secrets[secret] = store }
+      }
+    },
+    deriveConstraint: (req, ctx) => {
+      return req.headers['x-secret']
+    },
+    validate () { return true }
+  }
+
+  const fastify = Fastify()
+  fastify.addConstraintStrategy(constraint)
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { secret: 'mySecret' },
+    handler: (req, reply) => {
+      reply.send('from mySecret - my length is 31')
+    }
+  })
+
+  fastify.inject({
+    method: 'HEAD',
+    url: '/',
+    headers: {
+      'X-Secret': 'mySecret'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.headers['content-length'], '31')
+    t.equal(res.statusCode, 200)
+  })
+})
+
 test('Add a constraint strategy after fastify instance was started', t => {
   t.plan(4)
 
@@ -561,7 +646,7 @@ test('Should allow registering a constrained GET route after an unconstrained HE
     url: '/',
     handler: (req, reply) => {
       reply.header('content-type', 'text/plain')
-      reply.send('custom HEAD response')
+      reply.send('HEAD response: length is about 33')
     }
   })
 
@@ -570,7 +655,8 @@ test('Should allow registering a constrained GET route after an unconstrained HE
     url: '/',
     constraints: { host: 'fastify.io' },
     handler: (req, reply) => {
-      reply.send({ hello: 'from any other domain' })
+      reply.header('content-type', 'text/plain')
+      reply.send('Hello from constrains: length is about 41')
     }
   })
 
@@ -582,7 +668,7 @@ test('Should allow registering a constrained GET route after an unconstrained HE
     }
   }, (err, res) => {
     t.error(err)
-    t.same(res.payload, 'custom HEAD response')
+    t.same(res.headers['content-length'], '41')
     t.equal(res.statusCode, 200)
   })
 })
@@ -774,3 +860,41 @@ test('error in async constraints', async (t) => {
     t.equal(statusCode, 500)
   }
 })
+
+test('Allow regex constraints in routes', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { host: /.*\.fastify\.io/ },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from fastify dev domain' })
+    }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      host: 'dev.fastify.io'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'from fastify dev domain' })
+    t.equal(res.statusCode, 200)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      host: 'google.com'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 404)
+  })
+})

package/test/hooks-async.test.js

@@ -745,8 +745,8 @@ test('Should log a warning if is an async function with `done`', t => {
     try {
       fastify.addHook('onRequestAbort', async (req, done) => {})
     } catch (e) {
-      t.ok(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
-      t.ok(e.message === 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+      t.equal(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+      t.equal(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
     }
   })
 
@@ -757,8 +757,8 @@ test('Should log a warning if is an async function with `done`', t => {
     try {
       fastify.addHook('onRequest', async (req, reply, done) => {})
     } catch (e) {
-      t.ok(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
-      t.ok(e.message === 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+      t.equal(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+      t.equal(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
     }
   })
 
@@ -769,20 +769,20 @@ test('Should log a warning if is an async function with `done`', t => {
     try {
       fastify.addHook('onSend', async (req, reply, payload, done) => {})
     } catch (e) {
-      t.ok(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
-      t.ok(e.message === 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+      t.equal(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+      t.equal(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
     }
     try {
       fastify.addHook('preSerialization', async (req, reply, payload, done) => {})
     } catch (e) {
-      t.ok(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
-      t.ok(e.message === 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+      t.equal(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+      t.equal(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
     }
     try {
       fastify.addHook('onError', async (req, reply, payload, done) => {})
     } catch (e) {
-      t.ok(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
-      t.ok(e.message === 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+      t.equal(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+      t.equal(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
     }
   })
 
@@ -923,3 +923,153 @@ t.test('nested hooks to do not crash on 404', t => {
     t.equal(res.statusCode, 404)
   })
 })
+
+test('Register an hook (preHandler) as route option should fail if mixing async and callback style', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  try {
+    fastify.get(
+      '/',
+      {
+        preHandler: [
+          async (request, reply, done) => {
+            done()
+          }
+        ]
+      },
+      async (request, reply) => {
+        return { hello: 'world' }
+      }
+    )
+    t.fail('preHandler mixing async and callback style')
+  } catch (e) {
+    t.equal(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+    t.equal(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+  }
+})
+
+test('Register an hook (onSend) as route option should fail if mixing async and callback style', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  try {
+    fastify.get(
+      '/',
+      {
+        onSend: [
+          async (request, reply, payload, done) => {
+            done()
+          }
+        ]
+      },
+      async (request, reply) => {
+        return { hello: 'world' }
+      }
+    )
+    t.fail('onSend mixing async and callback style')
+  } catch (e) {
+    t.equal(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+    t.equal(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+  }
+})
+
+test('Register an hook (preSerialization) as route option should fail if mixing async and callback style', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  try {
+    fastify.get(
+      '/',
+      {
+        preSerialization: [
+          async (request, reply, payload, done) => {
+            done()
+          }
+        ]
+      },
+      async (request, reply) => {
+        return { hello: 'world' }
+      }
+    )
+    t.fail('preSerialization mixing async and callback style')
+  } catch (e) {
+    t.equal(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+    t.equal(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+  }
+})
+
+test('Register an hook (onError) as route option should fail if mixing async and callback style', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  try {
+    fastify.get(
+      '/',
+      {
+        onError: [
+          async (request, reply, error, done) => {
+            done()
+          }
+        ]
+      },
+      async (request, reply) => {
+        return { hello: 'world' }
+      }
+    )
+    t.fail('onError mixing async and callback style')
+  } catch (e) {
+    t.equal(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+    t.equal(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+  }
+})
+
+test('Register an hook (preParsing) as route option should fail if mixing async and callback style', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  try {
+    fastify.get(
+      '/',
+      {
+        preParsing: [
+          async (request, reply, payload, done) => {
+            done()
+          }
+        ]
+      },
+      async (request, reply) => {
+        return { hello: 'world' }
+      }
+    )
+    t.fail('preParsing mixing async and callback style')
+  } catch (e) {
+    t.equal(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+    t.equal(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+  }
+})
+
+test('Register an hook (onRequestAbort) as route option should fail if mixing async and callback style', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  try {
+    fastify.get(
+      '/',
+      {
+        onRequestAbort: [
+          async (request, done) => {
+            done()
+          }
+        ]
+      },
+      async (request, reply) => {
+        return { hello: 'world' }
+      }
+    )
+    t.fail('onRequestAbort mixing async and callback style')
+  } catch (e) {
+    t.equal(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+    t.equal(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+  }
+})

package/test/input-validation.js

@@ -72,7 +72,7 @@ module.exports.payloadMethod = function (method, t) {
           const result = schema.validateSync(data, yupOptions)
           return { value: result }
         } catch (e) {
-          return { error: e }
+          return { error: [e] }
         }
       }
     }
@@ -286,9 +286,9 @@ module.exports.payloadMethod = function (method, t) {
       }, (err, response, body) => {
         t.error(err)
         t.equal(response.statusCode, 400)
-        t.same(body, {
+        t.match(body, {
           error: 'Bad Request',
-          message: 'hello must be a `string` type, but the final value was: `44`.',
+          message: /body hello must be a `string` type, but the final value was: `44`./,
           statusCode: 400,
           code: 'FST_ERR_VALIDATION'
         })

package/test/internals/reply.test.js

@@ -14,7 +14,8 @@ const {
   kReplySerializer,
   kReplyIsError,
   kReplySerializerDefault,
-  kRouteContext
+  kRouteContext,
+  kPublicRouteContext
 } = require('../../lib/symbols')
 const fs = require('node:fs')
 const path = require('node:path')
@@ -35,10 +36,10 @@ const doGet = function (url) {
 }
 
 test('Once called, Reply should return an object with methods', t => {
-  t.plan(14)
+  t.plan(16)
   const response = { res: 'res' }
-  const context = {}
-  const request = { [kRouteContext]: context }
+  const context = { config: { onSend: [] }, schema: {} }
+  const request = { [kRouteContext]: context, [kPublicRouteContext]: { config: context.config, schema: context.schema } }
   const reply = new Reply(response, request)
   t.equal(typeof reply, 'object')
   t.equal(typeof reply[kReplyIsError], 'boolean')
@@ -52,6 +53,8 @@ test('Once called, Reply should return an object with methods', t => {
   t.equal(typeof reply[kReplyHeaders], 'object')
   t.same(reply.raw, response)
   t.equal(reply[kRouteContext], context)
+  t.equal(reply[kPublicRouteContext].config, context.config)
+  t.equal(reply[kPublicRouteContext].schema, context.schema)
   t.equal(reply.request, request)
   // Aim to not bad property keys (including Symbols)
   t.notOk('undefined' in reply)
@@ -1487,6 +1490,32 @@ test('should emit deprecation warning when trying to modify the reply.sent prope
   })
 })
 
+test('should emit deprecation warning when trying to use the reply.context.config property', t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  const deprecationCode = 'FSTDEP019'
+  warning.emitted.delete(deprecationCode)
+
+  process.removeAllListeners('warning')
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'FastifyDeprecation')
+    t.equal(warning.code, deprecationCode)
+  }
+
+  fastify.get('/', (req, reply) => {
+    req.log(reply.context.config)
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.error(err)
+    t.pass()
+
+    process.removeListener('warning', onWarning)
+  })
+})
+
 test('should throw error when passing falsy value to reply.sent', t => {
   t.plan(4)
   const fastify = Fastify()