@onlineapps/service-wrapper 2.0.5 → 2.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-wrapper",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "Thin orchestration layer for microservices - delegates all infrastructure concerns to specialized connectors",
   "main": "src/index.js",
   "scripts": {
@@ -24,17 +24,18 @@
   "author": "OA Drive Team",
   "license": "MIT",
   "dependencies": {
+    "@onlineapps/conn-base-cache": "^1.0.0",
     "@onlineapps/conn-base-logger": "^1.0.0",
+    "@onlineapps/conn-infra-error-handler": "^1.0.0",
     "@onlineapps/conn-infra-mq": "^1.1.0",
-    "@onlineapps/conn-orch-registry": "^1.1.4",
+    "@onlineapps/conn-orch-api-mapper": "^1.0.0",
     "@onlineapps/conn-orch-cookbook": "^2.0.0",
     "@onlineapps/conn-orch-orchestrator": "^1.0.1",
-    "@onlineapps/conn-orch-api-mapper": "^1.0.0",
-    "@onlineapps/conn-base-cache": "^1.0.0",
-    "@onlineapps/conn-infra-error-handler": "^1.0.0"
+    "@onlineapps/conn-orch-registry": "^1.1.4"
   },
   "devDependencies": {
-    "jest": "^29.5.0",
+    "express": "^5.1.0",
+    "jest": "^29.7.0",
     "jsdoc": "^4.0.2",
     "jsdoc-to-markdown": "^8.0.0"
   },

package/src/ServiceWrapper.js

@@ -69,7 +69,7 @@ class ServiceWrapper {
     this.config = options.config || {};
 
     // Initialize connectors
-    this.logger = LoggerConnector.create(this.serviceName);
+    this.logger = new LoggerConnector({ serviceName: this.serviceName });
     this.mqClient = null;
     this.registryClient = null;
     this.orchestrator = null;
@@ -297,8 +297,38 @@ class ServiceWrapper {
 
     // Subscribe to workflow messages
     await this.mqClient.consume(
-      async (message) => {
+      queueName,
+      async (rawMessage) => {
         try {
+          // Parse message content if it's a buffer (AMQP message)
+          let message;
+          if (rawMessage && rawMessage.content) {
+            // This is an AMQP message with content buffer
+            const messageContent = rawMessage.content.toString();
+            try {
+              message = JSON.parse(messageContent);
+            } catch (parseError) {
+              this.logger.error('Failed to parse message content', {
+                error: parseError.message,
+                content: messageContent
+              });
+              throw parseError;
+            }
+          } else {
+            // Already parsed or direct message
+            message = rawMessage;
+          }
+
+          // DEBUG: Log the actual message structure
+          this.logger.info('DEBUG: Received message structure', {
+            workflow_id: message.workflow_id,
+            has_cookbook: !!message.cookbook,
+            cookbook_name: message.cookbook?.name,
+            cookbook_steps: message.cookbook?.steps?.length,
+            first_step: message.cookbook?.steps?.[0],
+            current_step: message.current_step
+          });
+
           // Delegate ALL processing to orchestrator
           const result = await this.orchestrator.processWorkflowMessage(
             message,
@@ -313,13 +343,12 @@ class ServiceWrapper {
 
         } catch (error) {
           this.logger.error('Message processing failed', {
-            workflow_id: message.workflow_id,
-            step: message.current_step,
+            workflow_id: message?.workflow_id || 'unknown',
+            step: message?.current_step || 'unknown',
             error: error.message
           });
         }
-      },
-      { queue: queueName }
+      }
     );
 
     this.logger.info(`Subscribed to queue: ${queueName}`);

package/test/e2e/full-flow.test.js

@@ -0,0 +1,293 @@
+'use strict';
+
+/**
+ * End-to-End Integration Tests for ServiceWrapper
+ * Tests the complete flow: MQ → ServiceWrapper → HTTP Service → Response
+ */
+
+const ServiceWrapper = require('../../src/ServiceWrapper');
+const MQConnector = require('@onlineapps/conn-infra-mq');
+const express = require('express');
+const http = require('http');
+
+describe('ServiceWrapper E2E Tests', () => {
+  let testService;
+  let testServer;
+  let serviceWrapper;
+  let mqClient;
+  let servicePort;
+  const serviceName = 'test-service';
+  const rabbitUrl = process.env.RABBITMQ_URL || 'amqp://guest:guest@localhost:33023';
+
+  beforeAll(async () => {
+    // 1. Create test HTTP service
+    testService = express();
+    testService.use(express.json());
+
+    // Add test endpoints
+    testService.post('/test/hello', (req, res) => {
+      res.json({
+        message: `Hello ${req.body.name}`,
+        timestamp: new Date().toISOString()
+      });
+    });
+
+    testService.post('/test/error', (req, res) => {
+      res.status(500).json({ error: 'Test error' });
+    });
+
+    testService.get('/health', (req, res) => {
+      res.json({ status: 'ok' });
+    });
+
+    // Start test service
+    servicePort = 40000 + Math.floor(Math.random() * 1000);
+    testServer = http.createServer(testService);
+    await new Promise(resolve => {
+      testServer.listen(servicePort, resolve);
+    });
+
+    // 2. Create OpenAPI spec
+    const openApiSpec = {
+      openapi: '3.0.0',
+      info: {
+        title: 'Test Service',
+        version: '1.0.0'
+      },
+      paths: {
+        '/test/hello': {
+          post: {
+            operationId: 'sayHello',
+            requestBody: {
+              content: {
+                'application/json': {
+                  schema: {
+                    type: 'object',
+                    properties: {
+                      name: { type: 'string' }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        '/test/error': {
+          post: {
+            operationId: 'triggerError'
+          }
+        }
+      }
+    };
+
+    // 3. Initialize ServiceWrapper
+    serviceWrapper = new ServiceWrapper({
+      serviceUrl: `http://localhost:${servicePort}`,
+      serviceName,
+      openApiSpec,
+      config: {
+        rabbitmq: rabbitUrl,
+        heartbeatInterval: 60000, // Long interval for tests
+        directCall: false // Force HTTP calls
+      }
+    });
+
+    // 4. Initialize MQ client for sending test messages
+    mqClient = new MQConnector({
+      type: 'rabbitmq',
+      host: rabbitUrl,
+      queue: `${serviceName}.workflow`,
+      durable: true
+    });
+    await mqClient.connect();
+
+    // 5. Start wrapper (with timeout for registration)
+    await serviceWrapper.start();
+  }, 60000); // 60s timeout for setup
+
+  afterAll(async () => {
+    // Cleanup
+    if (serviceWrapper) {
+      await serviceWrapper.stop();
+    }
+    if (mqClient) {
+      await mqClient.disconnect();
+    }
+    if (testServer) {
+      await new Promise(resolve => testServer.close(resolve));
+    }
+  });
+
+  describe('Basic Message Flow', () => {
+    test('should process simple workflow message', async () => {
+      const testMessage = {
+        workflow_id: 'test-workflow-1',
+        current_step: {
+          service: serviceName,
+          operation: 'sayHello',
+          input: {
+            name: 'World'
+          }
+        }
+      };
+
+      // Send message to queue
+      await mqClient.publish(testMessage);
+
+      // Wait for processing
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      // Verify by checking service logs or response queue
+      // Note: In real test, we'd capture response through response queue
+      expect(true).toBe(true); // Placeholder
+    });
+
+    test('should handle error responses', async () => {
+      const testMessage = {
+        workflow_id: 'test-workflow-2',
+        current_step: {
+          service: serviceName,
+          operation: 'triggerError',
+          input: {}
+        }
+      };
+
+      await mqClient.publish(testMessage);
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      // Verify error handling
+      expect(true).toBe(true); // Placeholder
+    });
+  });
+
+  describe('Workflow Orchestration', () => {
+    test('should process multi-step workflow', async () => {
+      const workflow = {
+        workflow_id: 'multi-step-1',
+        steps: [
+          {
+            service: serviceName,
+            operation: 'sayHello',
+            input: { name: 'Step1' }
+          },
+          {
+            service: serviceName,
+            operation: 'sayHello',
+            input: { name: 'Step2' }
+          }
+        ],
+        current_step: {
+          service: serviceName,
+          operation: 'sayHello',
+          input: { name: 'Step1' }
+        }
+      };
+
+      await mqClient.publish(workflow);
+      await new Promise(resolve => setTimeout(resolve, 3000));
+
+      expect(true).toBe(true); // Placeholder
+    });
+  });
+
+  describe('Error Handling & Recovery', () => {
+    test('should retry on transient failures', async () => {
+      // Test retry logic
+      const testMessage = {
+        workflow_id: 'retry-test-1',
+        current_step: {
+          service: serviceName,
+          operation: 'triggerError',
+          input: {},
+          retry_count: 0,
+          max_retries: 3
+        }
+      };
+
+      await mqClient.publish(testMessage);
+      await new Promise(resolve => setTimeout(resolve, 5000));
+
+      // Verify retries occurred
+      expect(true).toBe(true); // Placeholder
+    });
+
+    test('should handle circuit breaker', async () => {
+      // Send multiple failing requests to trigger circuit breaker
+      for (let i = 0; i < 5; i++) {
+        await mqClient.publish({
+          workflow_id: `circuit-test-${i}`,
+          current_step: {
+            service: serviceName,
+            operation: 'triggerError',
+            input: {}
+          }
+        });
+      }
+
+      await new Promise(resolve => setTimeout(resolve, 3000));
+
+      // Verify circuit breaker activated
+      expect(true).toBe(true); // Placeholder
+    });
+  });
+
+  describe('Performance & Load Testing', () => {
+    test('should handle concurrent messages', async () => {
+      const messages = [];
+      for (let i = 0; i < 10; i++) {
+        messages.push({
+          workflow_id: `concurrent-${i}`,
+          current_step: {
+            service: serviceName,
+            operation: 'sayHello',
+            input: { name: `User${i}` }
+          }
+        });
+      }
+
+      // Send all messages concurrently
+      await Promise.all(messages.map(msg => mqClient.publish(msg)));
+
+      // Wait for all to process
+      await new Promise(resolve => setTimeout(resolve, 5000));
+
+      expect(true).toBe(true); // Placeholder
+    });
+
+    test('should respect prefetch limit', async () => {
+      // Send more messages than prefetch limit
+      const messages = [];
+      for (let i = 0; i < 20; i++) {
+        messages.push({
+          workflow_id: `prefetch-${i}`,
+          current_step: {
+            service: serviceName,
+            operation: 'sayHello',
+            input: { name: `Batch${i}` }
+          }
+        });
+      }
+
+      await Promise.all(messages.map(msg => mqClient.publish(msg)));
+      await new Promise(resolve => setTimeout(resolve, 10000));
+
+      // Verify prefetch was respected
+      expect(true).toBe(true); // Placeholder
+    });
+  });
+
+  describe('Registry Integration', () => {
+    test('should register service on startup', () => {
+      // Verify service was registered
+      expect(serviceWrapper.isRunning).toBe(true);
+    });
+
+    test('should send heartbeats', async () => {
+      // Wait for at least one heartbeat
+      await new Promise(resolve => setTimeout(resolve, 5000));
+
+      // Verify heartbeat was sent (check logs or registry)
+      expect(true).toBe(true); // Placeholder
+    });
+  });
+});