cxtms 1.9.13

package/dist/workflowValidator.js

@@ -0,0 +1,753 @@
+"use strict";
+/**
+ * Workflow validator for CargoXplorer YAML workflow files
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowValidator = void 0;
+const ajv_1 = __importDefault(require("ajv"));
+const ajv_formats_1 = __importDefault(require("ajv-formats"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+class WorkflowValidator {
+    constructor(options = {}) {
+        this.schemasDir = options.schemasPath || path.join(__dirname, '../schemas/workflows');
+        this.options = {
+            schemasPath: this.schemasDir,
+            strictMode: options.strictMode ?? true,
+            includeWarnings: options.includeWarnings ?? true,
+            validateTasks: options.validateTasks ?? true,
+            validateExpressions: options.validateExpressions ?? false
+        };
+        // Initialize Ajv with Draft 7 support
+        this.ajv = new ajv_1.default({
+            strict: false,
+            allErrors: true,
+            verbose: true,
+            validateFormats: true,
+            allowUnionTypes: true
+        });
+        // Add format validators
+        (0, ajv_formats_1.default)(this.ajv);
+        // Load all workflow schemas
+        this.schemas = this.loadWorkflowSchemas(this.schemasDir);
+        // Register schemas with Ajv
+        this.registerSchemas();
+    }
+    /**
+     * Load all workflow schemas from the schemas/workflows directory
+     */
+    loadWorkflowSchemas(schemasDir) {
+        const schemas = new Map();
+        // Load main workflow.json
+        const mainSchemaPath = path.join(schemasDir, 'workflow.json');
+        if (fs.existsSync(mainSchemaPath)) {
+            const schema = JSON.parse(fs.readFileSync(mainSchemaPath, 'utf-8'));
+            schemas.set('workflow.json', {
+                schema,
+                uri: `file:///${mainSchemaPath.replace(/\\/g, '/')}`
+            });
+        }
+        // Load workflow sub-schemas
+        const subSchemas = ['input.json', 'output.json', 'variable.json', 'trigger.json', 'schedule.json', 'activity.json'];
+        for (const schemaFile of subSchemas) {
+            const schemaPath = path.join(schemasDir, schemaFile);
+            if (fs.existsSync(schemaPath)) {
+                const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf-8'));
+                schemas.set(schemaFile, {
+                    schema,
+                    uri: `file:///${schemaPath.replace(/\\/g, '/')}`
+                });
+            }
+        }
+        // Load task schemas from tasks/ subdirectory
+        const tasksDir = path.join(schemasDir, 'tasks');
+        if (fs.existsSync(tasksDir)) {
+            this.loadSchemasFromDir(tasksDir, 'tasks', schemas);
+        }
+        // Load common schemas from common/ subdirectory
+        const commonDir = path.join(schemasDir, 'common');
+        if (fs.existsSync(commonDir)) {
+            this.loadSchemasFromDir(commonDir, 'common', schemas);
+        }
+        // Load flow schemas from flow/ subdirectory
+        const flowDir = path.join(schemasDir, 'flow');
+        if (fs.existsSync(flowDir)) {
+            this.loadSchemasFromDir(flowDir, 'flow', schemas);
+        }
+        return schemas;
+    }
+    /**
+     * Recursively load schemas from a directory
+     */
+    loadSchemasFromDir(dir, relativePath, schemas) {
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+            const filePath = path.join(dir, file);
+            const stat = fs.statSync(filePath);
+            if (stat.isDirectory()) {
+                this.loadSchemasFromDir(filePath, `${relativePath}/${file}`, schemas);
+            }
+            else if (file.endsWith('.json')) {
+                try {
+                    const schema = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                    const key = `${relativePath}/${file}`;
+                    schemas.set(key, {
+                        schema,
+                        uri: `file:///${filePath.replace(/\\/g, '/')}`
+                    });
+                }
+                catch (error) {
+                    console.error(`Error loading schema ${filePath}:`, error);
+                }
+            }
+        }
+    }
+    /**
+     * Register all loaded schemas with Ajv
+     */
+    registerSchemas() {
+        for (const [key, entry] of this.schemas.entries()) {
+            try {
+                this.ajv.addSchema(entry.schema, key);
+            }
+            catch (error) {
+                console.error(`Error adding schema ${key}:`, error);
+            }
+        }
+    }
+    /**
+     * Validate a YAML workflow file
+     */
+    async validateWorkflow(filePath) {
+        const errors = [];
+        const warnings = [];
+        try {
+            // Check if file exists
+            if (!fs.existsSync(filePath)) {
+                errors.push({
+                    type: 'file_not_found',
+                    path: filePath,
+                    message: `File not found: ${filePath}`
+                });
+                return this.createResult(filePath, errors, warnings);
+            }
+            // Read and parse YAML
+            const content = fs.readFileSync(filePath, 'utf-8');
+            let workflowData;
+            try {
+                workflowData = yaml_1.default.parse(content);
+            }
+            catch (yamlError) {
+                errors.push({
+                    type: 'yaml_syntax_error',
+                    path: filePath,
+                    message: `YAML syntax error: ${yamlError.message}`
+                });
+                return this.createResult(filePath, errors, warnings);
+            }
+            // Validate workflow structure
+            this.validateWorkflowStructure(workflowData, errors, warnings, filePath);
+            // Validate inputs and variables
+            this.validateInputs(workflowData, errors);
+            this.validateVariables(workflowData, errors);
+            // Validate against main workflow schema
+            const validate = this.ajv.getSchema('workflow.json');
+            if (validate && !validate(workflowData)) {
+                this.addAjvErrors(validate.errors, '', errors);
+            }
+            const isFlowWorkflow = workflowData.workflow?.workflowType === 'Flow';
+            if (isFlowWorkflow) {
+                // Validate Flow-specific sections
+                this.validateFlowWorkflow(workflowData, errors, warnings);
+            }
+            else {
+                // Validate activities recursively (standard workflows)
+                if (workflowData.activities && Array.isArray(workflowData.activities)) {
+                    this.validateActivities(workflowData.activities, 'activities', errors, warnings);
+                }
+            }
+            // Validate workflow-level event handler steps
+            this.validateEventSteps(workflowData.events, 'events', ['onWorkflowStarted', 'onWorkflowCompleted', 'onWorkflowExecuted', 'onWorkflowFailed'], errors, warnings);
+            // Warn on deprecated onWorkflowExecuted
+            if (workflowData.events && !Array.isArray(workflowData.events) && workflowData.events.onWorkflowExecuted) {
+                warnings.push({
+                    type: 'deprecated_property',
+                    path: 'events.onWorkflowExecuted',
+                    message: 'Use "onWorkflowCompleted" instead of "onWorkflowExecuted"'
+                });
+            }
+            return this.createResult(filePath, errors, warnings);
+        }
+        catch (error) {
+            errors.push({
+                type: 'unexpected_error',
+                path: filePath,
+                message: `Unexpected error: ${error.message}`
+            });
+            return this.createResult(filePath, errors, warnings);
+        }
+    }
+    /**
+     * Normalize file path: forward slashes, strip leading ./
+     */
+    normalizeFilePath(p) {
+        return p.replace(/\\/g, '/').replace(/^\.\//, '');
+    }
+    /**
+     * Validate top-level workflow structure
+     */
+    validateWorkflowStructure(workflowData, errors, warnings, filePath) {
+        // Check required top-level properties
+        if (!workflowData.workflow) {
+            errors.push({
+                type: 'missing_property',
+                path: 'workflow',
+                message: 'Missing required property: workflow'
+            });
+            return;
+        }
+        const isFlowWorkflow = workflowData.workflow?.workflowType === 'Flow';
+        if (isFlowWorkflow) {
+            if (!workflowData.entity) {
+                errors.push({
+                    type: 'missing_property',
+                    path: 'entity',
+                    message: 'Missing required property: entity (required for Flow workflows)'
+                });
+            }
+        }
+        else {
+            if (!workflowData.activities) {
+                errors.push({
+                    type: 'missing_property',
+                    path: 'activities',
+                    message: 'Missing required property: activities'
+                });
+            }
+        }
+        // Validate workflow metadata
+        const workflow = workflowData.workflow;
+        if (!workflow.workflowId) {
+            errors.push({
+                type: 'missing_property',
+                path: 'workflow.workflowId',
+                message: 'Missing required property: workflow.workflowId'
+            });
+        }
+        if (!workflow.name) {
+            errors.push({
+                type: 'missing_property',
+                path: 'workflow.name',
+                message: 'Missing required property: workflow.name'
+            });
+        }
+        // Check for deprecated properties
+        this.checkDeprecatedProperties(workflow, 'workflow', warnings);
+        // filePath / fileName deprecation and validation
+        if (workflow.fileName && !workflow.filePath) {
+            warnings.push({
+                type: 'deprecated_property',
+                path: 'workflow.fileName',
+                message: 'Use "filePath" instead of "fileName" in workflow section'
+            });
+        }
+        const declaredPath = workflow.filePath ?? workflow.fileName;
+        if (declaredPath && filePath) {
+            const normalizedActual = this.normalizeFilePath(filePath);
+            const normalizedDeclared = this.normalizeFilePath(declaredPath);
+            if (!normalizedActual.endsWith(normalizedDeclared)) {
+                warnings.push({
+                    type: 'file_path_mismatch',
+                    path: 'workflow.filePath',
+                    message: `Declared filePath "${normalizedDeclared}" does not match actual file path "${normalizedActual}"`
+                });
+            }
+        }
+    }
+    /**
+     * Validate workflow inputs.
+     * Top-level input properties are: name, type, props.
+     * Settings like required, displayName, description belong inside props.
+     */
+    validateInputs(workflowData, errors) {
+        const inputs = workflowData.inputs;
+        if (!inputs || !Array.isArray(inputs))
+            return;
+        const propsOnlyFields = ['required', 'isRequired', 'displayName', 'description', 'multiple', 'visible', 'defaultValue', 'mapping', 'filter', 'options'];
+        inputs.forEach((input, index) => {
+            const inputPath = `inputs[${index}]`;
+            for (const field of propsOnlyFields) {
+                if (field in input) {
+                    errors.push({
+                        type: 'schema_violation',
+                        path: `${inputPath}.${field}`,
+                        message: `Invalid top-level property '${field}'. Move it inside 'props'`
+                    });
+                }
+            }
+        });
+    }
+    /**
+     * Validate workflow variables.
+     * Top-level variable properties are: name, value, fromConfig.
+     */
+    validateVariables(workflowData, errors) {
+        const variables = workflowData.variables;
+        if (!variables || !Array.isArray(variables))
+            return;
+        variables.forEach((variable, index) => {
+            const varPath = `variables[${index}]`;
+            if ('type' in variable) {
+                errors.push({
+                    type: 'schema_violation',
+                    path: `${varPath}.type`,
+                    message: `Invalid property 'type' on variable. Variables only support 'name', 'value', and 'fromConfig'`
+                });
+            }
+        });
+    }
+    /**
+     * Validate activities array recursively
+     */
+    validateActivities(activities, basePath, errors, warnings) {
+        activities.forEach((activity, index) => {
+            const activityPath = `${basePath}[${index}]`;
+            this.validateActivity(activity, activityPath, errors, warnings);
+        });
+    }
+    /**
+     * Validate a single activity
+     */
+    validateActivity(activity, activityPath, errors, warnings) {
+        if (!activity || typeof activity !== 'object') {
+            errors.push({
+                type: 'invalid_activity',
+                path: activityPath,
+                message: 'Activity must be an object'
+            });
+            return;
+        }
+        // Check for required properties
+        if (!activity.name) {
+            errors.push({
+                type: 'missing_property',
+                path: `${activityPath}.name`,
+                message: 'Activity must have a name property'
+            });
+        }
+        if (!activity.steps || !Array.isArray(activity.steps)) {
+            errors.push({
+                type: 'missing_property',
+                path: `${activityPath}.steps`,
+                message: 'Activity must have a steps array'
+            });
+            return;
+        }
+        // Validate each step
+        activity.steps.forEach((step, stepIndex) => {
+            const stepPath = `${activityPath}.steps[${stepIndex}]`;
+            this.validateStep(step, stepPath, errors, warnings);
+        });
+        // Validate activity-level event handler steps
+        this.validateEventSteps(activity.events, `${activityPath}.events`, ['onActivityStarted', 'onActivityCompleted', 'onActivityFailed'], errors, warnings);
+    }
+    /**
+     * Validate steps inside event handlers (object format)
+     */
+    validateEventSteps(events, basePath, eventNames, errors, warnings) {
+        if (!events || typeof events !== 'object' || Array.isArray(events))
+            return;
+        for (const eventName of eventNames) {
+            const steps = events[eventName];
+            if (steps && Array.isArray(steps)) {
+                steps.forEach((step, index) => {
+                    this.validateStep(step, `${basePath}.${eventName}[${index}]`, errors, warnings);
+                });
+            }
+        }
+    }
+    /**
+     * Validate a single step (task)
+     */
+    validateStep(step, stepPath, errors, warnings) {
+        if (!step || typeof step !== 'object') {
+            errors.push({
+                type: 'schema_violation',
+                path: stepPath,
+                message: 'Step must be an object'
+            });
+            return;
+        }
+        // Check for task type
+        if (!step.task) {
+            errors.push({
+                type: 'missing_property',
+                path: `${stepPath}.task`,
+                message: 'Step must have a task property'
+            });
+            return;
+        }
+        // Validate nested structures (foreach, switch, while)
+        this.validateNestedSteps(step, stepPath, errors, warnings);
+    }
+    /**
+     * Validate nested structures within control flow tasks
+     */
+    validateNestedSteps(step, stepPath, errors, warnings) {
+        const taskType = step.task;
+        // Handle foreach
+        if (taskType === 'foreach') {
+            if (step.steps && Array.isArray(step.steps)) {
+                step.steps.forEach((nestedStep, index) => {
+                    this.validateStep(nestedStep, `${stepPath}.steps[${index}]`, errors, warnings);
+                });
+            }
+        }
+        // Handle switch
+        if (taskType === 'switch') {
+            if (step.cases && Array.isArray(step.cases)) {
+                step.cases.forEach((caseItem, caseIndex) => {
+                    if (caseItem.steps && Array.isArray(caseItem.steps)) {
+                        caseItem.steps.forEach((nestedStep, stepIndex) => {
+                            this.validateStep(nestedStep, `${stepPath}.cases[${caseIndex}].steps[${stepIndex}]`, errors, warnings);
+                        });
+                    }
+                });
+            }
+            if (step.default && step.default.steps && Array.isArray(step.default.steps)) {
+                step.default.steps.forEach((nestedStep, index) => {
+                    this.validateStep(nestedStep, `${stepPath}.default.steps[${index}]`, errors, warnings);
+                });
+            }
+        }
+        // Handle while
+        if (taskType === 'while') {
+            if (step.steps && Array.isArray(step.steps)) {
+                step.steps.forEach((nestedStep, index) => {
+                    this.validateStep(nestedStep, `${stepPath}.steps[${index}]`, errors, warnings);
+                });
+            }
+        }
+    }
+    /**
+     * Validate Flow workflow sections (entity, states, transitions, aggregations)
+     */
+    validateFlowWorkflow(workflowData, errors, warnings) {
+        this.validateFlowEntity(workflowData, errors);
+        const stateNames = this.validateFlowStates(workflowData, errors, warnings);
+        this.validateFlowTransitions(workflowData, stateNames, errors, warnings);
+        this.validateFlowAggregations(workflowData, errors);
+    }
+    /**
+     * Validate Flow entity section
+     */
+    validateFlowEntity(workflowData, errors) {
+        const entity = workflowData.entity;
+        if (!entity)
+            return;
+        if (!entity.name) {
+            errors.push({
+                type: 'missing_property',
+                path: 'entity.name',
+                message: 'Entity name is required for Flow workflows'
+            });
+        }
+    }
+    /**
+     * Validate Flow states and return set of state names
+     */
+    validateFlowStates(workflowData, errors, warnings) {
+        const stateNames = new Set();
+        const states = workflowData.states;
+        if (!states || !Array.isArray(states))
+            return stateNames;
+        let initialStateCount = 0;
+        const parentStates = new Set();
+        // First pass: collect state names and parents
+        for (const state of states) {
+            if (state.name)
+                stateNames.add(state.name);
+            if (state.parent)
+                parentStates.add(state.parent);
+        }
+        // Second pass: validate each state
+        states.forEach((state, index) => {
+            const statePath = `states[${index}]`;
+            if (!state.name) {
+                errors.push({
+                    type: 'missing_property',
+                    path: `${statePath}.name`,
+                    message: 'State name is required'
+                });
+                return;
+            }
+            // Check for duplicate names
+            const duplicates = states.filter((s) => s.name?.toLowerCase() === state.name?.toLowerCase());
+            if (duplicates.length > 1) {
+                errors.push({
+                    type: 'schema_violation',
+                    path: `${statePath}.name`,
+                    message: `Duplicate state name '${state.name}'`
+                });
+            }
+            if (state.isInitial)
+                initialStateCount++;
+            // Validate parent reference
+            if (state.parent && !stateNames.has(state.parent)) {
+                errors.push({
+                    type: 'schema_violation',
+                    path: `${statePath}.parent`,
+                    message: `Parent state '${state.parent}' not found`
+                });
+            }
+            // Validate onEnter/onExit steps
+            if (state.onEnter && Array.isArray(state.onEnter)) {
+                state.onEnter.forEach((step, stepIndex) => {
+                    this.validateStep(step, `${statePath}.onEnter[${stepIndex}]`, errors, warnings);
+                });
+            }
+            if (state.onExit && Array.isArray(state.onExit)) {
+                state.onExit.forEach((step, stepIndex) => {
+                    this.validateStep(step, `${statePath}.onExit[${stepIndex}]`, errors, warnings);
+                });
+            }
+        });
+        if (initialStateCount > 1) {
+            errors.push({
+                type: 'schema_violation',
+                path: 'states',
+                message: `Found ${initialStateCount} initial states. At most one state can be marked as initial.`
+            });
+        }
+        return stateNames;
+    }
+    /**
+     * Validate Flow transitions
+     */
+    validateFlowTransitions(workflowData, stateNames, errors, warnings) {
+        const transitions = workflowData.transitions;
+        if (!transitions || !Array.isArray(transitions))
+            return;
+        const transitionNames = new Set();
+        transitions.forEach((transition, index) => {
+            const transPath = `transitions[${index}]`;
+            if (!transition.name) {
+                errors.push({
+                    type: 'missing_property',
+                    path: `${transPath}.name`,
+                    message: 'Transition name is required'
+                });
+            }
+            else if (transitionNames.has(transition.name.toLowerCase())) {
+                errors.push({
+                    type: 'schema_violation',
+                    path: `${transPath}.name`,
+                    message: `Duplicate transition name '${transition.name}'`
+                });
+            }
+            else {
+                transitionNames.add(transition.name.toLowerCase());
+            }
+            // Validate from states
+            if (transition.from && stateNames.size > 0) {
+                const fromStates = Array.isArray(transition.from) ? transition.from : [transition.from];
+                for (const fromState of fromStates) {
+                    if (fromState !== '*' && !stateNames.has(fromState)) {
+                        errors.push({
+                            type: 'schema_violation',
+                            path: `${transPath}.from`,
+                            message: `Source state '${fromState}' not found in states`
+                        });
+                    }
+                }
+            }
+            // Validate to state
+            if (transition.to && stateNames.size > 0 && !stateNames.has(transition.to)) {
+                errors.push({
+                    type: 'schema_violation',
+                    path: `${transPath}.to`,
+                    message: `Target state '${transition.to}' not found in states`
+                });
+            }
+            // Validate trigger
+            const validTriggers = ['auto', 'manual', 'event'];
+            if (transition.trigger && !validTriggers.includes(transition.trigger)) {
+                errors.push({
+                    type: 'schema_violation',
+                    path: `${transPath}.trigger`,
+                    message: `Invalid trigger '${transition.trigger}'. Valid triggers: ${validTriggers.join(', ')}`
+                });
+            }
+            // Validate event trigger requires eventName
+            if (transition.trigger === 'event' && !transition.eventName) {
+                errors.push({
+                    type: 'missing_property',
+                    path: `${transPath}.eventName`,
+                    message: "eventName is required when trigger is 'event'"
+                });
+            }
+            // Validate transition steps
+            if (transition.steps && Array.isArray(transition.steps)) {
+                transition.steps.forEach((step, stepIndex) => {
+                    this.validateStep(step, `${transPath}.steps[${stepIndex}]`, errors, warnings);
+                });
+            }
+        });
+    }
+    /**
+     * Validate Flow aggregations
+     */
+    validateFlowAggregations(workflowData, errors) {
+        const aggregations = workflowData.aggregations;
+        if (!aggregations || !Array.isArray(aggregations))
+            return;
+        const validFunctions = ['all', 'any', 'sum', 'count', 'first', 'last', 'distinct', 'groupBy'];
+        const aggregationNames = new Set();
+        aggregations.forEach((aggregation, index) => {
+            const aggPath = `aggregations[${index}]`;
+            if (!aggregation.name) {
+                errors.push({
+                    type: 'missing_property',
+                    path: `${aggPath}.name`,
+                    message: 'Aggregation name is required'
+                });
+            }
+            else if (aggregationNames.has(aggregation.name.toLowerCase())) {
+                errors.push({
+                    type: 'schema_violation',
+                    path: `${aggPath}.name`,
+                    message: `Duplicate aggregation name '${aggregation.name}'`
+                });
+            }
+            else {
+                aggregationNames.add(aggregation.name.toLowerCase());
+            }
+            if (!aggregation.expression) {
+                errors.push({
+                    type: 'missing_property',
+                    path: `${aggPath}.expression`,
+                    message: 'Aggregation expression is required'
+                });
+            }
+            else {
+                const fnMatch = aggregation.expression.match(/^(\w+)\s*\(/);
+                if (fnMatch) {
+                    if (!validFunctions.includes(fnMatch[1].toLowerCase())) {
+                        errors.push({
+                            type: 'schema_violation',
+                            path: `${aggPath}.expression`,
+                            message: `Invalid aggregation function '${fnMatch[1]}'. Valid functions: ${validFunctions.join(', ')}`
+                        });
+                    }
+                }
+                else {
+                    errors.push({
+                        type: 'schema_violation',
+                        path: `${aggPath}.expression`,
+                        message: 'Aggregation expression must start with a function call'
+                    });
+                }
+            }
+        });
+    }
+    /**
+     * Convert Ajv errors to our error format
+     */
+    addAjvErrors(ajvErrors, basePath, errors) {
+        if (!ajvErrors)
+            return;
+        for (const error of ajvErrors) {
+            const errorPath = basePath ? `${basePath}${error.instancePath}` : error.instancePath.slice(1);
+            errors.push({
+                type: 'schema_violation',
+                path: errorPath || '/',
+                message: error.message || 'Schema validation failed',
+                schemaPath: error.schemaPath
+            });
+        }
+    }
+    /**
+     * Check for deprecated properties
+     */
+    checkDeprecatedProperties(obj, path, warnings) {
+        const deprecations = {
+        // Add deprecated workflow properties here as needed
+        };
+        for (const [oldProp, message] of Object.entries(deprecations)) {
+            if (oldProp in obj) {
+                warnings.push({
+                    type: 'deprecated_property',
+                    path: `${path}.${oldProp}`,
+                    message
+                });
+            }
+        }
+    }
+    /**
+     * Create validation result
+     */
+    createResult(filePath, errors, warnings) {
+        const errorsByType = {};
+        errors.forEach(error => {
+            errorsByType[error.type] = (errorsByType[error.type] || 0) + 1;
+        });
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings: this.options.includeWarnings ? warnings : [],
+            summary: {
+                file: filePath,
+                timestamp: new Date().toISOString(),
+                status: errors.length === 0 ? 'PASSED' : 'FAILED',
+                errorCount: errors.length,
+                warningCount: warnings.length,
+                errorsByType
+            }
+        };
+    }
+    /**
+     * Get all loaded schema keys
+     */
+    getLoadedSchemas() {
+        return Array.from(this.schemas.keys());
+    }
+}
+exports.WorkflowValidator = WorkflowValidator;
+//# sourceMappingURL=workflowValidator.js.map