@abejarano/ts-express-server 1.5.3 → 1.7.0

package/dist/adapters/ExpressAdapter.d.ts

@@ -0,0 +1,8 @@
+import { ServerAdapter, ServerApp, ServerInstance, ServerRouter, ServerRuntime } from "../abstract/ServerTypes";
+export declare class ExpressAdapter implements ServerAdapter {
+    runtime: ServerRuntime;
+    createApp(): ServerApp;
+    createRouter(): ServerRouter;
+    configure(app: ServerApp, port: number): void;
+    listen(app: ServerApp, port: number, onListen: () => void): ServerInstance;
+}

package/dist/adapters/ExpressAdapter.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressAdapter = void 0;
+const ServerTypes_1 = require("../abstract/ServerTypes");
+let expressModule = null;
+const getExpressModule = () => {
+    if (!expressModule) {
+        expressModule = require("express");
+    }
+    return expressModule;
+};
+class ExpressAdapter {
+    constructor() {
+        this.runtime = ServerTypes_1.ServerRuntime.Express;
+    }
+    createApp() {
+        const express = getExpressModule();
+        return express();
+    }
+    createRouter() {
+        const express = getExpressModule();
+        return express.Router();
+    }
+    configure(app, port) {
+        const expressApp = app;
+        const express = getExpressModule();
+        const bodyParser = require("body-parser");
+        const cookieParser = require("cookie-parser");
+        expressApp.use(express.json());
+        expressApp.use(bodyParser.urlencoded({ extended: true }));
+        expressApp.use(cookieParser());
+        expressApp.set("port", port);
+        expressApp.set("trust proxy", 1);
+    }
+    listen(app, port, onListen) {
+        const expressApp = app;
+        return expressApp.listen(port, onListen);
+    }
+}
+exports.ExpressAdapter = ExpressAdapter;

package/dist/adapters/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./BunAdapter";
+export * from "./ExpressAdapter";

package/dist/adapters/index.js

@@ -0,0 +1,18 @@
+"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("./BunAdapter"), exports);
+__exportStar(require("./ExpressAdapter"), exports);

package/dist/createRouter.d.ts

@@ -0,0 +1,2 @@
+import { ServerRuntime, ServerRouter } from "./abstract";
+export declare const createRouter: (runtime?: ServerRuntime) => ServerRouter;

package/dist/createRouter.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRouter = void 0;
+const abstract_1 = require("./abstract");
+const adapters_1 = require("./adapters");
+const createRouter = (runtime = abstract_1.ServerRuntime.Express) => {
+    if (runtime === abstract_1.ServerRuntime.Bun) {
+        return new adapters_1.BunAdapter().createRouter();
+    }
+    return new adapters_1.ExpressAdapter().createRouter();
+};
+exports.createRouter = createRouter;

package/dist/decorators/Controller.d.ts

@@ -1,2 +1,2 @@
 import "reflect-metadata";
-export declare function Controller(basePath: string): (target: Function) => void;
+export declare function Controller(basePath: string): (...args: any[]) => void;

package/dist/decorators/Controller.js

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Controller = Controller;
 const MetadataKeys_1 = require("./MetadataKeys");
