fastify 5.4.0 → 5.5.0

package/test/input-validation.js

@@ -1,6 +1,5 @@
 'use strict'
 
-const sget = require('simple-get').concat
 const Ajv = require('ajv')
 const Joi = require('joi')
 const yup = require('yup')
@@ -139,207 +138,197 @@ module.exports.payloadMethod = function (method, t) {
 
     t.after(() => { fastify.close() })
 
-    test(`${upMethod} - correctly replies`, (t, testDone) => {
+    test(`${upMethod} - correctly replies`, async (t) => {
       if (upMethod === 'HEAD') {
         t.plan(2)
-        sget({
-          method: upMethod,
-          url: 'http://localhost:' + fastify.server.address().port
-        }, (err, response) => {
-          t.assert.ifError(err)
-          t.assert.strictEqual(response.statusCode, 200)
-          testDone()
+        const result = await fetch('http://localhost:' + fastify.server.address().port, {
+          method: upMethod
         })
+        t.assert.ok(result.ok)
+        t.assert.strictEqual(result.status, 200)
       } else {
         t.plan(3)
-        sget({
+
+        const result = await fetch('http://localhost:' + fastify.server.address().port, {
           method: upMethod,
-          url: 'http://localhost:' + fastify.server.address().port,
-          body: {
-            hello: 42
-          },
-          json: true
-        }, (err, response, body) => {
-          t.assert.ifError(err)
-          t.assert.strictEqual(response.statusCode, 200)
-          t.assert.deepStrictEqual(body, { hello: 42 })
-          testDone()
+          body: JSON.stringify({ hello: 42 }),
+          headers: {
+            'Content-Type': 'application/json'
+          }
         })
+
+        t.assert.ok(result.ok)
+        t.assert.strictEqual(result.status, 200)
+        t.assert.deepStrictEqual(await result.json(), { hello: 42 })
       }
     })
 
-    test(`${upMethod} - 400 on bad parameters`, (t, testDone) => {
+    test(`${upMethod} - 400 on bad parameters`, async (t) => {
       t.plan(3)
-      sget({
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port, {
         method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port,
-        body: {
-          hello: 'world'
-        },
-        json: true
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 400)
-        t.assert.deepStrictEqual(body, {
-          error: 'Bad Request',
-          message: 'body/hello must be integer',
-          statusCode: 400,
-          code: 'FST_ERR_VALIDATION'
-        })
-        testDone()
+        body: JSON.stringify({ hello: 'world' }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+
+      t.assert.ok(!result.ok)
+      t.assert.strictEqual(result.status, 400)
+      t.assert.deepStrictEqual(await result.json(), {
+        error: 'Bad Request',
+        message: 'body/hello must be integer',
+        statusCode: 400,
+        code: 'FST_ERR_VALIDATION'
       })
     })
 
-    test(`${upMethod} - input-validation coerce`, (t, testDone) => {
+    test(`${upMethod} - input-validation coerce`, async (t) => {
       t.plan(3)
-      sget({
+
+      const restult = await fetch('http://localhost:' + fastify.server.address().port, {
         method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port,
-        body: {
-          hello: '42'
-        },
-        json: true
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(body, { hello: 42 })
-        testDone()
+        body: JSON.stringify({ hello: '42' }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
       })
+
+      t.assert.ok(restult.ok)
+      t.assert.strictEqual(restult.status, 200)
+      t.assert.deepStrictEqual(await restult.json(), { hello: 42 })
     })
 
-    test(`${upMethod} - input-validation custom schema compiler`, (t, testDone) => {
+    test(`${upMethod} - input-validation custom schema compiler`, async (t) => {
       t.plan(3)
-      sget({
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/custom', {
         method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port + '/custom',
-        body: {
-          hello: '42',
-          world: 55
-        },
-        json: true
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(body, { hello: 42 })
-        testDone()
+        body: JSON.stringify({ hello: '42', world: 55 }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
       })
+
+      t.assert.ok(result.ok)
+      t.assert.strictEqual(result.status, 200)
+      t.assert.deepStrictEqual(await result.json(), { hello: 42 })
     })
 
-    test(`${upMethod} - input-validation joi schema compiler ok`, (t, testDone) => {
+    test(`${upMethod} - input-validation joi schema compiler ok`, async (t) => {
       t.plan(3)
-      sget({
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/joi', {
         method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port + '/joi',
-        body: {
-          hello: '42'
-        },
-        json: true
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(body, { hello: '42' })
-        testDone()
+        body: JSON.stringify({ hello: '42' }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
       })
+
+      t.assert.ok(result.ok)
+      t.assert.strictEqual(result.status, 200)
+      t.assert.deepStrictEqual(await result.json(), { hello: '42' })
     })
 
-    test(`${upMethod} - input-validation joi schema compiler ko`, (t, testDone) => {
+    test(`${upMethod} - input-validation joi schema compiler ko`, async (t) => {
       t.plan(3)
-      sget({
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/joi', {
         method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port + '/joi',
-        body: {
-          hello: 44
-        },
-        json: true
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 400)
-        t.assert.deepStrictEqual(body, {
-          error: 'Bad Request',
-          message: '"hello" must be a string',
-          statusCode: 400,
-          code: 'FST_ERR_VALIDATION'
-        })
-        testDone()
+        body: JSON.stringify({ hello: 44 }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+
+      t.assert.ok(!result.ok)
+      t.assert.strictEqual(result.status, 400)
+      t.assert.deepStrictEqual(await result.json(), {
+        error: 'Bad Request',
+        message: '"hello" must be a string',
+        statusCode: 400,
+        code: 'FST_ERR_VALIDATION'
       })
     })
 
-    test(`${upMethod} - input-validation yup schema compiler ok`, (t, testDone) => {
+    test(`${upMethod} - input-validation yup schema compiler ok`, async (t) => {
       t.plan(3)
-      sget({
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/yup', {
         method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port + '/yup',
-        body: {
-          hello: '42'
-        },
-        json: true
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(body, { hello: '42' })
-        testDone()
+        body: JSON.stringify({ hello: '42' }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
       })
+
+      t.assert.ok(result.ok)
+      t.assert.strictEqual(result.status, 200)
+      t.assert.deepStrictEqual(await result.json(), { hello: '42' })
     })
 
-    test(`${upMethod} - input-validation yup schema compiler ko`, (t, testDone) => {
+    test(`${upMethod} - input-validation yup schema compiler ko`, async (t) => {
       t.plan(3)
-      sget({
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/yup', {
         method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port + '/yup',
-        body: {
-          hello: 44
-        },
-        json: true
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 400)
-        t.assert.deepStrictEqual(body, {
-          error: 'Bad Request',
-          message: 'body hello must be a `string` type, but the final value was: `44`.',
-          statusCode: 400,
-          code: 'FST_ERR_VALIDATION'
-        })
-        testDone()
+        body: JSON.stringify({ hello: 44 }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+
+      t.assert.ok(!result.ok)
+      t.assert.strictEqual(result.status, 400)
+      t.assert.deepStrictEqual(await result.json(), {
+        error: 'Bad Request',
+        message: 'body hello must be a `string` type, but the final value was: `44`.',
+        statusCode: 400,
+        code: 'FST_ERR_VALIDATION'
       })
     })
 
-    test(`${upMethod} - input-validation instance custom schema compiler encapsulated`, (t, testDone) => {
+    test(`${upMethod} - input-validation instance custom schema compiler encapsulated`, async (t) => {
       t.plan(3)
-      sget({
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/plugin', {
         method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port + '/plugin',
-        body: {},
-        json: true
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 400)
-        t.assert.deepStrictEqual(body, {
-          error: 'Bad Request',
-          message: 'From custom schema compiler!',
-          statusCode: 400,
-          code: 'FST_ERR_VALIDATION'
-        })
-        testDone()
+        body: JSON.stringify({}),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+
+      t.assert.ok(!result.ok)
+      t.assert.strictEqual(result.status, 400)
+      t.assert.deepStrictEqual(await result.json(), {
+        error: 'Bad Request',
+        message: 'From custom schema compiler!',
+        statusCode: 400,
+        code: 'FST_ERR_VALIDATION'
       })
     })
 
-    test(`${upMethod} - input-validation custom schema compiler encapsulated`, (t, testDone) => {
+    test(`${upMethod} - input-validation custom schema compiler encapsulated`, async (t) => {
       t.plan(3)
-      sget({
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/plugin/custom', {
         method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port + '/plugin/custom',
-        body: {},
-        json: true
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 400)
-        t.assert.deepStrictEqual(body, {
-          error: 'Bad Request',
-          message: 'Always fail!',
-          statusCode: 400,
-          code: 'FST_ERR_VALIDATION'
-        })
-        testDone()
+        body: JSON.stringify({}),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+
+      t.assert.ok(!result.ok)
+      t.assert.strictEqual(result.status, 400)
+      t.assert.deepStrictEqual(await result.json(), {
+        error: 'Bad Request',
+        message: 'Always fail!',
+        statusCode: 400,
+        code: 'FST_ERR_VALIDATION'
       })
     })
   })

package/test/internals/errors.test.js

@@ -5,7 +5,7 @@ const errors = require('../../lib/errors')
 const { readFileSync } = require('node:fs')
 const { resolve } = require('node:path')
 
-const expectedErrors = 85
+const expectedErrors = 86
 
 test(`should expose ${expectedErrors} errors`, t => {
   t.plan(1)
@@ -190,6 +190,16 @@ test('FST_ERR_CTP_EMPTY_JSON_BODY', t => {
   t.assert.ok(error instanceof Error)
 })
 
+test('FST_ERR_CTP_INVALID_JSON_BODY', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_CTP_INVALID_JSON_BODY()
+  t.assert.strictEqual(error.name, 'FastifyError')
+  t.assert.strictEqual(error.code, 'FST_ERR_CTP_INVALID_JSON_BODY')
+  t.assert.strictEqual(error.message, "Body is not valid JSON but content-type is set to 'application/json'")
+  t.assert.strictEqual(error.statusCode, 400)
+  t.assert.ok(error instanceof Error)
+})
+
 test('FST_ERR_CTP_INSTANCE_ALREADY_STARTED', t => {
   t.plan(5)
   const error = new errors.FST_ERR_CTP_INSTANCE_ALREADY_STARTED()
@@ -931,3 +941,42 @@ test('Ensure that non-existing errors are not in Errors.md documented', t => {
     t.assert.ok(exportedKeys.indexOf(match[1]) !== -1, match[1])
   }
 })
+
+test('Ensure that all errors are in errors.d.ts', t => {
+  t.plan(expectedErrors)
+
+  const errorsDts = readFileSync(resolve(__dirname, '../../types/errors.d.ts'), 'utf8')
+
+  const FastifyErrorCodesRE = /export type FastifyErrorCodes = Record<([^>]+),\s*FastifyErrorConstructor>/m
+
+  const [, errorCodeType] = errorsDts.match(FastifyErrorCodesRE)
+
+  const errorCodeRE = /'([A-Z0-9_]+)'/g
+  const matches = errorCodeType.matchAll(errorCodeRE)
+  const errorTypes = [...matches].map(match => match[1])
+  const exportedKeys = Object.keys(errors)
+
+  for (const key of exportedKeys) {
+    if (errors[key].name === 'FastifyError') {
+      t.assert.ok(errorTypes.includes(key), key)
+    }
+  }
+})
+
+test('Ensure that non-existing errors are not in errors.d.ts', t => {
+  t.plan(expectedErrors)
+
+  const errorsDts = readFileSync(resolve(__dirname, '../../types/errors.d.ts'), 'utf8')
+
+  const FastifyErrorCodesRE = /export type FastifyErrorCodes = Record<([^>]+),\s*FastifyErrorConstructor>/m
+
+  const [, errorCodeType] = errorsDts.match(FastifyErrorCodesRE)
+
+  const errorCodeRE = /'([A-Z0-9_]+)'/g
+  const matches = errorCodeType.matchAll(errorCodeRE)
+  const exportedKeys = Object.keys(errors)
+
+  for (const match of matches) {
+    t.assert.ok(exportedKeys.indexOf(match[1]) !== -1, match[1])
+  }
+})

package/test/internals/handle-request.test.js

@@ -191,7 +191,7 @@ test('request should be defined in onSend Hook on post request with content type
 })
 
 test('request should be defined in onSend Hook on options request with content type application/x-www-form-urlencoded', async t => {
-  t.plan(5)
+  t.plan(15)
   const fastify = require('../..')()
 
   t.after(() => {
@@ -209,16 +209,40 @@ test('request should be defined in onSend Hook on options request with content t
     reply.send(200)
   })
 
-  const fastifyServer = await fastify.listen({ port: 0 })
-  const result = await fetch(fastifyServer, {
+  // Test 1: OPTIONS with body and content-type header
+  const result1 = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    body: 'first-name=OPTIONS&last-name=METHOD',
+    headers: {
+      'content-type': 'application/x-www-form-urlencoded'
+    }
+  })
+
+  // Content-Type is not supported
+  t.assert.strictEqual(result1.statusCode, 415)
+
+  // Test 2: OPTIONS with content-type header only (no body)
+  const result2 = await fastify.inject({
     method: 'OPTIONS',
+    url: '/',
     headers: {
       'content-type': 'application/x-www-form-urlencoded'
     }
   })
 
-  // Body parsing skipped, so no body sent
-  t.assert.strictEqual(result.status, 200)
+  // Content-Type is not supported
+  t.assert.strictEqual(result2.statusCode, 415)
+
+  // Test 3: OPTIONS with body but no content-type header
+  const result3 = await fastify.inject({
+    method: 'OPTIONS',
+    url: '/',
+    body: 'first-name=OPTIONS&last-name=METHOD'
+  })
+
+  // No content-type with payload
+  t.assert.strictEqual(result3.statusCode, 415)
 })
 
 test('request should respond with an error if an unserialized payload is sent inside an async handler', async t => {

package/test/internals/promise.test.js

@@ -0,0 +1,63 @@
+'use strict'
+
+const { test } = require('node:test')
+
+const { kTestInternals } = require('../../lib/symbols')
+const PonyPromise = require('../../lib/promise')
+
+test('withResolvers', async (t) => {
+  t.plan(3)
+  await t.test('resolve', async (t) => {
+    t.plan(1)
+    const { promise, resolve } = PonyPromise.withResolvers()
+    resolve(true)
+    t.assert.ok(await promise)
+  })
+  await t.test('reject', async (t) => {
+    t.plan(1)
+    const { promise, reject } = PonyPromise.withResolvers()
+    await t.assert.rejects(async () => {
+      reject(Error('reject'))
+      return promise
+    }, {
+      name: 'Error',
+      message: 'reject'
+    })
+  })
+  await t.test('thenable', async (t) => {
+    t.plan(1)
+    const { promise, resolve } = PonyPromise.withResolvers()
+    resolve(true)
+    promise.then((value) => {
+      t.assert.ok(value)
+    })
+  })
+})
+
+test('withResolvers - ponyfill', async (t) => {
+  await t.test('resolve', async (t) => {
+    t.plan(1)
+    const { promise, resolve } = PonyPromise[kTestInternals].withResolvers()
+    resolve(true)
+    t.assert.ok(await promise)
+  })
+  await t.test('reject', async (t) => {
+    t.plan(1)
+    const { promise, reject } = PonyPromise[kTestInternals].withResolvers()
+    await t.assert.rejects(async () => {
+      reject(Error('reject'))
+      return promise
+    }, {
+      name: 'Error',
+      message: 'reject'
+    })
+  })
+  await t.test('thenable', async (t) => {
+    t.plan(1)
+    const { promise, resolve } = PonyPromise.withResolvers()
+    resolve(true)
+    promise.then((value) => {
+      t.assert.ok(value)
+    })
+  })
+})