@abejarano/ts-express-server 1.5.2 → 1.6.0

package/dist/adapters/BunAdapter.js

@@ -0,0 +1,418 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BunAdapter = void 0;
+const ServerTypes_1 = require("../abstract/ServerTypes");
+class BunResponse {
+    constructor() {
+        this.statusCode = 200;
+        this.headers = new Headers();
+        this.body = null;
+        this.ended = false;
+        this.endPromise = new Promise((resolve) => {
+            this.resolveEnd = resolve;
+        });
+    }
+    status(code) {
+        this.statusCode = code;
+        return this;
+    }
+    set(name, value) {
+        this.headers.set(name, value);
+        return this;
+    }
+    header(name, value) {
+        return this.set(name, value);
+    }
+    json(body) {
+        if (!this.headers.has("content-type")) {
+            this.headers.set("content-type", "application/json");
+        }
+        this.body = JSON.stringify(body ?? null);
+        this.ended = true;
+        this.resolveEnd?.();
+    }
+    send(body) {
+        if (body instanceof Response) {
+            this.rawResponse = body;
+            this.ended = true;
+            this.resolveEnd?.();
+            return;
+        }
+        if (typeof body === "string" || body instanceof Uint8Array) {
+            this.body = body;
+            this.ended = true;
+            this.resolveEnd?.();
+            return;
+        }
+        if (body === undefined) {
+            this.body = null;
+            this.ended = true;
+            this.resolveEnd?.();
+            return;
+        }
+        if (!this.headers.has("content-type")) {
+            this.headers.set("content-type", "application/json");
+        }
+        this.body = JSON.stringify(body);
+        this.ended = true;
+        this.resolveEnd?.();
+    }
+    end(body) {
+        if (body !== undefined) {
+            this.send(body);
+            return;
+        }
+        this.ended = true;
+        this.resolveEnd?.();
+    }
+    isEnded() {
+        return this.ended;
+    }
+    waitForEnd() {
+        return this.endPromise;
+    }
+    toResponse() {
+        if (this.rawResponse) {
+            return this.rawResponse;
+        }
+        return new Response(this.body, {
+            status: this.statusCode,
+            headers: this.headers,
+        });
+    }
+}
+class BunRouter {
+    constructor() {
+        this.middlewares = [];
+        this.routes = [];
+    }
+    use(pathOrHandler, ...handlers) {
+        if (typeof pathOrHandler === "string") {
+            const path = pathOrHandler;
+            const resolvedHandlers = normalizeHandlers(handlers).map((handler) => handler instanceof BunRouter
+                ? this.wrapRouter(handler, path)
+                : handler);
+            this.middlewares.push({ path, handlers: resolvedHandlers });
+            return;
+        }
+        const resolvedHandlers = normalizeHandlers([pathOrHandler, ...handlers]);
+        const wrappedHandlers = resolvedHandlers.map((handler) => handler instanceof BunRouter
+            ? this.wrapRouter(handler)
+            : handler);
+        this.middlewares.push({ handlers: wrappedHandlers });
+    }
+    get(path, ...handlers) {
+        this.routes.push({ method: "GET", path, handlers });
+    }
+    post(path, ...handlers) {
+        this.routes.push({ method: "POST", path, handlers });
+    }
+    put(path, ...handlers) {
+        this.routes.push({ method: "PUT", path, handlers });
+    }
+    delete(path, ...handlers) {
+        this.routes.push({ method: "DELETE", path, handlers });
+    }
+    patch(path, ...handlers) {
+        this.routes.push({ method: "PATCH", path, handlers });
+    }
+    async handle(req, res, done, pathOverride, suppressNotFound) {
+        const path = normalizePath(pathOverride ?? req.path);
+        const middlewares = this.collectMiddlewares(path);
+        const routeMatch = this.matchRoute(req.method, path);
+        if (routeMatch) {
+            req.params = routeMatch.params;
+        }
+        const handlers = [
+            ...middlewares.flatMap((mw) => mw.handlers),
+            ...(routeMatch ? routeMatch.route.handlers : []),
+        ];
+        let chainCompleted = false;
+        try {
+            chainCompleted = await runHandlers(handlers, req, res);
+        }
+        catch (error) {
+            res.status(500).json({ message: "Internal server error" });
+            done(error);
+            return;
+        }
+        if (!routeMatch) {
+            if (chainCompleted && !res.isEnded() && !suppressNotFound) {
+                res.status(404).json({ message: "Not found" });
+            }
+            if (chainCompleted) {
+                done();
+            }
+            return;
+        }
+        if (chainCompleted) {
+            done();
+        }
+    }
+    collectMiddlewares(path) {
+        return this.middlewares.filter((layer) => {
+            if (!layer.path) {
+                return true;
+            }
+            const normalized = normalizePath(layer.path);
+            if (normalized === "/") {
+                return true;
+            }
+            return path === normalized || path.startsWith(`${normalized}/`);
+        });
+    }
+    matchRoute(method, path) {
+        for (const route of this.routes) {
+            if (route.method !== method.toUpperCase()) {
+                continue;
+            }
+            const match = matchPath(route.path, path);
+            if (match) {
+                return { route, params: match };
+            }
+        }
+        return null;
+    }
+    wrapRouter(router, basePath) {
+        return async (req, res, next) => {
+            if (!basePath) {
+                await router.handle(req, res, next, undefined, true);
+                return;
+            }
+            const normalizedBase = normalizePath(basePath);
+            const currentPath = normalizePath(req.path);
+            if (normalizedBase === "/") {
+                await router.handle(req, res, next, currentPath, true);
+                return;
+            }
+            if (currentPath !== normalizedBase &&
+                !currentPath.startsWith(`${normalizedBase}/`)) {
+                return next();
+            }
+            const nestedPath = stripPrefix(currentPath, normalizedBase);
+            await router.handle(req, res, next, nestedPath, true);
+        };
+    }
+}
+class BunApp extends BunRouter {
+    createFetchHandler() {
+        return async (request, server) => {
+            const client = server?.requestIP?.(request);
+            const req = createRequest(request, client?.address);
+            const res = new BunResponse();
+            await this.handle(req, res, () => undefined);
+            if (!res.isEnded()) {
+                res.status(204).end();
+            }
+            return res.toResponse();
+        };
+    }
+}
+class BunAdapter {
+    constructor() {
+        this.runtime = ServerTypes_1.ServerRuntime.Bun;
+    }
+    createApp() {
+        return new BunApp();
+    }
+    createRouter() {
+        return new BunRouter();
+    }
+    configure(app, _port) {
+        const bunApp = app;
+        bunApp.use(parseJsonBody);
+        bunApp.use(parseUrlEncodedBody);
+    }
+    listen(app, port, onListen) {
+        const bunApp = app;
+        const server = Bun.serve({
+            port,
+            fetch: bunApp.createFetchHandler(),
+        });
+        onListen();
+        return {
+            close: (callback) => {
+                server.stop(true);
+                callback?.();
+            },
+        };
+    }
+}
+exports.BunAdapter = BunAdapter;
+const parseJsonBody = async (req, _res, next) => {
+    if (!req.raw || req.body !== undefined) {
+        return next();
+    }
+    const contentType = String(req.headers["content-type"] || "");
+    if (!contentType.includes("application/json")) {
+        return next();
+    }
+    try {
+        req.body = await req.raw.json();
+    }
+    catch {
+        req.body = undefined;
+    }
+    next();
+};
+const parseUrlEncodedBody = async (req, _res, next) => {
+    if (!req.raw || req.body !== undefined) {
+        return next();
+    }
+    const contentType = String(req.headers["content-type"] || "");
+    if (!contentType.includes("application/x-www-form-urlencoded")) {
+        return next();
+    }
+    const text = await req.raw.text();
+    req.body = Object.fromEntries(new URLSearchParams(text));
+    next();
+};
+function createRequest(request, ipOverride) {
+    const url = new URL(request.url);
+    const headers = toHeaderRecord(request.headers);
+    const query = toQueryRecord(url.searchParams);
+    return {
+        method: request.method.toUpperCase(),
+        path: normalizePath(url.pathname),
+        originalUrl: url.pathname + url.search,
+        params: {},
+        query,
+        headers,
+        cookies: parseCookies(headers.cookie),
+        ip: ipOverride || extractIp(headers),
+        raw: request,
+    };
+}
+function toHeaderRecord(headers) {
+    const record = {};
+    headers.forEach((value, key) => {
+        record[key.toLowerCase()] = value;
+    });
+    return record;
+}
+function toQueryRecord(search) {
+    const record = {};
+    for (const [key, value] of search.entries()) {
+        const existing = record[key];
+        if (existing === undefined) {
+            record[key] = value;
+        }
+        else if (Array.isArray(existing)) {
+            existing.push(value);
+        }
+        else {
+            record[key] = [existing, value];
+        }
+    }
+    return record;
+}
+function parseCookies(cookieHeader) {
+    if (!cookieHeader) {
+        return undefined;
+    }
+    const cookies = {};
+    cookieHeader.split(";").forEach((entry) => {
+        const [name, ...rest] = entry.trim().split("=");
+        if (!name) {
+            return;
+        }
+        cookies[name] = decodeURIComponent(rest.join("="));
+    });
+    return cookies;
+}
+function extractIp(headers) {
+    const forwarded = headers["x-forwarded-for"];
+    if (forwarded) {
+        return forwarded.split(",")[0]?.trim();
+    }
+    return headers["x-real-ip"];
+}
+function normalizePath(path) {
+    if (!path.startsWith("/")) {
+        path = `/${path}`;
+    }
+    if (path.length > 1 && path.endsWith("/")) {
+        return path.slice(0, -1);
+    }
+    return path;
+}
+function stripPrefix(path, prefix) {
+    if (!path.startsWith(prefix)) {
+        return path;
+    }
+    const stripped = path.slice(prefix.length);
+    return normalizePath(stripped || "/");
+}
+function matchPath(routePath, requestPath) {
+    const normalizedRoute = normalizePath(routePath);
+    const normalizedRequest = normalizePath(requestPath);
+    if (normalizedRoute === normalizedRequest) {
+        return {};
+    }
+    const routeParts = normalizedRoute.split("/").filter(Boolean);
+    const requestParts = normalizedRequest.split("/").filter(Boolean);
+    if (routeParts.length !== requestParts.length) {
+        return null;
+    }
+    const params = {};
+    for (let index = 0; index < routeParts.length; index += 1) {
+        const routePart = routeParts[index];
+        const requestPart = requestParts[index];
+        if (routePart.startsWith(":")) {
+            params[routePart.slice(1)] = decodeURIComponent(requestPart);
+            continue;
+        }
+        if (routePart !== requestPart) {
+            return null;
+        }
+    }
+    return params;
+}
+function normalizeHandlers(inputs) {
+    const handlers = [];
+    for (const input of inputs) {
+        if (Array.isArray(input)) {
+            handlers.push(...input);
+            continue;
+        }
+        handlers.push(input);
+    }
+    return handlers;
+}
+async function runHandlers(handlers, req, res) {
+    let index = 0;
+    const dispatch = async () => {
+        const handler = handlers[index];
+        index += 1;
+        if (!handler) {
+            return true;
+        }
+        let nextCalled = false;
+        let nextPromise;
+        let resolveNext;
+        const nextSignal = new Promise((resolve) => {
+            resolveNext = resolve;
+        });
+        const wrappedNext = (nextErr) => {
+            if (nextErr) {
+                throw nextErr;
+            }
+            nextCalled = true;
+            resolveNext?.();
+            nextPromise = dispatch();
+            return nextPromise;
+        };
+        await handler(req, res, wrappedNext);
+        if (!nextCalled) {
+            if (res.isEnded()) {
+                return false;
+            }
+            await Promise.race([nextSignal, res.waitForEnd()]);
+            if (!nextCalled || res.isEnded()) {
+                return false;
+            }
+        }
+        return nextPromise ? await nextPromise : true;
+    };
+    return dispatch();
+}

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/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[]): (target: any, key?: string, descriptor?: PropertyDescriptor) => void;

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