@refinedev/core 4.0.0

package/src/definitions/table/index.ts

@@ -0,0 +1,192 @@
+import qs, { IStringifyOptions } from "qs";
+import unionWith from "lodash/unionWith";
+import differenceWith from "lodash/differenceWith";
+import warnOnce from "warn-once";
+
+import {
+    CrudFilters,
+    CrudSorting,
+    CrudFilter,
+    CrudSort,
+    CrudOperators,
+    SortOrder,
+} from "../../interfaces";
+import { pickNotDeprecated } from "@definitions/helpers";
+
+export const parseTableParams = (url: string) => {
+    const { current, pageSize, sorter, sorters, filters } = qs.parse(
+        url.substring(1), // remove first ? character
+    );
+
+    return {
+        parsedCurrent: current && Number(current),
+        parsedPageSize: pageSize && Number(pageSize),
+        parsedSorter: (pickNotDeprecated(sorters, sorter) as CrudSorting) ?? [],
+        parsedFilters: (filters as CrudFilters) ?? [],
+    };
+};
+
+export const parseTableParamsFromQuery = (params: any) => {
+    const url = qs.stringify(params);
+    return parseTableParams(`/${url}`);
+};
+
+/**
+ * @internal This function is used to stringify table params from the useTable hook.
+ */
+export const stringifyTableParams = (params: {
+    pagination?: { current?: number; pageSize?: number };
+    sorters: CrudSorting;
+    filters: CrudFilters;
+    [key: string]: any;
+}): string => {
+    const options: IStringifyOptions = {
+        skipNulls: true,
+        arrayFormat: "indices",
+        encode: false,
+    };
+    const { pagination, sorter, sorters, filters, ...rest } = params;
+
+    const queryString = qs.stringify(
+        {
+            ...rest,
+            ...(pagination ? pagination : {}),
+            sorters: pickNotDeprecated(sorters, sorter),
+            filters,
+        },
+        options,
+    );
+
+    return queryString;
+};
+
+export const compareFilters = (
+    left: CrudFilter,
+    right: CrudFilter,
+): boolean => {
+    if (
+        left.operator !== "and" &&
+        left.operator !== "or" &&
+        right.operator !== "and" &&
+        right.operator !== "or"
+    ) {
+        return (
+            ("field" in left ? left.field : undefined) ==
+                ("field" in right ? right.field : undefined) &&
+            left.operator == right.operator
+        );
+    }
+
+    return (
+        ("key" in left ? left.key : undefined) ==
+            ("key" in right ? right.key : undefined) &&
+        left.operator == right.operator
+    );
+};
+
+export const compareSorters = (left: CrudSort, right: CrudSort): boolean =>
+    left.field == right.field;
+// Keep only one CrudFilter per type according to compareFilters
+// Items in the array that is passed first to unionWith have higher priority
+// CrudFilter items with undefined values are necessary to signify no filter
+// After union, don't keep CrudFilter items with undefined value in the result
+// Items in the arrays with higher priority are put at the end.
+export const unionFilters = (
+    permanentFilter: CrudFilters,
+    newFilters: CrudFilters,
+    prevFilters: CrudFilters = [],
+): CrudFilters => {
+    const isKeyRequired = newFilters.filter(
+        (f) => (f.operator === "or" || f.operator === "and") && !f.key,
+    );
+
+    if (isKeyRequired.length > 1) {
+        warnOnce(
+            true,
+            `[conditionalFilters]: You have created multiple Conditional Filters at the top level, this requires the key parameter. \nFor more information, see https://refine.dev/docs/advanced-tutorials/data-provider/handling-filters/#top-level-multiple-conditional-filters-usage`,
+        );
+    }
+
+    return unionWith(
+        permanentFilter,
+        newFilters,
+        prevFilters,
+        compareFilters,
+    ).filter(
+        (crudFilter) =>
+            crudFilter.value !== undefined &&
+            crudFilter.value !== null &&
+            (crudFilter.operator !== "or" ||
+                (crudFilter.operator === "or" &&
+                    crudFilter.value.length !== 0)) &&
+            (crudFilter.operator !== "and" ||
+                (crudFilter.operator === "and" &&
+                    crudFilter.value.length !== 0)),
+    );
+};
+
+export const unionSorters = (
+    permanentSorter: CrudSorting,
+    newSorters: CrudSorting,
+): CrudSorting =>
+    unionWith(permanentSorter, newSorters, compareSorters).filter(
+        (crudSorter) =>
+            crudSorter.order !== undefined && crudSorter.order !== null,
+    );
+// Prioritize filters in the permanentFilter and put it at the end of result array
+export const setInitialFilters = (
+    permanentFilter: CrudFilters,
+    defaultFilter: CrudFilters,
+): CrudFilters => [
+    ...differenceWith(defaultFilter, permanentFilter, compareFilters),
+    ...permanentFilter,
+];
+
+export const setInitialSorters = (
+    permanentSorter: CrudSorting,
+    defaultSorter: CrudSorting,
+): CrudSorting => [
+    ...differenceWith(defaultSorter, permanentSorter, compareSorters),
+    ...permanentSorter,
+];
+
+export const getDefaultSortOrder = (
+    columnName: string,
+    sorter?: CrudSorting,
+): SortOrder | undefined => {
+    if (!sorter) {
+        return undefined;
+    }
+
+    const sortItem = sorter.find((item) => item.field === columnName);
+
+    if (sortItem) {
+        return sortItem.order as SortOrder;
+    }
+
+    return undefined;
+};
+
+export const getDefaultFilter = (
+    columnName: string,
+    filters?: CrudFilters,
+    operatorType: CrudOperators = "eq",
+): CrudFilter["value"] | undefined => {
+    const filter = filters?.find((filter) => {
+        if (
+            filter.operator !== "or" &&
+            filter.operator !== "and" &&
+            "field" in filter
+        ) {
+            const { operator, field } = filter;
+            return field === columnName && operator === operatorType;
+        }
+        return undefined;
+    });
+
+    if (filter) {
+        return filter.value || [];
+    }
+
+    return undefined;
+};

