@refinedev/core 4.0.0

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

@@ -0,0 +1,94 @@
+import { QueryClient, QueryClientConfig } from "@tanstack/react-query";
+import { ReactQueryDevtools } from "@tanstack/react-query-devtools";
+
+import { defaultRefineOptions } from "@contexts/refine";
+import {
+    IRefineContextOptions,
+    IRefineOptions,
+    LiveModeProps,
+    MutationMode,
+} from "src/interfaces";
+
+type HandleRefineOptionsProps = {
+    options?: IRefineOptions;
+    mutationMode?: MutationMode;
+    syncWithLocation?: boolean;
+    warnWhenUnsavedChanges?: boolean;
+    undoableTimeout?: number;
+    liveMode?: LiveModeProps["liveMode"];
+    disableTelemetry?: boolean;
+    reactQueryClientConfig?: QueryClientConfig;
+    reactQueryDevtoolConfig?:
+        | React.ComponentProps<typeof ReactQueryDevtools>
+        | false;
+};
+
+type HandleRefineOptionsReturnValues = {
+    optionsWithDefaults: IRefineContextOptions;
+    disableTelemetryWithDefault: boolean;
+    reactQueryWithDefaults: {
+        clientConfig: QueryClientConfig | InstanceType<typeof QueryClient>;
+        devtoolConfig: false | React.ComponentProps<typeof ReactQueryDevtools>;
+    };
+};
+
+export const handleRefineOptions = ({
+    options,
+    disableTelemetry,
+    liveMode,
+    mutationMode,
+    reactQueryClientConfig,
+    reactQueryDevtoolConfig,
+    syncWithLocation,
+    undoableTimeout,
+    warnWhenUnsavedChanges,
+}: HandleRefineOptionsProps = {}): HandleRefineOptionsReturnValues => {
+    const optionsWithDefaults: IRefineContextOptions = {
+        breadcrumb: options?.breadcrumb,
+        mutationMode:
+            options?.mutationMode ??
+            mutationMode ??
+            defaultRefineOptions.mutationMode,
+        undoableTimeout:
+            options?.undoableTimeout ??
+            undoableTimeout ??
+            defaultRefineOptions.undoableTimeout,
+        syncWithLocation:
+            options?.syncWithLocation ??
+            syncWithLocation ??
+            defaultRefineOptions.syncWithLocation,
+        warnWhenUnsavedChanges:
+            options?.warnWhenUnsavedChanges ??
+            warnWhenUnsavedChanges ??
+            defaultRefineOptions.warnWhenUnsavedChanges,
+        liveMode:
+            options?.liveMode ?? liveMode ?? defaultRefineOptions.liveMode,
+        redirect: {
+            afterCreate:
+                options?.redirect?.afterCreate ??
+                defaultRefineOptions.redirect.afterCreate,
+            afterClone:
+                options?.redirect?.afterClone ??
+                defaultRefineOptions.redirect.afterClone,
+            afterEdit:
+                options?.redirect?.afterEdit ??
+                defaultRefineOptions.redirect.afterEdit,
+        },
+    };
+
+    const disableTelemetryWithDefault =
+        options?.disableTelemetry ?? disableTelemetry ?? false;
+
+    const reactQueryWithDefaults = {
+        clientConfig:
+            options?.reactQuery?.clientConfig ?? reactQueryClientConfig ?? {},
+        devtoolConfig:
+            options?.reactQuery?.devtoolConfig ?? reactQueryDevtoolConfig ?? {},
+    };
+
+    return {
+        optionsWithDefaults,
+        disableTelemetryWithDefault,
+        reactQueryWithDefaults,
+    };
+};

package/src/definitions/helpers/handleUseParams/index.tsx

@@ -0,0 +1,9 @@
+export const handleUseParams = (params: any = {}): any => {
+    if (params?.id) {
+        return {
+            ...params,
+            id: decodeURIComponent(params.id),
+        };
+    }
+    return params;
+};

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

@@ -0,0 +1,9 @@
+export const hasPermission = (
+    permissions: string[] | undefined,
+    action: string | undefined,
+): boolean => {
+    if (!permissions || !action) {
+        return false;
+    }
+    return !!permissions.find((i) => i === action);
+};

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

@@ -0,0 +1,14 @@
+export const humanizeString = (text: string): string => {
+    text = text.replace(/([a-z]{1})([A-Z]{1})/g, "$1-$2");
+    text = text.replace(/([A-Z]{1})([A-Z]{1})([a-z]{1})/g, "$1-$2$3");
+
+    text = text
+        .toLowerCase()
+        .replace(/[_-]+/g, " ")
+        .replace(/\s{2,}/g, " ")
+        .trim();
+    text = text.charAt(0).toUpperCase() + text.slice(1);
+
+    return text;
+};
+// https://www.npmjs.com/package/humanize-string

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

