@refinedev/core 4.47.2 → 4.48.0

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

@@ -1,15 +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");
-    });
+  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

@@ -1,15 +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"]);
-    });
+  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

@@ -11,18 +11,18 @@ import { splitToSegments } from "./split-to-segments";
  * - 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 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);
+  const routeSegments = splitToSegments(stdRoute);
+  const resourceRouteSegments = splitToSegments(stdResourceRoute);
 
-    return resourceRouteSegments.every((segment, index) => {
-        return isParameter(segment) || segment === routeSegments[index];
-    });
+  return resourceRouteSegments.every((segment, index) => {
+    return isParameter(segment) || segment === routeSegments[index];
+  });
 };

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

@@ -10,32 +10,30 @@ import { prepareRouteParams } from "./prepare-route-params";
  * - Then we replace the route params with the prepared route params (eg: /users/1)
  */
 export const composeRoute = (
-    designatedRoute: string,
-    resourceMeta: MetaQuery = {},
-    parsed: ParseResponse = {},
-    meta: Record<string, unknown> = {},
+  designatedRoute: string,
+  resourceMeta: MetaQuery = {},
+  parsed: ParseResponse = {},
+  meta: Record<string, unknown> = {},
 ): string => {
-    // pickRouteParams (from the route)
-    const routeParams = pickRouteParams(designatedRoute);
-    // prepareRouteParams (from route params, params and meta)
-    const preparedRouteParams = prepareRouteParams(routeParams, {
-        ...resourceMeta,
-        ...(typeof parsed?.id !== "undefined" ? { id: parsed.id } : {}),
-        ...(typeof parsed?.action !== "undefined"
-            ? { action: parsed.action }
-            : {}),
-        ...(typeof parsed?.resource !== "undefined"
-            ? { resource: parsed.resource }
-            : {}),
-        ...parsed?.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;
-    });
+  // pickRouteParams (from the route)
+  const routeParams = pickRouteParams(designatedRoute);
+  // prepareRouteParams (from route params, params and meta)
+  const preparedRouteParams = prepareRouteParams(routeParams, {
+    ...resourceMeta,
+    ...(typeof parsed?.id !== "undefined" ? { id: parsed.id } : {}),
+    ...(typeof parsed?.action !== "undefined" ? { action: parsed.action } : {}),
+    ...(typeof parsed?.resource !== "undefined"
+      ? { resource: parsed.resource }
+      : {}),
+    ...parsed?.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;
+  });
 };

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

@@ -3,9 +3,9 @@ import { getDefaultActionPath } from "./get-default-action-path";
 import { getParentPrefixForResource } from "./get-parent-prefix-for-resource";
 
 export type ResourceActionRoute = {
-    action: Action;
-    resource: IResourceItem;
-    route: string;
+  action: Action;
+  resource: IResourceItem;
+  route: string;
 };
 
 /**
@@ -16,56 +16,50 @@ export type ResourceActionRoute = {
  * - It will return an array of objects with the action, the resource and the route
  */
 export const getActionRoutesFromResource = (
-    resource: IResourceItem,
-    resources: IResourceItem[],
-    /**
-     * Uses legacy route if true (`options.route`)
-     */
-    legacy?: boolean,
+  resource: IResourceItem,
+  resources: IResourceItem[],
+  /**
+   * Uses legacy route if true (`options.route`)
+   */
+  legacy?: boolean,
 ) => {
-    const actions: ResourceActionRoute[] = [];
+  const actions: ResourceActionRoute[] = [];
 
-    const actionList: Action[] = ["list", "show", "edit", "create", "clone"];
+  const actionList: Action[] = ["list", "show", "edit", "create", "clone"];
 
-    const parentPrefix = getParentPrefixForResource(
-        resource,
-        resources,
-        legacy,
-    );
+  const parentPrefix = getParentPrefixForResource(resource, resources, legacy);
 
-    actionList.forEach((action) => {
-        const item =
-            legacy && action === "clone" ? resource.create : resource[action];
+  actionList.forEach((action) => {
+    const item =
+      legacy && action === "clone" ? resource.create : resource[action];
 
-        let route: string | undefined = undefined;
+    let route: string | undefined = undefined;
 
-        if (typeof item === "function" || legacy) {
-            // means we're fallbacking to default path for the action
-            route = getDefaultActionPath(
-                legacy
-                    ? resource.meta?.route ??
-                          resource.options?.route ??
-                          resource.name
-                    : resource.name,
-                action,
-                legacy ? parentPrefix : undefined,
-            );
-        } else if (typeof item === "string") {
-            // means we don't have the component, but we have the route
-            route = item;
-        } else if (typeof item === "object") {
-            // means we have the component and the route
-            route = item.path;
-        }
+    if (typeof item === "function" || legacy) {
+      // means we're fallbacking to default path for the action
+      route = getDefaultActionPath(
+        legacy
+          ? resource.meta?.route ?? resource.options?.route ?? resource.name
+          : resource.name,
+        action,
+        legacy ? parentPrefix : undefined,
+      );
+    } else if (typeof item === "string") {
+      // means we don't have the component, but we have the route
+      route = item;
+    } else if (typeof item === "object") {
+      // means we have the component and the route
+      route = item.path;
+    }
 
-        if (route) {
-            actions.push({
-                action,
-                resource,
-                route: `/${route.replace(/^\//, "")}`,
-            });
-        }
-    });
+    if (route) {
+      actions.push({
+        action,
+        resource,
+        route: `/${route.replace(/^\//, "")}`,
+      });
+    }
+  });
 
-    return actions;
+  return actions;
 };

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

