@strato-admin/faker-ecommerce 0.1.1 → 0.3.0

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

@@ -0,0 +1,206 @@
+import { useCallback } from 'react';
+import { useAuthenticated, useRequireAccess } from '../../auth';
+import { useRedirect, useParams } from '../../routing';
+import { useNotify } from '../../notification';
+import { useGetOne, useUpdate, } from '../../dataProvider';
+import { useTranslate } from '../../i18n';
+import { useResourceContext, useGetResourceLabel, useGetRecordRepresentation, } from '../../core';
+import { useMutationMiddlewares, } 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 const useEditController = (props = {}) => {
+    const { disableAuthentication = false, id: propsId, mutationMode = 'undoable', mutationOptions = {}, queryOptions = {}, redirect: redirectTo = DefaultRedirect, redirectOnError = DefaultRedirectOnError, transform, } = props;
+    const resource = useResourceContext(props);
+    if (!resource) {
+        throw new Error('useEditController requires a non-empty resource prop or context');
+    }
+    const { isPending: isPendingAuthenticated } = useAuthenticated({
+        enabled: !disableAuthentication,
+    });
+    const { isPending: isPendingCanAccess } = useRequireAccess({
+        action: 'edit',
+        resource,
+        enabled: !disableAuthentication && !isPendingAuthenticated,
+    });
+    const getRecordRepresentation = useGetRecordRepresentation(resource);
+    const translate = useTranslate();
+    const notify = useNotify();
+    const redirect = useRedirect();
+    const { id: routeId } = useParams();
+    if (!routeId && !propsId) {
+        throw new Error('useEditController requires an id prop or a route with an /:id? parameter.');
+    }
+    const id = propsId ?? routeId;
+    const { meta: queryMeta, ...otherQueryOptions } = queryOptions;
+    const { meta: mutationMeta, onSuccess, onError, ...otherMutationOptions } = mutationOptions;
+    if ((queryMeta || mutationMeta) &&
+        JSON.stringify(queryMeta) !== JSON.stringify(mutationMeta) &&
+        redirectTo === false) {
+        console.warn('When not redirecting after editing, query meta and mutation meta should be the same, or you will have data update issues.');
+    }
+    const { registerMutationMiddleware, getMutateWithMiddlewares, unregisterMutationMiddleware, } = useMutationMiddlewares();
+    const { data: record, error, isLoading, isFetching, isPaused, isPending, isPlaceholderData, refetch, } = useGetOne(resource, { id, meta: queryMeta }, {
+        enabled: (!isPendingAuthenticated && !isPendingCanAccess) ||
+            disableAuthentication,
+        onError: () => {
+            notify("strato.notification.item_doesnt_exist', {
+                type: 'error',
+            });
+            redirect(redirectOnError, resource, id);
+        },
+        refetchOnReconnect: false,
+        refetchOnWindowFocus: false,
+        retry: false,
+        ...otherQueryOptions,
+    });
+    // eslint-disable-next-line eqeqeq
+    if (record && record.id && record.id != id) {
+        throw new Error(`useEditController: Fetched record's id attribute (${record.id}) must match the requested 'id' (${id})`);
+    }
+    const getResourceLabel = useGetResourceLabel();
+    const recordRepresentation = getRecordRepresentation(record);
+    const defaultTitle = translate(`resources.${resource}.page.edit`, {
+        id,
+        record,
+        recordRepresentation: typeof recordRepresentation === 'string'
+            ? recordRepresentation
+            : '',
+        _: translate("strato.page.edit', {
+            name: getResourceLabel(resource, 1),
+            id,
+            record,
+            recordRepresentation: typeof recordRepresentation === 'string'
+                ? recordRepresentation
+                : '',
+        }),
+    });
+    const recordCached = { id, previousData: record };
+    const [update, { isPending: saving }] = useUpdate(resource, recordCached, {
+        onSuccess: async (...args) => {
+            if (onSuccess) {
+                return onSuccess(...args);
+            }
+            const [data] = args;
+            notify(`resources.${resource}.notifications.updated`, {
+                type: 'info',
+                messageArgs: {
+                    smart_count: 1,
+                    _: translate("strato.notification.updated', {
+                        smart_count: 1,
+                    }),
+                },
+                undoable: mutationMode === 'undoable',
+            });
+            redirect(redirectTo, 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, {
+            previousData: recordCached.previousData,
+        })
+        : transform
+            ? transform(data, {
+                previousData: recordCached.previousData,
+            })
+            : data).then(async (data) => {
+        try {
+            await update(resource, {
+                id,
+                data,
+                meta: metaFromSave ?? mutationMeta,
+                previousData: record,
+            }, {
+                onError: onErrorFromSave,
+                onSuccess: onSuccessFromSave,
+            });
+        }
+        catch (error) {
+            if (error.body?.errors != null) {
+                return error.body.errors;
+            }
+        }
+    }), [
+        id,
+        mutationMeta,
+        record,
+        resource,
+        transform,
+        update,
+        recordCached.previousData,
+    ]);
+    return {
+        defaultTitle,
+        error,
+        isFetching,
+        isLoading,
+        isPaused,
+        isPending,
+        isPlaceholderData,
+        mutationMode,
+        record,
+        redirect: redirectTo,
+        redirectOnError,
+        refetch,
+        registerMutationMiddleware,
+        resource,
+        save,
+        saving,
+        unregisterMutationMiddleware,
+    };
+};
+const DefaultRedirect = 'list';
+const DefaultRedirectOnError = 'list';

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

