@webiny/app 0.0.0-unstable.78f581c1d2 → 0.0.0-unstable.7be00a75a9

package/features/router/HistoryRouterGateway.test.js

@@ -0,0 +1,195 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createMemoryHistory } from "history";
+import { HistoryRouterGateway } from "./HistoryRouterGateway.js";
+import { RouteUrl } from "./RouteUrl.js";
+const wait = ()=>new Promise((resolve)=>setTimeout(resolve, 10));
+describe("Router Gateway", ()=>{
+    beforeEach(()=>{
+        vi.clearAllMocks();
+    });
+    it("should execute onMatch when history changes", async ()=>{
+        const spyHome = vi.fn();
+        const spyLogin = vi.fn();
+        const spyDynamic = vi.fn();
+        const history = createMemoryHistory();
+        history.replace("/__unknown__");
+        const gateway = new HistoryRouterGateway(history, "");
+        gateway.setRoutes([
+            {
+                name: "home",
+                path: "/",
+                onMatch: spyHome
+            },
+            {
+                name: "login",
+                path: "/login",
+                onMatch: spyLogin
+            },
+            {
+                name: "test",
+                path: "/dynamic-route/:name",
+                onMatch: spyDynamic
+            }
+        ]);
+        history.push("/login");
+        await wait();
+        history.push("/");
+        await wait();
+        history.push("/dynamic-route/cars");
+        await wait();
+        history.push("/login");
+        await wait();
+        history.push("/dynamic-route/blogs");
+        await wait();
+        history.push("/dynamic-route/blogs?search=123");
+        await wait();
+        expect(spyLogin).toHaveBeenCalledTimes(2);
+        expect(spyLogin).toHaveBeenNthCalledWith(1, {
+            name: "login",
+            path: "/login",
+            pathname: "/login",
+            params: {}
+        });
+        expect(spyLogin).toHaveBeenNthCalledWith(2, {
+            name: "login",
+            path: "/login",
+            pathname: "/login",
+            params: {}
+        });
+        expect(spyHome).toHaveBeenCalledTimes(1);
+        expect(spyHome).toHaveBeenLastCalledWith({
+            name: "home",
+            path: "/",
+            pathname: "/",
+            params: {}
+        });
+        expect(spyDynamic).toHaveBeenCalledTimes(3);
+        expect(spyDynamic).toHaveBeenNthCalledWith(1, {
+            name: "test",
+            path: "/dynamic-route/:name",
+            pathname: "/dynamic-route/cars",
+            params: {
+                name: "cars"
+            }
+        });
+        expect(spyDynamic).toHaveBeenNthCalledWith(2, {
+            name: "test",
+            path: "/dynamic-route/:name",
+            pathname: "/dynamic-route/blogs",
+            params: {
+                name: "blogs"
+            }
+        });
+        expect(spyDynamic).toHaveBeenNthCalledWith(3, {
+            name: "test",
+            path: "/dynamic-route/:name",
+            pathname: "/dynamic-route/blogs",
+            params: {
+                name: "blogs",
+                search: "123"
+            }
+        });
+    });
+    it("should generate route URLs", async ()=>{
+        const urls = [
+            RouteUrl.fromPattern("/"),
+            RouteUrl.fromPattern("/login", {}),
+            RouteUrl.fromPattern("/login", {
+                redirect: "/",
+                reason: "login"
+            }),
+            RouteUrl.fromPattern("/dynamic-route/:name", {
+                name: "cars"
+            }),
+            RouteUrl.fromPattern("/dynamic-route", {
+                folderId: "696556831e485d00027a1a0b#0001"
+            })
+        ];
+        expect(urls).toEqual([
+            "/",
+            "/login",
+            "/login?redirect=%2F&reason=login",
+            "/dynamic-route/cars",
+            "/dynamic-route?folderId=696556831e485d00027a1a0b%230001"
+        ]);
+    });
+    it("should handle baseUrl for route matching and URL generation", async ()=>{
+        const spyFileManager = vi.fn();
+        const spyHome = vi.fn();
+        const history = createMemoryHistory();
+        history.replace("/tenant123/__unknown__");
+        const gateway = new HistoryRouterGateway(history, "/tenant123");
+        gateway.setRoutes([
+            {
+                name: "home",
+                path: "/",
+                onMatch: spyHome
+            },
+            {
+                name: "fileManager",
+                path: "/file-manager",
+                onMatch: spyFileManager
+            }
+        ]);
+        history.push("/tenant123/file-manager");
+        await wait();
+        expect(spyFileManager).toHaveBeenCalledTimes(1);
+        expect(spyFileManager).toHaveBeenCalledWith({
+            name: "fileManager",
+            path: "/file-manager",
+            pathname: "/tenant123/file-manager",
+            params: {}
+        });
+        const urlWithBase = RouteUrl.fromPattern("/file-manager", {}, "/tenant123");
+        expect(urlWithBase).toBe("/tenant123/file-manager");
+        const urlWithBaseAndParams = RouteUrl.fromPattern("/file-manager", {
+            folder: "abc"
+        }, "/tenant123");
+        expect(urlWithBaseAndParams).toBe("/tenant123/file-manager?folder=abc");
+    });
+    it("should properly sort routes with wildcards always at the bottom", async ()=>{
+        const spyWildcard = vi.fn();
+        const spySpecific = vi.fn();
+        const spyHome = vi.fn();
+        const history = createMemoryHistory();
+        history.replace("/initial");
+        const gateway = new HistoryRouterGateway(history, "");
+        gateway.setRoutes([
+            {
+                name: "wildcard",
+                path: "*",
+                onMatch: spyWildcard
+            },
+            {
+                name: "home",
+                path: "/",
+                onMatch: spyHome
+            }
+        ]);
+        expect(spyWildcard).toHaveBeenCalledTimes(1);
+        vi.clearAllMocks();
+        gateway.setRoutes([
+            {
+                name: "specific",
+                path: "/specific-route",
+                onMatch: spySpecific
+            }
+        ]);
+        expect(spyWildcard).toHaveBeenCalledTimes(1);
+        vi.clearAllMocks();
+        history.push("/specific-route");
+        await wait();
+        expect(spySpecific).toHaveBeenCalledTimes(1);
+        expect(spyWildcard).toHaveBeenCalledTimes(0);
+        expect(spyHome).toHaveBeenCalledTimes(0);
+        history.push("/");
+        await wait();
+        expect(spyHome).toHaveBeenCalledTimes(1);
+        expect(spyWildcard).toHaveBeenCalledTimes(0);
+        history.push("/unknown");
+        await wait();
+        expect(spyWildcard).toHaveBeenCalledTimes(1);
+    });
+});
+
+//# sourceMappingURL=HistoryRouterGateway.test.js.map

