@refinedev/core 4.0.0

package/src/index.tsx

@@ -0,0 +1,120 @@
+export * from "./components";
+export * from "./hooks";
+
+export {
+    Action,
+    ActionWithPage,
+    AccessControlProvider,
+    AuditLogProvider,
+    LegacyAuthProvider,
+    AuthBindings,
+    BaseKey,
+    BaseRecord,
+    CanParams,
+    CanReturnType,
+    ConditionalFilter,
+    CreateManyResponse,
+    CreateResponse,
+    CrudFilter,
+    CrudFilters,
+    CrudOperators,
+    CrudSort,
+    CrudSorting,
+    CustomResponse,
+    DeleteManyResponse,
+    DeleteOneResponse,
+    FormAction,
+    GetListResponse,
+    GetManyResponse,
+    GetOneResponse,
+    HttpError,
+    LayoutProps,
+    LiveEvent,
+    LiveModeProps,
+    LogicalFilter,
+    LogParams,
+    MapDataFn,
+    MetaQuery,
+    MetaDataQuery,
+    MutationMode,
+    NotificationProvider,
+    OpenNotificationParams,
+    Option,
+    Pagination,
+    PromptProps,
+    RedirectionTypes,
+    RedirectAction,
+    ResourceErrorRouterParams,
+    ResourceProps,
+    ResourceRouterParams,
+    RouteAction,
+    SortOrder,
+    SuccessErrorNotification,
+    TitleProps,
+    TranslationProvider,
+    UpdateManyResponse,
+    UpdateResponse,
+    I18nProvider,
+    IAccessControlContext,
+    ILegacyAuthContext,
+    IDataContextProvider as DataProvider,
+    ILiveContext as LiveProvider,
+    ILog,
+    ILogData,
+    ILoginForm,
+    INotificationContext,
+    IResourceComponents,
+    IResourceComponentsProps,
+    IResourceContext as ResourceProvider,
+    ITranslationContext,
+    IResourceItem,
+    IRouterProvider,
+    ITreeMenu,
+    IQueryKeys,
+    AccessControlBindings,
+    DataBindings,
+    i18nBindings,
+    LiveBindings,
+    NotificationsBindings,
+    ResourceBindings,
+    RouterBindings,
+    ParseResponse,
+    ParsedParams,
+    GoConfig,
+    BackFunction,
+    GoFunction,
+    ParseFunction,
+    Prettify,
+    FormWithSyncWithLocationParams,
+} from "./interfaces";
+
+// all auth types
+export * from "./interfaces/auth";
+
+export {
+    getDefaultFilter,
+    getDefaultSortOrder,
+    parseTableParams,
+    parseTableParamsFromQuery,
+    setInitialFilters,
+    setInitialSorters,
+    stringifyTableParams,
+    unionFilters,
+    unionSorters,
+} from "./definitions/table";
+export {
+    createTreeView,
+    handleUseParams,
+    importCSVMapper,
+    routeGenerator,
+    userFriendlyResourceName,
+    getNextPageParam,
+    getPreviousPageParam,
+    pickNotDeprecated,
+    legacyResourceTransform,
+    matchResourceFromRoute,
+    useActiveAuthProvider,
+} from "./definitions/helpers";
+export { file2Base64 } from "./definitions/upload";
+
+export { ResourceContext } from "./contexts/resource/index";

package/src/interfaces/HttpError.ts

@@ -0,0 +1,4 @@
+export interface HttpError extends Record<string, any> {
+    message: string;
+    statusCode: number;
+}

package/src/interfaces/actions.ts

@@ -0,0 +1,16 @@
+export type Action = "create" | "edit" | "list" | "show" | "clone";
+
+export type RouteAction = Exclude<Action, "list"> | undefined;
+
+export type RedirectAction =
+    | Extract<Action, "list" | "show" | "edit" | "create">
+    | false;
+
+/**
+ * @deprecated use RedirectAction type instead
+ */
+export type RedirectionTypes = RedirectAction;
+
+export type FormAction = Extract<Action, "create" | "edit" | "clone">;
+
+export type ActionWithPage = Extract<Action, "show" | "create" | "edit">;

package/src/interfaces/auditLog/index.ts

@@ -0,0 +1 @@
+export * from "./logData";

