@abejarano/ts-express-server 1.5.1

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BootstrapStandardServer = exports.BootstrapServer = void 0;
+require("reflect-metadata");
+var BootstrapServer_1 = require("./BootstrapServer");
+Object.defineProperty(exports, "BootstrapServer", { enumerable: true, get: function () { return BootstrapServer_1.BootstrapServer; } });
+var BootstrapStandardServer_1 = require("./BootstrapStandardServer");
+Object.defineProperty(exports, "BootstrapStandardServer", { enumerable: true, get: function () { return BootstrapStandardServer_1.BootstrapStandardServer; } });
+__exportStar(require("./modules"), exports);
+__exportStar(require("./abstract"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./testing"), exports);

package/dist/modules/ControllersModule.d.ts

@@ -0,0 +1,11 @@
+import { Express } from "express";
+import { BaseServerModule } from "../abstract";
+import "reflect-metadata";
+export declare class ControllersModule extends BaseServerModule {
+    private controllers;
+    name: string;
+    priority: number;
+    constructor(controllers: Function[]);
+    getModuleName(): string;
+    init(app: Express): void;
+}

package/dist/modules/ControllersModule.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControllersModule = void 0;
+const express_1 = require("express");
+const abstract_1 = require("../abstract");
+const MetadataKeys_1 = require("../decorators/MetadataKeys");
+const Parameters_1 = require("../decorators/Parameters");
+require("reflect-metadata");
+class ControllersModule extends abstract_1.BaseServerModule {
+    constructor(controllers) {
+        super();
+        this.controllers = controllers;
+        this.name = "Controllers";
+        this.priority = 10;
+    }
+    getModuleName() {
+        return this.name;
+    }
+    init(app) {
+        this.controllers.forEach((ControllerClass) => {
+            const basePath = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.BASE_PATH, ControllerClass);
+            const classMiddlewares = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.MIDDLEWARE, ControllerClass) || [];
+            const routers = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.ROUTERS, ControllerClass.prototype) ||
+                [];
+            if (!basePath) {
+                return;
+            }
+            const router = (0, express_1.Router)();
+            // Create a single controller instance per controller class (singleton pattern)
+            const controllerInstance = new ControllerClass();
+            // Apply class-level middlewares
+            if (classMiddlewares.length > 0) {
+                router.use(classMiddlewares);
+            }
+            routers.forEach(({ method, path, handlerName }) => {
+                const routeHandler = ControllerClass.prototype[handlerName];
+                const routeMiddlewares = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.MIDDLEWARE, ControllerClass.prototype, handlerName) || [];
+                const parameterMetadata = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.PARAMETERS, ControllerClass.prototype, handlerName) || [];
+                router[method](path, ...routeMiddlewares, async (req, res, next) => {
+                    if (parameterMetadata.length === 0) {
+                        try {
+                            const result = routeHandler.call(controllerInstance, req, res, next);
+                            if (result instanceof Promise) {
+                                await result;
+                            }
+                            return result;
+                        }
+                        catch (error) {
+                            return next(error);
+                        }
+                    }
+                    const maxIndex = Math.max(routeHandler.length - 1, ...parameterMetadata.map((param) => param.index));
+                    const args = new Array(Math.max(0, maxIndex + 1));
+                    parameterMetadata.forEach((param) => {
+                        switch (param.type) {
+                            case Parameters_1.ParameterType.BODY:
+                                args[param.index] =
+                                    param.data && req.body ? req.body[param.data] : req.body;
+                                break;
+                            case Parameters_1.ParameterType.PARAM:
+                                args[param.index] = param.data
+                                    ? req.params?.[param.data]
+                                    : req.params;
+                                break;
+                            case Parameters_1.ParameterType.QUERY:
+                                args[param.index] =
+                                    param.data && req.query ? req.query[param.data] : req.query;
+                                break;
+                            case Parameters_1.ParameterType.HEADERS:
+                                if (param.data) {
+                                    const headerKey = param.data.toLowerCase();
+                                    args[param.index] = req.headers?.[headerKey];
+                                }
+                                else {
+                                    args[param.index] = req.headers;
+                                }
+                                break;
+                            case Parameters_1.ParameterType.FILE: {
+                                const files = req.files;
+                                if (!files) {
+                                    args[param.index] = undefined;
+                                    break;
+                                }
+                                if (param.data) {
+                                    args[param.index] = files[param.data];
+                                }
+                                else {
+                                    args[param.index] = files;
+                                }
+                                break;
+                            }
+                            case Parameters_1.ParameterType.REQUEST:
+                                args[param.index] = req;
+                                break;
+                            case Parameters_1.ParameterType.RESPONSE:
+                                args[param.index] = res;
+                                break;
+                            case Parameters_1.ParameterType.NEXT:
+                                args[param.index] = next;
+                                break;
+                            default:
+                                args[param.index] = undefined;
+                                break;
+                        }
+                    });
+                    // Fallbacks for common Express arguments when not explicitly decorated
+                    if (args[0] === undefined) {
+                        args[0] = req;
+                    }
+                    if (args[1] === undefined) {
+                        args[1] = res;
+                    }
+                    if (args[2] === undefined) {
+                        args[2] = next;
+                    }
+                    try {
+                        const result = routeHandler.apply(controllerInstance, args);
+                        if (result instanceof Promise) {
+                            await result;
+                        }
+                        return result;
+                    }
+                    catch (error) {
+                        return next(error);
+                    }
+                });
+            });
+            app.use(basePath, router);
+        });
+    }
+}
+exports.ControllersModule = ControllersModule;

