@onlineapps/conn-orch-orchestrator 1.0.74 → 1.0.76

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@onlineapps/conn-orch-orchestrator",
-  "version": "1.0.74",
+  "version": "1.0.76",
   "description": "Workflow orchestration connector for OA Drive - handles message routing and workflow execution",
   "main": "src/index.js",
   "scripts": {
     "test": "jest --config jest.config.js",
+    "test:unit": "jest --config jest.config.js tests/unit",
     "test:watch": "jest --config jest.config.js --watch",
     "test:coverage": "jest --config jest.config.js --coverage",
     "lint": "eslint src/",
@@ -24,7 +25,7 @@
     "@onlineapps/conn-infra-mq": "1.1.57",
     "@onlineapps/conn-orch-registry": "1.1.33",
     "@onlineapps/conn-orch-cookbook": "2.0.16",
-    "@onlineapps/conn-orch-api-mapper": "1.0.21"
+    "@onlineapps/conn-orch-api-mapper": "1.0.23"
   },
   "devDependencies": {
     "jest": "^29.5.0",

package/src/WorkflowOrchestrator.js

@@ -427,6 +427,15 @@ class WorkflowOrchestrator {
           cookbook: finalCookbook,  // UNIFIED cookbook with full state
           failed_at: new Date().toISOString()
         });