package/src/definitions/upload/file2Base64/index.ts

@@ -0,0 +1,21 @@
+export const file2Base64 = (file: any): Promise<string> => {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+
+        const resultHandler = () => {
+            if (reader.result) {
+                reader.removeEventListener("load", resultHandler, false);
+
+                resolve(reader.result as string);
+            }
+        };
+
+        reader.addEventListener("load", resultHandler, false);
+
+        reader.readAsDataURL(file.originFileObj as Blob);
+        reader.onerror = (error) => {
+            reader.removeEventListener("load", resultHandler, false);
+            return reject(error);
+        };
+    });
+};

package/src/definitions/upload/index.ts

@@ -0,0 +1 @@
+export * from "./file2Base64";

package/src/hooks/accessControl/index.ts

@@ -0,0 +1,2 @@
+export * from "./useCan";
+export * from "./useCanWithoutCache";

package/src/hooks/accessControl/useCan/index.ts

@@ -0,0 +1,69 @@
+import { useContext } from "react";
+import {
+    useQuery,
+    UseQueryResult,
+    UseQueryOptions,
+} from "@tanstack/react-query";
+
+import { AccessControlContext } from "@contexts/accessControl";
+import { CanParams, CanReturnType } from "../../../interfaces";
+import { sanitizeResource } from "@definitions/helpers/sanitize-resource";
+
+export type UseCanProps = CanParams & {
+    /**
+     * react-query's [useQuery](https://tanstack.com/query/v4/docs/reference/useQuery) options
+     */
+    queryOptions?: UseQueryOptions<CanReturnType>;
+};
+
+/**
+ * `useCan` uses the `can` as the query function for `react-query`'s {@link https://react-query.tanstack.com/guides/queries `useQuery`}. It takes the parameters that `can` takes. It can also be configured with `queryOptions` for `useQuery`. Returns the result of `useQuery`.
+ * @see {@link https://refine.dev/docs/core/hooks/accessControl/useCan} for more details.
+ *
+ * @typeParam CanParams {@link https://refine.dev/docs/core/interfaceReferences#canparams}
+ * @typeParam CanReturnType {@link https://refine.dev/docs/core/interfaceReferences#canreturntype}
+ *
+ */
+export const useCan = ({
+    action,
+    resource,
+    params,
+    queryOptions,
+}: UseCanProps): UseQueryResult<CanReturnType> => {
+    const { can } = useContext(AccessControlContext);
+
+    /**
+     * Since `react-query` stringifies the query keys, it will throw an error for a circular dependency if we include `React.ReactNode` elements inside the keys.
+     * The feature in #2220(https://github.com/refinedev/refine/issues/2220) includes such change and to fix this, we need to remove `icon` property in the `resource`
+     */
+    const { resource: _resource, ...paramsRest } = params ?? {};
+
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    const sanitizedResource = sanitizeResource(_resource ?? {});
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+
+    const queryResponse = useQuery<CanReturnType>(
+        [
+            "useCan",
+            {
+                action,
+                resource,
+                params: { ...paramsRest, resource: sanitizedResource },
+                enabled: queryOptions?.enabled,
+            },
+        ],
+        // Enabled check for `can` is enough to be sure that it's defined in the query function but TS is not smart enough to know that.
+        () =>
+            can?.({ action, resource, params }) ??
+            Promise.resolve({ can: true }),
+        {
+            enabled: typeof can !== "undefined",
+            ...queryOptions,
+            retry: false,
+        },
+    );
+
+    return typeof can === "undefined"
+        ? ({ data: { can: true } } as typeof queryResponse)
+        : queryResponse;
+};

