@refinedev/core 4.0.0

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

@@ -0,0 +1,71 @@
+import { Action, IResourceItem } from "src/interfaces";
+import { getDefaultActionPath } from "./get-default-action-path";
+import { getParentPrefixForResource } from "./get-parent-prefix-for-resource";
+
+export type ResourceActionRoute = {
+    action: Action;
+    resource: IResourceItem;
+    route: string;
+};
+
+/**
+ * This function returns all the routes for available actions for a resource.
+ * - If the action is a function, it means we're fallbacking to default path for the action
+ * - If the action is a string, it means we don't have the component, but we have the route
+ * - If the action is an object, it means we have the component and the route
+ * - 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,
+) => {
+    const actions: ResourceActionRoute[] = [];
+
+    const actionList: Action[] = ["list", "show", "edit", "create", "clone"];
+
+    const parentPrefix = getParentPrefixForResource(
+        resource,
+        resources,
+        legacy,
+    );
+
+    actionList.forEach((action) => {
+        const item =
+            legacy && action === "clone" ? resource.create : resource[action];
+
+        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 (route) {
+            actions.push({
+                action,
+                resource,
+                route: `/${route.replace(/^\//, "")}`,
+            });
+        }
+    });
+
+    return actions;
+};

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

@@ -0,0 +1,33 @@
+import { Action } from "src/interfaces";
+import { removeLeadingTrailingSlashes } from "./remove-leading-trailing-slashes";
+
+/**
+ * This helper function returns the default path for a given action and resource.
+ * It also applies the parentPrefix if provided.
+ * 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,
+): string => {
+    const cleanParentPrefix = removeLeadingTrailingSlashes(parentPrefix || "");
+
+    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`;
+    }
+
+    return `/${path.replace(/^\//, "")}`;
+};

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

@@ -0,0 +1,39 @@
+import { ResourceProps } from "src/interfaces/bindings/resource";
+import { getParentResource } from "./get-parent-resource";
+import { removeLeadingTrailingSlashes } from "./remove-leading-trailing-slashes";
+
+/**
+ * Returns the parent prefix for a resource
+ * - 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,
+): string | undefined => {
+    const parents: ResourceProps[] = [];
+
+    let parent = getParentResource(resource, resources);
+
+    while (parent) {
+        parents.push(parent);
+        parent = getParentResource(parent, resources);
+    }
+
+    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("/")}`;
+};

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

@@ -0,0 +1,31 @@
+import { IResourceItem } from "src/interfaces";
+import { pickNotDeprecated } from "../pickNotDeprecated";
+
+/**
+ * Returns the parent resource of the given resource.
+ * Works both with the deprecated `parentName` and the new `parent` property.
+ */
+export const getParentResource = (
+    resource: IResourceItem,
+    resources: IResourceItem[],
+): IResourceItem | undefined => {
+    const parentName = pickNotDeprecated(
+        resource.meta?.parent,
+        resource.options?.parent,
+        resource.parentName,
+    );
+
+    if (!parentName) {
+        return undefined;
+    }
+
+    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 };
+};

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

@@ -0,0 +1,10 @@
+export { checkBySegments } from "./check-by-segments";
+export { getActionRoutesFromResource } from "./get-action-routes-from-resource";
+export { getDefaultActionPath } from "./get-default-action-path";
+export { getParentPrefixForResource } from "./get-parent-prefix-for-resource";
+export { getParentResource } from "./get-parent-resource";
+export { isParameter } from "./is-parameter";
+export { isSegmentCountsSame } from "./is-segment-counts-same";
+export { removeLeadingTrailingSlashes } from "./remove-leading-trailing-slashes";
+
+export { matchResourceFromRoute } from "./match-resource-from-route";

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

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

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

@@ -0,0 +1,11 @@
+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);
+
+    return routeSegments.length === resourceRouteSegments.length;
+};

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

@@ -0,0 +1,37 @@
+import { Action, IResourceItem } from "../../../interfaces";
+import { checkBySegments } from "./check-by-segments";
+import { getActionRoutesFromResource } from "./get-action-routes-from-resource";
+import { pickMatchedRoute } from "./pick-matched-route";
+
+/**
+ * Match the resource from the route
+ * - It will calculate all possible routes for resources and their actions
+ * - It will check if the route matches any of the possible routes
+ * - It will return the most eligible resource and action
+ */
+export const matchResourceFromRoute = (
+    route: string,
+    resources: IResourceItem[],
+): {
+    found: boolean;
+    resource?: IResourceItem;
+    action?: Action;
+    matchedRoute?: string;
+} => {
+    const allActionRoutes = resources.flatMap((resource) => {
+        return getActionRoutesFromResource(resource, resources);
+    });
+
+    const allFound = allActionRoutes.filter((actionRoute) => {
+        return checkBySegments(route, actionRoute.route);
+    });
+
+    const mostEligible = pickMatchedRoute(allFound);
+
+    return {
+        found: !!mostEligible,
+        resource: mostEligible?.resource,
+        action: mostEligible?.action,
+        matchedRoute: mostEligible?.route,
+    };
+};

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

