@strato-admin/core 0.1.1 → 0.3.0

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

@@ -0,0 +1,108 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ResourceContextProvider } from '../../core';
+import { ListContextProvider } from '../list/ListContextProvider';
+import { useReferenceManyFieldController, } from './useReferenceManyFieldController';
+/**
+ * Render related records to the current one.
+ *
+ * You must define the fields to be passed to the iterator component as children.
+ *
+ * @example Display all the comments of the current post as a datagrid
+ * <ReferenceManyFieldBase reference="comments" target="post_id">
+ *     <Datagrid>
+ *         <TextField source="id" />
+ *         <TextField source="body" />
+ *         <DateField source="created_at" />
+ *         <EditButton />
+ *     </Datagrid>
+ * </ReferenceManyFieldBase>
+ *
+ * @example Display all the books by the current author, only the title
+ * <ReferenceManyFieldBase reference="books" target="author_id">
+ *     <SingleFieldList>
+ *         <ChipField source="title" />
+ *     </SingleFieldList>
+ * </ReferenceManyFieldBase>
+ *
+ * By default, restricts the displayed values to 25. You can extend this limit
+ * by setting the `perPage` prop.
+ *
+ * @example
+ * <ReferenceManyFieldBase perPage={10} reference="comments" target="post_id">
+ *    ...
+ * </ReferenceManyFieldBase>
+ *
+ * By default, orders the possible values by id desc. You can change this order
+ * by setting the `sort` prop (an object with `field` and `order` properties).
+ *
+ * @example
+ * <ReferenceManyFieldBase sort={{ field: 'created_at', order: 'DESC' }} reference="comments" target="post_id">
+ *    ...
+ * </ReferenceManyFieldBase>
+ *
+ * Also, you can filter the query used to populate the possible values. Use the
+ * `filter` prop for that.
+ *
+ * @example
+ * <ReferenceManyFieldBase filter={{ is_published: true }} reference="comments" target="post_id">
+ *    ...
+ * </ReferenceManyFieldBase>
+ */
+export const ReferenceManyFieldBase = (props) => {
+    const { children, render, debounce, empty, error, loading, filter = defaultFilter, exporter, offline, page = 1, perPage = 25, record, reference, resource, sort = defaultSort, source = 'id', storeKey, target, queryOptions, } = props;
+    const controllerProps = useReferenceManyFieldController({
+        debounce,
+        filter,
+        exporter,
+        page,
+        perPage,
+        record,
+        reference,
+        resource,
+        sort,
+        source,
+        storeKey,
+        target,
+        queryOptions,
+    });
+    if (!render && !children) {
+        throw new Error("<ReferenceManyFieldBase> requires either a 'render' prop or 'children' prop");
+    }
+    const { data, error: controllerError, filterValues, hasNextPage, hasPreviousPage, isPaused, isPending, isPlaceholderData, total, } = controllerProps;
+    const shouldRenderLoading = isPending && !isPaused && loading !== false && loading !== undefined;
+    const shouldRenderOffline = isPaused &&
+        (isPending || isPlaceholderData) &&
+        offline !== false &&
+        offline !== undefined;
+    const shouldRenderError = controllerError && error !== false && error !== undefined;
+    const shouldRenderEmpty = empty !== false &&
+        empty !== undefined &&
+        // there is no error
+        !error &&
+        // the list is not loading data for the first time
+        !isPending &&
+        // the API returned no data (using either normal or partial pagination)
+        (total === 0 ||
+            (total == null &&
+                // @ts-ignore FIXME total may be undefined when using partial pagination but the ListControllerResult type is wrong about it
+                hasPreviousPage === false &&
+                // @ts-ignore FIXME total may be undefined when using partial pagination but the ListControllerResult type is wrong about it
+                hasNextPage === false &&
+                // @ts-ignore FIXME total may be undefined when using partial pagination but the ListControllerResult type is wrong about it
+                data.length === 0)) &&
+        // the user didn't set any filters
+        !Object.keys(filterValues).length;
+    return (_jsx(ResourceContextProvider, { value: reference, children: _jsx(ListContextProvider, { value: controllerProps, children: shouldRenderLoading
+                ? loading
+                : shouldRenderOffline
+                    ? offline
+                    : shouldRenderError
+                        ? error
+                        : shouldRenderEmpty
+                            ? empty
+                            : render
+                                ? render(controllerProps)
+                                : children }) }));
+};
+const defaultFilter = {};
+const defaultSort = { field: 'id', order: 'DESC' };

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

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+import { UseReferenceOneFieldControllerParams } from './useReferenceOneFieldController';
+import type { RaRecord } from '../../types';
+import type { LinkToType } from '../../routing';
+import { UseReferenceResult } from '../useReference';
+/**
+ * Render the related record in a one-to-one relationship
+ *
+ * Expects a single field as child
+ *
+ * @example // display the bio of the current author
+ * <ReferenceOneFieldBase reference="bios" target="author_id">
+ *     <TextField source="body" />
+ * </ReferenceOneFieldBase>
+ */
+export declare const ReferenceOneFieldBase: <RecordType extends RaRecord = RaRecord, ReferenceRecordType extends RaRecord = RaRecord>(props: ReferenceOneFieldBaseProps<RecordType, ReferenceRecordType>) => import("react/jsx-runtime").JSX.Element;
+export interface ReferenceOneFieldBaseProps<RecordType extends RaRecord = RaRecord, ReferenceRecordType extends RaRecord = RaRecord> extends UseReferenceOneFieldControllerParams<RecordType, ReferenceRecordType> {
+    children?: ReactNode;
+    loading?: ReactNode;
+    error?: ReactNode;
+    empty?: ReactNode;
+    offline?: ReactNode;
+    render?: (props: UseReferenceResult<ReferenceRecordType>) => ReactNode;
+    link?: LinkToType<ReferenceRecordType>;
+    resource?: string;
+}

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

