@refinedev/core 4.47.2 → 4.48.0

package/src/definitions/helpers/menu/create-tree.ts

@@ -3,85 +3,83 @@ import { getParentResource } from "../router";
 import { createResourceKey } from "./create-resource-key";
 
 export type Tree = {
-    item: IResourceItem;
-    children: { [key: string]: Tree };
+  item: IResourceItem;
+  children: { [key: string]: Tree };
 };
 
 export type FlatTreeItem = IResourceItem & {
-    key: string;
-    children: FlatTreeItem[];
+  key: string;
+  children: FlatTreeItem[];
 };
 
 export const createTree = (
-    resources: IResourceItem[],
-    legacy = false,
+  resources: IResourceItem[],
+  legacy = false,
 ): FlatTreeItem[] => {
-    const root: Tree = {
-        item: {
-            name: "__root__",
-        },
-        children: {},
-    };
+  const root: Tree = {
+    item: {
+      name: "__root__",
+    },
+    children: {},
+  };
 
-    resources.forEach((resource) => {
-        const parents: IResourceItem[] = [];
+  resources.forEach((resource) => {
+    const parents: IResourceItem[] = [];
 
-        let currentParent = getParentResource(resource, resources);
-        while (currentParent) {
-            parents.push(currentParent);
-            currentParent = getParentResource(currentParent, resources);
-        }
-        parents.reverse();
+    let currentParent = getParentResource(resource, resources);
+    while (currentParent) {
+      parents.push(currentParent);
+      currentParent = getParentResource(currentParent, resources);
+    }
+    parents.reverse();
 
-        let currentTree = root;
+    let currentTree = root;
 
-        parents.forEach((parent) => {
-            const key =
-                (legacy ? parent.route : undefined) ??
-                parent.identifier ??
-                parent.name;
+    parents.forEach((parent) => {
+      const key =
+        (legacy ? parent.route : undefined) ?? parent.identifier ?? parent.name;
 
-            if (!currentTree.children[key]) {
-                currentTree.children[key] = {
-                    item: parent,
-                    children: {},
-                };
-            }
-            currentTree = currentTree.children[key];
-        });
+      if (!currentTree.children[key]) {
+        currentTree.children[key] = {
+          item: parent,
+          children: {},
+        };
+      }
+      currentTree = currentTree.children[key];
+    });
 
-        const key =
-            (legacy ? resource.route : undefined) ??
-            resource.identifier ??
-            resource.name;
+    const key =
+      (legacy ? resource.route : undefined) ??
+      resource.identifier ??
+      resource.name;
 
-        if (!currentTree.children[key]) {
-            currentTree.children[key] = {
-                item: resource,
-                children: {},
-            };
-        }
-    });
+    if (!currentTree.children[key]) {
+      currentTree.children[key] = {
+        item: resource,
+        children: {},
+      };
+    }
+  });
 
-    const flatten = (tree: Tree): FlatTreeItem[] => {
-        const items: FlatTreeItem[] = [];
+  const flatten = (tree: Tree): FlatTreeItem[] => {
+    const items: FlatTreeItem[] = [];
 
-        Object.keys(tree.children).forEach((key) => {
-            const itemKey = createResourceKey(
-                tree.children[key].item,
-                resources,
-                legacy,
-            );
-            const item: FlatTreeItem = {
-                ...tree.children[key].item,
-                key: itemKey,
-                children: flatten(tree.children[key]),
-            };
-            items.push(item);
-        });
+    Object.keys(tree.children).forEach((key) => {
+      const itemKey = createResourceKey(
+        tree.children[key].item,
+        resources,
+        legacy,
+      );
+      const item: FlatTreeItem = {
+        ...tree.children[key].item,
+        key: itemKey,
+        children: flatten(tree.children[key]),
+      };
+      items.push(item);
+    });
 
-        return items;
-    };
+    return items;
+  };
 
-    return flatten(root);
+  return flatten(root);
 };

package/src/definitions/helpers/pick-resource/index.ts

