@athenna/http 3.0.11 → 3.1.0

package/build/Handlers/HttpExceptionHandler.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @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;
+    /**
+     * Returns a boolean indicating if the error is an internal server error.
+     */
+    private isInternalServerError;
+}

package/build/Handlers/HttpExceptionHandler.js

@@ -0,0 +1,82 @@
+/**
+ * @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 { 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 = this.isInternalServerError(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 (!error.prettify) {
+            error = error.toAthennaException();
+        }
+        Log.channelOrVanilla('exception').error((await error.prettify()).concat('\n'));
+    }
+    /**
+     * 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;
+    }
+    /**
+     * Returns a boolean indicating if the error is an internal server error.
+     */
+    isInternalServerError(error) {
+        return [
+            'Error',
+            'URIError',
+            'TypeError',
+            'EvalError',
+            'RangeError',
+            'SyntaxError',
+            'InternalError',
+            'ReferenceError',
+        ].includes(error.name);
+    }
+}

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 resolvePathAndImport;
+}

package/build/Kernels/HttpKernel.js

@@ -0,0 +1,221 @@
+/**
+ * @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 { resolve } from 'node:path';
+import { Log } from '@athenna/logger';
+import { pathToFileURL } from 'node:url';
+import { Config } from '@athenna/config';
+import { Is, Module } from '@athenna/common';
+import { HttpExceptionHandler } from '#src/Handlers/HttpExceptionHandler';
+export class HttpKernel {
+    /**
+     * Register the @fastify/cors plugin in the Http server.
+     */
+    async registerCors() {
+        if (!Config.exists('http.cors')) {
+            return;
+        }
+        await Server.plugin(import('@fastify/cors'), Config.get('http.cors'));
+    }
+    /**
+     * Register the @fastify/helmet plugin in the Http server.
+     */
+    async registerHelmet() {
+        if (!Config.exists('http.helmet')) {
+            return;
+        }
+        await Server.plugin(import('@fastify/helmet'), Config.get('http.helmet'));
+    }
+    /**
+     * Register the @fastify/swagger plugin in the Http server.
+     */
+    async registerSwagger() {
+        if (!Config.exists('http.swagger')) {
+            return;
+        }
+        await Server.plugin(import('@fastify/swagger'), Config.get('http.swagger.configurations'));
+        await Server.plugin(import('@fastify/swagger-ui'), Config.get('http.swagger.ui'));
+    }
+    /**
+     * Register the @fastify/rate-limit plugin in the Http server.
+     */
+    async registerRateLimit() {
+        if (!Config.exists('http.rateLimit')) {
+            return;
+        }
+        await Server.plugin(import('@fastify/rate-limit'), Config.get('http.rateLimit'));
+    }
+    /**
+     * Register the cls-rtracer plugin in the Http server.
+     */
+    async registerRTracer() {
+        if (!Config.exists('http.rTracer')) {
+            return;
+        }
+        const rTracer = await import('cls-rtracer');
+        Server.middleware(async (ctx) => (ctx.data.traceId = rTracer.id()));
+        await Server.plugin(rTracer.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', []);
+        const promises = controllers.map(path => this.resolvePathAndImport(path).then(Controller => {
+            if (Reflect.hasMetadata('provider:registered', Controller)) {
+                return;
+            }
+            const createCamelAlias = false;
+            const alias = `App/Http/Controllers/${Controller.name}`;
+            ioc.bind(alias, Controller, createCamelAlias);
+        }));
+        await Promise.all(promises);
+    }
+    /**
+     * 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 Promise.all(Config.get('rc.middlewares').map(this.resolvePathAndImport));
+        }
+    }
+    /**
+     * Register all the named middlewares found inside "rc.namedMiddlewares"
+     * property.
+     */
+    async registerNamedMiddlewares() {
+        const namedMiddlewares = Config.get('rc.namedMiddlewares');
+        if (Is.Empty(namedMiddlewares)) {
+            return;
+        }
+        const promises = Object.keys(namedMiddlewares).map(key => this.resolvePathAndImport(namedMiddlewares[key]).then(Middleware => {
+            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);
+        }));
+        await Promise.all(promises);
+    }
+    /**
+     * Register all the named middlewares found inside "rc.globalMiddlewares"
+     * property.
+     */
+    async registerGlobalMiddlewares() {
+        const globalMiddlewares = Config.get('rc.globalMiddlewares');
+        if (Is.Empty(globalMiddlewares)) {
+            return;
+        }
+        const promises = globalMiddlewares.map(path => this.resolvePathAndImport(path).then(Middleware => {
+            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]);
+        }));
+        await Promise.all(promises);
+    }
+    /**
+     * 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.resolvePathAndImport(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.
+     */
+    resolvePathAndImport(path) {
+        if (path.includes('./') || path.includes('../')) {
+            path = resolve(path);
+        }
+        if (!path.startsWith('#')) {
+            path = pathToFileURL(path).href;
+        }
+        return import.meta
+            .resolve(path, Config.get('rc.meta'))
+            .then(meta => Module.get(import(`${meta}?version=${Math.random()}`)));
+    }
+}

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();
+    }
+}