@carno.js/core 0.2.3

package/dist/Carno.d.ts

@@ -0,0 +1,65 @@
+import { Server } from "bun";
+import { ValidatorOptions } from "class-validator";
+import * as pino from "pino";
+import { TokenRouteWithProvider } from "./container/ContainerConfiguration";
+import { CorsConfig } from "./domain/cors-config";
+import Memoirist from "./route/memoirist";
+export interface ApplicationConfig {
+    validation?: ValidatorOptions;
+    logger?: pino.LoggerOptions;
+    exports?: any[];
+    providers?: any[];
+    cors?: CorsConfig;
+    globalMiddlewares?: any[];
+}
+export declare class Carno {
+    config: ApplicationConfig;
+    router: Memoirist<TokenRouteWithProvider>;
+    private injector;
+    private fetch;
+    private server;
+    constructor(config?: ApplicationConfig);
+    /**
+     * Use the Carno plugin.
+     *
+     * @param plugin
+     */
+    use(plugin: Carno): this;
+    private findProviderInConfig;
+    private getProviderToken;
+    private shouldCloneProvider;
+    private cloneProvider;
+    /**
+     * Set the custom logger provider.
+     * The provider must be a class with the @Service() decorator.
+     * The provider must extend the LoggerService class.
+     *
+     * @param provider
+     */
+    useLogger(provider: any): this;
+    private loadProvidersAndControllers;
+    private registerControllers;
+    private registerMetadataProviders;
+    private registerConfigProviders;
+    private normalizeProvider;
+    init(): Promise<void>;
+    listen(port?: number): Promise<void>;
+    private registerShutdownHandlers;
+    getHttpServer(): Server<any>;
+    getInjector(): import(".").InjectorService;
+    private createHttpServer;
+    private fetcher;
+    private catcher;
+    private bootstrapApplication;
+    private handleShutdownHook;
+    private closeHttpServer;
+    private exitProcess;
+    private reportHookFailure;
+    private isCorsEnabled;
+    private isOriginAllowed;
+    private buildCorsHeaders;
+    private handlePreflightRequest;
+    private applyCorsHeaders;
+    close(closeActiveConnections?: boolean): void;
+    private discoverRoutePath;
+}

package/dist/Carno.js

