@stonecrop/stonecrop 0.10.12 → 0.10.14

package/dist/types/index.js

@@ -1,4 +1,9 @@
-// Re-export types
+// Re-export all type files
+export * from './composable';
+export * from './doctype';
 export * from './field-triggers';
-export * from './registry';
 export * from './operation-log';
+export * from './plugin';
+export * from './registry';
+export * from './schema-validator';
+export * from './stonecrop';

package/dist/types/schema-validator.js

@@ -0,0 +1,13 @@
+/**
+ * Validation severity levels
+ * @public
+ */
+export var ValidationSeverity;
+(function (ValidationSeverity) {
+    /** Blocking error that prevents save */
+    ValidationSeverity["ERROR"] = "error";
+    /** Advisory warning that allows save */
+    ValidationSeverity["WARNING"] = "warning";
+    /** Informational message */
+    ValidationSeverity["INFO"] = "info";
+})(ValidationSeverity || (ValidationSeverity = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stonecrop/stonecrop",
-  "version": "0.10.12",
+  "version": "0.10.14",
   "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.12"
+    "@stonecrop/schema": "0.10.14"
   },
   "peerDependencies": {
     "pinia": "^3.0.4",
@@ -60,9 +60,9 @@
     "vue-router": "^5.0.2",
     "vite": "^7.3.1",
     "vitest": "^4.0.18",
-    "@stonecrop/aform": "0.10.12",
-    "@stonecrop/atable": "0.10.12",
-    "stonecrop-rig": "0.7.0"
+    "@stonecrop/atable": "0.10.14",
+    "stonecrop-rig": "0.7.0",
+    "@stonecrop/aform": "0.10.14"
   },
   "description": "Schema-driven framework with XState workflows and HST state management",
   "publishConfig": {

package/src/composables/stonecrop.ts

@@ -1,100 +1,14 @@
-import {
-	type DoctypeManySchema,
-	type DoctypeOneSchema,
-	type DoctypeSchema,
-	type SchemaTypes,
-	isDoctypeMany,
-} from '@stonecrop/aform'
+import { type SchemaTypes } from '@stonecrop/aform'
 import { storeToRefs } from 'pinia'
-import { inject, onMounted, Ref, ref, watch, provide, computed, type ComputedRef } from 'vue'
+import { inject, onMounted, Ref, ref, watch, provide, computed } from 'vue'
 
+import Doctype from '../doctype'
 import Registry from '../registry'
 import { Stonecrop } from '../stonecrop'
-import Doctype from '../doctype'
 import type { HSTNode } from '../stores/hst'
+import type { BaseStonecropReturn, HSTStonecropReturn, HSTChangeData, OperationLogAPI } from '../types/composable'
+import type { HSTOperation, OperationLogConfig } from '../types/operation-log'
 import type { RouteContext } from '../types/registry'
-import type { HSTOperation, OperationLogConfig, OperationLogSnapshot } from '../types/operation-log'
-
-/**
- * Operation Log API - nested object containing all operation log functionality
- * @public
- */
-export type OperationLogAPI = {
-	operations: Ref<HSTOperation[]>
-	currentIndex: Ref<number>
-	undoRedoState: ComputedRef<{
-		canUndo: boolean
-		canRedo: boolean
-		undoCount: number
-		redoCount: number
-		currentIndex: number
-	}>
-	canUndo: ComputedRef<boolean>
-	canRedo: ComputedRef<boolean>
-	undoCount: ComputedRef<number>
-	redoCount: ComputedRef<number>
-	undo: (hstStore: HSTNode) => boolean
-	redo: (hstStore: HSTNode) => boolean
-	startBatch: () => void
-	commitBatch: (description?: string) => string | null
-	cancelBatch: () => void
-	clear: () => void
-	getOperationsFor: (doctype: string, recordId?: string) => HSTOperation[]
-	getSnapshot: () => OperationLogSnapshot
-	markIrreversible: (operationId: string, reason: string) => void
-	logAction: (
-		doctype: string,
-		actionName: string,
-		recordIds?: string[],
-		result?: 'success' | 'failure' | 'pending',
-		error?: string
-	) => string
-	configure: (options: Partial<OperationLogConfig>) => void
-}
-
-/**
- * Base Stonecrop composable return type - includes operation log functionality
- * @public
- */
-export type BaseStonecropReturn = {
-	stonecrop: Ref<Stonecrop | undefined>
-	operationLog: OperationLogAPI
-}
-
-/**
- * HST-enabled Stonecrop composable return type
- * @public
- */
-export type HSTStonecropReturn = BaseStonecropReturn & {
-	provideHSTPath: (fieldname: string, recordId?: string) => string
-	handleHSTChange: (changeData: HSTChangeData) => void
-	hstStore: Ref<HSTNode | undefined>
-	formData: Ref<Record<string, any>>
-	resolvedSchema: Ref<SchemaTypes[]>
-	loadNestedData: (parentPath: string, childDoctype: Doctype, recordId?: string) => Record<string, any>
-	collectRecordPayload: (doctype: Doctype, recordId: string) => Record<string, any>
-	createNestedContext: (
-		basePath: string,
-		childDoctype: Doctype
-	) => {
-		provideHSTPath: (fieldname: string) => string
-		handleHSTChange: (changeData: HSTChangeData) => void
-	}
-	isLoading: Ref<boolean>
-	error: Ref<Error | null>
-	resolvedDoctype: Ref<Doctype | undefined>
-}
-
-/**
- * HST Change data structure
- * @public
- */
-export type HSTChangeData = {
-	path: string
-	value: any
-	fieldname: string
-	recordId?: string
-}
 
 /**
  * Unified Stonecrop composable - handles both general operations and HST reactive integration
@@ -128,7 +42,7 @@ export function useStonecrop(options?: {
 
 	const registry = options.registry || inject<Registry>('$registry')
 	const providedStonecrop = inject<Stonecrop>('$stonecrop')
-	const stonecrop = ref<Stonecrop>()
+	const stonecrop = ref<Stonecrop | undefined>()
 	const hstStore = ref<HSTNode>()
 	const formData = ref<Record<string, any>>({})
 
@@ -144,6 +58,13 @@ export function useStonecrop(options?: {
 	const error = ref<Error | null>(null)
 	const resolvedDoctype = ref<Doctype | undefined>()
 
+	// Initialize stonecrop instance synchronously using singleton pattern
+	// Use injected instance if available, otherwise fall back to the singleton root
+	const stonecropInstance = providedStonecrop || Stonecrop._root
+	if (stonecropInstance) {
+		stonecrop.value = stonecropInstance
+	}
+
 	// If doctype is a Doctype instance (not string), set resolved immediately
 	if (options?.doctype && typeof options.doctype !== 'string') {
 		resolvedDoctype.value = options.doctype
@@ -228,12 +149,10 @@ export function useStonecrop(options?: {
 
 	// Initialize Stonecrop instance
 	onMounted(async () => {
-		if (!registry) {
+		if (!registry || !stonecrop.value) {
 			return
 		}
 
-		stonecrop.value = providedStonecrop || new Stonecrop(registry)
-
 		// Set up reactive refs from operation log store - only if Pinia is available
 		try {
 			const opLogStore = stonecrop.value.getOperationLogStore()
@@ -308,11 +227,11 @@ export function useStonecrop(options?: {
 									formData.value = loadedRecord.get('') || {}
 								}
 							} catch {
-								formData.value = initializeNewRecord(doctype)
+								formData.value = registry.initializeRecord(resolvedSchema.value)
 							}
 						}
 					} else {
-						formData.value = initializeNewRecord(doctype)
+						formData.value = registry.initializeRecord(resolvedSchema.value)
 					}
 
 					if (hstStore.value) {
@@ -395,11 +314,11 @@ export function useStonecrop(options?: {
 							formData.value = loadedRecord.get('') || {}
 						}
 					} catch {
-						formData.value = initializeNewRecord(doctype)
+						formData.value = registry.initializeRecord(resolvedSchema.value)
 					}
 				}
 			} else {
-				formData.value = initializeNewRecord(doctype)
+				formData.value = registry.initializeRecord(resolvedSchema.value)
 			}
 
 			if (hstStore.value) {
@@ -475,96 +394,31 @@ export function useStonecrop(options?: {
 
 	/**
 	 * Load nested doctype data from API or initialize empty structure
+	 * Delegates to Stonecrop.loadNestedData method
 	 * @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
+	 * @returns The loaded or initialized data
 	 */
 	const loadNestedData = (parentPath: string, childDoctype: Doctype, recordId?: string): Record<string, any> => {
 		if (!stonecrop.value) {
-			return initializeNewRecord(childDoctype)
+			throw new Error('Stonecrop instance not available')
 		}
-
-		// 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)
+		return stonecrop.value.loadNestedData(parentPath, childDoctype, recordId)
 	}
 
 	/**
 	 * Collect a record payload with all nested doctype fields from HST
+	 * Delegates to Stonecrop.collectRecordPayload method
 	 * @param doctype - The doctype metadata
 	 * @param recordId - The record ID to collect
 	 * @returns The complete record payload ready for API submission
 	 */
 	const collectRecordPayload = (doctype: Doctype, recordId: string): 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)
-			: []
-		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' &&
-				!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 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
-			}
+		if (!stonecrop.value) {
+			throw new Error('Stonecrop instance not available')
 		}
