@refinedev/core 4.47.2 → 4.49.0

package/src/contexts/data/types.ts

@@ -0,0 +1,490 @@
+import { QueryFunctionContext, QueryKey } from "@tanstack/react-query";
+import { DocumentNode } from "graphql";
+
+import { UseListConfig } from "../../hooks/data/useList";
+
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+export type BaseKey = string | number;
+export type BaseRecord = {
+  id?: BaseKey;
+  [key: string]: any;
+};
+export type BaseOption = {
+  label: any;
+  value: any;
+};
+
+/**
+ * @deprecated Use `BaseOption` instead.
+ */
+export interface Option extends BaseOption {}
+
+export type NestedField = {
+  operation: string;
+  variables: QueryBuilderOptions[];
+  fields: Fields;
+};
+
+export type Fields = Array<string | object | NestedField>;
+
+export type VariableOptions =
+  | {
+      type?: string;
+      name?: string;
+      value: any;
+      list?: boolean;
+      required?: boolean;
+    }
+  | { [k: string]: any };
+
+export interface QueryBuilderOptions {
+  operation?: string;
+  fields?: Fields;
+  variables?: VariableOptions;
+}
+
+export type GraphQLQueryOptions = {
+  /**
+   * @description GraphQL query to be used by data providers.
+   * @optional
+   * @example
+   * ```tsx
+   * import gql from 'graphql-tag'
+   * import { useOne } from '@refinedev/core'
+   *
+   * const PRODUCT_QUERY = gql`
+   *   query GetProduct($id: ID!) {
+   *     product(id: $id) {
+   *       id
+   *       name
+   *     }
+   *   }
+   * `
+   *
+   * useOne({
+   *   id: 1,
+   *   meta: { gqlQuery: PRODUCT_QUERY }
+   * })
+   * ```
+   */
+  gqlQuery?: DocumentNode;
+  /**
+   * @description GraphQL mutation to be used by data providers.
+   * @optional
+   * @example
+   * ```tsx
+   * import gql from 'graphql-tag'
+   * import { useCreate } from '@refinedev/core'
+   *
+   * const PRODUCT_CREATE_MUTATION = gql`
+   *   mutation CreateProduct($input: CreateOneProductInput!) {
+   *     createProduct(input: $input) {
+   *       id
+   *       name
+   *     }
+   *   }
+   * `
+   * const { mutate } = useCreate()
+   *
+   * mutate({
+   *   values: { name: "My Product" },
+   *   meta: { gqlQuery: PRODUCT_QUERY }
+   * })
+   * ```
+   */
+  gqlMutation?: DocumentNode;
+};
+
+export type MetaQuery = {
+  [k: string]: any;
+  queryContext?: Omit<QueryFunctionContext, "meta">;
+} & QueryBuilderOptions &
+  GraphQLQueryOptions;
+
+export interface Pagination {
+  /**
+   * Initial page index
+   * @default 1
+   */
+  current?: number;
+  /**
+   * Initial number of items per page
+   * @default 10
+   */
+  pageSize?: number;
+  /**
+   * Whether to use server side pagination or not.
+   * @default "server"
+   */
+  mode?: "client" | "server" | "off";
+}
+
+/**
+ * @deprecated `MetaDataQuery` is deprecated with refine@4, use `MetaQuery` instead, however, we still support `MetaDataQuery` for backward compatibility.
+ */
+export type MetaDataQuery = {
+  [k: string]: any;
+  queryContext?: Omit<QueryFunctionContext, "meta">;
+} & QueryBuilderOptions;
+
+export interface IQueryKeys {
+  all: QueryKey;
+  resourceAll: QueryKey;
+  list: (
+    config?:
+      | UseListConfig
+      | {
+          pagination?: Required<Pagination>;
+          hasPagination?: boolean;
+          sorters?: CrudSort[];
+          filters?: CrudFilter[];
+        }
+      | undefined,
+  ) => QueryKey;
+  many: (ids?: BaseKey[]) => QueryKey;
+  detail: (id?: BaseKey) => QueryKey;
+  logList: (meta?: Record<number | string, any>) => QueryKey;
+}
+
+export interface ValidationErrors {
+  [field: string]:
+    | string
+    | string[]
+    | boolean
+    | { key: string; message: string };
+}
+
+export interface HttpError extends Record<string, any> {
+  message: string;
+  statusCode: number;
+  errors?: ValidationErrors;
+}
+
+export type RefineError = HttpError;
+
+export type MutationMode = "pessimistic" | "optimistic" | "undoable";
+
+export type QueryResponse<T = BaseRecord> =
+  | GetListResponse<T>
+  | GetOneResponse<T>;
+
+export type PreviousQuery<TData> = [QueryKey, TData | unknown];
+
+export type PrevContext<TData> = {
+  previousQueries: PreviousQuery<TData>[];
+  /**
+   * @deprecated `QueryKeys` is deprecated in favor of `keys`. Please use `keys` instead to construct query keys for queries and mutations.
+   */
+  queryKey: IQueryKeys;
+};
+
+export type Context = {
+  previousQueries: ContextQuery[];
+};
+
+export type ContextQuery<T = BaseRecord> = {
+  query: QueryResponse<T>;
+  queryKey: QueryKey;
+};
+
+// Filters are used as a suffix of a field name:
+
+// | Filter              | Description                       |
+// | ------------------- | --------------------------------- |
+// | `eq`                | Equal                             |
+// | ne                  | Not equal                         |
+// | lt                  | Less than                         |
+// | gt                  | Greater than                      |
+// | lte                 | Less than or equal to             |
+// | gte                 | Greater than or equal to          |
+// | in                  | Included in an array              |
+// | nin                 | Not included in an array          |
+// | contains            | Contains                          |
+// | ncontains           | Doesn't contain                   |
+// | containss           | Contains, case sensitive          |
+// | ncontainss          | Doesn't contain, case sensitive   |
+// | null                | Is null or not null               |
+// | startswith          | Starts with                       |
+// | nstartswith         | Doesn't start with                |
+// | startswiths         | Starts with, case sensitive       |
+// | nstartswiths        | Doesn't start with, case sensitive|
+// | endswith            | Ends with                         |
+// | nendswith           | Doesn't end with                  |
+// | endswiths           | Ends with, case sensitive         |
+// | nendswiths          | Doesn't end with, case sensitive  |
+export type CrudOperators =
+  | "eq"
+  | "ne"
+  | "lt"
+  | "gt"
+  | "lte"
+  | "gte"
+  | "in"
+  | "nin"
+  | "contains"
+  | "ncontains"
+  | "containss"
+  | "ncontainss"
+  | "between"
+  | "nbetween"
+  | "null"
+  | "nnull"
+  | "startswith"
+  | "nstartswith"
+  | "startswiths"
+  | "nstartswiths"
+  | "endswith"
+  | "nendswith"
+  | "endswiths"
+  | "nendswiths"
+  | "or"
+  | "and";
+
+export type SortOrder = "desc" | "asc" | null;
+
+export type LogicalFilter = {
+  field: string;
+  operator: Exclude<CrudOperators, "or" | "and">;
+  value: any;
+};
+
+export type ConditionalFilter = {
+  key?: string;
+  operator: Extract<CrudOperators, "or" | "and">;
+  value: (LogicalFilter | ConditionalFilter)[];
+};
+
+export type CrudFilter = LogicalFilter | ConditionalFilter;
+export type CrudSort = {
+  field: string;
+  order: "asc" | "desc";
+};
+
+export type CrudFilters = CrudFilter[];
+export type CrudSorting = CrudSort[];
+
+export interface CustomResponse<TData = BaseRecord> {
+  data: TData;
+}
+export interface GetListResponse<TData = BaseRecord> {
+  data: TData[];
+  total: number;
+  [key: string]: any;
+}
+
+export interface CreateResponse<TData = BaseRecord> {
+  data: TData;
+}
+
+export interface CreateManyResponse<TData = BaseRecord> {
+  data: TData[];
+}
+
+export interface UpdateResponse<TData = BaseRecord> {
+  data: TData;
+}
+
+export interface UpdateManyResponse<TData = BaseRecord> {
+  data: TData[];
+}
+
+export interface GetOneResponse<TData = BaseRecord> {
+  data: TData;
+}
+
+export interface GetManyResponse<TData = BaseRecord> {
+  data: TData[];
+}
+
+export interface DeleteOneResponse<TData = BaseRecord> {
+  data: TData;
+}
+
+export interface DeleteManyResponse<TData = BaseRecord> {
+  data: TData[];
+}
+
+export interface GetListParams {
+  resource: string;
+  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[];
+  meta?: MetaQuery;
+  /**
+   * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+   */
+  metaData?: MetaQuery;
+  dataProviderName?: string;
+}
+
+export interface GetManyParams {
+  resource: string;
+  ids: BaseKey[];
+  meta?: MetaQuery;
+  /**
+   * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+   */
+  metaData?: MetaQuery;
+  dataProviderName?: string;
+}
+
+export interface GetOneParams {
+  resource: string;
+  id: BaseKey;
+  meta?: MetaQuery;
+  /**
+   * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+   */
+  metaData?: MetaQuery;
+}
+
+export interface CreateParams<TVariables = {}> {
+  resource: string;
+  variables: TVariables;
+  meta?: MetaQuery;
+  /**
+   * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+   */
+  metaData?: MetaQuery;
+}
+
+export interface CreateManyParams<TVariables = {}> {
+  resource: string;
+  variables: TVariables[];
+  meta?: MetaQuery;
+  /**
+   * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+   */
+  metaData?: MetaQuery;
+}
+
+export interface UpdateParams<TVariables = {}> {
+  resource: string;
+  id: BaseKey;
+  variables: TVariables;
+  meta?: MetaQuery;
+  /**
+   * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+   */
+  metaData?: MetaQuery;
+}
+
+export interface UpdateManyParams<TVariables = {}> {
+  resource: string;
+  ids: BaseKey[];
+  variables: TVariables;
+  meta?: MetaQuery;
+  /**
+   * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+   */
+  metaData?: MetaQuery;
+}
+
+export interface DeleteOneParams<TVariables = {}> {
+  resource: string;
+  id: BaseKey;
+  variables?: TVariables;
+  meta?: MetaQuery;
+  /**
+   * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+   */
+  metaData?: MetaQuery;
+}
+
+export interface DeleteManyParams<TVariables = {}> {
+  resource: string;
+  ids: BaseKey[];
+  variables?: TVariables;
+  meta?: MetaQuery;
+  /**
+   * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+   */
+  metaData?: MetaQuery;
+}
+
+export interface CustomParams<TQuery = unknown, TPayload = unknown> {
+  url: string;
+  method: "get" | "delete" | "head" | "options" | "post" | "put" | "patch";
+  /**
+   * @deprecated `sort` is deprecated, use `sorters` instead.
+   */
+  sort?: CrudSort[];
+  sorters?: CrudSort[];
+  filters?: CrudFilter[];
+  payload?: TPayload;
+  query?: TQuery;
+  headers?: {};
+  meta?: MetaQuery;
+  /**
+   * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+   */
+  metaData?: MetaQuery;
+}
+
+export type DataProvider = {
+  getList: <TData extends BaseRecord = BaseRecord>(
+    params: GetListParams,
+  ) => Promise<GetListResponse<TData>>;
+
+  getMany?: <TData extends BaseRecord = BaseRecord>(
+    params: GetManyParams,
+  ) => Promise<GetManyResponse<TData>>;
+
+  getOne: <TData extends BaseRecord = BaseRecord>(
+    params: GetOneParams,
+  ) => Promise<GetOneResponse<TData>>;
+
+  create: <TData extends BaseRecord = BaseRecord, TVariables = {}>(
+    params: CreateParams<TVariables>,
+  ) => Promise<CreateResponse<TData>>;
+
+  createMany?: <TData extends BaseRecord = BaseRecord, TVariables = {}>(
+    params: CreateManyParams<TVariables>,
+  ) => Promise<CreateManyResponse<TData>>;
+
+  update: <TData extends BaseRecord = BaseRecord, TVariables = {}>(
+    params: UpdateParams<TVariables>,
+  ) => Promise<UpdateResponse<TData>>;
+
+  updateMany?: <TData extends BaseRecord = BaseRecord, TVariables = {}>(
+    params: UpdateManyParams<TVariables>,
+  ) => Promise<UpdateManyResponse<TData>>;
+
+  deleteOne: <TData extends BaseRecord = BaseRecord, TVariables = {}>(
+    params: DeleteOneParams<TVariables>,
+  ) => Promise<DeleteOneResponse<TData>>;
+
+  deleteMany?: <TData extends BaseRecord = BaseRecord, TVariables = {}>(
+    params: DeleteManyParams<TVariables>,
+  ) => Promise<DeleteManyResponse<TData>>;
+
+  getApiUrl: () => string;
+
+  custom?: <
+    TData extends BaseRecord = BaseRecord,
+    TQuery = unknown,
+    TPayload = unknown,
+  >(
+    params: CustomParams<TQuery, TPayload>,
+  ) => Promise<CustomResponse<TData>>;
+};
+
+export type DataProviders = {
+  default: DataProvider;
+  [key: string]: DataProvider;
+};
+
+export type IDataContext = DataProviders;
+
+export type DataBindings = DataProvider | DataProviders;

