@refinedev/core 4.47.2 → 4.48.0

package/src/hooks/data/useApiUrl.ts

@@ -2,14 +2,13 @@ import { pickNotDeprecated } from "@definitions/index";
 import { useDataProvider, useResource } from "@hooks";
 
 export const useApiUrl = (dataProviderName?: string): string => {
-    const dataProvider = useDataProvider();
-    const { resource } = useResource();
+  const dataProvider = useDataProvider();
+  const { resource } = useResource();
 
-    const { getApiUrl } = dataProvider(
-        dataProviderName ??
-            pickNotDeprecated(resource?.meta, resource?.options)
-                ?.dataProviderName,
-    );
+  const { getApiUrl } = dataProvider(
+    dataProviderName ??
+      pickNotDeprecated(resource?.meta, resource?.options)?.dataProviderName,
+  );
 
-    return getApiUrl();
+  return getApiUrl();
 };

package/src/hooks/data/useCreate.ts

@@ -1,95 +1,95 @@
 import {
-    pickDataProvider,
-    pickNotDeprecated,
-    useActiveAuthProvider,
+  pickDataProvider,
+  pickNotDeprecated,
+  useActiveAuthProvider,
 } from "@definitions/helpers";
 import { getXRay } from "@refinedev/devtools-internal";
 import {
-    useMutation,
-    UseMutationOptions,
-    UseMutationResult,
+  useMutation,
+  UseMutationOptions,
+  UseMutationResult,
 } from "@tanstack/react-query";
 
 import {
-    useDataProvider,
-    useHandleNotification,
-    useInvalidate,
-    useLog,
-    useMeta,
-    useOnError,
-    usePublish,
-    useRefineContext,
-    useResource,
-    useTranslate,
+  useDataProvider,
+  useHandleNotification,
+  useInvalidate,
+  useLog,
+  useMeta,
+  useOnError,
+  usePublish,
+  useRefineContext,
+  useResource,
+  useTranslate,
 } from "@hooks";
 import { useKeys } from "@hooks/useKeys";
 import {
-    BaseRecord,
-    CreateResponse,
-    HttpError,
-    IQueryKeys,
-    MetaQuery,
-    SuccessErrorNotification,
+  BaseRecord,
+  CreateResponse,
+  HttpError,
+  IQueryKeys,
+  MetaQuery,
+  SuccessErrorNotification,
 } from "../../interfaces";
 import {
-    useLoadingOvertime,
-    UseLoadingOvertimeOptionsProps,
-    UseLoadingOvertimeReturnType,
+  useLoadingOvertime,
+  UseLoadingOvertimeOptionsProps,
+  UseLoadingOvertimeReturnType,
 } from "../useLoadingOvertime";
 
 type useCreateParams<TData, TError, TVariables> = {
-    /**
-     * Resource name for API data interactions
-     */
-    resource: string;
-    /**
-     * Values for mutation function
-     */
-    values: TVariables;
-    /**
-     * Meta data for `dataProvider`
-     */
-    meta?: MetaQuery;
-    /**
-     * Meta data for `dataProvider`
-     * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
-     */
-    metaData?: MetaQuery;
-    /**
-     * If there is more than one `dataProvider`, you should use the `dataProviderName` that you will use.
-     */
-    dataProviderName?: string;
-    /**
-     * You can use it to manage the invalidations that will occur at the end of the mutation.
-     */
-    invalidates?: Array<keyof IQueryKeys>;
+  /**
+   * Resource name for API data interactions
+   */
+  resource: string;
+  /**
+   * Values for mutation function
+   */
+  values: TVariables;
+  /**
+   * Meta data for `dataProvider`
+   */
+  meta?: MetaQuery;
+  /**
+   * Meta data for `dataProvider`
+   * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+   */
+  metaData?: MetaQuery;
+  /**
+   * If there is more than one `dataProvider`, you should use the `dataProviderName` that you will use.
+   */
+  dataProviderName?: string;
+  /**
+   * You can use it to manage the invalidations that will occur at the end of the mutation.
+   */
+  invalidates?: Array<keyof IQueryKeys>;
 } & SuccessErrorNotification<CreateResponse<TData>, TError, TVariables>;
 
 export type UseCreateReturnType<
