@strato-admin/core 0.1.0 → 0.3.0

package/dist/resource/SchemaRegistry.js

@@ -1,10 +1,11 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import React, { createContext, useContext, useState, useCallback, useMemo, Fragment } from 'react';
-import { required } from '@strato-admin/ra-core';
-import { FieldSchema } from './FieldSchema';
-import { InputSchema } from './InputSchema';
+import React, { createContext, useContext, useState, useCallback, useMemo, Fragment, } from 'react';
+import { required, useResourceContext, useResourceDefinition, useGetResourceLabel, } from '@strato-admin/ra-core';
+import { useSettings } from '../settings/SettingsContext';
+import { FieldSchema, useFieldSchema } from './FieldSchema';
+import { InputSchema, useInputSchema } from './InputSchema';
 const SchemaRegistryContext = createContext(undefined);
-// Use a global store for schemas to ensure they are available even before 
+// Use a global store for schemas to ensure they are available even before
 // components have finished their first render/useEffect cycle.
 const globalSchemaRegistry = {};
 let globalDefaultComponents = {};
@@ -33,9 +34,33 @@ export const registerGlobalSchemas = (resource, schemas) => {
         return;
     const existing = globalSchemaRegistry[resource];
     // Only update if we actually have new schema content to avoid redundant re-renders
-    if (schemas.fieldSchema || schemas.inputSchema) {
+    if (schemas.fieldSchema ||
+        schemas.inputSchema ||
+        schemas.listTitle ||
+        schemas.createTitle ||
+        schemas.editTitle ||
+        schemas.detailTitle ||
+        schemas.listDescription ||
+        schemas.createDescription ||
+        schemas.editDescription ||
+        schemas.detailDescription ||
+        schemas.listInclude ||
+        schemas.listExclude ||
+        schemas.listDisplay ||
+        schemas.detailInclude ||
+        schemas.detailExclude ||
+        schemas.formInclude ||
+        schemas.formExclude ||
+        schemas.editInclude ||
+        schemas.editExclude ||
+        schemas.createInclude ||
+        schemas.createExclude ||
+        schemas.listComponent ||
+        schemas.detailComponent ||
+        schemas.queryOptions) {
         globalSchemaRegistry[resource] = {
             ...existing,
+            ...schemas,
             fieldSchema: schemas.fieldSchema || existing?.fieldSchema,
             inputSchema: schemas.inputSchema || existing?.inputSchema,
         };
@@ -50,17 +75,6 @@ export const registerGlobalSchemas = (resource, schemas) => {
 export const parseUnifiedSchema = (children) => {
     const fieldSchema = [];
     const inputSchema = [];
-    const mergeValidation = (isRequired, validate) => {
-        if (!isRequired)
-            return validate;
-        const requiredValidator = required();
-        if (!validate)
-            return requiredValidator;
-        if (Array.isArray(validate)) {
-            return validate.some((v) => v.isRequired) ? validate : [requiredValidator, ...validate];
-        }
-        return validate.isRequired ? validate : [requiredValidator, validate];
-    };
     const walk = (nodes) => {
         React.Children.forEach(nodes, (child) => {
             if (!React.isValidElement(child))
@@ -89,7 +103,22 @@ export const parseUnifiedSchema = (children) => {
             if (React.isValidElement(input)) {
                 // Escape hatch: explicit input component provided
                 const validate = mergeValidation(isRequired, input.props.validate);
-                inputSchema.push(React.cloneElement(input, { ...rest, source, isRequired, validate, description, constraintText }));
+                // Handle collection fields (like ArrayField) that need to propagate their children to their input counterpart (e.g. ArrayInput)
+                let inputChildren = input.props.children || child.props.children;
+                if (child.type.isCollectionField && inputChildren && !input.props.children) {
+                    // Recursively parse children to get their input versions
+                    const parsed = parseUnifiedSchema(inputChildren);
+                    inputChildren = parsed.inputSchema;
+                }
+                inputSchema.push(React.cloneElement(input, {
+                    ...rest,
+                    source,
+                    isRequired,
+                    validate,
+                    description,
+                    constraintText,
+                    children: inputChildren,
+                }));
                 return;
             }
             // Infer default input component
@@ -97,14 +126,32 @@ export const parseUnifiedSchema = (children) => {
             if (InputComponent) {
                 const inputProps = input || {};
                 const validate = mergeValidation(isRequired, inputProps.validate);
-                inputSchema.push(_jsx(InputComponent, { ...rest, ...inputProps, source: source, isRequired: isRequired, validate: validate, description: description, constraintText: constraintText }, source));
+                // Handle collection fields (like ArrayField) that need to propagate their children to their input counterpart (e.g. ArrayInput)
+                let inputChildren = child.props.children;
+                if (child.type.isCollectionField && inputChildren) {
+                    // Recursively parse children to get their input versions
+                    const parsed = parseUnifiedSchema(inputChildren);
+                    inputChildren = parsed.inputSchema;
+                }
+                inputSchema.push(_jsx(InputComponent, { ...rest, ...inputProps, source: source, isRequired: isRequired, validate: validate, description: description, constraintText: constraintText, children: inputChildren }, source));
             }
         });
     };
+    const mergeValidation = (isRequired, validate) => {
+        if (!isRequired)
+            return validate;
+        const requiredValidator = required();
+        if (!validate)
+            return requiredValidator;
+        if (Array.isArray(validate)) {
+            return validate.some((v) => v.isRequired) ? validate : [requiredValidator, ...validate];
+        }
+        return validate.isRequired ? validate : [requiredValidator, validate];
+    };
     walk(children);
     return {
         fieldSchema: fieldSchema.length > 0 ? fieldSchema : undefined,
-        inputSchema: inputSchema.length > 0 ? inputSchema : undefined
+        inputSchema: inputSchema.length > 0 ? inputSchema : undefined,
     };
 };
 export const getGlobalSchemas = (resource) => globalSchemaRegistry[resource];
@@ -128,9 +175,9 @@ export const SchemaRegistryProvider = ({ children }) => {
     const value = useMemo(() => ({
         registerSchemas,
         getSchemas,
-        defaultComponents: globalDefaultComponents
+        defaultComponents: globalDefaultComponents,
     }), [registerSchemas, getSchemas]);
-    return (_jsx(SchemaRegistryContext.Provider, { value: value, children: children }));
+    return _jsx(SchemaRegistryContext.Provider, { value: value, children: children });
 };
 export const useSchemaRegistry = () => {
     const context = useContext(SchemaRegistryContext);
@@ -143,3 +190,123 @@ export const useSchemaRegistry = () => {
     }
     return context;
 };
+/**
+ * Hook to access all schema-related information for a resource.
+ * It combines information from ResourceContext, FieldSchemaContext, InputSchemaContext,
+ * and the central SchemaRegistry.
+ */
+export const useResourceSchema = (resourceProp) => {
+    const resourceContext = useResourceContext();
+    const resource = resourceProp || resourceContext;
+    const fieldSchemaFromContext = useFieldSchema();
+    const inputSchemaFromContext = useInputSchema();
+    const { getSchemas } = useSchemaRegistry();
+    const settings = useSettings();
+    const definition = useResourceDefinition({ resource });
+    const getResourceLabel = useGetResourceLabel();
+    return useMemo(() => {
+        const isDifferentResource = resourceProp && resourceProp !== resourceContext;
+        let fieldSchema = fieldSchemaFromContext;
+        let inputSchema = inputSchemaFromContext;
+        let listInclude = definition?.options?.listInclude;
+        let listExclude = definition?.options?.listExclude;
+        let listDisplay = definition?.options?.listDisplay;
+        let detailInclude = definition?.options?.detailInclude;
+        let detailExclude = definition?.options?.detailExclude;
+        let formInclude = definition?.options?.formInclude;
+        let formExclude = definition?.options?.formExclude;
+        let editInclude = definition?.options?.editInclude;
+        let editExclude = definition?.options?.editExclude;
+        let createInclude = definition?.options?.createInclude;
+        let createExclude = definition?.options?.createExclude;
+        let listTitle = definition?.options?.listTitle;
+        let createTitle = definition?.options?.createTitle;
+        let editTitle = definition?.options?.editTitle;
+        let detailTitle = definition?.options?.detailTitle;
+        let listDescription = definition?.options?.listDescription;
+        let createDescription = definition?.options?.createDescription;
+        let editDescription = definition?.options?.editDescription;
+        let detailDescription = definition?.options?.detailDescription;
+        let listComponent = definition?.options?.listComponent;
+        let detailComponent = definition?.options?.detailComponent;
+        let queryOptions = definition?.options?.queryOptions;
+        // Use registry if we are looking for a different resource,
+        // or if the current context has empty schemas (fallback).
+        if (resource && (isDifferentResource || fieldSchema.length === 0 || inputSchema.length === 0)) {
+            const registrySchemas = getSchemas(resource);
+            if (registrySchemas) {
+                if (isDifferentResource || fieldSchema.length === 0) {
+                    fieldSchema = registrySchemas.fieldSchema ? React.Children.toArray(registrySchemas.fieldSchema) : [];
+                }
+                if (isDifferentResource || inputSchema.length === 0) {
+                    inputSchema = registrySchemas.inputSchema ? React.Children.toArray(registrySchemas.inputSchema) : [];
+                }
+                listInclude = listInclude || registrySchemas.listInclude;
+                listExclude = listExclude || registrySchemas.listExclude;
+                listDisplay = listDisplay || registrySchemas.listDisplay;
+                detailInclude = detailInclude || registrySchemas.detailInclude;
+                detailExclude = detailExclude || registrySchemas.detailExclude;
+                formInclude = formInclude || registrySchemas.formInclude;
+                formExclude = formExclude || registrySchemas.formExclude;
+                editInclude = editInclude || registrySchemas.editInclude;
+                editExclude = editExclude || registrySchemas.editExclude;
+                createInclude = createInclude || registrySchemas.createInclude;
+                createExclude = createExclude || registrySchemas.createExclude;
+                listTitle = listTitle || registrySchemas.listTitle;
+                createTitle = createTitle || registrySchemas.createTitle;
+                editTitle = editTitle || registrySchemas.editTitle;
+                detailTitle = detailTitle || registrySchemas.detailTitle;
+                listDescription = listDescription || registrySchemas.listDescription;
+                createDescription = createDescription || registrySchemas.createDescription;
+                editDescription = editDescription || registrySchemas.editDescription;
+                detailDescription = detailDescription || registrySchemas.detailDescription;
+                listComponent = listComponent || registrySchemas.listComponent;
+                detailComponent = detailComponent || registrySchemas.detailComponent;
+                queryOptions = queryOptions || registrySchemas.queryOptions;
+            }
+        }
+        listComponent = listComponent || settings.listComponent;
+        detailComponent = detailComponent || settings.detailComponent;
+        return {
+            resource,
+            fieldSchema,
+            inputSchema,
+            listInclude,
+            listExclude,
+            listDisplay,
+            detailInclude,
+            detailExclude,
+            formInclude,
+            formExclude,
+            editInclude,
+            editExclude,
+            createInclude,
+            createExclude,
+            listTitle,
+            createTitle,
+            editTitle,
+            detailTitle,
+            listDescription,
+            createDescription,
+            editDescription,
+            detailDescription,
+            listComponent,
+            detailComponent,
+            queryOptions,
+            definition,
+            label: resource ? getResourceLabel(resource, 2) : undefined, // TODO: stop hardcoding pluralization - translation issues in some languages.
+            getField: (source) => fieldSchema.find((child) => React.isValidElement(child) && child.props.source === source),
+            getInput: (source) => inputSchema.find((child) => React.isValidElement(child) && child.props.source === source),
+        };
+    }, [
+        resource,
+        resourceProp,
+        resourceContext,
+        fieldSchemaFromContext,
+        inputSchemaFromContext,
+        getSchemas,
+        settings,
+        definition,
+        getResourceLabel,
+    ]);
+};

package/dist/resource/index.d.ts

@@ -1,6 +1,8 @@
 export * from './FieldSchema';
 export * from './InputSchema';
+export * from './Resource';
 export * from './ResourceSchema';
 export * from './ResourceSchemaProvider';
 export * from './SchemaRegistry';
 export * from './ResourceContext';
+export * from './useConstructedPageTitle';

package/dist/resource/index.js

@@ -1,6 +1,8 @@
 export * from './FieldSchema';
 export * from './InputSchema';
+export * from './Resource';
 export * from './ResourceSchema';
 export * from './ResourceSchemaProvider';
 export * from './SchemaRegistry';
 export * from './ResourceContext';
+export * from './useConstructedPageTitle';

package/dist/resource/useConstructedPageTitle.d.ts

@@ -0,0 +1 @@
+export declare function useConstructedPageTitle(type: 'create' | 'edit' | 'show' | 'list', customLabel?: string): string;

package/dist/resource/useConstructedPageTitle.js

@@ -0,0 +1,27 @@
+import { useResourceContext, useLocale } from '@strato-admin/ra-core';
+import { humanize, singularize, pluralize } from 'inflection';
+export function useConstructedPageTitle(type, customLabel) {
+    const resource = useResourceContext();
+    const locale = useLocale();
+    const baseName = customLabel || resource || '';
+    if (!baseName)
+        return '';
+    if (!locale.startsWith('en')) {
+        return '';
+    }
+    const humanized = humanize(baseName);
+    const singular = singularize(humanized);
+    const plural = pluralize(humanized);
+    switch (type) {
+        case 'create':
+            return `Create ${singular}`;
+        case 'edit':
+            return `Edit ${singular}`;
+        case 'show':
+            return `${singular} Details`;
+        case 'list':
+            return plural;
+        default:
+            return singular;
+    }
+}

package/dist/routing/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useCreatePath';
+export * from './useGetPathForRecord';

package/dist/routing/index.js

@@ -0,0 +1,2 @@
+export * from './useCreatePath';
+export * from './useGetPathForRecord';

package/dist/routing/useCreatePath.d.ts

@@ -0,0 +1,7 @@
+import { CreatePathParams } from '@strato-admin/ra-core';
+/**
+ * Strato version of useCreatePath that implements the new routing scheme:
+ * - 'detail' -> /:resource/:id
+ * - 'edit' -> /:resource/:id/edit
+ */
+export declare const useCreatePath: () => ({ resource, id, type }: CreatePathParams) => string;

package/dist/routing/useCreatePath.js

@@ -0,0 +1,36 @@
+import { useCallback } from 'react';
+import { useBasename, removeDoubleSlashes } from '@strato-admin/ra-core';
+/**
+ * Strato version of useCreatePath that implements the new routing scheme:
+ * - 'detail' -> /:resource/:id
+ * - 'edit' -> /:resource/:id/edit
+ */
+export const useCreatePath = () => {
+    const basename = useBasename();
+    return useCallback(({ resource, id, type }) => {
+        if (['list', 'create', 'edit', 'detail'].includes(type) && !resource) {
+            throw new Error('Cannot create a link without a resource. You must provide the resource name.');
+        }
+        switch (type) {
+            case 'list':
+                return removeDoubleSlashes(`${basename}/${resource}`);
+            case 'create':
+                return removeDoubleSlashes(`${basename}/${resource}/create`);
+            case 'edit': {
+                if (id == null) {
+                    return removeDoubleSlashes(`${basename}/${resource}`);
+                }
+                return removeDoubleSlashes(`${basename}/${resource}/${encodeURIComponent(id)}/edit`);
+            }
+            case 'detail':
+            case 'show': {
+                if (id == null) {
+                    return removeDoubleSlashes(`${basename}/${resource}`);
+                }
+                return removeDoubleSlashes(`${basename}/${resource}/${encodeURIComponent(id)}`);
+            }
+            default:
+                return type;
+        }
+    }, [basename]);
+};

package/dist/routing/useGetPathForRecord.d.ts

@@ -0,0 +1,11 @@
+import { RaRecord } from '@strato-admin/ra-core';
+export interface UseGetPathForRecordOptions<RecordType extends RaRecord = RaRecord> {
+    resource?: string;
+    record?: RecordType;
+    link?: string | boolean | ((record: RecordType, resource: string) => string | false | Promise<string | false>);
+}
+/**
+ * Strato version of useGetPathForRecord that uses the Strato useCreatePath hook
+ * to ensure that links generated for records follow the new routing scheme.
+ */
+export declare const useGetPathForRecord: <RecordType extends RaRecord = RaRecord>(options?: UseGetPathForRecordOptions<RecordType>) => string | false | undefined;

package/dist/routing/useGetPathForRecord.js

@@ -0,0 +1,94 @@
+import { useState, useEffect } from 'react';
+import { useResourceContext, useRecordContext, useCanAccess, useResourceDefinition, } from '@strato-admin/ra-core';
+import { useCreatePath } from './useCreatePath';
+/**
+ * Strato version of useGetPathForRecord that uses the Strato useCreatePath hook
+ * to ensure that links generated for records follow the new routing scheme.
+ */
+export const useGetPathForRecord = (options = {}) => {
+    const { link } = options || {};
+    const record = useRecordContext(options);
+    const resource = useResourceContext(options);
+    if (!resource) {
+        throw new Error('Cannot generate a link for a record without a resource. You must use useGetPathForRecord within a ResourceContextProvider, or pass a resource prop.');
+    }
+    const resourceDefinition = useResourceDefinition(options);
+    const createPath = useCreatePath();
+    const [path, setPath] = useState(link && typeof link !== 'function' && record != null
+        ? createPath({
+            resource,
+            id: record.id,
+            type: link,
+        })
+        : false);
+    const { canAccess: canAccessShow } = useCanAccess({
+        action: 'show',
+        resource,
+        record,
+        enabled: link == null && resourceDefinition.hasShow,
+    });
+    const { canAccess: canAccessEdit } = useCanAccess({
+        action: 'edit',
+        resource,
+        record,
+        enabled: link == null && resourceDefinition.hasEdit,
+    });
+    useEffect(() => {
+        if (!record)
+            return;
+        if (link === false) {
+            setPath(false);
+            return;
+        }
+        if (link == null) {
+            if (resourceDefinition.hasShow && canAccessShow) {
+                setPath(createPath({
+                    resource,
+                    id: record.id,
+                    type: 'show',
+                }));
+                return;
+            }
+            if (resourceDefinition.hasEdit && canAccessEdit) {
+                setPath(createPath({
+                    resource,
+                    id: record.id,
+                    type: 'edit',
+                }));
+                return;
+            }
+        }
+        if (typeof link === 'function') {
+            const linkResult = link(record, resource);
+            if (linkResult instanceof Promise) {
+                linkResult.then((resolvedPath) => setPath(resolvedPath));
+                return;
+            }
+            setPath(linkResult
+                ? createPath({
+                    resource,
+                    id: record.id,
+                    type: linkResult,
+                })
+                : false);
+            return;
+        }
+        if (link) {
+            setPath(createPath({
+                resource,
+                id: record.id,
+                type: link,
+            }));
+        }
+    }, [
+        createPath,
+        canAccessShow,
+        canAccessEdit,
+        link,
+        record,
+        resource,
+        resourceDefinition.hasEdit,
+        resourceDefinition.hasShow,
+    ]);
+    return path;
+};

package/dist/settings/SettingsContext.d.ts

@@ -0,0 +1,16 @@
+import type { ComponentType, ReactNode } from 'react';
+export interface AdminSettings {
+    listComponent?: ComponentType<any>;
+    detailComponent?: ComponentType<any>;
+    deleteSuccessMessage?: string | ReactNode;
+    bulkDeleteSuccessMessage?: string | ReactNode | ((count: number) => ReactNode);
+    listPageSize?: number;
+    listPageSizes?: number[];
+    listPageSizeLabel?: (pageSize: number) => ReactNode;
+    editSuccessMessage?: string | ReactNode;
+    mutationMode?: 'pessimistic' | 'optimistic' | 'undoable';
+    createRedirect?: 'list' | 'detail' | 'edit' | false;
+    editRedirect?: 'list' | 'detail' | false;
+}
+export declare const SettingsContext: import("react").Context<AdminSettings>;
+export declare const useSettings: () => AdminSettings;

package/dist/settings/SettingsContext.js

@@ -0,0 +1,3 @@
+import { createContext, useContext } from 'react';
+export const SettingsContext = createContext({});
+export const useSettings = () => useContext(SettingsContext);

package/dist/settings/useSettingValue.d.ts

@@ -0,0 +1,15 @@
+import type { AdminSettings } from './SettingsContext';
+type Resolver = <K extends keyof AdminSettings>(propValue: AdminSettings[K] | undefined, settingKey: K, schemaValue?: AdminSettings[K]) => AdminSettings[K] | undefined;
+/**
+ * Returns a resolver function that applies three-tier precedence:
+ *   local prop → resource schema override → admin settings
+ *
+ * Uses !== undefined (not ??) so `false` works as an explicit disable.
+ *
+ * @example
+ * const resolve = useSettingValue();
+ * const resolvedMode = resolve(mutationMode, 'mutationMode');
+ * const resolvedRedirect = resolve(redirect, 'editRedirect');
+ */
+export declare function useSettingValue(): Resolver;
+export {};

package/dist/settings/useSettingValue.js

@@ -0,0 +1,23 @@
+import { useCallback } from 'react';
+import { useSettings } from './SettingsContext';
+/**
+ * Returns a resolver function that applies three-tier precedence:
+ *   local prop → resource schema override → admin settings
+ *
+ * Uses !== undefined (not ??) so `false` works as an explicit disable.
+ *
+ * @example
+ * const resolve = useSettingValue();
+ * const resolvedMode = resolve(mutationMode, 'mutationMode');
+ * const resolvedRedirect = resolve(redirect, 'editRedirect');
+ */
+export function useSettingValue() {
+    const settings = useSettings();
+    return useCallback((propValue, settingKey, schemaValue) => {
+        if (propValue !== undefined)
+            return propValue;
+        if (schemaValue !== undefined)
+            return schemaValue;
+        return settings[settingKey];
+    }, [settings]);
+}

package/dist/strato-core/src/core/Resource.js

@@ -0,0 +1 @@
+"use strict";

package/dist/strato-core/src/core/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/strato-core/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from '@strato-admin/ra-core';
+export * from './resource';
+export { ResourceContext } from './resource';

package/dist/strato-core/src/index.js

@@ -0,0 +1,4 @@
+export * from '@strato-admin/ra-core';
+export * from './resource';
+// Resolve ambiguity between ra-core and strato-core resource exports.
+export { ResourceContext } from './resource';

package/dist/strato-core/src/ra-messages.d.ts

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