@onlineapps/conn-orch-orchestrator 1.0.10 → 1.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/conn-orch-orchestrator",
-  "version": "1.0.10",
+  "version": "1.0.13",
   "description": "Workflow orchestration connector for OA Drive - handles message routing and workflow execution",
   "main": "src/index.js",
   "scripts": {

package/src/WorkflowOrchestrator.js

@@ -37,10 +37,18 @@ class WorkflowOrchestrator {
     this.logger = config.logger || console;
     this.defaultTimeout = config.defaultTimeout || 30000;
 
-    // Create cookbook router
-    this.router = this.cookbook.createRouter(this.mqClient, this.registryClient, {
-      logger: this.logger
-    });
+    // Create cookbook router - createRouter is an exported function, not a method
+    const { createRouter } = this.cookbook;
+    if (typeof createRouter === 'function') {
+      this.router = createRouter(this.mqClient, this.registryClient, {
+        logger: this.logger
+      });
+    } else {
+      // Fallback: try calling it as method (backward compatibility)
+      this.router = this.cookbook.createRouter?.(this.mqClient, this.registryClient, {
+        logger: this.logger
+      }) || null;
+    }
   }
 
   /**
@@ -87,7 +95,13 @@ class WorkflowOrchestrator {
       // Check if this step is for this service
       if (step.type === 'task' && step.service !== serviceName) {
         this.logger.warn(`Step ${current_step} is for ${step.service}, not ${serviceName}`);
-        await this.router.routeToService(step.service, message);
+        if (this.router?.routeToService) {
+          await this.router.routeToService(step.service, message);
+        } else {
+          // Fallback: publish to service's workflow queue directly
+          const serviceQueue = `${step.service}.workflow`;
+          await this.mqClient.publish(serviceQueue, message);
+        }
         return { skipped: true, reason: 'wrong_service' };
       }
 
@@ -251,21 +265,82 @@ class WorkflowOrchestrator {
    * @returns {Promise<Object>} API call result
    */
   async _executeTaskStep(step, context) {
-    // Use API mapper to call the service
+    // Resolve variable references in step.input (e.g. ${steps[0].output.message})
+    console.log(`[WorkflowOrchestrator] [RESOLVE] Step ${step.id} input BEFORE:`, JSON.stringify(step.input));
+    console.log(`[WorkflowOrchestrator] [RESOLVE] Context.steps:`, JSON.stringify(context.steps?.map(s => ({ id: s.id, output: s.output }))));
+    
+    const resolvedInput = this._resolveInputReferences(step.input, context);
+    console.log(`[WorkflowOrchestrator] [RESOLVE] Step ${step.id} input AFTER:`, JSON.stringify(resolvedInput));
+    
+    // Use API mapper to call the service with resolved input
     const result = await this.apiMapper.callOperation(
       step.operation || step.id,
-      step.input,
+      resolvedInput,
       context
     );
 
     this.logger.info(`Task step executed`, {
       step: step.id,
       service: step.service,
-      operation: step.operation
+      operation: step.operation,
+      inputResolved: !!resolvedInput
     });
 
     return result;
   }
+  
+  /**
+   * Resolve variable references in input object
+   * Supports ${steps[N].output.field}, ${api_input.field}, ${context.field}
+   * @private
+   * @param {Object} input - Input object with potential references
+   * @param {Object} context - Current context with steps, api_input, etc
+   * @returns {Object} Resolved input object
+   */
+  _resolveInputReferences(input, context) {
+    if (!input) return input;
+    
+    const resolveValue = (value) => {
+      if (typeof value === 'string' && value.includes('${')) {
+        // Replace ${...} references
+        return value.replace(/\$\{([^}]+)\}/g, (match, path) => {
+          const resolved = this._getValueFromPath(path.trim(), context);
+          return resolved !== undefined ? resolved : match;
+        });
+      }
+      if (Array.isArray(value)) {
+        return value.map(resolveValue);
+      }
+      if (value && typeof value === 'object') {
+        return Object.fromEntries(
+          Object.entries(value).map(([k, v]) => [k, resolveValue(v)])
+        );
+      }
+      return value;
+    };
+    
+    return resolveValue(input);
+  }
+  
+  /**
+   * Get value from dot/bracket notation path
+   * @private
+   * @param {string} path - Path like "steps[0].output.message" or "api_input.name"
+   * @param {Object} context - Context object
+   * @returns {*} Resolved value or undefined
+   */
+  _getValueFromPath(path, context) {
+    // Normalize bracket notation to dot notation: steps[0] -> steps.0
+    const normalized = path.replace(/\[(\d+)\]/g, '.$1');
+    const parts = normalized.split('.');
+    
+    let current = context;
+    for (const part of parts) {
+      if (current === undefined || current === null) return undefined;
+      current = current[part];
+    }
+    return current;
+  }
 
   /**
    * Execute control flow step (foreach, switch, fork_join, etc)
@@ -322,10 +397,19 @@ class WorkflowOrchestrator {
 
     if (nextStep.type === 'task') {
       // Route to specific service
-      await this.router.routeToService(nextStep.service, message);
-      this.logger.info(`Routed to service: ${nextStep.service}`, {
-        step: nextStep.id
-      });
+      if (this.router?.routeToService) {
+        await this.router.routeToService(nextStep.service, message);
+        this.logger.info(`Routed to service: ${nextStep.service}`, {
+          step: nextStep.id
+        });
+      } else {
+        // Fallback: publish to service's workflow queue directly
+        const serviceQueue = `${nextStep.service}.workflow`;
+        await this.mqClient.publish(serviceQueue, message);
+        this.logger.info(`Published to queue: ${serviceQueue}`, {
+          step: nextStep.id
+        });
+      }
     } else {
       // Control flow steps handled by workflow init queue
       await this.mqClient.publish('workflow.init', message);