@refinedev/core 4.0.0

package/src/contexts/auth/index.tsx

@@ -0,0 +1,203 @@
+import React, { PropsWithChildren } from "react";
+
+import { useNavigation } from "@hooks";
+import { ILegacyAuthContext, IAuthBindingsContext } from "../../interfaces";
+
+/**
+ * @deprecated `LegacyAuthContext` is deprecated with refine@4, use `AuthBindingsContext` instead, however, we still support `LegacyAuthContext` for backward compatibility.
+ */
+export const LegacyAuthContext = React.createContext<ILegacyAuthContext>({});
+
+/**
+ * @deprecated `LegacyAuthContextProvider` is deprecated with refine@4, use `AuthBindingsContextProvider` instead, however, we still support `LegacyAuthContextProvider` for backward compatibility.
+ */
+export const LegacyAuthContextProvider: React.FC<
+    ILegacyAuthContext & {
+        children?: React.ReactNode;
+    }
+> = ({ children, isProvided, ...authOperations }) => {
+    const { replace } = useNavigation();
+
+    const loginFunc = async (params: any) => {
+        try {
+            const result = await authOperations.login?.(params);
+
+            return result;
+        } catch (error) {
+            return Promise.reject(error);
+        }
+    };
+
+    const registerFunc = async (params: any) => {
+        try {
+            const result = await authOperations.register?.(params);
+
+            return result;
+        } catch (error) {
+            return Promise.reject(error);
+        }
+    };
+
+    const logoutFunc = async (params: any) => {
+        try {
+            const redirectPath = await authOperations.logout?.(params);
+
+            return redirectPath;
+        } catch (error) {
+            return Promise.reject(error);
+        }
+    };
+
+    const checkAuthFunc = async (params: any) => {
+        try {
+            await authOperations.checkAuth?.(params);
+            return Promise.resolve();
+        } catch (error) {
+            if ((error as { redirectPath?: string })?.redirectPath) {
+                replace((error as { redirectPath: string }).redirectPath);
+            }
+
+            return Promise.reject(error);
+        }
+    };
+
+    return (
+        <LegacyAuthContext.Provider
+            value={{
+                ...authOperations,
+                login: loginFunc,
+                logout: logoutFunc,
+                checkAuth: checkAuthFunc,
+                register: registerFunc,
+                isProvided,
+            }}
+        >
+            {children}
+        </LegacyAuthContext.Provider>
+    );
+};
+
+export const AuthBindingsContext = React.createContext<
+    Partial<IAuthBindingsContext>
+>({});
+
+export const AuthBindingsContextProvider: React.FC<
+    PropsWithChildren<IAuthBindingsContext>
+> = ({ children, isProvided, ...authBindings }) => {
+    const handleLogin = async (params: unknown) => {
+        try {
+            const result = await authBindings.login?.(params);
+
+            return result;
+        } catch (error) {
+            console.warn(
+                "Unhandled Error in login: refine always expects a resolved promise.",
+                error,
+            );
+            return Promise.reject(error);
+        }
+    };
+
+    const handleRegister = async (params: unknown) => {
+        try {
+            const result = await authBindings.register?.(params);
+
+            return result;
+        } catch (error) {
+            console.warn(
+                "Unhandled Error in register: refine always expects a resolved promise.",
+                error,
+            );
+            return Promise.reject(error);
+        }
+    };
+
+    const handleLogout = async (params: unknown) => {
+        try {
+            const result = await authBindings.logout?.(params);
+
+            return result;
+        } catch (error) {
+            console.warn(
+                "Unhandled Error in logout: refine always expects a resolved promise.",
+                error,
+            );
+            return Promise.reject(error);
+        }
+    };
+
+    const handleCheck = async (params: unknown) => {
+        try {
+            const result = await authBindings.check?.(params);
+
+            return Promise.resolve(result);
+        } catch (error) {
+            console.warn(
+                "Unhandled Error in check: refine always expects a resolved promise.",
+                error,
+            );
+            return Promise.reject(error);
+        }
+    };
+
+    const handleForgotPassword = async (params: unknown) => {
+        try {
+            const result = await authBindings.forgotPassword?.(params);
+
+            return Promise.resolve(result);
+        } catch (error) {
+            console.warn(
+                "Unhandled Error in forgotPassword: refine always expects a resolved promise.",
+                error,
+            );
+            return Promise.reject(error);
+        }
+    };
+
+    const handleUpdatePassword = async (params: unknown) => {
+        try {
+            const result = await authBindings.updatePassword?.(params);
+            return Promise.resolve(result);
+        } catch (error) {
+            console.warn(
+                "Unhandled Error in updatePassword: refine always expects a resolved promise.",
+                error,
+            );
+            return Promise.reject(error);
+        }
+    };
+
+    return (
+        <AuthBindingsContext.Provider
+            value={{
+                ...authBindings,
+                login: handleLogin as IAuthBindingsContext["login"],
+                logout: handleLogout as IAuthBindingsContext["logout"],
+                check: handleCheck as IAuthBindingsContext["check"],
+                register: handleRegister as IAuthBindingsContext["register"],
+                forgotPassword:
+                    handleForgotPassword as IAuthBindingsContext["forgotPassword"],
+                updatePassword:
+                    handleUpdatePassword as IAuthBindingsContext["updatePassword"],
+                isProvided,
+            }}
+        >
+            {children}
+        </AuthBindingsContext.Provider>
+    );
+};
+
+/**
+ * @deprecated `useLegacyAuthContext` is deprecated with refine@4, use `useAuthBindingsContext` instead, however, we still support `useLegacyAuthContext` for backward compatibility.
+ */
+export const useLegacyAuthContext = () => {
+    const context = React.useContext(LegacyAuthContext);
+
+    return context;
+};
+
+export const useAuthBindingsContext = () => {
+    const context = React.useContext(AuthBindingsContext);
+
+    return context;
+};