package/src/hooks/accessControl/useCanWithoutCache.ts

@@ -0,0 +1,10 @@
+import { useContext } from "react";
+
+import { AccessControlContext } from "@contexts/accessControl";
+import { IAccessControlContext } from "../../interfaces";
+
+export const useCanWithoutCache = (): IAccessControlContext => {
+    const { can } = useContext(AccessControlContext);
+
+    return { can };
+};

package/src/hooks/auditLog/index.ts

@@ -0,0 +1,2 @@
+export * from "./useLog";
+export * from "./useLogList";

package/src/hooks/auditLog/useLog/index.ts

@@ -0,0 +1,139 @@
+import { useContext } from "react";
+import {
+    useMutation,
+    UseMutationOptions,
+    UseMutationResult,
+    useQueryClient,
+} from "@tanstack/react-query";
+
+import { AuditLogContext } from "@contexts/auditLog";
+import { ResourceContext } from "@contexts/resource";
+import { useGetIdentity } from "@hooks/auth";
+import { BaseKey, LogParams } from "../../../interfaces";
+import {
+    hasPermission,
+    pickNotDeprecated,
+    queryKeys,
+} from "@definitions/helpers";
+import { pickResource } from "@definitions/helpers/pick-resource";
+import { useActiveAuthProvider } from "@definitions/helpers";
+
+type LogRenameData =
+    | {
+          resource?: string;
+      }
+    | undefined;
+
+export type UseLogReturnType<TLogData, TLogRenameData> = {
+    log: UseMutationResult<TLogData, Error, LogParams>;
+    rename: UseMutationResult<
+        TLogRenameData,
+        Error,
+        {
+            id: BaseKey;
+            name: string;
+        }
+    >;
+};
+
+export type UseLogMutationProps<
+    TLogData,
+    TLogRenameData extends LogRenameData = LogRenameData,
+> = {
+    logMutationOptions?: Omit<
+        UseMutationOptions<TLogData, Error, LogParams, unknown>,
+        "mutationFn"
+    >;
+    renameMutationOptions?: Omit<
+        UseMutationOptions<
+            TLogRenameData,
+            Error,
+            { id: BaseKey; name: string },
+            unknown
+        >,
+        "mutationFn" | "onSuccess"
+    >;
+};
+
+/**
+ * useLog is used to `create` a new and `rename` the existing audit log.
+ * @see {@link https://refine.dev/docs/core/hooks/audit-log/useLog} for more details.
+ */
+
+export const useLog = <
+    TLogData,
+    TLogRenameData extends LogRenameData = LogRenameData,
+>({
+    logMutationOptions,
+    renameMutationOptions,
+}: UseLogMutationProps<TLogData, TLogRenameData> = {}): UseLogReturnType<
+    TLogData,
+    TLogRenameData
+> => {
+    const queryClient = useQueryClient();
+    const auditLogContext = useContext(AuditLogContext);
+
+    const authProvider = useActiveAuthProvider();
+
+    const { resources } = useContext(ResourceContext);
+    const {
+        data: identityData,
+        refetch,
+        isLoading,
+    } = useGetIdentity({
+        v3LegacyAuthProviderCompatible: Boolean(authProvider?.isLegacy),
+        queryOptions: {
+            enabled: !!auditLogContext,
+        },
+    });
+
+    const log = useMutation<TLogData, Error, LogParams, unknown>(
+        async (params) => {
+            const resource = pickResource(params.resource, resources);
+            const logPermissions = pickNotDeprecated(
+                resource?.meta?.audit,
+                resource?.options?.audit,
+                resource?.options?.auditLog?.permissions,
+            );
+
+            if (logPermissions) {
+                if (!hasPermission(logPermissions, params.action)) {
+                    return;
+                }
+            }
+
+            let authorData;
+            if (isLoading) {
+                authorData = await refetch();
+            }
+
+            return await auditLogContext.create?.({
+                ...params,
+                author: identityData ?? authorData?.data,
+            });
+        },
+        logMutationOptions,
+    );
+
+    const rename = useMutation<
+        TLogRenameData,
+        Error,
+        { id: BaseKey; name: string },
+        unknown
+    >(
+        async (params) => {
+            return await auditLogContext.update?.(params);
+        },
+        {
+            onSuccess: (data) => {
+                if (data?.resource) {
+                    const queryKey = queryKeys(data?.resource);
+                    queryClient.invalidateQueries(queryKey.logList());
+                }
+            },
+            ...renameMutationOptions,
+        },
+    );
+
+    return { log, rename };
+};

