@refinedev/core 4.48.0 → 4.49.0

package/src/contexts/accessControl/types.ts

@@ -0,0 +1,93 @@
+/**
+ * @author aliemir
+ *
+ * `AccessControlProvider` interface, used to define the access control bindings of refine.
+ *
+ * Currently, there's no change in the interface, but only in the `params.resource` property.
+ *
+ * This also had `{ children?: ITreeMenu[] }` type extension but we can remove it now.
+ *
+ * There's an error behind this extension, since we're using `Tanstack Query` to check the `can` function,
+ * params are stringified and Nodes can't be stringified properly, which throws an error.
+ *
+ * These kinds of errors should be handled by the user of the `can` function, not by the `can` function itself.
+ *
+ * In this case, its the `CanAccess` component, which wraps the `can` function and is used in the `Sider` components.
+ * `Sider` should sanitize the `params.resource` property and remove the `children` property (if exists).
+ *
+ * This may also apply to `resource.icon` property.
+ *
+ */
+import { UseQueryOptions } from "@tanstack/react-query";
+
+import { BaseKey } from "../data/types";
+import { IResourceItem, ITreeMenu } from "../resource/types";
+
+export type CanResponse = {
+  can: boolean;
+  reason?: string;
+  [key: string]: unknown;
+};
+
+export type CanParams = {
+  /**
+   * Resource name for API data interactions
+   */
+  resource?: string;
+  /**
+   * Intended action on resource
+   */
+  action: string;
+  /**
+   * Parameters associated with the resource
+   * @type {
+   *   resource?: [IResourceItem](https://refine.dev/docs/api-reference/core/interfaceReferences/#canparams),
+   *   id?: [BaseKey](https://refine.dev/docs/api-reference/core/interfaceReferences/#basekey), [key: string]: any
+   * }
+   */
+  params?: {
+    resource?: IResourceItem & { children?: ITreeMenu[] };
+    id?: BaseKey;
+    [key: string]: any;
+  };
+};
+
+export type CanReturnType = {
+  can: boolean;
+  reason?: string;
+};
+
+export type CanFunction = ({
+  resource,
+  action,
+  params,
+}: CanParams) => Promise<CanReturnType>;
+
+type AccessControlOptions = {
+  buttons?: {
+    enableAccessControl?: boolean;
+    hideIfUnauthorized?: boolean;
+  };
+  queryOptions?: UseQueryOptions<CanReturnType>;
+};
+
+export interface IAccessControlContext {
+  can?: CanFunction;
+  options?: AccessControlOptions;
+}
+
+export type IAccessControlContextReturnType = {
+  can?: CanFunction;
+  options: {
+    buttons: {
+      enableAccessControl: boolean;
+      hideIfUnauthorized: boolean;
+    };
+    queryOptions?: UseQueryOptions<CanReturnType>;
+  };
+};
+
+export type AccessControlProvider = {
+  can: CanFunction;
+  options?: AccessControlOptions;
+};

package/src/contexts/auditLog/index.tsx

@@ -1,13 +1,11 @@
-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 }}>

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,9 +13,7 @@ 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();
 
@@ -77,12 +76,12 @@ export const LegacyAuthContextProvider: React.FC<
   );
 };
 
-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 {
@@ -171,14 +170,12 @@ export const AuthBindingsContextProvider: React.FC<
     <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"],
+        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,
       }}
     >

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,34 +1,39 @@
-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;
-  } else {
-    dataProviders = {
-      default: 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 {
+      providerValue = dataProvider;
+    }
   }
+
   return (
-    <DataContext.Provider value={dataProviders}>
+    <DataContext.Provider value={providerValue}>
       {children}
     </DataContext.Provider>
   );