@strato-admin/faker-ecommerce 0.1.0 → 0.3.0

package/dist/ra-core/src/auth/usePermissions.d.ts

@@ -0,0 +1,41 @@
+import { QueryObserverResult, UseQueryOptions } from '@tanstack/react-query';
+/**
+ * Hook for getting user permissions
+ *
+ * Calls the authProvider.getPermissions() method using react-query.
+ * If the authProvider returns a rejected promise, returns empty permissions.
+ *
+ * The return value updates according to the request state:
+ *
+ * - start: { isPending: true }
+ * - success: { permissions: [any], isPending: false }
+ * - error: { error: [error from provider], isPending: false }
+ *
+ * Useful to enable features based on user permissions
+ *
+ * @param {Object} params Any params you want to pass to the authProvider
+ *
+ * @returns The current auth check state. Destructure as { permissions, error, isPending, refetch }.
+ *
+ * @example
+ *     import { usePermissions } from 'react-admin';
+ *
+ *     const PostDetail = () => {
+ *         const { isPending, permissions } = usePermissions();
+ *         if (!isPending && permissions == 'editor') {
+ *             return <PostEdit />
+ *         } else {
+ *             return <PostShow />
+ *         }
+ *     };
+ */
+declare const usePermissions: <PermissionsType = any, ErrorType = Error>(params?: {}, queryParams?: UsePermissionsOptions<PermissionsType, ErrorType>) => UsePermissionsResult<PermissionsType, ErrorType>;
+export default usePermissions;
+export interface UsePermissionsOptions<PermissionsType = any, ErrorType = Error> extends Omit<UseQueryOptions<PermissionsType, ErrorType>, 'queryKey' | 'queryFn'> {
+    onSuccess?: (data: PermissionsType) => void;
+    onError?: (err: ErrorType) => void;
+    onSettled?: (data?: PermissionsType, error?: ErrorType | null) => void;
+}
+export type UsePermissionsResult<PermissionsType = any, ErrorType = Error> = QueryObserverResult<PermissionsType, ErrorType> & {
+    permissions: PermissionsType | undefined;
+};

package/dist/ra-core/src/auth/usePermissions.js