@@ -7,35 +7,35 @@ import { removeLeadingTrailingSlashes } from "../router/remove-leading-trailing-
  * If legacy is true, then resource is matched by `route` first and then by `name`.
  */
 export const pickResource = (
-    identifier?: string,
-    resources: IResourceItem[] = [],
-    /**
-     * If true, the identifier will be checked for `route` and `name` properties
-     */
-    legacy = false,
+  identifier?: string,
+  resources: IResourceItem[] = [],
+  /**
+   * If true, the identifier will be checked for `route` and `name` properties
+   */
+  legacy = false,
 ): IResourceItem | undefined => {
-    if (!identifier) {
-        return undefined;
-    }
+  if (!identifier) {
+    return undefined;
+  }
 
-    if (legacy) {
-        const resourceByRoute = resources.find(
-            (r) =>
-                removeLeadingTrailingSlashes(r.route ?? "") ===
-                removeLeadingTrailingSlashes(identifier),
-        );
+  if (legacy) {
+    const resourceByRoute = resources.find(
+      (r) =>
+        removeLeadingTrailingSlashes(r.route ?? "") ===
+        removeLeadingTrailingSlashes(identifier),
+    );
 
-        const resource = resourceByRoute
-            ? resourceByRoute
-            : resources.find((r) => r.name === identifier);
+    const resource = resourceByRoute
+      ? resourceByRoute
+      : resources.find((r) => r.name === identifier);
 
-        return resource;
-    }
+    return resource;
+  }
 
-    let resource = resources.find((r) => r.identifier === identifier);
-    if (!resource) {
-        resource = resources.find((r) => r.name === identifier);
-    }
+  let resource = resources.find((r) => r.identifier === identifier);
+  if (!resource) {
+    resource = resources.find((r) => r.name === identifier);
+  }
 
-    return resource;
+  return resource;
 };

package/src/definitions/helpers/pickDataProvider/index.ts

@@ -6,24 +6,24 @@ import { pickNotDeprecated } from "../pickNotDeprecated";
  * Picks the data provider name based on the provided name or fallbacks to resource definition, or `default`.
  */
 export const pickDataProvider = (
-    resourceName?: string,
-    dataProviderName?: string,
-    resources?: IResourceItem[],
+  resourceName?: string,
+  dataProviderName?: string,
+  resources?: IResourceItem[],
 ) => {
-    if (dataProviderName) {
-        return dataProviderName;
-    }
+  if (dataProviderName) {
+    return dataProviderName;
+  }
 
-    /**
-     * In this helper, we don't do `route` based matching therefore there's no need to check for `legacy` behaviors.
-     */
-    const resource = pickResource(resourceName, resources);
+  /**
+   * In this helper, we don't do `route` based matching therefore there's no need to check for `legacy` behaviors.
+   */
+  const resource = pickResource(resourceName, resources);
 
-    const meta = pickNotDeprecated(resource?.meta, resource?.options);
+  const meta = pickNotDeprecated(resource?.meta, resource?.options);
 
-    if (meta?.dataProviderName) {
-        return meta.dataProviderName;
-    }
+  if (meta?.dataProviderName) {
+    return meta.dataProviderName;
+  }
 
-    return "default";
+  return "default";
 };

package/src/definitions/helpers/pickNotDeprecated/index.ts

@@ -3,7 +3,7 @@
  * @internal This is an internal helper function. Please do not use externally.
  */
 export const pickNotDeprecated = <T extends unknown[]>(
-    ...args: T
+  ...args: T
 ): T[never] => {
-    return args.find((arg) => typeof arg !== "undefined");
+  return args.find((arg) => typeof arg !== "undefined");
 };

package/src/definitions/helpers/property-path-to-array/index.ts

@@ -1,5 +1,5 @@
 export const propertyPathToArray = (propertyPath: string) => {
-    return propertyPath
-        .split(".")
-        .map((item) => (!isNaN(Number(item)) ? Number(item) : item));
+  return propertyPath
+    .split(".")
+    .map((item) => (!Number.isNaN(Number(item)) ? Number(item) : item));
 };

package/src/definitions/helpers/queryKeys/index.ts