@@ -0,0 +1,12 @@
+export * from './ReferenceOneFieldBase';
+export * from './ReferenceFieldBase';
+export * from './ReferenceFieldContext';
+export * from './ReferenceManyCountBase';
+export * from './ReferenceManyFieldBase';
+export * from './ReferenceArrayFieldBase';
+export * from './types';
+export * from './useReferenceArrayFieldController';
+export * from './useReferenceFieldController';
+export * from './useReferenceManyFieldController';
+export * from './useReferenceOneFieldController';
+export * from './sanitizeFieldRestProps';

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

@@ -0,0 +1,12 @@
+export * from './ReferenceOneFieldBase';
+export * from './ReferenceFieldBase';
+export * from './ReferenceFieldContext';
+export * from './ReferenceManyCountBase';
+export * from './ReferenceManyFieldBase';
+export * from './ReferenceArrayFieldBase';
+export * from './types';
+export * from './useReferenceArrayFieldController';
+export * from './useReferenceFieldController';
+export * from './useReferenceManyFieldController';
+export * from './useReferenceOneFieldController';
+export * from './sanitizeFieldRestProps';

package/dist/ra-core/src/controller/field/sanitizeFieldRestProps.d.ts

@@ -0,0 +1 @@
+export declare const sanitizeFieldRestProps: (props: any) => any;

package/dist/ra-core/src/controller/field/sanitizeFieldRestProps.js

@@ -0,0 +1 @@
+export const sanitizeFieldRestProps = ({ cellClassName, className, emptyText, fullWidth, headerClassName, label, linkType, link, locale, record, refetch, resource, sortable, sortBy, sortByOrder, source, textAlign, translateChoice, ...props }) => props;

package/dist/ra-core/src/controller/field/types.d.ts

@@ -0,0 +1,28 @@
+import { ExtractRecordPaths } from '../../types';
+export interface BaseFieldProps<RecordType extends Record<string, any> = Record<string, any>> {
+    /**
+     * Name of the property to display.
+     *
+     * @see https://marmelab.com/react-admin/Fields.html#source
+     * @example
+     * const CommentList = () => (
+     *     <List>
+     *         <Datagrid>
+     *             <TextField source="author.name" />
+     *             <TextField source="body" />
+     *         </Datagrid>
+     *     </List>
+     * );
+     */
+    source: ExtractRecordPaths<RecordType>;
+    /**
+     * The current record to use. Defaults to the `RecordContext` value.
+     *
+     * @see https://marmelab.com/react-admin/Fields.html#record
+     */
+    record?: RecordType;
+    /**
+     * The resource name. Defaults to the `ResourceContext` value.
+     */
+    resource?: string;
+}

package/dist/ra-core/src/controller/field/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ra-core/src/controller/field/useReferenceArrayFieldController.d.ts