package/src/contexts/i18n/index.tsx

@@ -0,0 +1,23 @@
+import React, { PropsWithChildren } from "react";
+
+import { I18nProvider, II18nContext } from "./types";
+
+/** @deprecated default value for translation context has no use and is an empty object.  */
+export const defaultProvider: Partial<I18nProvider> = {};
+
+export const I18nContext = React.createContext<II18nContext>({});
+
+export const I18nContextProvider: React.FC<PropsWithChildren<II18nContext>> = ({
+  children,
+  i18nProvider,
+}) => {
+  return (
+    <I18nContext.Provider
+      value={{
+        i18nProvider,
+      }}
+    >
+      {children}
+    </I18nContext.Provider>
+  );
+};

package/src/contexts/i18n/types.ts

@@ -0,0 +1,22 @@
+type TranslateFunction = (
+  key: string,
+  options?: any,
+  defaultMessage?: string,
+) => string;
+
+type ChangeLocaleFunction = (
+  locale: string,
+  options?: any,
+) => Promise<any> | any;
+
+type GetLocaleFunction = () => string;
+
+export type I18nProvider = {
+  translate: TranslateFunction;
+  changeLocale: ChangeLocaleFunction;
+  getLocale: GetLocaleFunction;
+};
+
+export interface II18nContext {
+  i18nProvider?: I18nProvider;
+}

