@athenna/http 3.0.11 → 3.1.1

package/build/Handlers/HttpExceptionHandler.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @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 { ErrorContext } from '#src';
+export declare class HttpExceptionHandler {
+    /**
+     * Error codes that should be ignored from logging.
+     */
+    get ignoreCodes(): string[];
+    /**
+     * Error statuses that should be ignored from logging.
+     */
+    get ignoreStatuses(): number[];
+    /**
+     * The exception handler of all request handlers.
+     */
+    handle({ error, response }: ErrorContext): Promise<void>;
+    /**
+     * Return a boolean indicating if the error can be logged or not.
+     */
+    private canBeLogged;
+}

package/build/Handlers/HttpExceptionHandler.js

@@ -0,0 +1,67 @@
+/**
+ * @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 { Log } from '@athenna/logger';
+import { Is, String } from '@athenna/common';
+export class HttpExceptionHandler {
+    /**
+     * Error codes that should be ignored from logging.
+     */
+    get ignoreCodes() {
+        return [];
+    }
+    /**
+     * Error statuses that should be ignored from logging.
+     */
+    get ignoreStatuses() {
+        return [];
+    }
+    /**
+     * The exception handler of all request handlers.
+     */
+    async handle({ error, response }) {
+        const body = {
+            statusCode: error.statusCode || error.status || 500,
+            code: String.toSnakeCase(error.code || error.name).toUpperCase(),
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+        };
+        if (error.help) {
+            body.help = error.help;
+        }
+        const isInternalServerError = Is.Error(error) && !Is.Exception(error);
+        const isDebugMode = Config.is('app.debug', true);
+        if (isInternalServerError && !isDebugMode) {
+            body.code = 'E_INTERNAL_SERVER';
+            body.name = 'InternalServerException';
+            body.message = 'An internal server exception has occurred.';
+            delete body.stack;
+        }
+        response.status(body.statusCode).send(body);
+        if (!this.canBeLogged(error)) {
+            return;
+        }
+        if (!Is.Exception(error)) {
+            error = error.toAthennaException();
+        }
+        Log.channelOrVanilla('exception').error(await error.prettify());
+    }
+    /**
+     * Return a boolean indicating if the error can be logged or not.
+     */
+    canBeLogged(error) {
+        if (this.ignoreCodes.includes(error.code)) {
+            return false;
+        }
+        if (this.ignoreStatuses.includes(error.status || error.statusCode)) {
+            return false;
+        }
+        return true;
+    }
+}

package/build/Kernels/HttpKernel.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @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 'reflect-metadata';
+export declare class HttpKernel {
+    /**
+     * Register the @fastify/cors plugin in the Http server.
+     */
+    registerCors(): Promise<void>;
+    /**
+     * Register the @fastify/helmet plugin in the Http server.
+     */
+    registerHelmet(): Promise<void>;
+    /**
+     * Register the @fastify/swagger plugin in the Http server.
+     */
+    registerSwagger(): Promise<void>;
+    /**
+     * Register the @fastify/rate-limit plugin in the Http server.
+     */
+    registerRateLimit(): Promise<void>;
+    /**
+     * Register the cls-rtracer plugin in the Http server.
+     */
+    registerRTracer(): Promise<void>;
+    /**
+     * Register the global log terminator in the Http server.
+     */
+    registerLoggerTerminator(): Promise<void>;
+    /**
+     * Register all the controllers found inside "rc.controllers" config
+     * inside the service provider.
+     */
+    registerControllers(): Promise<void>;
+    /**
+     * Register all the middlewares found inside "rc.middlewares" config
+     * inside the service provider. Also register if "rc.namedMiddlewares"
+     * and "rc.globalMiddlewares" exists.
+     */
+    registerMiddlewares(): Promise<void>;
+    /**
+     * Register all the named middlewares found inside "rc.namedMiddlewares"
+     * property.
+     */
+    registerNamedMiddlewares(): Promise<void>;
+    /**
+     * Register all the named middlewares found inside "rc.globalMiddlewares"
+     * property.
+     */
+    registerGlobalMiddlewares(): Promise<void>;
+    /**
+     * Register the exception handler for all request handlers.
+     */
+    registerExceptionHandler(path?: string): Promise<void>;
+    /**
+     * Fabricate the named middlewares aliases.
+     */
+    private getNamedMiddlewareAlias;
+    /**
+     * Fabricate the global middlewares alias and resolve the handler and
+     * server methods.
+     */
+    private getGlobalMiddlewareAliasAndHandler;
+    /**
+     * Resolve the import path by meta URL and import it.
+     */
+    private resolvePath;
+}

