@refinedev/core 4.47.2 → 4.49.0

package/src/contexts/auditLog/index.tsx

@@ -1,17 +1,15 @@
-import React from "react";
+import React, { PropsWithChildren } from "react";
 
-import { IAuditLogContext } from "./IAuditLogContext";
+import { IAuditLogContext } from "./types";
 
 export const AuditLogContext = React.createContext<IAuditLogContext>({});
 
 export const AuditLogContextProvider: React.FC<
-    IAuditLogContext & {
-        children: React.ReactNode;
-    }
+  PropsWithChildren<IAuditLogContext>
 > = ({ create, get, update, children }) => {
-    return (
-        <AuditLogContext.Provider value={{ create, get, update }}>
-            {children}
-        </AuditLogContext.Provider>
-    );
+  return (
+    <AuditLogContext.Provider value={{ create, get, update }}>
+      {children}
+    </AuditLogContext.Provider>
+  );
 };

package/src/contexts/auditLog/types.ts

@@ -0,0 +1,45 @@
+import { BaseKey, MetaDataQuery } from "../data/types";
+
+export type ILog<TData = any> = {
+  id: BaseKey;
+  createdAt: string;
+  author?: Record<number | string, any>;
+  name?: string;
+  data: TData;
+  previousData: TData;
+  resource: string;
+  action: string;
+  meta?: Record<number | string, any>;
+};
+
+export type ILogData<TData = any> = ILog<TData>[];
+
+export type LogParams = {
+  resource: string;
+  action: string;
+  data?: any;
+  author?: {
+    name?: string;
+    [key: string]: any;
+  };
+  previousData?: any;
+  meta: Record<number | string, any>;
+};
+
+export type IAuditLogContext = {
+  create?: (params: LogParams) => Promise<any>;
+  get?: (params: {
+    resource: string;
+    action?: string;
+    meta?: Record<number | string, any>;
+    author?: Record<number | string, any>;
+    metaData?: MetaDataQuery;
+  }) => Promise<any>;
+  update?: (params: {
+    id: BaseKey;
+    name: string;
+    [key: string]: any;
+  }) => Promise<any>;
+};
+
+export type AuditLogProvider = Required<IAuditLogContext>;

package/src/contexts/auth/index.tsx

@@ -1,7 +1,8 @@
 import React, { PropsWithChildren } from "react";
 
 import { useNavigation } from "@hooks";
