@refinedev/core 4.0.0

package/src/definitions/helpers/router/__tests__/get-action-routes-from-resource.ts

@@ -0,0 +1,169 @@
+import { getActionRoutesFromResource } from "../get-action-routes-from-resource";
+
+describe("getActionRoutesFromResource", () => {
+    it("should return empty array if no actions are found", () => {
+        const result = getActionRoutesFromResource(
+            {
+                name: "users",
+                meta: {},
+            },
+            [],
+        );
+
+        expect(result).toEqual([]);
+    });
+
+    it("should return the default routes for a given resource", () => {
+        const result = getActionRoutesFromResource(
+            {
+                name: "users",
+                meta: {},
+                list: () => null,
+                create: () => null,
+                edit: () => null,
+                show: () => null,
+                clone: () => null,
+            },
+            [],
+        );
+
+        expect(result).toEqual(
+            expect.arrayContaining([
+                expect.objectContaining({
+                    action: "list",
+                    route: "/users",
+                }),
+                expect.objectContaining({
+                    action: "create",
+                    route: "/users/create",
+                }),
+                expect.objectContaining({
+                    action: "edit",
+                    route: "/users/edit/:id",
+                }),
+                expect.objectContaining({
+                    action: "show",
+                    route: "/users/show/:id",
+                }),
+                expect.objectContaining({
+                    action: "clone",
+                    route: "/users/clone/:id",
+                }),
+            ]),
+        );
+    });
+
+    it("should return the default routes for a given resource with parent prefix [legacy]", () => {
+        const result = getActionRoutesFromResource(
+            {
+                name: "users",
+                meta: {
+                    parent: "orgs",
+                },
+                edit: () => null,
+            },
+            [],
+            true,
+        );
+
+        expect(result).toEqual(
+            expect.arrayContaining([
+                expect.objectContaining({
+                    action: "edit",
+                    route: "/orgs/users/edit/:id",
+                }),
+            ]),
+        );
+    });
+
+    it("should return the default routes for a given resource without parent prefix", () => {
+        const result = getActionRoutesFromResource(
+            {
+                name: "users",
+                meta: {
+                    parent: "orgs",
+                },
+                edit: () => null,
+            },
+            [],
+        );
+
+        expect(result).toEqual(
+            expect.arrayContaining([
+                expect.objectContaining({
+                    action: "edit",
+                    route: "/users/edit/:id",
+                }),
+            ]),
+        );
+    });
+
+    it("should not include parent prefix if route is explicitly defined", () => {
+        const result = getActionRoutesFromResource(
+            {
+                name: "users",
+                meta: {
+                    parent: "orgs",
+                },
+                edit: {
+                    path: "edit/:id",
+                    component: () => null,
+                },
+            },
+            [],
+        );
+
+        expect(result).toEqual(
+            expect.arrayContaining([
+                expect.objectContaining({
+                    action: "edit",
+                    route: "/edit/:id",
+                }),
+            ]),
+        );
+    });
+
+    it("should use deprecated route prop if legacy is set to true", () => {
+        const result = getActionRoutesFromResource(
+            {
+                name: "users",
+                parentName: "orgs",
+                options: {
+                    route: "custom-users",
+                },
+                list: () => null,
+            },
+            [],
+            true,
+        );
+
+        expect(result).toEqual(
+            expect.arrayContaining([
+                expect.objectContaining({
+                    action: "list",
+                    route: "/orgs/custom-users",
+                }),
+            ]),
+        );
+    });
+
+    it("should use the specific route instead of the default one with no component", () => {
+        const result = getActionRoutesFromResource(
+            {
+                name: "users",
+                meta: {},
+                list: "/super-cool-nesting/users/list",
+            },
+            [],
+        );
+
+        expect(result).toEqual(
+            expect.arrayContaining([
+                expect.objectContaining({
+                    action: "list",
+                    route: "/super-cool-nesting/users/list",
+                }),
+            ]),
+        );
+    });
+});

