@strato-admin/core 0.1.0 → 0.3.0

package/dist/ra-core/src/controller/create/useCreateController.js

@@ -0,0 +1,149 @@
+import { useCallback } from 'react';
+import { useAuthenticated, useRequireAccess } from '../../auth';
+import { HttpError, useCreate, } from '../../dataProvider';
+import { useRedirect } from '../../routing';
+import { useNotify } from '../../notification';
+import { useMutationMiddlewares, } from '../saveContext';
+import { useTranslate } from '../../i18n';
+import { useResourceContext, useResourceDefinition, useGetResourceLabel, } from '../../core';
+/**
+ * Prepare data for the Create view
+ *
+ * @param {Object} props The props passed to the Create component.
+ *
+ * @return {Object} controllerProps Fetched data and callbacks for the Create view
+ *
+ * @example
+ *
+ * import { useCreateController } from 'react-admin';
+ * import CreateView from './CreateView';
+ *
+ * const MyCreate = props => {
+ *     const controllerProps = useCreateController(props);
+ *     return <CreateView {...controllerProps} {...props} />;
+ * }
+ */
+export const useCreateController = (props = {}) => {
+    const { disableAuthentication, record, redirect: redirectTo, transform, mutationMode = 'pessimistic', mutationOptions = {}, } = props;
+    const resource = useResourceContext(props);
+    if (!resource) {
+        throw new Error('useCreateController requires a non-empty resource prop or context');
+    }
+    const { isPending: isPendingAuthenticated } = useAuthenticated({
+        enabled: !disableAuthentication,
+    });
+    const { isPending: isPendingCanAccess } = useRequireAccess({
+        action: 'create',
+        resource,
+        enabled: !disableAuthentication && !isPendingAuthenticated,
+    });
+    const { hasEdit, hasShow } = useResourceDefinition(props);
+    const finalRedirectTo = redirectTo ?? getDefaultRedirectRoute(hasShow, hasEdit);
+    const translate = useTranslate();
+    const notify = useNotify();
+    const redirect = useRedirect();
+    const { onSuccess, onError, meta, ...otherMutationOptions } = mutationOptions;
+    const { registerMutationMiddleware, getMutateWithMiddlewares, unregisterMutationMiddleware, } = useMutationMiddlewares();
+    const [create, { isPending: saving }] = useCreate(resource, undefined, {
+        onSuccess: async (...args) => {
+            if (onSuccess) {
+                return onSuccess(...args);
+            }
+            const [data] = args;
+            notify(`resources.${resource}.notifications.created`, {
+                type: 'info',
+                messageArgs: {
+                    smart_count: 1,
+                    _: translate(`ra.notification.created`, {
+                        smart_count: 1,
+                    }),
+                },
+                undoable: mutationMode === 'undoable',
+            });
+            redirect(finalRedirectTo, resource, data.id, data);
+        },
+        onError: (...args) => {
+            if (onError) {
+                return onError(...args);
+            }
+            const [error] = args;
+            // Don't trigger a notification if this is a validation error
+            // (notification will be handled by the useNotifyIsFormInvalid hook)
+            const validationErrors = error?.body?.errors;
+            const hasValidationErrors = !!validationErrors && Object.keys(validationErrors).length > 0;
+            if (!hasValidationErrors || mutationMode !== 'pessimistic') {
+                notify(typeof error === 'string'
+                    ? error
+                    : error.message ||
+                        "strato.notification.http_error', {
+                    type: 'error',
+                    messageArgs: {
+                        _: typeof error === 'string'
+                            ? error
+                            : error instanceof Error ||
+                                (typeof error === 'object' &&
+                                    error !== null &&
+                                    error.hasOwnProperty('message'))
+                                ? // @ts-ignore
+                                    error.message
+                                : undefined,
+                    },
+                });
+            }
+        },
+        ...otherMutationOptions,
+        mutationMode,
+        returnPromise: mutationMode === 'pessimistic',
+        getMutateWithMiddlewares,
+    });
+    const save = useCallback((data, { onSuccess: onSuccessFromSave, onError: onErrorFromSave, transform: transformFromSave, meta: metaFromSave, } = {}) => Promise.resolve(transformFromSave
+        ? transformFromSave(data)
+        : transform
+            ? transform(data)
+            : data).then(async (data) => {
+        try {
+            await create(resource, { data, meta: metaFromSave ?? meta }, {
+                onError: onErrorFromSave,
+                onSuccess: onSuccessFromSave,
+            });
+        }
+        catch (error) {
+            if ((error instanceof HttpError ||
+                (typeof error === 'object' &&
+                    error !== null &&
+                    error.hasOwnProperty('body'))) &&
+                error.body?.errors != null) {
+                return error.body.errors;
+            }
+        }
+    }), [create, meta, resource, transform]);
+    const getResourceLabel = useGetResourceLabel();
+    const defaultTitle = translate(`resources.${resource}.page.create`, {
+        _: translate("strato.page.create', {
+            name: getResourceLabel(resource, 1),
+        }),
+    });
+    return {
+        isFetching: false,
+        isLoading: false,
+        isPending: disableAuthentication ? false : isPendingCanAccess,
+        mutationMode,
+        saving,
+        defaultTitle,
+        save,
+        record,
+        resource,
+        redirect: finalRedirectTo,
+        registerMutationMiddleware,
+        unregisterMutationMiddleware,
+    };
+};
+const getDefaultRedirectRoute = (hasShow, hasEdit) => {
+    if (hasEdit) {
+        return 'edit';
+    }
+    if (hasShow) {
+        return 'show';
+    }
+    return 'list';
+};