package/src/interfaces/auditLog/logData.ts

@@ -0,0 +1,15 @@
+import { BaseKey } from "..";
+
+export interface 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>[];

package/src/interfaces/auth.tsx

@@ -0,0 +1,192 @@
+import React, { PropsWithChildren } from "react";
+
+export type OAuthProvider = {
+    name: string;
+    icon?: React.ReactNode;
+    label?: string;
+};
+
+export interface LoginFormTypes {
+    email?: string;
+    password?: string;
+    remember?: boolean;
+    providerName?: string;
+    redirectPath?: string;
+}
+
+export interface RegisterFormTypes {
+    email?: string;
+    password?: string;
+    providerName?: string;
+}
+
+export interface ForgotPasswordFormTypes {
+    email?: string;
+}
+
+export interface UpdatePasswordFormTypes {
+    password?: string;
+    confirmPassword?: string;
+}
+
+/**
+ * This should be the base type for `AuthPage` component implementations in UI integrations.
+ */
+export type AuthPageProps<
+    TWrapperProps extends {} = Record<keyof any, unknown>,
+    TContentProps extends {} = Record<keyof any, unknown>,
+    TFormProps extends {} = Record<keyof any, unknown>,
+> = (
+    | PropsWithChildren<{
+          /**
+           * @description The type of the auth page.
+           * @default "login"
+           * @optional
+           */
+          type?: "login";
+          /**
+           * @description Providers array for login with third party auth services.
+           * @type [OAuthProvider](/docs/api-reference/core/components/auth-page/#interface)
+           * @optional
+           */
+          providers?: OAuthProvider[];
+          /**
+           * @description Render a redirect to login page button node. If set to false, login button will not be rendered.
+           * @default `"/login"`
+           * @optional
+           */
+          loginLink?: React.ReactNode;
+          /**
+           * @description Render a redirect to register page button node. If set to false, register button will not be rendered.
+           * @default `"/register"`
+           * @optional
+           */
+          registerLink?: React.ReactNode;
+          /**
+           * @description Render a redirect to forgot password page button node. If set to false, forgot password button will not be rendered.
+           * @default `"/forgot-password"`
+           * @optional
+           */
+          forgotPasswordLink?: React.ReactNode;
+          /**
+           * @description Render a remember me button node. If set to false, remember me button will not be rendered.
+           * @optional
+           */
+          rememberMe?: React.ReactNode;
+      }>
+    | PropsWithChildren<{
+          /**
+           * @description The type of the auth page.
+           * @optional
+           */
+          type: "register";
+          /**
+           * @description Providers array for login with third party auth services.
+           * @optional
+           */
+          providers?: OAuthProvider[];
+      }>
+    | PropsWithChildren<{
+          /**
+           * @description The type of the auth page.
+           * @optional
+           */
+          type: "forgotPassword";
+          /**
+           * @description render a redirect to login page button node. If set to false, login button will not be rendered.
+           * @optional
+           */
+          loginLink?: React.ReactNode;
+      }>
+    | PropsWithChildren<{
+          /**
+           * @description The type of the auth page.
+           * @optional
+           */
+          type: "updatePassword";
+      }>
+) & {
+    /**
+     * @description The props that will be passed to the wrapper component.
+     * @optional
+     */
+    wrapperProps?: TWrapperProps;
+    /**
+     * @description The props that will be passed to the content component.
+     * @optional
+     */
+    contentProps?: TContentProps;
+    /**
+     * @description This method gives you the ability to render a custom content node.
+     * @optional
+     */
+    renderContent?: (content: React.ReactNode) => React.ReactNode;
+    /**
+     * @description Can be used to pass additional properties for the `Form`
+     * @optional
+     */
+    formProps?: TFormProps;
+};
+
+/**
+ * This should be the base type for `AuthPage` `Login` component implementations in UI integrations.
+ */
+export type LoginPageProps<
+    TWrapperProps extends {} = Record<keyof any, unknown>,
+    TContentProps extends {} = Record<keyof any, unknown>,
+    TFormProps extends {} = Record<keyof any, unknown>,
+> = PropsWithChildren<{
+    providers?: OAuthProvider[];
+    registerLink?: React.ReactNode;
+    forgotPasswordLink?: React.ReactNode;
+    rememberMe?: React.ReactNode;
+    wrapperProps?: TWrapperProps;
+    renderContent?: (content: React.ReactNode) => React.ReactNode;
+    contentProps?: TContentProps;
+    formProps?: TFormProps;
+}>;
+
+/**
+ * This should be the base type for `AuthPage` `Register` component implementations in UI integrations.
+ */
+export type RegisterPageProps<
+    TWrapperProps extends {} = Record<keyof any, unknown>,
+    TContentProps extends {} = Record<keyof any, unknown>,
+    TFormProps extends {} = Record<keyof any, unknown>,
+> = PropsWithChildren<{
+    providers?: OAuthProvider[];
+    loginLink?: React.ReactNode;
+    wrapperProps?: TWrapperProps;
+    renderContent?: (content: React.ReactNode) => React.ReactNode;
+    contentProps?: TContentProps;
+    formProps?: TFormProps;
+}>;
+
+/**
+ * This should be the base type for `AuthPage` `Reset Password` component implementations in UI integrations.
+ */
+export type ForgotPasswordPageProps<
+    TWrapperProps extends {} = Record<keyof any, unknown>,
+    TContentProps extends {} = Record<keyof any, unknown>,
+    TFormProps extends {} = Record<keyof any, unknown>,
+> = PropsWithChildren<{
+    loginLink?: React.ReactNode;
+    wrapperProps?: TWrapperProps;
+    renderContent?: (content: React.ReactNode) => React.ReactNode;
+    contentProps?: TContentProps;
+    formProps?: TFormProps;
+}>;
+
+/**
+ * This should be the base type for `AuthPage` `Update Password` component implementations in UI integrations.
+ */
+export type UpdatePasswordPageProps<
+    TWrapperProps extends {} = Record<keyof any, unknown>,
+    TContentProps extends {} = Record<keyof any, unknown>,
+    TFormProps extends {} = Record<keyof any, unknown>,
+> = PropsWithChildren<{
+    wrapperProps?: TWrapperProps;
+    renderContent?: (content: React.ReactNode) => React.ReactNode;
+    contentProps?: TContentProps;
+    formProps?: TFormProps;
+}>;

