@stonecrop/stonecrop 0.7.8 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stonecrop/stonecrop",
-  "version": "0.7.8",
+  "version": "0.8.0",
   "description": "schema helper",
   "license": "MIT",
   "type": "module",
@@ -60,9 +60,9 @@
     "typescript-eslint": "^8.53.0",
     "vite": "^7.3.1",
     "vitest": "^4.0.17",
-    "@stonecrop/aform": "0.7.8",
+    "@stonecrop/aform": "0.8.0",
     "stonecrop-rig": "0.7.0",
-    "@stonecrop/atable": "0.7.8"
+    "@stonecrop/atable": "0.8.0"
   },
   "publishConfig": {
     "access": "public"

package/src/composable.ts

@@ -8,6 +8,7 @@ import type { HSTNode } from './stores/hst'
 import { RouteContext } from './types/registry'
 import { storeToRefs } from 'pinia'
 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
@@ -64,6 +65,16 @@ export type HSTStonecropReturn = BaseStonecropReturn & {
 	handleHSTChange: (changeData: HSTChangeData) => void
 	hstStore: Ref<HSTNode | undefined>
 	formData: Ref<Record<string, any>>
+	resolvedSchema: Ref<SchemaTypes[]>
+	loadNestedData: (parentPath: string, childDoctype: DoctypeMeta, recordId?: string) => Record<string, any>
+	saveRecursive: (doctype: DoctypeMeta, recordId: string) => Promise<Record<string, any>>
+	createNestedContext: (
+		basePath: string,
+		childDoctype: DoctypeMeta
+	) => {
+		provideHSTPath: (fieldname: string) => string
+		handleHSTChange: (changeData: HSTChangeData) => void
+	}
 }
 
 /**
@@ -117,6 +128,19 @@ export function useStonecrop(options?: {
 	const routerDoctype = ref<DoctypeMeta | undefined>()
 	const routerRecordId = ref<string | undefined>()
 
+	// Resolved schema with nested Doctype fields expanded
+	const resolvedSchema = ref<SchemaTypes[]>([])
+
+	// Auto-resolve schema when doctype is available
+	if (options.doctype && registry) {
+		const schemaArray = options.doctype.schema
+			? Array.isArray(options.doctype.schema)
+				? options.doctype.schema
+				: Array.from(options.doctype.schema)
+			: []
+		resolvedSchema.value = registry.resolveSchema(schemaArray as SchemaTypes[])
+	}
+
 	// Operation log state and methods - will be populated after stonecrop instance is created
 	const operations = ref<HSTOperation[]>([])
 	const currentIndex = ref(-1)
@@ -254,6 +278,16 @@ export function useStonecrop(options?: {
 					routerRecordId.value = recordId
 					hstStore.value = stonecrop.value.getStore()
 
+					// Resolve schema for router-loaded doctype
+					if (registry) {
+						const schemaArray = doctype.schema
+							? Array.isArray(doctype.schema)
+								? doctype.schema
+								: Array.from(doctype.schema)
+							: []
+						resolvedSchema.value = registry.resolveSchema(schemaArray as SchemaTypes[])
+					}
+
 					if (recordId && recordId !== 'new') {
 						const existingRecord = stonecrop.value.getRecordById(doctype, recordId)
 						if (existingRecord) {
@@ -378,6 +412,103 @@ export function useStonecrop(options?: {
 		provide('hstChangeHandler', handleHSTChange)
 	}
 
+	/**
+	 * Load nested doctype data from API or initialize empty structure
+	 * @param parentPath - The parent path (e.g., "customer.123.address")
+	 * @param childDoctype - The child doctype metadata
+	 * @param recordId - Optional record ID to load
+	 * @returns Promise resolving to the loaded or initialized data
+	 */
+	const loadNestedData = (parentPath: string, childDoctype: DoctypeMeta, recordId?: string): Record<string, any> => {
+		if (!stonecrop.value) {
+			return initializeNewRecord(childDoctype)
+		}
+
+		// If recordId provided, try to load existing data
+		if (recordId) {
+			try {
+				// Check if data already exists in HST
+				const existingData = hstStore.value?.get(parentPath)
+				if (existingData && typeof existingData === 'object') {
+					return existingData as Record<string, any>
+				}
+
+				// TODO: Add API fetch logic here if needed
+				// For now, initialize new record
+				return initializeNewRecord(childDoctype)
+			} catch {
+				return initializeNewRecord(childDoctype)
+			}
+		}
+
+		// Initialize new record
+		return initializeNewRecord(childDoctype)
+	}
+
+	/**
+	 * Recursively save a record with all nested doctype fields
+	 * @param doctype - The doctype metadata
+	 * @param recordId - The record ID to save
+	 * @returns Promise resolving to the complete save payload
+	 */
+	const saveRecursive = async (doctype: DoctypeMeta, recordId: string): Promise<Record<string, any>> => {
+		if (!hstStore.value || !stonecrop.value) {
+			throw new Error('HST store not initialized')
+		}
+
+		const recordPath = `${doctype.slug}.${recordId}`
+		const recordData = hstStore.value.get(recordPath) || {}
+
+		// Build the save payload using resolved schema
+		const payload: Record<string, any> = { ...recordData }
+
+		// Use resolveSchema to get the full resolved tree, then walk Doctype fields
+		const schemaArray = (
+			doctype.schema ? (Array.isArray(doctype.schema) ? doctype.schema : Array.from(doctype.schema)) : []
+		) as SchemaTypes[]
+		const resolved = registry ? registry.resolveSchema(schemaArray) : schemaArray
+		const doctypeFields = resolved.filter(
+			field => 'fieldtype' in field && field.fieldtype === 'Doctype' && '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 fieldPath = `${recordPath}.${doctypeField.fieldname}`
+			const nestedData = collectNestedData(doctypeField.schema!, fieldPath, hstStore.value)
+			payload[doctypeField.fieldname] = nestedData
+		}
+
+		return payload
+	}
+
+	/**
+	 * Create a nested context for child forms
+	 * @param basePath - The base path for the nested context (e.g., "customer.123.address")
+	 * @param _childDoctype - The child doctype metadata (unused but kept for API consistency)
+	 * @returns Object with scoped provideHSTPath and handleHSTChange
+	 */
+	const createNestedContext = (basePath: string, _childDoctype: DoctypeMeta) => {
+		const nestedProvideHSTPath = (fieldname: string): string => {
+			return `${basePath}.${fieldname}`
+		}
+
+		const nestedHandleHSTChange = (changeData: HSTChangeData): void => {
+			// Update the path to be relative to the nested base path
+			const nestedPath = changeData.path.startsWith(basePath) ? changeData.path : `${basePath}.${changeData.fieldname}`
+
+			handleHSTChange({
+				...changeData,
+				path: nestedPath,
+			})
+		}
+
+		return {
+			provideHSTPath: nestedProvideHSTPath,
+			handleHSTChange: nestedHandleHSTChange,
+		}
+	}
+
 	// Create operation log API object
 	const operationLog: OperationLogAPI = {
 		operations,
@@ -409,6 +540,10 @@ export function useStonecrop(options?: {
 			handleHSTChange,
 			hstStore,
 			formData,
+			resolvedSchema,
+			loadNestedData,
+			saveRecursive,
+			createNestedContext,
 		} as HSTStonecropReturn
 	} else if (!options.doctype && registry?.router) {
 		// Router-based - return HST (will be populated after mount)
@@ -419,6 +554,10 @@ export function useStonecrop(options?: {
 			handleHSTChange,
 			hstStore,
 			formData,
+			resolvedSchema,
+			loadNestedData,
+			saveRecursive,
+			createNestedContext,
 		} as HSTStonecropReturn
 	}
 
@@ -514,3 +653,30 @@ function updateNestedObject(obj: any, path: string[], value: any): void {
 	const finalKey = path[path.length - 1]
 	current[finalKey] = value
 }
+
+/**
+ * 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
+ */
+function collectNestedData(resolvedSchema: SchemaTypes[], basePath: string, hstStore: HSTNode): Record<string, any> {
+	const data = hstStore.get(basePath) || {}
+	const payload: Record<string, any> = { ...data }
+
+	// Find Doctype fields that have resolved child schemas
+	const doctypeFields = resolvedSchema.filter(
+		field => 'fieldtype' in field && field.fieldtype === 'Doctype' && 'schema' in field && Array.isArray(field.schema)
+	)
+
+	// Recursively collect nested data
+	for (const field of doctypeFields) {
+		const doctypeField = field as DoctypeSchema
+		const fieldPath = `${basePath}.${doctypeField.fieldname}`
+		const nestedData = collectNestedData(doctypeField.schema!, fieldPath, hstStore)
+		payload[doctypeField.fieldname] = nestedData
+	}
+
+	return payload
+}

package/src/registry.ts

@@ -1,3 +1,4 @@
+import type { SchemaTypes } from '@stonecrop/aform'
 import { Router } from 'vue-router'
 
 import DoctypeMeta from './doctype'
@@ -83,6 +84,194 @@ export default class Registry {
 		}
 	}
 
+	/**
+	 * Resolve nested Doctype and Table 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.
+	 *
+	 * 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]`.
+	 *
+	 * Returns a new array — does not mutate the original schema.
+	 *
+	 * @param schema - The schema array to resolve
+	 * @returns A new schema array with nested Doctype fields resolved
+	 *
+	 * @example
+	 * ```ts
+	 * registry.addDoctype(addressDoctype)
+	 * registry.addDoctype(customerDoctype)
+	 *
+	 * // Before: customer schema has { fieldname: 'address', fieldtype: 'Doctype', options: 'address' }
+	 * const resolved = registry.resolveSchema(customerSchema)
+	 * // After: address field now has schema: [...address fields...]
+	 * ```
+	 *
+	 * @public
+	 */
+	resolveSchema(schema: SchemaTypes[], visited?: Set<string>): SchemaTypes[] {
+		const seen = visited || new Set<string>()
+
+		return schema.map(field => {
+			// Check for Doctype fieldtype with a string options (slug reference)
+			if (
+				'fieldtype' in field &&
+				field.fieldtype === 'Doctype' &&
+				'options' in field &&
+				typeof field.options === 'string'
+			) {
+				const doctypeSlug = field.options
+
+				// Circular reference protection
+				if (seen.has(doctypeSlug)) {
+					return { ...field }
+				}
+
+				const doctype = this.registry[doctypeSlug]
+				if (doctype && doctype.schema) {
+					// 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 }
+				}
+			}
+
+			// 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 as string
+
+				// Circular reference protection
+				if (seen.has(doctypeSlug)) {
+					return { ...field }
+				}
+
+				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 }
+
+					// 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 component if not already specified
+					if (!resolved.component) {
+						resolved.component = 'ATable'
+					}
+
+					// Set default config if not already specified
+					if (!('config' in field) || !field.config) {
+						resolved.config = { view: 'list' }
+					}
+
+					// 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 resolved as SchemaTypes
+				}
+			}
+
+			return { ...field }
+		})
+	}
+
+	/**
+	 * Initialize a new record with default values based on a schema.
+	 *
+	 * @remarks
+	 * Creates a plain object with keys from the schema's fieldnames and default values
+	 * derived from each field's `fieldtype`:
+	 * - Data, Text → `''`
+	 * - Check → `false`
+	 * - Int, Float, Decimal, Currency, Quantity → `0`
+	 * - Table → `[]`
+	 * - JSON, Doctype → `{}`
+	 * - All others → `null`
+	 *
+	 * For Doctype fields with a resolved `schema` array, recursively initializes the nested record.
+	 *
+	 * @param schema - The schema array to derive defaults from
+	 * @returns A plain object with default values for each field
+	 *
+	 * @example
+	 * ```ts
+	 * const defaults = registry.initializeRecord(addressSchema)
+	 * // { street: '', city: '', state: '', zip_code: '' }
+	 * ```
+	 *
+	 * @public
+	 */
+	initializeRecord(schema: SchemaTypes[]): Record<string, any> {
+		const record: Record<string, any> = {}
+
+		schema.forEach(field => {
+			const fieldtype = 'fieldtype' in field ? (field.fieldtype as string) : 'Data'
+
+			switch (fieldtype) {
+				case 'Data':
+				case 'Text':
+				case 'Code':
+					record[field.fieldname] = ''
+					break
+				case 'Check':
+					record[field.fieldname] = false
+					break
+				case 'Int':
+				case 'Float':
+				case 'Decimal':
+				case 'Currency':
+				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)) {
+						record[field.fieldname] = this.initializeRecord(field.schema)
+					} else {
+						record[field.fieldname] = {}
+					}
+					break
+				default:
+					record[field.fieldname] = null
+			}
+		})
+
+		return record
+	}
+
 	// TODO: should we allow clearing the registry at all?
 	// clear() {
 	// 	this.registry = {}