@@ -0,0 +1,307 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Carno = void 0;
+const node_process_1 = __importDefault(require("node:process"));
+const index_1 = require("./commons/index");
+const constants_1 = require("./constants");
+const createContainer_1 = require("./container/createContainer");
+const createInjector_1 = require("./container/createInjector");
+const domain_1 = require("./domain");
+const Context_1 = require("./domain/Context");
+const LocalsContainer_1 = require("./domain/LocalsContainer");
+const cors_config_1 = require("./domain/cors-config");
+const on_event_1 = require("./events/on-event");
+const HttpException_1 = require("./exceptions/HttpException");
+const RouteExecutor_1 = require("./route/RouteExecutor");
+const memoirist_1 = __importDefault(require("./route/memoirist"));
+const logger_service_1 = require("./services/logger.service");
+const parseUrl = require("parseurl-fast");
+// todo: change console.log for LoggerService.
+class Carno {
+    constructor(config = {}) {
+        this.config = config;
+        this.router = new memoirist_1.default();
+        this.injector = (0, createInjector_1.createInjector)();
+        this.fetch = async (request, server) => {
+            try {
+                return await this.fetcher(request, server);
+            }
+            catch (error) {
+                if (error instanceof HttpException_1.HttpException) {
+                    let response = new Response(JSON.stringify({
+                        message: error.getResponse(),
+                        statusCode: error.getStatus(),
+                    }), {
+                        status: error.statusCode,
+                        headers: { "Content-Type": "application/json" },
+                    });
+                    if (this.isCorsEnabled()) {
+                        const origin = request.headers.get("origin");
+                        if (origin && this.isOriginAllowed(origin)) {
+                            response = this.applyCorsHeaders(response, origin);
+                        }
+                    }
+                    return response;
+                }
+                throw error;
+            }
+        };
+        this.catcher = (error) => {
+            console.error("Unhandled error:", error);
+            return new Response("Internal Server Error", { status: 500 });
+        };
+        void this.bootstrapApplication();
+    }
+    /**
+     * Use the Carno plugin.
+     *
+     * @param plugin
+     */
+    use(plugin) {
+        if (!this.config.providers) {
+            this.config.providers = [];
+        }
+        if (!this.config.globalMiddlewares) {
+            this.config.globalMiddlewares = [];
+        }
+        for (const exportProvider of plugin.config.exports || []) {
+            const existingProvider = this.findProviderInConfig(plugin, exportProvider);
+            const providerToAdd = this.shouldCloneProvider(existingProvider)
+                ? this.cloneProvider(existingProvider)
+                : exportProvider;
+            this.config.providers.push(providerToAdd);
+        }
+        if (plugin.config.globalMiddlewares) {
+            this.config.globalMiddlewares.push(...plugin.config.globalMiddlewares);
+        }
+        return this;
+    }
+    findProviderInConfig(plugin, exportProvider) {
+        return plugin.config.providers?.find((p) => this.getProviderToken(p) === this.getProviderToken(exportProvider));
+    }
+    getProviderToken(provider) {
+        return provider?.provide || provider;
+    }
+    shouldCloneProvider(provider) {
+        return !!(provider?.useValue !== undefined || provider?.useClass);
+    }
+    cloneProvider(provider) {
+        return { ...provider };
+    }
+    /**
+     * Set the custom logger provider.
+     * The provider must be a class with the @Service() decorator.
+     * The provider must extend the LoggerService class.
+     *
+     * @param provider
+     */
+    useLogger(provider) {
+        (0, index_1.registerProvider)({ provide: logger_service_1.LoggerService, useClass: provider });
+        return this;
+    }
+    loadProvidersAndControllers() {
+        const providers = domain_1.Metadata.get(constants_1.PROVIDER, Reflect) || [];
+        const controllers = domain_1.Metadata.get(constants_1.CONTROLLER, Reflect) || [];
+        this.registerControllers(controllers);
+        this.registerMetadataProviders(providers);
+        this.registerConfigProviders();
+    }
+    registerControllers(controllers) {
+        for (const controller of controllers) {
+            (0, index_1.registerController)(controller);
+            controller.options?.children &&
+                controller.options.children.forEach((child) => {
+                    (0, index_1.registerController)({ provide: child, parent: controller.provide });
+                });
+        }
+    }
+    registerMetadataProviders(providers) {
+        for (const provider of providers) {
+            (0, index_1.registerProvider)(provider);
+        }
+    }
+    registerConfigProviders() {
+        if (!this.config.providers) {
+            return;
+        }
+        for (const provider of this.config.providers) {
+            const normalized = this.normalizeProvider(provider);
+            (0, index_1.registerProvider)(normalized);
+        }
+    }
+    normalizeProvider(provider) {
+        if (provider?.provide) {
+            return provider;
+        }
+        return {
+            provide: provider,
+            useClass: provider,
+        };
+    }
+    async init() {
+        this.loadProvidersAndControllers();
+        await this.injector.loadModule((0, createContainer_1.createContainer)(), this.config, this.router);
+    }
+    async listen(port = 3000) {
+        this.registerShutdownHandlers();
+        await this.init();
+        this.createHttpServer(port);
+    }
+    registerShutdownHandlers() {
+        const shutdown = async (signal) => {
+            console.log(`\nReceived ${signal}, starting graceful shutdown...`);
+            await this.handleShutdownHook();
+        };
+        node_process_1.default.on("SIGTERM", () => shutdown("SIGTERM"));
+        node_process_1.default.on("SIGINT", () => shutdown("SIGINT"));
+    }
+    getHttpServer() {
+        return this.server;
+    }
+    getInjector() {
+        return this.injector;
+    }
+    createHttpServer(port) {
+        this.server = Bun.serve({ port, fetch: this.fetch, error: this.catcher });
+        console.log(`Server running on port ${port}`);
+    }
+    async fetcher(request, server) {
+        if (this.isCorsEnabled()) {
+            const origin = request.headers.get("origin");
+            if (request.method === "OPTIONS" && origin) {
+                return this.handlePreflightRequest(request);
+            }
+        }
+        const urlParsed = parseUrl(request);
+        const context = await Context_1.Context.createFromRequest(urlParsed, request, server);
+        await this.injector.callHook(on_event_1.EventType.OnRequest, { context });
+        const local = new LocalsContainer_1.LocalsContainer();
+        const routePath = this.discoverRoutePath(urlParsed);
+        const route = this.router.find(request.method.toLowerCase(), routePath);
+        if (!route) {
+            throw new HttpException_1.HttpException("Method not allowed", 404);
+        }
+        context.param = route.params;
+        local.set(Context_1.Context, context);
+        let response = await RouteExecutor_1.RouteExecutor.executeRoute(route.store, this.injector, context, local);
+        if (this.isCorsEnabled()) {
+            const origin = request.headers.get("origin");
+            if (origin && this.isOriginAllowed(origin)) {
+                response = this.applyCorsHeaders(response, origin);
+            }
+        }
+        return response;
+    }
+    async bootstrapApplication() {
+        try {
+            await this.injector.callHook(on_event_1.EventType.OnApplicationBoot, {});
+        }
+        catch (error) {
+            this.reportHookFailure(on_event_1.EventType.OnApplicationBoot, error);
+        }
+    }
+    async handleShutdownHook() {
+        try {
+            await this.injector.callHook(on_event_1.EventType.OnApplicationShutdown);
+            this.closeHttpServer();
+            this.exitProcess();
+        }
+        catch (error) {
+            this.reportHookFailure(on_event_1.EventType.OnApplicationShutdown, error);
+            this.exitProcess(1);
+        }
+    }
+    closeHttpServer() {
+        if (this.server) {
+            console.log("Closing HTTP server...");
+            this.server.stop(true);
+        }
+    }
+    exitProcess(code = 0) {
+        console.log("Shutdown complete.");
+        node_process_1.default.exit(code);
+    }
+    reportHookFailure(event, error) {
+        console.error(`Lifecycle hook ${event} failed`, error);
+    }
+    isCorsEnabled() {
+        return !!this.config.cors;
+    }
+    isOriginAllowed(origin) {
+        if (!origin || !this.config.cors) {
+            return false;
+        }
+        const { origins } = this.config.cors;
+        if (typeof origins === "string") {
+            return origins === "*" || origins === origin;
+        }
+        if (Array.isArray(origins)) {
+            return origins.includes(origin);
+        }
+        if (origins instanceof RegExp) {
+            return origins.test(origin);
+        }
+        if (typeof origins === "function") {
+            return origins(origin);
+        }
+        return false;
+    }
+    buildCorsHeaders(origin) {
+        const cors = this.config.cors;
+        const headers = {};
+        const allowedOrigin = typeof cors.origins === "string" && cors.origins === "*"
+            ? "*"
+            : origin;
+        headers["Access-Control-Allow-Origin"] = allowedOrigin;
+        if (cors.credentials) {
+            headers["Access-Control-Allow-Credentials"] = "true";
+        }
+        const methods = cors.methods || cors_config_1.DEFAULT_CORS_METHODS;
+        headers["Access-Control-Allow-Methods"] = methods.join(", ");
+        const allowedHeaders = cors.allowedHeaders || cors_config_1.DEFAULT_CORS_ALLOWED_HEADERS;
+        headers["Access-Control-Allow-Headers"] = allowedHeaders.join(", ");
+        if (cors.exposedHeaders && cors.exposedHeaders.length > 0) {
+            headers["Access-Control-Expose-Headers"] = cors.exposedHeaders.join(", ");
+        }
+        if (cors.maxAge !== undefined) {
+            headers["Access-Control-Max-Age"] = cors.maxAge.toString();
+        }
+        return headers;
+    }
+    handlePreflightRequest(request) {
+        const origin = request.headers.get("origin");
+        if (!this.isOriginAllowed(origin)) {
+            return new Response(null, { status: 403 });
+        }
+        const corsHeaders = this.buildCorsHeaders(origin);
+        return new Response(null, {
+            status: 204,
+            headers: corsHeaders,
+        });
+    }
+    applyCorsHeaders(response, origin) {
+        const corsHeaders = this.buildCorsHeaders(origin);
+        const newHeaders = new Headers(response.headers);
+        for (const [key, value] of Object.entries(corsHeaders)) {
+            newHeaders.set(key, value);
+        }
+        return new Response(response.body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: newHeaders,
+        });
+    }
+    close(closeActiveConnections = false) {
+        this.server?.stop(closeActiveConnections);
+    }
+    discoverRoutePath(url) {
+        if (url?.pathname) {
+            return url.pathname;
+        }
+        return url?.path || "/";
+    }
+}
+exports.Carno = Carno;