package/src/definitions/helpers/router/__tests__/get-default-action-path.ts

@@ -0,0 +1,47 @@
+import { getDefaultActionPath } from "../get-default-action-path";
+
+describe("getDefaultActionPath", () => {
+    it("should return the default path for a given action and resource", () => {
+        expect(getDefaultActionPath("users", "list")).toBe("/users");
+        expect(getDefaultActionPath("users", "create")).toBe("/users/create");
+        expect(getDefaultActionPath("users", "edit")).toBe("/users/edit/:id");
+        expect(getDefaultActionPath("users", "show")).toBe("/users/show/:id");
+        expect(getDefaultActionPath("users", "clone")).toBe("/users/clone/:id");
+    });
+
+    it("should return the default path for a given action and resource with parent prefix", () => {
+        expect(getDefaultActionPath("users", "list", "/orgs")).toBe(
+            "/orgs/users",
+        );
+        expect(getDefaultActionPath("users", "create", "/orgs")).toBe(
+            "/orgs/users/create",
+        );
+        expect(getDefaultActionPath("users", "edit", "/orgs")).toBe(
+            "/orgs/users/edit/:id",
+        );
+        expect(getDefaultActionPath("users", "show", "/orgs")).toBe(
+            "/orgs/users/show/:id",
+        );
+        expect(getDefaultActionPath("users", "clone", "/orgs")).toBe(
+            "/orgs/users/clone/:id",
+        );
+    });
+
+    it("should return the default path for a given action and resource with multiple parent prefixes", () => {
+        expect(getDefaultActionPath("users", "list", "/orgs/posts")).toBe(
+            "/orgs/posts/users",
+        );
+        expect(getDefaultActionPath("users", "create", "/orgs/posts")).toBe(
+            "/orgs/posts/users/create",
+        );
+        expect(getDefaultActionPath("users", "edit", "/orgs/posts")).toBe(
+            "/orgs/posts/users/edit/:id",
+        );
+        expect(getDefaultActionPath("users", "show", "/orgs/posts")).toBe(
+            "/orgs/posts/users/show/:id",
+        );
+        expect(getDefaultActionPath("users", "clone", "/orgs/posts")).toBe(
+            "/orgs/posts/users/clone/:id",
+        );
+    });
+});

package/src/definitions/helpers/router/__tests__/get-parent-prefix-for-resource.ts

@@ -0,0 +1,84 @@
+import { getParentPrefixForResource } from "../get-parent-prefix-for-resource";
+
+describe("getParentPrefixForResource", () => {
+    it("should return undefined if no parent is found", () => {
+        const resources = [
+            {
+                name: "users",
+            },
+        ];
+
+        expect(getParentPrefixForResource(resources[0], resources)).toBe(
+            undefined,
+        );
+    });
+
+    it("should return the parent prefix", () => {
+        const resources = [
+            {
+                name: "users",
+            },
+            {
+                name: "posts",
+                meta: {
+                    parent: "users",
+                },
+            },
+        ];
+
+        expect(getParentPrefixForResource(resources[1], resources)).toBe(
+            "/users",
+        );
+    });
+
+    it("should return the parent prefix for deeply nested resources", () => {
+        const resources = [
+            {
+                name: "users",
+            },
+            {
+                name: "posts",
+                meta: {
+                    parent: "users",
+                },
+            },
+            {
+                name: "comments",
+                meta: {
+                    parent: "posts",
+                },
+            },
+        ];
+
+        expect(getParentPrefixForResource(resources[2], resources)).toBe(
+            "/users/posts",
+        );
+    });
+
+    it("should return the parent prefix for deeply nested resources with legacy routes", () => {
+        const resources = [
+            {
+                name: "users",
+                options: {
+                    route: "custom-users",
+                },
+            },
+            {
+                name: "posts",
+                meta: {
+                    parent: "users",
+                },
+            },
+            {
+                name: "comments",
+                meta: {
+                    parent: "posts",
+                },
+            },
+        ];
+
+        expect(getParentPrefixForResource(resources[2], resources, true)).toBe(
+            "/custom-users/posts",
+        );
+    });
+});