@@ -0,0 +1,123 @@
+import { useEffect, useMemo } from 'react';
+import { useQuery, } from '@tanstack/react-query';
+import useAuthProvider from './useAuthProvider';
+import useLogoutIfAccessDenied from './useLogoutIfAccessDenied';
+import { useEvent } from '../util';
+const emptyParams = {};
+/**
+ * Hook for getting user permissions
+ *
+ * Calls the authProvider.getPermissions() method using react-query.
+ * If the authProvider returns a rejected promise, returns empty permissions.
+ *
+ * The return value updates according to the request state:
+ *
+ * - start: { isPending: true }
+ * - success: { permissions: [any], isPending: false }
+ * - error: { error: [error from provider], isPending: false }
+ *
+ * Useful to enable features based on user permissions
+ *
+ * @param {Object} params Any params you want to pass to the authProvider
+ *
+ * @returns The current auth check state. Destructure as { permissions, error, isPending, refetch }.
+ *
+ * @example
+ *     import { usePermissions } from 'react-admin';
+ *
+ *     const PostDetail = () => {
+ *         const { isPending, permissions } = usePermissions();
+ *         if (!isPending && permissions == 'editor') {
+ *             return <PostEdit />
+ *         } else {
+ *             return <PostShow />
+ *         }
+ *     };
+ */
+const usePermissions = (params = emptyParams, queryParams = {
+    staleTime: 5 * 60 * 1000,
+}) => {
+    const authProvider = useAuthProvider();
+    const logoutIfAccessDenied = useLogoutIfAccessDenied();
+    const { onSuccess, onError, onSettled, ...queryOptions } = queryParams ?? {};
+    const queryResult = useQuery({
+        queryKey: ['auth', 'getPermissions', params],
+        queryFn: async ({ signal }) => {
+            if (!authProvider || !authProvider.getPermissions) {
+                return [];
+            }
+            const permissions = await authProvider.getPermissions({
+                ...params,
+                signal,
+            });
+            return permissions ?? null;
+        },
+        ...queryOptions,
+    });
+    const onSuccessEvent = useEvent(onSuccess ?? noop);
+    const onSettledEvent = useEvent(onSettled ?? noop);
+    const onErrorEvent = useEvent(onError ??
+        ((error) => {
+            if (process.env.NODE_ENV === 'development') {
+                console.error(error);
+            }
+            logoutIfAccessDenied(error);
+        }));
+    useEffect(() => {
+        if (queryResult.data === undefined || queryResult.isFetching)
+            return;
+        onSuccessEvent(queryResult.data);
+    }, [onSuccessEvent, queryResult.data, queryResult.isFetching]);
+    useEffect(() => {
+        if (queryResult.error == null || queryResult.isFetching)
+            return;
+        onErrorEvent(queryResult.error);
+    }, [onErrorEvent, queryResult.error, queryResult.isFetching]);
+    useEffect(() => {
+        if (queryResult.status === 'pending' || queryResult.isFetching)
+            return;
+        onSettledEvent(queryResult.data, queryResult.error);
+    }, [
+        onSettledEvent,
+        queryResult.data,
+        queryResult.error,
+        queryResult.status,
+        queryResult.isFetching,
+    ]);
+    const result = useMemo(() => ({
+        ...queryResult,
+        permissions: queryResult.data,
+    }), [queryResult]);
+    return !authProvider || !authProvider.getPermissions
+        ? fakeQueryResult
+        : result;
+};
+export default usePermissions;
+const noop = () => { };
+const fakeQueryResult = {
+    permissions: undefined,
+    data: undefined,
+    dataUpdatedAt: 0,
+    error: null,
+    errorUpdatedAt: 0,
+    errorUpdateCount: 0,
+    failureCount: 0,
+    failureReason: null,
+    fetchStatus: 'idle',
+    isError: false,
+    isInitialLoading: false,
+    isLoading: false,
+    isLoadingError: false,
+    isFetched: true,
+    isFetchedAfterMount: true,
+    isFetching: false,
+    isPaused: false,
+    isPlaceholderData: false,
+    isPending: false,
+    isRefetchError: false,
+    isRefetching: false,
+    isStale: false,
+    isSuccess: true,
+    status: 'success',
+    refetch: () => Promise.resolve(fakeQueryResult),
+};

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

@@ -0,0 +1,7 @@
+import useDeleteWithUndoController from './useDeleteWithUndoController';
+import useDeleteWithConfirmController from './useDeleteWithConfirmController';
+export { useDeleteWithUndoController, useDeleteWithConfirmController };
+export * from './useDeleteController';
+export * from './useBulkDeleteController';
+export * from './useUpdateController';
+export * from './useBulkUpdateController';

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

@@ -0,0 +1,7 @@
+import useDeleteWithUndoController from './useDeleteWithUndoController';
+import useDeleteWithConfirmController from './useDeleteWithConfirmController';
+export { useDeleteWithUndoController, useDeleteWithConfirmController };
+export * from './useDeleteController';
+export * from './useBulkDeleteController';
+export * from './useUpdateController';
+export * from './useBulkUpdateController';

package/dist/ra-core/src/controller/button/useBulkDeleteController.d.ts

@@ -0,0 +1,14 @@
+import { UseDeleteManyOptions } from '../../dataProvider/useDeleteMany';
+import { RaRecord, MutationMode } from '../../types';
+export declare const useBulkDeleteController: <RecordType extends RaRecord = any, ErrorType = Error>(props: UseBulkDeleteControllerParams<RecordType, ErrorType>) => UseBulkDeleteControllerReturn;
+export interface UseBulkDeleteControllerParams<RecordType extends RaRecord = any, MutationOptionsError = unknown> {
+    mutationMode?: MutationMode;
+    mutationOptions?: UseDeleteManyOptions<RecordType, MutationOptionsError>;
+    resource?: string;
+    successMessage?: string;
+}
+export interface UseBulkDeleteControllerReturn {
+    isLoading: boolean;
+    isPending: boolean;
+    handleDelete: () => void;
+}

package/dist/ra-core/src/controller/button/useBulkDeleteController.js

