@stonecrop/stonecrop 0.10.11 → 0.10.13

package/src/registry.ts

@@ -85,17 +85,18 @@ export default class Registry {
 	}
 
 	/**
-	 * Resolve nested Doctype and Table fields in a schema by embedding child schemas inline.
+	 * Resolve nested Doctype fields in a schema by embedding child schemas inline.
 	 *
 	 * @remarks
 	 * Walks the schema array and for each field with `fieldtype: 'Doctype'` and a string
-	 * `options` value, looks up the referenced doctype in the registry and embeds its schema
-	 * as the field's `schema` property. Recurses for deeply nested doctypes.
+	 * `options` value, looks up the referenced doctype in the registry and:
 	 *
-	 * For fields with `fieldtype: 'Table'`, looks up the referenced child doctype and
-	 * auto-derives `columns` from its schema fields (unless columns are already provided).
-	 * Also sets sensible defaults for `component` (`'ATable'`) and `config` (`{ view: 'list' }`).
-	 * Row data is expected to come from the parent form's data model at `data[fieldname]`.
+	 * - If `cardinality: 'many'`: auto-derives `columns` from the child doctype's schema,
+	 *   sets `component: 'ATable'`, `config: { view: 'list' }`, and initializes `rows: []`.
+	 * - Otherwise (default/`cardinality: 'one'`): embeds the child schema as the field's
+	 *   `schema` property for 1:1 nested forms.
+	 *
+	 * Recurses for deeply nested doctypes. Circular references are protected against.
 	 *
 	 * Returns a new array — does not mutate the original schema.
 	 *
@@ -137,64 +138,52 @@ export default class Registry {
 					// Convert Immutable.List to plain array if needed
 					const childSchema: SchemaTypes[] = Array.isArray(doctype.schema) ? doctype.schema : Array.from(doctype.schema)
 
-					// Recurse into child schema to resolve deeply nested doctypes
-					seen.add(doctypeSlug)
-					const resolvedChild = this.resolveSchema(childSchema, seen)
-					seen.delete(doctypeSlug)
-
-					return { ...field, schema: resolvedChild }
-				}
-			}
+					// Check cardinality to determine handling
+					const cardinality = 'cardinality' in field ? field.cardinality : undefined
 
-			// Resolve Table fieldtype — 1:many child doctype rendered as ATable
-			if (
-				'fieldtype' in field &&
-				field.fieldtype === 'Table' &&
-				'options' in field &&
-				typeof field.options === 'string'
-			) {
-				const doctypeSlug = field.options
+					if (cardinality === 'many') {
+						// 1:many child table - derive columns, set component, config, rows
+						const resolved: Record<string, any> = { ...field }
 
-				// Circular reference protection
-				if (seen.has(doctypeSlug)) {
-					return { ...field }
-				}
+						// Auto-derive columns from child schema fields if not already provided
+						if (!('columns' in field) || !field.columns) {
+							resolved.columns = childSchema.map(childField => ({
+								name: childField.fieldname,
+								fieldname: childField.fieldname,
+								label: ('label' in childField && childField.label) || childField.fieldname,
+								fieldtype: 'fieldtype' in childField ? childField.fieldtype : 'Data',
+								align: ('align' in childField && childField.align) || 'left',
+								edit: 'edit' in childField ? childField.edit : true,
+								width: ('width' in childField && childField.width) || '20ch',
+							}))
+						}
 
-				const doctype = this.registry[doctypeSlug]
-				if (doctype && doctype.schema) {
-					const childSchema: SchemaTypes[] = Array.isArray(doctype.schema) ? doctype.schema : Array.from(doctype.schema)
-					const resolved: Record<string, any> = { ...field }
+						// Set default component if not already specified
+						if (!resolved.component) {
+							resolved.component = 'ATable'
+						}
 
-					// Auto-derive columns from child schema fields if not already provided
-					if (!('columns' in field) || !field.columns) {
-						resolved.columns = childSchema.map(childField => ({
-							name: childField.fieldname,
-							fieldname: childField.fieldname,
-							label: ('label' in childField && childField.label) || childField.fieldname,
-							fieldtype: 'fieldtype' in childField ? childField.fieldtype : 'Data',
-							align: ('align' in childField && childField.align) || 'left',
-							edit: 'edit' in childField ? childField.edit : true,
-							width: ('width' in childField && childField.width) || '20ch',
-						}))
-					}
+						// Set default config if not already specified
+						if (!('config' in field) || !field.config) {
+							resolved.config = { view: 'list' }
+						}
 
-					// Set default component if not already specified
-					if (!resolved.component) {
-						resolved.component = 'ATable'
-					}
+						// Initialize rows to empty array so componentProps fallback
+						// routes data from the form's dataModel[fieldname]
+						if (!('rows' in field) || !field.rows) {
+							resolved.rows = []
+						}
 
-					// Set default config if not already specified
-					if (!('config' in field) || !field.config) {
-						resolved.config = { view: 'list' }
-					}
+						return resolved as SchemaTypes
+					} else {
+						// 1:1 nested form (default cardinality: 'one')
+						// Recurse into child schema to resolve deeply nested doctypes
+						seen.add(doctypeSlug)
+						const resolvedChild = this.resolveSchema(childSchema, seen)
+						seen.delete(doctypeSlug)
 
-					// Initialize rows to empty array so componentProps fallback
-					// routes data from the form's dataModel[fieldname]
-					if (!('rows' in field) || !field.rows) {
-						resolved.rows = []
+						return { ...field, schema: resolvedChild }
 					}
-
-					return resolved as SchemaTypes
 				}
 			}
 
@@ -211,11 +200,13 @@ export default class Registry {
 	 * - Data, Text → `''`
 	 * - Check → `false`
 	 * - Int, Float, Decimal, Currency, Quantity → `0`
-	 * - Table → `[]`
-	 * - JSON, Doctype → `{}`
+	 * - JSON → `{}`
+	 * - Doctype with `cardinality: 'many'` → `[]`
+	 * - Doctype without `cardinality` or `cardinality: 'one'` → recursively initializes nested record
 	 * - All others → `null`
 	 *
-	 * For Doctype fields with a resolved `schema` array, recursively initializes the nested record.
+	 * For Doctype fields with a resolved `schema` array (cardinality: 'one'), recursively
+	 * initializes the nested record.
 	 *
 	 * @param schema - The schema array to derive defaults from
 	 * @returns A plain object with default values for each field
@@ -250,20 +241,24 @@ export default class Registry {
 				case 'Quantity':
 					record[field.fieldname] = 0
 					break
-				case 'Table':
-					record[field.fieldname] = []
-					break
 				case 'JSON':
 					record[field.fieldname] = {}
 					break
-				case 'Doctype':
-					// If nested schema is resolved, recursively initialize
-					if ('schema' in field && Array.isArray(field.schema)) {
+				case 'Doctype': {
+					// Check cardinality to determine initial value
+					const cardinality = 'cardinality' in field ? field.cardinality : undefined
+					if (cardinality === 'many') {
+						// 1:many child table - initialize as empty array
+						record[field.fieldname] = []
+					} else if ('schema' in field && Array.isArray(field.schema)) {
+						// 1:1 nested form with resolved schema - recursively initialize
 						record[field.fieldname] = this.initializeRecord(field.schema)
 					} else {
+						// 1:1 without resolved schema - empty object
 						record[field.fieldname] = {}
 					}
 					break
+				}
 				default:
 					record[field.fieldname] = null
 			}

package/src/schema-validator.ts

@@ -7,74 +7,11 @@
 import type { SchemaTypes } from '@stonecrop/aform'
 import type { List, Map as ImmutableMap } from 'immutable'
 import type { AnyStateNodeConfig } from 'xstate'
+
 import { getGlobalTriggerEngine } from './field-triggers'
 import type Registry from './registry'
-
-/**
- * Validation severity levels
- * @public
- */
-export enum ValidationSeverity {
-	/** Blocking error that prevents save */
-	ERROR = 'error',
-	/** Advisory warning that allows save */
-	WARNING = 'warning',
-	/** Informational message */
-	INFO = 'info',
-}
-
-/**
- * Validation issue
- * @public
- */
-export interface ValidationIssue {
-	/** Severity level */
-	severity: ValidationSeverity
-	/** Validation rule that failed */
-	rule: string
-	/** Human-readable message */
-	message: string
-	/** Doctype name */
-	doctype?: string
-	/** Field name if applicable */
-	fieldname?: string
-	/** Additional context */
-	context?: Record<string, unknown>
-}
-
-/**
- * Validation result
- * @public
- */
-export interface ValidationResult {
-	/** Whether validation passed (no blocking errors) */
-	valid: boolean
-	/** List of validation issues */
-	issues: ValidationIssue[]
-	/** Count of errors */
-	errorCount: number
-	/** Count of warnings */
-	warningCount: number
-	/** Count of info messages */
-	infoCount: number
-}
-
-/**
- * Schema validator options
- * @public
- */
-export interface ValidatorOptions {
-	/** Registry instance for doctype lookups */
-	registry?: Registry
-	/** Whether to validate Link field targets */
-	validateLinkTargets?: boolean
-	/** Whether to validate workflow reachability */
-	validateWorkflows?: boolean
-	/** Whether to validate action registration */
-	validateActions?: boolean
-	/** Whether to validate required schema properties */
-	validateRequiredProperties?: boolean
-}
+import { ValidationSeverity } from './types/schema-validator'
+import type { ValidationIssue, ValidationResult, ValidatorOptions } from './types/schema-validator'
 
 /**
  * Schema validator class

package/src/stonecrop.ts

@@ -1,4 +1,11 @@
-import type { DataClient, WorkflowMeta } from '@stonecrop/schema'
+import {
+	type DoctypeManySchema,
+	type DoctypeOneSchema,
+	type DoctypeSchema,
+	type SchemaTypes,
+	isDoctypeMany,
+} from '@stonecrop/aform'
+import type { DataClient } from '@stonecrop/schema'
 import { reactive } from 'vue'
 
 import Doctype from './doctype'
@@ -7,28 +14,21 @@ import { createHST, type HSTNode } from './stores/hst'
 import { useOperationLogStore } from './stores/operation-log'
 import type { OperationLogConfig } from './types/operation-log'
 import type { RouteContext } from './types/registry'
+import type { StonecropOptions } from './types/stonecrop'
 
 /**
- * Options for constructing a Stonecrop instance directly.
- * When using the Vue plugin, pass these via `InstallOptions` instead.
+ * Main Stonecrop class with HST integration and built-in Operation Log
  * @public
  */