-
-		return payload
+		return stonecrop.value.collectRecordPayload(doctype, recordId)
 	}
 
 	/**
@@ -659,54 +513,6 @@ export function useStonecrop(options?: {
 	} as BaseStonecropReturn
 }
 
-/**
- * Initialize new record structure based on doctype schema
- */
-function initializeNewRecord(doctype: Doctype): Record<string, any> {
-	const initialData: Record<string, any> = {}
-
-	if (!doctype.schema) {
-		return initialData
-	}
-
-	doctype.schema.forEach(field => {
-		const fieldtype = 'fieldtype' in field ? field.fieldtype : 'Data'
-
-		switch (fieldtype) {
-			case 'Data':
-			case 'Text':
-				initialData[field.fieldname] = ''
-				break
-			case 'Check':
-				initialData[field.fieldname] = false
-				break
-			case 'Int':
-			case 'Float':
-				initialData[field.fieldname] = 0
-				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
-		}
-	})
-
-	return initialData
-}
-
 /**
  * Setup deep reactivity between form data and HST store
  */
@@ -753,49 +559,3 @@ 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 (1:1 only, not cardinality: 'many')
-	const doctypeFields = resolvedSchema.filter(
-		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 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/doctype.ts

@@ -5,32 +5,7 @@ import { Component } from 'vue'
 import type { UnknownMachineConfig } from 'xstate'
 
 import type { ImmutableDoctype } from './types'
-
-/**
- * Plain object representation of doctype configuration for serialization/API responses.
- * Compatible with the DoctypeMeta type from \@stonecrop/schema.
- * @public
- */
-export type DoctypeConfig = {
-	/** Display name of the doctype */
-	name: string
-	/** URL-friendly slug (kebab-case) */
-	slug?: string
-	/** Database table name */
-	tableName?: string
-	/** Field definitions */
-	fields?: SchemaTypes[]
-	/** Workflow configuration (XState format or simple WorkflowMeta) */
-	workflow?: UnknownMachineConfig | WorkflowMeta
-	/** Actions and their field triggers */
-	actions?: Record<string, string[]>
-	/** Parent doctype for inheritance */
-	inherits?: string
-	/** Doctype to use for list views */
-	listDoctype?: string
-	/** Parent doctype for child tables */
-	parentDoctype?: string
-}
+import type { DoctypeConfig } from './types/doctype'
 
 /**
  * Doctype runtime class with Immutable.js collections for HST change tracking.
@@ -249,9 +224,7 @@ export default class Doctype {
 	 *
 	 * @public
 	 */
-	getActionMeta(
-		actionName: string
-	):
+	getActionMeta(actionName: string):
 		| {
 				label: string
 				handler: string

package/src/index.ts

@@ -3,8 +3,9 @@ export type * from '@stonecrop/atable/types'
 
 import { useStonecrop } from './composables/stonecrop'
 import { useOperationLog, useUndoRedoShortcuts, withBatch } from './composables/operation-log'
-import Doctype, { type DoctypeConfig } from './doctype'
+import Doctype from './doctype'
 import {
+	FieldTriggerEngine,
 	getGlobalTriggerEngine,
 	markOperationIrreversible,
 	registerGlobalAction,
@@ -14,39 +15,29 @@ import {
 } from './field-triggers'
 import plugin from './plugins'
 import Registry from './registry'
-import { type StonecropOptions, Stonecrop } from './stonecrop'
+import { Stonecrop, collectNestedData } from './stonecrop'
 import { HST, createHST, type HSTNode } from './stores/hst'
 import { useOperationLogStore } from './stores/operation-log'
-// Export schema validator
 import { SchemaValidator, createValidator, validateSchema } from './schema-validator'
+import { ValidationSeverity } from './types/schema-validator'
+
+// Export all types from ./types
 export type * from './types'
-export type { BaseStonecropReturn, HSTChangeData, HSTStonecropReturn, OperationLogAPI } from './composables/stonecrop'
-export type { FieldTriggerEngine } from './field-triggers'
-export type {
-	FieldChangeContext,
-	TransitionChangeContext,
-	FieldTriggerExecutionResult,
-	ActionExecutionResult,
-	TransitionExecutionResult,
-	FieldActionFunction,
-	TransitionActionFunction,
-} from './types/field-triggers'
-// Export schema validator types
-export type { ValidationIssue, ValidationResult, ValidatorOptions } from './schema-validator'
-export { ValidationSeverity } from './schema-validator'
+
+// Export enum as value (enums need runtime export, not just type)
+export { ValidationSeverity }
 
 export {
 	Doctype,
-	DoctypeConfig,
 	Registry,
 	Stonecrop,
-	StonecropOptions,
 	useStonecrop,
 	// HST exports for advanced usage
 	HST,
 	createHST,
 	HSTNode,
 	// Field trigger system exports
+	FieldTriggerEngine,
 	getGlobalTriggerEngine,
 	registerGlobalAction,
 	registerTransitionAction,
@@ -62,6 +53,8 @@ export {
 	useOperationLogStore,
 	useUndoRedoShortcuts,
 	withBatch,
+	// Utility functions
+	collectNestedData,
 }
 
 // Default export is the Vue plugin

package/src/plugins/index.ts

@@ -72,7 +72,10 @@ const plugin: Plugin = {
 		app.config.globalProperties.$registry = registry
 
 		// Create and provide a global Stonecrop instance
-		const stonecrop = new Stonecrop(registry, undefined, options?.client ? { client: options.client } : undefined)
+		const stonecrop = new Stonecrop(registry)
+		if (options?.client) {
+			stonecrop.setClient(options.client)
+		}
 		app.provide('$stonecrop', stonecrop)
 		app.config.globalProperties.$stonecrop = stonecrop
 

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