@athenna/http 1.1.4 → 1.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/http",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "description": "The Athenna Http server. Built on top of fastify",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",
@@ -160,7 +160,8 @@
   "dependencies": {
     "@athenna/config": "1.0.6",
     "@athenna/ioc": "1.1.1",
-    "@secjs/utils": "1.8.2",
+    "@athenna/logger": "1.1.2",
+    "@secjs/utils": "1.8.3",
     "fastify": "3.27.4",
     "reflect-metadata": "0.1.13",
     "tscpaths": "0.0.9"

package/src/Context/Request.d.ts

@@ -9,19 +9,95 @@
 import { FastifyRequest } from 'fastify';
 import { RequestContract } from '../Contracts/Context/RequestContract';
 export declare class Request implements RequestContract {
-    private request;
+    private readonly request;
+    /**
+     * Create a new instance of Request.
+     *
+     * @return Request
+     */
     constructor(request: FastifyRequest);
+    /**
+     * Get the request ip.
+     *
+     * @return string
+     */
     get ip(): string;
+    /**
+     * Get the request method.
+     *
+     * @return string
+     */
     get method(): string;
+    /**
+     * Get the host url from request.
+     *
+     * @return string
+     */
     get hostUrl(): string;
+    /**
+     * Get the base request url.
+     *
+     * @return string
+     */
     get baseUrl(): string;
+    /**
+     * Get the original request url.
+     *
+     * @return string
+     */
     get originalUrl(): string;
-    get body(): Record<string, any>;
-    get params(): Record<string, string>;
-    get queries(): Record<string, string>;
-    get headers(): Record<string, string>;
-    param(param: string, defaultValue?: string): string | undefined;
-    query(query: string, defaultValue?: string): string | undefined;
-    header(header: string, defaultValue?: string): string | undefined;
+    /**
+     * Get all body from request.
+     *
+     * @return any
+     */
+    get body(): any;
+    /**
+     * Get all params from request.
+     *
+     * @return any
+     */
+    get params(): any;
+    /**
+     * Get all queries from request.
+     *
+     * @return any
+     */
+    get queries(): any;
+    /**
+     * Get all headers from request.
+     *
+     * @return any
+     */
+    get headers(): any;
+    /**
+     * Get a value from the request params or the default value.
+     *
+     * @return any
+     */
+    param(param: string, defaultValue?: string): any;
+    /**
+     * Get a value from the request query param or the default value.
+     *
+     * @return any
+     */
+    query(query: string, defaultValue?: string): any;
+    /**
+     * Get a value from the request header or the default value.
+     *
+     * @return any
+     */
+    header(header: string, defaultValue?: string): any;
+    /**
+     * Get a value from the request body or the default value.
+     *
+     * @return any
+     */
     payload(payload: string, defaultValue?: string): any;
+    /**
+     * Get the default fastify request object.
+     *
+     * @return FastifyRequest
+     */
+    getFastifyRequest(): FastifyRequest;
 }

package/src/Context/Request.js

@@ -13,56 +13,135 @@ const utils_1 = require("@secjs/utils");
 const config_1 = require("@athenna/config");
 const removeSlash_1 = require("../Utils/removeSlash");
 class Request {
+    /**
+     * Create a new instance of Request.
+     *
+     * @return Request
+     */
     constructor(request) {
         this.request = request;
     }
+    /**
+     * Get the request ip.
+     *
+     * @return string
+     */
     get ip() {
         return this.request.ip;
     }
+    /**
+     * Get the request method.
+     *
+     * @return string
+     */
     get method() {
         return this.request.method;
     }
+    /**
+     * Get the host url from request.
+     *
+     * @return string
+     */
     get hostUrl() {
         const url = this.request.url;
-        const port = config_1.Env('PORT', '1335');
-        let host = config_1.Env('APP_DOMAIN', `http://localhost:${port}`);
-        if (!utils_1.Is.Ip(host))
+        const port = config_1.Config.get('http.port', 1335);
+        let host = config_1.Config.get('http.domain', `http://localhost:${port}`);
+        if (!utils_1.Is.Ip(host) && !host.includes('localhost')) {
             host = host.replace(`:${port}`, '');
+        }
         return removeSlash_1.removeSlash(`${host}${url}`);
     }
+    /**
+     * Get the base request url.
+     *
+     * @return string
+     */
     get baseUrl() {
         return this.request.url.split('?')[0];
     }
+    /**
+     * Get the original request url.
+     *
+     * @return string
+     */
     get originalUrl() {
         return this.request.url;
     }
+    /**
+     * Get all body from request.
+     *
+     * @return any
+     */
     get body() {
         return this.request.body;
     }
+    /**
+     * Get all params from request.
+     *
+     * @return any
+     */
     get params() {
         return this.request.params;
     }
+    /**
+     * Get all queries from request.
+     *
+     * @return any
+     */
     get queries() {
         return this.request.query;
     }
+    /**
+     * Get all headers from request.
+     *
+     * @return any
+     */
     get headers() {
         return this.request.headers;
     }
+    /**
+     * Get a value from the request params or the default value.
+     *
+     * @return any
+     */
     param(param, defaultValue) {
         const params = this.request.params;
         return params[param] || defaultValue;
     }
+    /**
+     * Get a value from the request query param or the default value.
+     *
+     * @return any
+     */
     query(query, defaultValue) {
         const queries = this.request.query;
         return queries[query] || defaultValue;
     }
+    /**
+     * Get a value from the request header or the default value.
+     *
+     * @return any
+     */
     header(header, defaultValue) {
         const headers = this.request.headers;
         return headers[header] || defaultValue;
     }
+    /**
+     * Get a value from the request body or the default value.
+     *
+     * @return any
+     */
     payload(payload, defaultValue) {
         const body = this.request.body;
         return body[payload] || defaultValue;
     }
+    /**
+     * Get the default fastify request object.
+     *
+     * @return FastifyRequest
+     */
+    getFastifyRequest() {
+        return this.request;
+    }
 }
 exports.Request = Request;

package/src/Context/Response.d.ts

@@ -9,13 +9,69 @@
 import { FastifyReply } from 'fastify';
 import { ResponseContract } from '../Contracts/Context/ResponseContract';
 export declare class Response implements ResponseContract {
-    private response;
+    private readonly response;
+    /**
+     * Create a new instance of Response.
+     *
+     * @return Response
+     */
     constructor(response: FastifyReply);
-    send(data?: Record<string, any>): void;
-    json(data?: Record<string, any>): void;
+    /**
+     * Terminate the request sending the response body.
+     *
+     * @param data
+     * @return void
+     */
+    send(data?: any): void;
+    /**
+     * Terminate the request sending the response body.
+     *
+     * @param data
+     * @return void
+     */
+    json(data?: any): void;
+    /**
+     * Set the response status code.
+     *
+     * @param code
+     * @return Response
+     */
     status(code: number): this;
+    /**
+     * Remove some header from the response.
+     *
+     * @param header
+     * @return Response
+     */
     removeHeader(header: string): this;
+    /**
+     * Add some header to the response.
+     *
+     * @param header
+     * @param value
+     * @return Response
+     */
     header(header: string, value: any): this;
+    /**
+     * Only add some header to the response if it's not defined yet.
+     *
+     * @param header
+     * @param value
+     * @return Response
+     */
     safeHeader(header: string, value: any): this;
-    redirectTo(url: string, statusCode?: number): this;
+    /**
+     * Redirect the response to other url with different status code.
+     *
+     * @param url
+     * @param statusCode
+     * @return void
+     */
+    redirectTo(url: string, statusCode?: number): void;
+    /**
+     * Get the default fastify response object.
+     *
+     * @return FastifyReply
+     */
+    getFastifyResponse(): FastifyReply;
 }

package/src/Context/Response.js

@@ -10,40 +10,96 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Response = void 0;
 class Response {
+    /**
+     * Create a new instance of Response.
+     *
+     * @return Response
+     */
     constructor(response) {
         this.response = response;
     }
+    /**
+     * Terminate the request sending the response body.
+     *
+     * @param data
+     * @return void
+     */
     send(data) {
         this.response.send(data);
     }
+    /**
+     * Terminate the request sending the response body.
+     *
+     * @param data
+     * @return void
+     */
     json(data) {
-        this.response.serialize(data);
+        this.response.send(this.response.serialize(data));
     }
+    /**
+     * Set the response status code.
+     *
+     * @param code
+     * @return Response
+     */
     status(code) {
         this.response.status(code);
         return this;
     }
+    /**
+     * Remove some header from the response.
+     *
+     * @param header
+     * @return Response
+     */
     removeHeader(header) {
         this.response.removeHeader(header);
         return this;
     }
+    /**
+     * Add some header to the response.
+     *
+     * @param header
+     * @param value
+     * @return Response
+     */
     header(header, value) {
         this.response.header(header, value);
         return this;
     }
+    /**
+     * Only add some header to the response if it's not defined yet.
+     *
+     * @param header
+     * @param value
+     * @return Response
+     */
     safeHeader(header, value) {
         if (!this.response.hasHeader(header)) {
             this.response.header(header, value);
         }
         return this;
     }
+    /**
+     * Redirect the response to other url with different status code.
+     *
+     * @param url
+     * @param statusCode
+     * @return void
+     */
     redirectTo(url, statusCode) {
         if (statusCode) {
             this.response.redirect(statusCode, url);
-            return this;
         }
         this.response.redirect(url);
-        return this;
+    }
+    /**
+     * Get the default fastify response object.
+     *
+     * @return FastifyReply
+     */
+    getFastifyResponse() {
+        return this.response;
     }
 }
 exports.Response = Response;

package/src/Contracts/Context/ContextContract.d.ts

@@ -11,7 +11,7 @@ import { ResponseContract } from './ResponseContract';
 export interface ContextContract {
     request: RequestContract;
     response: ResponseContract;
-    params: Record<string, string>;
-    queries: Record<string, string>;
-    data: Record<string, any>;
+    data: any;
+    params: any;
+    queries: any;
 }

package/src/Contracts/Context/Middlewares/Handle/HandleContextContract.d.ts

@@ -12,8 +12,8 @@ import { ResponseContract } from '../../ResponseContract';
 export interface HandleContextContract {
     request: RequestContract;
     response: ResponseContract;
-    params: Record<string, string>;
-    queries: Record<string, string>;
-    data: Record<string, any>;
+    data: any;
+    params: any;
+    queries: any;
     next: NextContract;
 }

package/src/Contracts/Context/Middlewares/Intercept/InterceptContextContract.d.ts

@@ -9,8 +9,8 @@
 import { RequestContract } from '../../RequestContract';
 export interface InterceptContextContract {
     request: RequestContract;
-    params: Record<string, string>;
-    queries: Record<string, string>;
+    params: any;
+    queries: any;
     body: any;
     status: number;
     data: Record<string, any>;

package/src/Contracts/Context/Middlewares/Terminate/TerminateContextContract.d.ts

@@ -12,8 +12,8 @@ import { ResponseContract } from '../../ResponseContract';
 export interface TerminateContextContract {
     request: RequestContract;
     response: ResponseContract;
-    params: Record<string, string>;
-    queries: Record<string, string>;
-    data?: Record<string, any>;
+    data?: any;
+    params: any;
+    queries: any;
     next: NextContract;
 }

package/src/Contracts/Context/RequestContract.d.ts

@@ -6,18 +6,20 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
+import { FastifyRequest } from 'fastify';
 export interface RequestContract {
     ip: string;
     method: string;
     hostUrl: string;
     baseUrl: string;
     originalUrl: string;
-    body: Record<string, any>;
-    params: Record<string, string>;
-    queries: Record<string, string>;
-    headers: Record<string, string>;
+    body: any;
+    params: any;
+    queries: any;
+    headers: any;
     param(param: string, defaultValue?: string): string | undefined;
     query(query: string, defaultValue?: string): string | undefined;
     header(header: string, defaultValue?: string): string | string[] | undefined;
     payload(payload: string, defaultValue?: string): any | undefined;
+    getFastifyRequest(): FastifyRequest;
 }

package/src/Contracts/Context/ResponseContract.d.ts

@@ -1,3 +1,4 @@
+import { FastifyReply } from 'fastify';
 /**
  * @athenna/http
  *
@@ -7,12 +8,13 @@
  * file that was distributed with this source code.
  */
 export interface ResponseContract {
-    send(data?: Record<string, any>): Promise<void> | void;
-    json(data?: Record<string, any>): Promise<void> | void;
+    send(data?: any): Promise<void> | void;
+    json(data?: any): Promise<void> | void;
     status(code: number): this;
     removeHeader(header: string): this;
     header(header: string, value: any): this;
     safeHeader(header: string, value: any): this;
-    redirectTo(url: string): this;
-    redirectTo(url: string, statusCode: number): this;
+    redirectTo(url: string): Promise<void> | void;
+    redirectTo(url: string, statusCode: number): Promise<void> | void;
+    getFastifyResponse(): FastifyReply;
 }

package/src/Contracts/Context/ResponseContract.js

@@ -1,10 +1,2 @@
 "use strict";
-/**
- * @athenna/http
- *
- * (c) João Lenon <lenon@athenna.io>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
 Object.defineProperty(exports, "__esModule", { value: true });

package/src/Handlers/HttpErrorHandler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @athenna/http
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { ErrorContextContract } from '../Contracts/Context/Error/ErrorContextContract';
+export declare class HttpErrorHandler {
+    static handler({ error, request, response }: ErrorContextContract): void | Promise<void>;
+}

package/src/Handlers/HttpErrorHandler.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * @athenna/http
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpErrorHandler = void 0;
+const utils_1 = require("@secjs/utils");
+const logger_1 = require("@athenna/logger");
+const config_1 = require("@athenna/config");
+class HttpErrorHandler {
+    static handler({ error, request, response }) {
+        const code = error.code || error.name;
+        const statusCode = error.statusCode || error.status || 500;
+        const body = {
+            code: utils_1.String.toSnakeCase(code).toUpperCase(),
+            path: request.baseUrl,
+            method: request.method,
+            status: statusCode <= 399 ? 'SUCCESS' : 'ERROR',
+            statusCode: statusCode,
+            error: {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+            },
+        };
+        const isInternalServerError = statusCode === 500;
+        const isNotDebugMode = !config_1.Config.get('app.debug');
+        if (isInternalServerError && isNotDebugMode) {
+            body.error.name = 'Internal server error';
+            body.error.message =
+                'An internal server exception has occurred. Please contact administration of this service.';
+            delete body.error.stack;
+        }
+        new logger_1.Logger().error(`Error: ${JSON.stringify(body.error, null, 2)}`, {
+            context: HttpErrorHandler.name,
+        });
+        return response.status(statusCode).send(body);
+    }
+}
+exports.HttpErrorHandler = HttpErrorHandler;

package/src/Http.d.ts

@@ -16,22 +16,133 @@ import { HandleHandlerContract } from './Contracts/Context/Middlewares/Handle/Ha
 import { InterceptHandlerContract } from './Contracts/Context/Middlewares/Intercept/InterceptHandlerContract';
 import { TerminateHandlerContract } from './Contracts/Context/Middlewares/Terminate/TerminateHandlerContract';
 export declare class Http {
+    /**
+     * Holds the fastify server instance.
+     *
+     * @private
+     */
     private readonly server;
+    /**
+     * Instantiate Http class and fastify server.
+     *
+     * @return Http
+     */
     constructor();
+    /**
+     * Set the fastify error handler.
+     *
+     * @return Http
+     */
     setErrorHandler(handler: ErrorHandlerContract): void;
+    /**
+     * Get the fastify server instance.
+     *
+     * @return FastifyInstance
+     */
     getServer(): FastifyInstance;
+    /**
+     * Print all routes registered
+     *
+     * @param options {PrintRoutesOptions}
+     * @return string
+     */
     getRoutes(options?: PrintRoutesOptions): string;
+    /**
+     * Print all routes registered.
+     *
+     * @param handler {HandleHandlerContract,InterceptHandlerContract,TerminateHandlerContract}
+     * @param type {handle,intercept,terminate}
+     * @return void
+     */
     use(handler: HandleHandlerContract | InterceptHandlerContract | TerminateHandlerContract, type?: 'handle' | 'intercept' | 'terminate'): void;
     request(): LightMyRequest.Chain;
     request(options: InjectOptions | string): Promise<LightMyRequest.Response>;
+    /**
+     * Boot the http server to start listening on port and host defined.
+     *
+     * @param port {string,number}
+     * @param host {string}
+     * @return void
+     */
     listen(port?: string | number, host?: string): Promise<string>;
+    /**
+     * Close the http server.
+     *
+     * @param cb {any}
+     * @return Promise<void>
+     */
     close(cb?: any): Promise<void>;
+    /**
+     * Add a new route to the http server.
+     *
+     * @param url {string}
+     * @param methods {HttpMethodTypes[]}
+     * @param handler {HandlerContract}
+     * @param middlewares {MiddlewareTypesContract}
+     * @return void
+     */
     route(url: string, methods: HttpMethodTypes[], handler: HandlerContract, middlewares?: MiddlewareTypesContract): void;
+    /**
+     * Add a new GET route to the http server.
+     *
+     * @param url {string}
+     * @param handler {HandlerContract}
+     * @param middlewares {MiddlewareTypesContract}
+     * @return void
+     */
     get(url: string, handler: HandlerContract, middlewares?: MiddlewareTypesContract): void;
+    /**
+     * Add a new HEAD route to the http server.
+     *
+     * @param url {string}
+     * @param handler {HandlerContract}
+     * @param middlewares {MiddlewareTypesContract}
+     * @return void
+     */
     head(url: string, handler: HandlerContract, middlewares?: MiddlewareTypesContract): void;
+    /**
+     * Add a new POST route to the http server.
+     *
+     * @param url {string}
+     * @param handler {HandlerContract}
+     * @param middlewares {MiddlewareTypesContract}
+     * @return void
+     */
     post(url: string, handler: HandlerContract, middlewares?: MiddlewareTypesContract): void;
+    /**
+     * Add a new PUT route to the http server.
+     *
+     * @param url {string}
+     * @param handler {HandlerContract}
+     * @param middlewares {MiddlewareTypesContract}
+     * @return void
+     */
     put(url: string, handler: HandlerContract, middlewares?: MiddlewareTypesContract): void;
+    /**
+     * Add a new PATCH route to the http server.
+     *
+     * @param url {string}
+     * @param handler {HandlerContract}
+     * @param middlewares {MiddlewareTypesContract}
+     * @return void
+     */
     patch(url: string, handler: HandlerContract, middlewares?: MiddlewareTypesContract): void;
+    /**
+     * Add a new DELETE route to the http server.
+     *
+     * @param url {string}
+     * @param handler {HandlerContract}
+     * @param middlewares {MiddlewareTypesContract}
+     * @return void
+     */
     delete(url: string, handler: HandlerContract, middlewares?: MiddlewareTypesContract): void;
+    /**
+     * Add a new OPTIONS route to the http server.
+     *
+     * @param url {string}
+     * @param handler {HandlerContract}
+     * @param middlewares {MiddlewareTypesContract}
+     * @return void
+     */
     options(url: string, handler: HandlerContract, middlewares?: MiddlewareTypesContract): void;
 }

package/src/Http.js

@@ -15,19 +15,47 @@ exports.Http = void 0;
 const fastify_1 = __importDefault(require("fastify"));
 const FastifyHandler_1 = require("./Utils/FastifyHandler");
 class Http {
+    /**
+     * Instantiate Http class and fastify server.
+     *
+     * @return Http
+     */
     constructor() {
         this.server = fastify_1.default();
     }
+    /**
+     * Set the fastify error handler.
+     *
+     * @return Http
+     */
     setErrorHandler(handler) {
         const fastifyErrorHandler = FastifyHandler_1.FastifyHandler.createErrorHandler(handler);
         this.server.setErrorHandler(fastifyErrorHandler);
     }
+    /**
+     * Get the fastify server instance.
+     *
+     * @return FastifyInstance
+     */
     getServer() {
         return this.server;
     }
+    /**
+     * Print all routes registered
+     *
+     * @param options {PrintRoutesOptions}
+     * @return string
+     */
     getRoutes(options) {
         return this.server.printRoutes(options);
     }
+    /**
+     * Print all routes registered.
+     *
+     * @param handler {HandleHandlerContract,InterceptHandlerContract,TerminateHandlerContract}
+     * @param type {handle,intercept,terminate}
+     * @return void
+     */
     use(handler, type = 'handle') {
         let hookName = 'preHandler';
         let handlerType = 'createDoneHandler';
@@ -43,6 +71,12 @@ class Http {
         }
         this.server.addHook(hookName, FastifyHandler_1.FastifyHandler[handlerType](handler));
     }
+    /**
+     * Return a request handler to make internal requests to the Http server.
+     *
+     * @param options {InjectOptions,string}
+     * @return {LightMyRequest.Chain,Promise<LightMyRequest.Response>}
+     */
     request(options) {
         const server = this.getServer();
         if (!options) {
@@ -50,9 +84,22 @@ class Http {
         }
         return server.inject(options);
     }
+    /**
+     * Boot the http server to start listening on port and host defined.
+     *
+     * @param port {string,number}
+     * @param host {string}
+     * @return void
+     */
     async listen(port, host) {
         return this.server.listen(port || 1335, host || 'localhost');
     }
+    /**
+     * Close the http server.
+     *
+     * @param cb {any}
+     * @return Promise<void>
+     */
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     async close(cb) {
         if (cb) {
@@ -60,6 +107,15 @@ class Http {
         }
         return this.server.close();
     }
+    /**
+     * Add a new route to the http server.
+     *
+     * @param url {string}
+     * @param methods {HttpMethodTypes[]}
+     * @param handler {HandlerContract}
+     * @param middlewares {MiddlewareTypesContract}
+     * @return void
+     */
     route(url, methods, handler, middlewares) {
         const { handlers, terminators, interceptors } = Object.assign({}, { handlers: [], terminators: [], interceptors: [] }, middlewares);
         this.server.route({
@@ -71,24 +127,80 @@ class Http {
             onSend: interceptors.map(m => FastifyHandler_1.FastifyHandler.createOnSendHandler(m)),
         });
     }
+    /**
+     * Add a new GET route to the http server.
+     *
+     * @param url {string}
+     * @param handler {HandlerContract}
+     * @param middlewares {MiddlewareTypesContract}
+     * @return void
+     */
     get(url, handler, middlewares) {
         this.route(url, ['GET'], handler, middlewares);
     }
+    /**
+     * Add a new HEAD route to the http server.
+     *
+     * @param url {string}
+     * @param handler {HandlerContract}
+     * @param middlewares {MiddlewareTypesContract}
+     * @return void
+     */
     head(url, handler, middlewares) {
         this.route(url, ['HEAD'], handler, middlewares);
     }
+    /**
+     * Add a new POST route to the http server.
+     *
+     * @param url {string}
+     * @param handler {HandlerContract}
+     * @param middlewares {MiddlewareTypesContract}
+     * @return void
+     */
     post(url, handler, middlewares) {
         this.route(url, ['POST'], handler, middlewares);
     }
+    /**
+     * Add a new PUT route to the http server.
+     *
+     * @param url {string}
+     * @param handler {HandlerContract}
+     * @param middlewares {MiddlewareTypesContract}
+     * @return void
+     */
     put(url, handler, middlewares) {
         this.route(url, ['PUT'], handler, middlewares);
     }
+    /**
+     * Add a new PATCH route to the http server.
+     *
+     * @param url {string}
+     * @param handler {HandlerContract}
+     * @param middlewares {MiddlewareTypesContract}
+     * @return void
+     */
     patch(url, handler, middlewares) {
         this.route(url, ['PATCH'], handler, middlewares);
     }
+    /**
+     * Add a new DELETE route to the http server.
+     *
+     * @param url {string}
+     * @param handler {HandlerContract}
+     * @param middlewares {MiddlewareTypesContract}
+     * @return void
+     */
     delete(url, handler, middlewares) {
         this.route(url, ['DELETE'], handler, middlewares);
     }
+    /**
+     * Add a new OPTIONS route to the http server.
+     *
+     * @param url {string}
+     * @param handler {HandlerContract}
+     * @param middlewares {MiddlewareTypesContract}
+     * @return void
+     */
     options(url, handler, middlewares) {
         this.route(url, ['OPTIONS'], handler, middlewares);
     }

package/src/Kernels/HttpKernel.d.ts

@@ -8,11 +8,25 @@ export declare abstract class HttpKernel {
      *
      * This middlewares are run during every request to your http server.
      */
-    protected abstract globalMiddlewares: MiddlewareContractClass[];
+    protected abstract globalMiddlewares: MiddlewareContractClass[] | Promise<any>[];
     /**
      * The application's named HTTP middlewares.
      *
      * Here you define all your named middlewares to use inside routes/http file.
      */
-    protected abstract namedMiddlewares: Record<string, MiddlewareContractClass>;
+    protected abstract namedMiddlewares: Record<string, Promise<any> | MiddlewareContractClass>;
+    /**
+     * Returns an instance of any class that extends HttpKernel.
+     * Also configure the error handler, detect environment and
+     * configure log intercept middleware for requests.
+     *
+     * @return HttpKernel
+     */
+    constructor();
+    /**
+     * Register all global and named middlewares to the server.
+     *
+     * @return void
+     */
+    registerMiddlewares(): Promise<void>;
 }

package/src/Kernels/HttpKernel.js

@@ -1,6 +1,66 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpKernel = void 0;
+const config_1 = require("@athenna/config");
+const logger_1 = require("@athenna/logger");
+const HttpErrorHandler_1 = require("../Handlers/HttpErrorHandler");
+const utils_1 = require("@secjs/utils");
 class HttpKernel {
+    /**
+     * Returns an instance of any class that extends HttpKernel.
+     * Also configure the error handler, detect environment and
+     * configure log intercept middleware for requests.
+     *
+     * @return HttpKernel
+     */
+    constructor() {
+        const httpServer = ioc.safeUse('Athenna/Core/HttpServer');
+        httpServer.setErrorHandler(HttpErrorHandler_1.HttpErrorHandler.handler);
+        if (config_1.Config.get('http.log')) {
+            httpServer.use(async (ctx) => {
+                await new logger_1.Logger().channel('requests').log(ctx);
+                return ctx.body;
+            }, 'intercept');
+        }
+    }
+    /**
+     * Register all global and named middlewares to the server.
+     *
+     * @return void
+     */
+    async registerMiddlewares() {
+        const httpServer = ioc.safeUse('Athenna/Core/HttpServer');
+        /**
+         * Binding the named middlewares inside the container and
+         * creating a simple alias to use it inside Route.
+         */
+        for (const key of Object.keys(this.namedMiddlewares)) {
+            const Middleware = utils_1.resolveModule(await this.namedMiddlewares[key]);
+            if (!ioc.hasDependency(`App/Middlewares/${Middleware.name}`)) {
+                ioc.bind(`App/Middlewares/${Middleware.name}`, Middleware);
+            }
+            ioc.alias(`App/Middlewares/Names/${key}`, `App/Middlewares/${Middleware.name}`);
+        }
+        /**
+         * Binding the global middlewares inside the container and
+         * resolving it inside the Http server using "use" method.
+         */
+        for (const module of this.globalMiddlewares) {
+            let Middleware = utils_1.resolveModule(await module);
+            if (!ioc.hasDependency(`App/Middlewares/${Middleware.name}`)) {
+                ioc.bind(`App/Middlewares/${Middleware.name}`, Middleware);
+            }
+            Middleware = ioc.safeUse(`App/Middlewares/${Middleware.name}`);
+            if (Middleware.handle) {
+                httpServer.use(Middleware.handle, 'handle');
+            }
+            if (Middleware.intercept) {
+                httpServer.use(Middleware.intercept, 'intercept');
+            }
+            if (Middleware.terminate) {
+                httpServer.use(Middleware.terminate, 'terminate');
+            }
+        }
+    }
 }
 exports.HttpKernel = HttpKernel;

package/src/Utils/FastifyHandler.d.ts

@@ -20,7 +20,7 @@ declare module 'fastify' {
 export declare class FastifyHandler {
     static createOnSendHandler(handler: InterceptHandlerContract): (req: any, _res: any, payload: any) => Promise<any>;
     static createDoneHandler(handler: HandleHandlerContract): (req: any, res: any, done: any) => any;
-    static createResponseHandler(handler: TerminateHandlerContract): (req: any, res: any, done: any) => any;
+    static createResponseHandler(handler: TerminateHandlerContract): (req: any, res: FastifyReply, done: any) => any;
     static createErrorHandler(handler: ErrorHandlerContract): (error: any, req: FastifyRequest, res: FastifyReply) => any;
     static createRequestHandler(handler: HandlerContract): (req: FastifyRequest, res: FastifyReply) => Promise<any>;
 }