@stonecrop/stonecrop 0.6.3 → 0.7.1

package/dist/src/index.d.ts

@@ -9,10 +9,13 @@ import Registry from './registry';
 import { Stonecrop } from './stonecrop';
 import { HST, createHST, type HSTNode } from './stores/hst';
 import { useOperationLogStore } from './stores/operation-log';
+import { SchemaValidator, createValidator, validateSchema } from './schema-validator';
 export type * from './types';
 export type { BaseStonecropReturn, HSTChangeData, HSTStonecropReturn, OperationLogAPI } from './composable';
 export type { FieldTriggerEngine } from './field-triggers';
 export type { FieldChangeContext, TransitionChangeContext, FieldTriggerExecutionResult, ActionExecutionResult, TransitionExecutionResult, FieldActionFunction, TransitionActionFunction, } from './types/field-triggers';
-export { DoctypeMeta, Registry, Stonecrop, useStonecrop, HST, createHST, HSTNode, getGlobalTriggerEngine, registerGlobalAction, registerTransitionAction, setFieldRollback, triggerTransition, markOperationIrreversible, useOperationLog, useOperationLogStore, useUndoRedoShortcuts, withBatch, };
+export type { ValidationIssue, ValidationResult, ValidatorOptions } from './schema-validator';
+export { ValidationSeverity } from './schema-validator';
+export { DoctypeMeta, Registry, Stonecrop, useStonecrop, HST, createHST, HSTNode, getGlobalTriggerEngine, registerGlobalAction, registerTransitionAction, setFieldRollback, triggerTransition, markOperationIrreversible, SchemaValidator, createValidator, validateSchema, useOperationLog, useOperationLogStore, useUndoRedoShortcuts, withBatch, };
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,wBAAwB,CAAA;AAC3C,mBAAmB,yBAAyB,CAAA;AAE5C,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AAC9F,OAAO,WAAW,MAAM,WAAW,CAAA;AACnC,OAAO,EACN,sBAAsB,EACtB,yBAAyB,EACzB,oBAAoB,EACpB,wBAAwB,EACxB,gBAAgB,EAChB,iBAAiB,EACjB,MAAM,kBAAkB,CAAA;AACzB,OAAO,MAAM,MAAM,WAAW,CAAA;AAC9B,OAAO,QAAQ,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAC7D,mBAAmB,SAAS,CAAA;AAC5B,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC3G,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,YAAY,EACX,kBAAkB,EAClB,uBAAuB,EACvB,2BAA2B,EAC3B,qBAAqB,EACrB,yBAAyB,EACzB,mBAAmB,EACnB,wBAAwB,GACxB,MAAM,wBAAwB,CAAA;AAE/B,OAAO,EACN,WAAW,EACX,QAAQ,EACR,SAAS,EACT,YAAY,EAEZ,GAAG,EACH,SAAS,EACT,OAAO,EAEP,sBAAsB,EACtB,oBAAoB,EACpB,wBAAwB,EACxB,gBAAgB,EAChB,iBAAiB,EACjB,yBAAyB,EAEzB,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,SAAS,GACT,CAAA;AAGD,eAAe,MAAM,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,wBAAwB,CAAA;AAC3C,mBAAmB,yBAAyB,CAAA;AAE5C,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AAC9F,OAAO,WAAW,MAAM,WAAW,CAAA;AACnC,OAAO,EACN,sBAAsB,EACtB,yBAAyB,EACzB,oBAAoB,EACpB,wBAAwB,EACxB,gBAAgB,EAChB,iBAAiB,EACjB,MAAM,kBAAkB,CAAA;AACzB,OAAO,MAAM,MAAM,WAAW,CAAA;AAC9B,OAAO,QAAQ,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAE7D,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACrF,mBAAmB,SAAS,CAAA;AAC5B,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC3G,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,YAAY,EACX,kBAAkB,EAClB,uBAAuB,EACvB,2BAA2B,EAC3B,qBAAqB,EACrB,yBAAyB,EACzB,mBAAmB,EACnB,wBAAwB,GACxB,MAAM,wBAAwB,CAAA;AAE/B,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAC7F,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAEvD,OAAO,EACN,WAAW,EACX,QAAQ,EACR,SAAS,EACT,YAAY,EAEZ,GAAG,EACH,SAAS,EACT,OAAO,EAEP,sBAAsB,EACtB,oBAAoB,EACpB,wBAAwB,EACxB,gBAAgB,EAChB,iBAAiB,EACjB,yBAAyB,EAEzB,eAAe,EACf,eAAe,EACf,cAAc,EAEd,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,SAAS,GACT,CAAA;AAGD,eAAe,MAAM,CAAA"}

package/dist/src/index.js

