@refinedev/core 4.47.2 → 4.49.0

package/src/hooks/invalidate/index.tsx

@@ -1,95 +1,96 @@
 import { useCallback } from "react";
+
 import {
-    InvalidateOptions,
-    InvalidateQueryFilters,
-    useQueryClient,
+  InvalidateOptions,
+  InvalidateQueryFilters,
+  useQueryClient,
 } from "@tanstack/react-query";
 
-import { useResource } from "@hooks/resource";
 import { pickDataProvider } from "@definitions";
-import { BaseKey, IQueryKeys } from "../../interfaces";
-import { useKeys } from "@hooks/useKeys";
+import { useKeys, useResource } from "@hooks";
+
+import { BaseKey, IQueryKeys } from "../../contexts/data/types";
 
 export type UseInvalidateProp = {
-    resource?: string;
-    id?: BaseKey;
-    dataProviderName?: string;
-    invalidates: Array<keyof IQueryKeys> | false;
-    invalidationFilters?: InvalidateQueryFilters;
-    invalidationOptions?: InvalidateOptions;
+  resource?: string;
+  id?: BaseKey;
+  dataProviderName?: string;
+  invalidates: Array<keyof IQueryKeys> | false;
+  invalidationFilters?: InvalidateQueryFilters;
+  invalidationOptions?: InvalidateOptions;
 };
 
 export const useInvalidate = (): ((
-    props: UseInvalidateProp,
+  props: UseInvalidateProp,
 ) => Promise<void>) => {
-    const { resources } = useResource();
-    const queryClient = useQueryClient();
-    const { keys, preferLegacyKeys } = useKeys();
+  const { resources } = useResource();
+  const queryClient = useQueryClient();
+  const { keys, preferLegacyKeys } = useKeys();
 
-    const invalidate = useCallback(
-        async ({
-            resource,
-            dataProviderName,
-            invalidates,
-            id,
-            invalidationFilters = { type: "all", refetchType: "active" },
-            invalidationOptions = { cancelRefetch: false },
-        }: UseInvalidateProp) => {
-            if (invalidates === false) {
-                return;
-            }
-            const dp = pickDataProvider(resource, dataProviderName, resources);
+  const invalidate = useCallback(
+    async ({
+      resource,
+      dataProviderName,
+      invalidates,
+      id,
+      invalidationFilters = { type: "all", refetchType: "active" },
+      invalidationOptions = { cancelRefetch: false },
+    }: UseInvalidateProp) => {
+      if (invalidates === false) {
+        return;
+      }
+      const dp = pickDataProvider(resource, dataProviderName, resources);
 
-            const queryKey = keys()
-                .data(dp)
-                .resource(resource ?? "");
+      const queryKey = keys()
+        .data(dp)
+        .resource(resource ?? "");
 
-            await Promise.all(
-                invalidates.map((key) => {
-                    switch (key) {
-                        case "all":
-                            return queryClient.invalidateQueries(
-                                keys().data(dp).get(preferLegacyKeys),
-                                invalidationFilters,
-                                invalidationOptions,
-                            );
-                        case "list":
-                            return queryClient.invalidateQueries(
-                                queryKey.action("list").get(preferLegacyKeys),
-                                invalidationFilters,
-                                invalidationOptions,
-                            );
-                        case "many":
-                            return queryClient.invalidateQueries(
-                                queryKey.action("many").get(preferLegacyKeys),
-                                invalidationFilters,
-                                invalidationOptions,
-                            );
-                        case "resourceAll":
-                            return queryClient.invalidateQueries(
-                                queryKey.get(preferLegacyKeys),
-                                invalidationFilters,
-                                invalidationOptions,
-                            );
-                        case "detail":
-                            return queryClient.invalidateQueries(
-                                queryKey
-                                    .action("one")
-                                    .id(id || "")
-                                    .get(preferLegacyKeys),
-                                invalidationFilters,
-                                invalidationOptions,
-                            );
-                        default:
-                            return;
-                    }
-                }),
-            );
+      await Promise.all(
+        invalidates.map((key) => {
+          switch (key) {
+            case "all":
+              return queryClient.invalidateQueries(
+                keys().data(dp).get(preferLegacyKeys),
+                invalidationFilters,
+                invalidationOptions,
+              );
+            case "list":
+              return queryClient.invalidateQueries(
+                queryKey.action("list").get(preferLegacyKeys),
+                invalidationFilters,
+                invalidationOptions,
+              );
+            case "many":
+              return queryClient.invalidateQueries(
+                queryKey.action("many").get(preferLegacyKeys),
+                invalidationFilters,
+                invalidationOptions,
+              );
+            case "resourceAll":
+              return queryClient.invalidateQueries(
+                queryKey.get(preferLegacyKeys),
+                invalidationFilters,
+                invalidationOptions,
+              );
+            case "detail":
+              return queryClient.invalidateQueries(
+                queryKey
+                  .action("one")
+                  .id(id || "")
+                  .get(preferLegacyKeys),
+                invalidationFilters,
+                invalidationOptions,
+              );
+            default:
+              return;
+          }
+        }),
+      );
 
-            return;
-        },
-        [],
-    );
+      return;
+    },
+    [],
+  );
 
-    return invalidate;
+  return invalidate;
 };

