@strato-admin/core 0.1.0

package/src/resource/ResourceSchema.tsx

@@ -0,0 +1,125 @@
+import React, { ReactNode } from 'react';
+import { Resource, ResourceProps } from '@strato-admin/ra-core';
+import { ResourceSchemaProvider } from './ResourceSchemaProvider';
+import { registerGlobalSchemas, useSchemaRegistry, getDefaultResourceComponents, parseUnifiedSchema } from './SchemaRegistry';
+
+export interface ResourceSchemaProps extends ResourceProps {
+  fieldSchema?: ReactNode;
+  inputSchema?: ReactNode;
+  children?: ReactNode;
+  label?: string;
+  canCreate?: boolean;
+  canEdit?: boolean;
+  canDelete?: boolean;
+  canShowDetails?: boolean;
+  canList?: boolean;
+}
+
+/**
+ * A wrapper around React-Admin's <Resource> that allows defining 
+ * the field and input schemas via children or props.
+ * 
+ * @example
+ * <ResourceSchema name="posts" list={PostList}>
+ *   <TextField source="title" />
+ * </ResourceSchema>
+ */
+export const ResourceSchema = ({
+  fieldSchema: explicitFieldSchema,
+  inputSchema: explicitInputSchema,
+  children,
+  label,
+  options,
+  canCreate = true,
+  canEdit = true,
+  canDelete = true,
+  canShowDetails = true,
+  canList = true,
+  ...props
+}: ResourceSchemaProps) => {
+  const { defaultComponents } = useSchemaRegistry();
+  
+  const parsedSchemas = children ? parseUnifiedSchema(children) : {};
+  const fieldSchema = explicitFieldSchema || parsedSchemas.fieldSchema;
+  const inputSchema = explicitInputSchema || parsedSchemas.inputSchema;
+
+  const mergedOptions = { 
+    ...options, 
+    ...(label ? { label } : {}),
+    canCreate,
+    canEdit,
+    canDelete,
+    canShowDetails,
+    canList,
+  };
+
+  const finalProps = {
+    ...props,
+    list: canList ? (props.list || defaultComponents.list) : undefined,
+    create: canCreate ? (props.create || defaultComponents.create) : undefined,
+    edit: canEdit ? (props.edit || defaultComponents.edit) : undefined,
+    show: canShowDetails ? (props.show || defaultComponents.show) : undefined,
+  };
+
+  return (
+    <ResourceSchemaProvider resource={props.name} fieldSchema={fieldSchema} inputSchema={inputSchema}>
+      <Resource {...finalProps} options={mergedOptions} />
+    </ResourceSchemaProvider>
+  );
+};
+
+ResourceSchema.raName = 'Resource';
+
+/**
+ * This is called by React-Admin during Admin initialization.
+ * We use it to register schemas globally before any component renders.
+ */
+ResourceSchema.registerResource = (props: ResourceSchemaProps) => {
+  const { 
+    name, 
+    fieldSchema: explicitFieldSchema, 
+    inputSchema: explicitInputSchema,
+    children,
+    label, 
+    options, 
+    canCreate = true,
+    canEdit = true,
+    canDelete = true,
+    canShowDetails = true,
+    canList = true,
+    list,
+    create,
+    edit,
+    show,
+  } = props;
+  
+  const parsedSchemas = children ? parseUnifiedSchema(children) : {};
+  const fieldSchema = explicitFieldSchema || parsedSchemas.fieldSchema;
+  const inputSchema = explicitInputSchema || parsedSchemas.inputSchema;
+
+  if (name && (fieldSchema || inputSchema)) {
+    registerGlobalSchemas(name, { fieldSchema, inputSchema });
+  }
+
+  const defaultComponents = getDefaultResourceComponents();
+  const mergedOptions = { 
+    ...options, 
+    ...(label ? { label } : {}),
+    canCreate,
+    canEdit,
+    canDelete,
+    canShowDetails,
+    canList,
+  };
+
+  const finalProps = {
+    ...props,
+    list: canList ? (list || defaultComponents.list) : undefined,
+    create: canCreate ? (create || defaultComponents.create) : undefined,
+    edit: canEdit ? (edit || defaultComponents.edit) : undefined,
+    show: canShowDetails ? (show || defaultComponents.show) : undefined,
+    options: mergedOptions,
+  };
+
+  return (Resource as any).registerResource(finalProps);
+};

