@onlineapps/service-wrapper 2.0.20 → 2.0.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-wrapper",
-  "version": "2.0.20",
+  "version": "2.0.22",
   "description": "Thin orchestration layer for microservices - delegates all infrastructure concerns to specialized connectors",
   "main": "src/index.js",
   "scripts": {

package/src/ServiceWrapper.js

@@ -37,6 +37,7 @@ class ServiceWrapper {
    * @param {Object} options.operations - Operations schema
    * @param {string} [options.serviceRoot] - Service root directory (for validation)
    * @param {Object} [options.validationProof=null] - Optional validation proof {hash, data}
+   * @param {Object} [options._validationOrchestrator=null] - Optional ValidationOrchestrator for testing
    */
   constructor(options = {}) {
     this._validateOptions(options);
@@ -48,6 +49,7 @@ class ServiceWrapper {
     this.operations = options.operations;
     this.serviceRoot = options.serviceRoot;
     this.validationProof = options.validationProof || null;
+    this._injectedValidationOrchestrator = options._validationOrchestrator || null;
 
     // Initialize connector placeholders
     this.mqClient = null;
@@ -149,19 +151,26 @@ class ServiceWrapper {
         await this._initializeMonitoring();
       }
 
-      // 2. Run pre-validation (Tier 1)
+      // 2. Initialize MQ connection (needed for workflow.init listener)
+      if (this.config.wrapper?.mq?.enabled !== false) {
+        await this._initializeMQ();
+        
+        // Start workflow.init listener immediately (independent of service registration)
+        // This allows the system to receive workflow messages even if service validation/registration fails
+        await this._startWorkflowInitListener();
+      }
+
+      // 3. Run pre-validation (Tier 1)
       // Validates service structure, config, operations, cookbook tests
       // Skips if valid proof exists in conn-runtime/validation-proof.json
+      // NOTE: Validation is required for service-specific workflow listener and registration
       if (this.serviceRoot && this.config.wrapper?.validation?.enabled !== false) {
         await this._ensureValidationProof();
       }
 
-      // 3. Initialize MQ connection
-      if (this.config.wrapper?.mq?.enabled !== false) {
-        await this._initializeMQ();
-      }
-
       // 4. Initialize service registry
+      // NOTE: Service-specific workflow listener ({serviceName}.workflow) will be started
+      // ONLY after successful validation and registration (see _initializeRegistry)
       if (this.config.wrapper?.registry?.enabled !== false) {
         await this._initializeRegistry();
       }
@@ -306,12 +315,13 @@ class ServiceWrapper {
         console.log(`✓ Certificate received: ${registrationResult.certificate.certificateId}`);
       }
 
-      // CRITICAL: Only start workflow listeners after successful registration with certificate
+      // CRITICAL: Only start service-specific workflow listener after successful validation and registration with certificate
+      // workflow.init listener is already running (started during MQ initialization)
       if (registrationResult.success && registrationResult.certificate) {
-        console.log('✓ Certificate validated, starting workflow listeners...');
-        await this._startWorkflowListeners();
+        console.log('✓ Certificate validated, starting service-specific workflow listener...');
+        await this._startServiceWorkflowListener();
       } else {
-        console.warn('⚠ Registration succeeded but no certificate received - workflow listeners NOT started');
+        console.warn('⚠ Registration succeeded but no certificate received - service-specific workflow listener NOT started');
       }
 
     } catch (error) {
@@ -401,12 +411,25 @@ class ServiceWrapper {
     const servicePort = this.config.service?.port || process.env.PORT || 3000;
     const serviceUrl = `http://localhost:${servicePort}`;
 
-    // Create error handler
+    // Create error handler with monitoring instance
     const errorHandler = new ErrorHandlerConnector({
-      maxRetries: this.config.wrapper?.errorHandling?.maxRetries || 3,
-      retryDelay: this.config.wrapper?.errorHandling?.retryDelay || 1000,
-      logger: this.logger || console
+      serviceName: this.config.service?.name || 'unnamed-service',
+      serviceVersion: this.config.service?.version || '0.0.0',
+      environment: process.env.NODE_ENV || 'development',
+      monitoring: this.monitoring,  // Use monitoring instance from conn-base-monitoring
+      handling: {
+        maxRetries: this.config.wrapper?.errorHandling?.maxRetries || 3,
+        retryDelay: this.config.wrapper?.errorHandling?.retryDelay || 1000,
+        retryMultiplier: this.config.wrapper?.errorHandling?.retryMultiplier || 2,
+        circuitBreakerEnabled: this.config.wrapper?.errorHandling?.circuitBreakerEnabled !== false,
+        dlqEnabled: this.config.wrapper?.errorHandling?.dlqEnabled !== false,
+        mqClient: this.mqClient,  // For DLQ routing
+        compensationEnabled: this.config.wrapper?.errorHandling?.compensationEnabled !== false
+      }
     });
+    
+    // Store error handler for use in message processing
+    this.errorHandler = errorHandler;
 
     // Create API mapper for HTTP calls (never direct calls)
     const apiMapper = ApiMapperConnector.create({
@@ -432,25 +455,43 @@ class ServiceWrapper {
   }
 
   /**
-   * Start workflow listeners - ONLY called after receiving certificate from Registry
-   * CRITICAL: Unregistered services MUST NOT consume workflow messages
+   * Start workflow.init listener (runs independently of service registration)
+   * This allows the system to receive workflow messages even if service validation/registration fails
    * @private
    */
-  async _startWorkflowListeners() {
-    const serviceName = this.config.service?.name || 'unnamed-service';
+  async _startWorkflowInitListener() {
+    if (!this.mqClient) {
+      console.warn('Cannot start workflow.init listener: MQ client not initialized');
+      return;
+    }
 
     // Subscribe to workflow.init queue (for all services)
     await this.mqClient.consume('workflow.init', async (message) => {
       await this._processWorkflowMessage(message, 'workflow.init');
     });
 
-    // Subscribe to service-specific queue
+    console.log('✓ workflow.init listener started (independent of service registration)');
+  }
+
+  /**
+   * Start service-specific workflow listener (runs only after successful validation and registration)
+   * @private
+   */
+  async _startServiceWorkflowListener() {
+    if (!this.mqClient) {
+      console.warn('Cannot start service workflow listener: MQ client not initialized');
+      return;
+    }
+
+    const serviceName = this.config.service?.name || 'unnamed-service';
     const serviceQueue = `${serviceName}.workflow`;
+
+    // Subscribe to service-specific queue
     await this.mqClient.consume(serviceQueue, async (message) => {
       await this._processWorkflowMessage(message, serviceQueue);
     });
 
-    console.log(`Subscribed to queues: workflow.init, ${serviceQueue}`);
+    console.log(`✓ Service-specific workflow listener started: ${serviceQueue}`);
   }
 
   /**
@@ -517,17 +558,61 @@ class ServiceWrapper {
         };
 
         try {
+          // Detailed logging before publish
+          this.logger?.info(`[ServiceWrapper] Preparing to publish workflow.completed`, {
+            workflowId: message.workflow_id,
+            service: serviceName,
+            operation: workflowResponse.operation,
+            mqClientConnected: this.mqClient._connected,
+            hasTransport: !!this.mqClient._transport,
+            hasChannel: !!(this.mqClient._transport?._channel)
+          });
+
           await this.mqClient.publish('workflow.completed', workflowResponse);
-          console.log(`✓ Workflow response sent to workflow.completed: ${message.workflow_id}`);
+          
+          // Log success with details
+          this.logger?.info(`✓ Workflow response sent to workflow.completed: ${message.workflow_id}`, {
+            workflowId: message.workflow_id,
+            queue: 'workflow.completed',
+            responseSize: JSON.stringify(workflowResponse).length
+          });
         } catch (error) {
-          console.error(`Failed to send workflow response:`, error);
+          // Use error handler to log and handle the error
+          this.logger?.error(`[ServiceWrapper] Failed to publish workflow.completed`, {
+            workflowId: message.workflow_id,
+            queue: 'workflow.completed',
+            error: error.message,
+            errorStack: error.stack,
+            mqClientConnected: this.mqClient?._connected,
+            hasTransport: !!this.mqClient?._transport,
+            hasChannel: !!(this.mqClient?._transport?._channel)
+          });
+          
+          if (this.errorHandler) {
+            await this.errorHandler.logError({
+              moduleName: 'ServiceWrapper',
+              operation: 'sendWorkflowResponse',
+              error: error,
+              context: { workflowId: message.workflow_id, queue: 'workflow.completed' }
+            });
+          }
         }
       }
 
       return result;
 
     } catch (error) {
-      console.error(`Error processing message from ${queueName}:`, error);
+      // Use error handler to log and handle the error
+      if (this.errorHandler) {
+        await this.errorHandler.logError({
+          moduleName: 'ServiceWrapper',
+          operation: 'processMessage',
+          error: error,
+          context: { queueName, workflowId: message?.workflow_id }
+        });
+      } else {
+        this.logger?.error(`Error processing message from ${queueName}:`, error);
+      }
       throw error;
     }
   }
@@ -684,14 +769,24 @@ class ServiceWrapper {
       throw new Error('Monitoring must be initialized before validation');
     }
 
-    const { name: serviceName, version: serviceVersion } = this.config.service;
+    const { name: serviceName, version: serviceVersion, port: servicePort } = this.config.service;
+
+    // Validate service port is configured
+    if (!servicePort) {
+      throw new Error('Service port is required for validation (config.service.port)');
+    }
+
+    // Build service URL for validation (HTTP calls to running server)
+    const serviceUrl = `http://localhost:${servicePort}`;
 
     console.log('[ServiceWrapper] Checking validation proof...');
 
-    const orchestrator = new ValidationOrchestrator({
+    // Use injected orchestrator (for testing) or create new one (production)
+    const orchestrator = this._injectedValidationOrchestrator || new ValidationOrchestrator({
       serviceRoot: this.serviceRoot,
       serviceName,
       serviceVersion,
+      serviceUrl,
       logger: this.logger
     });