package/dist/modules/CorsModule.d.ts

@@ -0,0 +1,11 @@
+import { Express } from "express";
+import { BaseServerModule } from "../abstract";
+import cors from "cors";
+export declare class CorsModule extends BaseServerModule {
+    name: string;
+    priority: number;
+    private corsOptions;
+    constructor(corsOptions?: cors.CorsOptions);
+    getModuleName(): string;
+    init(app: Express): void;
+}

package/dist/modules/CorsModule.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorsModule = void 0;
+const abstract_1 = require("../abstract");
+const cors_1 = __importDefault(require("cors"));
+class CorsModule extends abstract_1.BaseServerModule {
+    constructor(corsOptions) {
+        super();
+        this.name = "Cors";
+        this.priority = -90;
+        this.corsOptions = corsOptions || {
+            origin: "*",
+            preflightContinue: false,
+            optionsSuccessStatus: 204,
+        };
+    }
+    getModuleName() {
+        return this.name;
+    }
+    init(app) {
+        app.use((0, cors_1.default)(this.corsOptions));
+    }
+}
+exports.CorsModule = CorsModule;

package/dist/modules/FileUploadModule.d.ts

@@ -0,0 +1,11 @@
+import { Express } from "express";
+import fileUpload from "express-fileupload";
+import { BaseServerModule } from "../abstract";
+export declare class FileUploadModule extends BaseServerModule {
+    name: string;
+    priority: number;
+    private fileUploadOptions;
+    constructor(fileUploadOptions?: fileUpload.Options);
+    getModuleName(): string;
+    init(app: Express): void;
+}

package/dist/modules/FileUploadModule.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileUploadModule = void 0;
+const express_fileupload_1 = __importDefault(require("express-fileupload"));
+const abstract_1 = require("../abstract");
+class FileUploadModule extends abstract_1.BaseServerModule {
+    constructor(fileUploadOptions) {
+        super();
+        this.name = "FileUpload";
+        this.priority = -60;
+        this.fileUploadOptions = fileUploadOptions || {
+            limits: { fileSize: 50 * 1024 * 1024 },
+            useTempFiles: true,
+            tempFileDir: "/tmp/",
+        };
+    }
+    getModuleName() {
+        return this.name;
+    }
+    init(app) {
+        app.use((0, express_fileupload_1.default)(this.fileUploadOptions));
+    }
+}
+exports.FileUploadModule = FileUploadModule;

package/dist/modules/RateLimitModule.d.ts

@@ -0,0 +1,11 @@
+import { Express } from "express";
+import { BaseServerModule } from "../abstract";
+import rateLimit from "express-rate-limit";
+export declare class RateLimitModule extends BaseServerModule {
+    name: string;
+    priority: number;
+    private limiterOptions;
+    constructor(limiterOptions?: Parameters<typeof rateLimit>[0]);
+    getModuleName(): string;
+    init(app: Express): void;
+}

package/dist/modules/RateLimitModule.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitModule = void 0;
+const abstract_1 = require("../abstract");
+const express_rate_limit_1 = __importDefault(require("express-rate-limit"));
+class RateLimitModule extends abstract_1.BaseServerModule {
+    constructor(limiterOptions) {
+        super();
+        this.name = "RateLimit";
+        this.priority = -70;
+        this.limiterOptions = limiterOptions || {
+            windowMs: 8 * 60 * 1000, // 8 minutes
+            limit: 100,
+            standardHeaders: true,
+            legacyHeaders: false,
+        };
+    }
+    getModuleName() {
+        return this.name;
+    }
+    init(app) {
+        const limiter = (0, express_rate_limit_1.default)(this.limiterOptions);
+        app.use(limiter);
+    }
+}
+exports.RateLimitModule = RateLimitModule;