@@ -0,0 +1,61 @@
+import { ResourceActionRoute } from "./get-action-routes-from-resource";
+import { isParameter } from "./is-parameter";
+import { removeLeadingTrailingSlashes } from "./remove-leading-trailing-slashes";
+import { splitToSegments } from "./split-to-segments";
+
+/**
+ * Picks the most eligible route from the given matched routes.
+ * - If there's only one route, it returns it.
+ * - If there's more than one route, it picks the best non-greedy match.
+ */
+export const pickMatchedRoute = (
+    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;
+    }
+
+    // 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;
+        }
+        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;
+    }
+
+    return eligibleRoutes[0];
+};

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

@@ -0,0 +1,19 @@
+import { splitToSegments } from "./split-to-segments";
+import { removeLeadingTrailingSlashes } from "./remove-leading-trailing-slashes";
+import { isParameter } from "./is-parameter";
+
+/**
+ * Picks the route parameters from the given route.
+ * (e.g. /users/:id/posts/:postId => ['id', 'postId'])
+ */
+export const pickRouteParams = (route: string) => {
+    const segments = splitToSegments(removeLeadingTrailingSlashes(route));
+
+    return segments.flatMap((s) => {
+        if (isParameter(s)) {
+            return [s.slice(1)];
+        }
+
+        return [];
+    });
+};

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

@@ -0,0 +1,32 @@
+import { MetaDataQuery, ParseResponse } from "../../../interfaces";
+
+/**
+ * Prepares the route params by checking the existing params and meta data.
+ * Meta data is prioritized over params.
+ * Params are prioritized over predetermined id, action and resource.
+ * This means, we can use `meta` for user supplied params (both manually or from the query string)
+ */
+export const prepareRouteParams = <
+    TRouteParams extends Record<
+        string,
+        string | number | undefined | Symbol
+    > = Record<string, string | number | undefined | Symbol>,
+>(
+    routeParams: (keyof TRouteParams)[],
+    params: ParseResponse = {},
+    meta: MetaDataQuery = {},
+): Partial<TRouteParams> => {
+    // meta is prioritized over params
+    return routeParams.reduce((acc, key) => {
+        const value =
+            meta[key as string] ||
+            params.params?.[key as string] ||
+            (key === "id" ? params.id : undefined) ||
+            (key === "action" ? params.action : undefined) ||
+            (key === "resource" ? params.resource : undefined);
+        if (typeof value !== "undefined") {
+            acc[key] = value;
+        }
+        return acc;
+    }, {} as Partial<TRouteParams>);
+};

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

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

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

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

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

@@ -0,0 +1,31 @@
+import { IResourceItem } from "../../../interfaces/bindings/resource";
+
+/**
+ * Remove all properties that are non-serializable from a resource object.
+ */
+export const sanitizeResource = (
+    resource: Partial<IResourceItem> & { children?: unknown },
+): Partial<IResourceItem> => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const {
+        icon,
+        list,
+        edit,
+        create,
+        show,
+        clone,
+        children,
+        meta,
+        options,
+        ...restResource
+    } = resource;
+
+    const { icon: _metaIcon, ...restMeta } = meta ?? {};
+    const { icon: _optionsIcon, ...restOptions } = options ?? {};
+
+    return {
+        ...restResource,
+        ...(meta ? { meta: restMeta } : {}),
+        ...(options ? { options: restOptions } : {}),
+    };
+};

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

@@ -0,0 +1,32 @@
+type EachResolve<TResolve, Response> = (
+    result: TResolve,
+    index: number,
+) => Response;
+type EachReject<TReject, Response> = (
+    error: TReject,
+    index: number,
+) => Response;
+
+export const sequentialPromises = async <
+    TResolve = unknown,
+    TReject = unknown,
+    TResolveResponse = unknown,
+    TRejectResponse = unknown,
+>(
+    promises: (() => Promise<TResolve>)[],
+    onEachResolve: EachResolve<TResolve, TResolveResponse>,
+    onEachReject: EachReject<TReject, TRejectResponse>,
+): Promise<(TResolveResponse | TRejectResponse)[]> => {
+    const results = [];
+    // @ts-expect-error Remove this when we enable `downLevelIterations`
+    for (const [index, promise] of promises.entries()) {
+        try {
+            const result = await promise();
+
+            results.push(onEachResolve(result, index));
+        } catch (error) {
+            results.push(onEachReject(error as TReject, index));
+        }
+    }
+    return results;
+};

package/src/definitions/helpers/treeView/createTreeView/index.ts