@@ -0,0 +1,15 @@
+import zip from "lodash/zip";
+import fromPairs from "lodash/fromPairs";
+import { MapDataFn } from "../../../interfaces";
+
+export const importCSVMapper = <TItem = any, TVariables = any>(
+    data: any[][],
+    mapData: MapDataFn<TItem, TVariables> = (item) => item as any,
+): TVariables[] => {
+    const [headers, ...body] = data;
+    return body
+        .map((entry) => fromPairs(zip(headers, entry)))
+        .map((item: any, index, array: any) =>
+            mapData.call(undefined, item, index, array),
+        );
+};

package/src/definitions/helpers/index.ts

@@ -0,0 +1,25 @@
+export { userFriendlySecond } from "./userFriendlySeconds";
+export { importCSVMapper } from "./importCSVMapper";
+export { userFriendlyResourceName } from "./userFriendlyResourceName";
+export { handleUseParams } from "./handleUseParams";
+export { queryKeys } from "./queryKeys";
+export { hasPermission } from "./hasPermission";
+export { routeGenerator } from "./routeGenerator";
+export { createTreeView } from "./treeView/createTreeView";
+export { humanizeString } from "./humanizeString";
+export { handleRefineOptions } from "./handleRefineOptions";
+export { redirectPage } from "./redirectPage";
+export { sequentialPromises } from "./sequentialPromises";
+export { pickDataProvider } from "./pickDataProvider";
+export { handleMultiple } from "./handleMultiple";
+export {
+    getNextPageParam,
+    getPreviousPageParam,
+} from "./useInfinitePagination";
+export { pickNotDeprecated } from "./pickNotDeprecated";
+export { legacyResourceTransform } from "./legacy-resource-transform";
+export { matchResourceFromRoute } from "./router/match-resource-from-route";
+export { getActionRoutesFromResource } from "./router";
+export { composeRoute } from "./router/compose-route";
+export { useActiveAuthProvider } from "./useActiveAuthProvider";
+export { handlePaginationParams } from "./handlePaginationParams";

package/src/definitions/helpers/legacy-resource-transform/index.ts

@@ -0,0 +1,30 @@
+import {
+    IResourceItem,
+    ResourceProps,
+} from "../../../interfaces/bindings/resource";
+
+import { routeGenerator } from "../routeGenerator";
+
+/**
+ * For the legacy definition of resources, we did a basic transformation for provided resources
+ * - This is meant to provide an easier way to access properties.
+ * - In the new definition, we don't need to do transformations and properties can be accessed via helpers or manually.
+ * This is kept for backward compability
+ */
+export const legacyResourceTransform = (resources: ResourceProps[]) => {
+    const _resources: IResourceItem[] = [];
+
+    resources?.forEach((resource) => {
+        _resources.push({
+            ...resource,
+            label: resource.options?.label,
+            route: routeGenerator(resource, resources),
+            canCreate: !!resource.create,
+            canEdit: !!resource.edit,
+            canShow: !!resource.show,
+            canDelete: resource.canDelete,
+        });
+    });
+
+    return _resources;
+};

package/src/definitions/helpers/menu/create-resource-key.ts

@@ -0,0 +1,33 @@
+import { IResourceItem } from "../../../interfaces";
+import {
+    getParentResource,
+    removeLeadingTrailingSlashes,
+} from "../../helpers/router";
+
+export const createResourceKey = (
+    resource: IResourceItem,
+    resources: IResourceItem[],
+    legacy = false,
+) => {
+    const parents: IResourceItem[] = [];
+
+    let currentParentResource = getParentResource(resource, resources);
+    while (currentParentResource) {
+        parents.push(currentParentResource);
+        currentParentResource = getParentResource(
+            currentParentResource,
+            resources,
+        );
+    }
+    parents.reverse();
+
+    const key = [...parents, resource]
+        .map((r) =>
+            removeLeadingTrailingSlashes(
+                (legacy ? r.route : undefined) ?? r.identifier ?? r.name,
+            ),
+        )
+        .join("/");
+
+    return `/${key.replace(/^\//, "")}`;
+};

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

@@ -0,0 +1,87 @@
+import { IResourceItem } from "@contexts/resource";
+import { getParentResource } from "../router";
+import { createResourceKey } from "./create-resource-key";
+
+export type Tree = {
+    item: IResourceItem;
+    children: { [key: string]: Tree };
+};
+
+export type FlatTreeItem = IResourceItem & {
+    key: string;
+    children: FlatTreeItem[];
+};
+
+export const createTree = (
+    resources: IResourceItem[],
+    legacy = false,
+): FlatTreeItem[] => {
+    const root: Tree = {
+        item: {
+            name: "__root__",
+        },
+        children: {},
+    };
+
+    resources.forEach((resource) => {
+        const parents: IResourceItem[] = [];
+
+        let currentParent = getParentResource(resource, resources);
+        while (currentParent) {
+            parents.push(currentParent);
+            currentParent = getParentResource(currentParent, resources);
+        }
+        parents.reverse();
+
+        let currentTree = root;
+
+        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];
+        });
+
+        const key =
+            (legacy ? resource.route : undefined) ??
+            resource.identifier ??
+            resource.name;
+
+        if (!currentTree.children[key]) {
+            currentTree.children[key] = {
+                item: resource,
+                children: {},
+            };
+        }
+    });
+
+    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);
+        });
+
+        return items;
+    };
+
+    return flatten(root);
+};

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