package/src/definitions/helpers/router/__tests__/get-parent-resource.ts

@@ -0,0 +1,51 @@
+import { getParentResource } from "../get-parent-resource";
+
+describe("getParentResource", () => {
+    it("should return undefined if no parent is given", () => {
+        const result = getParentResource(
+            {
+                name: "users",
+                meta: {},
+            },
+            [],
+        );
+
+        expect(result).toEqual(undefined);
+    });
+
+    it("should return the parent resource if parent is given", () => {
+        const result = getParentResource(
+            {
+                name: "users",
+                meta: {
+                    parent: "orgs",
+                },
+            },
+            [
+                {
+                    name: "orgs",
+                },
+            ],
+        );
+
+        expect(result).toEqual({
+            name: "orgs",
+        });
+    });
+
+    it("should return the parent resource if parent is given even if the parent is not defined", () => {
+        const result = getParentResource(
+            {
+                name: "users",
+                options: {
+                    parent: "orgs",
+                },
+            },
+            [],
+        );
+
+        expect(result).toEqual({
+            name: "orgs",
+        });
+    });
+});

package/src/definitions/helpers/router/__tests__/is-segment-counts-same.ts

@@ -0,0 +1,21 @@
+import { isSegmentCountsSame } from "../is-segment-counts-same";
+
+describe("isSegmentCountsSame", () => {
+    it("should return true if the route and resourceRoute have the same number of segments", () => {
+        const result = isSegmentCountsSame(
+            "/users/edit/123",
+            "/users/edit/:id",
+        );
+
+        expect(result).toEqual(true);
+    });
+
+    it("should return false if the route and resourceRoute don't have the same number of segments", () => {
+        const result = isSegmentCountsSame(
+            "/users/edit/123",
+            "users/posts/edit/:id/",
+        );
+
+        expect(result).toEqual(false);
+    });
+});

package/src/definitions/helpers/router/__tests__/match-resource-from-route.ts

@@ -0,0 +1,59 @@
+import { matchResourceFromRoute } from "../match-resource-from-route";
+
+describe("matchResourceFromRoute", () => {
+    it("should return found false if no resource is given", () => {
+        const result = matchResourceFromRoute("/users", []);
+
+        expect(result.found).toEqual(false);
+    });
+
+    it("should return found false if no route is given", () => {
+        const result = matchResourceFromRoute("", [
+            {
+                name: "users",
+                edit: {
+                    path: "/users/edit/:id",
+                    component: () => null,
+                },
+            },
+        ]);
+
+        expect(result.found).toEqual(false);
+    });
+
+    it("should return found true if route is found", () => {
+        const result = matchResourceFromRoute("/users/edit/123", [
+            {
+                name: "users",
+                edit: {
+                    path: "/users/edit/:id",
+                    component: () => null,
+                },
+            },
+        ]);
+
+        expect(result.found).toEqual(true);
+    });
+
+    it("should return the best one if multiple routes are found", () => {
+        const result = matchResourceFromRoute("/users/orgs/edit/123", [
+            {
+                name: "users",
+                edit: {
+                    path: "/users/:type/edit/:id",
+                    component: () => null,
+                },
+            },
+            {
+                name: "org-users",
+                edit: {
+                    path: "/users/orgs/edit/:id",
+                    component: () => null,
+                },
+            },
+        ]);
+
+        expect(result.found).toEqual(true);
+        expect(result.matchedRoute).toEqual("/users/orgs/edit/:id");
+    });
+});

package/src/definitions/helpers/router/__tests__/pick-matched-route.ts

