@stonecrop/stonecrop 0.10.16 → 0.11.0

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);
+}

package/dist/src/stonecrop.d.ts

@@ -1,4 +1,3 @@
-import { type SchemaTypes } from '@stonecrop/aform';
 import type { DataClient } from '@stonecrop/schema';
 import Doctype from './doctype';
 import Registry from './registry';
@@ -18,6 +17,7 @@ export declare class Stonecrop {
      * @internal
      */
     static _root: Stonecrop;
+    /** The HST store instance for reactive state management */
     private hstStore;
     private _operationLogStore?;
     private _operationLogConfig?;
@@ -77,8 +77,8 @@ export declare class Stonecrop {
             actionError?: string | undefined;
             userId?: string | undefined;
             metadata?: Record<string, any> | undefined;
-            parentOperationId?: string | undefined;
-            childOperationIds?: string[] | undefined;
+            ancestorOperationId?: string | undefined;
+            descendantOperationIds?: string[] | undefined;
         }[], import("./types").HSTOperation[] | {
             id: string;
             type: import("./types").HSTOperationType;
@@ -101,8 +101,8 @@ export declare class Stonecrop {
             actionError?: string | undefined;
             userId?: string | undefined;
             metadata?: Record<string, any> | undefined;
-            parentOperationId?: string | undefined;
-            childOperationIds?: string[] | undefined;
+            ancestorOperationId?: string | undefined;
+            descendantOperationIds?: string[] | undefined;
         }[]>;
         currentIndex: import("vue").Ref<number, number>;
         config: import("vue").Ref<{
@@ -140,7 +140,7 @@ export declare class Stonecrop {
         getSnapshot: () => import("./types").OperationLogSnapshot;
         markIrreversible: (operationId: string, reason: string) => void;
         logAction: (doctype: string, actionName: string, recordIds?: string[], result?: "success" | "failure" | "pending", error?: string) => string;
-    }, "operations" | "clientId" | "currentIndex" | "config">, Pick<{
+    }, "operations" | "currentIndex" | "config" | "clientId">, Pick<{
         operations: import("vue").Ref<{
             id: string;
             type: import("./types").HSTOperationType;
@@ -163,8 +163,8 @@ export declare class Stonecrop {
             actionError?: string | undefined;
             userId?: string | undefined;
             metadata?: Record<string, any> | undefined;
-            parentOperationId?: string | undefined;
-            childOperationIds?: string[] | undefined;
+            ancestorOperationId?: string | undefined;
+            descendantOperationIds?: string[] | undefined;
         }[], import("./types").HSTOperation[] | {
             id: string;
             type: import("./types").HSTOperationType;
@@ -187,8 +187,8 @@ export declare class Stonecrop {
             actionError?: string | undefined;
             userId?: string | undefined;
             metadata?: Record<string, any> | undefined;
-            parentOperationId?: string | undefined;
-            childOperationIds?: string[] | undefined;
+            ancestorOperationId?: string | undefined;
+            descendantOperationIds?: string[] | undefined;
         }[]>;
         currentIndex: import("vue").Ref<number, number>;
         config: import("vue").Ref<{
@@ -249,8 +249,8 @@ export declare class Stonecrop {
             actionError?: string | undefined;
             userId?: string | undefined;
             metadata?: Record<string, any> | undefined;
-            parentOperationId?: string | undefined;
-            childOperationIds?: string[] | undefined;
+            ancestorOperationId?: string | undefined;
+            descendantOperationIds?: string[] | undefined;
         }[], import("./types").HSTOperation[] | {
             id: string;
             type: import("./types").HSTOperationType;
@@ -273,8 +273,8 @@ export declare class Stonecrop {
             actionError?: string | undefined;
             userId?: string | undefined;
             metadata?: Record<string, any> | undefined;
-            parentOperationId?: string | undefined;
-            childOperationIds?: string[] | undefined;
+            ancestorOperationId?: string | undefined;
+            descendantOperationIds?: string[] | undefined;
         }[]>;
         currentIndex: import("vue").Ref<number, number>;
         config: import("vue").Ref<{
@@ -370,7 +370,25 @@ export declare class Stonecrop {
      * @param action - The action to run
      * @param args - Action arguments (typically record IDs)
      */
-    runAction(doctype: Doctype, action: string, args?: any[]): void;
+    runAction(doctype: Doctype, action: string, args?: string[]): void;
+    /**
+     * Get the effective blockWorkflows value for a link.
+     * Returns true if blockWorkflows is explicitly true, or if it's absent and fetch method is 'sync'.
+     * @param link - The link declaration
+     * @returns Whether workflows should be blocked until this link is loaded
+     */
+    private getEffectiveBlockWorkflows;
+    /**
+     * Check if workflow actions are ready to run (all required link data is loaded).
+     * A link's data is considered loaded if it exists in HST at `slug.recordId.linkname`.
+     * @param doctype - The doctype to check
+     * @param recordId - The record ID
+     * @returns Object with `ready: true` if all blocked links are loaded, or `ready: false` with `blockedLinks` array
+     */
+    isWorkflowReady(doctype: Doctype, recordId: string): {
+        ready: boolean;
+        blockedLinks?: string[];
+    };
     /**
      * Get records from server using the configured data client.
      * @param doctype - The doctype
@@ -438,23 +456,50 @@ export declare class Stonecrop {
      */
     collectRecordPayload(doctype: Doctype, recordId: string): Record<string, any>;
     /**
-     * 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
+     * Scaffold empty descendant records from defaults for all descendant links.
+     *
+     * Initializes all scalar and link fields at their HST paths with default values.
+     * For new records, call this after setting up the doctype to ensure all paths exist.
+     *
+     * @param path - HST path (e.g., "customer.new")
+     * @param doctype - The doctype to initialize
+     * @public
+     */
+    initializeNestedData(path: string, doctype: Doctype): void;
+    /**
+     * Fetch a record and its nested data from the server.
+     *
+     * Calls `_client.getRecord()` with nested sub-selections and stores each scalar field at its own HST path
+     * (`slug.recordId.fieldname`), descendants at the link-level path (`slug.recordId.linkname`).
+     *
+     * @param path - HST path (e.g., "recipe.r1")
+     * @param doctype - The doctype to fetch
+     * @param recordId - Record ID to fetch
+     * @param options - Query options (includeNested to control which links are fetched)
+     * @throws Error with code `"CLIENT_REQUIRED"` if no data client is configured
+     * @throws Error with code `"RECORD_NOT_FOUND"` if the server returns null
      * @public
      */
-    loadNestedData(parentPath: string, childDoctype: Doctype, _recordId?: string): Record<string, any>;
+    fetchNestedData(path: string, doctype: Doctype, recordId: string, options?: {
+        includeNested?: boolean | string[];
+    }): Promise<void>;
+    /**
+     * Recursively collect nested data from HST
+     * @param basePath - The base path in HST (e.g., "customer.123.address")
+     * @param doctype - The doctype whose links drive the recursive traversal
+     * @returns The collected data object
+     */
+    private collectNestedData;
 }
 /**
- * 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
+ * Returns the global Stonecrop singleton instance, or `undefined` if no
+ * instance has been created yet.
+ *
+ * Use this when you need the Stonecrop instance outside a Vue component
+ * context (e.g., in workflow action handlers, plugin setup code, or
+ * non-component utilities). Inside a component, prefer `useStonecrop()`.
+ *
  * @public
  */
-declare function collectNestedData(resolvedSchema: SchemaTypes[], basePath: string, hstStore: HSTNode): Record<string, any>;
-export { collectNestedData };
+export declare function getStonecrop(): Stonecrop | undefined;
 //# sourceMappingURL=stonecrop.d.ts.map

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

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