package/src/resource/ResourceSchemaProvider.tsx

@@ -0,0 +1,114 @@
+import React, { ReactNode, Children, useMemo, useContext } from 'react';
+import { FieldSchemaContext } from './FieldSchema';
+import { InputSchemaContext } from './InputSchema';
+import { useSchemaRegistry } from './SchemaRegistry';
+import { ResourceContext } from './ResourceContext';
+
+export interface ResourceSchemaProviderProps {
+  children: ReactNode;
+  resource?: string;
+  fieldSchema?: ReactNode;
+  inputSchema?: ReactNode;
+}
+
+/**
+ * Provides the field and input schemas to its children via context.
+ * This is a lightweight version of ResourceSchema that does not register
+ * a React-Admin <Resource> or define routes.
+ *
+ * It can also look up schemas in the central registry if a resource name is provided.
+ */
+export const ResourceSchemaProvider = ({
+  children,
+  resource,
+  fieldSchema,
+  inputSchema,
+}: ResourceSchemaProviderProps) => {
+  const { registerSchemas, getSchemas } = useSchemaRegistry();
+  const parentResource = useContext(ResourceContext);
+
+  // 1. Register schemas synchronously during render.
+  useMemo(() => {
+    if (resource && (fieldSchema || inputSchema)) {
+      registerSchemas(resource, { fieldSchema, inputSchema });
+    }
+  }, [resource, fieldSchema, inputSchema, registerSchemas]);
+
+  // 2. Lookup schemas if not provided
+  // We MUST check the registry if resource is provided, even if we have some schemas from props,
+  // because props might only contain ONE of them (e.g. only fieldSchema).
+  const registrySchemas = useMemo(() => {
+    const effectiveResource = resource || parentResource;
+    if (effectiveResource) {
+      return getSchemas(effectiveResource);
+    }
+    return undefined;
+  }, [resource, parentResource, getSchemas]);
+
+  const finalFieldSchema = fieldSchema || registrySchemas?.fieldSchema;
+  const finalInputSchema = inputSchema || registrySchemas?.inputSchema;
+
+  // Extract children if the schemas are passed as <FieldSchema> or <InputSchema> elements
+  const getChildren = (schema: ReactNode) => {
+    if (React.isValidElement(schema)) {
+      if ('children' in (schema.props as any)) {
+        return (schema.props as any).children;
+      }
+    }
+    return schema;
+  };
+
+  const fieldChildren = useMemo(() => 
+    finalFieldSchema ? Children.toArray(getChildren(finalFieldSchema)) : undefined
+  , [finalFieldSchema]);
+
+  const inputChildren = useMemo(() => 
+    finalInputSchema ? Children.toArray(getChildren(finalInputSchema)) : undefined
+  , [finalInputSchema]);
+
+  let content = children;
+
+  // 3. Wrap in new ResourceContext if the resource changed.
+  if (resource && resource !== parentResource) {
+    content = (
+      <ResourceContext.Provider value={resource}>
+        {content}
+      </ResourceContext.Provider>
+    );
+  }
+
+  // 4. Wrap in Schema Providers.
+  // We provide a new context if:
+  // - The resource changed (prevents leakage)
+  // - OR we have explicit schema children to provide
+  if (resource && resource !== parentResource) {
+    // If resource changed, we MUST provide a context to isolate children.
+    // If no schema found, we provide [] ONLY IF we are confident it's a known resource.
+    // Actually, providing [] is safer to block leakage, but Table needs to handle it.
+    content = (
+      <FieldSchemaContext.Provider value={fieldChildren || []}>
+        <InputSchemaContext.Provider value={inputChildren || []}>
+          {content}
+        </InputSchemaContext.Provider>
+      </FieldSchemaContext.Provider>
+    );
+  } else {
+    // Resource is the same (or not provided), only wrap if we have NEW schema content
+    if (fieldChildren) {
+      content = (
+        <FieldSchemaContext.Provider value={fieldChildren}>
+          {content}
+        </FieldSchemaContext.Provider>
+      );
+    }
+    if (inputChildren) {
+      content = (
+        <InputSchemaContext.Provider value={inputChildren}>
+          {content}
+        </InputSchemaContext.Provider>
+      );
+    }
+  }
+
+  return <>{content}</>;
+};

