@athenna/http 5.47.0 → 5.48.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/http",
-  "version": "5.47.0",
+  "version": "5.48.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/exceptions/ResponseValidationException.d.ts

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,11 @@
+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 });
+    }
+}

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/RouteSchema.js

@@ -8,6 +8,7 @@
  */
 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 = {};
@@ -45,10 +46,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 +57,9 @@ export async function parseResponseWithZod(reply, payload, schemas) {
     if (!schema) {
         return payload;
     }
-    return parseSchema(schema, payload);
+    return parseSchema(schema, payload).catch(error => {
+        throw new ResponseValidationException(error);
+    });
 }
 function getResponseSchema(statusCode, schemas) {
     return (schemas[statusCode] ||
@@ -85,58 +88,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.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 });
     }