@athenna/http 5.47.0 → 5.49.0

package/package.json

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

package/src/context/Response.d.ts

@@ -113,6 +113,7 @@ export declare class Response extends Macroable {
      * ```
      */
     send(data?: any): Promise<Response>;
+    private getRouteZodSchemas;
     /**
      * @example
      * ```ts

package/src/context/Response.js

@@ -8,6 +8,7 @@
  */
 import { View } from '@athenna/view';
 import { Macroable } from '@athenna/common';
+import { parseResponseWithZod } from '#src/router/RouteSchema';
 export class Response extends Macroable {
     constructor(response, request) {
         super();
@@ -126,10 +127,19 @@ export class Response extends Macroable {
      * ```
      */
     async send(data) {
+        const zodSchemas = this.getRouteZodSchemas();
+        if (zodSchemas) {
+            data = await parseResponseWithZod(this.response, data, zodSchemas);
+        }
         await this.response.send(data);
         this.response.body = data;
         return this;
     }
+    getRouteZodSchemas() {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return this.response.request?.routeOptions?.config?.zod || null;
+    }
     /**
      * Terminate the request sending a file.
      *

package/src/handlers/HttpExceptionHandler.js

@@ -51,7 +51,7 @@ export class HttpExceptionHandler extends ExceptionHandler {
         if (!isDebugMode) {
             delete body.stack;
         }
-        response.status(body.statusCode).send(body);
+        await response.status(body.statusCode).send(body);
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
         await super.handle({ error, response });

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

@@ -12,6 +12,7 @@ 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])) {
@@ -19,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
     };
 }
@@ -45,10 +53,10 @@ export async function parseRequestWithZod(req, schemas) {
         req.headers = await parseSchema(requestSchemas.headers, req.headers);
     }
     if (requestSchemas.params) {
-        req.params = await parseSchema(requestSchemas.params, coerceDataForValidation(requestSchemas.params, req.params));
+        req.params = await parseSchema(requestSchemas.params, req.params);
     }
     if (requestSchemas.querystring) {
-        req.query = await parseSchema(requestSchemas.querystring, coerceDataForValidation(requestSchemas.querystring, req.query));
+        req.query = await parseSchema(requestSchemas.querystring, req.query);
     }
 }
 export async function parseResponseWithZod(reply, payload, schemas) {
@@ -56,7 +64,8 @@ export async function parseResponseWithZod(reply, payload, schemas) {
     if (!schema) {
         return payload;
     }
-    return parseSchema(schema, payload);
+    const result = await schema.safeParseAsync(payload);
+    return result.success ? result.data : payload;
 }
 function getResponseSchema(statusCode, schemas) {
     return (schemas[statusCode] ||
@@ -85,58 +94,6 @@ function toJsonSchema(schema, io) {
     delete jsonSchema.$schema;
     return jsonSchema;
 }
-function coerceDataForValidation(schema, data) {
-    return coerceDataByJsonSchema(toJsonSchema(schema, 'input'), data);
-}
-function coerceDataByJsonSchema(schema, data) {
-    if (Is.Undefined(data) || Is.Null(data) || !schema) {
-        return data;
-    }
-    if (schema.anyOf) {
-        return coerceWithAlternatives(schema.anyOf, data);
-    }
-    if (schema.oneOf) {
-        return coerceWithAlternatives(schema.oneOf, data);
-    }
-    if (schema.type === 'object' && Is.Object(data)) {
-        const coerced = { ...data };
-        const properties = schema.properties || {};
-        Object.entries(properties).forEach(([key, childSchema]) => {
-            if (!Object.hasOwn(coerced, key)) {
-                return;
-            }
-            coerced[key] = coerceDataByJsonSchema(childSchema, coerced[key]);
-        });
-        return coerced;
-    }
-    if (schema.type === 'array' && Is.Array(data) && schema.items) {
-        return data.map(item => coerceDataByJsonSchema(schema.items, item));
-    }
-    if (schema.type === 'number' || schema.type === 'integer') {
-        return coerceNumber(data, schema.type === 'integer');
-    }
-    return data;
-}
-function coerceWithAlternatives(schemas, data) {
-    let coerced = data;
-    schemas.forEach(schema => {
-        coerced = coerceDataByJsonSchema(schema, coerced);
-    });
-    return coerced;
-}
-function coerceNumber(value, integerOnly) {
-    if (!Is.String(value) || value.trim() === '') {
-        return value;
-    }
-    const parsed = integerOnly ? Number.parseInt(value, 10) : Number(value);
-    if (Number.isNaN(parsed)) {
-        return value;
-    }
-    if (integerOnly && !Number.isInteger(parsed)) {
-        return value;
-    }
-    return parsed;
-}
 function isZodSchema(value) {
     return (Is.Defined(value) &&
         Is.Function(value.parse) &&

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

@@ -7,7 +7,7 @@
  * file that was distributed with this source code.
  */
 import fastify from 'fastify';
-import { normalizeRouteSchema, parseRequestWithZod, parseResponseWithZod } from '#src/router/RouteSchema';
+import { parseRequestWithZod, normalizeRouteSchema } from '#src/router/RouteSchema';
 import { Options, Macroable, Is } from '@athenna/common';
 import { FastifyHandler } from '#src/handlers/FastifyHandler';
 export class ServerImpl extends Macroable {
@@ -196,7 +196,6 @@ export class ServerImpl extends Macroable {
             onSend: [],
             preValidation: [],
             preHandler: [],
-            preSerialization: [],
             onResponse: [],
             url: options.url,
             method: options.methods,
@@ -213,9 +212,6 @@ export class ServerImpl extends Macroable {
         }
         if (zodSchemas) {
             route.preValidation = [async (req) => parseRequestWithZod(req, zodSchemas)];
-            route.preSerialization = [
-                async (_, reply, payload) => parseResponseWithZod(reply, payload, zodSchemas)
-            ];
         }
         if (options.data && Is.Array(route.preHandler)) {
             route.preHandler?.unshift((req, _, done) => {
@@ -231,10 +227,6 @@ export class ServerImpl extends Macroable {
                 ...this.toRouteHooks(route.preValidation),
                 ...this.toRouteHooks(fastifyOptions.preValidation)
             ];
-            fastifyOptions.preSerialization = [
-                ...this.toRouteHooks(route.preSerialization),
-                ...this.toRouteHooks(fastifyOptions.preSerialization)
-            ];
         }
         this.fastify.route({ ...route, ...fastifyOptions });
     }
@@ -290,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) {
@@ -305,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 || [];