@tsed/platform-express 8.19.4 → 8.20.0

package/lib/esm/components/PlatformExpress.js

@@ -2,7 +2,7 @@ import "@tsed/platform-multer/express";
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { catchAsyncError, Env, isFunction } from "@tsed/core";
+import { catchAsyncError, Env, isArray, isFunction } from "@tsed/core";
 import { constant, inject, logger, runInContext } from "@tsed/di";
 import { PlatformExceptions } from "@tsed/platform-exceptions";
 import { adapter, application, createContext, PlatformAdapter, PlatformBuilder, PlatformHandler, PlatformResponse } from "@tsed/platform-http";
@@ -19,6 +19,10 @@ function callNext(next, metadata, $ctx) {
 }
 function getVersion() {
     try {
+        const v = constant("express.version");
+        if (v) {
+            return v;
+        }
         const { version } = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.resolve("express"))), "package.json"), "utf8"));
         return `v${version.split(".")[0]}`;
     }
@@ -94,6 +98,12 @@ export class PlatformExpress extends PlatformAdapter {
                     if (req.params["0"] && !req.params[wildcard]) {
                         req.params[wildcard] = req.params["0"];
                     }
+                    if (isArray(req.params[wildcard])) {
+                        req.params[wildcard] = req.params[wildcard].join("/");
+                    }
+                    if (wildcard === "wildcard") {
+                        req.params["*"] ||= req.params[wildcard];
+                    }
                     next();
                 }));
             }

package/lib/esm/services/PlatformExpressResponse.js