-    TData extends BaseRecord = BaseRecord,
-    TError extends HttpError = HttpError,
-    TVariables = {},
+  TData extends BaseRecord = BaseRecord,
+  TError extends HttpError = HttpError,
+  TVariables = {},
 > = UseMutationResult<
-    CreateResponse<TData>,
-    TError,
-    useCreateParams<TData, TError, TVariables>,
-    unknown
+  CreateResponse<TData>,
+  TError,
+  useCreateParams<TData, TError, TVariables>,
+  unknown
 >;
 
 export type UseCreateProps<
-    TData extends BaseRecord = BaseRecord,
-    TError extends HttpError = HttpError,
-    TVariables = {},
+  TData extends BaseRecord = BaseRecord,
+  TError extends HttpError = HttpError,
+  TVariables = {},
 > = {
-    mutationOptions?: Omit<
-        UseMutationOptions<
-            CreateResponse<TData>,
-            TError,
-            useCreateParams<TData, TError, TVariables>,
-            unknown
-        >,
-        "mutationFn" | "onError" | "onSuccess"
-    >;
+  mutationOptions?: Omit<
+    UseMutationOptions<
+      CreateResponse<TData>,
+      TError,
+      useCreateParams<TData, TError, TVariables>,
+      unknown
+    >,
+    "mutationFn" | "onError" | "onSuccess"
+  >;
 } & UseLoadingOvertimeOptionsProps;
 
 /**
@@ -106,196 +106,196 @@ export type UseCreateProps<
  */
 
 export const useCreate = <
-    TData extends BaseRecord = BaseRecord,
-    TError extends HttpError = HttpError,
-    TVariables = {},
+  TData extends BaseRecord = BaseRecord,
+  TError extends HttpError = HttpError,
+  TVariables = {},
 >({
-    mutationOptions,
-    overtimeOptions,
+  mutationOptions,
+  overtimeOptions,
 }: UseCreateProps<TData, TError, TVariables> = {}): UseCreateReturnType<
-    TData,
-    TError,
-    TVariables
+  TData,
+  TError,
+  TVariables
 > &