package/src/stonecrop.ts

@@ -1,3 +1,4 @@
+import { reactive } from 'vue'
 import DoctypeMeta from './doctype'
 import Registry from './registry'
 import { createHST, type HSTNode } from './stores/hst'
@@ -58,7 +59,9 @@ export class Stonecrop {
 			initialStoreStructure[doctypeSlug] = {}
 		})
 
-		this.hstStore = createHST(initialStoreStructure, 'StonecropStore')
+		// Wrap the store in Vue's reactive() for automatic change detection
+		// This enables Vue computed properties to track HST store changes
+		this.hstStore = createHST(reactive(initialStoreStructure), 'StonecropStore')
 	}
 
 	/**
@@ -235,10 +238,10 @@ export class Stonecrop {
 	 */
 	async getRecords(doctype: DoctypeMeta): Promise<void> {
 		const response = await fetch(`/${doctype.slug}`)
-		const records = await response.json()
+		const records = (await response.json()) as { id: string }[]
 
 		// Store each record in HST
-		records.forEach((record: any) => {
+		records.forEach(record => {
 			if (record.id) {
 				this.addRecord(doctype, record.id, record)
 			}

package/src/stores/hst.ts

@@ -138,6 +138,7 @@ interface PropertyAccessible {
 
 // Extend global interfaces
 declare global {
+	// eslint-disable-next-line @typescript-eslint/no-empty-object-type
 	interface Window extends RegistryGlobal {}
 	const global: RegistryGlobal | undefined
 }
@@ -291,7 +292,6 @@ class HSTProxy implements HSTNode {
 				const isDelete = value === undefined && beforeValue !== undefined
 				const operationType: 'set' | 'delete' = isDelete ? 'delete' : 'set'
 
-				// eslint-disable-next-line @typescript-eslint/no-unsafe-call
 				logStore.addOperation(
 					{
 						type: operationType,
@@ -429,7 +429,6 @@ class HSTProxy implements HSTNode {
 		// Log FSM transition operation
 		const logStore = getOperationLogStore()
 		if (logStore && typeof logStore.addOperation === 'function') {
-			// eslint-disable-next-line @typescript-eslint/no-unsafe-call
 			logStore.addOperation(
 				{
 					type: 'transition' as const,
@@ -678,9 +677,20 @@ class HSTProxy implements HSTNode {
 		)
 	}
 
+	/**
+	 * Parse a path string into segments, handling both dot notation and array bracket notation
+	 * @param path - The path string to parse (e.g., "order.456.line_items[0].product")
+	 * @returns Array of path segments (e.g., ['order', '456', 'line_items', '0', 'product'])
+	 */
 	private parsePath(path: string): string[] {
 		if (!path) return []
-		return path.split('.').filter(segment => segment.length > 0)
+
+		// Replace array bracket notation with dot notation
+		// items[0] → items.0
+		// items[0][1] → items.0.1
+		const normalizedPath = path.replace(/\[(\d+)\]/g, '.$1')
+
+		return normalizedPath.split('.').filter(segment => segment.length > 0)
 	}
 }