@@ -0,0 +1,66 @@
+import { useCallback, useMemo } from 'react';
+import { useDeleteMany, } from '../../dataProvider/useDeleteMany';
+import { useRefresh } from '../../dataProvider/useRefresh';
+import { useListContext } from '../list/useListContext';
+import { useNotify } from '../../notification/useNotify';
+import { useResourceContext } from '../../core/useResourceContext';
+import { useTranslate } from '../../i18n/useTranslate';
+export const useBulkDeleteController = (props) => {
+    const { mutationMode = 'undoable', mutationOptions = {}, successMessage, } = props;
+    const { meta: mutationMeta, ...otherMutationOptions } = mutationOptions;
+    const resource = useResourceContext(props);
+    const notify = useNotify();
+    const refresh = useRefresh();
+    const translate = useTranslate();
+    const { selectedIds, onUnselectItems } = useListContext();
+    const [deleteMany, { isPending }] = useDeleteMany(resource, undefined, {
+        onSuccess: () => {
+            notify(successMessage ??
+                `resources.${resource}.notifications.deleted`, {
+                type: 'info',
+                messageArgs: {
+                    smart_count: selectedIds.length,
+                    _: translate("strato.notification.deleted', {
+                        smart_count: selectedIds.length,
+                    }),
+                },
+                undoable: mutationMode === 'undoable',
+            });
+            onUnselectItems(true);
+        },
+        onError: (error) => {
+            notify(typeof error === 'string'
+                ? error
+                : error?.message || "strato.notification.http_error', {
+                type: 'error',
+                messageArgs: {
+                    _: typeof error === 'string'
+                        ? error
+                        : error?.message,
+                },
+            });
+            refresh();
+        },
+    });
+    const handleDelete = useCallback(() => {
+        deleteMany(resource, {
+            ids: selectedIds,
+            meta: mutationMeta,
+        }, {
+            mutationMode,
+            ...otherMutationOptions,
+        });
+    }, [
+        deleteMany,
+        mutationMeta,
+        mutationMode,
+        otherMutationOptions,
+        resource,
+        selectedIds,
+    ]);
+    return useMemo(() => ({
+        isPending,
+        isLoading: isPending,
+        handleDelete,
+    }), [isPending, handleDelete]);
+};

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

@@ -0,0 +1,6 @@
+export * from './CreateBase';
+export * from './CreateContext';
+export * from './CreateContextProvider';
+export * from './CreateController';
+export * from './useCreateContext';
+export * from './useCreateController';

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

@@ -0,0 +1,6 @@
+export * from './CreateBase';
+export * from './CreateContext';
+export * from './CreateContextProvider';
+export * from './CreateController';
+export * from './useCreateContext';
+export * from './useCreateController';

package/dist/ra-core/src/controller/create/useCreateController.d.ts

@@ -0,0 +1,50 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import { UseCreateMutateParams } from '../../dataProvider';
+import { RedirectionSideEffect } from '../../routing';
+import { SaveContextValue } from '../saveContext';
+import { Identifier, MutationMode, RaRecord, TransformData } from '../../types';
+/**
+ * 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 declare const useCreateController: <RecordType extends Omit<RaRecord, "id"> = any, MutationOptionsError = Error, ResultRecordType extends RaRecord = RecordType & {
+    id: Identifier;
+}>(props?: CreateControllerProps<RecordType, MutationOptionsError, ResultRecordType>) => CreateControllerResult<RecordType>;
+export interface CreateControllerProps<RecordType extends Omit<RaRecord, 'id'> = any, MutationOptionsError = Error, ResultRecordType extends RaRecord = RecordType & {
+    id: Identifier;
+}> {
+    disableAuthentication?: boolean;
+    hasEdit?: boolean;
+    hasShow?: boolean;
+    record?: Partial<RecordType>;
+    redirect?: RedirectionSideEffect;
+    resource?: string;
+    mutationMode?: MutationMode;
+    mutationOptions?: UseMutationOptions<ResultRecordType, MutationOptionsError, UseCreateMutateParams<RecordType>> & {
+        meta?: any;
+    };
+    transform?: TransformData;
+}
+export interface CreateControllerResult<RecordType extends Omit<RaRecord, 'id'> = any> extends SaveContextValue {
+    defaultTitle?: string;
+    isFetching: boolean;
+    isPending: boolean;
+    isLoading: boolean;
+    record?: Partial<RecordType>;
+    redirect: RedirectionSideEffect;
+    resource: string;
+    saving: boolean;
+}

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/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/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>;