@stonecrop/stonecrop 0.10.10 → 0.10.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stonecrop/stonecrop",
-  "version": "0.10.10",
+  "version": "0.10.12",
   "license": "MIT",
   "type": "module",
   "author": {
@@ -34,7 +34,7 @@
     "pinia-shared-state": "^1.0.1",
     "pinia-xstate": "^3.0.0",
     "xstate": "^5.25.0",
-    "@stonecrop/schema": "0.10.10"
+    "@stonecrop/schema": "0.10.12"
   },
   "peerDependencies": {
     "pinia": "^3.0.4",
@@ -60,9 +60,9 @@
     "vue-router": "^5.0.2",
     "vite": "^7.3.1",
     "vitest": "^4.0.18",
-    "stonecrop-rig": "0.7.0",
-    "@stonecrop/aform": "0.10.10",
-    "@stonecrop/atable": "0.10.10"
+    "@stonecrop/aform": "0.10.12",
+    "@stonecrop/atable": "0.10.12",
+    "stonecrop-rig": "0.7.0"
   },
   "description": "Schema-driven framework with XState workflows and HST state management",
   "publishConfig": {

package/src/composables/stonecrop.ts

@@ -1,13 +1,19 @@
-import { inject, onMounted, Ref, ref, watch, provide, computed, ComputedRef } from 'vue'
+import {
+	type DoctypeManySchema,
+	type DoctypeOneSchema,
+	type DoctypeSchema,
+	type SchemaTypes,
+	isDoctypeMany,
+} from '@stonecrop/aform'
+import { storeToRefs } from 'pinia'
+import { inject, onMounted, Ref, ref, watch, provide, computed, type ComputedRef } from 'vue'
 
 import Registry from '../registry'
 import { Stonecrop } from '../stonecrop'
 import Doctype from '../doctype'
 import type { HSTNode } from '../stores/hst'
-import { RouteContext } from '../types/registry'
-import { storeToRefs } from 'pinia'
+import type { RouteContext } from '../types/registry'
 import type { HSTOperation, OperationLogConfig, OperationLogSnapshot } from '../types/operation-log'
-import { SchemaTypes, DoctypeSchema } from '@stonecrop/aform'
 
 /**
  * Operation Log API - nested object containing all operation log functionality
@@ -66,7 +72,7 @@ export type HSTStonecropReturn = BaseStonecropReturn & {
 	formData: Ref<Record<string, any>>
 	resolvedSchema: Ref<SchemaTypes[]>
 	loadNestedData: (parentPath: string, childDoctype: Doctype, recordId?: string) => Record<string, any>
-	saveRecursive: (doctype: Doctype, recordId: string) => Promise<Record<string, any>>
+	collectRecordPayload: (doctype: Doctype, recordId: string) => Record<string, any>
 	createNestedContext: (
 		basePath: string,
 		childDoctype: Doctype
@@ -501,12 +507,12 @@ export function useStonecrop(options?: {
 	}
 
 	/**
-	 * Recursively save a record with all nested doctype fields
+	 * Collect a record payload with all nested doctype fields from HST
 	 * @param doctype - The doctype metadata
-	 * @param recordId - The record ID to save
-	 * @returns The complete save payload
+	 * @param recordId - The record ID to collect
+	 * @returns The complete record payload ready for API submission
 	 */
-	const saveRecursive = (doctype: Doctype, recordId: string): Record<string, any> => {
+	const collectRecordPayload = (doctype: Doctype, recordId: string): Record<string, any> => {
 		if (!hstStore.value || !stonecrop.value) {
 			throw new Error('HST store not initialized')
 		}
@@ -524,18 +530,40 @@ export function useStonecrop(options?: {
 				: Array.from(doctype.schema)
 			: []
 		const resolved = registry ? registry.resolveSchema(schemaArray) : schemaArray
+
+		// 1:1 nested Doctype fields (cardinality: 'one' or undefined)
 		const doctypeFields = resolved.filter(
-			field => 'fieldtype' in field && field.fieldtype === 'Doctype' && 'schema' in field && Array.isArray(field.schema)
+			field =>
+				'fieldtype' in field &&
+				field.fieldtype === 'Doctype' &&
+				!isDoctypeMany(field as DoctypeSchema) &&
+				'schema' in field &&
+				Array.isArray(field.schema)
 		)
 
 		// Recursively collect nested data from HST using resolved schemas
 		for (const field of doctypeFields) {
-			const doctypeField = field as DoctypeSchema
+			const doctypeField = field as DoctypeOneSchema
 			const fieldPath = `${recordPath}.${doctypeField.fieldname}`
 			const nestedData = collectNestedData(doctypeField.schema!, fieldPath, hstStore.value)
 			payload[doctypeField.fieldname] = nestedData
 		}
 
+		// 1:many child tables (cardinality: 'many')
+		const doctypeManyFields = resolved.filter(
+			field => 'fieldtype' in field && field.fieldtype === 'Doctype' && isDoctypeMany(field as DoctypeSchema)
+		)
+
+		// Read array data from HST for cardinality: 'many' fields
+		for (const field of doctypeManyFields) {
+			const doctypeField = field as DoctypeManySchema
+			const fieldPath = `${recordPath}.${doctypeField.fieldname}`
+			const arrayData = hstStore.value.get(fieldPath)
+			if (Array.isArray(arrayData)) {
+				payload[doctypeField.fieldname] = arrayData
+			}
+		}
+
 		return payload
 	}
 
@@ -599,7 +627,7 @@ export function useStonecrop(options?: {
 			formData,
 			resolvedSchema,
 			loadNestedData,
-			saveRecursive,
+			collectRecordPayload,
 			createNestedContext,
 			isLoading,
 			error,
@@ -616,7 +644,7 @@ export function useStonecrop(options?: {
 			formData,
 			resolvedSchema,
 			loadNestedData,
-			saveRecursive,
+			collectRecordPayload,
 			createNestedContext,
 			isLoading,
 			error,
@@ -656,12 +684,21 @@ function initializeNewRecord(doctype: Doctype): Record<string, any> {
 			case 'Float':
 				initialData[field.fieldname] = 0
 				break
-			case 'Table':
-				initialData[field.fieldname] = []
-				break
 			case 'JSON':
 				initialData[field.fieldname] = {}
 				break
+			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
+					initialData[field.fieldname] = []
+				} else {
+					// 1:1 nested form - initialize as empty object
+					initialData[field.fieldname] = {}
+				}
+				break
+			}
 			default:
 				initialData[field.fieldname] = null
 		}
@@ -728,18 +765,37 @@ function collectNestedData(resolvedSchema: SchemaTypes[], basePath: string, hstS
 	const data = hstStore.get(basePath) || {}
 	const payload: Record<string, any> = { ...data }
 
-	// Find Doctype fields that have resolved child schemas
+	// Find Doctype fields that have resolved child schemas (1:1 only, not cardinality: 'many')
 	const doctypeFields = resolvedSchema.filter(
-		field => 'fieldtype' in field && field.fieldtype === 'Doctype' && 'schema' in field && Array.isArray(field.schema)
+		field =>
+			'fieldtype' in field &&
+			field.fieldtype === 'Doctype' &&
+			!isDoctypeMany(field as DoctypeSchema) &&
+			'schema' in field &&
+			Array.isArray(field.schema)
 	)
 
 	// Recursively collect nested data
 	for (const field of doctypeFields) {
-		const doctypeField = field as DoctypeSchema
+		const doctypeField = field as DoctypeOneSchema
 		const fieldPath = `${basePath}.${doctypeField.fieldname}`
 		const nestedData = collectNestedData(doctypeField.schema!, fieldPath, hstStore)
 		payload[doctypeField.fieldname] = nestedData
 	}
 
+	// Also collect array data for cardinality: 'many' fields
+	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
 }

package/src/field-triggers.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-new-func, no-eval */
 import type { Map as ImmutableMap } from 'immutable'
 import { useOperationLogStore } from './stores/operation-log'
 import type {
@@ -101,11 +100,11 @@ export class FieldTriggerEngine {
 		const transitionMap = new Map<string, string[]>()
 
 		// Convert from different Map types to regular Map
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		if (typeof (actions as any).entrySeq === 'function') {
+		// Check for Immutable.js Map first (has entrySeq method)
+		const immutableActions = actions as ImmutableMap<string, string[]>
+		if (typeof immutableActions.entrySeq === 'function') {
 			// Immutable Map
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			;(actions as any).entrySeq().forEach(([key, value]: [string, string[]]) => {
+			immutableActions.entrySeq().forEach(([key, value]: [string, string[]]) => {
 				this.categorizeAction(key, value, actionMap, transitionMap)
 			})
 		} else if (actions instanceof Map) {
@@ -506,7 +505,7 @@ export class FieldTriggerEngine {
 				})
 				.catch(error => {
 					clearTimeout(timeoutId)
-					reject(error)
+					reject(error instanceof Error ? error : new Error(String(error)))
 				})
 		})
 	}

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/stonecrop.ts

@@ -1,4 +1,4 @@
-import type { DataClient, WorkflowMeta } from '@stonecrop/schema'
+import type { DataClient } from '@stonecrop/schema'
 import { reactive } from 'vue'
 
 import Doctype from './doctype'