@@ -7,27 +7,27 @@ import { removeLeadingTrailingSlashes } from "./remove-leading-trailing-slashes"
  * This is used by the legacy router and the new router if the resource doesn't provide a custom path.
  */
 export const getDefaultActionPath = (
-    resourceName: string,
-    action: Action,
-    parentPrefix?: string,
+  resourceName: string,
+  action: Action,
+  parentPrefix?: string,
 ): string => {
-    const cleanParentPrefix = removeLeadingTrailingSlashes(parentPrefix || "");
+  const cleanParentPrefix = removeLeadingTrailingSlashes(parentPrefix || "");
 
-    let path = `${cleanParentPrefix}${
-        cleanParentPrefix ? "/" : ""
-    }${resourceName}`;
+  let path = `${cleanParentPrefix}${
+    cleanParentPrefix ? "/" : ""
+  }${resourceName}`;
 
-    if (action === "list") {
-        path = `${path}`;
-    } else if (action === "create") {
-        path = `${path}/create`;
-    } else if (action === "edit") {
-        path = `${path}/edit/:id`;
-    } else if (action === "show") {
-        path = `${path}/show/:id`;
-    } else if (action === "clone") {
-        path = `${path}/clone/:id`;
-    }
+  if (action === "list") {
+    path = `${path}`;
+  } else if (action === "create") {
+    path = `${path}/create`;
+  } else if (action === "edit") {
+    path = `${path}/edit/:id`;
+  } else if (action === "show") {
+    path = `${path}/show/:id`;
+  } else if (action === "clone") {
+    path = `${path}/clone/:id`;
+  }
 
-    return `/${path.replace(/^\//, "")}`;
+  return `/${path.replace(/^\//, "")}`;
 };

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

@@ -7,33 +7,31 @@ import { removeLeadingTrailingSlashes } from "./remove-leading-trailing-slashes"
  * - If `legacy` is provided, the computation is based on the `route` option of the resource
  */
 export const getParentPrefixForResource = (
-    resource: ResourceProps,
-    resources: ResourceProps[],
-    /**
-     * Uses legacy route if true (`options.route`)
-     */
-    legacy?: boolean,
+  resource: ResourceProps,
+  resources: ResourceProps[],
+  /**
+   * Uses legacy route if true (`options.route`)
+   */
+  legacy?: boolean,
 ): string | undefined => {
-    const parents: ResourceProps[] = [];
+  const parents: ResourceProps[] = [];
 
-    let parent = getParentResource(resource, resources);
+  let parent = getParentResource(resource, resources);
 
-    while (parent) {
-        parents.push(parent);
-        parent = getParentResource(parent, resources);
-    }
+  while (parent) {
+    parents.push(parent);
+    parent = getParentResource(parent, resources);
+  }
 
-    if (parents.length === 0) {
-        return undefined;
-    }
+  if (parents.length === 0) {
+    return undefined;
+  }
 
-    return `/${parents
-        .reverse()
-        .map((parent) => {
-            const v = legacy
-                ? parent.options?.route ?? parent.name
-                : parent.name;
-            return removeLeadingTrailingSlashes(v);
-        })
-        .join("/")}`;
+  return `/${parents
+    .reverse()
+    .map((parent) => {
+      const v = legacy ? parent.options?.route ?? parent.name : parent.name;
+      return removeLeadingTrailingSlashes(v);
+    })
+    .join("/")}`;
 };

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