@@ -0,0 +1,89 @@
+import { pickMatchedRoute } from "../pick-matched-route";
+
+describe("pickMatchedRoute", () => {
+    it("should return the route with no params", () => {
+        const routes = [
+            {
+                route: "/users/edit/123",
+                action: "edit" as const,
+                resource: { name: "users" },
+            },
+            {
+                route: "users/:action/:id/",
+                action: "edit" as const,
+                resource: { name: "users" },
+            },
+            {
+                route: "/users/:action/:id",
+                action: "edit" as const,
+                resource: { name: "users" },
+            },
+            {
+                route: "/users/edit/:id",
+                action: "edit" as const,
+                resource: { name: "users" },
+            },
+        ];
+
+        const picked = pickMatchedRoute(routes);
+
+        expect(picked?.route).toEqual("/users/edit/123");
+    });
+
+    it("should return the route with least params", () => {
+        const routes = [
+            {
+                route: "/users/:action/:id",
+                action: "edit" as const,
+                resource: { name: "users" },
+            },
+            {
+                route: "/users/edit/:id",
+                action: "edit" as const,
+                resource: { name: "users" },
+            },
+        ];
+
+        const picked = pickMatchedRoute(routes);
+
+        expect(picked?.route).toEqual("/users/edit/:id");
+    });
+
+    it("should return the latest parametrized route", () => {
+        const routes = [
+            {
+                route: "/users/page/:action/:id",
+                action: "edit" as const,
+                resource: { name: "users" },
+            },
+            {
+                route: "/users/page/list/:id/",
+                action: "edit" as const,
+                resource: { name: "users" },
+            },
+        ];
+
+        const picked = pickMatchedRoute(routes);
+
+        expect(picked?.route).toEqual("/users/page/list/:id/");
+    });
+
+    it("should return the latest parametrized route with single", () => {
+        const routes = [
+            {
+                route: "/users/:org/list/123",
+                action: "edit" as const,
+                resource: { name: "users" },
+            },
+            {
+                route: "/users/refine/list/:id",
+                action: "edit" as const,
+                resource: { name: "users" },
+            },
+        ];
+
+        const picked = pickMatchedRoute(routes);
+
+        expect(picked?.route).toEqual("/users/refine/list/:id");
+    });
+});

package/src/definitions/helpers/router/__tests__/pick-route-params.ts

@@ -0,0 +1,18 @@
+import { pickRouteParams } from "../pick-route-params";
+
+describe("pickRouteParams", () => {
+    it("should extract route params from a path", () => {
+        expect(pickRouteParams("/users/:id/posts/:postId")).toEqual([
+            "id",
+            "postId",
+        ]);
+    });
+
+    it("should return an empty array if no route params are given", () => {
+        expect(pickRouteParams("/users/list")).toEqual([]);
+    });
+
+    it("should extract route params from a path", () => {
+        expect(pickRouteParams("users/:id")).toEqual(["id"]);
+    });
+});

package/src/definitions/helpers/router/__tests__/prepare-route-params.ts

@@ -0,0 +1,23 @@
+import { prepareRouteParams } from "../prepare-route-params";
+
+describe("prepareRouteParams", () => {
+    it("should return an empty object if no route params are given", () => {
+        expect(prepareRouteParams([])).toEqual({});
+    });
+
+    it("should return `id` property when params array contains `id`", () => {
+        expect(prepareRouteParams(["id"], { id: "1" })).toEqual({ id: "1" });
+    });
+
+    it("should prioritize meta over params", () => {
+        expect(prepareRouteParams(["id"], { id: "1" }, { id: "2" })).toEqual({
+            id: "2",
+        });
+    });
+
+    it("should combine params and meta", () => {
+        expect(
+            prepareRouteParams(["id", "action"], { id: "1" }, { action: "2" }),
+        ).toEqual({ id: "1", action: "2" });
+    });
+});

package/src/definitions/helpers/router/__tests__/remove-leading-trailing-slashes.ts