package/dist/ra-core/src/controller/edit/EditBase.d.ts

@@ -0,0 +1,41 @@
+import { ReactNode } from 'react';
+import { RaRecord } from '../../types';
+import { EditControllerProps, EditControllerResult } from './useEditController';
+/**
+ * Call useEditController and put the value in a EditContext
+ *
+ * Base class for <Edit> components, without UI.
+ *
+ * Accepts any props accepted by useEditController:
+ * - id: The record identifier
+ * - resource: The resource
+ *
+ * @example // Custom edit layout
+ *
+ * const PostEdit = () => (
+ *     <EditBase resource="posts">
+ *         <Grid container>
+ *             <Grid item xs={8}>
+ *                 <SimpleForm>
+ *                     ...
+ *                 </SimpleForm>
+ *             </Grid>
+ *             <Grid item xs={4}>
+ *                 Edit instructions...
+ *             </Grid>
+ *         </Grid>
+ *         <div>
+ *             Post related links...
+ *         </div>
+ *     </EditBase>
+ * );
+ */
+export declare const EditBase: <RecordType extends RaRecord = any, ErrorType = Error>({ authLoading, loading, offline, error, redirectOnError, children, render, ...props }: EditBaseProps<RecordType, ErrorType>) => import("react/jsx-runtime").JSX.Element;
+export interface EditBaseProps<RecordType extends RaRecord = RaRecord, ErrorType = Error> extends EditControllerProps<RecordType, ErrorType> {
+    authLoading?: ReactNode;
+    loading?: ReactNode;
+    offline?: ReactNode;
+    error?: ReactNode;
+    children?: ReactNode;
+    render?: (props: EditControllerResult<RecordType, ErrorType>) => ReactNode;
+}

