@adobe-commerce/aio-toolkit 1.2.2 → 1.2.3

package/dist/index.mjs

@@ -5877,11 +5877,15 @@ var _AbdbCollection = class _AbdbCollection {
       const collection = await client.collection(this._name);
       return await callback(collection, client);
     } catch (error) {
-      if (error instanceof DbError) {
-        throw new Error(`AbdbCollection: database error: ${error.message}`);
+      if (DbError && error instanceof DbError) {
+        const dbErr = new Error(`AbdbCollection: database error: ${error.message}`);
+        dbErr.cause = error;
+        throw dbErr;
       }
       const detail = error instanceof Error ? error.message : String(error);
-      throw new Error(`AbdbCollection: unexpected error: ${detail}`);
+      const unexpectedErr = new Error(`AbdbCollection: unexpected error: ${detail}`);
+      unexpectedErr.cause = error;
+      throw unexpectedErr;
     } finally {
       await client?.close();
     }
@@ -11694,6 +11698,185 @@ __name(_OnboardCommerce, "OnboardCommerce");
 var OnboardCommerce = _OnboardCommerce;
 var onboard_commerce_default = OnboardCommerce;
 
+// src/integration/rabbit-mq-client/index.ts
+import amqplib from "amqplib";
+var _RabbitMQClient = class _RabbitMQClient {
+  /**
+   * @param credentials - AMQP connection credentials (host, port, username, password, vhost).
+   */
+  constructor(credentials) {
+    this.credentials = credentials;
+  }
+  /**
+   * Opens an AMQP connection, checks queue depth, sets prefetch for concurrency control,
+   * and starts a push consumer. The broker delivers at most `maxParallel` unacked messages
+   * at a time, so processing concurrency is naturally bounded without a separate semaphore.
+   * The consumer is cancelled once `effectiveBatch = min(batchSize, messageCount)` messages
+   * are received and processed. The connection is always closed in a `finally` block.
+   *
+   * @param queueName - Name of the queue to consume from.
+   * @param options - Consume configuration (batchSize, maxParallel, nackRequeue, exchange).
+   * @param handler - Callback invoked with the queue name and decoded string content of each message.
+   * @returns Counts of consumed, acked, and nacked messages; plus per-failure details in `errors`.
+   * @throws Propagates connection, exchange-assertion, or queue-assertion errors to the caller.
+   */
+  async consume(queueName, options, handler) {
+    const connection = await amqplib.connect(this.buildConnectionUrl());
+    let channel;
+    try {
+      channel = await connection.createChannel();
+      if (options.exchange) {
+        await channel.assertExchange(options.exchange, "direct", { durable: true });
+        await channel.assertQueue(queueName, { durable: true });
+        await channel.bindQueue(queueName, options.exchange, queueName);
+      } else {
+        await channel.assertQueue(queueName, { durable: true });
+      }
+      return await this.processBatch(channel, queueName, options, handler);
+    } finally {
+      await channel?.close();
+      await connection.close();
+    }
+  }
+  /**
+   * Opens an AMQP connection, asserts the queue, and enqueues each payload in `payloads`.
+   * Each payload is sent as a persistent message via `sendToQueue`. If the write buffer is
+   * full (`sendToQueue` returns `false`) or the call throws, the payload is recorded in
+   * `stats.errors` and counted as failed. The connection is always closed in a `finally`
+   * block regardless of outcome.
+   *
+   * @param queueName - Name of the queue to publish to.
+   * @param payloads - Array of string payloads to enqueue.
+   * @returns Counts of published and failed messages; plus per-failure details in `errors`.
+   * @throws Propagates connection or queue-assertion errors to the caller.
+   */
+  async publish(queueName, payloads) {
+    const connection = await amqplib.connect(this.buildConnectionUrl());
+    let channel;
+    try {
+      channel = await connection.createChannel();
+      await channel.assertQueue(queueName, { durable: true });
+      return this.publishBatch(channel, queueName, payloads);
+    } finally {
+      await channel?.close();
+      await connection.close();
+    }
+  }
+  /**
+   * Sends each payload to the queue via `sendToQueue`. Tracks published and failed counts.
+   * A payload is considered failed when `sendToQueue` returns `false` (write buffer full)
+   * or throws an error.
+   */
+  publishBatch(channel, queueName, payloads) {
+    const stats = { published: 0, failed: 0, errors: [] };
+    for (const payload of payloads) {
+      try {
+        const sent = channel.sendToQueue(queueName, Buffer.from(payload), { persistent: true });
+        if (sent) {
+          stats.published++;
+        } else {
+          stats.failed++;
+          stats.errors.push({ payload, error: new Error("Write buffer full") });
+        }
+      } catch (error) {
+        stats.failed++;
+        stats.errors.push({ payload, error });
+      }
+    }
+    return stats;
+  }
+  /**
+   * Builds the AMQP connection URL from the stored credentials.
+   * Uses `amqps://` when `secure` is true, `amqp://` otherwise.
+   * Username, password, and vhost are percent-encoded to handle special characters.
+   */
+  buildConnectionUrl() {
+    const { host, port, username, password, vhost, secure = false } = this.credentials;
+    const protocol = secure ? "amqps" : "amqp";
+    return `${protocol}://${encodeURIComponent(username)}:${encodeURIComponent(password)}@${host}:${port}/${encodeURIComponent(vhost)}`;
+  }
+  /**
+   * Checks queue depth via `channel.checkQueue`, then sets `channel.prefetch(maxParallel)`
+   * for broker-side concurrency control. Registers a push consumer that receives
+   * `effectiveBatch = min(batchSize, messageCount)` messages. The Promise resolves after
+   * `channel.consume` setup completes and all in-flight handlers have settled.
+   *
+   * Because the broker delivers at most `maxParallel` unacked messages at a time, processing
+   * concurrency is bounded without a separate semaphore — each ack/nack releases a slot.
+   */
+  async processBatch(channel, queueName, options, handler) {
+    const stats = { consumed: 0, acked: 0, nacked: 0, errors: [] };
+    const maxParallel = Math.floor(options.maxParallel);
+    const batchSize = Math.floor(options.batchSize);
+    const { messageCount } = await channel.checkQueue(queueName);
+    if (messageCount === 0) return stats;
+    const effectiveBatch = Math.min(batchSize, messageCount);
+    await channel.prefetch(maxParallel);
+    return new Promise((resolve, reject) => {
+      let consumerTag = "";
+      let cancelRequested = false;
+      let received = 0;
+      let pending = 0;
+      let setupDone = false;
+      const maybeResolve = /* @__PURE__ */ __name(() => {
+        if ((received >= effectiveBatch || cancelRequested) && pending === 0 && setupDone) {
+          resolve(stats);
+        }
+      }, "maybeResolve");
+      const msgCallback = /* @__PURE__ */ __name(async (msg) => {
+        if (!msg || received >= effectiveBatch) return;
+        received++;
+        stats.consumed++;
+        pending++;
+        if (received >= effectiveBatch) {
+          cancelRequested = true;
+          if (consumerTag) {
+            channel.cancel(consumerTag).catch(reject);
+          }
+        }
+        await this.processMessage(channel, queueName, msg, stats, options, handler);
+        pending--;
+        maybeResolve();
+      }, "msgCallback");
+      channel.consume(queueName, msgCallback, { noAck: false }).then(async ({ consumerTag: tag }) => {
+        consumerTag = tag;
+        setupDone = true;
+        if (cancelRequested) {
+          channel.cancel(tag).catch(reject);
+        } else if (received === 0) {
+          const { messageCount: remaining } = await channel.checkQueue(queueName);
+          if (remaining === 0) {
+            cancelRequested = true;
+            channel.cancel(tag).catch(reject);
+          }
+        }
+        maybeResolve();
+      }).catch(reject);
+    });
+  }
+  /**
+   * Invokes `handler` with the queue name and decoded message content. Acks on success.
+   * On failure, nacks the message and records the content and error in `stats.errors`.
+   * Whether to requeue on nack is controlled by `options.nackRequeue` (default: true).
+   */
+  async processMessage(channel, queueName, msg, stats, options, handler) {
+    const { nackRequeue = true } = options;
+    const content = msg.content.toString();
+    try {
+      await handler(queueName, content);
+      channel.ack(msg);
+      stats.acked++;
+    } catch (error) {
+      channel.nack(msg, false, nackRequeue);
+      stats.errors.push({ content, error });
+      stats.nacked++;
+    }
+  }
+};
+__name(_RabbitMQClient, "RabbitMQClient");
+var RabbitMQClient = _RabbitMQClient;
+var rabbit_mq_client_default = RabbitMQClient;
+
 // src/commerce/adobe-commerce-client/index.ts
 import got from "got";
 var _AdobeCommerceClient = class _AdobeCommerceClient {
@@ -12713,6 +12896,7 @@ export {
   parameters_default as Parameters,
   provider_default as ProviderManager,
   publish_event_default as PublishEvent,
+  rabbit_mq_client_default as RabbitMQClient,
   registration_default as RegistrationManager,
   rest_client_default as RestClient,
   runtime_action_default as RuntimeAction,