package/src/interfaces/bindings/access-control.ts

@@ -0,0 +1,53 @@
+/**
+ * @author aliemir
+ *
+ * `AccessControlBindings` 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 { IResourceItem } from "@contexts/resource";
+import { BaseKey } from "src";
+
+export type CanParams = {
+    /**
+     * Resource name for API data interactions
+     */
+    resource: string;
+    /**
+     * Intenden 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;
+        id?: BaseKey;
+        [key: string]: unknown;
+    };
+};
+
+export type CanResponse = {
+    can: boolean;
+    reason?: string;
+    [key: string]: unknown;
+};
+
+export type AccessControlBindings = {
+    can: (params: CanParams) => Promise<CanResponse>;
+};

package/src/interfaces/bindings/auth.ts

@@ -0,0 +1,72 @@
+/**
+ * @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.
+ */
+
+export type CheckResponse = {
+    authenticated: boolean;
+    redirectTo?: string;
+    logout?: boolean;
+    error?: Error;
+};
+
+export type OnErrorResponse = {
+    redirectTo?: string;
+    logout?: boolean;
+    error?: Error;
+};
+
+export type AuthActionResponse = {
+    success: boolean;
+    redirectTo?: string;
+    error?: Error;
+    [key: string]: unknown;
+};
+
+export type PermissionResponse = unknown;
+
+export type IdentityResponse = unknown;
+
+export type AuthBindings = {
+    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?: any) => Promise<PermissionResponse>;
+    getIdentity?: (params?: any) => Promise<IdentityResponse>;
+};
+
+export interface IAuthBindingsContext extends Partial<AuthBindings> {
+    isProvided: boolean;
+}

package/src/interfaces/bindings/data.ts

@@ -0,0 +1,18 @@
+/**
+ * @author aliemir
+ *
+ * There's no change between `DataBindings` and `DataProvider` interfaces.
+ *
+ * But we should probably throw a soft error to the console if there's no `default` key in `MultipleDataBinding`.
+ */
+
+import { IDataContext } from "@contexts/data/IDataContext";
+
+export type SingleDataBinding = IDataContext;
+
+export type MultipleDataBinding = {
+    default: IDataContext;
+    [key: string]: IDataContext;
+};
+
+export type DataBindings = SingleDataBinding | MultipleDataBinding;