package/dist/ra-core/src/controller/edit/EditBase.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEditController, } from './useEditController';
+import { EditContextProvider } from './EditContextProvider';
+import { OptionalResourceContextProvider } from '../../core';
+import { useIsAuthPending } from '../../auth';
+/**
+ * Call useEditController and put the value in a EditContext
+ *
+ * Base class for <Edit> components, without UI.
+ *
+ * Accepts any props accepted by useEditController:
+ * - id: The record identifier
+ * - resource: The resource
+ *
+ * @example // Custom edit layout
+ *
+ * const PostEdit = () => (
+ *     <EditBase resource="posts">
+ *         <Grid container>
+ *             <Grid item xs={8}>
+ *                 <SimpleForm>
+ *                     ...
+ *                 </SimpleForm>
+ *             </Grid>
+ *             <Grid item xs={4}>
+ *                 Edit instructions...
+ *             </Grid>
+ *         </Grid>
+ *         <div>
+ *             Post related links...
+ *         </div>
+ *     </EditBase>
+ * );
+ */
+export const EditBase = ({ authLoading, loading, offline, error, redirectOnError, children, render, ...props }) => {
+    const hasError = error !== false && error !== undefined;
+    const controllerProps = useEditController({
+        ...props,
+        redirectOnError: redirectOnError ?? (hasError ? false : undefined),
+    });
+    const isAuthPending = useIsAuthPending({
+        resource: controllerProps.resource,
+        action: 'edit',
+    });
+    if (!render && !children) {
+        throw new Error("<EditBase> requires either a 'render' prop or 'children' prop");
+    }
+    const { isPaused, isPending, error: errorState } = controllerProps;
+    const showAuthLoading = isAuthPending &&
+        !props.disableAuthentication &&
+        authLoading !== false &&
+        authLoading !== undefined;
+    const showLoading = !isPaused &&
+        ((!props.disableAuthentication && isAuthPending) || isPending) &&
+        loading !== false &&
+        loading !== undefined;
+    const showOffline = isPaused && isPending && offline !== false && offline !== undefined;
+    const showError = errorState && hasError;
+    return (
+    // We pass props.resource here as we don't need to create a new ResourceContext if the props is not provided
+    _jsx(OptionalResourceContextProvider, { value: props.resource, children: _jsx(EditContextProvider, { value: controllerProps, children: showAuthLoading
+                ? authLoading
+                : showLoading
+                    ? loading
+                    : showOffline
+                        ? offline
+                        : showError
+                            ? error
+                            : render
+                                ? render(controllerProps)
+                                : children }) }));
+};

package/dist/ra-core/src/controller/edit/EditContext.d.ts

@@ -0,0 +1,20 @@
+import { EditControllerResult } from './useEditController';
+/**
+ * Context to store the result of the useEditController() hook.
+ *
+ * Use the useEditContext() hook to read the context. That's what the Edit components do in react-admin.
+ *
+ * @example
+ *
+ * import { useEditController, EditContextProvider } from '@strato-admin/ra-core';
+ *
+ * const Edit = props => {
+ *     const controllerProps = useEditController(props);
+ *     return (
+ *         <EditContextProvider value={controllerProps}>
+ *             ...
+ *         </EditContextProvider>
+ *     );
+ * };
+ */
+export declare const EditContext: import("react").Context<EditControllerResult | null>;

package/dist/ra-core/src/controller/edit/EditContext.js

@@ -0,0 +1,21 @@
+import { createContext } from 'react';
+/**
+ * Context to store the result of the useEditController() hook.
+ *
+ * Use the useEditContext() hook to read the context. That's what the Edit components do in react-admin.
+ *
+ * @example
+ *
+ * import { useEditController, EditContextProvider } from '@strato-admin/ra-core';
+ *
+ * const Edit = props => {
+ *     const controllerProps = useEditController(props);
+ *     return (
+ *         <EditContextProvider value={controllerProps}>
+ *             ...
+ *         </EditContextProvider>
+ *     );
+ * };
+ */
+export const EditContext = createContext(null);
+EditContext.displayName = 'EditContext';

package/dist/ra-core/src/controller/edit/EditContextProvider.d.ts