@@ -7,11 +7,16 @@ import Registry from './registry';
 import { Stonecrop } from './stonecrop';
 import { HST, createHST } from './stores/hst';
 import { useOperationLogStore } from './stores/operation-log';
+// Export schema validator
+import { SchemaValidator, createValidator, validateSchema } from './schema-validator';
+export { ValidationSeverity } from './schema-validator';
 export { DoctypeMeta, Registry, Stonecrop, useStonecrop, 
 // HST exports for advanced usage
 HST, createHST, 
 // Field trigger system exports
 getGlobalTriggerEngine, registerGlobalAction, registerTransitionAction, setFieldRollback, triggerTransition, markOperationIrreversible, 
+// Schema validator exports
+SchemaValidator, createValidator, validateSchema, 
 // Operation log exports
 useOperationLog, useOperationLogStore, useUndoRedoShortcuts, withBatch, };
 // Default export is the Vue plugin

package/dist/src/schema-validator.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Schema Validation Utilities
+ * Validates Stonecrop schemas for integrity and consistency
+ * @packageDocumentation
+ */
+import type { SchemaTypes } from '@stonecrop/aform';
+import type { List, Map as ImmutableMap } from 'immutable';
+import type { AnyStateNodeConfig } from 'xstate';
+import type Registry from './registry';
+/**
+ * Validation severity levels
+ * @public
+ */
+export declare 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;
+}
+/**
+ * Schema validator class
+ * @public
+ */
+export declare class SchemaValidator {
+    private options;
+    /**
+     * Creates a new SchemaValidator instance
+     * @param options - Validator configuration options
+     */
+    constructor(options?: ValidatorOptions);
+    /**
+     * Validates a complete doctype schema
+     * @param doctype - Doctype name
+     * @param schema - Schema fields (List or Array)
+     * @param workflow - Optional workflow configuration
+     * @param actions - Optional actions map
+     * @returns Validation result
+     */
+    validate(doctype: string, schema: List<SchemaTypes> | SchemaTypes[] | undefined, workflow?: AnyStateNodeConfig, actions?: ImmutableMap<string, string[]> | Map<string, string[]>): ValidationResult;
+    /**
+     * Validates that required schema properties are present
+     * @internal
+     */
+    private validateRequiredProperties;
+    /**
+     * Validates Link field targets exist in registry
+     * @internal
+     */
+    private validateLinkFields;
+    /**
+     * Validates workflow state machine configuration
+     * @internal
+     */
+    private validateWorkflow;
+    /**
+     * Validates that actions are registered in the FieldTriggerEngine
+     * @internal
+     */
+    private validateActionRegistration;
+}
+/**
+ * Creates a validator with the given registry
+ * @param registry - Registry instance
+ * @param options - Additional validator options
+ * @returns SchemaValidator instance
+ * @public
+ */
+export declare function createValidator(registry: Registry, options?: Partial<ValidatorOptions>): SchemaValidator;
+/**
+ * Quick validation helper
+ * @param doctype - Doctype name
+ * @param schema - Schema fields
+ * @param registry - Registry instance
+ * @param workflow - Optional workflow configuration
+ * @param actions - Optional actions map
+ * @returns Validation result
+ * @public
+ */
+export declare function validateSchema(doctype: string, schema: List<SchemaTypes> | SchemaTypes[] | undefined, registry: Registry, workflow?: AnyStateNodeConfig, actions?: ImmutableMap<string, string[]> | Map<string, string[]>): ValidationResult;
+//# sourceMappingURL=schema-validator.d.ts.map

package/dist/src/schema-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-validator.d.ts","sourceRoot":"","sources":["../../src/schema-validator.ts"],"names":[],"mappings":"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"}

package/dist/src/schema-validator.js