@@ -0,0 +1,15 @@
+import { removeLeadingTrailingSlashes } from "../remove-leading-trailing-slashes";
+
+describe("removeLeadingTrailingSlashes", () => {
+    it("should remove leading and trailing slashes", () => {
+        expect(removeLeadingTrailingSlashes("/a/b/c")).toEqual("a/b/c");
+    });
+
+    it("should remove leading and trailing slashes", () => {
+        expect(removeLeadingTrailingSlashes("a/b/c")).toEqual("a/b/c");
+    });
+
+    it("should remove leading and trailing slashes", () => {
+        expect(removeLeadingTrailingSlashes("/a/b/c/")).toEqual("a/b/c");
+    });
+});

package/src/definitions/helpers/router/__tests__/split-to-segments.ts

@@ -0,0 +1,15 @@
+import { splitToSegments } from "../split-to-segments";
+
+describe("splitToSegments", () => {
+    it("should split a path to segments", () => {
+        expect(splitToSegments("/a/b/c")).toEqual(["a", "b", "c"]);
+    });
+
+    it("should split a path to segments", () => {
+        expect(splitToSegments("a/b/c")).toEqual(["a", "b", "c"]);
+    });
+
+    it("should split a path to segments", () => {
+        expect(splitToSegments("/a/b/c/")).toEqual(["a", "b", "c"]);
+    });
+});

package/src/definitions/helpers/router/check-by-segments.ts

@@ -0,0 +1,28 @@
+import { isParameter } from "./is-parameter";
+import { isSegmentCountsSame } from "./is-segment-counts-same";
+import { removeLeadingTrailingSlashes } from "./remove-leading-trailing-slashes";
+import { splitToSegments } from "./split-to-segments";
+
+/**
+ * This function if the route and resourceRoute match by segments.
+ * - First, trailing and leading slashes are removed
+ * - Then, the route and resourceRoute are split to segments and checked if they have the same number of segments
+ * - Then, each segment is checked if it is a parameter or if it matches the resourceRoute segment
+ * - If all segments match, the function returns true, otherwise false
+ */
+export const checkBySegments = (route: string, resourceRoute: string) => {
+    const stdRoute = removeLeadingTrailingSlashes(route);
+    const stdResourceRoute = removeLeadingTrailingSlashes(resourceRoute);
+    // we need to check if the route and resourceRoute have the same number of segments
+    // if not, we can't match them
+    if (!isSegmentCountsSame(stdRoute, stdResourceRoute)) {
+        return false;
+    }
+
+    const routeSegments = splitToSegments(stdRoute);
+    const resourceRouteSegments = splitToSegments(stdResourceRoute);
+
+    return resourceRouteSegments.every((segment, index) => {
+        return isParameter(segment) || segment === routeSegments[index];
+    });
+};

package/src/definitions/helpers/router/compose-route.ts

@@ -0,0 +1,30 @@
+import { MetaDataQuery, ParseResponse } from "../../../interfaces";
+
+import { pickRouteParams } from "./pick-route-params";
+import { prepareRouteParams } from "./prepare-route-params";
+
+/**
+ * This function will compose a route with the given params and meta.
+ * - A route can have parameters like (eg: /users/:id)
+ * - First we pick the route params from the route (eg: [id])
+ * - Then we prepare the route params with the given params and meta (eg: { id: 1 })
+ * - Then we replace the route params with the prepared route params (eg: /users/1)
+ */
+export const composeRoute = (
+    designatedRoute: string,
+    params: ParseResponse = {},
+    meta: MetaDataQuery = {},
+): string => {
+    // pickRouteParams (from the route)
+    const routeParams = pickRouteParams(designatedRoute);
+    // prepareRouteParams (from route params, params and meta)
+    const preparedRouteParams = prepareRouteParams(routeParams, params, meta);
+    // replace route params with prepared route params
+    return designatedRoute.replace(/:([^\/]+)/g, (match, key) => {
+        const fromParams = preparedRouteParams[key];
+        if (typeof fromParams !== "undefined") {
+            return `${fromParams}`;
+        }
+        return match;
+    });
+};