package/src/hooks/legacy-router/useRouterContext.ts

@@ -1,18 +1,19 @@
 import { useContext } from "react";
-import { RouterContext, defaultProvider } from "@contexts/legacy-router";
+
+import { LegacyRouterContext, defaultProvider } from "@contexts/router/legacy";
 
 export const useRouterContext = () => {
-    const routerContextValues = useContext(RouterContext);
+  const routerContextValues = useContext(LegacyRouterContext);
 
-    const { useHistory, useLocation, useParams, Prompt, Link, routes } =
-        routerContextValues ?? defaultProvider;
+  const { useHistory, useLocation, useParams, Prompt, Link, routes } =
+    routerContextValues ?? defaultProvider;
 
-    return {
-        useHistory,
-        useLocation,
-        useParams,
-        Prompt,
-        Link,
-        routes,
-    };
+  return {
+    useHistory,
+    useLocation,
+    useParams,
+    Prompt,
+    Link,
+    routes,
+  };
 };

package/src/hooks/live/useLiveMode/index.ts

@@ -1,12 +1,15 @@
 import { useContext } from "react";
-import { LiveModeProps, IRefineContext } from "../../../interfaces";
+
 import { RefineContext } from "@contexts/refine";
 
+import { LiveModeProps } from "../../../contexts/live/types";
+import { IRefineContext } from "../../../contexts/refine/types";
+
 export const useLiveMode = (
-    liveMode: LiveModeProps["liveMode"],
+  liveMode: LiveModeProps["liveMode"],
 ): LiveModeProps["liveMode"] => {
-    const { liveMode: liveModeFromContext } =
-        useContext<IRefineContext>(RefineContext);
+  const { liveMode: liveModeFromContext } =
+    useContext<IRefineContext>(RefineContext);
 
-    return liveMode ?? liveModeFromContext;
+  return liveMode ?? liveModeFromContext;
 };

package/src/hooks/live/usePublish/index.ts

@@ -1,10 +1,10 @@
 import { useContext } from "react";
 
 import { LiveContext } from "@contexts/live";
-import { ILiveContext } from "../../../interfaces";
+import { LiveProvider } from "../../../contexts/live/types";
 
-export const usePublish: () => NonNullable<ILiveContext>["publish"] = () => {
-    const liveContext = useContext<ILiveContext>(LiveContext);
+export const usePublish: () => NonNullable<LiveProvider>["publish"] = () => {
+  const { liveProvider } = useContext(LiveContext);
 
-    return liveContext?.publish;
+  return liveProvider?.publish;
 };

package/src/hooks/live/useResourceSubscription/index.ts

@@ -1,131 +1,129 @@
+import { useContext, useEffect } from "react";
+
 import { LiveContext } from "@contexts/live";
 import { RefineContext } from "@contexts/refine";
 import { useInvalidate } from "@hooks/invalidate";
 import { useResource } from "@hooks/resource";
-import { useContext, useEffect } from "react";
+
 import {
-    BaseKey,
-    CrudFilters,
-    CrudSorting,
-    ILiveContext,
-    IRefineContext,
-    LiveEvent,
-    LiveModeProps,
-    MetaQuery,
-    Pagination,
-} from "../../../interfaces";
+  BaseKey,
+  CrudFilter,
+  CrudSort,
+  MetaQuery,
+  Pagination,
+} from "../../../contexts/data/types";
+import { LiveEvent, LiveModeProps } from "../../../contexts/live/types";
+import { IRefineContext } from "../../../contexts/refine/types";
 
 export type UseResourceSubscriptionProps = {
-    channel: string;
-    params?: {
-        ids?: BaseKey[];
-        id?: BaseKey;
-        /**
-         * @deprecated `params.meta` is depcerated. Use `meta` directly from the root level instead.
-         */
-        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";
-        [key: string]: any;
-    };
-    types: LiveEvent["type"][];
-    resource?: string;
-    enabled?: boolean;
+  channel: string;
+  params?: {
+    ids?: BaseKey[];
+    id?: BaseKey;
+    /**
+     * @deprecated `params.meta` is depcerated. Use `meta` directly from the root level instead.
+     */
+    meta?: MetaQuery;
     /**
-     * @deprecated use `meta.dataProviderName` instead.
+     * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
      */
-    dataProviderName?: string;
-    meta?: MetaQuery & { dataProviderName?: string };
+    metaData?: MetaQuery;
+    pagination?: Pagination;
+    /**
+     * @deprecated `hasPagination` is deprecated, use `pagination.mode` instead.
+     */
+    hasPagination?: boolean;
+    /**
+     * @deprecated `sort` is deprecated. Use `sorters` instead.
+     */
+    sort?: CrudSort[];
+    sorters?: CrudSort[];
+    filters?: CrudFilter[];
+    subscriptionType: "useList" | "useOne" | "useMany";
+    [key: string]: any;
+  };
+  types: LiveEvent["type"][];
+  resource?: string;
+  enabled?: boolean;
+  /**
+   * @deprecated use `meta.dataProviderName` instead.
+   */
+  dataProviderName?: string;
+  meta?: MetaQuery & { dataProviderName?: string };
 } & LiveModeProps;
 