@@ -0,0 +1,40 @@
+import { IResourceItem } from "src/interfaces/bindings/resource";
+import { removeLeadingTrailingSlashes } from "../router/remove-leading-trailing-slashes";
+
+/**
+ * Picks the resource based on the provided identifier.
+ * Identifier fallbacks to `name` if `identifier` is not explicitly provided to the resource.
+ * 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,
+): IResourceItem | undefined => {
+    if (!identifier) {
+        return undefined;
+    }
+
+    if (legacy) {
+        const resourceByRoute = resources.find(
+            (r) =>
+                removeLeadingTrailingSlashes(r.route ?? "") ===
+                removeLeadingTrailingSlashes(identifier),
+        );
+
+        const resource = resourceByRoute
+            ? resourceByRoute
+            : resources.find((r) => r.name === identifier);
+
+        return resource;
+    }
+
+    const resource = resources.find(
+        (r) => (r.identifier ?? r.name) === identifier,
+    );
+
+    return resource;
+};

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

@@ -0,0 +1,29 @@
+import { IResourceItem } from "src/interfaces/bindings/resource";
+import { pickResource } from "../pick-resource";
+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[],
+) => {
+    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);
+
+    const meta = pickNotDeprecated(resource?.meta, resource?.options);
+
+    if (meta?.dataProviderName) {
+        return meta.dataProviderName;
+    }
+
+    return "default";
+};

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

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

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

@@ -0,0 +1,47 @@
+import { IQueryKeys } from "src/interfaces";
+import { QueryKey } from "@tanstack/react-query";
+
+import { MetaQuery } from "src/interfaces";
+import { pickNotDeprecated } from "../pickNotDeprecated";
+
+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 && 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;
+};

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

@@ -0,0 +1,28 @@
+import { Action, IRefineContextOptions, RedirectAction } from "src/interfaces";
+
+type RedirectPageProps = {
+    redirectFromProps?: RedirectAction;
+    action: Action;
+    redirectOptions: IRefineContextOptions["redirect"];
+};
+
+export const redirectPage = ({
+    redirectFromProps,
+    action,
+    redirectOptions,
+}: RedirectPageProps): RedirectAction => {
+    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;
+    }
+};

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

@@ -0,0 +1,29 @@
+import { ResourceProps } from "src/interfaces/bindings/resource";
+import { getParentPrefixForResource } from "../router";
+import { pickNotDeprecated } from "../pickNotDeprecated";
+
+/**
+ * generates route for the resource based on parents and custom routes
+ * @deprecated this is a **legacy** function and works only with the old resource definition
+ */
+export const routeGenerator = (
+    item: ResourceProps,
+    resourcesFromProps: ResourceProps[],
+): string | undefined => {
+    let route;
+
+    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;
+    }
+
+    return `/${route.replace(/^\//, "")}`;
+};

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

@@ -0,0 +1,24 @@
+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");
+
+        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/");
+
+        expect(result).toEqual(false);
+    });
+
+    it("should return false if segments are not equal", () => {
+        const result = checkBySegments(
+            "/users/edit/123",
+            "/users/edit/:id/step",
+        );
+
+        expect(result).toEqual(false);
+    });
+});

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

@@ -0,0 +1,42 @@
+import { composeRoute } from "../compose-route";
+
+describe("composeRoute", () => {
+    it("should compose single slash", () => {
+        const result = composeRoute("/");
+
+        expect(result).toEqual("/");
+    });
+
+    it("should return the route as same if no params are found", () => {
+        const result = composeRoute("/users", { id: 1 });
+
+        expect(result).toEqual("/users");
+    });
+
+    it("should return the route with params replaced", () => {
+        const result = composeRoute("/users/:id", { id: 1 });
+
+        expect(result).toEqual("/users/1");
+    });
+
+    it("should return the route with multiple params replaced", () => {
+        const result = composeRoute("/users/:id/:name", {
+            id: 1,
+            params: {
+                name: "John",
+            },
+        });
+
+        expect(result).toEqual("/users/1/John");
+    });
+
+    it("should return the route with multiple params by prioritizing meta params", () => {
+        const result = composeRoute(
+            "/users/:id/:name",
+            { params: { id: 1, name: "John" } },
+            { name: "Doe" },
+        );
+
+        expect(result).toEqual("/users/1/Doe");
+    });
+});