@athenna/http 4.25.0 → 4.27.0

package/src/context/Response.js

@@ -7,83 +7,236 @@
  * file that was distributed with this source code.
  */
 import { View } from '@athenna/view';
-/**
- * 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;
+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').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;
         }
-    };
-    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;
+    }
+    /**
+     * Get the original fastify response.
+     */
+    getFastifyResponse() {
+        return this.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
@@ -21,9 +21,9 @@ export class FastifyHandler {
             }
             const ctx = {};
             ctx.data = req.data;
-            ctx.request = request(req);
-            ctx.response = response(res, ctx.request);
-            return handler(ctx);
+            ctx.request = new Request(req);
+            ctx.response = new Response(res, ctx.request);
+            await handler(ctx);
         };
     }
     /**
@@ -46,11 +46,11 @@ export class FastifyHandler {
             res.body = payload;
             const ctx = {};
             ctx.data = req.data;
-            ctx.request = request(req);
-            ctx.response = response(res, ctx.request);
+            ctx.request = new Request(req);
+            ctx.response = new Response(res, ctx.request);
             ctx.status = ctx.response.statusCode;
             payload = await handler(ctx);
-            ctx.response.response.body = payload;
+            req.body = payload;
             if (Is.Object(payload)) {
                 payload = JSON.stringify(payload);
             }
@@ -67,8 +67,8 @@ export class FastifyHandler {
             }
             const ctx = {};
             ctx.data = req.data;
-            ctx.request = request(req);
-            ctx.response = response(res, ctx.request);
+            ctx.request = new Request(req);
+            ctx.response = new Response(res, ctx.request);
             ctx.status = ctx.response.statusCode;
             ctx.responseTime = ctx.response.elapsedTime;
             await handler(ctx);
@@ -84,8 +84,8 @@ export class FastifyHandler {
             }
             const ctx = {};
             ctx.data = req.data;
-            ctx.request = request(req);
-            ctx.response = response(res, ctx.request);
+            ctx.request = new Request(req);
+            ctx.response = new Response(res, ctx.request);
             ctx.error = error;
             await handler(ctx);
         };

package/src/kernels/HttpKernel.js

@@ -60,11 +60,12 @@ export class HttpKernel {
             return;
         }
         if (swaggerPlugin) {
-            debug('Not able to register swagger plugin. Install @fastify/swagger package.');
             await Server.plugin(swaggerPlugin, Config.get('http.swagger.configurations'));
         }
+        else {
+            debug('Not able to register swagger plugin. Install @fastify/swagger package.');
+        }
         if (swaggerUiPlugin) {
-            debug('Not able to register swagger-ui plugin. Install @fastify/swagger-ui package.');
             const swaggerUiConfig = Config.get('http.swagger.ui', {});
             if (!swaggerUiConfig.logo) {
                 const __dirname = Module.createDirname(import.meta.url);
@@ -76,6 +77,9 @@ export class HttpKernel {
             }
             await Server.plugin(swaggerUiPlugin, swaggerUiConfig);
         }
+        else {
+            debug('Not able to register swagger-ui plugin. Install @fastify/swagger-ui package.');
+        }
     }
     /**
      * Register the @fastify/rate-limit plugin in the Http server.

package/src/server/ServerImpl.js

@@ -125,7 +125,7 @@ export class ServerImpl {
         if (!this.isListening) {
             return;
         }
-        await this.fastify.close().then(() => (this.isListening = true));
+        await this.fastify.close().then(() => (this.isListening = false));
     }
     /**
      * Add a new route to the http server.