package/src/contexts/data/IDataContext.ts

@@ -0,0 +1,285 @@
+import { BaseRecord, BaseKey, MetaQuery } from "../../interfaces";
+
+export interface Pagination {
+    /**
+     * Initial page index
+     * @default 1
+     */
+    current?: number;
+    /**
+     * Initial number of items per page
+     * @default 10
+     */
+    pageSize?: number;
+    /**
+     * Whether to use server side pagination or not.
+     * @default "server"
+     */
+    mode?: "client" | "server" | "off";
+}
+
+// Filters are used as a suffix of a field name:
+
+// | Filter              | Description                       |
+// | ------------------- | --------------------------------- |
+// | `eq`                | Equal                             |
+// | ne                  | Not equal                         |
+// | lt                  | Less than                         |
+// | gt                  | Greater than                      |
+// | lte                 | Less than or equal to             |
+// | gte                 | Greater than or equal to          |
+// | in                  | Included in an array              |
+// | nin                 | Not included in an array          |
+// | contains            | Contains                          |
+// | ncontains           | Doesn't contain                   |
+// | containss           | Contains, case sensitive          |
+// | ncontainss          | Doesn't contain, case sensitive   |
+// | null                | Is null or not null               |
+// | startswith          | Starts with                       |
+// | nstartswith         | Doesn't start with                |
+// | startswiths         | Starts with, case sensitive       |
+// | nstartswiths        | Doesn't start with, case sensitive|
+// | endswith            | Ends with                         |
+// | nendswith           | Doesn't end with                  |
+// | endswiths           | Ends with, case sensitive         |
+// | nendswiths          | Doesn't end with, case sensitive  |
+export type CrudOperators =
+    | "eq"
+    | "ne"
+    | "lt"
+    | "gt"
+    | "lte"
+    | "gte"
+    | "in"
+    | "nin"
+    | "contains"
+    | "ncontains"
+    | "containss"
+    | "ncontainss"
+    | "between"
+    | "nbetween"
+    | "null"
+    | "nnull"
+    | "startswith"
+    | "nstartswith"
+    | "startswiths"
+    | "nstartswiths"
+    | "endswith"
+    | "nendswith"
+    | "endswiths"
+    | "nendswiths"
+    | "or"
+    | "and";
+
+export type SortOrder = "desc" | "asc" | null;
+
+export type LogicalFilter = {
+    field: string;
+    operator: Exclude<CrudOperators, "or" | "and">;
+    value: any;
+};
+
+export type ConditionalFilter = {
+    key?: string;
+    operator: Extract<CrudOperators, "or" | "and">;
+    value: (LogicalFilter | ConditionalFilter)[];
+};
+
+export type CrudFilter = LogicalFilter | ConditionalFilter;
+export type CrudSort = {
+    field: string;
+    order: "asc" | "desc";
+};
+
+export type CrudFilters = CrudFilter[];
+export type CrudSorting = CrudSort[];
+
+export interface CustomResponse<TData = BaseRecord> {
+    data: TData;
+}
+export interface GetListResponse<TData = BaseRecord> {
+    data: TData[];
+    total: number;
+    [key: string]: any;
+}
+
+export interface CreateResponse<TData = BaseRecord> {
+    data: TData;
+}
+
+export interface CreateManyResponse<TData = BaseRecord> {
+    data: TData[];
+}
+
+export interface UpdateResponse<TData = BaseRecord> {
+    data: TData;
+}
+
+export interface UpdateManyResponse<TData = BaseRecord> {
+    data: TData[];
+}
+
+export interface GetOneResponse<TData = BaseRecord> {
+    data: TData;
+}
+
+export interface GetManyResponse<TData = BaseRecord> {
+    data: TData[];
+}
+
+export interface DeleteOneResponse<TData = BaseRecord> {
+    data: TData;
+}
+
+export interface DeleteManyResponse<TData = BaseRecord> {
+    data: TData[];
+}
+
+export interface IDataContextProvider {
+    getList: <TData extends BaseRecord = BaseRecord>(params: {
+        resource: string;
+        pagination?: Pagination;
+        /**
+         * @deprecated `hasPagination` is deprecated, use `pagination.mode` instead.
+         */
+        hasPagination?: boolean;
+        /**
+         * @deprecated `sort` is deprecated, use `sorters` instead.
+         */
+        sort?: CrudSorting;
+        sorters?: CrudSorting;
+        filters?: CrudFilters;
+        meta?: MetaQuery;
+        /**
+         * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+         */
+        metaData?: MetaQuery;
+        dataProviderName?: string;
+    }) => Promise<GetListResponse<TData>>;
+    getMany?: <TData extends BaseRecord = BaseRecord>(params: {
+        resource: string;
+        ids: BaseKey[];
+        meta?: MetaQuery;
+        /**
+         * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+         */
+        metaData?: MetaQuery;
+        dataProviderName?: string;
+    }) => Promise<GetManyResponse<TData>>;
+    getOne: <TData extends BaseRecord = BaseRecord>(params: {
+        resource: string;
+        id: BaseKey;
+        meta?: MetaQuery;
+        /**
+         * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+         */
+        metaData?: MetaQuery;
+    }) => Promise<GetOneResponse<TData>>;
+    create: <TData extends BaseRecord = BaseRecord, TVariables = {}>(params: {
+        resource: string;
+        variables: TVariables;
+        meta?: MetaQuery;
+        /**
+         * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+         */
+        metaData?: MetaQuery;
+    }) => Promise<CreateResponse<TData>>;
+    createMany?: <
+        TData extends BaseRecord = BaseRecord,
+        TVariables = {},
+    >(params: {
+        resource: string;
+        variables: TVariables[];
+        meta?: MetaQuery;
+        /**
+         * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+         */
+        metaData?: MetaQuery;
+    }) => Promise<CreateManyResponse<TData>>;
+    update: <TData extends BaseRecord = BaseRecord, TVariables = {}>(params: {
+        resource: string;
+        id: BaseKey;
+        variables: TVariables;
+        meta?: MetaQuery;
+        /**
+         * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+         */
+        metaData?: MetaQuery;
+    }) => Promise<UpdateResponse<TData>>;
+    updateMany?: <
+        TData extends BaseRecord = BaseRecord,
+        TVariables = {},
+    >(params: {
+        resource: string;
+        ids: BaseKey[];
+        variables: TVariables;
+        meta?: MetaQuery;
+        /**
+         * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+         */
+        metaData?: MetaQuery;
+    }) => Promise<UpdateManyResponse<TData>>;
+    deleteOne: <
+        TData extends BaseRecord = BaseRecord,
+        TVariables = {},
+    >(params: {
+        resource: string;
+        id: BaseKey;
+        variables?: TVariables;
+        meta?: MetaQuery;
+        /**
+         * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+         */
+        metaData?: MetaQuery;
+    }) => Promise<DeleteOneResponse<TData>>;
+    deleteMany?: <
+        TData extends BaseRecord = BaseRecord,
+        TVariables = {},
+    >(params: {
+        resource: string;
+        ids: BaseKey[];
+        variables?: TVariables;
+        meta?: MetaQuery;
+        /**
+         * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+         */
+        metaData?: MetaQuery;
+    }) => Promise<DeleteManyResponse<TData>>;
+    getApiUrl: () => string;
+    custom?: <
+        TData extends BaseRecord = BaseRecord,
+        TQuery = unknown,
+        TPayload = unknown,
+    >(params: {
+        url: string;
+        method:
+            | "get"
+            | "delete"
+            | "head"
+            | "options"
+            | "post"
+            | "put"
+            | "patch";
+        /**
+         * @deprecated `sort` is deprecated, use `sorters` instead.
+         */
+        sort?: CrudSorting;
+        sorters?: CrudSorting;
+        filters?: CrudFilter[];
+        payload?: TPayload;
+        query?: TQuery;
+        headers?: {};
+        meta?: MetaQuery;
+        /**
+         * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+         */
+        metaData?: MetaQuery;
+    }) => Promise<CustomResponse<TData>>;
+}
+
+export type IDataContext = IDataContextProvider;
+
+export interface IDataMultipleContextProvider {
+    default: IDataContextProvider;
+    [key: string]: IDataContextProvider | any;
+}