@@ -6,26 +6,26 @@ import { pickNotDeprecated } from "../pickNotDeprecated";
  * Works both with the deprecated `parentName` and the new `parent` property.
  */
 export const getParentResource = (
-    resource: IResourceItem,
-    resources: IResourceItem[],
+  resource: IResourceItem,
+  resources: IResourceItem[],
 ): IResourceItem | undefined => {
-    const parentName = pickNotDeprecated(
-        resource.meta?.parent,
-        resource.options?.parent,
-        resource.parentName,
-    );
+  const parentName = pickNotDeprecated(
+    resource.meta?.parent,
+    resource.options?.parent,
+    resource.parentName,
+  );
 
-    if (!parentName) {
-        return undefined;
-    }
+  if (!parentName) {
+    return undefined;
+  }
 
-    const parentResource = resources.find(
-        (resource) => (resource.identifier ?? resource.name) === parentName,
-    );
+  const parentResource = resources.find(
+    (resource) => (resource.identifier ?? resource.name) === parentName,
+  );
 
-    /**
-     * If the parent resource is not found, we return a resource object with the name of the parent resource.
-     * Because we still want to have nesting and prefixing for the resource even if the parent is not explicitly defined.
-     */
-    return parentResource ?? { name: parentName };
+  /**
+   * If the parent resource is not found, we return a resource object with the name of the parent resource.
+   * Because we still want to have nesting and prefixing for the resource even if the parent is not explicitly defined.
+   */
+  return parentResource ?? { name: parentName };
 };

package/src/definitions/helpers/router/is-parameter.ts

@@ -2,5 +2,5 @@
  * Check if a segment is a parameter. (e.g. :id)
  */
 export const isParameter = (segment: string) => {
-    return segment.startsWith(":");
+  return segment.startsWith(":");
 };

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

@@ -4,8 +4,8 @@ import { splitToSegments } from "./split-to-segments";
  * Checks if the both routes have the same number of segments.
  */
 export const isSegmentCountsSame = (route: string, resourceRoute: string) => {
-    const routeSegments = splitToSegments(route);
-    const resourceRouteSegments = splitToSegments(resourceRoute);
+  const routeSegments = splitToSegments(route);
+  const resourceRouteSegments = splitToSegments(resourceRoute);
 
-    return routeSegments.length === resourceRouteSegments.length;
+  return routeSegments.length === resourceRouteSegments.length;
 };

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

@@ -10,28 +10,28 @@ import { pickMatchedRoute } from "./pick-matched-route";
  * - It will return the most eligible resource and action
  */
 export const matchResourceFromRoute = (
-    route: string,
-    resources: IResourceItem[],
+  route: string,
+  resources: IResourceItem[],
 ): {
-    found: boolean;
-    resource?: IResourceItem;
-    action?: Action;
-    matchedRoute?: string;
+  found: boolean;
+  resource?: IResourceItem;
+  action?: Action;
+  matchedRoute?: string;
 } => {
-    const allActionRoutes = resources.flatMap((resource) => {
-        return getActionRoutesFromResource(resource, resources);
-    });
+  const allActionRoutes = resources.flatMap((resource) => {
+    return getActionRoutesFromResource(resource, resources);
+  });
 
-    const allFound = allActionRoutes.filter((actionRoute) => {
-        return checkBySegments(route, actionRoute.route);
-    });
+  const allFound = allActionRoutes.filter((actionRoute) => {
+    return checkBySegments(route, actionRoute.route);
+  });
 
-    const mostEligible = pickMatchedRoute(allFound);
+  const mostEligible = pickMatchedRoute(allFound);
 
-    return {
-        found: !!mostEligible,
-        resource: mostEligible?.resource,
-        action: mostEligible?.action,
-        matchedRoute: mostEligible?.route,
-    };
+  return {
+    found: !!mostEligible,
+    resource: mostEligible?.resource,
+    action: mostEligible?.action,
+    matchedRoute: mostEligible?.route,
+  };
 };

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