@@ -0,0 +1,39 @@
+import { Exporter, RaRecord, SortPayload } from '../../types';
+import { ListControllerResult } from '../list';
+import { UseQueryOptions } from '@tanstack/react-query';
+export interface UseReferenceArrayFieldControllerParams<RecordType extends RaRecord = RaRecord, ReferenceRecordType extends RaRecord = RaRecord, ErrorType = Error> {
+    filter?: any;
+    exporter?: Exporter<ReferenceRecordType> | false;
+    page?: number;
+    perPage?: number;
+    record?: RecordType;
+    reference: string;
+    resource?: string;
+    sort?: SortPayload;
+    source: string;
+    queryOptions?: Omit<UseQueryOptions<ReferenceRecordType[], ErrorType>, 'queryFn' | 'queryKey'>;
+}
+/**
+ * Hook that fetches records from another resource specified
+ * by an array of *ids* in current record.
+ *
+ * @example
+ *
+ * const { data, error, isFetching, isPending } = useReferenceArrayFieldController({
+ *      record: { referenceIds: ['id1', 'id2']};
+ *      reference: 'reference';
+ *      resource: 'resource';
+ *      source: 'referenceIds';
+ * });
+ *
+ * @param {Object} props
+ * @param {Object} props.record The current resource record
+ * @param {string} props.reference The linked resource name
+ * @param {string} props.resource The current resource name
+ * @param {string} props.source The key of the linked resource identifier
+ *
+ * @param {Props} props
+ *
+ * @returns {ListControllerResult} The reference props
+ */
+export declare const useReferenceArrayFieldController: <RecordType extends RaRecord = RaRecord, ReferenceRecordType extends RaRecord = RaRecord, ErrorType = Error>(props: UseReferenceArrayFieldControllerParams<RecordType, ReferenceRecordType, ErrorType>) => ListControllerResult<ReferenceRecordType, ErrorType>;

package/dist/ra-core/src/controller/field/useReferenceArrayFieldController.js

@@ -0,0 +1,82 @@
+import get from 'lodash/get.js';
+import { useGetManyAggregate } from '../../dataProvider';
+import { useList } from '../list';
+import { useNotify } from '../../notification';
+import { defaultExporter } from '../../export';
+import { useTranslate } from '../../i18n';
+import { useGetResourceLabel } from '../../core';
+const emptyArray = [];
+const defaultFilter = {};
+/**
+ * Hook that fetches records from another resource specified
+ * by an array of *ids* in current record.
+ *
+ * @example
+ *
+ * const { data, error, isFetching, isPending } = useReferenceArrayFieldController({
+ *      record: { referenceIds: ['id1', 'id2']};
+ *      reference: 'reference';
+ *      resource: 'resource';
+ *      source: 'referenceIds';
+ * });
+ *
+ * @param {Object} props
+ * @param {Object} props.record The current resource record
+ * @param {string} props.reference The linked resource name
+ * @param {string} props.resource The current resource name
+ * @param {string} props.source The key of the linked resource identifier
+ *
+ * @param {Props} props
+ *
+ * @returns {ListControllerResult} The reference props
+ */
+export const useReferenceArrayFieldController = (props) => {
+    const { filter = defaultFilter, exporter = defaultExporter, page = 1, perPage = 1000, record, reference, sort, source, queryOptions = {}, } = props;
+    const notify = useNotify();
+    const translate = useTranslate();
+    const value = get(record, source);
+    const { meta, ...otherQueryOptions } = queryOptions;
+    const ids = Array.isArray(value) ? value : emptyArray;
+    const { data, error, isLoading, isFetching, isPaused, isPending, isPlaceholderData, refetch, } = useGetManyAggregate(reference, { ids, meta }, {
+        onError: error => notify(typeof error === 'string'
+            ? error
+            : error?.message ||
+                "strato.notification.http_error', {
+            type: 'error',
+            messageArgs: {
+                _: typeof error === 'string'
+                    ? error
+                    : error?.message
+                        ? error.message
+                        : undefined,
+            },
+        }),
+        ...otherQueryOptions,
+    });
+    const listProps = useList({
+        data,
+        error,
+        exporter,
+        filter,
+        isFetching,
+        isLoading,
+        isPaused,
+        isPending,
+        isPlaceholderData,
+        page,
+        perPage,
+        sort,
+    });
+    const getResourceLabel = useGetResourceLabel();
+    const defaultTitle = translate(`resources.${reference}.page.list`, {
+        _: translate("strato.page.list', {
+            name: getResourceLabel(reference, 2),
+        }),
+    });
+    return {
+        ...listProps,
+        defaultTitle,
+        refetch,
+        resource: reference,
+    };
+};

package/dist/ra-core/src/controller/field/useReferenceFieldController.d.ts