package/src/contexts/data/index.tsx

@@ -0,0 +1,50 @@
+import React from "react";
+import { ReactNode } from "react";
+
+import {
+    IDataContextProvider,
+    IDataMultipleContextProvider,
+} from "../../interfaces";
+
+export const defaultDataProvider = () => {
+    return {
+        default: {
+            create: () => Promise.resolve({ data: { id: 1 } }),
+            createMany: () => Promise.resolve({ data: [] }),
+            deleteOne: () => Promise.resolve({ data: { id: 1 } }),
+            deleteMany: () => Promise.resolve({ data: [] }),
+            getList: () => Promise.resolve({ data: [], total: 0 }),
+            getMany: () => Promise.resolve({ data: [] }),
+            getOne: () => Promise.resolve({ data: { id: 1 } }),
+            update: () => Promise.resolve({ data: { id: 1 } }),
+            updateMany: () => Promise.resolve({ data: [] }),
+            custom: () => Promise.resolve({ data: {} }),
+            getApiUrl: () => "",
+        },
+    };
+};
+
+export const DataContext = React.createContext<IDataMultipleContextProvider>(
+    defaultDataProvider() as IDataMultipleContextProvider,
+);
+
+export const DataContextProvider: React.FC<
+    | IDataMultipleContextProvider
+    | (IDataContextProvider & {
+          children: ReactNode;
+      })
+> = ({ children, ...rest }) => {
+    let dataProviders;
+    if (!rest.getList || !rest.getOne) {
+        dataProviders = rest as IDataMultipleContextProvider;
+    } else {
+        dataProviders = {
+            default: rest,
+        } as IDataMultipleContextProvider;
+    }
+    return (
+        <DataContext.Provider value={dataProviders}>
+            {children}
+        </DataContext.Provider>
+    );
+};