package/src/interfaces/bindings/i18n.ts

@@ -0,0 +1,29 @@
+/**
+ * @author aliemir
+ *
+ * i18n bindings are same with the `i18nProvider` interface.
+ *
+ * We should probably enforce the three or single parameter use in our hooks.
+ *
+ * Currently, we cover the `key, options`, `key, defaultMessage`, `key, options, defaultMessage` usages internally in i18n hooks.
+ * Which creates an unnecessary confusion in the codebase.
+ */
+
+export type TranslateFunction = (
+    key: string,
+    options?: unknown,
+    defaultMessage?: string,
+) => string;
+
+export type ChangeLocaleFunction = (
+    locale: string,
+    options?: unknown,
+) => Promise<unknown> | unknown;
+
+export type GetLocaleFunction = () => string;
+
+export type i18nBindings = {
+    translate: TranslateFunction;
+    changeLocale: ChangeLocaleFunction;
+    getLocale: GetLocaleFunction;
+};

package/src/interfaces/bindings/index.ts

@@ -0,0 +1,24 @@
+export { AccessControlBindings } from "./access-control";
+export {
+    AuthBindings,
+    IAuthBindingsContext,
+    AuthActionResponse,
+    IdentityResponse,
+    CheckResponse,
+    OnErrorResponse,
+    PermissionResponse,
+} from "./auth";
+export { DataBindings } from "./data";
+export { i18nBindings } from "./i18n";
+export { LiveBindings } from "./live";
+export { NotificationsBindings } from "./notifications";
+export { ResourceBindings } from "./resource";
+export {
+    RouterBindings,
+    ParseResponse,
+    ParsedParams,
+    GoConfig,
+    BackFunction,
+    GoFunction,
+    ParseFunction,
+} from "./router";

package/src/interfaces/bindings/live.ts

@@ -0,0 +1,56 @@
+/**
+ * @author aliemir
+ *
+ * There's a small change in the `LiveBindings` interface, we've defined the `params` property of `subscribe` function
+ * as a combination of `LiveCommonParams` and `LiveListParams & LiveOneParams & LiveManyParams`.
+ * which creates a bit of a confusion because in `list` type we don't need `id` or `ids` and in `one` type we don't need `ids`.
+ * There should be an update like below to make it more clear in usage.
+ *
+ * A small but kinda important change for the consistency of the codebase.
+ */
+
+import {
+    BaseKey,
+    CrudFilters,
+    CrudSorting,
+    LiveEvent,
+    MetaQuery,
+    Pagination,
+} from "src";
+
+export type LiveListParams = {
+    resource?: string;
+    pagination?: Pagination;
+    hasPagination?: boolean;
+    sort?: CrudSorting;
+    filters?: CrudFilters;
+    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;
+};
+
+export type LiveBindings = {
+    publish?: (event: LiveEvent) => void;
+    subscribe: (options: {
+        channel: string;
+        types: Array<LiveEvent["type"]>;
+        callback: (event: LiveEvent) => void;
+        params?: LiveCommonParams &
+            (LiveListParams | LiveOneParams | LiveManyParams);
+    }) => unknown;
+    unsubscribe: (subscription: unknown) => void;
+};

package/src/interfaces/bindings/notifications.ts

@@ -0,0 +1,25 @@
+/**
+ * @author aliemir
+ *
+ * While switching to NotificationBindings, we can try to experiment and explore the idea of
+ * user controlled undoable notifications.
+ *
+ * Currently, we're handling the undoable notifications internally by updating the existing notification.
+ * This is leading to some uncontrollable behaviors in the notification bindings.
+ *
+ * While leaving the control might not be possible, we can still try it at least. :)
+ */
+
+export interface OpenNotificationParams {
+    key?: string;
+    message: string;
+    type: "success" | "error" | "progress";
+    description?: string;
+    cancelMutation?: () => void;
+    undoableTimeout?: number;
+}
+
+export type NotificationsBindings = {
+    open: (params: OpenNotificationParams) => void;
+    close: (key: string) => void;
+};