@@ -0,0 +1,64 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { useReferenceOneFieldController, } from './useReferenceOneFieldController';
+import { useRecordContext, RecordContextProvider } from '../record';
+import { ResourceContextProvider } from '../../core';
+import { ReferenceFieldContextProvider } from './ReferenceFieldContext';
+import { useGetPathForRecord } from '../../routing';
+/**
+ * Render the related record in a one-to-one relationship
+ *
+ * Expects a single field as child
+ *
+ * @example // display the bio of the current author
+ * <ReferenceOneFieldBase reference="bios" target="author_id">
+ *     <TextField source="body" />
+ * </ReferenceOneFieldBase>
+ */
+export const ReferenceOneFieldBase = (props) => {
+    const { children, render, record, reference, source = 'id', target, empty, error, loading, sort, filter, link, offline, queryOptions, } = props;
+    const controllerProps = useReferenceOneFieldController({
+        record,
+        reference,
+        source,
+        target,
+        sort,
+        filter,
+        queryOptions,
+    });
+    const path = useGetPathForRecord({
+        record: controllerProps.referenceRecord,
+        resource: reference,
+        link,
+    });
+    const context = useMemo(() => ({
+        ...controllerProps,
+        link: path,
+    }), [controllerProps, path]);
+    if (!render && !children) {
+        throw new Error("<ReferenceOneFieldBase> requires either a 'render' prop or 'children' prop");
+    }
+    const recordFromContext = useRecordContext(props);
+    const { error: controllerError, isPending, isPaused, referenceRecord, } = controllerProps;
+    const shouldRenderLoading = !isPaused && isPending && loading !== false && loading !== undefined;
+    const shouldRenderOffline = isPaused && isPending && offline !== false && offline !== undefined;
+    const shouldRenderError = !!controllerError && error !== false && error !== undefined;
+    const shouldRenderEmpty = (!recordFromContext ||
+        (!isPaused &&
+            referenceRecord == null &&
+            !controllerError &&
+            !isPending)) &&
+        empty !== false &&
+        empty !== undefined;
+    return (_jsx(ResourceContextProvider, { value: reference, children: _jsx(ReferenceFieldContextProvider, { value: context, children: _jsx(RecordContextProvider, { value: referenceRecord, children: shouldRenderLoading
+                    ? loading
+                    : shouldRenderOffline
+                        ? offline
+                        : shouldRenderError
+                            ? error
+                            : shouldRenderEmpty
+                                ? empty
+                                : render
+                                    ? render(controllerProps)
+                                    : children }) }) }));
+};

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'>;
+}