@@ -9,6 +9,49 @@ import { keys as newKeys } from "../keys";
  * @deprecated `queryKeys` is deprecated. Please use `keys` instead.
  */
 export const queryKeys = (
+  resource?: string,
+  dataProviderName?: string,
+  meta?: MetaQuery,
+  /**
+   * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+   */
+  metaData?: MetaQuery | undefined,
+): IQueryKeys => {
+  const providerName = dataProviderName || "default";
+  const keys: IQueryKeys = {
+    all: [providerName],
+    resourceAll: [providerName, resource || ""],
+    list: (config) => [
+      ...keys.resourceAll,
+      "list",
+      {
+        ...config,
+        ...(pickNotDeprecated(meta, metaData) || {}),
+      } as QueryKey,
+    ],
+    many: (ids) =>
+      [
+        ...keys.resourceAll,
+        "getMany",
+        ids?.map(String) as QueryKey,
+        { ...(pickNotDeprecated(meta, metaData) || {}) } as QueryKey,
+      ].filter((item) => item !== undefined),
+    detail: (id) => [
+      ...keys.resourceAll,
+      "detail",
+      id?.toString(),
+      { ...(pickNotDeprecated(meta, metaData) || {}) } as QueryKey,
+    ],
+    logList: (meta) =>
+      ["logList", resource, meta as any, metaData as QueryKey].filter(
+        (item) => item !== undefined,
+      ),
+  };
+  return keys;
+};
+
+export const queryKeysReplacement = (preferLegacyKeys?: boolean) => {
+  return (
     resource?: string,
     dataProviderName?: string,
     meta?: MetaQuery,
@@ -16,100 +59,57 @@ export const queryKeys = (
      * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
      */
     metaData?: MetaQuery | undefined,
-): IQueryKeys => {
+  ): IQueryKeys => {
     const providerName = dataProviderName || "default";
+
     const keys: IQueryKeys = {
-        all: [providerName],
-        resourceAll: [providerName, resource || ""],
-        list: (config) => [
-            ...keys.resourceAll,
-            "list",
-            {
-                ...config,
-                ...(pickNotDeprecated(meta, metaData) || {}),
-            } as QueryKey,
-        ],
-        many: (ids) =>
-            [
-                ...keys.resourceAll,
-                "getMany",
-                (ids && ids.map(String)) as QueryKey,
-                { ...(pickNotDeprecated(meta, metaData) || {}) } as QueryKey,
-            ].filter((item) => item !== undefined),
-        detail: (id) => [
-            ...keys.resourceAll,
-            "detail",
-            id?.toString(),
-            { ...(pickNotDeprecated(meta, metaData) || {}) } as QueryKey,
-        ],
-        logList: (meta) =>
-            ["logList", resource, meta as any, metaData as QueryKey].filter(
-                (item) => item !== undefined,
-            ),
+      all: newKeys().data(providerName).get(preferLegacyKeys),
+      resourceAll: newKeys()
+        .data(dataProviderName)
+        .resource(resource ?? "")
+        .get(preferLegacyKeys),
+      list: (config) =>
+        newKeys()
+          .data(dataProviderName)
+          .resource(resource ?? "")
+          .action("list")
+          .params({
+            ...config,
+            ...(pickNotDeprecated(meta, metaData) || {}),
+          })
+          .get(preferLegacyKeys),
+      many: (ids) =>
+        newKeys()
+          .data(dataProviderName)
+          .resource(resource ?? "")
+          .action("many")
+          .ids(...(ids ?? []))
+          .params({
+            ...(pickNotDeprecated(meta, metaData) || {}),
+          })
+          .get(preferLegacyKeys),
+      detail: (id) =>
+        newKeys()
+          .data(dataProviderName)
+          .resource(resource ?? "")
+          .action("one")
+          .id(id ?? "")
+          .params({
+            ...(pickNotDeprecated(meta, metaData) || {}),
+          })
+          .get(preferLegacyKeys),
+      logList: (meta) =>
+        [
+          ...newKeys()
+            .audit()
+            .resource(resource)
+            .action("list")
+            .params(meta)
+            .get(preferLegacyKeys),
+          metaData as QueryKey,
+        ].filter((item) => item !== undefined),
     };
-    return keys;
-};
-
-export const queryKeysReplacement = (preferLegacyKeys?: boolean) => {
-    return (
-        resource?: string,
-        dataProviderName?: string,
-        meta?: MetaQuery,
-        /**
-         * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
-         */
-        metaData?: MetaQuery | undefined,
-    ): IQueryKeys => {
-        const providerName = dataProviderName || "default";
 
-        const keys: IQueryKeys = {
-            all: newKeys().data(providerName).get(preferLegacyKeys),
-            resourceAll: newKeys()
-                .data(dataProviderName)
-                .resource(resource ?? "")
-                .get(preferLegacyKeys),
-            list: (config) =>
-                newKeys()
-                    .data(dataProviderName)
-                    .resource(resource ?? "")
-                    .action("list")
-                    .params({
-                        ...config,
-                        ...(pickNotDeprecated(meta, metaData) || {}),
-                    })
-                    .get(preferLegacyKeys),
-            many: (ids) =>
-                newKeys()
-                    .data(dataProviderName)
-                    .resource(resource ?? "")
-                    .action("many")
-                    .ids(...(ids ?? []))
-                    .params({
-                        ...(pickNotDeprecated(meta, metaData) || {}),
-                    })
-                    .get(preferLegacyKeys),
-            detail: (id) =>
-                newKeys()
-                    .data(dataProviderName)
-                    .resource(resource ?? "")
-                    .action("one")
-                    .id(id ?? "")
-                    .params({
-                        ...(pickNotDeprecated(meta, metaData) || {}),
-                    })
-                    .get(preferLegacyKeys),
-            logList: (meta) =>
-                [
-                    ...newKeys()
-                        .audit()
-                        .resource(resource)
-                        .action("list")
-                        .params(meta)
-                        .get(preferLegacyKeys),
-                    metaData as QueryKey,
-                ].filter((item) => item !== undefined),
-        };
-
-        return keys;
-    };
+    return keys;
+  };
 };

package/src/definitions/helpers/redirectPage/index.ts

@@ -1,28 +1,28 @@
 import { Action, IRefineContextOptions, RedirectAction } from "src/interfaces";
 
 type RedirectPageProps = {
-    redirectFromProps?: RedirectAction;
-    action: Action;
-    redirectOptions: IRefineContextOptions["redirect"];
+  redirectFromProps?: RedirectAction;
+  action: Action;
+  redirectOptions: IRefineContextOptions["redirect"];
 };
 
 export const redirectPage = ({
-    redirectFromProps,
-    action,
-    redirectOptions,
+  redirectFromProps,
+  action,
+  redirectOptions,
 }: RedirectPageProps): RedirectAction => {
-    if (redirectFromProps || redirectFromProps === false) {
-        return redirectFromProps;
-    }
+  if (redirectFromProps || redirectFromProps === false) {
+    return redirectFromProps;
+  }
 
-    switch (action) {
-        case "clone":
-            return redirectOptions.afterClone;
-        case "create":
-            return redirectOptions.afterCreate;
-        case "edit":
-            return redirectOptions.afterEdit;
-        default:
-            return false;
-    }
+  switch (action) {
+    case "clone":
+      return redirectOptions.afterClone;
+    case "create":
+      return redirectOptions.afterCreate;
+    case "edit":
+      return redirectOptions.afterEdit;
+    default:
+      return false;
+  }
 };

package/src/definitions/helpers/routeGenerator/index.ts

@@ -7,23 +7,23 @@ import { pickNotDeprecated } from "../pickNotDeprecated";
  * @deprecated this is a **legacy** function and works only with the old resource definition
  */
 export const routeGenerator = (
-    item: ResourceProps,
-    resourcesFromProps: ResourceProps[],
+  item: ResourceProps,
+  resourcesFromProps: ResourceProps[],
 ): string | undefined => {
-    let route;
+  let route;
 
-    const parentPrefix = getParentPrefixForResource(
-        item,
-        resourcesFromProps,
-        true,
-    );
+  const parentPrefix = getParentPrefixForResource(
+    item,
+    resourcesFromProps,
+    true,
+  );
 
-    if (parentPrefix) {
-        const meta = pickNotDeprecated(item.meta, item.options);
-        route = `${parentPrefix}/${meta?.route ?? item.name}`;
-    } else {
-        route = item.options?.route ?? item.name;
-    }
+  if (parentPrefix) {
+    const meta = pickNotDeprecated(item.meta, item.options);
+    route = `${parentPrefix}/${meta?.route ?? item.name}`;
+  } else {
+    route = item.options?.route ?? item.name;
+  }
 
-    return `/${route.replace(/^\//, "")}`;
+  return `/${route.replace(/^\//, "")}`;
 };

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

@@ -1,24 +1,21 @@
 import { checkBySegments } from "../check-by-segments";
 
 describe("checkBySegments", () => {
-    it("should return true if the route and resourceRoute match by segments", () => {
-        const result = checkBySegments("/users/edit/123", "/users/edit/:id");
+  it("should return true if the route and resourceRoute match by segments", () => {
+    const result = checkBySegments("/users/edit/123", "/users/edit/:id");
 
-        expect(result).toEqual(true);
-    });
+    expect(result).toEqual(true);
+  });
 
-    it("should return false if the route and resourceRoute don't match by segments", () => {
-        const result = checkBySegments("/users/edit/123", "/posts/edit/:id/");
+  it("should return false if the route and resourceRoute don't match by segments", () => {
+    const result = checkBySegments("/users/edit/123", "/posts/edit/:id/");
 
-        expect(result).toEqual(false);
-    });
+    expect(result).toEqual(false);
+  });
 
-    it("should return false if segments are not equal", () => {
-        const result = checkBySegments(
-            "/users/edit/123",
-            "/users/edit/:id/step",
-        );
+  it("should return false if segments are not equal", () => {
+    const result = checkBySegments("/users/edit/123", "/users/edit/:id/step");
 
-        expect(result).toEqual(false);
-    });
+    expect(result).toEqual(false);
+  });
 });