package/src/resource/SchemaRegistry.tsx

@@ -0,0 +1,190 @@
+import React, { createContext, useContext, ReactNode, useState, useCallback, useMemo, ComponentType, Fragment } from 'react';
+import { required } from '@strato-admin/ra-core';
+import { FieldSchema } from './FieldSchema';
+import { InputSchema } from './InputSchema';
+
+export interface ResourceSchemas {
+  fieldSchema?: ReactNode;
+  inputSchema?: ReactNode;
+}
+
+export interface DefaultResourceComponents {
+  list?: ComponentType<any>;
+  create?: ComponentType<any>;
+  edit?: ComponentType<any>;
+  show?: ComponentType<any>;
+}
+
+export interface SchemaRegistryContextValue {
+  registerSchemas: (resource: string, schemas: ResourceSchemas) => void;
+  getSchemas: (resource: string) => ResourceSchemas | undefined;
+  defaultComponents: DefaultResourceComponents;
+}
+
+const SchemaRegistryContext = createContext<SchemaRegistryContextValue | undefined>(undefined);
+
+// Use a global store for schemas to ensure they are available even before 
+// components have finished their first render/useEffect cycle.
+const globalSchemaRegistry: Record<string, ResourceSchemas> = {};
+let globalDefaultComponents: DefaultResourceComponents = {};
+const globalFieldInputMapping = new Map<any, any>();
+
+/**
+ * Registers default input components for given field components.
+ * This mapping is used by ResourceSchemaProvider to infer forms.
+ */
+export const registerFieldInputMapping = (mapping: Map<any, any>) => {
+  mapping.forEach((value, key) => {
+    globalFieldInputMapping.set(key, value);
+  });
+};
+
+/**
+ * Retrieves the registered default input component for a field.
+ */
+export const getDefaultInputForField = (fieldComponent: any) => {
+  return globalFieldInputMapping.get(fieldComponent);
+};
+
+/**
+ * Synchronously registers schemas for a resource.
+ * Can be called during render or outside of React.
+ */
+export const registerGlobalSchemas = (resource: string, schemas: ResourceSchemas) => {
+  if (!resource) return;
+  
+  const existing = globalSchemaRegistry[resource];
+  
+  // Only update if we actually have new schema content to avoid redundant re-renders
+  if (schemas.fieldSchema || schemas.inputSchema) {
+    globalSchemaRegistry[resource] = {
+      ...existing,
+      fieldSchema: schemas.fieldSchema || existing?.fieldSchema,
+      inputSchema: schemas.inputSchema || existing?.inputSchema,
+    };
+    return true;
+  }
+  return false;
+};
+
+/**
+ * Parses unified schema children (Field components) into separate
+ * fieldSchema and inputSchema arrays.
+ */
+export const parseUnifiedSchema = (children: React.ReactNode): ResourceSchemas => {
+  const fieldSchema: React.ReactNode[] = [];
+  const inputSchema: React.ReactNode[] = [];
+
+  const mergeValidation = (isRequired: boolean, validate: any) => {
+    if (!isRequired) return validate;
+    const requiredValidator = required();
+    if (!validate) return requiredValidator;
+    if (Array.isArray(validate)) {
+      return validate.some((v) => (v as any).isRequired) ? validate : [requiredValidator, ...validate];
+    }
+    return (validate as any).isRequired ? validate : [requiredValidator, validate];
+  };
+
+  const walk = (nodes: React.ReactNode) => {
+    React.Children.forEach(nodes, (child) => {
+      if (!React.isValidElement(child)) return;
+
+      // Handle Fragments and FieldSchema by recursing into their children
+      if (child.type === Fragment || child.type === (FieldSchema as any)) {
+        walk((child.props as any).children);
+        return;
+      }
+
+      // Handle explicit InputSchema by only adding to inputSchema
+      if (child.type === (InputSchema as any)) {
+        React.Children.forEach((child.props as any).children, (inputChild) => {
+          if (React.isValidElement(inputChild)) {
+            inputSchema.push(inputChild);
+          }
+        });
+        return;
+      }
+
+      // The field component itself goes into the field schema
+      fieldSchema.push(child);
+
+      // Extract input configuration
+      const { source, input, isRequired, description, constraintText, ...rest } = child.props as any;
+
+      if (input === false) {
+        return; // Explicitly excluded from inputs
+      }
+
+      if (React.isValidElement(input)) {
+        // Escape hatch: explicit input component provided
+        const validate = mergeValidation(isRequired, (input.props as any).validate);
+        inputSchema.push(React.cloneElement(input, { ...rest, source, isRequired, validate, description, constraintText }));
+        return;
+      }
+
+      // Infer default input component
+      const InputComponent = getDefaultInputForField(child.type);
+      if (InputComponent) {
+        const inputProps = input || {};
+        const validate = mergeValidation(isRequired, inputProps.validate);
+        inputSchema.push(<InputComponent key={source} {...rest} {...inputProps} source={source} isRequired={isRequired} validate={validate} description={description} constraintText={constraintText} />);
+      }
+    });
+  };
+
+  walk(children);
+
+  return { 
+    fieldSchema: fieldSchema.length > 0 ? fieldSchema : undefined, 
+    inputSchema: inputSchema.length > 0 ? inputSchema : undefined 
+  };
+};
+
+export const getGlobalSchemas = (resource: string) => globalSchemaRegistry[resource];
+
+/**
+ * Registers default components to be used by ResourceSchema when not explicitly provided.
+ */
+export const registerDefaultResourceComponents = (components: DefaultResourceComponents) => {
+  globalDefaultComponents = { ...globalDefaultComponents, ...components };
+};
+
+export const getDefaultResourceComponents = () => globalDefaultComponents;
+
+export const SchemaRegistryProvider = ({ children }: { children: ReactNode }) => {
+  // We still use state to trigger re-renders when new schemas are registered dynamically
+  const [, setTick] = useState(0);
+
+  const registerSchemas = useCallback((resource: string, schemas: ResourceSchemas) => {
+    const updated = registerGlobalSchemas(resource, schemas);
+    if (updated) {
+      setTick((t) => t + 1);
+    }
+  }, []);
+
+  const getSchemas = useCallback((resource: string) => globalSchemaRegistry[resource], []);
+
+  const value = useMemo(() => ({ 
+    registerSchemas, 
+    getSchemas, 
+    defaultComponents: globalDefaultComponents 
+  }), [registerSchemas, getSchemas]);
+
+  return (
+    <SchemaRegistryContext.Provider value={value}>
+      {children}
+    </SchemaRegistryContext.Provider>
+  );
+};
+
+export const useSchemaRegistry = () => {
+  const context = useContext(SchemaRegistryContext);
+  if (!context) {
+    return {
+      registerSchemas: registerGlobalSchemas,
+      getSchemas: getGlobalSchemas,
+      defaultComponents: globalDefaultComponents,
+    };
+  }
+  return context;
+};

package/src/resource/index.ts

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