@onlineapps/mq-client-core 1.0.36 → 1.0.38

package/src/utils/publishErrors.js

@@ -0,0 +1,105 @@
+'use strict';
+
+/**
+ * Specialized error types for publish/reconnect flow.
+ * These errors umožní čisté oddělení publish vrstvy a recovery workeru.
+ */
+
+class TransientPublishError extends Error {
+  /**
+   * @param {string} message - Human readable message
+   * @param {Error} [cause]  - Underlying error
+   */
+  constructor(message, cause) {
+    super(message);
+    this.name = 'TransientPublishError';
+    this.cause = cause || null;
+    this.retryable = true;
+  }
+}
+
+class PermanentPublishError extends Error {
+  /**
+   * @param {string} message - Human readable message
+   * @param {Error} [cause]  - Underlying error
+   */
+  constructor(message, cause) {
+    super(message);
+    this.name = 'PermanentPublishError';
+    this.cause = cause || null;
+    this.retryable = false;
+  }
+}
+
+class QueueNotFoundError extends PermanentPublishError {
+  /**
+   * @param {string} queueName
+   * @param {boolean} isInfrastructure
+   * @param {Error} [cause]
+   */
+  constructor(queueName, isInfrastructure, cause) {
+    const baseMessage = isInfrastructure
+      ? `Cannot publish to infrastructure queue ${queueName}: queue does not exist. Infrastructure queues must be created explicitly with correct arguments (TTL, max-length, etc.) before publishing.`
+      : `Queue ${queueName} does not exist`;
+    super(baseMessage, cause);
+    this.name = 'QueueNotFoundError';
+    this.queueName = queueName;
+    this.isInfrastructure = !!isInfrastructure;
+  }
+}
+
+/**
+ * Best-effort klasifikace chyb z publishu do specializovaných typů.
+ * Vrací původní chybu, pokud neodpovídá žádnému známému patternu.
+ *
+ * @param {Error} err
+ * @returns {Error} - buď speciální error, nebo původní err
+ */
+function classifyPublishError(err) {
+  if (!err) {
+    return err;
+  }
+
+  // Už je to náš specializovaný error – ponecháme jak je
+  if (
+    err instanceof TransientPublishError ||
+    err instanceof PermanentPublishError ||
+    err instanceof QueueNotFoundError
+  ) {
+    return err;
+  }
+
+  const message = (err.message || String(err)).toLowerCase();
+
+  // Queue neexistuje – trvalý problém, nerozbitný retry
+  if (message.includes('queue does not exist') || message.includes('no queue') || err.code === 404) {
+    // Nevíme, zda je to infra/biz – necháme isInfrastructure=false, publish vrstva si může dovodit sama
+    return new QueueNotFoundError('unknown', false, err);
+  }
+
+  // Typicky transientní problémy connection/channel
+  if (
+    message.includes('connection closing') ||
+    message.includes('connection closed') ||
+    message.includes('connection ended') ||
+    message.includes('channel closed') ||
+    message.includes('channel ended') ||
+    message.includes('timeout') ||
+    message.includes('confirmation timeout') ||
+    message.includes('reconnecting')
+  ) {
+    return new TransientPublishError(err.message || String(err), err);
+  }
+
+  // Ostatní považujeme za permanentní – ale explicitně označíme typ
+  return new PermanentPublishError(err.message || String(err), err);
+}
+
+module.exports = {
+  TransientPublishError,
+  PermanentPublishError,
+  QueueNotFoundError,
+  classifyPublishError,
+};
+
+

package/src/workers/RecoveryWorker.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const { QueueNotFoundError } = require('../utils/publishErrors');
+
+/**
+ * RecoveryWorker - řeší problémy s publish (connection recovery, queue creation)
+ * 
+ * Scope:
+ * - infrastructure: connection recovery, channel recreation, consumer re-registration (NENÍ queue creation)
+ * - business: connection recovery, channel recreation, consumer re-registration, queue creation (pokud není infra queue)
+ */
+class RecoveryWorker {
+  /**
+   * @param {Object} options
+   * @param {Object} options.client - RabbitMQClient instance
+   * @param {string} [options.scope='infrastructure'] - 'infrastructure' nebo 'business'
+   * @param {Object} [options.logger] - Logger
+   */
+  constructor(options = {}) {
+    if (!options.client) {
+      throw new Error('RecoveryWorker requires a client instance');
+    }
+
+    this._client = options.client;
+    this._scope = options.scope || 'infrastructure';
+    this._logger = options.logger || console;
+
+    // Scope configuration
+    this._queueCreationEnabled = this._scope === 'business';
+    this._queueCreationFilter = options.queueCreationFilter || null;
+  }
+
+  /**
+   * Handle transient publish error
+   * @param {Error} error - TransientPublishError
+   * @param {Object} context - { queue, buffer, options }
+   */
+  async handleTransientError(error, context) {
+    // Transient errors jsou už bufferované v PublishLayer
+    // Recovery worker jen loguje a může triggerovat další akce
+    this._logger?.warn?.(`[RecoveryWorker] Transient error handled (buffered): ${error.message}`, context);
+  }
+
+  /**
+   * Handle QueueNotFoundError
+   * @param {QueueNotFoundError} error
+   * @param {Object} context - { queue, buffer, options }
+   */
+  async handleQueueNotFound(error, context) {
+    if (!(error instanceof QueueNotFoundError)) {
+      return;
+    }
+
+    // Infrastructure queues must exist - cannot create
+    if (error.isInfrastructure) {
+      this._logger?.error?.(`[RecoveryWorker] Cannot create infrastructure queue '${error.queueName}' - must exist before publishing`);
+      throw error;
+    }
+
+    // Business queues - create if scope allows
+    if (this._queueCreationEnabled) {
+      // Check filter if provided
+      if (this._queueCreationFilter && !this._queueCreationFilter(error.queueName)) {
+        this._logger?.warn?.(`[RecoveryWorker] Queue creation filtered out for '${error.queueName}'`);
+        throw error;
+      }
+
+      try {
+        await this.createQueue(error.queueName, context.options);
+        this._logger?.info?.(`[RecoveryWorker] ✓ Created queue '${error.queueName}'`);
+      } catch (createErr) {
+        this._logger?.error?.(`[RecoveryWorker] Failed to create queue '${error.queueName}': ${createErr.message}`);
+        throw error;
+      }
+    } else {
+      this._logger?.error?.(`[RecoveryWorker] Cannot create queue '${error.queueName}' - scope is '${this._scope}' (queue creation disabled)`);
+      throw error;
+    }
+  }
+
+  /**
+   * Create queue (business services only)
+   * @private
+   */
+  async createQueue(queueName, options = {}) {
+    if (!this._queueCreationEnabled) {
+      throw new Error(`Queue creation not enabled for scope '${this._scope}'`);
+    }
+
+    // Use queue channel to create queue
+    await this._client._ensureQueueChannel();
+    
+    const queueOptions = options.queueOptions || { durable: this._client._config.durable };
+    await this._client._queueChannel.assertQueue(queueName, queueOptions);
+  }
+}
+
+module.exports = RecoveryWorker;
+