@@ -0,0 +1,29 @@
+import { ReactNode } from 'react';
+import { EditControllerResult } from './useEditController';
+/**
+ * Create an Edit Context.
+ *
+ * @example
+ *
+ * const MyEdit = (props) => {
+ *     const controllerProps = useEditController(props);
+ *     return (
+ *         <EditContextProvider value={controllerProps}>
+ *             <MyEditView>
+ *         </EditContextProvider>
+ *     );
+ * };
+ *
+ * const MyEditView = () => {
+ *     const record = useRecordContext();
+ *     // or, to rerender only when the save operation change but not data
+ *     const { saving } = useEditContext();
+ * }
+ *
+ * @see EditContext
+ * @see RecordContext
+ */
+export declare const EditContextProvider: ({ children, value, }: {
+    children: ReactNode;
+    value: EditControllerResult<any, any>;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/ra-core/src/controller/edit/EditContextProvider.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RecordContextProvider } from '../record';
+import { SaveContextProvider, usePickSaveContext } from '../saveContext';
+import { EditContext } from './EditContext';
+/**
+ * Create an Edit Context.
+ *
+ * @example
+ *
+ * const MyEdit = (props) => {
+ *     const controllerProps = useEditController(props);
+ *     return (
+ *         <EditContextProvider value={controllerProps}>
+ *             <MyEditView>
+ *         </EditContextProvider>
+ *     );
+ * };
+ *
+ * const MyEditView = () => {
+ *     const record = useRecordContext();
+ *     // or, to rerender only when the save operation change but not data
+ *     const { saving } = useEditContext();
+ * }
+ *
+ * @see EditContext
+ * @see RecordContext
+ */
+export const EditContextProvider = ({ children, value, }) => (_jsx(EditContext.Provider, { value: value, children: _jsx(SaveContextProvider, { value: usePickSaveContext(value), children: _jsx(RecordContextProvider, { value: value && value.record, children: children }) }) }));

package/dist/ra-core/src/controller/edit/EditController.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { EditControllerProps, EditControllerResult } from './useEditController';
+import { RaRecord } from '../../types';
+/**
+ * Render prop version of the useEditController hook
+ *
+ * @see useEditController
+ * @example
+ *
+ * const EditView = () => <div>...</div>
+ * const MyEdit = props => (
+ *     <EditController {...props}>
+ *         {controllerProps => <EditView {...controllerProps} {...props} />}
+ *     </EditController>
+ * );
+ */
+export declare const EditController: <RecordType extends RaRecord = any, ErrorType = Error>({ children, ...props }: {
+    children: (params: EditControllerResult<RecordType, ErrorType>) => ReactNode;
+} & EditControllerProps<RecordType, ErrorType>) => ReactNode;

package/dist/ra-core/src/controller/edit/EditController.js

@@ -0,0 +1,18 @@
+import { useEditController, } from './useEditController';
+/**
+ * Render prop version of the useEditController hook
+ *
+ * @see useEditController
+ * @example
+ *
+ * const EditView = () => <div>...</div>
+ * const MyEdit = props => (
+ *     <EditController {...props}>
+ *         {controllerProps => <EditView {...controllerProps} {...props} />}
+ *     </EditController>
+ * );
+ */
+export const EditController = ({ children, ...props }) => {
+    const controllerProps = useEditController(props);
+    return children(controllerProps);
+};

package/dist/ra-core/src/controller/edit/index.d.ts

@@ -0,0 +1,6 @@
+export * from './EditBase';
+export * from './EditContext';
+export * from './EditContextProvider';
+export * from './EditController';
+export * from './useEditContext';
+export * from './useEditController';

package/dist/ra-core/src/controller/edit/index.js

@@ -0,0 +1,6 @@
+export * from './EditBase';
+export * from './EditContext';
+export * from './EditContextProvider';
+export * from './EditController';
+export * from './useEditContext';
+export * from './useEditController';

package/dist/ra-core/src/controller/edit/useEditContext.d.ts

@@ -0,0 +1,12 @@
+import { RaRecord } from '../../types';
+import { EditControllerResult } from './useEditController';
+/**
+ * Hook to read the edit controller props from the EditContext.
+ *
+ * Used within a <EditContextProvider> (e.g. as a descendent of <Edit>).
+ *
+ * @returns {EditControllerResult} edit controller props
+ *
+ * @see useEditController for how it is filled
+ */
+export declare const useEditContext: <RecordType extends RaRecord = any, ErrorType = Error>() => EditControllerResult<RecordType, ErrorType>;

package/dist/ra-core/src/controller/edit/useEditContext.js

@@ -0,0 +1,18 @@
+import { useContext } from 'react';
+import { EditContext } from './EditContext';
+/**
+ * Hook to read the edit controller props from the EditContext.
+ *
+ * Used within a <EditContextProvider> (e.g. as a descendent of <Edit>).
+ *
+ * @returns {EditControllerResult} edit controller props
+ *
+ * @see useEditController for how it is filled
+ */
+export const useEditContext = () => {
+    const context = useContext(EditContext);
+    if (!context) {
+        throw new Error('useEditContext must be used inside an EditContextProvider');
+    }
+    return context;
+};

package/dist/ra-core/src/controller/edit/useEditController.d.ts

@@ -0,0 +1,72 @@
+import { RaRecord, MutationMode, TransformData } from '../../types';
+import { RedirectionSideEffect } from '../../routing';
+import { UseGetOneHookValue, UseGetOneOptions, UseUpdateOptions } from '../../dataProvider';
+import { SaveContextValue } from '../saveContext';
+/**
+ * Prepare data for the Edit view.
+ *
+ * useEditController does a few things:
+ * - it grabs the id from the URL and the resource name from the ResourceContext,
+ * - it fetches the record via useGetOne,
+ * - it prepares the page title.
+ *
+ * @param {Object} props The props passed to the Edit component.
+ *
+ * @return {Object} controllerProps Fetched data and callbacks for the Edit view
+ *
+ * @example
+ *
+ * import { useEditController } from 'react-admin';
+ * import EditView from './EditView';
+ *
+ * const MyEdit = () => {
+ *     const controllerProps = useEditController({ resource: 'posts', id: 123 });
+ *     return <EditView {...controllerProps} {...props} />;
+ * }
+ */
+export declare const useEditController: <RecordType extends RaRecord = any, ErrorType = Error>(props?: EditControllerProps<RecordType, ErrorType>) => EditControllerResult<RecordType, ErrorType>;
+export interface EditControllerProps<RecordType extends RaRecord = any, ErrorType = Error> {
+    disableAuthentication?: boolean;
+    id?: RecordType['id'];
+    mutationMode?: MutationMode;
+    mutationOptions?: UseUpdateOptions<RecordType, ErrorType>;
+    queryOptions?: UseGetOneOptions<RecordType, ErrorType>;
+    redirect?: RedirectionSideEffect;
+    redirectOnError?: RedirectionSideEffect;
+    resource?: string;
+    transform?: TransformData;
+    [key: string]: any;
+}
+export interface EditControllerBaseResult<RecordType extends RaRecord = any> extends SaveContextValue<RecordType> {
+    defaultTitle?: string;
+    isFetching: boolean;
+    isLoading: boolean;
+    isPaused?: boolean;
+    isPlaceholderData?: boolean;
+    refetch: UseGetOneHookValue<RecordType>['refetch'];
+    redirect: RedirectionSideEffect;
+    redirectOnError: RedirectionSideEffect;
+    resource: string;
+    saving: boolean;
+}
+export interface EditControllerLoadingResult<RecordType extends RaRecord = any> extends EditControllerBaseResult<RecordType> {
+    record: undefined;
+    error: null;
+    isPending: true;
+}
+export interface EditControllerLoadingErrorResult<RecordType extends RaRecord = any, TError = Error> extends EditControllerBaseResult<RecordType> {
+    record: undefined;
+    error: TError;
+    isPending: false;
+}
+export interface EditControllerRefetchErrorResult<RecordType extends RaRecord = any, TError = Error> extends EditControllerBaseResult<RecordType> {
+    record: RecordType;
+    error: TError;
+    isPending: false;
+}
+export interface EditControllerSuccessResult<RecordType extends RaRecord = any> extends EditControllerBaseResult<RecordType> {
+    record: RecordType;
+    error: null;
+    isPending: false;
+}
+export type EditControllerResult<RecordType extends RaRecord = any, ErrorType = Error> = EditControllerLoadingResult<RecordType> | EditControllerLoadingErrorResult<RecordType, ErrorType> | EditControllerRefetchErrorResult<RecordType, ErrorType> | EditControllerSuccessResult<RecordType>;