-    UseLoadingOvertimeReturnType => {
-    const authProvider = useActiveAuthProvider();
-    const { mutate: checkError } = useOnError({
-        v3LegacyAuthProviderCompatible: Boolean(authProvider?.isLegacy),
-    });
-    const dataProvider = useDataProvider();
-    const invalidateStore = useInvalidate();
-    const { resources, select } = useResource();
-    const translate = useTranslate();
-    const publish = usePublish();
-    const { log } = useLog();
-    const handleNotification = useHandleNotification();
-    const getMeta = useMeta();
-    const {
-        options: { textTransformers },
-    } = useRefineContext();
-    const { keys, preferLegacyKeys } = useKeys();
+  UseLoadingOvertimeReturnType => {
+  const authProvider = useActiveAuthProvider();
+  const { mutate: checkError } = useOnError({
+    v3LegacyAuthProviderCompatible: Boolean(authProvider?.isLegacy),
+  });
+  const dataProvider = useDataProvider();
+  const invalidateStore = useInvalidate();
+  const { resources, select } = useResource();
+  const translate = useTranslate();
+  const publish = usePublish();
+  const { log } = useLog();
+  const handleNotification = useHandleNotification();
+  const getMeta = useMeta();
+  const {
+    options: { textTransformers },
+  } = useRefineContext();
+  const { keys, preferLegacyKeys } = useKeys();
 
-    const mutation = useMutation<
-        CreateResponse<TData>,
-        TError,
-        useCreateParams<TData, TError, TVariables>,
-        unknown
-    >({
-        mutationFn: ({
-            resource: resourceName,
-            values,
-            meta,
-            metaData,
-            dataProviderName,
-        }: useCreateParams<TData, TError, TVariables>) => {
-            const { resource, identifier } = select(resourceName);
+  const mutation = useMutation<
+    CreateResponse<TData>,
+    TError,
+    useCreateParams<TData, TError, TVariables>,
+    unknown
+  >({
+    mutationFn: ({
+      resource: resourceName,
+      values,
+      meta,
+      metaData,
+      dataProviderName,
+    }: useCreateParams<TData, TError, TVariables>) => {
+      const { resource, identifier } = select(resourceName);
 
-            const combinedMeta = getMeta({
-                resource,
-                meta: pickNotDeprecated(meta, metaData),
-            });
+      const combinedMeta = getMeta({
+        resource,
+        meta: pickNotDeprecated(meta, metaData),
+      });
 
-            return dataProvider(
-                pickDataProvider(identifier, dataProviderName, resources),
-            ).create<TData, TVariables>({
-                resource: resource.name,
-                variables: values,
-                meta: combinedMeta,
-                metaData: combinedMeta,
-            });
-        },
-        onSuccess: (
-            data,
-            {
-                resource: resourceName,
-                successNotification: successNotificationFromProp,
-                dataProviderName: dataProviderNameFromProp,
-                invalidates = ["list", "many"],
-                values,
-                meta,
-                metaData,
-            },
-        ) => {
-            const { resource, identifier } = select(resourceName);
-            const resourceSingular = textTransformers.singular(identifier);
+      return dataProvider(
+        pickDataProvider(identifier, dataProviderName, resources),
+      ).create<TData, TVariables>({
+        resource: resource.name,
+        variables: values,
+        meta: combinedMeta,
+        metaData: combinedMeta,
+      });
+    },
+    onSuccess: (
+      data,
+      {
+        resource: resourceName,
+        successNotification: successNotificationFromProp,
+        dataProviderName: dataProviderNameFromProp,
+        invalidates = ["list", "many"],
+        values,
+        meta,
+        metaData,
+      },
+    ) => {
+      const { resource, identifier } = select(resourceName);
+      const resourceSingular = textTransformers.singular(identifier);
 
-            const dataProviderName = pickDataProvider(
-                identifier,
-                dataProviderNameFromProp,
-                resources,
-            );
+      const dataProviderName = pickDataProvider(
+        identifier,
+        dataProviderNameFromProp,
+        resources,
+      );
 
-            const combinedMeta = getMeta({
-                resource,
-                meta: pickNotDeprecated(meta, metaData),
-            });
+      const combinedMeta = getMeta({
+        resource,
+        meta: pickNotDeprecated(meta, metaData),
+      });
 
-            const notificationConfig =
-                typeof successNotificationFromProp === "function"
-                    ? successNotificationFromProp(data, values, identifier)
-                    : successNotificationFromProp;
+      const notificationConfig =
+        typeof successNotificationFromProp === "function"
+          ? successNotificationFromProp(data, values, identifier)
+          : successNotificationFromProp;
 
-            handleNotification(notificationConfig, {
-                key: `create-${identifier}-notification`,
-                message: translate(
-                    "notifications.createSuccess",
-                    {
-                        resource: translate(
-                            `${identifier}.${identifier}`,
-                            resourceSingular,
-                        ),
-                    },
-                    `Successfully created ${resourceSingular}`,
-                ),
-                description: translate("notifications.success", "Success"),
-                type: "success",
-            });
+      handleNotification(notificationConfig, {
+        key: `create-${identifier}-notification`,
+        message: translate(
+          "notifications.createSuccess",
+          {
+            resource: translate(
+              `${identifier}.${identifier}`,
+              resourceSingular,
+            ),
+          },
+          `Successfully created ${resourceSingular}`,
+        ),
+        description: translate("notifications.success", "Success"),
+        type: "success",
+      });
 
-            invalidateStore({
-                resource: identifier,
-                dataProviderName,
-                invalidates,
-            });
+      invalidateStore({
+        resource: identifier,
+        dataProviderName,
+        invalidates,
+      });
 
-            publish?.({
-                channel: `resources/${resource.name}`,
-                type: "created",
-                payload: {
-                    ids: data?.data?.id ? [data.data.id] : undefined,
-                },
-                date: new Date(),
-                meta: {
-                    ...combinedMeta,
-                    dataProviderName,
-                },
-            });
+      publish?.({
+        channel: `resources/${resource.name}`,
+        type: "created",
+        payload: {
+          ids: data?.data?.id ? [data.data.id] : undefined,
+        },
+        date: new Date(),
+        meta: {
+          ...combinedMeta,
+          dataProviderName,
+        },
+      });
 
-            const {
-                fields: _fields,
-                operation: _operation,
-                variables: _variables,
-                ...rest
-            } = combinedMeta || {};
-            log?.mutate({
-                action: "create",
-                resource: resource.name,
-                data: values,
-                meta: {
-                    dataProviderName,
-                    id: data?.data?.id ?? undefined,
-                    ...rest,
-                },
-            });
+      const {
+        fields: _fields,
+        operation: _operation,
+        variables: _variables,
+        ...rest
+      } = combinedMeta || {};
+      log?.mutate({
+        action: "create",
+        resource: resource.name,
+        data: values,
+        meta: {
+          dataProviderName,
+          id: data?.data?.id ?? undefined,
+          ...rest,
         },
-        onError: (
-            err: TError,
-            {
-                resource: resourceName,
-                errorNotification: errorNotificationFromProp,
-                values,
-            },
-        ) => {
-            checkError(err);
+      });
+    },
+    onError: (
+      err: TError,
+      {
+        resource: resourceName,
+        errorNotification: errorNotificationFromProp,
+        values,
+      },
+    ) => {
+      checkError(err);
 
-            const { identifier } = select(resourceName);
+      const { identifier } = select(resourceName);
 
-            const resourceSingular = textTransformers.singular(identifier);
+      const resourceSingular = textTransformers.singular(identifier);
 
-            const notificationConfig =
-                typeof errorNotificationFromProp === "function"
-                    ? errorNotificationFromProp(err, values, identifier)
-                    : errorNotificationFromProp;
+      const notificationConfig =
+        typeof errorNotificationFromProp === "function"
+          ? errorNotificationFromProp(err, values, identifier)
+          : errorNotificationFromProp;
 
-            handleNotification(notificationConfig, {
-                key: `create-${identifier}-notification`,
-                description: err.message,
-                message: translate(
-                    "notifications.createError",
-                    {
-                        resource: translate(
-                            `${identifier}.${identifier}`,
-                            resourceSingular,
-                        ),
-                        statusCode: err.statusCode,
-                    },
-                    `There was an error creating ${resourceSingular} (status code: ${err.statusCode})`,
-                ),
-                type: "error",
-            });
-        },
-        mutationKey: keys().data().mutation("create").get(preferLegacyKeys),
-        ...mutationOptions,
-        meta: {
-            ...mutationOptions?.meta,
-            ...getXRay("useCreate", preferLegacyKeys),
-        },
-    });
+      handleNotification(notificationConfig, {
+        key: `create-${identifier}-notification`,
+        description: err.message,
+        message: translate(
+          "notifications.createError",
+          {
+            resource: translate(
+              `${identifier}.${identifier}`,
+              resourceSingular,
+            ),
+            statusCode: err.statusCode,
+          },
+          `There was an error creating ${resourceSingular} (status code: ${err.statusCode})`,
+        ),
+        type: "error",
+      });
+    },
+    mutationKey: keys().data().mutation("create").get(preferLegacyKeys),
+    ...mutationOptions,
+    meta: {
+      ...mutationOptions?.meta,
+      ...getXRay("useCreate", preferLegacyKeys),
+    },
+  });
 
-    const { elapsedTime } = useLoadingOvertime({
-        isLoading: mutation.isLoading,
-        interval: overtimeOptions?.interval,
-        onInterval: overtimeOptions?.onInterval,
-    });
+  const { elapsedTime } = useLoadingOvertime({
+    isLoading: mutation.isLoading,
+    interval: overtimeOptions?.interval,
+    onInterval: overtimeOptions?.onInterval,
+  });
 
-    return { ...mutation, overtime: { elapsedTime } };
+  return { ...mutation, overtime: { elapsedTime } };
 };