@athenna/http 5.48.0 → 5.50.0

package/package.json

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

package/src/kernels/HttpKernel.js

@@ -13,7 +13,7 @@ import { Log } from '@athenna/logger';
 import { Config } from '@athenna/config';
 import { sep, isAbsolute, resolve } from 'node:path';
 import { Annotation } from '@athenna/ioc';
-import { File, Path, Module, String } from '@athenna/common';
+import { File, Path, Module, String, Json } from '@athenna/common';
 import { HttpExceptionHandler } from '#src/handlers/HttpExceptionHandler';
 export class HttpKernel {
     /**
@@ -57,7 +57,14 @@ export class HttpKernel {
             return;
         }
         if (swaggerPlugin) {
-            await Server.plugin(swaggerPlugin, Config.get('http.swagger.configurations'));
+            const openapiConfig = Json.omit(Config.get('openapi', {}), ['paths']);
+            const pluginConfig = Json.omit(Config.get('http.swagger.configurations', {}), ['swagger']);
+            const swaggerConfig = Config.get('http.swagger.configurations.swagger', {});
+            await Server.plugin(swaggerPlugin, {
+                ...pluginConfig,
+                ...openapiConfig,
+                ...swaggerConfig
+            });
         }
         else {
             debug('Not able to register swagger plugin. Install @fastify/swagger package.');

package/src/router/Route.js

@@ -238,17 +238,25 @@ export class Route extends Macroable {
      * ```
      */
     schema(options) {
-        const { schema, zod } = normalizeRouteSchema(options);
+        const { schema, swaggerSchema, zod } = normalizeRouteSchema(options);
         this.route.fastify.schema = schema;
         if (zod) {
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
             this.route.fastify.config.zod = zod;
+            if (Object.keys(zod.response).length) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                this.route.fastify.config.swaggerSchema = swaggerSchema;
+            }
         }
         else {
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
             delete this.route.fastify.config.zod;
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            delete this.route.fastify.config.swaggerSchema;
         }
         return this;
     }

package/src/router/RouteSchema.d.ts

@@ -23,6 +23,7 @@ export type RouteZodSchemas = {
 };
 export declare function normalizeRouteSchema(options: RouteSchemaOptions): {
     schema: FastifySchema;
+    swaggerSchema: FastifySchema;
     zod: RouteZodSchemas | null;
 };
 export declare function parseRequestWithZod(req: FastifyRequest, schemas: RouteZodSchemas): Promise<void>;

package/src/router/RouteSchema.js

@@ -8,11 +8,11 @@
  */
 import { Is } from '@athenna/common';
 import { ZodValidationException } from '#src/exceptions/ZodValidationException';