package/src/contexts/legacy-router/IRouterContext.ts

@@ -0,0 +1,37 @@
+import React from "react";
+
+export interface IRouterProvider {
+    useHistory: () => {
+        push: (...args: any) => any;
+        replace: (...args: any) => any;
+        goBack: (...args: any) => any;
+    };
+    useLocation: () => {
+        search: string;
+        pathname: string;
+    };
+    useParams: <
+        Params extends { [K in keyof Params]?: string } = {},
+    >() => Params;
+    Prompt: React.FC<PromptProps>;
+    Link: React.FC<any>;
+    RouterComponent?: React.FC<any>;
+    routes?: any;
+}
+
+export interface IRouterContext {
+    useHistory: () => any;
+    useLocation: () => any;
+    useParams: <
+        Params extends { [K in keyof Params]?: string } = {},
+    >() => Params;
+    Prompt: React.FC<PromptProps>;
+    Link: React.FC<any>;
+    routes?: any;
+}
+
+export type PromptProps = {
+    message: string;
+    when?: boolean;
+    setWarnWhen?: (warnWhen: boolean) => void;
+};

package/src/contexts/legacy-router/index.tsx

@@ -0,0 +1,45 @@
+import React from "react";
+
+import { IRouterContext } from "../../interfaces";
+
+export const defaultProvider: IRouterContext = {
+    useHistory: () => false,
+    useLocation: () => false,
+    useParams: () => ({} as any),
+    Prompt: () => null,
+    Link: () => null,
+};
+
+export const LegacyRouterContext =
+    React.createContext<IRouterContext>(defaultProvider);
+
+export const RouterContext = LegacyRouterContext;
+
+export const LegacyRouterContextProvider: React.FC<
+    Partial<IRouterContext> & {
+        children?: React.ReactNode;
+    }
+> = ({
+    children,
+    useHistory,
+    useLocation,
+    useParams,
+    Prompt,
+    Link,
+    routes,
+}) => {
+    return (
+        <RouterContext.Provider
+            value={{
+                useHistory: useHistory ?? defaultProvider.useHistory,
+                useLocation: useLocation ?? defaultProvider.useLocation,
+                useParams: useParams ?? defaultProvider.useParams,
+                Prompt: Prompt ?? defaultProvider.Prompt,
+                Link: Link ?? defaultProvider.Link,
+                routes: routes ?? defaultProvider.routes,
+            }}
+        >
+            {children}
+        </RouterContext.Provider>
+    );
+};

