fastify 5.6.0 → 5.6.2

package/test/types/schema.test-d.ts

@@ -72,6 +72,27 @@ expectAssignable<FastifyInstance>(server.post('/test', {
   }
 }, async req => req.body))
 
+expectAssignable<FastifyInstance>(server.post('/test', {
+  validatorCompiler: ({ schema }) => {
+    return data => {
+      if (!data || data.constructor !== Object) {
+        return {
+          error: [
+            {
+              keyword: 'type',
+              instancePath: '',
+              schemaPath: '#/type',
+              params: { type: 'object' },
+              message: 'value is not an object'
+            }
+          ]
+        }
+      }
+      return { value: data }
+    }
+  }
+}, async req => req.body))
+
 expectAssignable<FastifyInstance>(server.setValidatorCompiler<FastifySchema & { validate: Record<string, unknown> }>(
   function ({ schema }) {
     return new Ajv().compile(schema)

package/test/validation-error-handling.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('node:test')
+const { describe, test } = require('node:test')
 const Joi = require('joi')
 const Fastify = require('..')
 
@@ -831,3 +831,70 @@ test('plugin override', async (t) => {
   })
   t.assert.strictEqual(response5.statusCode, 400)
 })
+
+describe('sync and async must work in the same way', () => {
+  // Route with custom validator that throws
+  const throwingRouteValidator = {
+    schema: {
+      body: {
+        type: 'object',
+        properties: { name: { type: 'string' } }
+      }
+    },
+    validatorCompiler: () => {
+      return function (inputData) {
+        // This custom validator throws a sync error instead of returning `{ error }`
+        throw new Error('Custom validation failed')
+      }
+    },
+    handler (request, reply) { reply.send({ success: true }) }
+  }
+
+  test('async preValidation with custom validator should trigger error handler when validator throws', async (t) => {
+    t.plan(4)
+
+    const fastify = Fastify()
+    fastify.setErrorHandler((error, request, reply) => {
+      t.assert.ok(error instanceof Error, 'error should be an Error instance')
+      t.assert.strictEqual(error.message, 'Custom validation failed')
+      reply.status(500).send({ error: error.message })
+    })
+
+    // Add async preValidation hook
+    fastify.addHook('preValidation', async (request, reply) => {
+      await Promise.resolve('ok')
+    })
+    fastify.post('/async', throwingRouteValidator)
+
+    const response = await fastify.inject({
+      method: 'POST',
+      url: '/async',
+      payload: { name: 'test' }
+    })
+    t.assert.strictEqual(response.statusCode, 500)
+    t.assert.deepStrictEqual(response.json(), { error: 'Custom validation failed' })
+  })
+
+  test('sync preValidation with custom validator should trigger error handler when validator throws', async (t) => {
+    t.plan(4)
+
+    const fastify = Fastify()
+    fastify.setErrorHandler((error, request, reply) => {
+      t.assert.ok(error instanceof Error, 'error should be an Error instance')
+      t.assert.strictEqual(error.message, 'Custom validation failed')
+      reply.status(500).send({ error: error.message })
+    })
+
+    // Add sync preValidation hook
+    fastify.addHook('preValidation', (request, reply, next) => { next() })
+    fastify.post('/sync', throwingRouteValidator)
+
+    const response = await fastify.inject({
+      method: 'POST',
+      url: '/sync',
+      payload: { name: 'test' }
+    })
+    t.assert.strictEqual(response.statusCode, 500)
+    t.assert.deepStrictEqual(response.json(), { error: 'Custom validation failed' })
+  })
+})

package/test/wrap-thenable.test.js

@@ -2,7 +2,7 @@
 
 const { test } = require('node:test')
 const { kReplyHijacked } = require('../lib/symbols')
-const wrapThenable = require('../lib/wrapThenable')
+const wrapThenable = require('../lib/wrap-thenable')
 const Reply = require('../lib/reply')
 
 test('should resolve immediately when reply[kReplyHijacked] is true', async t => {

package/types/instance.d.ts

@@ -464,12 +464,12 @@ export interface FastifyInstance<
   /**
    * Fastify default error handler
    */
-  errorHandler: (error: FastifyError, request: FastifyRequest, reply: FastifyReply) => void;
+  errorHandler: <TError = unknown>(error: TError, request: FastifyRequest, reply: FastifyReply) => void;
 
   /**
    * Set a function that will be invoked whenever an exception is thrown during the request lifecycle.
    */
-  setErrorHandler<TError extends Error = FastifyError, RouteGeneric extends RouteGenericInterface = RouteGenericInterface, SchemaCompiler extends FastifySchema = FastifySchema, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault>(
+  setErrorHandler<TError = unknown, RouteGeneric extends RouteGenericInterface = RouteGenericInterface, SchemaCompiler extends FastifySchema = FastifySchema, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault>(
     handler: (this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>, error: TError, request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>, reply: FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfigDefault, SchemaCompiler, TypeProvider>) => any | Promise<any>
   ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
 

package/types/schema.d.ts

@@ -33,7 +33,7 @@ export interface FastifySchemaValidationError {
 }
 
 export interface FastifyValidationResult {
-  (data: any): boolean | SafePromiseLike<any> | { error?: Error, value?: any }
+  (data: any): boolean | SafePromiseLike<any> | { error?: Error | FastifySchemaValidationError[], value?: any }
   errors?: FastifySchemaValidationError[] | null;
 }
 

package/test/check.test.js

@@ -1,219 +0,0 @@
-'use strict'
-
-const { test } = require('node:test')
-const { S } = require('fluent-json-schema')
-const Fastify = require('..')
-
-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) => {
-  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', async t => {
-  const fastify = Fastify({})
-
-  t.after(() => fastify.close())
-
-  fastify.post('/', options, handler)
-
-  const fastifyServer = await fastify.listen({ port: 0 })
-
-  const result = await fetch(fastifyServer, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json'
-    },
-    body: '12'
-  })
-
-  t.assert.ok(!result.ok)
-  t.assert.strictEqual(result.status, 400)
-  t.assert.deepStrictEqual(await result.json(), {
-    statusCode: 400,
-    error: 'Bad Request',
-    message: 'body must be object'
-  })
-})
-
-// 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()
-//     })
-//   })
-// })