@@ -0,0 +1,315 @@
+/**
+ * Schema Validation Utilities
+ * Validates Stonecrop schemas for integrity and consistency
+ * @packageDocumentation
+ */
+import { getGlobalTriggerEngine } from './field-triggers';
+/**
+ * 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 = {}));
+/**
+ * Schema validator class
+ * @public
+ */
+export class SchemaValidator {
+    options;
+    /**
+     * Creates a new SchemaValidator instance
+     * @param options - Validator configuration options
+     */
+    constructor(options = {}) {
+        this.options = {
+            registry: options.registry || null,
+            validateLinkTargets: options.validateLinkTargets ?? true,
+            validateActions: options.validateActions ?? true,
+            validateWorkflows: options.validateWorkflows ?? true,
+            validateRequiredProperties: options.validateRequiredProperties ?? true,
+        };
+    }
+    /**
+     * Validates a complete doctype schema
+     * @param doctype - Doctype name
+     * @param schema - Schema fields (List or Array)
+     * @param workflow - Optional workflow configuration
+     * @param actions - Optional actions map
+     * @returns Validation result
+     */
+    validate(doctype, schema, workflow, actions) {
+        const issues = [];
+        // Convert schema to array for easier iteration
+        const schemaArray = schema ? (Array.isArray(schema) ? schema : schema.toArray()) : [];
+        // Validate required properties
+        if (this.options.validateRequiredProperties) {
+            issues.push(...this.validateRequiredProperties(doctype, schemaArray));
+        }
+        // Validate Link field targets
+        if (this.options.validateLinkTargets && this.options.registry) {
+            issues.push(...this.validateLinkFields(doctype, schemaArray, this.options.registry));
+        }
+        // Validate workflow configuration
+        if (this.options.validateWorkflows && workflow) {
+            issues.push(...this.validateWorkflow(doctype, workflow));
+        }
+        // Validate action registration
+        if (this.options.validateActions && actions) {
+            const actionsMap = actions instanceof Map ? actions : actions.toObject();
+            issues.push(...this.validateActionRegistration(doctype, actionsMap));
+        }
+        // Calculate counts
+        const errorCount = issues.filter(i => i.severity === ValidationSeverity.ERROR).length;
+        const warningCount = issues.filter(i => i.severity === ValidationSeverity.WARNING).length;
+        const infoCount = issues.filter(i => i.severity === ValidationSeverity.INFO).length;
+        return {
+            valid: errorCount === 0,
+            issues,
+            errorCount,
+            warningCount,
+            infoCount,
+        };
+    }
+    /**
+     * Validates that required schema properties are present
+     * @internal
+     */
+    validateRequiredProperties(doctype, schema) {
+        const issues = [];
+        for (const field of schema) {
+            // Check for fieldname
+            if (!field.fieldname) {
+                issues.push({
+                    severity: ValidationSeverity.ERROR,
+                    rule: 'required-fieldname',
+                    message: 'Field is missing required property: fieldname',
+                    doctype,
+                    context: { field },
+                });
+                continue;
+            }
+            // Check for component or fieldtype
+            if (!field.component && !('fieldtype' in field)) {
+                issues.push({
+                    severity: ValidationSeverity.ERROR,
+                    rule: 'required-component-or-fieldtype',
+                    message: `Field "${field.fieldname}" must have either component or fieldtype property`,
+                    doctype,
+                    fieldname: field.fieldname,
+                });
+            }
+            // Validate nested schemas (recursively)
+            if ('schema' in field) {
+                const nestedSchema = field.schema;
+                const nestedArray = (Array.isArray(nestedSchema) ? nestedSchema : nestedSchema.toArray?.() || []);
+                issues.push(...this.validateRequiredProperties(doctype, nestedArray));
+            }
+        }
+        return issues;
+    }
+    /**
+     * Validates Link field targets exist in registry
+     * @internal
+     */
+    validateLinkFields(doctype, schema, registry) {
+        const issues = [];
+        for (const field of schema) {
+            const fieldtype = 'fieldtype' in field ? field.fieldtype : undefined;
+            // Check Link fields
+            if (fieldtype === 'Link') {
+                const options = 'options' in field ? field.options : undefined;
+                if (!options) {
+                    issues.push({
+                        severity: ValidationSeverity.ERROR,
+                        rule: 'link-missing-options',
+                        message: `Link field "${field.fieldname}" is missing options property (target doctype)`,
+                        doctype,
+                        fieldname: field.fieldname,
+                    });
+                    continue;
+                }
+                // Check if target doctype exists in registry
+                // Options should be a string representing the target doctype name
+                const targetDoctype = typeof options === 'string' ? options : '';
+                if (!targetDoctype) {
+                    issues.push({
+                        severity: ValidationSeverity.ERROR,
+                        rule: 'link-invalid-options',
+                        message: `Link field "${field.fieldname}" has invalid options format (expected string doctype name)`,
+                        doctype,
+                        fieldname: field.fieldname,
+                    });
+                    continue;
+                }
+                const targetMeta = registry.registry[targetDoctype] || registry.registry[targetDoctype.toLowerCase()];
+                if (!targetMeta) {
+                    issues.push({
+                        severity: ValidationSeverity.ERROR,
+                        rule: 'link-invalid-target',
+                        message: `Link field "${field.fieldname}" references non-existent doctype: "${targetDoctype}"`,
+                        doctype,
+                        fieldname: field.fieldname,
+                        context: { targetDoctype },
+                    });
+                }
+            }
+            // Recursively check nested schemas
+            if ('schema' in field) {
+                const nestedSchema = field.schema;
+                const nestedArray = (Array.isArray(nestedSchema) ? nestedSchema : nestedSchema.toArray?.() || []);
+                issues.push(...this.validateLinkFields(doctype, nestedArray, registry));
+            }
+        }
+        return issues;
+    }
+    /**
+     * Validates workflow state machine configuration
+     * @internal
+     */
+    validateWorkflow(doctype, workflow) {
+        const issues = [];
+        // Check for initial state
+        if (!workflow.initial && !workflow.type) {
+            issues.push({
+                severity: ValidationSeverity.WARNING,
+                rule: 'workflow-missing-initial',
+                message: 'Workflow is missing initial state property',
+                doctype,
+            });
+        }
+        // Check for states
+        if (!workflow.states || Object.keys(workflow.states).length === 0) {
+            issues.push({
+                severity: ValidationSeverity.WARNING,
+                rule: 'workflow-no-states',
+                message: 'Workflow has no states defined',
+                doctype,
+            });
+            return issues;
+        }
+        // Validate initial state exists
+        if (workflow.initial && typeof workflow.initial === 'string' && !workflow.states[workflow.initial]) {
+            issues.push({
+                severity: ValidationSeverity.ERROR,
+                rule: 'workflow-invalid-initial',
+                message: `Workflow initial state "${workflow.initial}" does not exist in states`,
+                doctype,
+                context: { initialState: workflow.initial },
+            });
+        }
+        // Check state reachability (simple check - all states should have at least one incoming transition or be initial)
+        const stateNames = Object.keys(workflow.states);
+        const reachableStates = new Set();
+        // Initial state is always reachable
+        if (workflow.initial && typeof workflow.initial === 'string') {
+            reachableStates.add(workflow.initial);
+        }
+        // Find all target states from transitions
+        for (const [_stateName, stateConfig] of Object.entries(workflow.states)) {
+            const state = stateConfig;
+            if (state.on) {
+                for (const [_event, transition] of Object.entries(state.on)) {
+                    if (typeof transition === 'string') {
+                        reachableStates.add(transition);
+                    }
+                    else if (transition && typeof transition === 'object') {
+                        const target = 'target' in transition ? transition.target : undefined;
+                        if (typeof target === 'string') {
+                            reachableStates.add(target);
+                        }
+                        else if (Array.isArray(target)) {
+                            target.forEach((t) => {
+                                if (typeof t === 'string') {
+                                    reachableStates.add(t);
+                                }
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // Check for unreachable states
+        for (const stateName of stateNames) {
+            if (!reachableStates.has(stateName)) {
+                issues.push({
+                    severity: ValidationSeverity.WARNING,
+                    rule: 'workflow-unreachable-state',
+                    message: `Workflow state "${stateName}" may not be reachable`,
+                    doctype,
+                    context: { stateName },
+                });
+            }
+        }
+        return issues;
+    }
+    /**
+     * Validates that actions are registered in the FieldTriggerEngine
+     * @internal
+     */
+    validateActionRegistration(doctype, actions) {
+        const issues = [];
+        const triggerEngine = getGlobalTriggerEngine();
+        for (const [triggerName, actionNames] of Object.entries(actions)) {
+            if (!Array.isArray(actionNames)) {
+                issues.push({
+                    severity: ValidationSeverity.ERROR,
+                    rule: 'action-invalid-format',
+                    message: `Action configuration for "${triggerName}" must be an array`,
+                    doctype,
+                    context: { triggerName, actionNames },
+                });
+                continue;
+            }
+            // Check each action name
+            for (const actionName of actionNames) {
+                // Check if action is registered globally
+                const engine = triggerEngine;
+                const isRegistered = engine.globalActions?.has(actionName) || engine.globalTransitionActions?.has(actionName);
+                if (!isRegistered) {
+                    issues.push({
+                        severity: ValidationSeverity.WARNING,
+                        rule: 'action-not-registered',
+                        message: `Action "${actionName}" referenced in "${triggerName}" is not registered in FieldTriggerEngine`,
+                        doctype,
+                        context: { triggerName, actionName },
+                    });
+                }
+            }
+        }
+        return issues;
+    }
+}
+/**
+ * Creates a validator with the given registry
+ * @param registry - Registry instance
+ * @param options - Additional validator options
+ * @returns SchemaValidator instance
+ * @public
+ */
+export function createValidator(registry, options) {
+    return new SchemaValidator({
+        registry,
+        ...options,
+    });
+}
+/**
+ * Quick validation helper
+ * @param doctype - Doctype name
+ * @param schema - Schema fields
+ * @param registry - Registry instance
+ * @param workflow - Optional workflow configuration
+ * @param actions - Optional actions map
+ * @returns Validation result
+ * @public
+ */
+export function validateSchema(doctype, schema, registry, workflow, actions) {
+    const validator = createValidator(registry);
+    return validator.validate(doctype, schema, workflow, actions);
+}