package/src/contexts/live/ILiveContext.ts

@@ -0,0 +1,48 @@
+import {
+    BaseKey,
+    CrudFilters,
+    CrudSorting,
+    LiveEvent,
+    MetaQuery,
+    Pagination,
+} from "../../interfaces";
+
+export type ILiveContext =
+    | {
+          publish?: (event: LiveEvent) => void;
+          subscribe: (options: {
+              channel: string;
+              params?: {
+                  ids?: BaseKey[];
+                  id?: BaseKey;
+                  meta?: MetaQuery;
+                  /**
+                   * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+                   */
+                  metaData?: MetaQuery;
+                  pagination?: Pagination;
+                  /**
+                   * @deprecated `hasPagination` is deprecated, use `pagination.mode` instead.
+                   */
+                  hasPagination?: boolean;
+                  /**
+                   * @deprecated `sort` is deprecated, use `sorters` instead.
+                   */
+                  sort?: CrudSorting;
+                  sorters?: CrudSorting;
+                  filters?: CrudFilters;
+                  subscriptionType?: "useList" | "useOne" | "useMany";
+                  resource?: string;
+                  [key: string]: any;
+              };
+              types: LiveEvent["type"][];
+              callback: (event: LiveEvent) => void;
+          }) => any;
+          unsubscribe: (subscription: any) => void;
+      }
+    | undefined;
+
+export type ILiveContextProvider = {
+    liveProvider: ILiveContext;
+    children: React.ReactNode;
+};

package/src/contexts/live/index.tsx

@@ -0,0 +1,16 @@
+import React from "react";
+
+import { ILiveContext, ILiveContextProvider } from "./ILiveContext";
+
+export const LiveContext = React.createContext<ILiveContext>(undefined);
+
+export const LiveContextProvider: React.FC<ILiveContextProvider> = ({
+    liveProvider,
+    children,
+}) => {
+    return (
+        <LiveContext.Provider value={liveProvider}>
+            {children}
+        </LiveContext.Provider>
+    );
+};

package/src/contexts/notification/INotificationContext.ts

@@ -0,0 +1,15 @@
+export interface OpenNotificationParams {
+    key?: string;
+    message: string;
+    type: "success" | "error" | "progress";
+    description?: string;
+    cancelMutation?: () => void;
+    undoableTimeout?: number;
+}
+
+export interface INotificationContext {
+    open?: (params: OpenNotificationParams) => void;
+    close?: (key: string) => void;
+}
+
+export type NotificationProvider = Required<INotificationContext>;