-import { ILegacyAuthContext, IAuthBindingsContext } from "../../interfaces";
+
+import { IAuthContext, ILegacyAuthContext } from "./types";
 
 /**
  * @deprecated `LegacyAuthContext` is deprecated with refine@4, use `AuthBindingsContext` instead, however, we still support `LegacyAuthContext` for backward compatibility.
@@ -12,192 +13,188 @@ 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;
-    }
+  PropsWithChildren<ILegacyAuthContext>
 > = ({ 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>
-    );
+  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 AuthBindingsContext = React.createContext<Partial<IAuthContext>>(
+  {},
+);
 
 export const AuthBindingsContextProvider: React.FC<
-    PropsWithChildren<IAuthBindingsContext>
+  PropsWithChildren<IAuthContext>
 > = ({ 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>
-    );
+  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 IAuthContext["login"],
+        logout: handleLogout as IAuthContext["logout"],
+        check: handleCheck as IAuthContext["check"],
+        register: handleRegister as IAuthContext["register"],
+        forgotPassword: handleForgotPassword as IAuthContext["forgotPassword"],
+        updatePassword: handleUpdatePassword as IAuthContext["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);
+  const context = React.useContext(LegacyAuthContext);
 
-    return context;
+  return context;
 };
 
 export const useAuthBindingsContext = () => {
-    const context = React.useContext(AuthBindingsContext);
+  const context = React.useContext(AuthBindingsContext);
 
-    return context;
+  return context;
 };

package/src/contexts/auth/types.ts

@@ -0,0 +1,115 @@
+/**
+ * @author aliemir
+ *
+ * In the current internal structure, sometimes we pass params and args from one function to another,
+ * like in case of `check` (formerly `checkAuth`) function, we pass the reject value to `useLogout` hook,
+ * which handles the redirect after logout.
+ *
+ * These actions should be separated,
+ *
+ * Apps can exist with an optional auth,
+ * or do not redirect after logout,
+ * or do the redirect but not log out,
+ * or do the redirect to a different page than `/login`.
+ *
+ * To cover all those cases, we should return more information from auth functions.
+ *
+ * Let's say, they should always resolve, even if user is not authenticated,
+ * but have the proper information to handle the situation.
+ *
+ * like `authenticated: false`, `redirect: '/login'` and `logout: true`
+ * which will inform refine that user is not authenticated and should be redirected to `/login` and logout.
+ * In some cases, redirect might need to be transferred to other hooks (like `useLogout` hook),
+ * but these cases can be handled internally.
+ *
+ * If the response from `check` is `{ authenticated: false, logout: false, redirect: "/not-authenticated" }`,
+ * then the user will be redirected to `/not-authenticated` without logging out.
+ *
+ * If the response from `check` is `{ authenticated: false, logout: true, redirect: false }`,
+ * then the user will be logged out without redirecting.
+ *
+ * Same goes for `onError` function, it should always resolve.
+ */
+
+import { RefineError } from "../data/types";
+
+export type CheckResponse = {
+  authenticated: boolean;
+  redirectTo?: string;
+  logout?: boolean;
+  error?: RefineError | Error;
+};
+
+export type OnErrorResponse = {
+  redirectTo?: string;
+  logout?: boolean;
+  error?: RefineError | Error;
+};
+
+export type SuccessNotificationResponse = {
+  message: string;
+  description?: string;
+};
+
+export type AuthActionResponse = {
+  success: boolean;
+  redirectTo?: string;
+  error?: RefineError | Error;
+  [key: string]: unknown;
+  successNotification?: SuccessNotificationResponse;
+};
+
+export type PermissionResponse = unknown;
+
+export type IdentityResponse = unknown;
+
+export type AuthProvider = {
+  login: (params: any) => Promise<AuthActionResponse>;
+  logout: (params: any) => Promise<AuthActionResponse>;
+  check: (params?: any) => Promise<CheckResponse>;
+  onError: (error: any) => Promise<OnErrorResponse>;
+  register?: (params: any) => Promise<AuthActionResponse>;
+  forgotPassword?: (params: any) => Promise<AuthActionResponse>;
+  updatePassword?: (params: any) => Promise<AuthActionResponse>;
+  getPermissions?: (
+    params?: Record<string, any>,
+  ) => Promise<PermissionResponse>;
+  getIdentity?: (params?: any) => Promise<IdentityResponse>;
+};
+
+/**
+ * @deprecated use `AuthProvider` instead.
+ */
+export type AuthBindings = AuthProvider;
+
+export interface IAuthContext extends Partial<AuthProvider> {
+  isProvided: boolean;
+}
+
+export type TLogoutData = void | false | string;
+export type TLoginData = void | false | string | object;
+export type TRegisterData = void | false | string;
+export type TForgotPasswordData = void | false | string;
+export type TUpdatePasswordData = void | false | string;
+
+/**
+ * @deprecated `LegacyAuthProvider` is deprecated with refine@4, use `AuthProvider` instead, however, we still support `LegacyAuthProvider` for backward compatibility.
+ */
+export interface LegacyAuthProvider {
+  login: (params: any) => Promise<TLoginData>;
+  register?: (params: any) => Promise<TRegisterData>;
+  forgotPassword?: (params: any) => Promise<TForgotPasswordData>;
+  updatePassword?: (params: any) => Promise<TUpdatePasswordData>;
+  logout: (params: any) => Promise<TLogoutData>;
+  checkAuth: (params?: any) => Promise<any>;
+  checkError: (error: any) => Promise<void>;
+  getPermissions?: (params?: Record<string, any>) => Promise<any>;
+  getUserIdentity?: (params?: any) => Promise<any>;
+}
+
+/**
+ * @deprecated `ILegacyAuthContext` is deprecated with refine@4, use `IAuthContext` instead, however, we still support `ILegacyAuthContext` for backward compatibility.
+ */
+export interface ILegacyAuthContext extends Partial<LegacyAuthProvider> {
+  isProvided?: boolean;
+}

package/src/contexts/data/index.tsx

@@ -1,35 +1,40 @@
-import React from "react";
-import { ReactNode } from "react";
+import React, { PropsWithChildren } from "react";
 
-import {
-    IDataContextProvider,
-    IDataMultipleContextProvider,
-} from "../../interfaces";
+import { DataProvider, DataProviders, IDataContext } from "./types";
 
-export const defaultDataProvider = () => {
-    return {};
+export const defaultDataProvider: DataProviders = {
+  default: {} as DataProvider,
 };
 
-export const DataContext = React.createContext<
-    Partial<IDataMultipleContextProvider>
->(defaultDataProvider());
+export const DataContext =
+  React.createContext<IDataContext>(defaultDataProvider);
 
-type Props = React.PropsWithChildren<
-    Partial<IDataMultipleContextProvider> | IDataContextProvider
->;
+type Props = PropsWithChildren<{
+  dataProvider?: DataProvider | DataProviders;
+}>;
 
-export const DataContextProvider: React.FC<Props> = ({ children, ...rest }) => {
-    let dataProviders;
-    if (!rest.getList || !rest.getOne) {
-        dataProviders = rest as IDataMultipleContextProvider;
+export const DataContextProvider: React.FC<Props> = ({
+  children,
+  dataProvider,
+}) => {
+  let providerValue = defaultDataProvider;
+
+  if (dataProvider) {
+    if (
+      !("default" in dataProvider) &&
+      ("getList" in dataProvider || "getOne" in dataProvider)
+    ) {
+      providerValue = {
+        default: dataProvider,
+      };
     } else {
-        dataProviders = {
-            default: rest,
-        } as IDataMultipleContextProvider;
+      providerValue = dataProvider;
     }
-    return (
-        <DataContext.Provider value={dataProviders}>
-            {children}
-        </DataContext.Provider>
-    );
+  }
+
+  return (
+    <DataContext.Provider value={providerValue}>
+      {children}
+    </DataContext.Provider>
+  );
 };