package/features/router/HistoryRouterGateway.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/router/HistoryRouterGateway.test.js","sources":["../../../src/features/router/HistoryRouterGateway.test.ts"],"sourcesContent":["import { describe, it, beforeEach, expect, vi } from \"vitest\";\nimport { createMemoryHistory } from \"history\";\nimport { HistoryRouterGateway } from \"./HistoryRouterGateway.js\";\nimport { RouteUrl } from \"./RouteUrl.js\";\n\nconst wait = () => new Promise(resolve => setTimeout(resolve, 10));\n\ndescribe(\"Router Gateway\", () => {\n    beforeEach(() => {\n        vi.clearAllMocks();\n    });\n\n    it(\"should execute onMatch when history changes\", async () => {\n        const spyHome = vi.fn();\n        const spyLogin = vi.fn();\n        const spyDynamic = vi.fn();\n\n        // Create `history` and set the initial pathname to an unknown route\n        const history = createMemoryHistory();\n        history.replace(\"/__unknown__\");\n\n        const gateway = new HistoryRouterGateway(history, \"\");\n        gateway.setRoutes([\n            { name: \"home\", path: \"/\", onMatch: spyHome },\n            { name: \"login\", path: \"/login\", onMatch: spyLogin },\n            { name: \"test\", path: \"/dynamic-route/:name\", onMatch: spyDynamic }\n        ]);\n\n        history.push(\"/login\");\n        await wait();\n        history.push(\"/\");\n        await wait();\n        history.push(\"/dynamic-route/cars\");\n        await wait();\n        history.push(\"/login\");\n        await wait();\n        history.push(\"/dynamic-route/blogs\");\n        await wait();\n        history.push(\"/dynamic-route/blogs?search=123\");\n        await wait();\n\n        expect(spyLogin).toHaveBeenCalledTimes(2);\n        expect(spyLogin).toHaveBeenNthCalledWith(1, {\n            name: \"login\",\n            path: \"/login\",\n            pathname: \"/login\",\n            params: {}\n        });\n        expect(spyLogin).toHaveBeenNthCalledWith(2, {\n            name: \"login\",\n            path: \"/login\",\n            pathname: \"/login\",\n            params: {}\n        });\n        expect(spyHome).toHaveBeenCalledTimes(1);\n        expect(spyHome).toHaveBeenLastCalledWith({\n            name: \"home\",\n            path: \"/\",\n            pathname: \"/\",\n            params: {}\n        });\n        expect(spyDynamic).toHaveBeenCalledTimes(3);\n        expect(spyDynamic).toHaveBeenNthCalledWith(1, {\n            name: \"test\",\n            path: \"/dynamic-route/:name\",\n            pathname: \"/dynamic-route/cars\",\n            params: {\n                name: \"cars\"\n            }\n        });\n        expect(spyDynamic).toHaveBeenNthCalledWith(2, {\n            name: \"test\",\n            path: \"/dynamic-route/:name\",\n            pathname: \"/dynamic-route/blogs\",\n            params: {\n                name: \"blogs\"\n            }\n        });\n        expect(spyDynamic).toHaveBeenNthCalledWith(3, {\n            name: \"test\",\n            path: \"/dynamic-route/:name\",\n            pathname: \"/dynamic-route/blogs\",\n            params: {\n                name: \"blogs\",\n                search: \"123\"\n            }\n        });\n    });\n\n    it(\"should generate route URLs\", async () => {\n        const urls = [\n            RouteUrl.fromPattern(\"/\"),\n            RouteUrl.fromPattern(\"/login\", {}),\n            RouteUrl.fromPattern(\"/login\", { redirect: \"/\", reason: \"login\" }),\n            RouteUrl.fromPattern(\"/dynamic-route/:name\", { name: \"cars\" }),\n            RouteUrl.fromPattern(\"/dynamic-route\", { folderId: \"696556831e485d00027a1a0b#0001\" })\n        ];\n        expect(urls).toEqual([\n            \"/\",\n            \"/login\",\n            \"/login?redirect=%2F&reason=login\",\n            \"/dynamic-route/cars\",\n            \"/dynamic-route?folderId=696556831e485d00027a1a0b%230001\"\n        ]);\n    });\n\n    it(\"should handle baseUrl for route matching and URL generation\", async () => {\n        const spyFileManager = vi.fn();\n        const spyHome = vi.fn();\n\n        // Create history with a tenant prefix\n        const history = createMemoryHistory();\n        history.replace(\"/tenant123/__unknown__\");\n\n        const gateway = new HistoryRouterGateway(history, \"/tenant123\");\n        gateway.setRoutes([\n            { name: \"home\", path: \"/\", onMatch: spyHome },\n            { name: \"fileManager\", path: \"/file-manager\", onMatch: spyFileManager }\n        ]);\n\n        // Navigate to /tenant123/file-manager\n        history.push(\"/tenant123/file-manager\");\n        await wait();\n\n        // Should match the /file-manager route\n        expect(spyFileManager).toHaveBeenCalledTimes(1);\n        expect(spyFileManager).toHaveBeenCalledWith({\n            name: \"fileManager\",\n            path: \"/file-manager\",\n            pathname: \"/tenant123/file-manager\",\n            params: {}\n        });\n\n        // Test URL generation with baseUrl\n        const urlWithBase = RouteUrl.fromPattern(\"/file-manager\", {}, \"/tenant123\");\n        expect(urlWithBase).toBe(\"/tenant123/file-manager\");\n\n        const urlWithBaseAndParams = RouteUrl.fromPattern(\n            \"/file-manager\",\n            { folder: \"abc\" },\n            \"/tenant123\"\n        );\n        expect(urlWithBaseAndParams).toBe(\"/tenant123/file-manager?folder=abc\");\n    });\n\n    it(\"should properly sort routes with wildcards always at the bottom\", async () => {\n        const spyWildcard = vi.fn();\n        const spySpecific = vi.fn();\n        const spyHome = vi.fn();\n\n        const history = createMemoryHistory();\n        // Start at a non-matching path to avoid initial route resolution\n        history.replace(\"/initial\");\n\n        const gateway = new HistoryRouterGateway(history, \"\");\n\n        // Add wildcard first, then home route\n        // Note: setRoutes will trigger route resolution for current path (/initial)\n        gateway.setRoutes([\n            { name: \"wildcard\", path: \"*\", onMatch: spyWildcard },\n            { name: \"home\", path: \"/\", onMatch: spyHome }\n        ]);\n\n        // Wildcard should have matched /initial\n        expect(spyWildcard).toHaveBeenCalledTimes(1);\n        vi.clearAllMocks();\n\n        // Now add a specific route after the wildcard - this should re-sort and keep wildcard at bottom\n        // Note: setRoutes will trigger route resolution again for /initial, matching wildcard again\n        gateway.setRoutes([{ name: \"specific\", path: \"/specific-route\", onMatch: spySpecific }]);\n\n        // Wildcard should match /initial again after re-sorting\n        expect(spyWildcard).toHaveBeenCalledTimes(1);\n        vi.clearAllMocks();\n\n        // Navigate to the specific route\n        history.push(\"/specific-route\");\n        await wait();\n\n        // Should match the specific route, not the wildcard\n        expect(spySpecific).toHaveBeenCalledTimes(1);\n        expect(spyWildcard).toHaveBeenCalledTimes(0);\n        expect(spyHome).toHaveBeenCalledTimes(0);\n\n        // Navigate to home\n        history.push(\"/\");\n        await wait();\n\n        // Should match home route\n        expect(spyHome).toHaveBeenCalledTimes(1);\n        expect(spyWildcard).toHaveBeenCalledTimes(0);\n\n        // Navigate to unknown route\n        history.push(\"/unknown\");\n        await wait();\n\n        // Should match wildcard\n        expect(spyWildcard).toHaveBeenCalledTimes(1);\n    });\n});\n"],"names":["wait","Promise","resolve","setTimeout","describe","beforeEach","vi","it","spyHome","spyLogin","spyDynamic","history","createMemoryHistory","gateway","HistoryRouterGateway","expect","urls","RouteUrl","spyFileManager","urlWithBase","urlWithBaseAndParams","spyWildcard","spySpecific"],"mappings":"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"}