package/build/Kernels/HttpKernel.js

@@ -0,0 +1,217 @@
+/**
+ * @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 'reflect-metadata';
+import { Server } from '#src';
+import { Log } from '@athenna/logger';
+import { Config } from '@athenna/config';
+import { Exec, Is, Module } 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 rTracerPlugin = await Module.safeImport('cls-rtracer');
+export class HttpKernel {
+    /**
+     * Register the @fastify/cors plugin in the Http server.
+     */
+    async registerCors() {
+        if (!corsPlugin) {
+            return;
+        }
+        await Server.plugin(corsPlugin, Config.get('http.cors'));
+    }
+    /**
+     * Register the @fastify/helmet plugin in the Http server.
+     */
+    async registerHelmet() {
+        if (!helmetPlugin) {
+            return;
+        }
+        await Server.plugin(helmetPlugin, Config.get('http.helmet'));
+    }
+    /**
+     * Register the @fastify/swagger plugin in the Http server.
+     */
+    async registerSwagger() {
+        if (swaggerPlugin) {
+            await Server.plugin(swaggerPlugin, Config.get('http.swagger.configurations'));
+        }
+        if (swaggerUiPlugin) {
+            await Server.plugin(swaggerUiPlugin, Config.get('http.swagger.ui'));
+        }
+    }
+    /**
+     * Register the @fastify/rate-limit plugin in the Http server.
+     */
+    async registerRateLimit() {
+        if (!rateLimitPlugin) {
+            return;
+        }
+        await Server.plugin(rateLimitPlugin, Config.get('http.rateLimit'));
+    }
+    /**
+     * Register the cls-rtracer plugin in the Http server.
+     */
+    async registerRTracer() {
+        if (!rTracerPlugin) {
+            return;
+        }
+        Server.middleware(async (ctx) => (ctx.data.traceId = rTracerPlugin.id()));
+        await Server.plugin(rTracerPlugin.fastifyPlugin, Config.get('http.rTracer'));
+    }
+    /**
+     * Register the global log terminator in the Http server.
+     */
+    async registerLoggerTerminator() {
+        if (!Config.exists('http.logger') || Config.is('http.logger', false)) {
+            return;
+        }
+        Server.terminate(ctx => Log.channelOrVanilla('request').info(ctx));
+    }
+    /**
+     * Register all the controllers found inside "rc.controllers" config
+     * inside the service provider.
+     */
+    async registerControllers() {
+        const controllers = Config.get('rc.controllers', []);
+        await Exec.concurrently(controllers, async (path) => {
+            const Controller = await this.resolvePath(path);
+            if (Reflect.hasMetadata('provider:registered', Controller)) {
+                return;
+            }
+            const createCamelAlias = false;
+            const alias = `App/Http/Controllers/${Controller.name}`;
+            ioc.bind(alias, Controller, createCamelAlias);
+        });
+    }
+    /**
+     * Register all the middlewares found inside "rc.middlewares" config
+     * inside the service provider. Also register if "rc.namedMiddlewares"
+     * and "rc.globalMiddlewares" exists.
+     */
+    async registerMiddlewares() {
+        await this.registerNamedMiddlewares();
+        await this.registerGlobalMiddlewares();
+        if (Config.exists('rc.middlewares')) {
+            await Exec.concurrently(Config.get('rc.middlewares'), this.resolvePath);
+        }
+    }
+    /**
+     * Register all the named middlewares found inside "rc.namedMiddlewares"
+     * property.
+     */
+    async registerNamedMiddlewares() {
+        const namedMiddlewares = Config.get('rc.namedMiddlewares');
+        if (Is.Empty(namedMiddlewares)) {
+            return;
+        }
+        await Exec.concurrently(Object.keys(namedMiddlewares), async (key) => {
+            const Middleware = await this.resolvePath(namedMiddlewares[key]);
+            if (Reflect.hasMetadata('provider:registered', Middleware)) {
+                return;
+            }
+            const createCamelAlias = false;
+            const { alias, namedAlias } = this.getNamedMiddlewareAlias(key, Middleware);
+            ioc.bind(alias, Middleware, createCamelAlias).alias(namedAlias, alias);
+        });
+    }
+    /**
+     * Register all the named middlewares found inside "rc.globalMiddlewares"
+     * property.
+     */
+    async registerGlobalMiddlewares() {
+        const globalMiddlewares = Config.get('rc.globalMiddlewares');
+        if (Is.Empty(globalMiddlewares)) {
+            return;
+        }
+        await Exec.concurrently(globalMiddlewares, async (path) => {
+            const Middleware = await this.resolvePath(path);
+            if (Reflect.hasMetadata('provider:registered', Middleware)) {
+                return;
+            }
+            const createCamelAlias = false;
+            const { alias, handler, serverMethod } = this.getGlobalMiddlewareAliasAndHandler(Middleware);
+            ioc.bind(alias, Middleware, createCamelAlias);
+            Server[serverMethod](ioc.safeUse(alias)[handler]);
+        });
+    }
+    /**
+     * Register the exception handler for all request handlers.
+     */
+    async registerExceptionHandler(path) {
+        if (!path) {
+            const handler = new HttpExceptionHandler();
+            Server.setErrorHandler(handler.handle.bind(handler));
+            return;
+        }
+        const Handler = await this.resolvePath(path);
+        const handler = new Handler();
+        Server.setErrorHandler(handler.handle.bind(handler));
+    }
+    /**
+     * Fabricate the named middlewares aliases.
+     */
+    getNamedMiddlewareAlias(name, Middleware) {
+        const middleware = new Middleware();
+        if (middleware.handle) {
+            return {
+                alias: `App/Http/Middlewares/${Middleware.name}`,
+                namedAlias: `App/Http/Middlewares/Names/${name}`,
+            };
+        }
+        if (middleware.intercept) {
+            return {
+                alias: `App/Http/Interceptors/${Middleware.name}`,
+                namedAlias: `App/Http/Interceptors/Names/${name}`,
+            };
+        }
+        if (middleware.terminate) {
+            return {
+                alias: `App/Http/Terminators/${Middleware.name}`,
+                namedAlias: `App/Http/Terminators/Names/${name}`,
+            };
+        }
+    }
+    /**
+     * Fabricate the global middlewares alias and resolve the handler and
+     * server methods.
+     */
+    getGlobalMiddlewareAliasAndHandler(Middleware) {
+        const middleware = new Middleware();
+        if (middleware.handle) {
+            return {
+                handler: 'handle',
+                serverMethod: 'middleware',
+                alias: `App/Http/Middlewares/${Middleware.name}`,
+            };
+        }
+        if (middleware.intercept) {
+            return {
+                handler: 'intercept',
+                serverMethod: 'intercept',
+                alias: `App/Http/Interceptors/${Middleware.name}`,
+            };
+        }
+        if (middleware.terminate) {
+            return {
+                handler: 'terminate',
+                serverMethod: 'terminate',
+                alias: `App/Http/Terminators/${Middleware.name}`,
+            };
+        }
+    }
+    /**
+     * Resolve the import path by meta URL and import it.
+     */
+    resolvePath(path) {
+        return Module.resolve(`${path}?version=${Math.random()}`, Config.get('rc.meta'));
+    }
+}