@@ -1,11 +1,17 @@
-import { isNumber } from "@tsed/core";
+import { isArray, isNumber } from "@tsed/core";
 import { PlatformResponse } from "@tsed/platform-http";
 export class PlatformExpressResponse extends PlatformResponse {
+    cookie(name, value, opts) {
+        super.cookie(name, value, opts);
+        const cookie = this.get("set-cookie");
+        if (cookie && !isArray(value)) {
+            this.setHeader("set-cookie", [].concat(cookie));
+        }
+        return this;
+    }
     end(data) {
         if (isNumber(data)) {
-            // TODO remove this when Express 5 will be the default version of Ts.ED
-            // @ts-ignore
-            this.raw.send(this.statusCode, data);
+            this.raw.send(String(data));
         }
         else {
             this.raw.send(data);

package/lib/esm/utils/convertPath.js

@@ -3,77 +3,109 @@ import { isString } from "@tsed/core";
  * Converts a path to v4 format
  */
 function convertPathToV4(path) {
-    const segments = path.split("/");
-    const parsed = segments.reduce((options, segment, index) => {
-        const isLastSegment = index === segments.length - 1;
-        if (isLastSegment && (segment === "*" || segment === "(.*)")) {
-            options.wildcard = "*";
-            options.path.push("*");
-            return options;
-        }
-        if (isLastSegment && segment.startsWith("*")) {
-            options.wildcard = segment.substring(1);
-            options.path.push("*");
-            return options;
-        }
-        if (segment.startsWith(":") && segment.endsWith("*")) {
-            options.wildcard = segment.substring(1, segment.length - 1);
-            options.path.push("*");
-            return options;
-        }
-        if (segment.startsWith("{")) {
-            // Handle v5 style parameters like /{param}
-            const paramName = segment.substring(1, segment.length - 1);
-            options.path.push(`${paramName}?`);
-            return options;
+    // Preserve unsupported/complex patterns
+    // Keep paths with bracket choices or middle wildcards intact
+    if (path.includes("[") || (path.includes("(.*)") && !path.endsWith("/(.*)") && path !== "/(.*)")) {
+        return { path };
+    }
+    let wildcard;
+    let result = path;
+    // v5 optional segment syntax -> v4 optional param
+    // e.g. "/test{/:foo}{/:param}" -> "/test/:foo?/:param?"
+    result = result.replace(/\{\/:([A-Za-z0-9_]+)\}/g, "/:$1?");
+    // e.g. "/test/:foo/{:param}" -> "/test/:foo/:param"
+    result = result.replace(/\{:([A-Za-z0-9_]+)\}/g, ":$1");
+    // Trailing v5 wildcard segment -> v4
+    result = result.replace(/\/{\*([A-Za-z0-9_]+)\}$/g, (_m, name) => {
+        wildcard = name;
+        return "/*";
+    });
+    const segments = result.split("/");
+    const last = segments[segments.length - 1];
+    if (last === "*" || last === "(.*)") {
+        wildcard = "*";
+        if (last === "(.*)") {
+            segments[segments.length - 1] = "*";
+            result = segments.join("/");
         }
-        options.path.push(segment);
-        return options;
-    }, { path: [], wildcard: undefined });
-    return {
-        path: parsed.path.join("/"),
-        wildcard: parsed.wildcard
-    };
+        return { path: result, wildcard };
+    }
+    // Trailing *name -> wildcard name for v4
+    if (last && last.startsWith("*") && last.length > 1) {
+        wildcard = last.substring(1);
+        segments[segments.length - 1] = "*";
+        result = segments.join("/");
+        return { path: result, wildcard };
+    }
+    // Ts.ED syntax :param* -> v4 "*"
+    if (last && last.startsWith(":") && last.endsWith("*")) {
+        wildcard = last.substring(1, last.length - 1);
+        segments[segments.length - 1] = "*";
+        result = segments.join("/");
+        return { path: result, wildcard };
+    }
+    return { path: result, wildcard };
 }
 /**
  * Converts a path to v5 format
  */
 function convertPathToV5(path) {
+    // Preserve unsupported/complex patterns
+    if (path.includes("[") || (path.includes("(.*)") && !path.endsWith("/(.*)") && path !== "/(.*)")) {
+        return { path };
+    }
+    // Already v5-style specific constructs should be preserved
+    if (/\/{\*[^}]+\}/.test(path) || /\{:[^}]+\}/.test(path) || /\{\/:[^}]+\}/.test(path)) {
+        const m = path.match(/\/{\*([^}]+)\}$/);
+        return { path, wildcard: m ? m[1] : undefined };
+    }
     const segments = path.split("/");
-    const parsed = segments.reduce((options, segment, index) => {
-        const isLastSegment = index === segments.length - 1;
-        if (isLastSegment && (segment === "*" || segment === "(.*)")) {
-            options.wildcard = "*";
-            options.path.push("{*wildcard}");
-            return options;
+    const base = [];
+    const optionals = [];
+    let wildcard;
+    segments.forEach((seg, idx) => {
+        if (idx === 0)
+            return; // first split is empty because path starts with '/'
+        const isLast = idx === segments.length - 1;
+        // Trailing raw wildcard
+        if (isLast && (seg === "*" || seg === "(.*)")) {
+            wildcard = "wildcard";
+            optionals.push("/{*wildcard}");
+            return;
         }
-        if (isLastSegment && segment.startsWith("*")) {
-            options.wildcard = segment.substring(1);
-            options.path.push(segment);
-            return options;
+        // Trailing named wildcard forms
+        if (isLast && seg.startsWith(":") && seg.endsWith("*")) {
+            wildcard = seg.substring(1, seg.length - 1);
+            optionals.push(`/{*${wildcard}}`);
+            return;
         }
-        if (segment.startsWith(":")) {
-            if (segment.endsWith("?")) {
-                options.path.push(`{:${segment.substring(1, segment.length - 1)}}`);
-                return options;
-            }
-            if (isLastSegment && segment.endsWith("*")) {
-                options.wildcard = segment.substring(1, segment.length - 1);
-                options.path.push(`{*${options.wildcard}}`);
-                return options;
-            }
+        if (isLast && seg.startsWith("*") && seg.length > 1) {
+            wildcard = seg.substring(1);
+            base.push(seg); // keep as-is according to spec for v5
+            return;
         }
-        if (isLastSegment && segment.startsWith("{*")) {
-            // Handle v5 style parameters like /{param}
-            options.wildcard = segment.substring(2, segment.length - 1);
+        // Optional parameter -> v5 optional segment
+        if (seg.startsWith(":") && seg.endsWith("?")) {
+            const name = seg.substring(1, seg.length - 1);
+            optionals.push(`{/:${name}}`);
+            return;
         }
-        options.path.push(segment);
-        return options;
-    }, { path: [], wildcard: undefined });
-    return {
-        path: parsed.path.join("/"),
-        wildcard: parsed.wildcard
-    };
+        // Keep everything else (including non-optional params)
+        base.push(seg);
+    });
+    let result = "/" + base.join("/");
+    // Collapse double slash when base is empty
+    if (result === "/") {
+        result = "";
+    }
+    result += optionals.join("");
+    // If named wildcard kept as segment like '/*splat', leave as-is (handled above)
+    if (!result) {
+        // Edge case when path was only optional param like "/:param?"
+        // base is empty -> result becomes optionals only
+        result = optionals.join("");
+    }
+    return { path: result || "/", wildcard };
 }
 /**
  * Converts a path between v4 and v5 formats

package/lib/types/interfaces/PlatformExpressSettings.d.ts

@@ -2,6 +2,10 @@ import type { Options, OptionsJson, OptionsText, OptionsUrlencoded } from "body-
 import type { NextHandleFunction } from "connect";
 import type { RouterOptions } from "express";
 export interface PlatformExpressSettings {
+    /**
+     * Force Express version detection. Use when Ts.ED doesn't detect the version automatically.
+     */
+    version?: "v4" | "v5";
     /**
      * Global configuration for the Express.Router. See express [documentation](http://expressjs.com/en/api.html#express.router).
      */

package/lib/types/services/PlatformExpressResponse.d.ts

@@ -1,4 +1,5 @@
 import { PlatformResponse } from "@tsed/platform-http";
 export declare class PlatformExpressResponse extends PlatformResponse<TsED.Response> {
-    protected end(data?: string | Buffer): void;
+    cookie(name: string, value: string | null, opts?: TsED.SetCookieOpts): this;
+    protected end(data?: number | string | Buffer): void;
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/platform-express",
   "description": "A TypeScript Framework on top of Express",
   "type": "module",
-  "version": "8.19.4",
+  "version": "8.20.0",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
@@ -58,17 +58,17 @@
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.19.4",
-    "@tsed/core": "8.19.4",
-    "@tsed/di": "8.19.4",
-    "@tsed/platform-http": "8.19.4",
-    "@tsed/platform-test-sdk": "8.19.4",
-    "@tsed/platform-views": "8.19.4",
-    "@tsed/typescript": "8.19.4",
+    "@tsed/barrels": "8.20.0",
+    "@tsed/core": "8.20.0",
+    "@tsed/di": "8.20.0",
+    "@tsed/platform-http": "8.20.0",
+    "@tsed/platform-test-sdk": "8.20.0",
+    "@tsed/platform-views": "8.20.0",
+    "@tsed/typescript": "8.20.0",
     "@types/body-parser": "1.19.5",
     "@types/compression": "1.7.5",
     "@types/cookie-parser": "1.4.7",
-    "@types/express": "^4.17.21",
+    "@types/express": "^5.0.6",
     "@types/express-session": "1.18.1",
     "@types/method-override": "0.0.35",
     "body-parser": "2.2.0",
@@ -77,7 +77,7 @@
     "cors": "2.8.5",
     "cross-env": "7.0.3",
     "eslint": "9.12.0",
-    "express": "^4.21.0",
+    "express": "5.2.1",
     "express-session": "1.18.1",
     "method-override": "3.0.0",
     "typescript": "5.9.3",