@onlineapps/service-wrapper 3.0.9 → 3.0.12

package/jest.config.js

@@ -26,6 +26,7 @@ module.exports = {
     '@onlineapps/conn-orch-registry': '<rootDir>/tests/mocks/connectors.js',
     '@onlineapps/conn-base-logger': '<rootDir>/tests/mocks/connectors.js',
     '@onlineapps/conn-orch-orchestrator': '<rootDir>/tests/mocks/connectors.js',
+    '@onlineapps/conn-orch-orchestrator/package.json': '<rootDir>/tests/mocks/orchestrator-package-v2.js',
     '@onlineapps/conn-orch-api-mapper': '<rootDir>/tests/mocks/connectors.js',
     '@onlineapps/conn-orch-cookbook': '<rootDir>/tests/mocks/connectors.js',
     '@onlineapps/conn-base-state': '<rootDir>/tests/mocks/connectors.js'

package/package.json

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

package/src/ErrorMapper.js

@@ -93,31 +93,31 @@ class ErrorMapper {
     if (err instanceof ValidationError) {
       if (err.phase === 'output') {
         this._logger.error(
-          { err, operation, correlation_id, code: 'INTERNAL_ERROR', status: 500 },
-          'output schema validation failed - server bug'
+          'output schema validation failed - server bug',
+          { err, operation, correlation_id, code: 'INTERNAL_ERROR', status: 500 }
         );
         return this._buildError(500, 'INTERNAL_ERROR', 'Internal validation error', undefined, correlation_id);
       }
 
       this._logger.info(
-        { err, operation, correlation_id, code: 'VALIDATION_FAILED', status: 400 },
-        'input schema validation failed'
+        'input schema validation failed',
+        { err, operation, correlation_id, code: 'VALIDATION_FAILED', status: 400 }
       );
       return this._buildError(400, 'VALIDATION_FAILED', err.message, err.details, correlation_id);
     }
 
     if (err instanceof UnknownOperationError) {
       this._logger.warn(
-        { err, operation, correlation_id, code: 'UNKNOWN_OPERATION', status: 404 },
-        'unknown operation requested'
+        'unknown operation requested',
+        { err, operation, correlation_id, code: 'UNKNOWN_OPERATION', status: 404 }
       );
       return this._buildError(404, 'UNKNOWN_OPERATION', err.message, undefined, correlation_id);
     }
 
     if (err instanceof BusinessError) {
       this._logger.info(
-        { err, operation, correlation_id, code: err.code, status: err.status },
-        'handler raised BusinessError'
+        'handler raised BusinessError',
+        { err, operation, correlation_id, code: err.code, status: err.status }
       );
       return this._buildError(err.status, err.code, err.message, err.details, correlation_id);
     }
@@ -125,15 +125,15 @@ class ErrorMapper {
     if (err instanceof AbortError || (err && err.name === 'AbortError')) {
       const message = err && err.message ? err.message : 'Invocation aborted';
       this._logger.info(
-        { err, operation, correlation_id, code: 'CLIENT_CANCELLED', status: 499 },
-        'invocation aborted by client'
+        'invocation aborted by client',
+        { err, operation, correlation_id, code: 'CLIENT_CANCELLED', status: 499 }
       );
       return this._buildError(499, 'CLIENT_CANCELLED', message, undefined, correlation_id);
     }
 
     this._logger.error(
-      { err, operation, correlation_id, code: 'INTERNAL_ERROR', status: 500, stack: err && err.stack },
-      'unhandled error during operation invocation'
+      'unhandled error during operation invocation',
+      { err, operation, correlation_id, code: 'INTERNAL_ERROR', status: 500, stack: err && err.stack }
     );
     return this._buildError(500, 'INTERNAL_ERROR', 'An internal error occurred', undefined, correlation_id);
   }

package/src/ServiceWrapper.js

@@ -34,6 +34,40 @@ const { ErrorMapper, UnknownOperationError, ValidationError } = require('./Error
 const RUNTIME_DIR = 'conn-runtime';
 const PROOF_RELATIVE_PATH = `${RUNTIME_DIR}/validation-proof.json`;
 
+/**
+ * service-wrapper v3 wires OrchestratorConnector with invoker RPC (conn-orch-orchestrator ≥2).
+ * If npm resolves orchestrator 1.x (stale tree / lockfile), WorkflowOrchestrator throws
+ * "apiMapper is required" — fail here with an explicit contract error instead.
+ * @returns {{ version: string, major: number }}
+ */
+function readConnOrchOrchestratorContractVersion() {
+  let pkg;
+  try {
+    pkg = require('@onlineapps/conn-orch-orchestrator/package.json');
+  } catch (e) {
+    throw new Error(
+      `[ServiceWrapper] Missing dependency - cannot resolve @onlineapps/conn-orch-orchestrator/package.json — ${e.message}. Fix: npm install from service root so @onlineapps/conn-orch-orchestrator is installed.`
+    );
+  }
+  const version = pkg.version;
+  const major = Number(String(version).split('.')[0]);
+  if (!Number.isFinite(major)) {
+    throw new Error(
+      `[ServiceWrapper] Invalid dependency metadata - @onlineapps/conn-orch-orchestrator version "${version}" is not semver-like. Fix: reinstall node_modules from a valid registry lockfile.`
+    );
+  }
+  return { version, major };
+}
+
+function assertConnOrchOrchestratorV2Contract() {
+  const { version, major } = readConnOrchOrchestratorContractVersion();
+  if (major < 2) {
+    throw new Error(
+      `[ServiceWrapper] Dependency contract violation - resolved @onlineapps/conn-orch-orchestrator@${version} is incompatible with service-wrapper v3 (orchestrator invoker model). Expected major version >= 2. Fix: pin "@onlineapps/conn-orch-orchestrator":"2.0.2" (or newer 2.x) in the service package.json, delete node_modules and .oa_drive_deps_hash, then run npm ci.`
+    );
+  }
+}
+
 const REVALIDATION_FAST_BACKOFF_MS = [30000, 60000, 120000, 300000, 600000, 1800000];
 const REVALIDATION_HOURLY_MS = 3600000;
 const REVALIDATION_HOURLY_MAX = 24;
@@ -1468,6 +1502,8 @@ class ServiceWrapper {
    * @private
    */
   async _initializeOrchestrator() {
+    assertConnOrchOrchestratorV2Contract();
+
     const serviceName = this.config.service?.name;
     const serviceVersion = this.config.service?.version;
     const environment = this.config.service?.env;
@@ -1628,23 +1664,71 @@ class ServiceWrapper {
     }
   }
 
+  /**
+   * If the inbound message used RPC (replyTo + correlationId), publish the JSON response
+   * to the caller's reply queue with the same AMQP correlationId.
+   *
+   * @private
+   * @param {object} rawMessage - amqplib consume message
+   * @param {object|null} parsedMessage - parsed JSON body, or null when JSON.parse failed
+   * @param {{ status: string, output?: object, error?: object, correlation_id?: string, workflow_id?: string }} body
+   */
+  async _publishWorkflowRpcReply(rawMessage, parsedMessage, body) {
+    const props = rawMessage && rawMessage.properties;
+    if (!this.mqClient || !props || !props.replyTo || props.correlationId == null || String(props.correlationId) === '') {
+      return;
+    }
+    const amqpCid = String(props.correlationId);
+    const correlation_id =
+      body.correlation_id != null
+        ? String(body.correlation_id)
+        : parsedMessage && parsedMessage.correlation_id != null
+          ? String(parsedMessage.correlation_id)
+          : amqpCid;
+    const workflow_id =
+      body.workflow_id != null
+        ? body.workflow_id
+        : parsedMessage &&
+            (parsedMessage.workflow_id != null || parsedMessage.workflowId != null)
+          ? parsedMessage.workflow_id || parsedMessage.workflowId
+          : undefined;
+    const payload = { ...body, correlation_id };
+    if (workflow_id !== undefined && payload.workflow_id === undefined) {
+      payload.workflow_id = workflow_id;
+    }
+    await this.mqClient.publish(props.replyTo, payload, {
+      correlationId: amqpCid,
+      persistent: true,
+      contentType: 'application/json',
+    });
+  }
+
   /**
    * Process workflow message
    * @private
    */
   async _processWorkflowMessage(rawMessage, queueName) {
+    let message;
     try {
-      // Parse message
-      let message;
       if (rawMessage && rawMessage.content) {
-        // AMQP message with content buffer
         const messageContent = rawMessage.content.toString();
         message = JSON.parse(messageContent);
       } else {
-        // Already parsed message
         message = rawMessage;
       }
+    } catch (parseErr) {
+      try {
+        await this._publishWorkflowRpcReply(rawMessage, null, {
+          status: 'error',
+          error: { message: parseErr.message, code: 'INVALID_JSON' },
+        });
+      } catch (replyErr) {
+        this.logger?.error('[ServiceWrapper] RPC reply after JSON parse error failed', replyErr);
+      }
+      throw parseErr;
+    }
 
+    try {
       // Extract and normalize flags
       const flags = Array.isArray(message.flags) ? message.flags : [];
       const isTest = flags.includes('test');
@@ -1741,6 +1825,11 @@ class ServiceWrapper {
       // ServiceWrapper should NOT publish here to avoid duplicate messages
       // If orchestrator is not used, ServiceWrapper would publish, but that's legacy path
 
+      await this._publishWorkflowRpcReply(rawMessage, message, {
+        status: 'ok',
+        output: result,
+      });
+
       return result;
 
     } catch (error) {
@@ -1755,6 +1844,17 @@ class ServiceWrapper {
       } else {
         this.logger?.error(`Error processing message from ${queueName}:`, error);
       }
+      try {
+        await this._publishWorkflowRpcReply(rawMessage, message, {
+          status: 'error',
+          error: {
+            message: error.message,
+            code: error.code || 'PROCESSING_ERROR',
+          },
+        });
+      } catch (replyErr) {
+        this.logger?.error('[ServiceWrapper] RPC error reply publish failed', replyErr);
+      }
       throw error;
     }
   }
@@ -1967,12 +2067,13 @@ class ServiceWrapper {
 
     this._contextBuilder = new ContextBuilder({
       connectors: {
-        storage: this.stateConnector || null,
+        storage: null,
         cache: this.cacheConnector || null,
         http: null,
         secrets: null,
         monitoring: this.monitoring || null,
-        mq: this.mqClient || null
+        mq: this.mqClient || null,
+        state: this.stateConnector || null
       },
       config: this.config,
       logger