package/features/router/Route.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export type RouteParamsDefinition = Record<string, z.ZodTypeAny>;
+export type RouteParamsInfer<T extends RouteParamsDefinition | undefined> = T extends RouteParamsDefinition ? z.infer<z.ZodObject<T> & {
+    [k: string]: any;
+}> : never;
+export interface RouteParams<TParams extends RouteParamsDefinition | undefined> {
+    name: string;
+    path: `/${string}` | `*`;
+    params?: (zod: typeof z) => TParams;
+}
+export declare class Route<TParams extends RouteParamsDefinition | undefined = undefined> {
+    private readonly route;
+    private readonly schema;
+    constructor(route: RouteParams<TParams>);
+    get name(): string;
+    get path(): `/${string}` | "*";
+    get params(): TParams extends RouteParamsDefinition ? RouteParamsInfer<TParams> : undefined;
+    private coerceParams;
+}

package/features/router/Route.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+class Route {
+    constructor(route){
+        this.route = route;
+        const paramsSchema = route.params ? route.params(z) : void 0;
+        this.schema = paramsSchema ? z.looseObject(this.coerceParams(paramsSchema)) : void 0;
+    }
+    get name() {
+        return this.route.name;
+    }
+    get path() {
+        return this.route.path;
+    }
+    get params() {
+        return this.schema;
+    }
+    coerceParams(shape) {
+        const result = {};
+        for (const [key, schema] of Object.entries(shape)){
+            let base = schema;
+            let isOptional = false;
+            let isNullable = false;
+            if (base instanceof z.ZodOptional) {
+                isOptional = true;
+                base = base.unwrap();
+            }
+            if (base instanceof z.ZodNullable) {
+                isNullable = true;
+                base = base.unwrap();
+            }
+            if (base instanceof z.ZodString) base = z.coerce.string();
+            else if (base instanceof z.ZodNumber) base = z.coerce.number();
+            else if (base instanceof z.ZodBoolean) base = z.coerce.boolean();
+            if (isNullable) base = base.nullable();
+            if (isOptional) base = base.optional();
+            result[key] = base;
+        }
+        return result;
+    }
+}
+export { Route };
+
+//# sourceMappingURL=Route.js.map

