@athenna/http 4.24.0 → 4.25.0

package/src/context/Response.d.ts

@@ -7,210 +7,8 @@
  * 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;
-    /**
-     * 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. 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. 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 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. 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 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.
-     *
-     * @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;
-}
+import type { Request, Response } from '#src/types';
+/**
+ * Create the Athenna response object
+ */
+export declare function response(reply: FastifyReply, request?: Request): Response;

package/src/context/Response.js

@@ -7,230 +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. 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. 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. 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 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. 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.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);
-        return this;
-    }
-    /**
-     * 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);
-        return this;
-    }
-    /**
-     * 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 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);
-        return this;
-    }
-    /**
-     * 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.
-     *
-     * @example
-     * ```ts
-     * return response.redirect('users', 304)
-     * ```
-     */
-    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.
-     *
-     * @example
-     * ```ts
-     * return response
-     *  .helmet({ enableCSPNonces: false })
-     *  .view('profile', user)
-     * ```
-     */
-    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
@@ -19,9 +19,11 @@ export class FastifyHandler {
             if (!req.data) {
                 req.data = {};
             }
-            const request = new Request(req);
-            const response = new Response(res, request);
-            return handler({ request, response, data: req.data });
+            const ctx = {};
+            ctx.data = req.data;
+            ctx.request = request(req);
+            ctx.response = response(res, ctx.request);
+            return handler(ctx);
         };
     }
     /**
@@ -38,19 +40,17 @@ export class FastifyHandler {
             if (!req.data) {
                 req.data = {};
             }
-            const request = new Request(req);
-            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
-            });
-            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);
             }
@@ -65,15 +65,13 @@ export class FastifyHandler {
             if (!req.data) {
                 req.data = {};
             }
-            const request = new Request(req);
-            const response = new Response(res, request);
-            await handler({
-                request,
-                response,
-                data: req.data,
-                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);
         };
     }
     /**
@@ -84,14 +82,12 @@ export class FastifyHandler {
             if (!req.data) {
                 req.data = {};
             }
-            const request = new Request(req);
-            const response = new Response(res, request);
-            await handler({
-                request,
-                response,
-                data: req.data,
-                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/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.
      */