+const DecoratorGuards_1 = require("./DecoratorGuards");
 require("reflect-metadata");
 function Controller(basePath) {
-    return function (target) {
+    return function (...args) {
+        (0, DecoratorGuards_1.assertLegacyDecorator)(args, "@Controller");
+        const target = args[0];
         Reflect.defineMetadata(MetadataKeys_1.MetadataKeys.BASE_PATH, basePath, target);
     };
 }

package/dist/decorators/DecoratorGuards.d.ts

@@ -0,0 +1 @@
+export declare function assertLegacyDecorator(args: any[], decoratorName: string): void;

package/dist/decorators/DecoratorGuards.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertLegacyDecorator = assertLegacyDecorator;
+function assertLegacyDecorator(args, decoratorName) {
+    const context = args[1];
+    if (args.length === 2 &&
+        context &&
+        typeof context === "object" &&
+        "kind" in context) {
+        throw new Error(`[ts-express-server] ${decoratorName} is not compatible with ` +
+            `standard TypeScript decorators. Enable "experimentalDecorators": true ` +
+            `in your tsconfig and ensure your files are included by that config.`);
+    }
+}

package/dist/decorators/Handlers.d.ts

@@ -11,8 +11,8 @@ export interface IRouter {
     path: string;
     handlerName: string | symbol;
 }
-export declare const Get: (path: string) => (target: any, key: string, descriptor: PropertyDescriptor) => void;
-export declare const Post: (path: string) => (target: any, key: string, descriptor: PropertyDescriptor) => void;
-export declare const Put: (path: string) => (target: any, key: string, descriptor: PropertyDescriptor) => void;
-export declare const Delete: (path: string) => (target: any, key: string, descriptor: PropertyDescriptor) => void;
-export declare const Patch: (path: string) => (target: any, key: string, descriptor: PropertyDescriptor) => void;
+export declare const Get: (path: string) => (...args: any[]) => void;
+export declare const Post: (path: string) => (...args: any[]) => void;
+export declare const Put: (path: string) => (...args: any[]) => void;
+export declare const Delete: (path: string) => (...args: any[]) => void;
+export declare const Patch: (path: string) => (...args: any[]) => void;

package/dist/decorators/Handlers.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Patch = exports.Delete = exports.Put = exports.Post = exports.Get = exports.Methods = void 0;
 const MetadataKeys_1 = require("./MetadataKeys");
+const DecoratorGuards_1 = require("./DecoratorGuards");
 require("reflect-metadata");
 var Methods;
 (function (Methods) {
@@ -13,7 +14,10 @@ var Methods;
 })(Methods || (exports.Methods = Methods = {}));
 function methodDecorator(method) {
     return function (path) {
-        return function (target, key, descriptor) {
+        return function (...args) {
+            (0, DecoratorGuards_1.assertLegacyDecorator)(args, `@${method.toUpperCase()}`);
+            const target = args[0];
+            const key = args[1];
             const routers = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.ROUTERS, target) || [];
             routers.push({
                 method,

package/dist/decorators/Use.d.ts

@@ -1,3 +1,3 @@
-import { RequestHandler } from "express";
+import { ServerHandler } from "../abstract";
 import "reflect-metadata";
-export declare function Use(middleware: RequestHandler | RequestHandler[]): (target: any, key?: string, descriptor?: PropertyDescriptor) => void;
+export declare function Use(middleware: ServerHandler | ServerHandler[]): (...args: any[]) => void;

package/dist/decorators/Use.js

@@ -2,9 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Use = Use;
 const MetadataKeys_1 = require("./MetadataKeys");
+const DecoratorGuards_1 = require("./DecoratorGuards");
 require("reflect-metadata");
 function Use(middleware) {
-    return function (target, key, descriptor) {
+    return function (...args) {
+        (0, DecoratorGuards_1.assertLegacyDecorator)(args, "@Use");
+        const target = args[0];
+        const key = args[1];
         const newMiddlewares = Array.isArray(middleware)
             ? middleware
             : [middleware];

package/dist/index.d.ts

@@ -1,7 +1,10 @@
 import "reflect-metadata";
 export { BootstrapServer } from "./BootstrapServer";
+export type { BootstrapServerOptions } from "./BootstrapServer";
 export { BootstrapStandardServer } from "./BootstrapStandardServer";
 export type { BootstrapStandardServerOptions } from "./BootstrapStandardServer";
+export * from "./adapters";
+export * from "./createRouter";
 export * from "./modules";
 export * from "./abstract";
 export * from "./decorators";

package/dist/index.js

@@ -20,6 +20,8 @@ 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("./adapters"), exports);
+__exportStar(require("./createRouter"), exports);
 __exportStar(require("./modules"), exports);
 __exportStar(require("./abstract"), exports);
 __exportStar(require("./decorators"), exports);

package/dist/modules/ControllersModule.d.ts

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

package/dist/modules/ControllersModule.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ControllersModule = void 0;
-const express_1 = require("express");
 const abstract_1 = require("../abstract");
+const adapters_1 = require("../adapters");
 const MetadataKeys_1 = require("../decorators/MetadataKeys");
 const Parameters_1 = require("../decorators/Parameters");
 require("reflect-metadata");
@@ -16,16 +16,16 @@ class ControllersModule extends abstract_1.BaseServerModule {
     getModuleName() {
         return this.name;
     }
-    init(app) {
+    init(app, context) {
         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) ||
-                [];
+            const routers = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.ROUTERS, ControllerClass.prototype) || [];
             if (!basePath) {
                 return;
             }
-            const router = (0, express_1.Router)();
+            const adapter = context?.adapter ?? new adapters_1.ExpressAdapter();
+            const router = adapter.createRouter();
             // Create a single controller instance per controller class (singleton pattern)
             const controllerInstance = new ControllerClass();
             // Apply class-level middlewares
@@ -36,7 +36,8 @@ class ControllersModule extends abstract_1.BaseServerModule {
                 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) => {
+                const routerMethod = router[method]?.bind(router);
+                routerMethod(path, ...routeMiddlewares, async (req, res, next) => {
                     if (parameterMetadata.length === 0) {
                         try {
                             const result = routeHandler.call(controllerInstance, req, res, next);
@@ -54,8 +55,13 @@ class ControllersModule extends abstract_1.BaseServerModule {
                     parameterMetadata.forEach((param) => {
                         switch (param.type) {
                             case Parameters_1.ParameterType.BODY:
-                                args[param.index] =
-                                    param.data && req.body ? req.body[param.data] : req.body;
+                                if (param.data) {
+                                    const body = req.body;
+                                    args[param.index] = body ? body[param.data] : undefined;
+                                }
+                                else {
+                                    args[param.index] = req.body;
+                                }
                                 break;
                             case Parameters_1.ParameterType.PARAM:
                                 args[param.index] = param.data

package/dist/modules/CorsModule.d.ts

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

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