@athenna/http 4.22.0 → 4.24.0

package/src/context/Response.d.ts

@@ -7,65 +7,210 @@
  * file that was distributed with this source code.
  */
 import type { FastifyReply } from 'fastify';
+import type { SendOptions } from '@fastify/static';
+import type { Request } from '#src/context/Request';
 import type { FastifyHelmetOptions } from '@fastify/helmet';
 export declare class Response {
     /**
      * The fastify response object.
      */
     response: FastifyReply;
-    constructor(response: FastifyReply);
     /**
-     * Verify if the response has been already sent.
+     * The request object from request context.
+     */
+    request: Request;
+    constructor(response: FastifyReply, request?: Request);
+    /**
+     * Verify if the response has been already sent. Keep
+     * in mind that this method will only return `true`
+     * after `response.send()`, `response.view()`,
+     * `response.sendFile()` or `response.download()` methods
+     * call.
+     *
+     * @example
+     * ```ts
+     * if (response.sent) {
+     *  // do something
+     * }
+     * ```
      */
     get sent(): boolean;
     /**
-     * Get the response body sent in response.
+     * Get the response body sent in response. Keep
+     * in mind that this method will only return `true`
+     * after `response.send()`, `response.view()`,
+     * `response.sendFile()` or `response.download()` methods
+     * call.
+     *
+     * @example
+     * ```ts
+     * const { createdAt, updatedAt } = response.body
+     * ```
      */
     get body(): any | any[];
     /**
-     * Get the status code sent in response.
+     * Get the status code sent in response. Keep
+     * in mind that this method will only return `true`
+     * after `response.send()`, `response.view()`,
+     * `response.sendFile()` or `response.download()` methods
+     * call.
+     *
+     * @example
+     * ```ts
+     * if (response.statusCode !== 200) {
+     *  // do something
+     * }
+     * ```
      */
     get statusCode(): number;
     /**
-     * Get the headers sent in response.
+     * Get the headers set in the response.
+     *
+     * @example
+     * ```ts
+     * const headers = response.headers
+     * ```
      */
     get headers(): any;
     /**
-     * Get the time in MS of how much the request has taken to response.
+     * Get the time in MS of how much the request has
+     * taken to response. Keep in mind that this method
+     * will only return `true` after `response.send()`,
+     * `response.view()`, `response.sendFile()` or
+     * `response.download()` methods call.
+     *
+     * @example
+     * ```ts
+     * console.log(response.responseTime) // 1000
+     * ```
      */
     get responseTime(): number;
+    /**
+     * Terminate the request sending a view to be rendered.
+     *
+     * @example
+     * ```ts
+     * return response.view('welcome', { name: 'lenon' })
+     * ```
+     */
+    view(view: string, data?: any): Promise<Response>;
     /**
      * Terminate the request sending the response body or not.
+     *
+     * @example
+     * ```ts
+     * return response.send({ name: 'lenon' })
+     * ```
      */
     send(data?: any): Promise<Response>;
+    /**
+     * @example
+     * ```ts
+     * return response.sendFile('img.png')
+     * ```
+     */
+    sendFile(filename: string, filepath?: string): Promise<Response>;
+    /**
+     * @example
+     * ```ts
+     * return response.sendFile('img.png', { cacheControl: false })
+     * ```
+     */
+    sendFile(filename: string, options?: string | SendOptions): Promise<Response>;
+    /**
+     * @example
+     * ```ts
+     * return response.sendFile('img.png', Path.tmp(), {
+     *  cacheControl: false
+     * })
+     * ```
+     */
+    sendFile(filename: string, filepath?: string, options?: SendOptions): Promise<Response>;
+    /**
+     * @example
+     * ```ts
+     * return response.download('img.png', 'custom-img.png')
+     * ```
+     */
+    download(filepath: string, filename: string): Promise<Response>;
+    /**
+     * @example
+     * ```ts
+     * return response.download('img.png', 'custom-img.png', {
+     *  cacheControl: false
+     * })
+     * ```
+     */
+    download(filepath: string, filename: string, options?: SendOptions): Promise<Response>;
     /**
      * Set the response status code.
+     *
+     * @example
+     * ```ts
+     * return response.status(200).send()
+     * ```
      */
     status(code: number): Response;
     /**
      * Add some header to the response.
+     *
+     * @example
+     * ```ts
+     * response.header('content-type', 'application/json')
+     *
+     * return response.header('accept-encoding', 'gzip').send(user)
+     * ```
      */
     header(header: string, value: any): Response;
     /**
      * Verify if response has some header.
+     *
+     * @example
+     * ```ts
+     * if (response.hasHeader('content-type')) {
+     *   // do something
+     * }
+     * ```
      */
     hasHeader(header: string): boolean;
     /**
-     * Add some header safelly to the response. This means that the header is not
-     * going to be added if is already set.
+     * Add some header safely to the response. This means that
+     * the header is not going to be added if is already set.
+     *
+     * @example
+     * ```ts
+     * response.safeHeader('content-type', 'application/json')
+     * ```
      */
     safeHeader(header: string, value: any): Response;
     /**
      * Remove some header from the response.
+     *
+     * @example
+     * ```ts
+     * response.removeHeader('content-type')
+     * ```
      */
     removeHeader(header: string): Response;
     /**
-     * Redirect the response to other url. You can also set a different status code
-     * for the redirect.
+     * Redirect the response to other url. You can also set a
+     * different status code for the redirect.
+     *
+     * @example
+     * ```ts
+     * return response.redirect('users', 304)
+     * ```
      */
     redirectTo(url: string, status?: number): Promise<Response>;
     /**
      * Apply helmet in response.
+     *
+     * @example
+     * ```ts
+     * return response
+     *  .helmet({ enableCSPNonces: false })
+     *  .view('profile', user)
+     * ```
      */
     helmet(options: FastifyHelmetOptions): Response;
 }

