@strato-admin/core 0.1.0 → 0.3.0

package/src/resource/SchemaRegistry.tsx

@@ -1,11 +1,49 @@
-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';
+import React, {
+  createContext,
+  useContext,
+  ReactNode,
+  useState,
+  useCallback,
+  useMemo,
+  ComponentType,
+  Fragment,
+} from 'react';
+import {
+  required,
+  useResourceContext,
+  useResourceDefinition,
+  useGetResourceLabel,
+  ExtractRecordPaths,
+} from '@strato-admin/ra-core';
+import { useSettings } from '../settings/SettingsContext';
+import { FieldSchema, useFieldSchema } from './FieldSchema';
+import { InputSchema, useInputSchema } from './InputSchema';
 
-export interface ResourceSchemas {
+export interface ResourceSchemas<RecordType extends Record<string, any> = any> {
   fieldSchema?: ReactNode;
   inputSchema?: ReactNode;
+  listTitle?: ReactNode;
+  createTitle?: ReactNode;
+  editTitle?: ReactNode | ((record?: any) => ReactNode);
+  detailTitle?: ReactNode | ((record?: any) => ReactNode);
+  listDescription?: ReactNode;
+  createDescription?: ReactNode;
+  editDescription?: ReactNode | ((record?: any) => ReactNode);
+  detailDescription?: ReactNode | ((record?: any) => ReactNode);
+  listInclude?: ExtractRecordPaths<RecordType>[];
+  listExclude?: ExtractRecordPaths<RecordType>[];
+  listDisplay?: ExtractRecordPaths<RecordType>[];
+  detailInclude?: ExtractRecordPaths<RecordType>[];
+  detailExclude?: ExtractRecordPaths<RecordType>[];
+  formInclude?: ExtractRecordPaths<RecordType>[];
+  formExclude?: ExtractRecordPaths<RecordType>[];
+  editInclude?: ExtractRecordPaths<RecordType>[];
+  editExclude?: ExtractRecordPaths<RecordType>[];
+  createInclude?: ExtractRecordPaths<RecordType>[];
+  createExclude?: ExtractRecordPaths<RecordType>[];
+  listComponent?: ComponentType<any>;
+  detailComponent?: ComponentType<any>;
+  queryOptions?: any;
 }
 
 export interface DefaultResourceComponents {
@@ -16,16 +54,21 @@ export interface DefaultResourceComponents {
 }
 
 export interface SchemaRegistryContextValue {
-  registerSchemas: (resource: string, schemas: ResourceSchemas) => void;
-  getSchemas: (resource: string) => ResourceSchemas | undefined;
+  registerSchemas: <RecordType extends Record<string, any> = any>(
+    resource: string,
+    schemas: ResourceSchemas<RecordType>,
+  ) => void;
+  getSchemas: <RecordType extends Record<string, any> = any>(
+    resource: string,
+  ) => ResourceSchemas<RecordType> | undefined;
   defaultComponents: DefaultResourceComponents;
 }
 
 const SchemaRegistryContext = createContext<SchemaRegistryContextValue | undefined>(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: Record<string, ResourceSchemas> = {};
+const globalSchemaRegistry: Record<string, ResourceSchemas<any>> = {};
 let globalDefaultComponents: DefaultResourceComponents = {};
 const globalFieldInputMapping = new Map<any, any>();
 
@@ -50,15 +93,44 @@ export const getDefaultInputForField = (fieldComponent: any) => {
  * Synchronously registers schemas for a resource.
  * Can be called during render or outside of React.
  */
-export const registerGlobalSchemas = (resource: string, schemas: ResourceSchemas) => {
+export const registerGlobalSchemas = <RecordType extends Record<string, any> = any>(
+  resource: string,
+  schemas: ResourceSchemas<RecordType>,
+) => {
   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) {
+  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,
     };
@@ -75,16 +147,6 @@ 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;
@@ -118,7 +180,26 @@ export const parseUnifiedSchema = (children: React.ReactNode): ResourceSchemas =
       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 }));
+
+        // Handle collection fields (like ArrayField) that need to propagate their children to their input counterpart (e.g. ArrayInput)
+        let inputChildren = (input.props as any).children || (child.props as any).children;
+        if ((child.type as any).isCollectionField && inputChildren && !(input.props as any).children) {
+          // Recursively parse children to get their input versions
+          const parsed = parseUnifiedSchema(inputChildren);
+          inputChildren = parsed.inputSchema;
+        }
+
+        inputSchema.push(
+          React.cloneElement(input as React.ReactElement, {
+            ...rest,
+            source,
+            isRequired,
+            validate,
+            description,
+            constraintText,
+            children: inputChildren,
+          }),
+        );
         return;
       }
 
@@ -127,20 +208,53 @@ export const parseUnifiedSchema = (children: React.ReactNode): ResourceSchemas =
       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} />);
