@abejarano/ts-express-server 1.6.0 → 1.7.0

package/dist/abstract/ServerTypes.d.ts

@@ -24,6 +24,15 @@ export interface ServerResponse {
     send(body: unknown): void | Promise<void>;
     set(name: string, value: string): this;
     header(name: string, value: string): this;
+    cookie?(name: string, value: string, options?: {
+        maxAge?: number;
+        domain?: string;
+        path?: string;
+        expires?: Date;
+        httpOnly?: boolean;
+        secure?: boolean;
+        sameSite?: "lax" | "strict" | "none";
+    }): this;
     end(body?: unknown): void | Promise<void>;
 }
 export type ServerHandlerInput = ServerHandler | ServerHandler[] | ServerRouter;

package/dist/adapters/BunAdapter.d.ts

@@ -1,4 +1,4 @@
-import { ServerAdapter, ServerApp, ServerInstance, ServerRouter, ServerRuntime } from "../abstract/ServerTypes";
+import { ServerAdapter, ServerApp, ServerInstance, ServerRequest, ServerRouter, ServerRuntime } from "../abstract/ServerTypes";
 export declare class BunAdapter implements ServerAdapter {
     runtime: ServerRuntime;
     createApp(): ServerApp;
@@ -6,3 +6,13 @@ export declare class BunAdapter implements ServerAdapter {
     configure(app: ServerApp, _port: number): void;
     listen(app: ServerApp, port: number, onListen: () => void): ServerInstance;
 }
+type MultipartFile = {
+    name: string;
+    size: number;
+    type: string;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    lastModified?: number;
+};
+export declare function getFiles(req: ServerRequest, field: string): MultipartFile[];
+export declare function getFile(req: ServerRequest, field: string): MultipartFile | undefined;
+export {};

package/dist/adapters/BunAdapter.js

@@ -1,28 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BunAdapter = void 0;
+exports.getFiles = getFiles;
+exports.getFile = getFile;
 const ServerTypes_1 = require("../abstract/ServerTypes");
 class BunResponse {
-    constructor() {
+    constructor(cookieJar, handlerTimeoutMs) {
         this.statusCode = 200;
+        this.statusExplicitlySet = false;
         this.headers = new Headers();
+        this.setCookies = [];
         this.body = null;
         this.ended = false;
+        this.cookieJar = cookieJar;
+        this.handlerTimeoutMs = handlerTimeoutMs;
         this.endPromise = new Promise((resolve) => {
             this.resolveEnd = resolve;
         });
     }
     status(code) {
+        this.statusExplicitlySet = true;
         this.statusCode = code;
         return this;
     }
     set(name, value) {
+        if (name.toLowerCase() === "set-cookie") {
+            this.setCookies.push(value);
+            return this;
+        }
         this.headers.set(name, value);
         return this;
     }
     header(name, value) {
         return this.set(name, value);
     }
+    cookie(name, value, options = {}) {
+        if (this.cookieJar && typeof this.cookieJar.set === "function") {
+            this.cookieJar.set(name, value, toCookieJarOptions(options));
+            return this;
+        }
+        this.setCookies.push(serializeCookie(name, value, options));
+        return this;
+    }
     json(body) {
         if (!this.headers.has("content-type")) {
             this.headers.set("content-type", "application/json");
@@ -71,13 +90,47 @@ class BunResponse {
     waitForEnd() {
         return this.endPromise;
     }
+    getHandlerTimeoutMs() {
+        return this.handlerTimeoutMs;
+    }
     toResponse() {
         if (this.rawResponse) {
-            return this.rawResponse;
+            const headerMap = new Map();
+            const setCookies = readSetCookieHeaders(this.rawResponse.headers);
+            this.rawResponse.headers.forEach((value, key) => {
+                if (key.toLowerCase() === "set-cookie") {
+                    return;
+                }
+                headerMap.set(key.toLowerCase(), value);
+            });
+            this.headers.forEach((value, key) => {
+                headerMap.set(key.toLowerCase(), value);
+            });
+            setCookies.push(...this.setCookies);
+            const headersInit = [];
+            headerMap.forEach((value, key) => {
+                headersInit.push([key, value]);
+            });
+            for (const cookie of setCookies) {
+                headersInit.push(["set-cookie", cookie]);
+            }
+            return new Response(this.rawResponse.body, {
+                status: this.statusExplicitlySet
+                    ? this.statusCode
+                    : this.rawResponse.status,
+                headers: headersInit,
+            });
+        }
+        const headersInit = [];
+        this.headers.forEach((value, key) => {
+            headersInit.push([key, value]);
+        });
+        for (const cookie of this.setCookies) {
+            headersInit.push(["set-cookie", cookie]);
         }
         return new Response(this.body, {
             status: this.statusCode,
-            headers: this.headers,
+            headers: headersInit,
         });
     }
 }
@@ -128,14 +181,41 @@ class BunRouter {
             ...(routeMatch ? routeMatch.route.handlers : []),
         ];
         let chainCompleted = false;
+        let timeoutId;
+        let timedOut = false;
+        const timeoutMs = res.getHandlerTimeoutMs();
+        const timeoutPromise = typeof timeoutMs === "number" && timeoutMs > 0
+            ? new Promise((resolve) => {
+                timeoutId = setTimeout(() => {
+                    timedOut = true;
+                    if (!res.isEnded()) {
+                        res.status(504).json({ message: "Handler timeout" });
+                    }
+                    resolve(false);
+                }, timeoutMs);
+            })
+            : null;
         try {
-            chainCompleted = await runHandlers(handlers, req, res);
+            chainCompleted = timeoutPromise
+                ? await Promise.race([runHandlers(handlers, req, res), timeoutPromise])
+                : await runHandlers(handlers, req, res);
         }
         catch (error) {
-            res.status(500).json({ message: "Internal server error" });
+            if (!res.isEnded()) {
+                res.status(500).json({ message: "Internal server error" });
+            }
             done(error);
             return;
         }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }
+        if (timedOut) {
+            done();
+            return;
+        }
         if (!routeMatch) {
             if (chainCompleted && !res.isEnded() && !suppressNotFound) {
                 res.status(404).json({ message: "Not found" });
@@ -195,11 +275,25 @@ class BunRouter {
     }
 }
 class BunApp extends BunRouter {
+    constructor() {
+        super(...arguments);
+        this.settings = new Map();
+    }
+    set(key, value) {
+        this.settings.set(key, value);
+    }
+    get(key) {
+        return this.settings.get(key);
+    }
     createFetchHandler() {
         return async (request, server) => {
             const client = server?.requestIP?.(request);
-            const req = createRequest(request, client?.address);
-            const res = new BunResponse();
+            const cookieJar = request.cookies;
+            const handlerTimeoutMs = this.get("handlerTimeoutMs");
+            const trustProxy = this.get("trustProxy") === true;
+            const ipOverride = trustProxy ? undefined : client?.address;
+            const req = createRequest(request, ipOverride);
+            const res = new BunResponse(cookieJar, typeof handlerTimeoutMs === "number" ? handlerTimeoutMs : undefined);
             await this.handle(req, res, () => undefined);
             if (!res.isEnded()) {
                 res.status(204).end();
@@ -220,8 +314,9 @@ class BunAdapter {
     }
     configure(app, _port) {
         const bunApp = app;
-        bunApp.use(parseJsonBody);
-        bunApp.use(parseUrlEncodedBody);
+        bunApp.use(createMultipartBodyParser(bunApp));
+        bunApp.use(createJsonBodyParser(bunApp));
+        bunApp.use(createUrlEncodedBodyParser(bunApp));
     }
     listen(app, port, onListen) {
         const bunApp = app;
@@ -239,33 +334,121 @@ class BunAdapter {
     }
 }
 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 createJsonBodyParser = (app) => {
+    return 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();
+        }
+        const limit = getBodyLimit(app);
+        const contentLength = parseContentLength(req.headers["content-length"]);
+        if (contentLength !== undefined && contentLength > limit) {
+            res.status(413).json({ message: "Payload too large" });
+            return;
+        }
+        try {
+            req.body = await req.raw.json();
+        }
+        catch {
+            res.status(400).json({ message: "Invalid JSON" });
+            return;
+        }
+        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();
+const createUrlEncodedBodyParser = (app) => {
+    return 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 limit = getBodyLimit(app);
+        const contentLength = parseContentLength(req.headers["content-length"]);
+        if (contentLength !== undefined && contentLength > limit) {
+            res.status(413).json({ message: "Payload too large" });
+            return;
+        }
+        const text = await req.raw.text();
+        req.body = Object.fromEntries(new URLSearchParams(text));
+        next();
+    };
+};
+const createMultipartBodyParser = (app) => {
+    return async (req, res, next) => {
+        if (!req.raw || req.body !== undefined) {
+            return next();
+        }
+        const contentType = String(req.headers["content-type"] || "");
+        if (!contentType.includes("multipart/form-data")) {
+            return next();
+        }
+        const options = normalizeMultipartOptions(app.get("multipart"));
+        const lengthHeader = req.headers["content-length"];
+        const contentLength = parseContentLength(lengthHeader);
+        if (contentLength !== undefined && contentLength > options.maxBodyBytes) {
+            res.status(413).json({ message: "Payload too large" });
+            return;
+        }
+        try {
+            const formData = await req.raw.formData();
+            const fields = {};
+            const files = {};
+            let fileCount = 0;
+            for (const [key, value] of formData.entries()) {
+                if (isFile(value)) {
+                    if (value.size > options.maxFileBytes) {
+                        res.status(413).json({ message: "Payload too large" });
+                        return;
+                    }
+                    if (!isMimeAllowed(value.type, options.allowedMimeTypes)) {
+                        res.status(415).json({ message: "Unsupported media type" });
+                        return;
+                    }
+                    fileCount += 1;
+                    if (fileCount > options.maxFiles) {
+                        res.status(413).json({ message: "Payload too large" });
+                        return;
+                    }
+                    const bucket = files[key];
+                    if (bucket) {
+                        bucket.push(value);
+                    }
+                    else {
+                        files[key] = [value];
+                    }
+                    continue;
+                }
+                const existing = fields[key];
+                const textValue = String(value);
+                if (existing === undefined) {
+                    fields[key] = textValue;
+                }
+                else if (Array.isArray(existing)) {
+                    existing.push(textValue);
+                }
+                else {
+                    fields[key] = [existing, textValue];
+                }
+            }
+            if (Object.keys(fields).length > 0) {
+                req.body = fields;
+            }
+            if (Object.keys(files).length > 0) {
+                req.files = files;
+            }
+        }
+        catch {
+            res.status(400).json({ message: "Invalid multipart form data" });
+            return;
+        }
+        next();
+    };
 };
 function createRequest(request, ipOverride) {
     const url = new URL(request.url);
@@ -306,6 +489,109 @@ function toQueryRecord(search) {
     }
     return record;
 }
+const DEFAULT_MULTIPART_OPTIONS = {
+    maxBodyBytes: 10 * 1024 * 1024,
+    maxFileBytes: 10 * 1024 * 1024,
+    maxFiles: 10,
+};
+function serializeCookie(name, value, options) {
+    const parts = [`${name}=${encodeURIComponent(value)}`];
+    if (options.maxAge !== undefined) {
+        const maxAgeSeconds = Math.floor(options.maxAge / 1000);
+        parts.push(`Max-Age=${maxAgeSeconds}`);
+        if (!options.expires) {
+            parts.push(`Expires=${new Date(Date.now() + options.maxAge).toUTCString()}`);
+        }
+    }
+    if (options.domain) {
+        parts.push(`Domain=${options.domain}`);
+    }
+    if (options.path) {
+        parts.push(`Path=${options.path}`);
+    }
+    if (options.expires) {
+        parts.push(`Expires=${options.expires.toUTCString()}`);
+    }
+    if (options.httpOnly) {
+        parts.push("HttpOnly");
+    }
+    if (options.secure || options.sameSite === "none") {
+        parts.push("Secure");
+    }
+    if (options.sameSite) {
+        const normalized = options.sameSite === "none"
+            ? "None"
+            : options.sameSite === "strict"
+                ? "Strict"
+                : "Lax";
+        parts.push(`SameSite=${normalized}`);
+    }
+    return parts.join("; ");
+}
+function toCookieJarOptions(options) {
+    const sameSite = options.sameSite === "none"
+        ? "None"
+        : options.sameSite === "strict"
+            ? "Strict"
+            : options.sameSite === "lax"
+                ? "Lax"
+                : undefined;
+    const maxAge = options.maxAge === undefined
+        ? undefined
+        : Math.floor(options.maxAge / 1000);
+    return {
+        maxAge,
+        domain: options.domain,
+        path: options.path,
+        expires: options.expires,
+        httpOnly: options.httpOnly,
+        secure: options.secure || options.sameSite === "none",
+        sameSite,
+    };
+}
+function getBodyLimit(app) {
+    return normalizeMultipartOptions(app.get("multipart")).maxBodyBytes;
+}
+function normalizeMultipartOptions(input) {
+    if (!input || typeof input !== "object") {
+        return { ...DEFAULT_MULTIPART_OPTIONS };
+    }
+    const value = input;
+    return {
+        maxBodyBytes: value.maxBodyBytes ?? DEFAULT_MULTIPART_OPTIONS.maxBodyBytes,
+        maxFileBytes: value.maxFileBytes ?? DEFAULT_MULTIPART_OPTIONS.maxFileBytes,
+        maxFiles: value.maxFiles ?? DEFAULT_MULTIPART_OPTIONS.maxFiles,
+        allowedMimeTypes: value.allowedMimeTypes,
+    };
+}
+function isMimeAllowed(type, allowed) {
+    if (!allowed || allowed.length === 0) {
+        return true;
+    }
+    const normalized = type.toLowerCase();
+    for (const entry of allowed) {
+        const rule = entry.toLowerCase();
+        if (rule.endsWith("/*")) {
+            const prefix = rule.slice(0, -1);
+            if (normalized.startsWith(prefix)) {
+                return true;
+            }
+            continue;
+        }
+        if (normalized === rule) {
+            return true;
+        }
+    }
+    return false;
+}
+function isFile(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    return (typeof value.arrayBuffer === "function" &&
+        typeof value.name === "string" &&
+        typeof value.size === "number");
+}
 function parseCookies(cookieHeader) {
     if (!cookieHeader) {
         return undefined;
@@ -316,10 +602,47 @@ function parseCookies(cookieHeader) {
         if (!name) {
             return;
         }
-        cookies[name] = decodeURIComponent(rest.join("="));
+        try {
+            cookies[name] = decodeURIComponent(rest.join("="));
+        }
+        catch {
+            cookies[name] = rest.join("=");
+        }
     });
     return cookies;
 }
+function parseContentLength(header) {
+    if (header === undefined) {
+        return undefined;
+    }
+    const value = Array.isArray(header) ? header[0] : header;
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+function readSetCookieHeaders(headers) {
+    const bunHeaders = headers;
+    const setCookieFromApi = bunHeaders.getSetCookie?.() ?? bunHeaders.getAll?.("Set-Cookie");
+    if (setCookieFromApi && setCookieFromApi.length > 0) {
+        return setCookieFromApi;
+    }
+    const setCookies = [];
+    headers.forEach((value, key) => {
+        if (key.toLowerCase() === "set-cookie") {
+            setCookies.push(value);
+        }
+    });
+    return setCookies;
+}
+function getFiles(req, field) {
+    const map = (req.files ?? {});
+    return map[field] ?? [];
+}
+function getFile(req, field) {
+    return getFiles(req, field)[0];
+}
 function extractIp(headers) {
     const forwarded = headers["x-forwarded-for"];
     if (forwarded) {

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 { ServerHandler } from "../abstract";
 import "reflect-metadata";
-export declare function Use(middleware: ServerHandler | ServerHandler[]): (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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@abejarano/ts-express-server",
   "author": "angel bejarano / angel.bejarano@jaspesoft.com",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [