@athenna/http 4.23.0 → 4.25.0

package/src/context/Response.js

@@ -7,121 +7,83 @@
  * file that was distributed with this source code.
  */
 import { View } from '@athenna/view';
-export class Response {
-    constructor(response, request) {
-        this.response = response;
-        this.request = request;
-    }
-    /**
-     * Verify if the response has been already sent.
-     */
-    get sent() {
-        return this.response.sent;
-    }
-    /**
-     * Get the response body sent in response.
-     */
-    get body() {
-        return this.response.body;
-    }
-    /**
-     * Get the status code sent in response.
-     */
-    get statusCode() {
-        return this.response.statusCode;
-    }
-    /**
-     * Get the headers sent in response.
-     */
-    get headers() {
-        return this.response.getHeaders();
-    }
-    /**
-     * Get the time in MS of how much the request has taken to response.
-     */
-    get responseTime() {
-        return this.response.elapsedTime;
-    }
-    /**
-     * Terminated the request sending a view to be rendered.
-     */
-    async view(view, data) {
-        const content = await View.render(view, { ...data, request: this.request });
-        await this.safeHeader('Content-Type', 'text/html; charset=utf-8').response.send(content);
-        this.response.body = content;
-        return this;
-    }
-    /**
-     * Terminate the request sending the response body or not.
-     */
-    async send(data) {
-        await this.response.send(data);
-        this.response.body = data;
-        return this;
-    }
-    /**
-     * Terminated the request sending a file.
-     */
-    async sendFile(filename, filepath, options) {
-        await this.response.sendFile(filename, filepath, options);
-        return this;
-    }
-    async download(filepath, filename, options) {
-        await this.response.download(filename, filepath, options);
-        return this;
-    }
-    /**
-     * Set the response status code.
-     */
-    status(code) {
-        this.response.status(code);
-        return this;
-    }
-    /**
-     * Add some header to the response.
-     */
-    header(header, value) {
-        this.response.header(header, value);
-        return this;
-    }
-    /**
-     * Verify if response has some header.
-     */
-    hasHeader(header) {
-        return this.response.hasHeader(header);
-    }
-    /**
-     * Add some header safely to the response. This means that the header is not
-     * going to be added if is already set.
-     */
-    safeHeader(header, value) {
-        this.response.header(header, value);
-        return this;
-    }
-    /**
-     * Remove some header from the response.
-     */
-    removeHeader(header) {
-        this.response.removeHeader(header);
-        return this;
-    }
-    /**
-     * Redirect the response to other url. You can also set a different status code
-     * for the redirect.
-     */
-    async redirectTo(url, status) {
-        if (status) {
-            await this.response.redirect(status, url);
-            return this;
+/**
+ * Create the Athenna response object
+ */
+export function response(reply, request) {
+    const response = {
+        response: reply,
+        request,
+        get sent() {
+            return reply.sent;
+        },
+        get body() {
+            return reply.body;
+        },
+        get statusCode() {
+            return reply.statusCode;
+        },
+        get headers() {
+            return reply.getHeaders();
+        },
+        get responseTime() {
+            return reply.elapsedTime;
+        },
+        async view(view, data) {
+            const content = await View.render(view, {
+                ...data,
+                request: this.request
+            });
+            await response
+                .safeHeader('Content-Type', 'text/html; charset=utf-8')
+                .response.send(content);
+            response.response.body = content;
+            return response;
+        },
+        async send(data) {
+            await response.response.send(data);
+            response.response.body = data;
+            return response;
+        },
+        async sendFile(filename, filepath, options) {
+            await response.response.sendFile(filename, filepath, options);
+            return response;
+        },
+        async download(filepath, filename, options) {
+            await response.response.download(filename, filepath, options);
+            return response;
+        },
+        status(code) {
+            response.response.status(code);
+            return response;
+        },
+        header(header, value) {
+            response.response.header(header, value);
+            return response;
+        },
+        hasHeader(header) {
+            return response.response.hasHeader(header);
+        },
+        safeHeader(header, value) {
+            response.response.header(header, value);
+            return response;
+        },
+        removeHeader(header) {
+            response.response.removeHeader(header);
+            return response;
+        },
+        async redirectTo(url, status) {
+            if (status) {
+                await this.response.redirect(status, url);
+                return response;
+            }
+            await this.response.redirect(url);
+            return response;
+        },
+        helmet(options) {
+            this.response.helmet(options);
+            return response;
         }
-        await this.response.redirect(url);
-        return this;
-    }
-    /**
-     * Apply helmet in response.
-     */
-    helmet(options) {
-        this.response.helmet(options);
-        return this;
-    }
+    };
+    return response;
 }

package/src/handlers/FastifyHandler.js

@@ -7,8 +7,8 @@
  * file that was distributed with this source code.
  */
 import { Is } from '@athenna/common';
-import { Request } from '#src/context/Request';
-import { Response } from '#src/context/Response';
+import { request } from '#src/context/Request';
+import { response } from '#src/context/Response';
 export class FastifyHandler {
     /**
      * Parse the fastify request handler and the preHandler hook to an Athenna
@@ -16,20 +16,14 @@ export class FastifyHandler {
      */
     static request(handler) {
         return async (req, res) => {
-            const request = new Request(req);
             if (!req.data) {
                 req.data = {};
             }
-            const response = new Response(res, request);
-            await handler({
-                request,
-                response,
-                data: req.data,
-                body: req.body,
-                params: req.params,
-                queries: req.query,
-                headers: req.headers
-            });
+            const ctx = {};
+            ctx.data = req.data;
+            ctx.request = request(req);
+            ctx.response = response(res, ctx.request);
+            return handler(ctx);
         };
     }
     /**
@@ -43,26 +37,20 @@ export class FastifyHandler {
      */
     static intercept(handler) {
         return async (req, res, payload) => {
-            const request = new Request(req);
             if (!req.data) {
                 req.data = {};
             }
-            const response = new Response(res, request);
             if (Is.Json(payload)) {
                 payload = JSON.parse(payload);
             }
             res.body = payload;
-            payload = await handler({
-                request,
-                response,
-                status: response.statusCode,
-                data: req.data,
-                body: res.body,
-                params: req.params,
-                queries: req.query,
-                headers: req.headers
-            });
-            res.body = payload;
+            const ctx = {};
+            ctx.data = req.data;
+            ctx.request = request(req);
+            ctx.response = response(res, ctx.request);
+            ctx.status = ctx.response.statusCode;
+            payload = await handler(ctx);
+            ctx.response.response.body = payload;
             if (Is.Object(payload)) {
                 payload = JSON.stringify(payload);
             }
@@ -74,22 +62,16 @@ export class FastifyHandler {
      */
     static terminate(handler) {
         return async (req, res) => {
-            const request = new Request(req);
             if (!req.data) {
                 req.data = {};
             }
-            const response = new Response(res, request);
-            await handler({
-                request,
-                response,
-                params: req.params,
-                queries: req.query,
-                data: req.data,
-                body: res.body || req.body,
-                headers: res.getHeaders(),
-                status: res.statusCode,
-                responseTime: res.elapsedTime
-            });
+            const ctx = {};
+            ctx.data = req.data;
+            ctx.request = request(req);
+            ctx.response = response(res, ctx.request);
+            ctx.status = ctx.response.statusCode;
+            ctx.responseTime = ctx.response.elapsedTime;
+            await handler(ctx);
         };
     }
     /**
@@ -97,21 +79,15 @@ export class FastifyHandler {
      */
     static error(handler) {
         return async (error, req, res) => {
-            const request = new Request(req);
             if (!req.data) {
                 req.data = {};
             }
-            const response = new Response(res, request);
-            await handler({
-                request,
-                response,
-                data: req.data,
-                body: res.body || req.body,
-                params: req.params,
-                queries: req.query,
-                headers: req.headers,
-                error
-            });
+            const ctx = {};
+            ctx.data = req.data;
+            ctx.request = request(req);
+            ctx.response = response(res, ctx.request);
+            ctx.error = error;
+            await handler(ctx);
         };
     }
 }

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, Exec, Module, String } from '@athenna/common';
+import { File, Path, Exec, Module, String } from '@athenna/common';
 import { HttpExceptionHandler } from '#src/handlers/HttpExceptionHandler';
 const corsPlugin = await Module.safeImport('@fastify/cors');
 const helmetPlugin = await Module.safeImport('@fastify/helmet');

package/src/router/Router.d.ts

@@ -44,6 +44,16 @@ export declare class Router {
      * Creates a new route resource.
      */
     resource(resource: string, controller?: any): RouteResource;
+    /**
+     * This method is a convenient shortcut to render a view without
+     * defining an explicit handler.
+     */
+    view(pattern: string, view: string, data?: any): Route;
+    /**
+     * This method is a convenient shortcut to redirect a route without
+     * defining an explicit handler.
+     */
+    redirect(pattern: string, url: string, status?: number): Route;
     /**
      * Define a route that handles all common HTTP methods.
      */

package/src/router/Router.js

@@ -79,6 +79,24 @@ export class Router {
         }
         return resourceInstance;
     }
+    /**
+     * This method is a convenient shortcut to render a view without
+     * defining an explicit handler.
+     */
+    view(pattern, view, data) {
+        return this.route(pattern, ['GET', 'HEAD'], ctx => {
+            return ctx.response.view(view, data);
+        });
+    }
+    /**
+     * This method is a convenient shortcut to redirect a route without
+     * defining an explicit handler.
+     */
+    redirect(pattern, url, status) {
+        return this.route(pattern, ['GET', 'HEAD'], ctx => {
+            return ctx.response.redirectTo(url, status);
+        });
+    }
     /**
      * Define a route that handles all common HTTP methods.
      */

package/src/server/ServerImpl.js

@@ -151,17 +151,22 @@ export class ServerImpl {
             });
             return;
         }
-        this.fastify.route({
+        const { middlewares, interceptors, terminators } = options.middlewares;
+        const route = {
             url: options.url,
             method: options.methods,
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            handler: FastifyHandler.request(options.handler),
-            preHandler: options.middlewares.middlewares.map(m => FastifyHandler.handle(m)),
-            onSend: options.middlewares.interceptors.map(m => FastifyHandler.intercept(m)),
-            onResponse: options.middlewares.terminators.map(m => FastifyHandler.terminate(m)),
-            ...options.fastify
-        });
+            handler: FastifyHandler.request(options.handler)
+        };
+        if (middlewares.length) {
+            route.preHandler = middlewares.map(m => FastifyHandler.handle(m));
+        }
+        if (interceptors.length) {
+            route.onSend = interceptors.map(i => FastifyHandler.intercept(i));
+        }
+        if (terminators.length) {
+            route.onResponse = terminators.map(t => FastifyHandler.terminate(t));
+        }
+        this.fastify.route({ ...route, ...options.fastify });
     }
     /**
      * Add a new GET route to the http server.