@@ -9,53 +9,53 @@ import { splitToSegments } from "./split-to-segments";
  * - If there's more than one route, it picks the best non-greedy match.
  */
 export const pickMatchedRoute = (
-    routes: ResourceActionRoute[],
+  routes: ResourceActionRoute[],
 ): ResourceActionRoute | undefined => {
-    // these routes are all matched, we should pick the least parametrized one
-
-    // no routes, no match
-    if (routes.length === 0) {
-        return undefined;
+  // these routes are all matched, we should pick the least parametrized one
+
+  // no routes, no match
+  if (routes.length === 0) {
+    return undefined;
+  }
+
+  // no need to calculate the route segments if there's only one route
+  if (routes.length === 1) {
+    return routes[0];
+  }
+
+  // remove trailing and leading slashes
+  // split them to segments
+  const sanitizedRoutes = routes.map((route) => ({
+    ...route,
+    splitted: splitToSegments(removeLeadingTrailingSlashes(route.route)),
+  }));
+
+  // at this point, before calling this function, we already checked for segment lenghts and expect all of them to be the same
+  const segmentsCount = sanitizedRoutes[0]?.splitted.length ?? 0;
+
+  let eligibleRoutes: Array<(typeof sanitizedRoutes)[number]> = [
+    ...sanitizedRoutes,
+  ];
+
+  // loop through the segments
+  for (let i = 0; i < segmentsCount; i++) {
+    const nonParametrizedRoutes = eligibleRoutes.filter(
+      (route) => !isParameter(route.splitted[i]),
+    );
+
+    if (nonParametrizedRoutes.length === 0) {
+      // keep the eligible routes as they are
+      continue;
     }
-
-    // no need to calculate the route segments if there's only one route
-    if (routes.length === 1) {
-        return routes[0];
+    if (nonParametrizedRoutes.length === 1) {
+      // no need to continue, we found the route
+      eligibleRoutes = nonParametrizedRoutes;
+      break;
     }
 
-    // remove trailing and leading slashes
-    // split them to segments
-    const sanitizedRoutes = routes.map((route) => ({
-        ...route,
-        splitted: splitToSegments(removeLeadingTrailingSlashes(route.route)),
-    }));
-
-    // at this point, before calling this function, we already checked for segment lenghts and expect all of them to be the same
-    const segmentsCount = sanitizedRoutes[0]?.splitted.length ?? 0;
-
-    let eligibleRoutes: Array<(typeof sanitizedRoutes)[number]> = [
-        ...sanitizedRoutes,
-    ];
-
-    // loop through the segments
-    for (let i = 0; i < segmentsCount; i++) {
-        const nonParametrizedRoutes = eligibleRoutes.filter(
-            (route) => !isParameter(route.splitted[i]),
-        );
-
-        if (nonParametrizedRoutes.length === 0) {
-            // keep the eligible routes as they are
-            continue;
-        }
-        if (nonParametrizedRoutes.length === 1) {
-            // no need to continue, we found the route
-            eligibleRoutes = nonParametrizedRoutes;
-            break;
-        }
-
-        // we have more than one non-parametrized route, we need to check the next segment
-        eligibleRoutes = nonParametrizedRoutes;
-    }
+    // we have more than one non-parametrized route, we need to check the next segment
+    eligibleRoutes = nonParametrizedRoutes;
+  }
 
-    return eligibleRoutes[0];
+  return eligibleRoutes[0];
 };

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

@@ -7,13 +7,13 @@ import { isParameter } from "./is-parameter";
  * (e.g. /users/:id/posts/:postId => ['id', 'postId'])
  */
 export const pickRouteParams = (route: string) => {
-    const segments = splitToSegments(removeLeadingTrailingSlashes(route));
+  const segments = splitToSegments(removeLeadingTrailingSlashes(route));
 
-    return segments.flatMap((s) => {
-        if (isParameter(s)) {
-            return [s.slice(1)];
-        }
+  return segments.flatMap((s) => {
+    if (isParameter(s)) {
+      return [s.slice(1)];
+    }
 
-        return [];
-    });
+    return [];
+  });
 };

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

@@ -5,16 +5,19 @@
  * This means, we can use `meta` for user supplied params (both manually or from the query string)
  */
 export const prepareRouteParams = <
-    TRouteParams extends Record<string, unknown> = Record<string, unknown>,
+  TRouteParams extends Record<string, unknown> = Record<string, unknown>,
 >(
-    routeParams: (keyof TRouteParams)[],
-    meta: Record<string, unknown> = {},
+  routeParams: (keyof TRouteParams)[],
+  meta: Record<string, unknown> = {},
 ): Partial<TRouteParams> => {
-    return routeParams.reduce((acc, key) => {
-        const value = meta[key as string];
-        if (typeof value !== "undefined") {
-            acc[key] = value as TRouteParams[keyof TRouteParams];
-        }
-        return acc;
-    }, {} as Partial<TRouteParams>);
+  return routeParams.reduce(
+    (acc, key) => {
+      const value = meta[key as string];
+      if (typeof value !== "undefined") {
+        acc[key] = value as TRouteParams[keyof TRouteParams];
+      }
+      return acc;
+    },
+    {} as Partial<TRouteParams>,
+  );
 };

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

@@ -2,5 +2,5 @@
  * Remove leading and trailing slashes from a route.
  */
 export const removeLeadingTrailingSlashes = (route: string) => {
-    return route.replace(/^\/|\/$/g, "");
+  return route.replace(/^\/|\/$/g, "");
 };

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

@@ -2,6 +2,6 @@
  * Split a path to segments.
  */
 export const splitToSegments = (path: string) => {
-    const segments = path.split("/").filter((segment) => segment !== "");
-    return segments;
+  const segments = path.split("/").filter((segment) => segment !== "");
+  return segments;
 };