+
+        // Compatibility: also publish to workflow.dlq for DLQ dashboards/tools that only look for "*.dlq" queues.
+        // workflow.dlq is an infrastructure queue created by Gateway.
+        await this.mqClient.publish('workflow.dlq', {
+          workflow_id,
+          current_step,
+          cookbook: finalCookbook,
+          failed_at: new Date().toISOString()
+        });
         
         // ALSO publish to monitoring.workflow so dashboard shows the DLQ entry
         try {

package/tests/component/orchestrator.component.test.js

@@ -1,150 +0,0 @@
-'use strict';
-
-/**
- * Component tests for WorkflowOrchestrator (V2.1 unified cookbook message format)
- *
- * Goal: verify orchestration behavior (task execution + routing) without external MQ/registry.
- */
-
-jest.mock('@onlineapps/mq-client-core', () => ({
-  monitoring: {
-    publishToMonitoringWorkflow: jest.fn(async () => true)
-  }
-}));
-
-const WorkflowOrchestrator = require('../../src/WorkflowOrchestrator');
-
-describe('WorkflowOrchestrator - Component Tests @component', () => {
-  let orchestrator;
-  let mqClientStub;
-  let registryClientStub;
-  let apiMapperStub;
-
-  beforeEach(() => {
-    mqClientStub = {
-      publish: jest.fn(async () => true)
-    };
-
-    registryClientStub = {
-      getService: jest.fn(async () => null),
-      getAllServices: jest.fn(async () => [])
-    };
-
-    apiMapperStub = {
-      callOperation: jest.fn(async (operationId, input) => ({ operationId, input }))
-    };
-
-    orchestrator = new WorkflowOrchestrator({
-      mqClient: mqClientStub,
-      registryClient: registryClientStub,
-      apiMapper: apiMapperStub,
-      cookbook: {
-        validateCookbook: jest.fn(),
-        templateHelpers: {
-          normalizeString: (v) => String(v || '').trim()
-        }
-      },
-      logger: {
-        info: jest.fn(),
-        error: jest.fn(),
-        warn: jest.fn(),
-        debug: jest.fn()
-      }
-    });
-  });
-
-  it('executes task and routes next task to next service queue', async () => {
-    const cookbook = {
-      version: '2.1.0',
-      api_input: { x: 1 },
-      steps: [
-        { step_id: 's1', type: 'task', service: 'svc-a', operation: 'op1', input: { x: '{{api_input.x}}' } },
-        { step_id: 's2', type: 'task', service: 'svc-b', operation: 'op2', input: { y: 2 } }
-      ],
-      delivery: { handler: 'none' }
-    };
-
-    const msg = { workflow_id: 'wf-1', cookbook, current_step: 's1' };
-    await orchestrator.processWorkflowMessage(msg, 'svc-a');
-
-    expect(apiMapperStub.callOperation).toHaveBeenCalledWith(
-      'op1',
-      { x: 1 },
-      expect.any(Object)
-    );
-
-    expect(mqClientStub.publish).toHaveBeenCalledWith(
-      'svc-b.workflow',
-      expect.objectContaining({
-        workflow_id: 'wf-1',
-        current_step: 's2',
-        cookbook: expect.objectContaining({
-          _pointer: { next: 's2' }
-        })
-      })
-    );
-  });
-
-  it('routes next pinned control-flow step to pinned service queue (not workflow.init/workflow.control)', async () => {
-    const cookbook = {
-      version: '2.1.0',
-      api_input: { items: ['a'] },
-      steps: [
-        { step_id: 's1', type: 'task', service: 'svc-a', operation: 'op1', input: { x: 1 } },
-        {
-          step_id: 'loop',
-          type: 'foreach',
-          service: 'hello-service',
-          iterator: '{{api_input.items}}',
-          body: [
-            { step_id: 'inner', type: 'task', service: 'hello-service', operation: 'good-day', input: { name: '{{current}}' } }
-          ]
-        }
-      ],
-      delivery: { handler: 'none' }
-    };
-
-    const msg = { workflow_id: 'wf-2', cookbook, current_step: 's1' };
-    await orchestrator.processWorkflowMessage(msg, 'svc-a');
-
-    expect(mqClientStub.publish).toHaveBeenCalledWith(
-      'hello-service.workflow',
-      expect.objectContaining({
-        workflow_id: 'wf-2',
-        current_step: 'loop'
-      })
-    );
-  });
-
-  it('routes next unpinned control-flow step to workflow.control', async () => {
-    const cookbook = {
-      version: '2.1.0',
-      api_input: { items: ['a'] },
-      steps: [
-        { step_id: 's1', type: 'task', service: 'svc-a', operation: 'op1', input: { x: 1 } },
-        {
-          step_id: 'loop',
-          type: 'foreach',
-          iterator: '{{api_input.items}}',
-          body: [
-            { step_id: 'inner', type: 'task', service: 'hello-service', operation: 'good-day', input: { name: '{{current}}' } }
-          ]
-        }
-      ],
-      delivery: { handler: 'none' }
-    };
-
-    const msg = { workflow_id: 'wf-3', cookbook, current_step: 's1' };
-    await orchestrator.processWorkflowMessage(msg, 'svc-a');
-
-    expect(mqClientStub.publish).toHaveBeenCalledWith(
-      'workflow.control',
-      expect.objectContaining({
-        workflow_id: 'wf-3',
-        current_step: 'loop'
-      })
-    );
-  });
-});
-
-

package/tests/integration/orchestrator.integration.test.js

@@ -1,318 +0,0 @@
-'use strict';
-
-/**
- * Integration tests for Orchestrator
- * Tests orchestrator with real external services (when available)
- */
-
-const WorkflowOrchestrator = require('../../src');
-const MQConnector = require('@onlineapps/conn-infra-mq');
-const RegistryConnector = require('@onlineapps/conn-orch-registry');
-const ApiMapperConnector = require('@onlineapps/conn-orch-api-mapper');
-const CookbookConnector = require('@onlineapps/conn-orch-cookbook');
-
-// Skip integration tests if external services are not available
-const SKIP_INTEGRATION = process.env.SKIP_INTEGRATION === 'true';
-const RABBITMQ_URL = process.env.RABBITMQ_URL || null;
-const REGISTRY_URL = process.env.REGISTRY_URL || null;
-const HAS_ENV = !!(RABBITMQ_URL && REGISTRY_URL);
-
-const describeMaybe = (!SKIP_INTEGRATION && HAS_ENV) ? describe : describe.skip;
-
-describeMaybe('Orchestrator - Integration Tests @integration', () => {
-  if (SKIP_INTEGRATION) {
-    it('Skipping integration tests (SKIP_INTEGRATION=true)', () => {});
-  }
-  if (!HAS_ENV) {
-    it('Skipping integration tests (missing RABBITMQ_URL/REGISTRY_URL)', () => {});
-  }
-
-  let orchestrator;
-  let mqClient;
-  let registryClient;
-
-  beforeAll(async () => {
-    // Setup real connections
-    try {
-      mqClient = new MQConnector({
-        url: RABBITMQ_URL,
-        serviceName: 'test-orchestrator'
-      });
-      await mqClient.connect();
-
-      registryClient = new RegistryConnector.ServiceRegistryClient({
-        registryUrl: REGISTRY_URL
-      });
-
-      // Register test service
-      await registryClient.register({
-        name: 'test-orchestrator',
-        url: 'http://localhost:9999',
-        openapi: {
-          openapi: '3.0.0',
-          info: { title: 'Test Service', version: '1.0.0' },
-          paths: {
-            '/echo': {
-              post: {
-                operationId: 'echo',
-                requestBody: {
-                  content: {
-                    'application/json': {
-                      schema: { type: 'object' }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      });
-    } catch (error) {
-      console.warn('Failed to setup integration test environment:', error.message);
-      console.warn('Skipping integration tests');
-      return;
-    }
-  });
-
-  afterAll(async () => {
-    // Cleanup
-    if (orchestrator) {
-      await orchestrator.shutdown();
-    }
-    if (registryClient) {
-      await registryClient.unregister('test-orchestrator');
-    }
-    if (mqClient) {
-      await mqClient.disconnect();
-    }
-  });
-
-  beforeEach(() => {
-    const apiMapper = ApiMapperConnector.create({
-      openApiSpec: {
-        openapi: '3.0.0',
-        paths: {
-          '/echo': {
-            post: {
-              operationId: 'echo'
-            }
-          }
-        }
-      },
-      serviceUrl: 'http://localhost:9999'
-    });
-
-    orchestrator = WorkflowOrchestrator.create({
-      mqClient,
-      registryClient,
-      apiMapper,
-      cookbook: CookbookConnector,
-      logger: {
-        info: jest.fn(),
-        error: jest.fn(),
-        warn: jest.fn(),
-        debug: jest.fn()
-      }
-    });
-  });
-
-  describe('End-to-End Workflow Execution', () => {
-    it('should execute a simple workflow end-to-end', async () => {
-      const workflow = {
-        workflow_id: 'int-test-' + Date.now(),
-        current_step: {
-          id: 'step1',
-          service: 'test-orchestrator',
-          operation: 'echo',
-          input: { message: 'Hello Integration Test' },
-          output: 'echoResult'
-        },
-        context: {
-          variables: {},
-          results: {}
-        }
-      };
-
-      // Mock the actual HTTP call since we don't have a real service
-      orchestrator.apiMapper.callOperation = jest.fn().mockResolvedValue({
-        status: 200,
-        data: { echoed: 'Hello Integration Test' }
-      });
-
-      const result = await orchestrator.processWorkflowMessage(
-        workflow,
-        'test-orchestrator'
-      );
-
-      expect(result).toBeDefined();
-      expect(result.data).toHaveProperty('echoed');
-    });
-
-    it('should handle message routing through RabbitMQ', async () => {
-      const testQueue = 'test.integration.queue';
-
-      // Setup consumer
-      let receivedMessage = null;
-      await mqClient.consume(
-        (message) => {
-          receivedMessage = message;
-          return Promise.resolve();
-        },
-        { queue: testQueue }
-      );
-
-      // Send message through orchestrator
-      const workflow = {
-        workflow_id: 'route-test-' + Date.now(),
-        current_step: {
-          id: 'route',
-          service: 'test-orchestrator',
-          operation: 'echo',
-          input: { test: 'data' }
-        },
-        next_steps: [
-          {
-            id: 'next',
-            service: 'next-service',
-            operation: 'process'
-          }
-        ],
-        context: {}
-      };
-
-      // Mock the API call
-      orchestrator.apiMapper.callOperation = jest.fn().mockResolvedValue({
-        status: 200,
-        data: { processed: true }
-      });
-
-      // Override routing to use test queue
-      orchestrator.routeToNextStep = async (workflowId, step, context) => {
-        await mqClient.publish(
-          { workflow_id: workflowId, current_step: step, context },
-          { queue: testQueue }
-        );
-      };
-
-      await orchestrator.processWorkflowMessage(workflow, 'test-orchestrator');
-
-      // Wait for message to be received
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      expect(receivedMessage).toBeTruthy();
-      expect(receivedMessage.workflow_id).toBe(workflow.workflow_id);
-    });
-
-    it('should interact with registry for service discovery', async () => {
-      // Get service info from registry
-      const serviceInfo = await registryClient.getService('test-orchestrator');
-
-      expect(serviceInfo).toBeDefined();
-      expect(serviceInfo.name).toBe('test-orchestrator');
-      expect(serviceInfo.openapi).toBeDefined();
-    });
-  });
-
-  describe('Fault Tolerance', () => {
-    it('should handle temporary network failures', async () => {
-      // Simulate network failure
-      orchestrator.apiMapper.callOperation = jest.fn()
-        .mockRejectedValueOnce(new Error('ECONNREFUSED'))
-        .mockResolvedValueOnce({ status: 200, data: { ok: true } });
-
-      const workflow = {
-        workflow_id: 'retry-test-' + Date.now(),
-        current_step: {
-          service: 'test-orchestrator',
-          operation: 'echo',
-          retry: { max: 3, delay: 100 }
-        }
-      };
-
-      // With retry logic (if implemented)
-      const result = await orchestrator.processWorkflowMessage(
-        workflow,
-        'test-orchestrator'
-      ).catch(e => e);
-
-      // Should eventually succeed or fail after retries
-      expect(orchestrator.apiMapper.callOperation).toHaveBeenCalled();
-    });
-
-    it('should handle message acknowledgment correctly', async () => {
-      const workflow = {
-        workflow_id: 'ack-test-' + Date.now(),
-        current_step: {
-          service: 'test-orchestrator',
-          operation: 'echo'
-        }
-      };
-
-      orchestrator.apiMapper.callOperation = jest.fn()
-        .mockResolvedValue({ status: 200, data: {} });
-
-      await orchestrator.processWorkflowMessage(workflow, 'test-orchestrator');
-
-      // Message should be processed without errors
-      expect(orchestrator.apiMapper.callOperation).toHaveBeenCalled();
-    });
-  });
-
-  describe('Performance', () => {
-    it('should handle multiple concurrent workflows', async () => {
-      const workflows = Array.from({ length: 10 }, (_, i) => ({
-        workflow_id: `perf-test-${Date.now()}-${i}`,
-        current_step: {
-          service: 'test-orchestrator',
-          operation: 'echo',
-          input: { index: i }
-        }
-      }));
-
-      orchestrator.apiMapper.callOperation = jest.fn()
-        .mockResolvedValue({ status: 200, data: {} });
-
-      const startTime = Date.now();
-
-      await Promise.all(
-        workflows.map(w =>
-          orchestrator.processWorkflowMessage(w, 'test-orchestrator')
-        )
-      );
-
-      const duration = Date.now() - startTime;
-
-      expect(orchestrator.apiMapper.callOperation).toHaveBeenCalledTimes(10);
-      expect(duration).toBeLessThan(5000); // Should complete within 5 seconds
-    });
-
-    it('should not leak memory during long-running operations', async () => {
-      const initialMemory = process.memoryUsage().heapUsed;
-
-      // Process many workflows
-      for (let i = 0; i < 100; i++) {
-        const workflow = {
-          workflow_id: `mem-test-${i}`,
-          current_step: {
-            service: 'test-orchestrator',
-            operation: 'echo',
-            input: { data: 'x'.repeat(1000) } // 1KB of data
-          }
-        };
-
-        orchestrator.apiMapper.callOperation = jest.fn()
-          .mockResolvedValue({ status: 200, data: {} });
-
-        await orchestrator.processWorkflowMessage(workflow, 'test-orchestrator');
-      }
-
-      global.gc && global.gc(); // Force garbage collection if available
-
-      const finalMemory = process.memoryUsage().heapUsed;
-      const memoryGrowth = finalMemory - initialMemory;
-
-      // Memory growth should be reasonable (< 50MB)
-      expect(memoryGrowth).toBeLessThan(50 * 1024 * 1024);
-    });
-  });
-});

package/tests/unit/WorkflowOrchestrator.test.js

@@ -1,254 +0,0 @@
-'use strict';
-
-/**
- * Unit tests for WorkflowOrchestrator
- * Tests individual methods in isolation with mocked dependencies
- */
-
-jest.mock('@onlineapps/mq-client-core', () => ({
-  monitoring: {
-    publishToMonitoringWorkflow: jest.fn(async () => true)
-  }
-}));
-
-const WorkflowOrchestrator = require('../../src/WorkflowOrchestrator');
-
-describe('WorkflowOrchestrator - Unit Tests @unit', () => {
-  let orchestrator;
-  let mockMqClient;
-  let mockRegistryClient;
-  let mockApiMapper;
-  let mockCookbook;
-  let mockLogger;
-  let mockCache;
-  let mockErrorHandler;
-
-  beforeEach(() => {
-    // Setup mocked dependencies
-    mockMqClient = {
-      publish: jest.fn().mockResolvedValue(true),
-      subscribe: jest.fn().mockResolvedValue(true)
-    };
-
-    mockRegistryClient = {
-      getService: jest.fn().mockResolvedValue({
-        name: 'test-service',
-        url: 'http://localhost:3000',
-        openapi: {}
-      })
-    };
-
-    mockApiMapper = {
-      callOperation: jest.fn(async (operationId, input, ctx) => ({
-        operationId,
-        input,
-        ctx
-      }))
-    };
-
-    mockCookbook = {
-      validateCookbook: jest.fn(),
-      templateHelpers: {
-        normalizeString: jest.fn((value) => String(value || '').replace(/\s+/g, ' ').trim()),
-        webalizeString: jest.fn((value) => String(value || '').toLowerCase().replace(/\s+/g, '-')),
-        string2file: jest.fn(async (value) => ({ _descriptor: true, type: 'file', storage_ref: `minio://mock/${String(value).length}` })),
-        file2string: jest.fn(async (descriptor) => (descriptor && descriptor.storage_ref ? `from:${descriptor.storage_ref}` : String(descriptor)))
-      }
-    };
-
-    mockLogger = {
-      info: jest.fn(),
-      error: jest.fn(),
-      warn: jest.fn(),
-      debug: jest.fn()
-    };
-
-    mockCache = {
-      get: jest.fn().mockResolvedValue(null),
-      set: jest.fn().mockResolvedValue('OK'),
-      del: jest.fn().mockResolvedValue(1)
-    };
-
-    mockErrorHandler = {
-      executeWithRetry: jest.fn((fn) => fn()),
-      handleError: jest.fn(),
-      isRetryableError: jest.fn().mockReturnValue(false)
-    };
-
-    orchestrator = new WorkflowOrchestrator({
-      mqClient: mockMqClient,
-      registryClient: mockRegistryClient,
-      apiMapper: mockApiMapper,
-      cookbook: mockCookbook,
-      logger: mockLogger,
-      cache: mockCache,
-      errorHandler: mockErrorHandler
-    });
-  });
-
-  describe('constructor', () => {
-    it('should initialize with all required dependencies', () => {
-      expect(orchestrator.mqClient).toBe(mockMqClient);
-      expect(orchestrator.registryClient).toBe(mockRegistryClient);
-      expect(orchestrator.apiMapper).toBe(mockApiMapper);
-      expect(orchestrator.cookbook).toBe(mockCookbook);
-      expect(orchestrator.logger).toBe(mockLogger);
-      expect(orchestrator.cache).toBe(mockCache);
-      expect(orchestrator.errorHandler).toBe(mockErrorHandler);
-    });
-
-    it('should throw if required dependencies are missing', () => {
-      expect(() => new WorkflowOrchestrator({})).toThrow();
-    });
-  });
-
-  describe('processWorkflowMessage', () => {
-    it('executes task step for the current service and calls ApiMapper', async () => {
-      const cookbook = {
-        version: '2.1.0',
-        api_input: { text: 'hello' },
-        steps: [
-          {
-            step_id: 's1',
-            type: 'task',
-            service: 'hello-service',
-            operation: 'test-echo',
-            input: { text: '{{api_input.text}}' }
-          }
-        ],
-        delivery: { handler: 'none' }
-      };
-
-      const message = { workflow_id: 'wf-123', cookbook, current_step: 's1' };
-      const result = await orchestrator.processWorkflowMessage(message, 'hello-service');
-
-      expect(mockApiMapper.callOperation).toHaveBeenCalledWith(
-        'test-echo',
-        { text: 'hello' },
-        expect.objectContaining({ workflow_id: 'wf-123', step_id: 's1' })
-      );
-      expect(result.success).toBe(true);
-    });
-
-    it('routes task step to correct service queue when service does not match', async () => {
-      const cookbook = {
-        version: '2.1.0',
-        api_input: { text: 'hello' },
-        steps: [
-          {
-            step_id: 's1',
-            type: 'task',
-            service: 'other-service',
-            operation: 'test-echo',
-            input: { text: '{{api_input.text}}' }
-          }
-        ],
-        delivery: { handler: 'none' }
-      };
-
-      const message = { workflow_id: 'wf-123', cookbook, current_step: 's1' };
-      const res = await orchestrator.processWorkflowMessage(message, 'hello-service');
-
-      expect(res).toEqual({ skipped: true, reason: 'wrong_service' });
-      expect(mockMqClient.publish).toHaveBeenCalledWith('other-service.workflow', message);
-      expect(mockApiMapper.callOperation).not.toHaveBeenCalled();
-    });
-
-    it('routes pinned control-flow step to pinned service when current service does not match', async () => {
-      const cookbook = {
-        version: '2.1.0',
-        api_input: { items: ['A', 'B'] },
-        steps: [
-          {
-            step_id: 'loop',
-            type: 'foreach',
-            service: 'hello-service', // pin
-            iterator: '{{api_input.items}}',
-            body: [
-              {
-                step_id: 'inner',
-                type: 'task',
-                service: 'hello-service',
-                operation: 'good-day',
-                input: { name: '{{current}}' }
-              }
-            ]
-          }
-        ],
-        delivery: { handler: 'none' }
-      };
-
-      const message = { workflow_id: 'wf-123', cookbook, current_step: 'loop' };
-      const res = await orchestrator.processWorkflowMessage(message, 'pdfgen-service');
-
-      expect(res).toEqual({ skipped: true, reason: 'wrong_service_control_flow' });
-      expect(mockMqClient.publish).toHaveBeenCalledWith('hello-service.workflow', message);
-      expect(mockApiMapper.callOperation).not.toHaveBeenCalled();
-    });
-
-    it('executes foreach control-flow step when pinned to this service', async () => {
-      const cookbook = {
-        version: '2.1.0',
-        api_input: { items: ['A', 'B'] },
-        steps: [
-          {
-            step_id: 'loop',
-            type: 'foreach',
-            service: 'hello-service', // pin to ensure deterministic executor
-            iterator: '{{api_input.items}}',
-            body: [
-              {
-                step_id: 'inner',
-                type: 'task',
-                service: 'hello-service',
-                operation: 'good-day',
-                input: { name: '{{current}}' }
-              }
-            ]
-          }
-        ],
-        delivery: { handler: 'none' }
-      };
-
-      const message = { workflow_id: 'wf-123', cookbook, current_step: 'loop' };
-      const res = await orchestrator.processWorkflowMessage(message, 'hello-service');
-
-      expect(res.success).toBe(true);
-      expect(res.result).toEqual(expect.objectContaining({ type: 'foreach', count: 2 }));
-      expect(mockApiMapper.callOperation).toHaveBeenCalledTimes(2);
-      expect(mockApiMapper.callOperation).toHaveBeenNthCalledWith(
-        1,
-        'good-day',
-        { name: 'A' },
-        expect.objectContaining({ workflow_id: 'wf-123', step_id: 'inner' })
-      );
-    });
-
-    it('resolves helper call in templates', async () => {
-      const cookbook = {
-        version: '2.1.0',
-        api_input: { text: '  Hello   World  ' },
-        steps: [
-          {
-            step_id: 's1',
-            type: 'task',
-            service: 'hello-service',
-            operation: 'test-echo',
-            input: { text: '{{normalizeString(api_input.text)}}' }
-          }
-        ],
-        delivery: { handler: 'none' }
-      };
-
-      const message = { workflow_id: 'wf-123', cookbook, current_step: 's1' };
-      await orchestrator.processWorkflowMessage(message, 'hello-service');
-
-      expect(mockCookbook.templateHelpers.normalizeString).toHaveBeenCalled();
-      expect(mockApiMapper.callOperation).toHaveBeenCalledWith(
-        'test-echo',
-        { text: 'Hello World' },
-        expect.objectContaining({ workflow_id: 'wf-123', step_id: 's1' })
-      );
-    });
-  });
-});