-import { ResponseValidationException } from '#src/exceptions/ResponseValidationException';
 export function normalizeRouteSchema(options) {
     const request = {};
     const response = {};
     const schema = { ...options };
+    const swaggerSchema = { ...options };
     const requestKeys = ['body', 'headers', 'params', 'querystring'];
     requestKeys.forEach(key => {
         if (!isZodSchema(options[key])) {
@@ -20,20 +20,27 @@ export function normalizeRouteSchema(options) {
         }
         request[key] = options[key];
         schema[key] = toJsonSchema(options[key], 'input');
+        swaggerSchema[key] = toJsonSchema(options[key], 'input');
     });
     if (options.response && Is.Object(options.response)) {
         schema.response = { ...options.response };
+        swaggerSchema.response = { ...options.response };
         Object.entries(options.response).forEach(([statusCode, value]) => {
             if (!isZodSchema(value)) {
                 return;
             }
             response[statusCode] = value;
-            schema.response[statusCode] = toJsonSchema(value, 'output');
+            swaggerSchema.response[statusCode] = toJsonSchema(value, 'output');
+            delete schema.response[statusCode];
         });
+        if (!Object.keys(schema.response).length) {
+            delete schema.response;
+        }
     }
     const hasZodSchemas = Object.keys(request).length > 0 || Object.keys(response).length > 0;
     return {
         schema,
+        swaggerSchema,
         zod: hasZodSchemas ? { request, response } : null
     };
 }
@@ -57,9 +64,8 @@ export async function parseResponseWithZod(reply, payload, schemas) {
     if (!schema) {
         return payload;
     }
-    return parseSchema(schema, payload).catch(error => {
-        throw new ResponseValidationException(error);
-    });
+    const result = await schema.safeParseAsync(payload);
+    return result.success ? result.data : payload;
 }
 function getResponseSchema(statusCode, schemas) {
     return (schemas[statusCode] ||

package/src/server/ServerImpl.d.ts

@@ -138,6 +138,7 @@ export declare class ServerImpl extends Macroable {
     options(options: Omit<RouteJson, 'methods'>): void;
     private toRouteHooks;
     private getFastifyOptionsWithOpenApiSchema;
+    private configureSwaggerTransform;
     private getOpenApiRouteSchema;
     private getOpenApiPathCandidates;
     private normalizePath;

package/src/server/ServerImpl.js

@@ -282,13 +282,21 @@ export class ServerImpl extends Macroable {
         const automaticSchema = this.getOpenApiRouteSchema(options);
         const fastifyOptions = { ...options.fastify };
         if (!automaticSchema) {
+            this.configureSwaggerTransform(fastifyOptions);
             return fastifyOptions;
         }
         const normalizedSchema = normalizeRouteSchema(automaticSchema);
         const currentConfig = { ...(fastifyOptions.config || {}) };
+        const currentSwaggerSchema = 
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        currentConfig.swaggerSchema || fastifyOptions.schema;
         fastifyOptions.schema = this.mergeFastifySchemas(normalizedSchema.schema, fastifyOptions.schema);
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
+        currentConfig.swaggerSchema = this.mergeFastifySchemas(normalizedSchema.swaggerSchema, currentSwaggerSchema);
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
         const currentZod = currentConfig.zod;
         const mergedZod = this.mergeZodSchemas(normalizedSchema.zod, currentZod);
         if (mergedZod) {
@@ -297,8 +305,31 @@ export class ServerImpl extends Macroable {
             currentConfig.zod = mergedZod;
         }
         fastifyOptions.config = currentConfig;
+        this.configureSwaggerTransform(fastifyOptions);
         return fastifyOptions;
     }
+    configureSwaggerTransform(fastifyOptions) {
+        const config = fastifyOptions?.config;
+        if (!config?.swaggerSchema) {
+            return;
+        }
+        const customTransform = config.swaggerTransform;
+        if (customTransform === false) {
+            return;
+        }
+        config.swaggerTransform = (args) => {
+            const transformed = Is.Function(customTransform)
+                ? customTransform(args)
+                : args;
+            if (transformed === false) {
+                return false;
+            }
+            return {
+                ...transformed,
+                schema: this.mergeFastifySchemas(transformed?.schema || args.schema, config.swaggerSchema)
+            };
+        };
+    }
     getOpenApiRouteSchema(options) {
         const paths = Config.get('openapi.paths', {});
         const methods = options.methods || [];

package/src/exceptions/ResponseValidationException.d.ts

@@ -1,5 +0,0 @@
-import type { ZodError } from 'zod';
-import { HttpException } from '#src/exceptions/HttpException';
-export declare class ResponseValidationException extends HttpException {
-    constructor(error: ZodError);
-}

package/src/exceptions/ResponseValidationException.js

@@ -1,11 +0,0 @@
-import { HttpException } from '#src/exceptions/HttpException';
-export class ResponseValidationException extends HttpException {
-    constructor(error) {
-        const name = 'ResponseValidationException';
-        const code = 'E_RESPONSE_VALIDATION_ERROR';
-        const status = 500;
-        const message = 'The server failed to generate a valid response.';
-        const details = error.issues;
-        super({ name, message, status, code, details });
-    }
-}