-export type PublishType = {
-    (event: LiveEvent): void;
-};
+export type PublishType = (event: LiveEvent) => void;
 
 export const useResourceSubscription = ({
-    resource: resourceFromProp,
-    params,
-    channel,
-    types,
-    enabled = true,
-    liveMode: liveModeFromProp,
-    onLiveEvent,
-    dataProviderName: dataProviderNameFromProps,
-    meta,
+  resource: resourceFromProp,
+  params,
+  channel,
+  types,
+  enabled = true,
+  liveMode: liveModeFromProp,
+  onLiveEvent,
+  dataProviderName: dataProviderNameFromProps,
+  meta,
 }: UseResourceSubscriptionProps): void => {
-    const { resource, identifier } = useResource(resourceFromProp);
+  const { resource, identifier } = useResource(resourceFromProp);
 
-    const liveDataContext = useContext<ILiveContext>(LiveContext);
-    const {
-        liveMode: liveModeFromContext,
-        onLiveEvent: onLiveEventContextCallback,
-    } = useContext<IRefineContext>(RefineContext);
+  const { liveProvider } = useContext(LiveContext);
+  const {
+    liveMode: liveModeFromContext,
+    onLiveEvent: onLiveEventContextCallback,
+  } = useContext<IRefineContext>(RefineContext);
 
-    const liveMode = liveModeFromProp ?? liveModeFromContext;
+  const liveMode = liveModeFromProp ?? liveModeFromContext;
 
-    const invalidate = useInvalidate();
+  const invalidate = useInvalidate();
 
-    const dataProviderName =
-        dataProviderNameFromProps ??
-        meta?.dataProviderName ??
-        resource?.meta?.dataProviderName;
+  const dataProviderName =
+    dataProviderNameFromProps ??
+    meta?.dataProviderName ??
+    resource?.meta?.dataProviderName;
 
-    useEffect(() => {
-        let subscription: any;
+  useEffect(() => {
+    let subscription: any;
 
-        const callback = (event: LiveEvent) => {
-            if (liveMode === "auto") {
-                invalidate({
-                    resource: identifier,
-                    dataProviderName,
-                    invalidates: ["resourceAll"],
-                    invalidationFilters: {
-                        type: "active",
-                        refetchType: "active",
-                    },
-                    invalidationOptions: { cancelRefetch: false },
-                });
-            }
+    const callback = (event: LiveEvent) => {
+      if (liveMode === "auto") {
+        invalidate({
+          resource: identifier,
+          dataProviderName,
+          invalidates: ["resourceAll"],
+          invalidationFilters: {
+            type: "active",
+            refetchType: "active",
+          },
+          invalidationOptions: { cancelRefetch: false },
+        });
+      }
 
-            onLiveEvent?.(event);
-            onLiveEventContextCallback?.(event);
-        };
+      onLiveEvent?.(event);
+      onLiveEventContextCallback?.(event);
+    };
 
-        if (liveMode && liveMode !== "off" && enabled) {
-            subscription = liveDataContext?.subscribe({
-                channel,
-                params: {
-                    resource: resource?.name,
-                    ...params,
-                },
-                types,
-                callback,
-                dataProviderName,
-                meta: {
-                    ...meta,
-                    dataProviderName,
-                },
-            });
-        }
+    if (liveMode && liveMode !== "off" && enabled) {
+      subscription = liveProvider?.subscribe({
+        channel,
+        params: {
+          resource: resource?.name,
+          ...params,
+        },
+        types,
+        callback,
+        dataProviderName,
+        meta: {
+          ...meta,
+          dataProviderName,
+        },
+      });
+    }
 
-        return () => {
-            if (subscription) {
-                liveDataContext?.unsubscribe(subscription);
-            }
-        };
-    }, [enabled]);
+    return () => {
+      if (subscription) {
+        liveProvider?.unsubscribe(subscription);
+      }
+    };
+  }, [enabled]);
 };