@@ -0,0 +1,44 @@
+import { pickNotDeprecated } from "@definitions/helpers/pickNotDeprecated";
+import { IResourceItem, ITreeMenu, IMenuItem } from "src/interfaces";
+
+/**
+ * @deprecated This helper is deprecated. Please use `createTree` instead.
+ */
+export const createTreeView = (
+    resources: IResourceItem[] | IMenuItem[],
+): ITreeMenu[] | ITreeMenu[] => {
+    const tree = [];
+    const resourcesRouteObject: { [key: string]: any } = {};
+    const resourcesNameObject: { [key: string]: any } = {};
+    let parent: IResourceItem | IMenuItem;
+    let child: ITreeMenu;
+
+    for (let i = 0; i < resources.length; i++) {
+        parent = resources[i];
+
+        const route =
+            parent.route ??
+            pickNotDeprecated(parent?.meta, parent.options)?.route ??
+            "";
+
+        resourcesRouteObject[route] = parent;
+        resourcesRouteObject[route]["children"] = [];
+
+        resourcesNameObject[parent.name] = parent;
+        resourcesNameObject[parent.name]["children"] = [];
+    }
+
+    for (const name in resourcesRouteObject) {
+        if (resourcesRouteObject.hasOwnProperty(name)) {
+            child = resourcesRouteObject[name];
+
+            if (child.parentName && resourcesNameObject[child.parentName]) {
+                resourcesNameObject[child.parentName]["children"].push(child);
+            } else {
+                tree.push(child);
+            }
+        }
+    }
+
+    return tree;
+};

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

@@ -0,0 +1 @@
+export { createTreeView } from "./createTreeView";

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

@@ -0,0 +1,30 @@
+import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
+
+/**
+ * @returns authProvider or legacyAuthProvider if provided, otherwise null
+ * @internal
+ * NOTE: Will be removed in v5
+ */
+export const useActiveAuthProvider = () => {
+    const legacyAuthProvider = useLegacyAuthContext();
+    const authProvider = useAuthBindingsContext();
+
+    if (authProvider.isProvided) {
+        return { isLegacy: false, ...authProvider };
+    }
+
+    if (legacyAuthProvider.isProvided) {
+        // legacyAuthProvider interface is different from authProvider interface
+        // we need to convert it to authProvider interface for simple usage
+        // in the future, we will remove legacyAuthProvider
+        return {
+            isLegacy: true,
+            ...legacyAuthProvider,
+            check: legacyAuthProvider.checkAuth,
+            onError: legacyAuthProvider.checkError,
+            getIdentity: legacyAuthProvider.getUserIdentity,
+        };
+    }
+
+    return null;
+};

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

@@ -0,0 +1,30 @@
+import { GetListResponse } from "../../../interfaces";
+
+export const getNextPageParam = (lastPage: GetListResponse) => {
+    const { pagination, cursor } = lastPage;
+
+    // cursor pagination
+    if (cursor?.next) {
+        return cursor.next;
+    }
+
+    const current = pagination?.current || 1;
+
+    const pageSize = pagination?.pageSize || 10;
+    const totalPages = Math.ceil((lastPage.total || 0) / pageSize);
+
+    return current < totalPages ? Number(current) + 1 : undefined;
+};
+
+export const getPreviousPageParam = (lastPage: GetListResponse) => {
+    const { pagination, cursor } = lastPage;
+
+    // cursor pagination
+    if (cursor?.prev) {
+        return cursor.prev;
+    }
+
+    const current = pagination?.current || 1;
+
+    return current === 1 ? undefined : current - 1;
+};

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

@@ -0,0 +1,17 @@
+import pluralize from "pluralize";
+import { humanizeString } from "@definitions";
+
+/**
+ * A method that the internal uses
+ * @internal
+ */
+export const userFriendlyResourceName = (
+    resource = "",
+    type: "singular" | "plural",
+): string => {
+    const humanizeResource = humanizeString(resource);
+    if (type === "singular") {
+        return pluralize.singular(humanizeResource);
+    }
+    return pluralize.plural(humanizeResource);
+};

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

@@ -0,0 +1,3 @@
+export const userFriendlySecond = (miliseconds: number): number => {
+    return miliseconds / 1000; //convert to seconds
+};

package/src/definitions/index.ts

@@ -0,0 +1,3 @@
+export * from "./table";
+export * from "./helpers";
+export * from "./upload";

package/src/definitions/table/__snapshots__/index.spec.ts.snap

@@ -0,0 +1,7 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`definitions/table sorters should be prioritized over sorter 1`] = `"current=1&pageSize=10&sorters[0][field]=id&sorters[0][order]=desc"`;
+
+exports[`definitions/table stringify table params correctly 1`] = `"foo=bar&current=1&pageSize=10&sorters[0][field]=id&sorters[0][order]=desc&sorters[1][field]=title&sorters[1][order]=desc&filters[0][field]=categoryId&filters[0][operator]=in&filters[0][value][0]=1&filters[0][value][1]=2"`;
+
+exports[`definitions/table stringify table single sort params correctly 1`] = `"current=1&pageSize=10&sorters[0][field]=id&sorters[0][order]=desc&filters[0][field]=categoryId&filters[0][operator]=in&filters[0][value][0]=1&filters[0][value][1]=2"`;