package/src/hooks/auditLog/useLogList/index.ts

@@ -0,0 +1,55 @@
+import { useContext } from "react";
+import {
+    useQuery,
+    UseQueryResult,
+    UseQueryOptions,
+} from "@tanstack/react-query";
+
+import { AuditLogContext } from "@contexts/auditLog";
+import { queryKeys } from "@definitions/helpers";
+import { HttpError, MetaDataQuery } from "../../../interfaces";
+
+export type UseLogProps<TData, TError> = {
+    resource: string;
+    action?: string;
+    meta?: Record<number | string, any>;
+    author?: Record<number | string, any>;
+    queryOptions?: UseQueryOptions<TData, TError>;
+    metaData?: MetaDataQuery;
+};
+
+/**
+ * useLogList is used to get and filter audit logs.
+ * @see {@link https://refine.dev/docs/core/hooks/audit-log/useLogList} for more details.
+ */
+export const useLogList = <TData = any, TError extends HttpError = HttpError>({
+    resource,
+    action,
+    meta,
+    author,
+    metaData,
+    queryOptions,
+}: UseLogProps<TData, TError>): UseQueryResult<TData> => {
+    const { get } = useContext(AuditLogContext);
+
+    const queryKey = queryKeys(resource, undefined, metaData);
+
+    const queryResponse = useQuery<TData, TError>(
+        queryKey.logList(meta),
+        () =>
+            get?.({
+                resource,
+                action,
+                author,
+                meta,
+                metaData,
+            }) ?? Promise.resolve([]),
+        {
+            enabled: typeof get !== "undefined",
+            ...queryOptions,
+            retry: false,
+        },
+    );
+
+    return queryResponse;
+};

package/src/hooks/auth/index.ts

@@ -0,0 +1,10 @@
+export { usePermissions } from "./usePermissions";
+export { useGetIdentity } from "./useGetIdentity";
+export { useLogout } from "./useLogout";
+export { useLogin } from "./useLogin";
+export { useRegister } from "./useRegister";
+export { useForgotPassword } from "./useForgotPassword";
+export { useUpdatePassword } from "./useUpdatePassword";
+export { useAuthenticated, useIsAuthenticated } from "./useIsAuthenticated";
+export { useCheckError, useOnError } from "./useOnError";
+export { useIsExistAuthentication } from "./useIsExistAuthentication";

package/src/hooks/auth/useForgotPassword/index.ts