package/src/hooks/live/useSubscription/index.ts

@@ -1,100 +1,100 @@
 import { useContext, useEffect } from "react";
 
 import { LiveContext } from "@contexts/live";
+
 import {
-    BaseKey,
-    CrudFilters,
-    CrudSorting,
-    ILiveContext,
-    LiveEvent,
-    MetaQuery,
-    Pagination,
-} from "../../../interfaces";
+  BaseKey,
+  CrudFilter,
+  CrudSort,
+  MetaQuery,
+  Pagination,
+} from "../../../contexts/data/types";
+import { LiveEvent } from "../../../contexts/live/types";
 
 export type UseSubscriptionProps = {
+  /**
+   * Channel name to subscribe.
+   */
+  channel: string;
+  /**
+   * Callback that is run when new events from subscription arrive.
+   */
+  onLiveEvent: (event: LiveEvent) => void;
+  /**
+   * Type of events to subscribe. `"*"` means all events.
+   * @type Array<"deleted" | "updated" | "created" | "*" | string>
+   */
+  types?: LiveEvent["type"][];
+  /**
+   * Determines subscription should subscribe or not.
+   * @type Array<"deleted" | "updated" | "created" | "*" | string>
+   */
+  enabled?: boolean;
+  params?: {
+    ids?: BaseKey[];
+    id?: BaseKey;
     /**
-     * Channel name to subscribe.
+     * @deprecated `params.meta` is depcerated. Use `meta` directly from the root level instead.
      */
-    channel: string;
+    meta?: MetaQuery;
     /**
-     * Callback that is run when new events from subscription arrive.
+     * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
      */
-    onLiveEvent: (event: LiveEvent) => void;
+    metaData?: MetaQuery;
+    pagination?: Pagination;
     /**
-     * Type of events to subscribe. `"*"` means all events.
-     * @type Array<"deleted" | "updated" | "created" | "*" | string>
+     * @deprecated `hasPagination` is deprecated, use `pagination.mode` instead.
      */
-    types?: LiveEvent["type"][];
+    hasPagination?: boolean;
     /**
-     * Determines subscription should subscribe or not.
-     * @type Array<"deleted" | "updated" | "created" | "*" | string>
+     * @deprecated `sort` is deprecated, use `sorters` instead.
      */
-    enabled?: boolean;
-    params?: {
-        ids?: BaseKey[];
-        id?: BaseKey;
-        /**
-         * @deprecated `params.meta` is depcerated. Use `meta` directly from the root level instead.
-         */
-        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;
-    };
-    /**
-     * @deprecated use `meta.dataProviderName` instead.
-     */
-    dataProviderName?: string;
-    meta?: MetaQuery & { dataProviderName?: string };
+    sort?: CrudSort[];
+    sorters?: CrudSort[];
+    filters?: CrudFilter[];
+    subscriptionType?: "useList" | "useOne" | "useMany";
+    resource?: string;
+    [key: string]: any;
+  };
+  /**
+   * @deprecated use `meta.dataProviderName` instead.
+   */
+  dataProviderName?: string;
+  meta?: MetaQuery & { dataProviderName?: string };
 };
 
 export const useSubscription = ({
-    params,
-    channel,
-    types = ["*"],
-    enabled = true,
-    onLiveEvent,
-    dataProviderName = "default",
-    meta,
+  params,
+  channel,
+  types = ["*"],
+  enabled = true,
+  onLiveEvent,
+  dataProviderName = "default",
+  meta,
 }: UseSubscriptionProps): void => {
-    const liveDataContext = useContext<ILiveContext>(LiveContext);
+  const { liveProvider } = useContext(LiveContext);
 
-    useEffect(() => {
-        let subscription: any;
+  useEffect(() => {
+    let subscription: any;
 
-        if (enabled) {
-            subscription = liveDataContext?.subscribe({
-                channel,
-                params,
-                types,
-                callback: onLiveEvent,
-                dataProviderName,
-                meta: {
-                    ...meta,
-                    dataProviderName,
-                },
-            });
-        }
+    if (enabled) {
+      subscription = liveProvider?.subscribe({
+        channel,
+        params,
+        types,
+        callback: onLiveEvent,
+        dataProviderName,
+        meta: {
+          ...meta,
+          dataProviderName,
+        },
+      });
+    }
 
-        return () => {
-            if (subscription) {
-                liveDataContext?.unsubscribe(subscription);
-            }
-        };
-    }, [enabled]);
+    return () => {
+      if (subscription) {
+        liveProvider?.unsubscribe(subscription);
+      }
+    };
+  }, [enabled]);
 };