@stonecrop/stonecrop 0.11.0 → 0.11.1

package/dist/src/registry.js

@@ -1,246 +0,0 @@
-import { getGlobalTriggerEngine } from './field-triggers';
-/**
- * Stonecrop Registry class
- * @public
- */
-export default class Registry {
-    /**
-     * The root Registry instance
-     */
-    static _root;
-    /**
-     * The name of the Registry instance
-     *
-     * @defaultValue 'Registry'
-     */
-    name = 'Registry';
-    /**
-     * The registry property contains a collection of doctypes
-     * @see {@link Doctype}
-     */
-    registry = {};
-    /**
-     * The Vue router instance
-     * @see {@link https://router.vuejs.org/}
-     */
-    router;
-    /**
-     * Creates a new Registry instance (singleton pattern)
-     * @param router - Optional Vue router instance for route management
-     * @param getMeta - Optional function to fetch doctype metadata from an API
-     */
-    constructor(router, getMeta) {
-        if (Registry._root) {
-            return Registry._root;
-        }
-        Registry._root = this;
-        this.router = router;
-        this.getMeta = getMeta;
-    }
-    /**
-     * The getMeta function fetches doctype metadata from an API based on route context
-     * @see {@link Doctype}
-     */
-    getMeta;
-    /**
-     * Get doctype metadata
-     * @param doctype - The doctype to fetch metadata for
-     * @returns The doctype metadata
-     * @see {@link Doctype}
-     */
-    addDoctype(doctype) {
-        if (!(doctype.slug in this.registry)) {
-            this.registry[doctype.slug] = doctype;
-        }
-        // Register actions (including field triggers) with the field trigger engine
-        const triggerEngine = getGlobalTriggerEngine();
-        // Register under both doctype name and slug to handle different lookup patterns
-        triggerEngine.registerDoctypeActions(doctype.doctype, doctype.actions);
-        if (doctype.slug !== doctype.doctype) {
-            triggerEngine.registerDoctypeActions(doctype.slug, doctype.actions);
-        }
-        if (doctype.component && this.router && !this.router.hasRoute(doctype.doctype)) {
-            this.router.addRoute({
-                path: `/${doctype.slug}`,
-                name: doctype.slug,
-                component: doctype.component,
-            });
-        }
-    }
-    /**
-     * 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:
-     *
-     * - 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.
-     *
-     * @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, visited) {
-        const seen = visited || new Set();
-        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 = Array.isArray(doctype.schema) ? doctype.schema : Array.from(doctype.schema);
-                    // Check cardinality to determine handling
-                    const cardinality = 'cardinality' in field ? field.cardinality : undefined;
-                    if (cardinality === 'many') {
-                        // 1:many child table - derive columns, set component, config, rows
-                        const resolved = { ...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;
-                    }
-                    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);
-                        return { ...field, schema: resolvedChild };
-                    }
-                }
-            }
-            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`
-     * - 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 (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
-     *
-     * @example
-     * ```ts
-     * const defaults = registry.initializeRecord(addressSchema)
-     * // { street: '', city: '', state: '', zip_code: '' }
-     * ```
-     *
-     * @public
-     */
-    initializeRecord(schema) {
-        const record = {};
-        schema.forEach(field => {
-            const fieldtype = 'fieldtype' in field ? field.fieldtype : '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 'JSON':
-                    record[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
-                        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;
-            }
-        });
-        return record;
-    }
-    /**
-     * Get a registered doctype by slug
-     * @param slug - The doctype slug to look up
-     * @returns The Doctype instance if found, or undefined
-     * @public
-     */
-    getDoctype(slug) {
-        return this.registry[slug];
-    }
-}

package/dist/src/schema-validator.js

@@ -1,315 +0,0 @@
-/**
- * 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);
-}