@abejarano/ts-express-server 1.5.2 → 1.6.0

package/dist/modules/CorsModule.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CorsModule = void 0;
 const abstract_1 = require("../abstract");
+const abstract_2 = require("../abstract");
 const cors_1 = __importDefault(require("cors"));
 class CorsModule extends abstract_1.BaseServerModule {
     constructor(corsOptions) {
@@ -20,8 +21,71 @@ class CorsModule extends abstract_1.BaseServerModule {
     getModuleName() {
         return this.name;
     }
-    init(app) {
-        app.use((0, cors_1.default)(this.corsOptions));
+    init(app, context) {
+        const runtime = context?.runtime ?? abstract_2.ServerRuntime.Express;
+        if (runtime === abstract_2.ServerRuntime.Express) {
+            app.use((0, cors_1.default)(this.corsOptions));
+            return;
+        }
+        app.use(createCorsMiddleware(this.corsOptions));
     }
 }
 exports.CorsModule = CorsModule;
+const createCorsMiddleware = (options) => {
+    return (req, res, next) => {
+        const originHeader = String(req.headers?.origin || "");
+        const allowOrigin = resolveOrigin(options.origin, originHeader);
+        if (allowOrigin) {
+            res.set("access-control-allow-origin", allowOrigin);
+        }
+        if (options.credentials) {
+            res.set("access-control-allow-credentials", "true");
+        }
+        if (options.methods) {
+            res.set("access-control-allow-methods", Array.isArray(options.methods) ? options.methods.join(",") : options.methods);
+        }
+        if (options.allowedHeaders) {
+            res.set("access-control-allow-headers", Array.isArray(options.allowedHeaders)
+                ? options.allowedHeaders.join(",")
+                : options.allowedHeaders);
+        }
+        if (options.maxAge !== undefined) {
+            res.set("access-control-max-age", String(options.maxAge));
+        }
+        if (req.method === "OPTIONS") {
+            res.status(204).end();
+            return;
+        }
+        next();
+    };
+};
+const resolveOrigin = (originOption, requestOrigin) => {
+    if (!originOption || originOption === "*") {
+        return "*";
+    }
+    if (originOption === true) {
+        return requestOrigin || "*";
+    }
+    if (typeof originOption === "string") {
+        return originOption;
+    }
+    if (Array.isArray(originOption)) {
+        return originOption.includes(requestOrigin) ? requestOrigin : undefined;
+    }
+    if (typeof originOption === "function") {
+        let resolved;
+        originOption(requestOrigin, (err, value) => {
+            if (err) {
+                return;
+            }
+            if (value === true) {
+                resolved = requestOrigin || "*";
+            }
+            else if (typeof value === "string") {
+                resolved = value;
+            }
+        });
+        return resolved;
+    }
+    return undefined;
+};

package/dist/modules/FileUploadModule.d.ts

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

package/dist/modules/FileUploadModule.js

@@ -1,11 +1,8 @@
 "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");
+const abstract_2 = require("../abstract");
 class FileUploadModule extends abstract_1.BaseServerModule {
     constructor(fileUploadOptions) {
         super();
@@ -20,8 +17,48 @@ class FileUploadModule extends abstract_1.BaseServerModule {
     getModuleName() {
         return this.name;
     }
-    init(app) {
-        app.use((0, express_fileupload_1.default)(this.fileUploadOptions));
+    init(app, context) {
+        const runtime = context?.runtime ?? abstract_2.ServerRuntime.Express;
+        if (runtime === abstract_2.ServerRuntime.Express) {
+            const fileUpload = require("express-fileupload");
+            app.use(fileUpload(this.fileUploadOptions));
+            return;
+        }
+        app.use(createBunFileUploadMiddleware());
     }
 }
 exports.FileUploadModule = FileUploadModule;
+const createBunFileUploadMiddleware = () => {
+    return async (req, _res, next) => {
+        if (!req.raw || req.files) {
+            return next();
+        }
+        const contentType = String(req.headers?.["content-type"] || "");
+        if (!contentType.includes("multipart/form-data")) {
+            return next();
+        }
+        try {
+            const formData = await req.raw.formData();
+            const files = {};
+            const body = {};
+            formData.forEach((value, key) => {
+                if (value instanceof File) {
+                    files[key] = value;
+                }
+                else {
+                    body[key] = value;
+                }
+            });
+            if (Object.keys(files).length) {
+                req.files = files;
+            }
+            if (Object.keys(body).length && req.body === undefined) {
+                req.body = body;
+            }
+        }
+        catch {
+            // Ignore malformed multipart payloads.
+        }
+        next();
+    };
+};

package/dist/modules/RateLimitModule.d.ts

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

package/dist/modules/RateLimitModule.js

@@ -1,11 +1,8 @@
 "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"));
+const abstract_2 = require("../abstract");
 class RateLimitModule extends abstract_1.BaseServerModule {
     constructor(limiterOptions) {
         super();
@@ -21,9 +18,53 @@ class RateLimitModule extends abstract_1.BaseServerModule {
     getModuleName() {
         return this.name;
     }
-    init(app) {
-        const limiter = (0, express_rate_limit_1.default)(this.limiterOptions);
-        app.use(limiter);
+    init(app, context) {
+        const runtime = context?.runtime ?? abstract_2.ServerRuntime.Express;
+        if (runtime === abstract_2.ServerRuntime.Express) {
+            const rateLimitModule = require("express-rate-limit");
+            const rateLimit = rateLimitModule.default ?? rateLimitModule;
+            const limiter = rateLimit(this.limiterOptions);
+            app.use(limiter);
+            return;
+        }
+        app.use(createRateLimitMiddleware(this.limiterOptions));
     }
 }
 exports.RateLimitModule = RateLimitModule;
+const createRateLimitMiddleware = (options) => {
+    const windowMsOption = options?.windowMs;
+    const windowMs = typeof windowMsOption === "number" ? windowMsOption : 8 * 60 * 1000;
+    const legacyMax = options?.max;
+    const limitOption = options?.limit ?? legacyMax;
+    const limit = typeof limitOption === "number" ? limitOption : 100;
+    const hits = new Map();
+    return (req, res, next) => {
+        const key = req.ip || String(req.headers?.["x-forwarded-for"] || "unknown");
+        const now = Date.now();
+        const existing = hits.get(key);
+        if (!existing || existing.expiresAt <= now) {
+            hits.set(key, { count: 1, expiresAt: now + windowMs });
+        }
+        else {
+            existing.count += 1;
+        }
+        const current = hits.get(key);
+        const remaining = Math.max(0, limit - current.count);
+        if (options?.standardHeaders) {
+            res.set("ratelimit-limit", String(limit));
+            res.set("ratelimit-remaining", String(remaining));
+            res.set("ratelimit-reset", String(Math.ceil(current.expiresAt / 1000)));
+        }
+        if (current.count > limit) {
+            const message = typeof options?.message === "string" ||
+                (typeof options?.message === "object" && options?.message)
+                ? options.message
+                : undefined;
+            res.status(429).json(message || {
+                message: "Too many requests, please try again later.",
+            });
+            return;
+        }
+        next();
+    };
+};

package/dist/modules/RequestContextModule.d.ts

@@ -1,16 +1,9 @@
-import { Express } from "express";
 import { BaseServerModule } from "../abstract";
-declare global {
-    namespace Express {
-        interface Request {
-            requestId?: string;
-        }
-    }
-}
+import { ServerApp, ServerContext } from "../abstract";
 export declare class RequestContextModule extends BaseServerModule {
     name: string;
     priority: number;
-    init(app: Express): void;
+    init(app: ServerApp, _context?: ServerContext): void;
     getModuleName(): string;
 }
 interface Context {

package/dist/modules/RequestContextModule.js

@@ -1,7 +1,39 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 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 {
@@ -10,12 +42,13 @@ class RequestContextModule extends abstract_1.BaseServerModule {
         this.name = "RequestContext";
         this.priority = -50;
     }
-    init(app) {
-        const requestContextMiddleware = (req, res, next) => {
+    init(app, _context) {
+        const requestContextMiddleware = async (req, _res, next) => {
             const incomingRequestId = req.headers["x-request-id"];
             const requestId = (Array.isArray(incomingRequestId)
                 ? incomingRequestId[0]
-                : incomingRequestId) || (0, uuid_1.v4)();
+                : incomingRequestId) || (await createRequestId());
+            req.requestId = requestId;
             RequestContext.run({ requestId }, () => {
                 next();
             });
@@ -43,3 +76,19 @@ class RequestContext {
 }
 exports.RequestContext = RequestContext;
 RequestContext.storage = new async_hooks_1.AsyncLocalStorage();
+const createRequestId = async () => {
+    const cryptoObj = globalThis.crypto;
+    if (cryptoObj?.randomUUID) {
+        return cryptoObj.randomUUID();
+    }
+    try {
+        const uuidModule = (await Promise.resolve().then(() => __importStar(require("uuid"))));
+        if (uuidModule.v4) {
+            return uuidModule.v4();
+        }
+    }
+    catch {
+        // Ignore and fallback.
+    }
+    return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+};

package/dist/modules/RoutesModule.d.ts

@@ -1,9 +1,9 @@
-import { Express, RequestHandler, Router } from "express";
 import { BaseServerModule } from "../abstract";
+import { ServerApp, ServerContext, ServerHandler, ServerRouter } from "../abstract";
 export interface RouteConfig {
     path: string;
-    router: Router;
-    middleware?: RequestHandler[] | RequestHandler;
+    router: ServerRouter;
+    middleware?: ServerHandler[] | ServerHandler;
 }
 export declare class RoutesModule extends BaseServerModule {
     name: string;
@@ -13,5 +13,5 @@ export declare class RoutesModule extends BaseServerModule {
     getModuleName(): string;
     addRoute(route: RouteConfig): void;
     addRoutes(routes: RouteConfig[]): void;
-    init(app: Express): void;
+    init(app: ServerApp, context?: ServerContext): void;
 }

package/dist/modules/RoutesModule.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RoutesModule = void 0;
 const abstract_1 = require("../abstract");
+const abstract_2 = require("../abstract");
 class RoutesModule extends abstract_1.BaseServerModule {
     constructor(routes = []) {
         super();
@@ -20,10 +21,18 @@ class RoutesModule extends abstract_1.BaseServerModule {
     addRoutes(routes) {
         this.routes.push(...routes);
     }
-    init(app) {
+    init(app, context) {
+        if (context?.runtime === abstract_2.ServerRuntime.Bun) {
+            console.warn("[RoutesModule] Express routers are not supported on Bun. Migrate to decorated controllers for Bun runtime.");
+        }
         this.routes.forEach(({ path, router, middleware }) => {
-            if (middleware && middleware.length > 0) {
-                app.use(path, middleware, router);
+            const middlewareList = Array.isArray(middleware)
+                ? middleware
+                : middleware
+                    ? [middleware]
+                    : [];
+            if (middlewareList.length > 0) {
+                app.use(path, ...middlewareList, router);
             }
             else {
                 app.use(path, router);

package/dist/modules/SecurityModule.d.ts

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

package/dist/modules/SecurityModule.js

@@ -1,11 +1,8 @@
 "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");
+const abstract_2 = require("../abstract");
 class SecurityModule extends abstract_1.BaseServerModule {
     constructor(helmetOptions) {
         super();
@@ -29,8 +26,48 @@ class SecurityModule extends abstract_1.BaseServerModule {
     getModuleName() {
         return this.name;
     }
-    init(app) {
-        app.use((0, helmet_1.default)(this.helmetOptions));
+    init(app, context) {
+        const runtime = context?.runtime ?? abstract_2.ServerRuntime.Express;
+        if (runtime === abstract_2.ServerRuntime.Express) {
+            const helmetModule = require("helmet");
+            const helmet = helmetModule.default ?? helmetModule;
+            app.use(helmet(this.helmetOptions));
+            return;
+        }
+        app.use(createSecurityMiddleware(this.helmetOptions));
     }
 }
 exports.SecurityModule = SecurityModule;
+const createSecurityMiddleware = (options) => {
+    return (_req, res, next) => {
+        const frameguard = options?.frameguard;
+        if (frameguard && typeof frameguard === "object" && "action" in frameguard) {
+            const action = frameguard.action;
+            if (action) {
+                res.set("x-frame-options", action.toUpperCase());
+            }
+        }
+        if (options?.ieNoOpen !== false) {
+            res.set("x-download-options", "noopen");
+        }
+        if (options?.noSniff !== false) {
+            res.set("x-content-type-options", "nosniff");
+        }
+        if (options?.originAgentCluster) {
+            res.set("origin-agent-cluster", "?1");
+        }
+        if (options?.permittedCrossDomainPolicies === false) {
+            res.set("x-permitted-cross-domain-policies", "none");
+        }
+        const referrerPolicy = options?.referrerPolicy;
+        if (referrerPolicy && typeof referrerPolicy === "object" && "policy" in referrerPolicy) {
+            res.set("referrer-policy", Array.isArray(referrerPolicy.policy)
+                ? referrerPolicy.policy.join(",")
+                : referrerPolicy.policy);
+        }
+        if (options?.dnsPrefetchControl) {
+            res.set("x-dns-prefetch-control", "on");
+        }
+        next();
+    };
+};

package/dist/testing/createDecoratedTestApp.d.ts

@@ -1,7 +1,6 @@
-import { Express } from "express";
 import type { BootstrapServer } from "../BootstrapServer";
 import { ControllersModule } from "../modules";
-import { BaseServerService } from "../abstract";
+import { BaseServerService, ServerApp, ServerRuntime } from "../abstract";
 import { BootstrapStandardServerOptions } from "../BootstrapStandardServer";
 type ControllerClass<T = any> = new (...args: any[]) => T;
 export interface DecoratedTestAppOptions {
@@ -10,9 +9,10 @@ export interface DecoratedTestAppOptions {
     port?: number;
     services?: BaseServerService[];
     standardOptions?: BootstrapStandardServerOptions;
+    runtime?: ServerRuntime;
 }
 export interface DecoratedTestAppResult {
-    app: Express;
+    app: ServerApp;
     server: BootstrapServer;
     stop: () => Promise<void>;
 }

package/dist/testing/createDecoratedTestApp.js

@@ -12,6 +12,7 @@ const mergeOptions = (base, override) => {
         ...(override.services ?? []),
     ];
     return {
+        runtime: override.runtime ?? base.runtime,
         services: mergedServices.length ? mergedServices : undefined,
         modules: {
             ...(base.modules ?? {}),
@@ -31,15 +32,18 @@ async function createDecoratedTestApp(options) {
         },
     };
     const mergedOptions = mergeOptions(baseOptions, standardOptions);
-    const server = (0, BootstrapStandardServer_1.BootstrapStandardServer)(port, moduleInstance, mergedOptions);
+    const server = (0, BootstrapStandardServer_1.BootstrapStandardServer)(port, moduleInstance, {
+        ...mergedOptions,
+        runtime: options.runtime ?? mergedOptions.runtime,
+    });
     await server.initialize();
     return {
         app: server.getApp(),
         server,
         stop: async () => {
-            const httpServer = server.getHttpServer();
-            if (httpServer) {
-                await new Promise((resolve) => httpServer.close(() => resolve()));
+            const serverInstance = server.getServer();
+            if (serverInstance) {
+                await new Promise((resolve) => serverInstance.close(() => resolve()));
             }
         },
     };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@abejarano/ts-express-server",
   "author": "angel bejarano / angel.bejarano@jaspesoft.com",
-  "version": "1.5.2",
+  "version": "1.6.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -33,9 +33,9 @@
     "body-parser": "^2.2.1",
     "cookie-parser": "^1.4.7",
     "cors": "^2.8.5",
-    "express": "^5.1.0",
+    "express": "^5.2.1",
     "express-fileupload": "^1.5.2",
-    "express-rate-limit": "^8.1.0",
+    "express-rate-limit": "^8.2.1",
     "helmet": "^8.1.0",
     "reflect-metadata": "^0.2.2",
     "uuid": "^13.0.0"
@@ -46,16 +46,15 @@
     "@types/body-parser": "^1.19.6",
     "@types/cookie-parser": "^1.4.9",
     "@types/cors": "^2.8.19",
-    "@types/express": "^5.0.3",
+    "@types/express": "^5.0.6",
     "@types/express-fileupload": "^1.5.1",
-    "@types/express-rate-limit": "^6.0.2",
     "@types/jest": "^30.0.0",
-    "@types/node": "^24.6.0",
+    "@types/node": "^25.0.3",
     "@types/supertest": "^6.0.3",
     "jest": "^30.2.0",
     "prettier": "^3.6.2",
     "rimraf": "^6.0.1",
-    "semantic-release": "^24.2.9",
+    "semantic-release": "^25.0.2",
     "supertest": "^7.1.4",
     "ts-jest": "^29.4.5",
     "typescript": "^5.9.3"