package/build/Providers/HttpRouteProvider.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 { ServiceProvider } from '@athenna/ioc';
+export declare class HttpRouteProvider extends ServiceProvider {
+    register(): void;
+}

package/build/Providers/HttpRouteProvider.js

@@ -0,0 +1,15 @@
+/**
+ * @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 { Router } from '#src/Router/Router';
+import { ServiceProvider } from '@athenna/ioc';
+export class HttpRouteProvider extends ServiceProvider {
+    register() {
+        this.container.instance('Athenna/Core/HttpRoute', new Router(), false);
+    }
+}

package/build/Providers/HttpServerProvider.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @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 { ServiceProvider } from '@athenna/ioc';
+export declare class HttpServerProvider extends ServiceProvider {
+    register(): void;
+    shutdown(): Promise<void>;
+}

package/build/Providers/HttpServerProvider.js

@@ -0,0 +1,25 @@
+/**
+ * @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 { ServerImpl } from '#src/Server/ServerImpl';
+import { ServiceProvider } from '@athenna/ioc';
+export class HttpServerProvider extends ServiceProvider {
+    register() {
+        this.container.instance('Athenna/Core/HttpServer', new ServerImpl(), false);
+    }
+    async shutdown() {
+        const Server = this.container.use('Athenna/Core/HttpServer');
+        if (!Server) {
+            return;
+        }
+        if (!Server.isListening) {
+            return;
+        }
+        await Server.close();
+    }
+}