package/dist/Cheetah.d.ts

@@ -0,0 +1,65 @@
+import { Server } from "bun";
+import { ValidatorOptions } from "class-validator";
+import * as pino from "pino";
+import { TokenRouteWithProvider } from "./container/ContainerConfiguration";
+import { CorsConfig } from "./domain/cors-config";
+import Memoirist from "./route/memoirist";
+export interface ApplicationConfig {
+    validation?: ValidatorOptions;
+    logger?: pino.LoggerOptions;
+    exports?: any[];
+    providers?: any[];
+    cors?: CorsConfig;
+    globalMiddlewares?: any[];
+}
+export declare class Cheetah {
+    config: ApplicationConfig;
+    router: Memoirist<TokenRouteWithProvider>;
+    private injector;
+    private fetch;
+    private server;
+    constructor(config?: ApplicationConfig);
+    /**
+     * Use the Cheetah plugin.
+     *
+     * @param plugin
+     */
+    use(plugin: Cheetah): this;
+    private findProviderInConfig;
+    private getProviderToken;
+    private shouldCloneProvider;
+    private cloneProvider;
+    /**
+     * Set the custom logger provider.
+     * The provider must be a class with the @Service() decorator.
+     * The provider must extend the LoggerService class.
+     *
+     * @param provider
+     */
+    useLogger(provider: any): this;
+    private loadProvidersAndControllers;
+    private registerControllers;
+    private registerMetadataProviders;
+    private registerConfigProviders;
+    private normalizeProvider;
+    init(): Promise<void>;
+    listen(port?: number): Promise<void>;
+    private registerShutdownHandlers;
+    getHttpServer(): Server<any>;
+    getInjector(): import(".").InjectorService;
+    private createHttpServer;
+    private fetcher;
+    private catcher;
+    private bootstrapApplication;
+    private handleShutdownHook;
+    private closeHttpServer;
+    private exitProcess;
+    private reportHookFailure;
+    private isCorsEnabled;
+    private isOriginAllowed;
+    private buildCorsHeaders;
+    private handlePreflightRequest;
+    private applyCorsHeaders;
+    close(closeActiveConnections?: boolean): void;
+    private discoverRoutePath;
+}