package/src/context/Response.js

@@ -6,50 +6,145 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
+import { View } from '@athenna/view';
 export class Response {
-    constructor(response) {
+    constructor(response, request) {
         this.response = response;
+        this.request = request;
     }
     /**
-     * Verify if the response has been already sent.
+     * Verify if the response has been already sent. Keep
+     * in mind that this method will only return `true`
+     * after `response.send()`, `response.view()`,
+     * `response.sendFile()` or `response.download()` methods
+     * call.
+     *
+     * @example
+     * ```ts
+     * if (response.sent) {
+     *  // do something
+     * }
+     * ```
      */
     get sent() {
         return this.response.sent;
     }
     /**
-     * Get the response body sent in response.
+     * Get the response body sent in response. Keep
+     * in mind that this method will only return `true`
+     * after `response.send()`, `response.view()`,
+     * `response.sendFile()` or `response.download()` methods
+     * call.
+     *
+     * @example
+     * ```ts
+     * const { createdAt, updatedAt } = response.body
+     * ```
      */
     get body() {
         return this.response.body;
     }
     /**
-     * Get the status code sent in response.
+     * Get the status code sent in response. Keep
+     * in mind that this method will only return `true`
+     * after `response.send()`, `response.view()`,
+     * `response.sendFile()` or `response.download()` methods
+     * call.
+     *
+     * @example
+     * ```ts
+     * if (response.statusCode !== 200) {
+     *  // do something
+     * }
+     * ```
      */
     get statusCode() {
         return this.response.statusCode;
     }
     /**
-     * Get the headers sent in response.
+     * Get the headers set in the response.
+     *
+     * @example
+     * ```ts
+     * const headers = response.headers
+     * ```
      */
     get headers() {
         return this.response.getHeaders();
     }
     /**
-     * Get the time in MS of how much the request has taken to response.
+     * Get the time in MS of how much the request has
+     * taken to response. Keep in mind that this method
+     * will only return `true` after `response.send()`,
+     * `response.view()`, `response.sendFile()` or
+     * `response.download()` methods call.
+     *
+     * @example
+     * ```ts
+     * console.log(response.responseTime) // 1000
+     * ```
      */
     get responseTime() {
-        return this.response.getResponseTime();
+        return this.response.elapsedTime;
+    }
+    /**
+     * Terminate the request sending a view to be rendered.
+     *
+     * @example
+     * ```ts
+     * return response.view('welcome', { name: 'lenon' })
+     * ```
+     */
+    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.
+     *
+     * @example
+     * ```ts
+     * return response.send({ name: 'lenon' })
+     * ```
      */
     async send(data) {
         await this.response.send(data);
         this.response.body = data;
         return this;
     }
+    /**
+     * Terminate the request sending a file.
+     *
+     * @example
+     * ```ts
+     * return response.sendFile('img.png')
+     * ```
+     */
+    async sendFile(filename, filepath, options) {
+        await this.response.sendFile(filename, filepath, options);
+        return this;
+    }
+    /**
+     * Terminate the request sending a file with custom name.
+     *
+     * @example
+     * ```ts
+     * return response.download('img.png', 'custom-img.png')
+     * ```
+     */
+    async download(filepath, filename, options) {
+        await this.response.download(filename, filepath, options);
+        return this;
+    }
     /**
      * Set the response status code.
+     *
+     * @example
+     * ```ts
+     * return response.status(200).send()
+     * ```
      */
     status(code) {
         this.response.status(code);
@@ -57,6 +152,13 @@ export class Response {
     }
     /**
      * Add some header to the response.
+     *
+     * @example
+     * ```ts
+     * response.header('content-type', 'application/json')
+     *
+     * return response.header('accept-encoding', 'gzip').send(user)
+     * ```
      */
     header(header, value) {
         this.response.header(header, value);
@@ -64,13 +166,25 @@ export class Response {
     }
     /**
      * Verify if response has some header.
+     *
+     * @example
+     * ```ts
+     * if (response.hasHeader('content-type')) {
+     *   // do something
+     * }
+     * ```
      */
     hasHeader(header) {
         return this.response.hasHeader(header);
     }
     /**
-     * Add some header safelly to the response. This means that the header is not
-     * going to be added if is already set.
+     * Add some header safely to the response. This means that
+     * the header is not going to be added if is already set.
+     *
+     * @example
+     * ```ts
+     * response.safeHeader('content-type', 'application/json')
+     * ```
      */
     safeHeader(header, value) {
         this.response.header(header, value);
@@ -78,14 +192,24 @@ export class Response {
     }
     /**
      * Remove some header from the response.
+     *
+     * @example
+     * ```ts
+     * response.removeHeader('content-type')
+     * ```
      */
     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.
+     * Redirect the response to other url. You can also set a
+     * different status code for the redirect.
+     *
+     * @example
+     * ```ts
+     * return response.redirect('users', 304)
+     * ```
      */
     async redirectTo(url, status) {
         if (status) {
@@ -97,6 +221,13 @@ export class Response {
     }
     /**
      * Apply helmet in response.
+     *
+     * @example
+     * ```ts
+     * return response
+     *  .helmet({ enableCSPNonces: false })
+     *  .view('profile', user)
+     * ```
      */
     helmet(options) {
         this.response.helmet(options);

package/src/handlers/FastifyHandler.d.ts

@@ -6,9 +6,9 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import type { InterceptHandler, TerminateHandler } from '#src/types';
 import type { RequestHandler } from '#src/types/contexts/Context';
 import type { ErrorHandler } from '#src/types/contexts/ErrorContext';
+import type { InterceptHandler, TerminateHandler } from '#src/types';
 import type { FastifyReply, FastifyRequest, RouteHandlerMethod } from 'fastify';
 export declare class FastifyHandler {
     /**

package/src/handlers/FastifyHandler.js

@@ -16,20 +16,12 @@ export class FastifyHandler {
      */
     static request(handler) {
         return async (req, res) => {
-            const request = new Request(req);
-            const response = new Response(res);
             if (!req.data) {
                 req.data = {};
             }
-            await handler({
-                request,
-                response,
-                data: req.data,
-                body: req.body,
-                params: req.params,
-                queries: req.query,
-                headers: req.headers
-            });
+            const request = new Request(req);
+            const response = new Response(res, request);
+            return handler({ request, response, data: req.data });
         };
     }
     /**
@@ -43,8 +35,11 @@ export class FastifyHandler {
      */
     static intercept(handler) {
         return async (req, res, payload) => {
+            if (!req.data) {
+                req.data = {};
+            }
             const request = new Request(req);
-            const response = new Response(res);
+            const response = new Response(res, request);
             if (Is.Json(payload)) {
                 payload = JSON.parse(payload);
             }
@@ -53,11 +48,7 @@ export class FastifyHandler {
                 request,
                 response,
                 status: response.statusCode,
-                data: req.data,
-                body: res.body,
-                params: req.params,
-                queries: req.query,
-                headers: req.headers
+                data: req.data
             });
             res.body = payload;
             if (Is.Object(payload)) {
@@ -71,18 +62,17 @@ export class FastifyHandler {
      */
     static terminate(handler) {
         return async (req, res) => {
+            if (!req.data) {
+                req.data = {};
+            }
             const request = new Request(req);
-            const response = new Response(res);
+            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.getResponseTime()
+                responseTime: res.elapsedTime
             });
         };
     }
@@ -91,16 +81,15 @@ export class FastifyHandler {
      */
     static error(handler) {
         return async (error, req, res) => {
+            if (!req.data) {
+                req.data = {};
+            }
             const request = new Request(req);
-            const response = new Response(res);
+            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
             });
         };

package/src/kernels/HttpKernel.d.ts

@@ -24,6 +24,10 @@ export declare class HttpKernel {
      * Register the @fastify/rate-limit plugin in the Http server.
      */
     registerRateLimit(): Promise<void>;
+    /**
+     * Register the @fastify/static plugin in the Http server.
+     */
+    registerStatic(): Promise<void>;
     /**
      * Register the cls-rtracer plugin in the Http server.
      */

package/src/kernels/HttpKernel.js

@@ -13,13 +13,14 @@ 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');
 const swaggerPlugin = await Module.safeImport('@fastify/swagger');
 const swaggerUiPlugin = await Module.safeImport('@fastify/swagger-ui');
 const rateLimitPlugin = await Module.safeImport('@fastify/rate-limit');
+const staticPlugin = await Module.safeImport('@fastify/static');
 const rTracerPlugin = await Module.safeImport('cls-rtracer');
 export class HttpKernel {
     /**
@@ -90,6 +91,20 @@ export class HttpKernel {
         }
         await Server.plugin(rateLimitPlugin, this.getConfig('http.rateLimit'));
     }
+    /**
+     * Register the @fastify/static plugin in the Http server.
+     */
+    async registerStatic() {
+        if (Config.is('http.static.enabled', false)) {
+            debug('Not able to register static plugin. Set the http.static.enabled configuration as true.');
+            return;
+        }
+        if (!staticPlugin) {
+            debug('Not able to register static plugin. Install @fastify/static package.');
+            return;
+        }
+        await Server.plugin(staticPlugin, this.getConfig('http.static'));
+    }
     /**
      * Register the cls-rtracer plugin in the Http server.
      */

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.

package/src/types/contexts/Context.d.ts

@@ -12,9 +12,5 @@ export type Context = {
     request: Request;
     response: Response;
     data: any;
-    body: any;
-    params: any;
-    queries: any;
-    headers: any;
 };
 export type RequestHandler = (ctx: Context) => any | Promise<any>;

package/src/types/contexts/ErrorContext.d.ts

@@ -6,16 +6,8 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import { Request } from '#src/context/Request';
-import { Response } from '#src/context/Response';
-export type ErrorContext = {
-    request: Request;
-    response: Response;
-    data: any;
-    body: any;
+import type { Context } from '#src/types/contexts/Context';
+export type ErrorContext = Context & {
     error: any;
-    params: any;
-    queries: any;
-    headers: any;
 };
 export type ErrorHandler = (ctx: ErrorContext) => Promise<void>;

package/src/types/contexts/ErrorContext.js

@@ -6,5 +6,4 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import { Request } from '#src/context/Request';
-import { Response } from '#src/context/Response';
+export {};