package/features/router/Route.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/router/Route.js","sources":["../../../src/features/router/Route.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport type RouteParamsDefinition = Record<string, z.ZodTypeAny>;\n\nexport type RouteParamsInfer<T extends RouteParamsDefinition | undefined> =\n    T extends RouteParamsDefinition ? z.infer<z.ZodObject<T> & { [k: string]: any }> : never;\n\nexport interface RouteParams<TParams extends RouteParamsDefinition | undefined> {\n    name: string;\n    path: `/${string}` | `*`;\n    params?: (zod: typeof z) => TParams;\n}\n\nexport class Route<TParams extends RouteParamsDefinition | undefined = undefined> {\n    private readonly route: RouteParams<TParams>;\n    private readonly schema: TParams extends RouteParamsDefinition\n        ? RouteParamsInfer<TParams>\n        : undefined;\n\n    constructor(route: RouteParams<TParams>) {\n        this.route = route;\n        const paramsSchema = route.params ? route.params(z) : undefined;\n        // @ts-expect-error\n        this.schema = paramsSchema ? z.looseObject(this.coerceParams(paramsSchema)) : undefined;\n    }\n\n    get name() {\n        return this.route.name;\n    }\n\n    get path() {\n        return this.route.path;\n    }\n\n    get params(): TParams extends RouteParamsDefinition ? RouteParamsInfer<TParams> : undefined {\n        return this.schema;\n    }\n\n    private coerceParams<T extends Record<string, z.ZodTypeAny>>(shape: T) {\n        const result: Record<string, z.ZodTypeAny> = {};\n        for (const [key, schema] of Object.entries(shape)) {\n            let base = schema as z.ZodTypeAny;\n            let isOptional = false;\n            let isNullable = false;\n\n            // unwrap optional\n            if (base instanceof z.ZodOptional) {\n                isOptional = true;\n                base = base.unwrap() as z.ZodTypeAny;\n            }\n\n            // unwrap nullable\n            if (base instanceof z.ZodNullable) {\n                isNullable = true;\n                base = base.unwrap() as z.ZodTypeAny;\n            }\n\n            // replace with coerced\n            if (base instanceof z.ZodString) {\n                base = z.coerce.string();\n            } else if (base instanceof z.ZodNumber) {\n                base = z.coerce.number();\n            } else if (base instanceof z.ZodBoolean) {\n                base = z.coerce.boolean();\n            }\n\n            // rewrap optional/nullable\n            if (isNullable) {\n                base = base.nullable();\n            }\n            if (isOptional) {\n                base = base.optional();\n            }\n\n            result[key] = base;\n        }\n        return result;\n    }\n}\n"],"names":["Route","route","paramsSchema","z","undefined","shape","result","key","schema","Object","base","isOptional","isNullable"],"mappings":";AAaO,MAAMA;IAMT,YAAYC,KAA2B,CAAE;QACrC,IAAI,CAAC,KAAK,GAAGA;QACb,MAAMC,eAAeD,MAAM,MAAM,GAAGA,MAAM,MAAM,CAACE,KAAKC;QAEtD,IAAI,CAAC,MAAM,GAAGF,eAAeC,EAAE,WAAW,CAAC,IAAI,CAAC,YAAY,CAACD,iBAAiBE;IAClF;IAEA,IAAI,OAAO;QACP,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI;IAC1B;IAEA,IAAI,OAAO;QACP,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI;IAC1B;IAEA,IAAI,SAAwF;QACxF,OAAO,IAAI,CAAC,MAAM;IACtB;IAEQ,aAAqDC,KAAQ,EAAE;QACnE,MAAMC,SAAuC,CAAC;QAC9C,KAAK,MAAM,CAACC,KAAKC,OAAO,IAAIC,OAAO,OAAO,CAACJ,OAAQ;YAC/C,IAAIK,OAAOF;YACX,IAAIG,aAAa;YACjB,IAAIC,aAAa;YAGjB,IAAIF,gBAAgBP,EAAE,WAAW,EAAE;gBAC/BQ,aAAa;gBACbD,OAAOA,KAAK,MAAM;YACtB;YAGA,IAAIA,gBAAgBP,EAAE,WAAW,EAAE;gBAC/BS,aAAa;gBACbF,OAAOA,KAAK,MAAM;YACtB;YAGA,IAAIA,gBAAgBP,EAAE,SAAS,EAC3BO,OAAOP,EAAE,MAAM,CAAC,MAAM;iBACnB,IAAIO,gBAAgBP,EAAE,SAAS,EAClCO,OAAOP,EAAE,MAAM,CAAC,MAAM;iBACnB,IAAIO,gBAAgBP,EAAE,UAAU,EACnCO,OAAOP,EAAE,MAAM,CAAC,OAAO;YAI3B,IAAIS,YACAF,OAAOA,KAAK,QAAQ;YAExB,IAAIC,YACAD,OAAOA,KAAK,QAAQ;YAGxBJ,MAAM,CAACC,IAAI,GAAGG;QAClB;QACA,OAAOJ;IACX;AACJ"}

package/features/router/RouteUrl.d.ts

@@ -0,0 +1,85 @@
+interface Params {
+    [key: string]: any;
+}
+interface MatchResult {
+    params: Record<string, string>;
+}
+/**
+ * Utility class for route URL pattern matching and generation.
+ * Handles simple route patterns with :param syntax (e.g., /cms/entries/:modelId).
+ *
+ * Public API uses static methods, which internally construct RouteUrl instances
+ * to handle the logic through proper instance methods.
+ */
+export declare class RouteUrl {
+    private static patternCache;
+    private readonly pattern;
+    private readonly params;
+    private readonly baseUrl;
+    private constructor();
+    /**
+     * Generate a URL from a route pattern and parameters.
+     * Path parameters are injected into the pattern, remaining parameters become query strings.
+     *
+     * @param pattern - Route pattern (e.g., '/security/api-keys/:id')
+     * @param params - Parameters object (e.g., { id: 123, new: true })
+     * @param baseUrl - Optional base URL to prepend (e.g., '/tenant123')
+     * @returns Generated URL string
+     *
+     * @example
+     * RouteUrl.fromPattern('/security/api-keys/:id', { id: 123, new: true })
+     * // Returns: '/security/api-keys/123?new=true'
+     *
+     * @example
+     * RouteUrl.fromPattern('/file-manager', {}, '/tenant123')
+     * // Returns: '/tenant123/file-manager'
+     */
+    static fromPattern(pattern: string, params?: Params, baseUrl?: string): string;
+    /**
+     * Match a pathname against a route pattern and extract parameters.
+     * If baseUrl is provided, it will be stripped from the pathname before matching.
+     *
+     * @param pathname - The pathname to match (e.g., '/tenant123/security/api-keys/123')
+     * @param pattern - Route pattern (e.g., '/security/api-keys/:id')
+     * @param baseUrl - Optional base URL to strip before matching (e.g., '/tenant123')
+     * @returns Object with extracted params if matched, null otherwise
+     *
+     * @example
+     * RouteUrl.match('/security/api-keys/123', '/security/api-keys/:id')
+     * // Returns: { params: { id: '123' } }
+     *
+     * @example
+     * RouteUrl.match('/tenant123/file-manager', '/file-manager', '/tenant123')
+     * // Returns: { params: {} }
+     */
+    static match(pathname: string, pattern: string, baseUrl?: string): MatchResult | null;
+    /**
+     * Generate a URL from the instance's pattern, params, and baseUrl.
+     */
+    private generate;
+    /**
+     * Match a pathname against the instance's pattern.
+     */
+    private matchPathname;
+    /**
+     * Extract path parameter names from the pattern.
+     */
+    private extractPathKeys;
+    /**
+     * Replace :param placeholders with actual values from params.
+     */
+    private replacePathParams;
+    /**
+     * Build query string from params that are not path parameters.
+     */
+    private buildQueryString;
+    /**
+     * Normalize baseUrl by ensuring it starts with / and doesn't end with /
+     */
+    private normalizeBaseUrl;
+    /**
+     * Compile the instance's pattern into a regex and extract parameter names.
+     */
+    private compilePattern;
+}
+export {};

package/features/router/RouteUrl.js

@@ -0,0 +1,99 @@
+class RouteUrl {
+    static{
+        this.patternCache = new Map();
+    }
+    constructor(pattern, params, baseUrl){
+        this.pattern = pattern;
+        this.params = params;
+        this.baseUrl = this.normalizeBaseUrl(baseUrl);
+    }
+    static fromPattern(pattern, params, baseUrl) {
+        const routeUrl = new RouteUrl(pattern, params, baseUrl);
+        return routeUrl.generate();
+    }
+    static match(pathname, pattern, baseUrl) {
+        const routeUrl = new RouteUrl(pattern, void 0, baseUrl);
+        return routeUrl.matchPathname(pathname);
+    }
+    generate() {
+        if (!this.params) return this.baseUrl + this.pattern;
+        const pathKeys = this.extractPathKeys();
+        let url = this.replacePathParams();
+        if (!url || "" === url) url = "/";
+        url = this.baseUrl + url;
+        const queryString = this.buildQueryString(pathKeys);
+        if (queryString) url += `?${queryString}`;
+        return url;
+    }
+    matchPathname(pathname) {
+        if (this.baseUrl && pathname.startsWith(this.baseUrl)) pathname = pathname.slice(this.baseUrl.length) || "/";
+        else if (this.baseUrl) return null;
+        if ("*" === this.pattern || "(.*)" === this.pattern) return {
+            params: {}
+        };
+        let compiled = RouteUrl.patternCache.get(this.pattern);
+        if (!compiled) {
+            compiled = this.compilePattern();
+            RouteUrl.patternCache.set(this.pattern, compiled);
+        }
+        const match = pathname.match(compiled.regex);
+        if (!match) return null;
+        const params = {};
+        compiled.keys.forEach((key, index)=>{
+            const value = match[index + 1];
+            if (void 0 !== value) params[key] = decodeURIComponent(value);
+        });
+        return {
+            params
+        };
+    }
+    extractPathKeys() {
+        const pathKeys = new Set();
+        const paramRegex = /:([a-zA-Z_][a-zA-Z0-9_]*)/g;
+        let match;
+        while(null !== (match = paramRegex.exec(this.pattern)))pathKeys.add(match[1]);
+        return pathKeys;
+    }
+    replacePathParams() {
+        return this.pattern.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, key)=>{
+            const value = this.params[key];
+            if (null == value) return "";
+            return encodeURIComponent(String(value));
+        });
+    }
+    buildQueryString(pathKeys) {
+        const queryParams = {};
+        for(const key in this.params)if (!pathKeys.has(key)) queryParams[key] = this.params[key];
+        if (0 === Object.keys(queryParams).length) return "";
+        const searchParams = new URLSearchParams();
+        for(const key in queryParams){
+            const value = queryParams[key];
+            if (null != value) if (Array.isArray(value)) value.forEach((v)=>searchParams.append(key, String(v)));
+            else searchParams.append(key, String(value));
+        }
+        return searchParams.toString();
+    }
+    normalizeBaseUrl(baseUrl) {
+        if (!baseUrl || "/" === baseUrl) return "";
+        let normalized = baseUrl;
+        if (!normalized.startsWith("/")) normalized = "/" + normalized;
+        if (normalized.endsWith("/")) normalized = normalized.slice(0, -1);
+        return normalized;
+    }
+    compilePattern() {
+        const keys = [];
+        let regexPattern = this.pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\\\*/g, ".*");
+        regexPattern = regexPattern.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, key)=>{
+            keys.push(key);
+            return "([^/]+)";
+        });
+        const regex = new RegExp(`^${regexPattern}$`);
+        return {
+            regex,
+            keys
+        };
+    }
+}
+export { RouteUrl };
+
+//# sourceMappingURL=RouteUrl.js.map