@@ -0,0 +1,174 @@
+import {
+    useMutation,
+    UseMutationOptions,
+    UseMutationResult,
+} from "@tanstack/react-query";
+
+import { useGo, useNavigation, useNotification, useRouterType } from "@hooks";
+import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
+
+import {
+    AuthActionResponse,
+    OpenNotificationParams,
+    TForgotPasswordData,
+} from "../../../interfaces";
+
+export type UseForgotPasswordLegacyProps<TVariables> = {
+    v3LegacyAuthProviderCompatible: true;
+    mutationOptions?: Omit<
+        UseMutationOptions<TForgotPasswordData, Error, TVariables, unknown>,
+        "mutationFn" | "onError" | "onSuccess"
+    >;
+};
+
+export type UseForgotPasswordProps<TVariables> = {
+    v3LegacyAuthProviderCompatible?: false;
+    mutationOptions?: Omit<
+        UseMutationOptions<AuthActionResponse, Error, TVariables, unknown>,
+        "mutationFn"
+    >;
+};
+
+export type UseForgotPasswordCombinedProps<TVariables> = {
+    v3LegacyAuthProviderCompatible: boolean;
+    mutationOptions?: Omit<
+        UseMutationOptions<
+            AuthActionResponse | TForgotPasswordData,
+            Error,
+            TVariables,
+            unknown
+        >,
+        "mutationFn"
+    >;
+};
+
+export type UseForgotPasswordLegacyReturnType<TVariables> = UseMutationResult<
+    TForgotPasswordData,
+    Error,
+    TVariables,
+    unknown
+>;
+
+export type UseForgotPasswordReturnType<TVariables> = UseMutationResult<
+    AuthActionResponse,
+    Error,
+    TVariables,
+    unknown
+>;
+
+export type UseForgotPasswordCombinedReturnType<TVariables> = UseMutationResult<
+    AuthActionResponse | TForgotPasswordData,
+    Error,
+    TVariables,
+    unknown
+>;
+
+export function useForgotPassword<TVariables = {}>(
+    props: UseForgotPasswordLegacyProps<TVariables>,
+): UseForgotPasswordLegacyReturnType<TVariables>;
+
+export function useForgotPassword<TVariables = {}>(
+    props?: UseForgotPasswordProps<TVariables>,
+): UseForgotPasswordReturnType<TVariables>;
+
+export function useForgotPassword<TVariables = {}>(
+    props?: UseForgotPasswordCombinedProps<TVariables>,
+): UseForgotPasswordCombinedReturnType<TVariables>;
+
+/**
+ * `useForgotPassword` calls `forgotPassword` method from {@link https://refine.dev/docs/api-references/providers/auth-provider `authProvider`} under the hood.
+ *
+ * @see {@link https://refine.dev/docs/core/hooks/auth/useForgotPassword} for more details.
+ *
+ * @typeParam TData - Result data of the query
+ * @typeParam TVariables - Values for mutation function. default `{}`
+ *
+ */
+export function useForgotPassword<TVariables = {}>({
+    v3LegacyAuthProviderCompatible,
+    mutationOptions,
+}:
+    | UseForgotPasswordProps<TVariables>
+    | UseForgotPasswordLegacyProps<TVariables> = {}):
+    | UseForgotPasswordReturnType<TVariables>
+    | UseForgotPasswordLegacyReturnType<TVariables> {
+    const routerType = useRouterType();
+    const go = useGo();
+    const { replace } = useNavigation();
+    const {
+        forgotPassword: v3LegacyAuthProviderCompatibleForgotPasswordFromContext,
+    } = useLegacyAuthContext();
+    const { forgotPassword: forgotPasswordFromContext } =
+        useAuthBindingsContext();
+    const { close, open } = useNotification();
+
+    const mutation = useMutation<
+        AuthActionResponse,
+        Error,
+        TVariables,
+        unknown
+    >(["useForgotPassword"], forgotPasswordFromContext, {
+        onSuccess: ({ success, redirectTo, error }) => {
+            if (success) {
+                close?.("forgot-password-error");
+            }
+
+            if (error || !success) {
+                open?.(buildNotification(error));
+            }
+
+            if (redirectTo) {
+                if (routerType === "legacy") {
+                    replace(redirectTo);
+                } else {
+                    go({ to: redirectTo, type: "replace" });
+                }
+            }
+        },
+        onError: (error: any) => {
+            open?.(buildNotification(error));
+        },
+        ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
+    });
+
+    const v3LegacyAuthProviderCompatibleMutation = useMutation<
+        TForgotPasswordData,
+        Error,
+        TVariables,
+        unknown
+    >(
+        ["useForgotPassword", "v3LegacyAuthProviderCompatible"],
+        v3LegacyAuthProviderCompatibleForgotPasswordFromContext,
+        {
+            onSuccess: (redirectPathFromAuth) => {
+                if (redirectPathFromAuth !== false) {
+                    if (redirectPathFromAuth) {
+                        if (routerType === "legacy") {
+                            replace(redirectPathFromAuth);
+                        } else {
+                            go({ to: redirectPathFromAuth, type: "replace" });
+                        }
+                    }
+                }
+                close?.("forgot-password-error");
+            },
+            onError: (error: any) => {
+                open?.(buildNotification(error));
+            },
+            ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
+        },
+    );
+
+    return v3LegacyAuthProviderCompatible
+        ? v3LegacyAuthProviderCompatibleMutation
+        : mutation;
+}
+
+const buildNotification = (error?: Error): OpenNotificationParams => {
+    return {
+        message: error?.name || "Forgot Password Error",
+        description: error?.message || "Error while resetting password",
+        key: "forgot-password-error",
+        type: "error",
+    };
+};