@refinedev/core 4.53.0 → 4.54.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@refinedev/core",
-  "version": "4.53.0",
+  "version": "4.54.0",
   "private": false,
   "description": "refine is a React-based framework for building internal tools, rapidly. It ships with Ant Design System, an enterprise-level UI toolkit.",
   "repository": {
@@ -27,7 +27,7 @@
   "module": "dist/index.mjs",
   "typings": "dist/index.d.ts",
   "dependencies": {
-    "@refinedev/devtools-internal": "1.1.13",
+    "@refinedev/devtools-internal": "1.1.14",
     "@tanstack/react-query": "^4.10.1",
     "lodash": "^4.17.21",
     "lodash-es": "^4.17.21",

package/src/components/pages/auth/components/login/index.tsx

@@ -1,8 +1,13 @@
 import React, { useState } from "react";
 
 import { useActiveAuthProvider } from "@definitions/helpers";
-import { useLink, useLogin, useRouterContext, useRouterType } from "@hooks";
-import { useTranslate } from "@hooks/i18n";
+import {
+  useLink,
+  useLogin,
+  useRouterContext,
+  useRouterType,
+  useTranslate,
+} from "@hooks";
 
 import type { DivPropsType, FormPropsType } from "../..";
 import type { LoginFormTypes, LoginPageProps } from "../../types";

package/src/definitions/types/index.ts

@@ -0,0 +1,40 @@
+import type {
+  MutateOptions,
+  UseMutationResult as UseMutationResultBase,
+} from "@tanstack/react-query";
+
+export type MutateAsyncFunction<
+  TData = unknown,
+  TError = unknown,
+  TVariables = void,
+  TContext = unknown,
+> = (
+  variables?: TVariables,
+  options?: MutateOptions<TData, TError, TVariables, TContext>,
+) => Promise<TData>;
+
+export type MutateFunction<
+  TData = unknown,
+  TError = unknown,
+  TVariables = void,
+  TContext = unknown,
+> = (
+  ...args: Parameters<MutateAsyncFunction<TData, TError, TVariables, TContext>>
+) => void;
+
+/**
+ * we want to make the mutate and mutateAsync functions optional in the UseMutationResult
+ * because we want users to be able to provide the required parameters from the hook
+ */
+export type UseMutationResult<
+  TData = unknown,
+  TError = unknown,
+  TVariables = unknown,
+  TContext = unknown,
+> = Omit<
+  UseMutationResultBase<TData, TError, TVariables, TContext>,
+  "mutate" | "mutateAsync"
+> & {
+  mutate: MutateFunction<TData, TError, TVariables, TContext>;
+  mutateAsync: MutateAsyncFunction<TData, TError, TVariables, TContext>;
+};

package/src/hooks/data/useCreate.ts

@@ -6,7 +6,7 @@ import {
 import { getXRay } from "@refinedev/devtools-internal";
 import {
   type UseMutationOptions,
-  type UseMutationResult,
+  type MutateOptions,
   useMutation,
 } from "@tanstack/react-query";
 
@@ -31,6 +31,7 @@ import type {
   IQueryKeys,
   MetaQuery,
 } from "../../contexts/data/types";
+import type { UseMutationResult } from "../../definitions/types";
 import type { SuccessErrorNotification } from "../../contexts/notification/types";
 import {
   type UseLoadingOvertimeOptionsProps,
@@ -42,11 +43,11 @@ export type UseCreateParams<TData, TError, TVariables> = {
   /**
    * Resource name for API data interactions
    */
-  resource: string;
+  resource?: string;
   /**
    * Values for mutation function
    */
-  values: TVariables;
+  values?: TVariables;
   /**
    * Meta data for `dataProvider`
    */
@@ -89,9 +90,10 @@ export type UseCreateProps<
       UseCreateParams<TData, TError, TVariables>,
       unknown
     >,
-    "mutationFn" | "onError" | "onSuccess"
+    "mutationFn"
   >;
-} & UseLoadingOvertimeOptionsProps;
+} & UseLoadingOvertimeOptionsProps &
+  UseCreateParams<TData, TError, TVariables>;
 
 /**
  * `useCreate` is a modified version of `react-query`'s {@link https://react-query.tanstack.com/reference/useMutation `useMutation`} for create mutations.
@@ -111,6 +113,14 @@ export const useCreate = <
   TError extends HttpError = HttpError,
   TVariables = {},
 >({
+  resource: resourceFromProps,
+  values: valuesFromProps,
+  dataProviderName: dataProviderNameFromProps,
+  successNotification: successNotificationFromProps,
+  errorNotification: errorNotificationFromProps,
+  invalidates: invalidatesFromProps,
+  meta: metaFromProps,
+  metaData: metaDataFromProps,
   mutationOptions,
   overtimeOptions,
 }: UseCreateProps<TData, TError, TVariables> = {}): UseCreateReturnType<
@@ -136,19 +146,22 @@ export const useCreate = <
   } = useRefineContext();
   const { keys, preferLegacyKeys } = useKeys();
 
-  const mutation = useMutation<
+  const mutationResult = useMutation<
     CreateResponse<TData>,
     TError,
     UseCreateParams<TData, TError, TVariables>,
     unknown
   >({
     mutationFn: ({
-      resource: resourceName,
-      values,
-      meta,
-      metaData,
-      dataProviderName,
+      resource: resourceName = resourceFromProps,
+      values = valuesFromProps,
+      meta = metaFromProps,
+      metaData = metaDataFromProps,
+      dataProviderName = dataProviderNameFromProps,
     }: UseCreateParams<TData, TError, TVariables>) => {
+      if (!values) throw missingValuesError;
+      if (!resourceName) throw missingResourceError;
+
       const { resource, identifier } = select(resourceName);
 
       const combinedMeta = getMeta({
@@ -165,18 +178,20 @@ export const useCreate = <
         metaData: combinedMeta,
       });
     },
-    onSuccess: (
-      data,
-      {
-        resource: resourceName,
-        successNotification: successNotificationFromProp,
-        dataProviderName: dataProviderNameFromProp,
-        invalidates = ["list", "many"],
-        values,
-        meta,
-        metaData,
-      },
-    ) => {
+    onSuccess: (data, variables, context) => {
+      const {
+        resource: resourceName = resourceFromProps,
+        successNotification:
+          successNotificationFromProp = successNotificationFromProps,
+        dataProviderName: dataProviderNameFromProp = dataProviderNameFromProps,
+        invalidates = invalidatesFromProps ?? ["list", "many"],
+        values = valuesFromProps,
+        meta = metaFromProps,
+        metaData = metaDataFromProps,
+      } = variables;
+      if (!values) throw missingValuesError;
+      if (!resourceName) throw missingResourceError;
+
       const { resource, identifier } = select(resourceName);
       const resourceSingular = textTransformers.singular(identifier);
 
@@ -247,15 +262,19 @@ export const useCreate = <
           ...rest,
         },
       });
+
+      mutationOptions?.onSuccess?.(data, variables, context);
     },
-    onError: (
-      err: TError,
-      {
-        resource: resourceName,
-        errorNotification: errorNotificationFromProp,
-        values,
-      },
-    ) => {
+    onError: (err: TError, variables, context) => {
+      const {
+        resource: resourceName = resourceFromProps,
+        errorNotification:
+          errorNotificationFromProp = errorNotificationFromProps,
+        values = valuesFromProps,
+      } = variables;
+      if (!values) throw missingValuesError;
+      if (!resourceName) throw missingResourceError;
+
       checkError(err);
 
       const { identifier } = select(resourceName);
@@ -283,6 +302,8 @@ export const useCreate = <
         ),
         type: "error",
       });
+
+      mutationOptions?.onError?.(err, variables, context);
     },
     mutationKey: keys().data().mutation("create").get(preferLegacyKeys),
     ...mutationOptions,
@@ -291,6 +312,7 @@ export const useCreate = <
       ...getXRay("useCreate", preferLegacyKeys),
     },
   });
+  const { mutate, mutateAsync, ...mutation } = mutationResult;
 
   const { elapsedTime } = useLoadingOvertime({
     isLoading: mutation.isLoading,
@@ -298,5 +320,44 @@ export const useCreate = <
     onInterval: overtimeOptions?.onInterval,
   });
 
-  return { ...mutation, overtime: { elapsedTime } };
+  // this function is used to make the `variables` parameter optional
+  const handleMutation = (
+    variables?: UseCreateParams<TData, TError, TVariables>,
+    options?: MutateOptions<
+      CreateResponse<TData>,
+      TError,
+      UseCreateParams<TData, TError, TVariables>,
+      unknown
+    >,
+  ) => {
+    return mutate(variables || {}, options);
+  };
+
+  // this function is used to make the `variables` parameter optional
+  const handleMutateAsync = (
+    variables?: UseCreateParams<TData, TError, TVariables>,
+    options?: MutateOptions<
+      CreateResponse<TData>,
+      TError,
+      UseCreateParams<TData, TError, TVariables>,
+      unknown
+    >,
+  ) => {
+    return mutateAsync(variables || {}, options);
+  };
+
+  return {
+    ...mutation,
+    mutate: handleMutation,
+    mutateAsync: handleMutateAsync,
+    overtime: { elapsedTime },
+  };
 };
+
+const missingResourceError = new Error(
+  "[useCreate]: `resource` is not defined or not matched but is required",
+);
+
+const missingValuesError = new Error(
+  "[useCreate]: `values` is not provided but is required",
+);

package/src/hooks/data/useCreateMany.ts

@@ -1,7 +1,7 @@
 import { getXRay } from "@refinedev/devtools-internal";
 import {
   type UseMutationOptions,
-  type UseMutationResult,
+  type MutateOptions,
   useMutation,
 } from "@tanstack/react-query";
 
@@ -30,6 +30,7 @@ import type {
   IQueryKeys,
   MetaQuery,
 } from "../../contexts/data/types";
+import type { UseMutationResult } from "../../definitions/types";
 import type { SuccessErrorNotification } from "../../contexts/notification/types";
 import {
   type UseLoadingOvertimeOptionsProps,
@@ -37,9 +38,9 @@ import {
   useLoadingOvertime,
 } from "../useLoadingOvertime";
 
-type useCreateManyParams<TData, TError, TVariables> = {
-  resource: string;
-  values: TVariables[];
+export type UseCreateManyParams<TData, TError, TVariables> = {
+  resource?: string;
+  values?: TVariables[];
   meta?: MetaQuery;
   metaData?: MetaQuery;
   dataProviderName?: string;
@@ -53,7 +54,7 @@ export type UseCreateManyReturnType<
 > = UseMutationResult<
   CreateManyResponse<TData>,
   TError,
-  useCreateManyParams<TData, TError, TVariables>,
+  UseCreateManyParams<TData, TError, TVariables>,
   unknown
 >;
 
@@ -66,11 +67,12 @@ export type UseCreateManyProps<
     UseMutationOptions<
       CreateManyResponse<TData>,
       TError,
-      useCreateManyParams<TData, TError, TVariables>
+      UseCreateManyParams<TData, TError, TVariables>
     >,
-    "mutationFn" | "onError" | "onSuccess"
+    "mutationFn"
   >;
-} & UseLoadingOvertimeOptionsProps;
+} & UseLoadingOvertimeOptionsProps &
+  UseCreateManyParams<TData, TError, TVariables>;
 
 /**
  * `useCreateMany` is a modified version of `react-query`'s {@link https://react-query.tanstack.com/reference/useMutation `useMutation`} for multiple create mutations.
@@ -89,6 +91,14 @@ export const useCreateMany = <
   TError extends HttpError = HttpError,
   TVariables = {},
 >({
+  resource: resourceFromProps,
+  values: valuesFromProps,
+  dataProviderName: dataProviderNameFromProps,
+  successNotification: successNotificationFromProps,
+  errorNotification: errorNotificationFromProps,
+  meta: metaFromProps,
+  metaData: metaDataFromProps,
+  invalidates: invalidatesFromProps,
   mutationOptions,
   overtimeOptions,
 }: UseCreateManyProps<TData, TError, TVariables> = {}): UseCreateManyReturnType<
@@ -110,18 +120,21 @@ export const useCreateMany = <
   } = useRefineContext();
   const { keys, preferLegacyKeys } = useKeys();
 
-  const mutation = useMutation<
+  const mutationResult = useMutation<
     CreateManyResponse<TData>,
     TError,
-    useCreateManyParams<TData, TError, TVariables>
+    UseCreateManyParams<TData, TError, TVariables>
   >({
     mutationFn: ({
-      resource: resourceName,
-      values,
-      meta,
-      metaData,
-      dataProviderName,
-    }: useCreateManyParams<TData, TError, TVariables>) => {
+      resource: resourceName = resourceFromProps,
+      values = valuesFromProps,
+      meta = metaFromProps,
+      metaData = metaDataFromProps,
+      dataProviderName = dataProviderNameFromProps,
+    }: UseCreateManyParams<TData, TError, TVariables>) => {
+      if (!values) throw missingValuesError;
+      if (!resourceName) throw missingResourceError;
+
       const { resource, identifier } = select(resourceName);
 
       const combinedMeta = getMeta({
@@ -152,18 +165,19 @@ export const useCreateMany = <
         ),
       );
     },
-    onSuccess: (
-      response,
-      {
-        resource: resourceName,
-        successNotification,
-        dataProviderName: dataProviderNameFromProp,
-        invalidates = ["list", "many"],
-        values,
-        meta,
-        metaData,
-      },
-    ) => {
+    onSuccess: (response, variables, context) => {
+      const {
+        resource: resourceName = resourceFromProps,
+        successNotification = successNotificationFromProps,
+        dataProviderName: dataProviderNameFromProp = dataProviderNameFromProps,
+        invalidates = invalidatesFromProps ?? ["list", "many"],
+        values = valuesFromProps,
+        meta = metaFromProps,
+        metaData = metaDataFromProps,
+      } = variables;
+      if (!values) throw missingValuesError;
+      if (!resourceName) throw missingResourceError;
+
       const { resource, identifier } = select(resourceName);
       const resourcePlural = textTransformers.plural(identifier);
 
@@ -234,11 +248,18 @@ export const useCreateMany = <
           ...rest,
         },
       });
+
+      mutationOptions?.onSuccess?.(response, variables, context);
     },
-    onError: (
-      err: TError,
-      { resource: resourceName, errorNotification, values },
-    ) => {
+    onError: (err: TError, variables, context) => {
+      const {
+        resource: resourceName = resourceFromProps,
+        errorNotification = errorNotificationFromProps,
+        values = valuesFromProps,
+      } = variables;
+      if (!values) throw missingValuesError;
+      if (!resourceName) throw missingResourceError;
+
       const { identifier } = select(resourceName);
 
       const notificationConfig =
@@ -259,6 +280,8 @@ export const useCreateMany = <
         ),
         type: "error",
       });
+
+      mutationOptions?.onError?.(err, variables, context);
     },
     mutationKey: keys().data().mutation("createMany").get(preferLegacyKeys),
     ...mutationOptions,
@@ -267,6 +290,7 @@ export const useCreateMany = <
       ...getXRay("useCreateMany", preferLegacyKeys),
     },
   });
+  const { mutate, mutateAsync, ...mutation } = mutationResult;
 
   const { elapsedTime } = useLoadingOvertime({
     isLoading: mutation.isLoading,
@@ -274,5 +298,44 @@ export const useCreateMany = <
     onInterval: overtimeOptions?.onInterval,
   });
 
-  return { ...mutation, overtime: { elapsedTime } };
+  // this function is used to make the `variables` parameter optional
+  const handleMutation = (
+    variables?: UseCreateManyParams<TData, TError, TVariables>,
+    options?: MutateOptions<
+      CreateManyResponse<TData>,
+      TError,
+      UseCreateManyParams<TData, TError, TVariables>,
+      unknown
+    >,
+  ) => {
+    return mutate(variables || {}, options);
+  };
+
+  // this function is used to make the `variables` parameter optional
+  const handleMutateAsync = (
+    variables?: UseCreateManyParams<TData, TError, TVariables>,
+    options?: MutateOptions<
+      CreateManyResponse<TData>,
+      TError,
+      UseCreateManyParams<TData, TError, TVariables>,
+      unknown
+    >,
+  ) => {
+    return mutateAsync(variables || {}, options);
+  };
+
+  return {
+    ...mutation,
+    mutate: handleMutation,
+    mutateAsync: handleMutateAsync,
+    overtime: { elapsedTime },
+  };
 };
+
+const missingResourceError = new Error(
+  "[useCreateMany]: `resource` is not defined or not matched but is required",
+);
+
+const missingValuesError = new Error(
+  "[useCreateMany]: `values` is not provided but is required",
+);