@onlineapps/conn-infra-mq 1.1.19 → 1.1.21

package/README.md

@@ -4,16 +4,16 @@
 [![Coverage Status](https://codecov.io/gh/onlineapps/conn-infra-mq/branch/main/graph/badge.svg)](https://codecov.io/gh/onlineapps/conn-infra-mq)
 [![npm version](https://img.shields.io/npm/v/@onlineapps/conn-infra-mq)](https://www.npmjs.com/package/@onlineapps/conn-infra-mq)
 
-> Message queue connector with **layered architecture** for workflow orchestration, RPC, fork-join, and retry patterns. Built on top of RabbitMQ with clean separation of concerns.
+> Message queue connector with **layered architecture** for workflow orchestration, fork-join, and retry patterns. Built on top of RabbitMQ with clean separation of concerns. **Asynchronous workflow pattern only** - synchronous RPC patterns are not supported and not aligned with our architecture philosophy.
 
 ---
 
 ## 🚀 Features
 
-- **Layered Architecture**: Clean separation into specialized layers (WorkflowRouter, QueueManager, ForkJoinHandler, RPCHandler, RetryHandler)
+- **Layered Architecture**: Clean separation into specialized layers (WorkflowRouter, QueueManager, ForkJoinHandler, RetryHandler)
 - **Workflow Orchestration**: Decentralized workflow routing without central orchestrator
 - **Fork-Join Pattern**: Parallel processing with result aggregation and built-in join strategies
-- **RPC Support**: Request-response communication with correlation IDs and timeouts
+- **Asynchronous First**: All communication is asynchronous (fire-and-forget), no synchronous blocking patterns
 - **Automatic Retry**: Exponential backoff, dead letter queue management, configurable retry policies
 - **Queue Management**: TTL, DLQ, auto-delete, temporary queues, exchange bindings
 - **Promise-based API**: All operations return promises for clean async/await usage
@@ -43,7 +43,6 @@ ConnectorMQClient (main orchestrator - for business services only)
     ├── WorkflowRouter (workflow orchestration)
     ├── QueueManager (queue lifecycle management)
     ├── ForkJoinHandler (parallel processing)
-    ├── RPCHandler (request-response patterns)
     └── RetryHandler (error recovery & DLQ)
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@onlineapps/conn-infra-mq",
-    "version": "1.1.19",
+    "version": "1.1.21",
     "description": "A promise-based, broker-agnostic client for sending and receiving messages via RabbitMQ",
     "main": "src/index.js",
     "repository": {

package/src/ConnectorMQClient.js

@@ -4,7 +4,6 @@ const BaseClient = require('@onlineapps/mq-client-core');
 const WorkflowRouter = require('./layers/WorkflowRouter');
 const QueueManager = require('./layers/QueueManager');
 const ForkJoinHandler = require('./layers/ForkJoinHandler');
-const RPCHandler = require('./layers/RPCHandler');
 const RetryHandler = require('./layers/RetryHandler');
 
 /**
@@ -25,8 +24,7 @@ const RetryHandler = require('./layers/RetryHandler');
  * @example <caption>With Workflow</caption>
  * const mqClient = new ConnectorMQClient({
  *   url: 'amqp://localhost:5672',
- *   serviceName: 'invoice-service',
- *   enableRPC: true
+ *   serviceName: 'invoice-service'
  * });
  */
 class ConnectorMQClient extends BaseClient {
@@ -37,7 +35,6 @@ class ConnectorMQClient extends BaseClient {
    * @param {Object} [config={}] - Configuration options
    * @param {string} config.url - RabbitMQ connection URL
    * @param {string} [config.serviceName='unknown'] - Service name
-   * @param {boolean} [config.enableRPC=true] - Enable RPC handler
    * @param {number} [config.prefetchCount=10] - Message prefetch count
    * @param {Object} [config.retry] - Retry configuration
    *
@@ -56,7 +53,6 @@ class ConnectorMQClient extends BaseClient {
     this.queues = new QueueManager(this, config);
     this.retry = new RetryHandler(this, config);
     this.forkJoin = new ForkJoinHandler(this, this.queues, config);
-    this.rpc = new RPCHandler(this, this.queues, config);
 
     // Service identification
     this.serviceName = config.serviceName || 'unknown';
@@ -86,11 +82,6 @@ class ConnectorMQClient extends BaseClient {
     // Base connection
     await super.connect();
 
-    // Initialize RPC handler if needed
-    if (this._config.enableRPC !== false) {
-      await this.rpc.initialize();
-    }
-
     // Setup service queues if service name provided
     const shouldAutoSetup = this._config.autoSetupServiceQueues !== false;
 
@@ -126,7 +117,6 @@ class ConnectorMQClient extends BaseClient {
     if (this._initialized) {
       // Cleanup layers
       await this.forkJoin.cleanupAll();
-      await this.rpc.cleanup();
       await this.queues.cleanup();
     }
 
@@ -291,38 +281,6 @@ class ConnectorMQClient extends BaseClient {
     return this.forkJoin.join(queueName, joinStrategy, options);
   }
 
-  // ============================================
-  // RPC Operations (via RPCHandler)
-  // ============================================
-
-  /**
-   * Make RPC call
-   */
-  async rpcCall(targetQueue, request, options) {
-    return this.rpc.call(targetQueue, request, options);
-  }
-
-  /**
-   * Setup RPC server
-   */
-  async rpcServe(queue, handler, options) {
-    return this.rpc.serve(queue, handler, options);
-  }
-
-  /**
-   * Make multiple RPC calls
-   */
-  async rpcCallMany(requests) {
-    return this.rpc.callMany(requests);
-  }
-
-  /**
-   * RPC with retry
-   */
-  async rpcCallWithRetry(targetQueue, request, options) {
-    return this.rpc.callWithRetry(targetQueue, request, options);
-  }
-
   // ============================================
   // Retry Operations (via RetryHandler)
   // ============================================
@@ -374,8 +332,6 @@ class ConnectorMQClient extends BaseClient {
       return this.publishWorkflowInit(message, options);
     } else if (options.service) {
       return this.publishToService(options.service, message, options);
-    } else if (options.rpc) {
-      return this.rpcCall(options.rpc, message, options);
     } else {
       return this.publish(message, options);
     }
@@ -416,12 +372,10 @@ class ConnectorMQClient extends BaseClient {
         workflow: true,
         queues: true,
         retry: true,
-        forkJoin: true,
-        rpc: this.rpc.getPendingCount() >= 0
+        forkJoin: true
       },
       stats: {
         retry: this.retry.getStats(),
-        pendingRPC: this.rpc.getPendingCount(),
         managedQueues: this.queues.getManagedQueues().length
       }
     };

package/src/index.js

@@ -2,8 +2,8 @@
 
 /**
  * @module @onlineapps/conn-infra-mq
- * @description RabbitMQ connector with workflow routing, fork-join, RPC, and retry patterns for OA Drive.
- * Provides layered architecture for complex messaging patterns.
+ * @description RabbitMQ connector with workflow routing, fork-join, and retry patterns for OA Drive.
+ * Provides layered architecture for asynchronous messaging patterns.
  *
  * @see {@link https://github.com/onlineapps/oa-drive/tree/main/shared/connector/conn-infra-mq|GitHub Repository}
  * @author OA Drive Team
@@ -18,7 +18,6 @@ const BaseClient = require('@onlineapps/mq-client-core');
 const WorkflowRouter = require('./layers/WorkflowRouter');
 const QueueManager = require('./layers/QueueManager');
 const ForkJoinHandler = require('./layers/ForkJoinHandler');
-const RPCHandler = require('./layers/RPCHandler');
 const RetryHandler = require('./layers/RetryHandler');
 
 // Default export - the main client
@@ -33,7 +32,6 @@ module.exports.layers = {
   WorkflowRouter,
   QueueManager,
   ForkJoinHandler,
-  RPCHandler,
   RetryHandler
 };
 

package/src/layers/QueueManager.js

@@ -103,17 +103,40 @@ class QueueManager {
         throw new Error('Channel closed during checkQueue - cannot verify queue');
       }
       
-      // If queue doesn't exist (404), we'll let it be created lazily on first publish
-      // This avoids RPC reply queue issues with assertQueue()
+      // If queue doesn't exist (404), create it using assertQueue with proper error handling
+      // Business queues MUST be created with specific arguments (TTL, DLQ, max-length) from queueConfig
+      // Lazy creation via sendToQueue() is NOT suitable - it creates queue with default arguments
       if (checkErr.code === 404) {
-        // Queue doesn't exist - will be created on first sendToQueue()
-        // Return a mock queue info to indicate queue will be created lazily
-        console.info(`[QueueManager] Queue ${queueName} doesn't exist - will be created on first publish`);
-        return {
-          queue: queueName,
-          messageCount: 0,
-          consumerCount: 0
-        };
+        // CRITICAL: Business queues MUST be created explicitly with correct arguments
+        // Use assertQueue() on regular channel (queueChannel) - this should work without RPC issues
+        // If it fails, it's a real problem that needs to be fixed, not worked around
+        try {
+          if (!channel || channel.closed) {
+            throw new Error('Channel closed - cannot create queue');
+          }
+          
+          // For business queues: use assertQueue with queueOptions from queueConfig
+          // This ensures correct TTL, DLQ, max-length arguments
+          return await channel.assertQueue(queueName, queueOptions);
+        } catch (assertErr) {
+          // If channel closed during assertQueue, it's a real error
+          if (!channel || channel.closed) {
+            throw new Error(`Channel closed during assertQueue for ${queueName} - check channel management`);
+          }
+          
+          // If 406 PRECONDITION-FAILED, queue exists with different args
+          if (assertErr.code === 406) {
+            console.warn(`[QueueManager] Queue ${queueName} exists with different arguments:`, assertErr.message);
+            // Try to get queue info anyway
+            if (!channel || channel.closed) {
+              throw new Error('Channel closed - cannot check existing queue');
+            }
+            return await channel.checkQueue(queueName);
+          }
+          
+          // Other errors - rethrow
+          throw assertErr;
+        }
       } else {
         // Other error (including 406) - queue exists with different args
         // Log warning and return queue info without asserting

package/src/transports/rabbitmqClient.js

@@ -222,23 +222,24 @@ class RabbitMQClient extends EventEmitter {
             throw checkErr;
           }
         } else {
-          // Business queue - may need to be created, but use unified config
+          // Business queue - should already be created by setupServiceQueues() BEFORE consume is called
           // Use queueChannel (regular channel) for queue operations to avoid RPC reply queue issues
-          const queueOptions = this._getQueueOptions(queue, { durable });
-          
-          // Try to assert queue with our config
-          // If it fails with 406 (PRECONDITION-FAILED), queue exists with different args - use it as-is
-          // IMPORTANT: Don't try to re-assert after 406, as it will close the channel
+          // Only check if it exists - don't try to create it here (that's setupServiceQueues() responsibility)
           try {
-            await this._queueChannel.assertQueue(queue, queueOptions);
-          } catch (assertErr) {
-            // If queue exists with different arguments (406), use it as-is without re-asserting
-            if (assertErr.code === 406) {
-              console.warn(`[RabbitMQClient] Queue ${queue} exists with different arguments, using as-is (skipping assert to avoid channel close):`, assertErr.message);
-              // Don't try to re-assert - just proceed to consume
+            await this._queueChannel.checkQueue(queue);
+            // Queue exists - proceed to consume
+          } catch (checkErr) {
+            if (checkErr.code === 404) {
+              // Queue doesn't exist - this is an error, queue should have been created by setupServiceQueues()
+              throw new Error(`Business queue '${queue}' not found. Queue should be created by setupServiceQueues() before consuming.`);
+            }
+            // Other error (including 406) - queue exists with different args, use it as-is
+            if (checkErr.code === 406) {
+              console.warn(`[RabbitMQClient] Queue ${queue} exists with different arguments, using as-is:`, checkErr.message);
+              // Proceed to consume - queue exists, just with different args
             } else {
               // Other error - rethrow
-              throw assertErr;
+              throw checkErr;
             }
           }
         }

package/src/layers/RPCHandler.js

@@ -1,324 +0,0 @@
-'use strict';
-
-/**
- * RPCHandler - Manages RPC (Remote Procedure Call) patterns
- * Handles request-response communication with correlation IDs and timeouts
- */
-class RPCHandler {
-  constructor(mqClient, queueManager, config = {}) {
-    this.client = mqClient;
-    this.queueManager = queueManager;
-    this.config = {
-      defaultTimeout: config.defaultTimeout || 5000,
-      replyQueuePrefix: config.replyQueuePrefix || 'rpc.reply',
-      ...config
-    };
-    this.pendingRequests = new Map();
-    this.replyQueue = null;
-    this.replyConsumer = null;
-  }
-
-  /**
-   * Initialize RPC handler (create reply queue)
-   */
-  async initialize() {
-    if (this.replyQueue) {
-      return this.replyQueue;
-    }
-
-    // Create exclusive reply queue
-    this.replyQueue = await this.queueManager.createTemporaryQueue(
-      this.config.replyQueuePrefix,
-      {
-        exclusive: true,
-        autoDelete: true,
-        expires: 3600000 // 1 hour
-      }
-    );
-
-    // Start consuming replies
-    this.replyConsumer = await this.client.consume(
-      this.replyQueue,
-      (message, rawMsg) => this.handleReply(message, rawMsg),
-      {
-        noAck: true
-      }
-    );
-
-    return this.replyQueue;
-  }
-
-  /**
-   * Send RPC request and wait for response
-   * @param {string} targetQueue - Target service queue
-   * @param {Object} request - Request message
-   * @param {Object} options - RPC options
-   */
-  async call(targetQueue, request, options = {}) {
-    // Ensure reply queue exists
-    await this.initialize();
-
-    const correlationId = this.generateCorrelationId();
-    const timeout = options.timeout || this.config.defaultTimeout;
-
-    // Create promise for response
-    const responsePromise = new Promise((resolve, reject) => {
-      // Setup timeout
-      const timeoutHandle = setTimeout(() => {
-        this.pendingRequests.delete(correlationId);
-        reject(new Error(`RPC request timeout after ${timeout}ms`));
-      }, timeout);
-
-      // Store pending request
-      this.pendingRequests.set(correlationId, {
-        resolve,
-        reject,
-        timeoutHandle,
-        startTime: Date.now(),
-        targetQueue
-      });
-    });
-
-    // Send request with correlation ID and reply queue
-    await this.client.publish(request, {
-      queue: targetQueue,
-      correlationId,
-      replyTo: this.replyQueue,
-      expiration: timeout.toString(),
-      ...options
-    });
-
-    return responsePromise;
-  }
-
-  /**
-   * Setup service as RPC server
-   * @param {string} queue - Queue to listen on
-   * @param {Function} handler - Request handler function
-   * @param {Object} options - Server options
-   */
-  async serve(queue, handler, options = {}) {
-    return this.client.consume(async (request, rawMsg) => {
-      const { correlationId, replyTo } = rawMsg.properties;
-
-      if (!replyTo) {
-        // Not an RPC request, handle normally
-        if (options.allowNonRPC) {
-          await handler(request, rawMsg);
-        }
-        await this.client.ack(rawMsg);
-        return;
-      }
-
-      try {
-        // Process request
-        const response = await handler(request, rawMsg);
-
-        // Send response
-        if (replyTo && correlationId) {
-          await this.client.publish(response, {
-            queue: replyTo,
-            correlationId
-          });
-        }
-
-        await this.client.ack(rawMsg);
-      } catch (error) {
-        // Send error response
-        if (replyTo && correlationId) {
-          await this.client.publish(
-            {
-              error: {
-                message: error.message,
-                code: error.code || 'RPC_ERROR',
-                timestamp: Date.now()
-              }
-            },
-            {
-              queue: replyTo,
-              correlationId
-            }
-          );
-        }
-
-        // Reject or acknowledge based on configuration
-        if (options.rejectOnError) {
-          await this.client.nack(rawMsg, false);
-        } else {
-          await this.client.ack(rawMsg);
-        }
-      }
-    }, {
-      queue,
-      ...options
-    });
-  }
-
-  /**
-   * Handle RPC reply
-   * @private
-   */
-  handleReply(message, rawMsg) {
-    const { correlationId } = rawMsg.properties;
-
-    if (!correlationId || !this.pendingRequests.has(correlationId)) {
-      // Unknown or expired request
-      return;
-    }
-
-    const pending = this.pendingRequests.get(correlationId);
-    this.pendingRequests.delete(correlationId);
-
-    // Clear timeout
-    clearTimeout(pending.timeoutHandle);
-
-    // Calculate round-trip time
-    const rtt = Date.now() - pending.startTime;
-
-    // Check for error response
-    if (message && message.error) {
-      const error = new Error(message.error.message || 'RPC error');
-      error.code = message.error.code;
-      error.rtt = rtt;
-      pending.reject(error);
-    } else {
-      // Add metadata to response
-      if (typeof message === 'object' && message !== null) {
-        message._rpcMetadata = {
-          rtt,
-          correlationId,
-          targetQueue: pending.targetQueue
-        };
-      }
-      pending.resolve(message);
-    }
-  }
-
-  /**
-   * Call multiple RPC requests in parallel
-   * @param {Array} requests - Array of { queue, request, options } objects
-   */
-  async callMany(requests) {
-    const promises = requests.map(req =>
-      this.call(req.queue, req.request, req.options)
-        .then(response => ({ success: true, response, queue: req.queue }))
-        .catch(error => ({ success: false, error, queue: req.queue }))
-    );
-
-    return Promise.all(promises);
-  }
-
-  /**
-   * Call with retry logic
-   * @param {string} targetQueue - Target service queue
-   * @param {Object} request - Request message
-   * @param {Object} options - RPC options with retry configuration
-   */
-  async callWithRetry(targetQueue, request, options = {}) {
-    const maxRetries = options.maxRetries || 3;
-    const retryDelay = options.retryDelay || 1000;
-    let lastError;
-
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        return await this.call(targetQueue, request, options);
-      } catch (error) {
-        lastError = error;
-
-        if (attempt < maxRetries) {
-          // Wait before retry with exponential backoff
-          const delay = retryDelay * Math.pow(2, attempt);
-          await new Promise(resolve => setTimeout(resolve, delay));
-        }
-      }
-    }
-
-    throw lastError;
-  }
-
-  /**
-   * Broadcast request to multiple queues and collect responses
-   * @param {Array} queues - Target queues
-   * @param {Object} request - Request message
-   * @param {Object} options - Broadcast options
-   */
-  async broadcast(queues, request, options = {}) {
-    const timeout = options.timeout || this.config.defaultTimeout;
-    const waitForAll = options.waitForAll !== false;
-
-    const results = [];
-    const promises = [];
-
-    for (const queue of queues) {
-      const promise = this.call(queue, request, { timeout })
-        .then(response => {
-          results.push({ queue, response, success: true });
-          return { queue, response, success: true };
-        })
-        .catch(error => {
-          const result = { queue, error: error.message, success: false };
-          if (!waitForAll) {
-            results.push(result);
-          }
-          return result;
-        });
-
-      promises.push(promise);
-    }
-
-    if (waitForAll) {
-      const allResults = await Promise.all(promises);
-      return allResults;
-    } else {
-      // Race for first successful response
-      await Promise.race(promises.filter(p => p.then(r => r.success)));
-      return results;
-    }
-  }
-
-  /**
-   * Generate unique correlation ID
-   * @private
-   */
-  generateCorrelationId() {
-    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  /**
-   * Get pending requests count
-   */
-  getPendingCount() {
-    return this.pendingRequests.size;
-  }
-
-  /**
-   * Clear all pending requests
-   */
-  clearPending() {
-    for (const pending of this.pendingRequests.values()) {
-      clearTimeout(pending.timeoutHandle);
-      pending.reject(new Error('RPC handler shutdown'));
-    }
-    this.pendingRequests.clear();
-  }
-
-  /**
-   * Cleanup RPC handler
-   */
-  async cleanup() {
-    this.clearPending();
-
-    if (this.replyQueue) {
-      try {
-        await this.queueManager.deleteQueue(this.replyQueue);
-      } catch (error) {
-        // Queue might already be deleted
-      }
-      this.replyQueue = null;
-    }
-
-    this.replyConsumer = null;
-  }
-}
-
-module.exports = RPCHandler;