-export interface StonecropOptions {
+export class Stonecrop {
 	/**
-	 * Data client for fetching doctype metadata and records.
-	 * Use \@stonecrop/graphql-client's StonecropClient for GraphQL backends,
-	 * or implement DataClient for custom data sources.
-	 *
-	 * Can be set later via `setClient()` for deferred configuration.
+	 * Singleton instance of Stonecrop. Only one Stonecrop instance can exist
+	 * per application, ensuring consistent HST state and registry access.
+	 * Subsequent constructor calls return this instance instead of creating new ones.
+	 * @internal
 	 */
-	client?: DataClient
-}
+	static _root: Stonecrop
 
-/**
- * Main Stonecrop class with HST integration and built-in Operation Log
- * @public
- */
-export class Stonecrop {
 	private hstStore: HSTNode
 	private _operationLogStore?: ReturnType<typeof useOperationLogStore>
 	private _operationLogConfig?: Partial<OperationLogConfig>
@@ -38,12 +38,17 @@ export class Stonecrop {
 	readonly registry: Registry
 
 	/**
-	 * Creates a new Stonecrop instance with HST integration
+	 * Creates a new Stonecrop instance with HST integration (singleton pattern)
 	 * @param registry - The Registry instance containing doctype definitions
 	 * @param operationLogConfig - Optional configuration for the operation log
 	 * @param options - Options including the data client (can be set later via setClient)
 	 */
 	constructor(registry: Registry, operationLogConfig?: Partial<OperationLogConfig>, options?: StonecropOptions) {
+		if (Stonecrop._root) {
+			return Stonecrop._root
+		}
+		Stonecrop._root = this
+
 		this.registry = registry
 
 		// Store config for lazy initialization
@@ -417,4 +422,130 @@ export class Stonecrop {
 
 		return status || initialState
 	}
+
+	/**
+	 * Collect a record payload with all nested doctype fields from HST
+	 * @param doctype - The doctype metadata
+	 * @param recordId - The record ID to collect
+	 * @returns The complete record payload ready for API submission
+	 * @public
+	 */
+	collectRecordPayload(doctype: Doctype, recordId: string): Record<string, any> {
+		const recordPath = `${doctype.slug}.${recordId}`
+		const recordData = this.hstStore.get(recordPath) || {}
+
+		const payload: Record<string, any> = { ...recordData }
+
+		const schemaArray = doctype.schema
+			? Array.isArray(doctype.schema)
+				? doctype.schema
+				: Array.from(doctype.schema)
+			: []
+		const resolved = this.registry.resolveSchema(schemaArray)
+
+		const doctypeFields = resolved.filter(
+			field =>
+				'fieldtype' in field &&
+				field.fieldtype === 'Doctype' &&
+				!isDoctypeMany(field as DoctypeSchema) &&
+				'schema' in field &&
+				Array.isArray(field.schema)
+		)
+
+		for (const field of doctypeFields) {
+			const doctypeField = field as DoctypeOneSchema
+			const fieldPath = `${recordPath}.${doctypeField.fieldname}`
+			const nestedData = collectNestedData(doctypeField.schema!, fieldPath, this.hstStore)
+			payload[doctypeField.fieldname] = nestedData
+		}
+
+		const doctypeManyFields = resolved.filter(
+			field => 'fieldtype' in field && field.fieldtype === 'Doctype' && isDoctypeMany(field as DoctypeSchema)
+		)
+
+		for (const field of doctypeManyFields) {
+			const doctypeField = field as DoctypeManySchema
+			const fieldPath = `${recordPath}.${doctypeField.fieldname}`
+			const arrayData = this.hstStore.get(fieldPath)
+			if (Array.isArray(arrayData)) {
+				payload[doctypeField.fieldname] = arrayData
+			}
+		}
+
+		return payload
+	}
+
+	/**
+	 * Load nested data from HST or initialize with defaults
+	 * @param parentPath - The HST path to check for existing data
+	 * @param childDoctype - The child doctype metadata
+	 * @param _recordId - Optional record ID to load
+	 * @returns The loaded or initialized data
+	 * @public
+	 */
+	loadNestedData(parentPath: string, childDoctype: Doctype, _recordId?: string): Record<string, any> {
+		// Check if data already exists in HST
+		const existingData = this.hstStore.get(parentPath)
+		if (existingData && typeof existingData === 'object') {
+			return existingData as Record<string, any>
+		}
+
+		// TODO: If recordId provided and no HST data, fetch from API using this._client
+		// For now, always fall through to initialize new record
+
+		// Resolve schema and initialize with defaults
+		const schemaArray = childDoctype.schema
+			? Array.isArray(childDoctype.schema)
+				? childDoctype.schema
+				: Array.from(childDoctype.schema)
+			: []
+		const resolvedSchema = this.registry.resolveSchema(schemaArray)
+		return this.registry.initializeRecord(resolvedSchema)
+	}
 }
+
+/**
+ * Recursively collect nested data from HST using pre-resolved schemas
+ * @param resolvedSchema - The already-resolved schema (with nested schemas embedded)
+ * @param basePath - The base path in HST (e.g., "customer.123.address")
+ * @param hstStore - The HST store instance
+ * @returns The collected data object
+ * @public
+ */
+function collectNestedData(resolvedSchema: SchemaTypes[], basePath: string, hstStore: HSTNode): Record<string, any> {
+	const data = hstStore.get(basePath) || {}
+	const payload: Record<string, any> = { ...data }
+
+	const doctypeFields = resolvedSchema.filter(
+		field =>
+			'fieldtype' in field &&
+			field.fieldtype === 'Doctype' &&
+			!isDoctypeMany(field as DoctypeSchema) &&
+			'schema' in field &&
+			Array.isArray(field.schema)
+	)
+
+	for (const field of doctypeFields) {
+		const doctypeField = field as DoctypeOneSchema
+		const fieldPath = `${basePath}.${doctypeField.fieldname}`
+		const nestedData = collectNestedData(doctypeField.schema!, fieldPath, hstStore)
+		payload[doctypeField.fieldname] = nestedData
+	}
+
+	const doctypeManyFields = resolvedSchema.filter(
+		field => 'fieldtype' in field && field.fieldtype === 'Doctype' && isDoctypeMany(field as DoctypeSchema)
+	)
+
+	for (const field of doctypeManyFields) {
+		const doctypeField = field as DoctypeManySchema
+		const fieldPath = `${basePath}.${doctypeField.fieldname}`
+		const arrayData = hstStore.get(fieldPath)
+		if (Array.isArray(arrayData)) {
+			payload[doctypeField.fieldname] = arrayData
+		}
+	}
+
+	return payload
+}
+
+export { collectNestedData }