@onlineapps/conn-orch-validator 7.0.0 → 8.0.0

package/src/WorkflowTestRunner.js

@@ -1,402 +0,0 @@
-'use strict';
-
-const EventEmitter = require('events');
-
-/**
- * WorkflowTestRunner - Executes and tests cookbook workflows
- */
-class WorkflowTestRunner extends EventEmitter {
-  constructor(options = {}) {
-    super();
-    this.mqClient = options.mqClient;
-    this.registry = options.registry;
-    this.storage = options.storage;
-    this.timeout = options.timeout || 30000;
-    this.debug = options.debug || false;
-    this.runningWorkflows = new Map();
-  }
-
-  /**
-   * Run workflow test
-   */
-  async runWorkflow(cookbook, initialContext = {}) {
-    const workflowId = `test-workflow-${Date.now()}`;
-    
-    const workflow = {
-      id: workflowId,
-      cookbook,
-      context: {
-        api_input: initialContext,
-        steps: {}
-      },
-      status: 'running',
-      startedAt: Date.now(),
-      currentStep: 0,
-      results: [],
-      errors: []
-    };
-
-    this.runningWorkflows.set(workflowId, workflow);
-    this.emit('workflow:started', { workflowId, cookbook });
-
-    try {
-      // Execute steps sequentially
-      for (let i = 0; i < cookbook.steps.length; i++) {
-        const step = cookbook.steps[i];
-        workflow.currentStep = i;
-        
-        const stepResult = await this.executeStep(step, workflow);
-        workflow.results.push(stepResult);
-        
-        if (!stepResult.success) {
-          workflow.status = 'failed';
-          workflow.errors.push(stepResult.error);
-          this.emit('workflow:failed', { workflowId, error: stepResult.error });
-          break;
-        }
-        
-        // Update context with step result
-        workflow.context.steps[step.id] = stepResult.data;
-      }
-
-      if (workflow.status !== 'failed') {
-        workflow.status = 'completed';
-        workflow.completedAt = Date.now();
-        this.emit('workflow:completed', { workflowId, results: workflow.results });
-      }
-
-    } catch (error) {
-      workflow.status = 'error';
-      workflow.errors.push(error.message);
-      this.emit('workflow:error', { workflowId, error: error.message });
-    }
-
-    return workflow;
-  }
-
-  /**
-   * Execute individual step
-   */
-  async executeStep(step, workflow) {
-    const startTime = Date.now();
-    
-    this.emit('step:started', { 
-      workflowId: workflow.id, 
-      stepId: step.id, 
-      type: step.type 
-    });
-
-    const result = {
-      stepId: step.id,
-      type: step.type,
-      success: false,
-      data: null,
-      error: null,
-      duration: 0
-    };
-
-    try {
-      switch (step.type) {
-        case 'task':
-          result.data = await this.executeTaskStep(step, workflow);
-          break;
-        
-        case 'foreach':
-          result.data = await this.executeForeachStep(step, workflow);
-          break;
-        
-        case 'switch':
-          result.data = await this.executeSwitchStep(step, workflow);
-          break;
-        
-        case 'fork_join':
-          result.data = await this.executeForkJoinStep(step, workflow);
-          break;
-        
-        default:
-          throw new Error(`Unknown step type: ${step.type}`);
-      }
-      
-      result.success = true;
-      result.duration = Date.now() - startTime;
-      
-      this.emit('step:completed', { 
-        workflowId: workflow.id, 
-        stepId: step.id, 
-        result 
-      });
-
-    } catch (error) {
-      result.error = error.message;
-      result.duration = Date.now() - startTime;
-      
-      this.emit('step:failed', { 
-        workflowId: workflow.id, 
-        stepId: step.id, 
-        error: error.message 
-      });
-    }
-
-    return result;
-  }
-
-  /**
-   * Execute task step
-   */
-  async executeTaskStep(step, workflow) {
-    const { service, operation, input } = step;
-    
-    // Resolve input using JSONPath
-    const resolvedInput = this.resolveInput(input, workflow.context);
-    
-    if (this.debug) {
-      // WHICH operation ran, never WHAT it carried: the resolved input is the
-      // workflow's payload, and printing it to stdout put whatever the cookbook
-      // held — identifiers, amounts, anything — into the terminal and every log
-      // collector behind it. This class takes no logger (constructor above), so
-      // the trace stays on console; giving it one is an API change and the
-      // owner's call, not a side effect of this fix.
-      console.log(`Executing task: ${service}.${operation}`);
-    }
-
-    // Get service from registry
-    const serviceInfo = await this.registry.getService(service);
-    if (!serviceInfo) {
-      throw new Error(`Service not found: ${service}`);
-    }
-
-    // Simulate API call or send to queue
-    if (this.mqClient) {
-      // Send to service queue
-      const queueName = `service.${service}.request`;
-      await this.mqClient.publish(queueName, {
-        workflow_id: workflow.id,
-        step_id: step.id,
-        operation,
-        input: resolvedInput
-      });
-
-      // Wait for response (with timeout)
-      const response = await this.waitForResponse(
-        workflow.id, 
-        step.id, 
-        this.timeout
-      );
-      
-      return response;
-    } else {
-      // Simulate response
-      return {
-        processed: true,
-        operation,
-        input: resolvedInput,
-        output: { simulated: true }
-      };
-    }
-  }
-
-  /**
-   * Execute foreach step
-   */
-  async executeForeachStep(step, workflow) {
-    const { items, body } = step;
-    
-    // Resolve items array
-    const itemsArray = this.resolveInput(items, workflow.context);
-    if (!Array.isArray(itemsArray)) {
-      throw new Error('Foreach items must resolve to an array');
-    }
-
-    const results = [];
-    for (const item of itemsArray) {
-      // Create context with current item
-      const itemContext = {
-        ...workflow.context,
-        current_item: item
-      };
-      
-      // Execute body step for each item
-      const itemWorkflow = { ...workflow, context: itemContext };
-      const result = await this.executeStep(body, itemWorkflow);
-      results.push(result);
-    }
-
-    return { items: itemsArray.length, results };
-  }
-
-  /**
-   * Execute switch step
-   */
-  async executeSwitchStep(step, workflow) {
-    const { condition, cases, default: defaultCase } = step;
-    
-    // Resolve condition value
-    const conditionValue = this.resolveInput(condition, workflow.context);
-    
-    // Find matching case
-    const matchingCase = cases.find(c => c.value === conditionValue);
-    const stepToExecute = matchingCase ? matchingCase.step : defaultCase;
-    
-    if (!stepToExecute) {
-      throw new Error(`No matching case for condition value: ${conditionValue}`);
-    }
-
-    // Execute the selected step
-    const result = await this.executeStep(stepToExecute, workflow);
-    
-    return {
-      condition: conditionValue,
-      executed: stepToExecute.id,
-      result
-    };
-  }
-
-  /**
-   * Execute fork-join step
-   */
-  async executeForkJoinStep(step, workflow) {
-    const { branches, join } = step;
-    
-    // Execute all branches in parallel
-    const branchPromises = branches.map(branch => 
-      this.executeStep(branch, workflow)
-    );
-    
-    const results = await Promise.all(branchPromises);
-    
-    // Apply join strategy
-    let joinedResult;
-    switch (join.strategy) {
-      case 'merge':
-        joinedResult = this.mergeResults(results);
-        break;
-      case 'first':
-        joinedResult = results[0];
-        break;
-      case 'all':
-        joinedResult = results;
-        break;
-      default:
-        joinedResult = results;
-    }
-    
-    return {
-      branches: branches.length,
-      strategy: join.strategy,
-      result: joinedResult
-    };
-  }
-
-  /**
-   * Resolve input using JSONPath or direct value
-   */
-  resolveInput(input, context) {
-    if (!input) return null;
-    
-    if (typeof input === 'string' && input.startsWith('$')) {
-      // JSONPath resolution
-      return this.resolveJsonPath(input, context);
-    }
-    
-    if (typeof input === 'object' && input !== null) {
-      // Recursively resolve object properties
-      const resolved = {};
-      for (const [key, value] of Object.entries(input)) {
-        resolved[key] = this.resolveInput(value, context);
-      }
-      return resolved;
-    }
-    
-    return input;
-  }
-
-  /**
-   * Simple JSONPath resolution
-   */
-  resolveJsonPath(path, context) {
-    // Remove leading $
-    const pathParts = path.substring(1).split('.');
-    
-    let current = context;
-    for (const part of pathParts) {
-      if (current === null || current === undefined) {
-        return null;
-      }
-      current = current[part];
-    }
-    
-    return current;
-  }
-
-  /**
-   * Wait for step response from queue
-   */
-  async waitForResponse(workflowId, stepId, timeout) {
-    return new Promise((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        reject(new Error(`Timeout waiting for response: ${stepId}`));
-      }, timeout);
-
-      // Listen for response on response queue
-      const responseQueue = `workflow.${workflowId}.response`;
-      
-      this.mqClient.consume(responseQueue, (msg) => {
-        const message = JSON.parse(msg.content.toString());
-        
-        if (message.step_id === stepId) {
-          clearTimeout(timeoutId);
-          this.mqClient.ack(msg);
-          resolve(message.result);
-        }
-      });
-    });
-  }
-
-  /**
-   * Merge results from parallel branches
-   */
-  mergeResults(results) {
-    const merged = {};
-    
-    results.forEach((result, index) => {
-      if (result.data && typeof result.data === 'object') {
-        Object.assign(merged, result.data);
-      } else {
-        merged[`branch_${index}`] = result.data;
-      }
-    });
-    
-    return merged;
-  }
-
-  /**
-   * Get workflow status
-   */
-  getWorkflowStatus(workflowId) {
-    return this.runningWorkflows.get(workflowId);
-  }
-
-  /**
-   * Stop workflow
-   */
-  stopWorkflow(workflowId) {
-    const workflow = this.runningWorkflows.get(workflowId);
-    if (workflow && workflow.status === 'running') {
-      workflow.status = 'stopped';
-      this.emit('workflow:stopped', { workflowId });
-    }
-  }
-
-  /**
-   * Clear completed workflows
-   */
-  clearCompleted() {
-    for (const [id, workflow] of this.runningWorkflows.entries()) {
-      if (workflow.status === 'completed' || workflow.status === 'failed') {
-        this.runningWorkflows.delete(id);
-      }
-    }
-  }
-}
-
-module.exports = WorkflowTestRunner;