fix: run zod schema before ajv

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/http",
-  "version": "5.56.0",
+  "version": "5.57.0",
   "description": "The Athenna Http server. Built on top of fastify.",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",

src/router/Route.ts

@@ -352,7 +352,7 @@ export class Route extends Macroable {
       // @ts-ignore
       this.route.fastify.config.zod = zod
 
-      if (Object.keys(zod.response).length) {
+      if (Object.keys(swaggerSchema).length) {
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
         this.route.fastify.config.swaggerSchema = swaggerSchema

src/router/RouteSchema.ts

@@ -49,8 +49,9 @@ export function normalizeRouteSchema(options: RouteSchemaOptions): {
     }
 
     request[key] = options[key]
-    schema[key] = toJsonSchema(options[key], 'input')
     swaggerSchema[key] = toJsonSchema(options[key], 'input')
+
+    delete schema[key]
   })
 
   if (options.response && Is.Object(options.response)) {

tests/unit/router/RouteTest.ts

@@ -11,7 +11,7 @@ import { Config } from '@athenna/config'
 import { MyMiddleware } from '#tests/fixtures/middlewares/MyMiddleware'
 import { Test, AfterEach, BeforeEach, type Context, Cleanup } from '@athenna/test'
 import { HelloController } from '#tests/fixtures/controllers/HelloController'
-import { Route, Server, HttpRouteProvider, HttpServerProvider } from '#src'
+import { Route, Server, HttpKernel, HttpRouteProvider, HttpServerProvider } from '#src'
 import { z } from 'zod'
 
 export default class RouteTest {
@@ -369,6 +369,53 @@ export default class RouteTest {
     })
   }
 
+  @Test()
+  @Cleanup(() => Config.set('openapi.paths', {}))
+  @Cleanup(() => Config.set('http.logger.ignoreStatuses', []))
+  public async shouldUseZodValidationErrorsForInvalidOpenApiRequestSchemas({ assert }: Context) {
+    Config.set('http.logger.ignoreStatuses', [422])
+
+    const kernel = new HttpKernel()
+    await kernel.registerExceptionHandler()
+
+    Config.set('openapi.paths', {
+      '/avatars': {
+        post: {
+          body: z.object({
+            name: z.string(),
+            siteId: z.string(),
+            slug: z.string()
+          })
+        }
+      }
+    })
+
+    Route.post('avatars', async ctx => {
+      await ctx.response.status(201).send({ ok: true })
+    })
+
+    Route.register()
+
+    const response = await Server.request({
+      path: '/avatars',
+      method: 'post',
+      payload: {}
+    })
+
+    const body = response.json()
+
+    assert.equal(response.statusCode, 422)
+    assert.equal(body.code, 'E_VALIDATION_ERROR')
+    assert.deepEqual(
+      body.details.map(({ expected, code, path }) => ({ expected, code, path })),
+      [
+        { expected: 'string', code: 'invalid_type', path: ['name'] },
+        { expected: 'string', code: 'invalid_type', path: ['siteId'] },
+        { expected: 'string', code: 'invalid_type', path: ['slug'] }
+      ]
+    )
+  }
+
   @Test()
   public async shouldBeAbleToHideARouteFromTheSwaggerDocumentation({ assert }: Context) {
     Route.get('test', new HelloController().index)