package/src/contexts/live/index.tsx

@@ -1,16 +1,16 @@
-import React from "react";
+import React, { PropsWithChildren } from "react";
 
-import { ILiveContext, ILiveContextProvider } from "./ILiveContext";
+import { ILiveContext } from "./types";
 
-export const LiveContext = React.createContext<ILiveContext>(undefined);
+export const LiveContext = React.createContext<ILiveContext>({});
 
-export const LiveContextProvider: React.FC<ILiveContextProvider> = ({
-    liveProvider,
-    children,
+export const LiveContextProvider: React.FC<PropsWithChildren<ILiveContext>> = ({
+  liveProvider,
+  children,
 }) => {
-    return (
-        <LiveContext.Provider value={liveProvider}>
-            {children}
-        </LiveContext.Provider>
-    );
+  return (
+    <LiveContext.Provider value={{ liveProvider }}>
+      {children}
+    </LiveContext.Provider>
+  );
 };

package/src/contexts/live/types.ts

@@ -0,0 +1,113 @@
+import {
+  BaseKey,
+  CrudFilter,
+  CrudSort,
+  MetaQuery,
+  Pagination,
+} from "../data/types";
+
+export type LiveEvent = {
+  channel: string;
+  type: "deleted" | "updated" | "created" | "*" | string;
+  payload: {
+    ids?: BaseKey[];
+    [x: string]: any;
+  };
+  date: Date;
+  meta?: MetaQuery & {
+    dataProviderName?: string;
+  };
+};
+
+export type LiveModeProps = {
+  /**
+   * Whether to update data automatically ("auto") or not ("manual") if a related live event is received. The "off" value is used to avoid creating a subscription.
+   * @type  [`"auto" | "manual" | "off"`](/docs/api-reference/core/providers/live-provider/#livemode)
+   * @default `"off"`
+   */
+  liveMode?: "auto" | "manual" | "off";
+  /**
+   * Callback to handle all related live events of this hook.
+   * @type [`(event: LiveEvent) => void`](/docs/api-reference/core/interfaceReferences/#livemodeprops)
+   * @default `undefined`
+   */
+  onLiveEvent?: (event: LiveEvent) => void;
+  /**
+   * Params to pass to liveProvider's subscribe method if liveMode is enabled.
+   * @type [`{ ids?: BaseKey[]; [key: string]: any; }`](/docs/api-reference/core/interfaceReferences/#livemodeprops)
+   * @default `undefined`
+   */
+  liveParams?: {
+    ids?: BaseKey[];
+    [key: string]: any;
+  };
+};
+
+export type ILiveModeContextProvider = LiveModeProps;
+
+export type LiveListParams = {
+  resource?: string;
+  pagination?: Pagination;
+  hasPagination?: boolean;
+  sorters?: CrudSort[];
+  filters?: CrudFilter[];
+  meta?: MetaQuery;
+  metaData?: MetaQuery;
+};
+
+export type LiveOneParams = {
+  resource?: string;
+  id?: BaseKey;
+};
+
+export type LiveManyParams = {
+  resource?: string;
+  ids?: BaseKey[];
+};
+
+export type LiveCommonParams = {
+  subscriptionType?: "useList" | "useOne" | "useMany";
+  [key: string]: unknown;
+};
+
+type LiveSubscribeOptions = {
+  channel: string;
+  types: Array<LiveEvent["type"]>;
+  callback: (event: LiveEvent) => void;
+  params?: LiveCommonParams & LiveListParams & LiveOneParams & LiveManyParams;
+};
+
+type LiveDeprecatedSubscribeOptions = {
+  /**
+   * @deprecated use `meta.dataProviderName` instead.
+   */
+  dataProviderName?: string;
+  /**
+   * @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;
+  /**
+   * @deprecated `hasPagination` is deprecated, use `pagination.mode` instead.
+   */
+  hasPagination?: boolean;
+  /**
+   * @deprecated `sort` is deprecated, use `sorters` instead.
+   */
+  sort?: CrudSort[];
+};
+
+export type LiveProvider = {
+  publish?: (event: LiveEvent) => void;
+  subscribe: (
+    options: LiveSubscribeOptions & LiveDeprecatedSubscribeOptions,
+  ) => any;
+  unsubscribe: (subscription: any) => void;
+};
+
+export type ILiveContext = {
+  liveProvider?: LiveProvider;
+};

package/src/contexts/notification/index.tsx

@@ -1,6 +1,6 @@
-import React, { createContext } from "react";
+import React, { createContext, PropsWithChildren } from "react";
 
-import { INotificationContext } from "./INotificationContext";
+import { INotificationContext } from "./types";
 
 /** @deprecated default value for notification context has no use and is an empty object.  */
 export const defaultNotificationProvider: INotificationContext = {};
@@ -8,13 +8,11 @@ export const defaultNotificationProvider: INotificationContext = {};
 export const NotificationContext = createContext<INotificationContext>({});
 
 export const NotificationContextProvider: React.FC<
-    INotificationContext & {
-        children?: React.ReactNode;
-    }
+  PropsWithChildren<INotificationContext>
 > = ({ open, close, children }) => {
-    return (
-        <NotificationContext.Provider value={{ open, close }}>
-            {children}
-        </NotificationContext.Provider>
-    );
+  return (
+    <NotificationContext.Provider value={{ open, close }}>
+      {children}
+    </NotificationContext.Provider>
+  );
 };