+
+        // Handle collection fields (like ArrayField) that need to propagate their children to their input counterpart (e.g. ArrayInput)
+        let inputChildren = (child.props as any).children;
+        if ((child.type as any).isCollectionField && inputChildren) {
+          // Recursively parse children to get their input versions
+          const parsed = parseUnifiedSchema(inputChildren);
+          inputChildren = parsed.inputSchema;
+        }
+
+        inputSchema.push(
+          <InputComponent
+            key={source}
+            {...rest}
+            {...inputProps}
+            source={source}
+            isRequired={isRequired}
+            validate={validate}
+            description={description}
+            constraintText={constraintText}
+          >
+            {inputChildren}
+          </InputComponent>,
+        );
       }
     });
   };
 
+  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];
+  };
+
   walk(children);
 
-  return { 
-    fieldSchema: fieldSchema.length > 0 ? fieldSchema : undefined, 
-    inputSchema: inputSchema.length > 0 ? inputSchema : undefined 
+  return {
+    fieldSchema: fieldSchema.length > 0 ? fieldSchema : undefined,
+    inputSchema: inputSchema.length > 0 ? inputSchema : undefined,
   };
 };
 
-export const getGlobalSchemas = (resource: string) => globalSchemaRegistry[resource];
+export const getGlobalSchemas = <RecordType extends Record<string, any> = any>(resource: string) =>
+  globalSchemaRegistry[resource] as ResourceSchemas<RecordType> | undefined;
 
 /**
  * Registers default components to be used by ResourceSchema when not explicitly provided.
@@ -155,26 +269,32 @@ 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 registerSchemas = useCallback(
+    <RecordType extends Record<string, any> = any>(resource: string, schemas: ResourceSchemas<RecordType>) => {
+      const updated = registerGlobalSchemas(resource, schemas);
+      if (updated) {
+        setTick((t) => t + 1);
+      }
+    },
+    [],
+  );
 
-  const value = useMemo(() => ({ 
-    registerSchemas, 
-    getSchemas, 
-    defaultComponents: globalDefaultComponents 
-  }), [registerSchemas, getSchemas]);
+  const getSchemas = useCallback(
+    <RecordType extends Record<string, any> = any>(resource: string) =>
+      globalSchemaRegistry[resource] as ResourceSchemas<RecordType> | undefined,
+    [],
+  );
 
-  return (
-    <SchemaRegistryContext.Provider value={value}>
-      {children}
-    </SchemaRegistryContext.Provider>
+  const value = useMemo(
+    () => ({
+      registerSchemas,
+      getSchemas,
+      defaultComponents: globalDefaultComponents,
+    }),
+    [registerSchemas, getSchemas],
   );
+
+  return <SchemaRegistryContext.Provider value={value}>{children}</SchemaRegistryContext.Provider>;
 };
 
 export const useSchemaRegistry = () => {
@@ -188,3 +308,132 @@ 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 = <RecordType extends Record<string, any> = any>(resourceProp?: string) => {
+  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 as any)?.options?.listInclude;
+    let listExclude = (definition as any)?.options?.listExclude;
+    let listDisplay = (definition as any)?.options?.listDisplay;
+    let detailInclude = (definition as any)?.options?.detailInclude;
+    let detailExclude = (definition as any)?.options?.detailExclude;
+    let formInclude = (definition as any)?.options?.formInclude;
+    let formExclude = (definition as any)?.options?.formExclude;
+    let editInclude = (definition as any)?.options?.editInclude;
+    let editExclude = (definition as any)?.options?.editExclude;
+    let createInclude = (definition as any)?.options?.createInclude;
+    let createExclude = (definition as any)?.options?.createExclude;
+    let listTitle = (definition as any)?.options?.listTitle;
+    let createTitle = (definition as any)?.options?.createTitle;
+    let editTitle = (definition as any)?.options?.editTitle;
+    let detailTitle = (definition as any)?.options?.detailTitle;
+    let listDescription = (definition as any)?.options?.listDescription;
+    let createDescription = (definition as any)?.options?.createDescription;
+    let editDescription = (definition as any)?.options?.editDescription;
+    let detailDescription = (definition as any)?.options?.detailDescription;
+    let listComponent = (definition as any)?.options?.listComponent;
+    let detailComponent = (definition as any)?.options?.detailComponent;
+    let queryOptions = (definition as any)?.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<RecordType>(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: string) =>
+        fieldSchema.find((child) => React.isValidElement(child) && (child.props as any).source === source),
+      getInput: (source: string) =>
+        inputSchema.find((child) => React.isValidElement(child) && (child.props as any).source === source),
+    };
+  }, [
+    resource,
+    resourceProp,
+    resourceContext,
+    fieldSchemaFromContext,
+    inputSchemaFromContext,
+    getSchemas,
+    settings,
+    definition,
+    getResourceLabel,
+  ]);
+};

package/src/resource/index.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/src/resource/useConstructedPageTitle.ts

@@ -0,0 +1,31 @@
+import { useResourceContext, useLocale } from '@strato-admin/ra-core';
+import { humanize, singularize, pluralize } from 'inflection';
+
+export function useConstructedPageTitle(type: 'create' | 'edit' | 'show' | 'list', customLabel?: string): string {
+  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/src/routing/index.ts

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

package/src/routing/useCreatePath.test.tsx

@@ -0,0 +1,38 @@
+import * as React from 'react';
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect } from 'vitest';
+import { useCreatePath } from './useCreatePath';
+import { Identifier } from '@strato-admin/ra-core';
+
+describe('useCreatePath (Strato)', () => {
+  const UseCreatePath = ({ resource, type, id }: { resource: string; type: any; id?: Identifier }) => {
+    const createPath = useCreatePath();
+    const path = createPath({ resource, type, id });
+    return <div>{path}</div>;
+  };
+
+  it('creates links for list views', () => {
+    render(<UseCreatePath resource="posts" type="list" />);
+    screen.getByText('/posts');
+  });
+
+  it('creates links for create views', () => {
+    render(<UseCreatePath resource="posts" type="create" />);
+    screen.getByText('/posts/create');
+  });
+
+  it('creates links for edit views using the new scheme', () => {
+    render(<UseCreatePath resource="posts" type="edit" id="1234" />);
+    screen.getByText('/posts/1234/edit');
+  });
+
+  it('creates links for show views using the new scheme (no suffix)', () => {
+    render(<UseCreatePath resource="posts" type="show" id="1234" />);
+    screen.getByText('/posts/1234');
+  });
+
+  it('removes double slashes', () => {
+    render(<UseCreatePath resource="/posts" type="edit" id="1234" />);
+    screen.getByText('/posts/1234/edit');
+  });
+});

package/src/routing/useCreatePath.ts

@@ -0,0 +1,40 @@
+import { useCallback } from 'react';
+import { useBasename, CreatePathParams, 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 }: CreatePathParams): string => {
+      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 as string;
+      }
+    },
+    [basename],
+  );
+};

package/src/routing/useGetPathForRecord.ts

@@ -0,0 +1,127 @@
+import { useState, useEffect } from 'react';
+import {
+  useResourceContext,
+  useRecordContext,
+  RaRecord,
+  useCanAccess,
+  useResourceDefinition,
+} from '@strato-admin/ra-core';
+import { useCreatePath } from './useCreatePath';
+
+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 const useGetPathForRecord = <RecordType extends RaRecord = RaRecord>(
+  options: UseGetPathForRecordOptions<RecordType> = {},
+): string | false | undefined => {
+  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<string | false>(
+    link && typeof link !== 'function' && record != null
+      ? createPath({
+          resource,
+          id: record.id,
+          type: link as any,
+        })
+      : 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 as any,
+            })
+          : false,
+      );
+      return;
+    }
+
+    if (link) {
+      setPath(
+        createPath({
+          resource,
+          id: record.id,
+          type: link as any,
+        }),
+      );
+    }
+  }, [
+    createPath,
+    canAccessShow,
+    canAccessEdit,
+    link,
+    record,
+    resource,
+    resourceDefinition.hasEdit,
+    resourceDefinition.hasShow,
+  ]);
+
+  return path;
+};

package/src/settings/SettingsContext.ts

@@ -0,0 +1,20 @@
+import { createContext, useContext } from 'react';
+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 const SettingsContext = createContext<AdminSettings>({});
+
+export const useSettings = (): AdminSettings => useContext(SettingsContext);