package/dist/modules/RequestContextModule.d.ts

@@ -0,0 +1,25 @@
+import { Express } from "express";
+import { BaseServerModule } from "../abstract";
+declare global {
+    namespace Express {
+        interface Request {
+            requestId?: string;
+        }
+    }
+}
+export declare class RequestContextModule extends BaseServerModule {
+    name: string;
+    priority: number;
+    init(app: Express): void;
+    getModuleName(): string;
+}
+interface Context {
+    requestId: string;
+}
+declare class RequestContext {
+    private static storage;
+    static get currentContext(): Context | undefined;
+    static get requestId(): string | undefined;
+    static run(context: Context, callback: () => void): void;
+}
+export { RequestContext };

package/dist/modules/RequestContextModule.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestContext = exports.RequestContextModule = void 0;
+const uuid_1 = require("uuid");
+const abstract_1 = require("../abstract");
+const async_hooks_1 = require("async_hooks");
+class RequestContextModule extends abstract_1.BaseServerModule {
+    constructor() {
+        super(...arguments);
+        this.name = "RequestContext";
+        this.priority = -50;
+    }
+    init(app) {
+        const requestContextMiddleware = (req, res, next) => {
+            const incomingRequestId = req.headers["x-request-id"];
+            const requestId = (Array.isArray(incomingRequestId)
+                ? incomingRequestId[0]
+                : incomingRequestId) || (0, uuid_1.v4)();
+            RequestContext.run({ requestId }, () => {
+                next();
+            });
+        };
+        app.use(requestContextMiddleware);
+    }
+    getModuleName() {
+        return this.name;
+    }
+}
+exports.RequestContextModule = RequestContextModule;
+class RequestContext {
+    // Obtiene el contexto actual
+    static get currentContext() {
+        return this.storage.getStore();
+    }
+    // Obtiene el requestId actual del contexto
+    static get requestId() {
+        return this.currentContext?.requestId;
+    }
+    // Inicializa el contexto
+    static run(context, callback) {
+        this.storage.run(context, callback);
+    }
+}
+exports.RequestContext = RequestContext;
+RequestContext.storage = new async_hooks_1.AsyncLocalStorage();

package/dist/modules/RoutesModule.d.ts

@@ -0,0 +1,17 @@
+import { Express, RequestHandler, Router } from "express";
+import { BaseServerModule } from "../abstract";
+export interface RouteConfig {
+    path: string;
+    router: Router;
+    middleware?: RequestHandler[] | RequestHandler;
+}
+export declare class RoutesModule extends BaseServerModule {
+    name: string;
+    priority: number;
+    private routes;
+    constructor(routes?: RouteConfig[]);
+    getModuleName(): string;
+    addRoute(route: RouteConfig): void;
+    addRoutes(routes: RouteConfig[]): void;
+    init(app: Express): void;
+}

package/dist/modules/RoutesModule.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutesModule = void 0;
+const abstract_1 = require("../abstract");
+class RoutesModule extends abstract_1.BaseServerModule {
+    constructor(routes = []) {
+        super();
+        this.name = "Routes";
+        this.priority = 10; // Executed after basic middlewares
+        this.routes = routes;
+    }
+    getModuleName() {
+        return this.name;
+    }
+    addRoute(route) {
+        this.routes.push({
+            ...route,
+        });
+    }
+    addRoutes(routes) {
+        this.routes.push(...routes);
+    }
+    init(app) {
+        this.routes.forEach(({ path, router, middleware }) => {
+            if (middleware && middleware.length > 0) {
+                app.use(path, middleware, router);
+            }
+            else {
+                app.use(path, router);
+            }
+        });
+    }
+}
+exports.RoutesModule = RoutesModule;

package/dist/modules/SecurityModule.d.ts

@@ -0,0 +1,11 @@
+import { Express } from "express";
+import helmet from "helmet";
+import { BaseServerModule } from "../abstract";
+export declare class SecurityModule extends BaseServerModule {
+    name: string;
+    priority: number;
+    private readonly helmetOptions;
+    constructor(helmetOptions?: Parameters<typeof helmet>[0]);
+    getModuleName(): string;
+    init(app: Express): void;
+}