@@ -0,0 +1,14 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { RaRecord } from '../../types';
+import { LinkToType } from '../../routing';
+import { UseReferenceResult } from '../useReference';
+export declare const useReferenceFieldController: <ReferenceRecordType extends RaRecord = RaRecord, ErrorType = Error>(options: UseReferenceFieldControllerOptions<ReferenceRecordType, ErrorType>) => UseReferenceFieldControllerResult<ReferenceRecordType, ErrorType>;
+export interface UseReferenceFieldControllerOptions<ReferenceRecordType extends RaRecord = RaRecord, ErrorType = Error> {
+    source: string;
+    queryOptions?: Omit<UseQueryOptions<ReferenceRecordType[], ErrorType>, 'queryFn' | 'queryKey'>;
+    reference: string;
+    link?: LinkToType<ReferenceRecordType>;
+}
+export interface UseReferenceFieldControllerResult<ReferenceRecordType extends RaRecord = RaRecord, ErrorType = Error> extends UseReferenceResult<ReferenceRecordType, ErrorType> {
+    link?: string | false;
+}

package/dist/ra-core/src/controller/field/useReferenceFieldController.js

@@ -0,0 +1,31 @@
+import { useMemo } from 'react';
+import { useGetPathForRecord } from '../../routing';
+import { useReference } from '../useReference';
+import { useFieldValue } from '../../util';
+export const useReferenceFieldController = (options) => {
+    const { link, reference, queryOptions } = options;
+    if (!reference) {
+        throw new Error('useReferenceFieldController: missing reference prop. You must provide a reference, e.g. reference="posts".');
+    }
+    const id = useFieldValue(options);
+    const referenceRecordQuery = useReference({
+        reference,
+        id,
+        options: {
+            ...queryOptions,
+            enabled: (queryOptions?.enabled == null ||
+                queryOptions?.enabled === true) &&
+                id != null,
+        },
+    });
+    const path = useGetPathForRecord({
+        record: referenceRecordQuery.referenceRecord,
+        resource: reference,
+        link,
+    });
+    const result = useMemo(() => ({
+        ...referenceRecordQuery,
+        link: path,
+    }), [path, referenceRecordQuery]);
+    return result;
+};

package/dist/ra-core/src/controller/field/useReferenceManyFieldController.d.ts

@@ -0,0 +1,49 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { Exporter, FilterPayload, RaRecord, SortPayload } from '../../types';
+import type { ListControllerResult } from '../list';
+/**
+ * Fetch reference records, and return them when available
+ *
+ * Uses dataProvider.getManyReference() internally.
+ *
+ * @example // fetch the comments related to the current post
+ * const { isPending, data } = useReferenceManyFieldController({
+ *     reference: 'comments',
+ *     target: 'post_id',
+ *     record: { id: 123, title: 'hello, world' },
+ *     resource: 'posts',
+ * });
+ *
+ * @param {Object} props
+ * @param {string} props.reference The linked resource name. Required.
+ * @param {string} props.target The target resource key. Required.
+ * @param {Object} props.filter The filter applied on the recorded records list
+ * @param {number} props.page the page number
+ * @param {number} props.perPage the number of item per page
+ * @param {Object} props.record The current resource record
+ * @param {string} props.resource The current resource name
+ * @param {Object} props.sort the sort to apply to the referenced records
+ * @param {string} props.source The key of the linked resource identifier
+ * @param {UseQuery Options} props.queryOptions `react-query` options`
+ *
+ * @returns {ListControllerResult} The reference many props
+ */
+export declare const useReferenceManyFieldController: <RecordType extends RaRecord = RaRecord, ReferenceRecordType extends RaRecord = RaRecord, ErrorType = Error>(props: UseReferenceManyFieldControllerParams<RecordType, ReferenceRecordType, ErrorType>) => ListControllerResult<ReferenceRecordType, ErrorType>;
+export interface UseReferenceManyFieldControllerParams<RecordType extends Record<string, any> = Record<string, any>, ReferenceRecordType extends Record<string, any> = Record<string, any>, ErrorType = Error> {
+    debounce?: number;
+    filter?: FilterPayload;
+    page?: number;
+    perPage?: number;
+    record?: RecordType;
+    reference: string;
+    resource?: string;
+    exporter?: Exporter<ReferenceRecordType & RaRecord> | false;
+    sort?: SortPayload;
+    source?: string;
+    storeKey?: string;
+    target: string;
+    queryOptions?: Omit<UseQueryOptions<{
+        data: ReferenceRecordType[];
+        total: number;
+    }, ErrorType>, 'queryKey' | 'queryFn'>;
+}