package/features/router/RouteUrl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/router/RouteUrl.js","sources":["../../../src/features/router/RouteUrl.ts"],"sourcesContent":["interface Params {\n    [key: string]: any;\n}\n\ninterface MatchResult {\n    params: Record<string, string>;\n}\n\n/**\n * Utility class for route URL pattern matching and generation.\n * Handles simple route patterns with :param syntax (e.g., /cms/entries/:modelId).\n *\n * Public API uses static methods, which internally construct RouteUrl instances\n * to handle the logic through proper instance methods.\n */\nexport class RouteUrl {\n    private static patternCache = new Map<string, { regex: RegExp; keys: string[] }>();\n\n    private readonly pattern: string;\n    private readonly params: Params | undefined;\n    private readonly baseUrl: string;\n\n    private constructor(pattern: string, params?: Params, baseUrl?: string) {\n        this.pattern = pattern;\n        this.params = params;\n        this.baseUrl = this.normalizeBaseUrl(baseUrl);\n    }\n\n    /**\n     * Generate a URL from a route pattern and parameters.\n     * Path parameters are injected into the pattern, remaining parameters become query strings.\n     *\n     * @param pattern - Route pattern (e.g., '/security/api-keys/:id')\n     * @param params - Parameters object (e.g., { id: 123, new: true })\n     * @param baseUrl - Optional base URL to prepend (e.g., '/tenant123')\n     * @returns Generated URL string\n     *\n     * @example\n     * RouteUrl.fromPattern('/security/api-keys/:id', { id: 123, new: true })\n     * // Returns: '/security/api-keys/123?new=true'\n     *\n     * @example\n     * RouteUrl.fromPattern('/file-manager', {}, '/tenant123')\n     * // Returns: '/tenant123/file-manager'\n     */\n    static fromPattern(pattern: string, params?: Params, baseUrl?: string): string {\n        const routeUrl = new RouteUrl(pattern, params, baseUrl);\n        return routeUrl.generate();\n    }\n\n    /**\n     * Match a pathname against a route pattern and extract parameters.\n     * If baseUrl is provided, it will be stripped from the pathname before matching.\n     *\n     * @param pathname - The pathname to match (e.g., '/tenant123/security/api-keys/123')\n     * @param pattern - Route pattern (e.g., '/security/api-keys/:id')\n     * @param baseUrl - Optional base URL to strip before matching (e.g., '/tenant123')\n     * @returns Object with extracted params if matched, null otherwise\n     *\n     * @example\n     * RouteUrl.match('/security/api-keys/123', '/security/api-keys/:id')\n     * // Returns: { params: { id: '123' } }\n     *\n     * @example\n     * RouteUrl.match('/tenant123/file-manager', '/file-manager', '/tenant123')\n     * // Returns: { params: {} }\n     */\n    static match(pathname: string, pattern: string, baseUrl?: string): MatchResult | null {\n        const routeUrl = new RouteUrl(pattern, undefined, baseUrl);\n        return routeUrl.matchPathname(pathname);\n    }\n\n    /**\n     * Generate a URL from the instance's pattern, params, and baseUrl.\n     */\n    private generate(): string {\n        if (!this.params) {\n            return this.baseUrl + this.pattern;\n        }\n\n        // Extract path parameter names from pattern\n        const pathKeys = this.extractPathKeys();\n\n        // Replace :param with actual values\n        let url = this.replacePathParams();\n\n        // Handle empty url\n        if (!url || url === \"\") {\n            url = \"/\";\n        }\n\n        // Prepend baseUrl\n        url = this.baseUrl + url;\n\n        // Add query parameters for keys not used in the path\n        const queryString = this.buildQueryString(pathKeys);\n        if (queryString) {\n            url += `?${queryString}`;\n        }\n\n        return url;\n    }\n\n    /**\n     * Match a pathname against the instance's pattern.\n     */\n    private matchPathname(pathname: string): MatchResult | null {\n        // Strip baseUrl from pathname if provided\n        if (this.baseUrl && pathname.startsWith(this.baseUrl)) {\n            pathname = pathname.slice(this.baseUrl.length) || \"/\";\n        } else if (this.baseUrl) {\n            // pathname doesn't start with baseUrl, no match\n            return null;\n        }\n\n        // Handle wildcard pattern\n        if (this.pattern === \"*\" || this.pattern === \"(.*)\") {\n            return { params: {} };\n        }\n\n        // Get or create cached pattern\n        let compiled = RouteUrl.patternCache.get(this.pattern);\n        if (!compiled) {\n            compiled = this.compilePattern();\n            RouteUrl.patternCache.set(this.pattern, compiled);\n        }\n\n        const match = pathname.match(compiled.regex);\n        if (!match) {\n            return null;\n        }\n\n        // Extract parameters from capture groups\n        const params: Record<string, string> = {};\n        compiled.keys.forEach((key, index) => {\n            const value = match[index + 1];\n            if (value !== undefined) {\n                params[key] = decodeURIComponent(value);\n            }\n        });\n\n        return { params };\n    }\n\n    /**\n     * Extract path parameter names from the pattern.\n     */\n    private extractPathKeys(): Set<string> {\n        const pathKeys = new Set<string>();\n        const paramRegex = /:([a-zA-Z_][a-zA-Z0-9_]*)/g;\n        let match;\n        while ((match = paramRegex.exec(this.pattern)) !== null) {\n            pathKeys.add(match[1]);\n        }\n        return pathKeys;\n    }\n\n    /**\n     * Replace :param placeholders with actual values from params.\n     */\n    private replacePathParams(): string {\n        return this.pattern.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, key) => {\n            const value = this.params![key];\n            if (value === undefined || value === null) {\n                return \"\";\n            }\n            return encodeURIComponent(String(value));\n        });\n    }\n\n    /**\n     * Build query string from params that are not path parameters.\n     */\n    private buildQueryString(pathKeys: Set<string>): string {\n        const queryParams: Record<string, any> = {};\n\n        for (const key in this.params) {\n            if (!pathKeys.has(key)) {\n                queryParams[key] = this.params[key];\n            }\n        }\n\n        if (Object.keys(queryParams).length === 0) {\n            return \"\";\n        }\n\n        const searchParams = new URLSearchParams();\n\n        for (const key in queryParams) {\n            const value = queryParams[key];\n            if (value !== undefined && value !== null) {\n                if (Array.isArray(value)) {\n                    value.forEach(v => searchParams.append(key, String(v)));\n                } else {\n                    searchParams.append(key, String(value));\n                }\n            }\n        }\n\n        return searchParams.toString();\n    }\n\n    /**\n     * Normalize baseUrl by ensuring it starts with / and doesn't end with /\n     */\n    private normalizeBaseUrl(baseUrl?: string): string {\n        if (!baseUrl || baseUrl === \"/\") {\n            return \"\";\n        }\n\n        let normalized = baseUrl;\n\n        // Ensure it starts with /\n        if (!normalized.startsWith(\"/\")) {\n            normalized = \"/\" + normalized;\n        }\n\n        // Remove trailing /\n        if (normalized.endsWith(\"/\")) {\n            normalized = normalized.slice(0, -1);\n        }\n\n        return normalized;\n    }\n\n    /**\n     * Compile the instance's pattern into a regex and extract parameter names.\n     */\n    private compilePattern(): { regex: RegExp; keys: string[] } {\n        const keys: string[] = [];\n\n        // Escape special regex characters except for :param syntax\n        let regexPattern = this.pattern\n            .replace(/[.+?^${}()|[\\]\\\\]/g, \"\\\\$&\") // Escape special chars\n            .replace(/\\\\\\*/g, \".*\"); // Handle * wildcard (already escaped by above)\n\n        // Replace :param with capture groups\n        regexPattern = regexPattern.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, key) => {\n            keys.push(key);\n            return \"([^/]+)\"; // Match any non-slash characters\n        });\n\n        // Create regex that matches the entire pathname\n        const regex = new RegExp(`^${regexPattern}$`);\n\n        return { regex, keys };\n    }\n}\n"],"names":["RouteUrl","Map","pattern","params","baseUrl","routeUrl","pathname","undefined","pathKeys","url","queryString","compiled","match","key","index","value","decodeURIComponent","Set","paramRegex","_","encodeURIComponent","String","queryParams","Object","searchParams","URLSearchParams","Array","v","normalized","keys","regexPattern","regex","RegExp"],"mappings":"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"}

package/features/router/Router.d.ts

@@ -0,0 +1,45 @@
+import type { RouteDefinition, MatchedRoute } from "./abstractions.js";
+interface ResolveResult {
+    matchedRoute: MatchedRoute;
+    onMatch: (route: MatchedRoute) => void;
+}
+/**
+ * Router manages a collection of route definitions and resolves pathnames to matched routes.
+ */
+export declare class Router {
+    private routes;
+    private baseUrl;
+    constructor(baseUrl?: string);
+    /**
+     * Set or update route definitions. Routes with the same name will be replaced.
+     *
+     * @param routes - Array of route definitions to add
+     */
+    setRoutes(routes: RouteDefinition[]): void;
+    /**
+     * Find a route by name.
+     *
+     * @param name - Route name to find
+     * @returns Route definition if found, undefined otherwise
+     */
+    findRoute(name: string): RouteDefinition | undefined;
+    /**
+     * Resolve a pathname to a matched route.
+     * The pathname will be matched against patterns after stripping the baseUrl.
+     *
+     * @param pathname - The pathname to resolve (e.g., '/tenant123/cms/entries/123')
+     * @param queryParams - Optional query parameters to merge into route params
+     * @returns Matched route with onMatch callback, or null if no route matches
+     */
+    resolve(pathname: string, queryParams?: Record<string, unknown>): ResolveResult | null;
+    /**
+     * Get the current baseUrl.
+     */
+    getBaseUrl(): string;
+    /**
+     * Sort routes to ensure proper matching order.
+     * Wildcard routes (*) and index routes (/) are moved to the bottom.
+     */
+    private sortRoutes;
+}
+export {};

package/features/router/Router.js

@@ -0,0 +1,72 @@
+import { RouteUrl } from "./RouteUrl.js";
+class Router {
+    constructor(baseUrl = ""){
+        this.routes = [];
+        this.baseUrl = baseUrl;
+    }
+    setRoutes(routes) {
+        routes.forEach((route)=>{
+            const index = this.routes.findIndex((r)=>r.name === route.name);
+            if (index > -1) this.routes[index] = route;
+            else this.routes.push(route);
+        });
+        this.sortRoutes();
+    }
+    findRoute(name) {
+        return this.routes.find((r)=>r.name === name);
+    }
+    resolve(pathname, queryParams) {
+        for (const route of this.routes){
+            const pattern = "*" === route.path ? "(.*)" : route.path;
+            const matchResult = RouteUrl.match(pathname, pattern, this.baseUrl);
+            if (matchResult) {
+                const matchedRoute = {
+                    name: route.name,
+                    path: route.path,
+                    pathname,
+                    params: {
+                        ...matchResult.params,
+                        ...queryParams || {}
+                    }
+                };
+                const onMatch = (matched)=>{
+                    route.onMatch(matched);
+                };
+                return {
+                    matchedRoute,
+                    onMatch
+                };
+            }
+        }
+        return null;
+    }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    sortRoutes() {
+        const INDEX_PATH = "/";
+        const WILDCARD_PATTERNS = [
+            "*",
+            "(.*)"
+        ];
+        this.routes.sort((a, b)=>{
+            const pathA = a.path || "*";
+            const pathB = b.path || "*";
+            const isWildcardA = WILDCARD_PATTERNS.includes(pathA);
+            const isWildcardB = WILDCARD_PATTERNS.includes(pathB);
+            const isIndexA = pathA === INDEX_PATH;
+            const isIndexB = pathB === INDEX_PATH;
+            if (isWildcardA && isWildcardB || isIndexA && isIndexB) return 0;
+            if (isIndexA && isWildcardB) return -1;
+            if (isWildcardA && isIndexB) return 1;
+            if (isWildcardA) return 1;
+            if (isWildcardB) return -1;
+            if (isIndexA) return 1;
+            if (isIndexB) return -1;
+            return 0;
+        });
+    }
+}
+export { Router };
+
+//# sourceMappingURL=Router.js.map

package/features/router/Router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/router/Router.js","sources":["../../../src/features/router/Router.ts"],"sourcesContent":["import type { RouteDefinition, MatchedRoute } from \"./abstractions.js\";\nimport { RouteUrl } from \"./RouteUrl.js\";\n\ninterface ResolveResult {\n    matchedRoute: MatchedRoute;\n    onMatch: (route: MatchedRoute) => void;\n}\n\n/**\n * Router manages a collection of route definitions and resolves pathnames to matched routes.\n */\nexport class Router {\n    private routes: RouteDefinition[] = [];\n    private baseUrl: string;\n\n    constructor(baseUrl: string = \"\") {\n        this.baseUrl = baseUrl;\n    }\n\n    /**\n     * Set or update route definitions. Routes with the same name will be replaced.\n     *\n     * @param routes - Array of route definitions to add\n     */\n    setRoutes(routes: RouteDefinition[]): void {\n        routes.forEach(route => {\n            const index = this.routes.findIndex(r => r.name === route.name);\n\n            if (index > -1) {\n                this.routes[index] = route;\n            } else {\n                this.routes.push(route);\n            }\n        });\n\n        this.sortRoutes();\n    }\n\n    /**\n     * Find a route by name.\n     *\n     * @param name - Route name to find\n     * @returns Route definition if found, undefined otherwise\n     */\n    findRoute(name: string): RouteDefinition | undefined {\n        return this.routes.find(r => r.name === name);\n    }\n\n    /**\n     * Resolve a pathname to a matched route.\n     * The pathname will be matched against patterns after stripping the baseUrl.\n     *\n     * @param pathname - The pathname to resolve (e.g., '/tenant123/cms/entries/123')\n     * @param queryParams - Optional query parameters to merge into route params\n     * @returns Matched route with onMatch callback, or null if no route matches\n     */\n    resolve(pathname: string, queryParams?: Record<string, unknown>): ResolveResult | null {\n        for (const route of this.routes) {\n            const pattern = route.path === \"*\" ? \"(.*)\" : route.path;\n            const matchResult = RouteUrl.match(pathname, pattern, this.baseUrl);\n\n            if (matchResult) {\n                const matchedRoute: MatchedRoute = {\n                    name: route.name,\n                    path: route.path,\n                    pathname,\n                    params: { ...matchResult.params, ...(queryParams || {}) }\n                };\n\n                const onMatch = (matched: MatchedRoute) => {\n                    route.onMatch(matched);\n                };\n\n                return { matchedRoute, onMatch };\n            }\n        }\n\n        return null;\n    }\n\n    /**\n     * Get the current baseUrl.\n     */\n    getBaseUrl(): string {\n        return this.baseUrl;\n    }\n\n    /**\n     * Sort routes to ensure proper matching order.\n     * Wildcard routes (*) and index routes (/) are moved to the bottom.\n     */\n    private sortRoutes(): void {\n        const INDEX_PATH = \"/\";\n        const WILDCARD_PATTERNS = [\"*\", \"(.*)\"];\n\n        this.routes.sort((a, b) => {\n            const pathA = a.path || \"*\";\n            const pathB = b.path || \"*\";\n\n            const isWildcardA = WILDCARD_PATTERNS.includes(pathA);\n            const isWildcardB = WILDCARD_PATTERNS.includes(pathB);\n            const isIndexA = pathA === INDEX_PATH;\n            const isIndexB = pathB === INDEX_PATH;\n\n            // Both are wildcards or both are index - maintain order\n            if ((isWildcardA && isWildcardB) || (isIndexA && isIndexB)) {\n                return 0;\n            }\n\n            // Index path should come before wildcard\n            if (isIndexA && isWildcardB) {\n                return -1;\n            }\n            if (isWildcardA && isIndexB) {\n                return 1;\n            }\n\n            // Push wildcards to the bottom\n            if (isWildcardA) {\n                return 1;\n            }\n            if (isWildcardB) {\n                return -1;\n            }\n\n            // Push index to the bottom (but above wildcards)\n            if (isIndexA) {\n                return 1;\n            }\n            if (isIndexB) {\n                return -1;\n            }\n\n            // All other routes maintain their order\n            return 0;\n        });\n    }\n}\n"],"names":["Router","baseUrl","routes","route","index","r","name","pathname","queryParams","pattern","matchResult","RouteUrl","matchedRoute","onMatch","matched","INDEX_PATH","WILDCARD_PATTERNS","a","b","pathA","pathB","isWildcardA","isWildcardB","isIndexA","isIndexB"],"mappings":";AAWO,MAAMA;IAIT,YAAYC,UAAkB,EAAE,CAAE;aAH1B,MAAM,GAAsB,EAAE;QAIlC,IAAI,CAAC,OAAO,GAAGA;IACnB;IAOA,UAAUC,MAAyB,EAAQ;QACvCA,OAAO,OAAO,CAACC,CAAAA;YACX,MAAMC,QAAQ,IAAI,CAAC,MAAM,CAAC,SAAS,CAACC,CAAAA,IAAKA,EAAE,IAAI,KAAKF,MAAM,IAAI;YAE9D,IAAIC,QAAQ,IACR,IAAI,CAAC,MAAM,CAACA,MAAM,GAAGD;iBAErB,IAAI,CAAC,MAAM,CAAC,IAAI,CAACA;QAEzB;QAEA,IAAI,CAAC,UAAU;IACnB;IAQA,UAAUG,IAAY,EAA+B;QACjD,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAACD,CAAAA,IAAKA,EAAE,IAAI,KAAKC;IAC5C;IAUA,QAAQC,QAAgB,EAAEC,WAAqC,EAAwB;QACnF,KAAK,MAAML,SAAS,IAAI,CAAC,MAAM,CAAE;YAC7B,MAAMM,UAAUN,AAAe,QAAfA,MAAM,IAAI,GAAW,SAASA,MAAM,IAAI;YACxD,MAAMO,cAAcC,SAAS,KAAK,CAACJ,UAAUE,SAAS,IAAI,CAAC,OAAO;YAElE,IAAIC,aAAa;gBACb,MAAME,eAA6B;oBAC/B,MAAMT,MAAM,IAAI;oBAChB,MAAMA,MAAM,IAAI;oBAChBI;oBACA,QAAQ;wBAAE,GAAGG,YAAY,MAAM;wBAAE,GAAIF,eAAe,CAAC,CAAC;oBAAE;gBAC5D;gBAEA,MAAMK,UAAU,CAACC;oBACbX,MAAM,OAAO,CAACW;gBAClB;gBAEA,OAAO;oBAAEF;oBAAcC;gBAAQ;YACnC;QACJ;QAEA,OAAO;IACX;IAKA,aAAqB;QACjB,OAAO,IAAI,CAAC,OAAO;IACvB;IAMQ,aAAmB;QACvB,MAAME,aAAa;QACnB,MAAMC,oBAAoB;YAAC;YAAK;SAAO;QAEvC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAACC,GAAGC;YACjB,MAAMC,QAAQF,EAAE,IAAI,IAAI;YACxB,MAAMG,QAAQF,EAAE,IAAI,IAAI;YAExB,MAAMG,cAAcL,kBAAkB,QAAQ,CAACG;YAC/C,MAAMG,cAAcN,kBAAkB,QAAQ,CAACI;YAC/C,MAAMG,WAAWJ,UAAUJ;YAC3B,MAAMS,WAAWJ,UAAUL;YAG3B,IAAKM,eAAeC,eAAiBC,YAAYC,UAC7C,OAAO;YAIX,IAAID,YAAYD,aACZ,OAAO;YAEX,IAAID,eAAeG,UACf,OAAO;YAIX,IAAIH,aACA,OAAO;YAEX,IAAIC,aACA,OAAO;YAIX,IAAIC,UACA,OAAO;YAEX,IAAIC,UACA,OAAO;YAIX,OAAO;QACX;IACJ;AACJ"}