package/dist/modules/SecurityModule.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityModule = void 0;
+const helmet_1 = __importDefault(require("helmet"));
+const abstract_1 = require("../abstract");
+class SecurityModule extends abstract_1.BaseServerModule {
+    constructor(helmetOptions) {
+        super();
+        this.name = "Security";
+        this.priority = -80;
+        this.helmetOptions = helmetOptions || {
+            contentSecurityPolicy: {
+                directives: {
+                    defaultSrc: ["'self'"],
+                    styleSrc: ["'self'", "'unsafe-inline'"],
+                    scriptSrc: ["'self'"],
+                    imgSrc: ["'self'", "data:", "https:"],
+                },
+            },
+            crossOriginEmbedderPolicy: true,
+            crossOriginOpenerPolicy: true,
+            crossOriginResourcePolicy: { policy: "cross-origin" },
+            dnsPrefetchControl: true,
+            frameguard: { action: "deny" },
+            hidePoweredBy: true,
+            ieNoOpen: true,
+            noSniff: true,
+            originAgentCluster: true,
+            permittedCrossDomainPolicies: false,
+            referrerPolicy: { policy: "no-referrer" },
+            xssFilter: true,
+        };
+    }
+    getModuleName() {
+        return this.name;
+    }
+    init(app) {
+        app.use((0, helmet_1.default)(this.helmetOptions));
+    }
+}
+exports.SecurityModule = SecurityModule;

package/dist/modules/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./CorsModule";
+export * from "./ControllersModule";
+export * from "./FileUploadModule";
+export * from "./RateLimitModule";
+export * from "./RequestContextModule";
+export * from "./RoutesModule";
+export * from "./SecurityModule";

package/dist/modules/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./CorsModule"), exports);
+__exportStar(require("./ControllersModule"), exports);
+__exportStar(require("./FileUploadModule"), exports);
+__exportStar(require("./RateLimitModule"), exports);
+__exportStar(require("./RequestContextModule"), exports);
+__exportStar(require("./RoutesModule"), exports);
+__exportStar(require("./SecurityModule"), exports);

package/dist/testing/createDecoratedTestApp.d.ts

@@ -0,0 +1,20 @@
+import { Express } from "express";
+import type { BootstrapServer } from "../BootstrapServer";
+import { ControllersModule } from "../modules";
+import { BaseServerService } from "../abstract";
+import { BootstrapStandardServerOptions } from "../BootstrapStandardServer";
+type ControllerClass<T = any> = new (...args: any[]) => T;
+export interface DecoratedTestAppOptions {
+    controllers?: ControllerClass[];
+    controllersModule?: ControllersModule;
+    port?: number;
+    services?: BaseServerService[];
+    standardOptions?: BootstrapStandardServerOptions;
+}
+export interface DecoratedTestAppResult {
+    app: Express;
+    server: BootstrapServer;
+    stop: () => Promise<void>;
+}
+export declare function createDecoratedTestApp(options: DecoratedTestAppOptions): Promise<DecoratedTestAppResult>;
+export {};

package/dist/testing/createDecoratedTestApp.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDecoratedTestApp = createDecoratedTestApp;
+const BootstrapStandardServer_1 = require("../BootstrapStandardServer");
+const modules_1 = require("../modules");
+const mergeOptions = (base, override) => {
+    if (!override) {
+        return base;
+    }
+    const mergedServices = [
+        ...(base.services ?? []),
+        ...(override.services ?? []),
+    ];
+    return {
+        services: mergedServices.length ? mergedServices : undefined,
+        modules: {
+            ...(base.modules ?? {}),
+            ...(override.modules ?? {}),
+        },
+    };
+};
+async function createDecoratedTestApp(options) {
+    const { controllers = [], controllersModule, port = 0, services, standardOptions, } = options;
+    const moduleInstance = controllersModule ?? new modules_1.ControllersModule(controllers);
+    const baseOptions = {
+        services,
+        modules: {
+            cors: false,
+            security: false,
+            rateLimit: false,
+        },
+    };
+    const mergedOptions = mergeOptions(baseOptions, standardOptions);
+    const server = (0, BootstrapStandardServer_1.BootstrapStandardServer)(port, moduleInstance, mergedOptions);
+    await server.initialize();
+    return {
+        app: server.getApp(),
+        server,
+        stop: async () => {
+            const httpServer = server.getHttpServer();
+            if (httpServer) {
+                await new Promise((resolve) => httpServer.close(() => resolve()));
+            }
+        },
+    };
+}

package/dist/testing/index.d.ts

@@ -0,0 +1 @@
+export * from "./createDecoratedTestApp";

package/dist/testing/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./createDecoratedTestApp"), exports);