@adobe-commerce/aio-toolkit 1.2.2 → 1.2.4

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();
     }
@@ -5974,13 +5978,31 @@ var _AbdbRepository = class _AbdbRepository {
    * Returns all documents matching `filter` as an array.
    * Passing no filter (or an empty object) returns every document in the collection.
    *
+   * Pagination and sorting are applied in the following MongoDB cursor order:
+   * `.find(filter)` → `.sort(...)` → `.skip(...)` → `.limit(...)` → `.toArray()`
+   *
    * @param filter - Optional query filter (default: `{}`)
+   * @param options - Optional pagination and sort configuration
+   * @param options.sort - Column and direction to sort by (`'asc'` maps to `1`, `'desc'` to `-1`)
+   * @param options.page_size - Maximum number of documents to return
+   * @param options.current_page - 1-based page index; combined with `page_size` to compute `.skip()`
    * @returns Array of matched documents (may be empty)
    */
-  async find(filter = {}) {
+  async find(filter = {}, options = {}) {
     return this._collection.run(
       async (collection) => {
-        return collection.find(filter).toArray();
+        const { current_page, page_size, sort } = options;
+        let cursor = collection.find(filter);
+        if (sort?.column) {
+          cursor = cursor.sort({ [sort.column]: sort.direction === "desc" ? -1 : 1 });
+        }
+        if (page_size !== void 0 && page_size > 0) {
+          if (current_page !== void 0 && current_page > 1) {
+            cursor = cursor.skip((current_page - 1) * page_size);
+          }
+          cursor = cursor.limit(page_size);
+        }
+        return cursor.toArray();
       },
       this._token,
       this._region
@@ -6401,7 +6423,7 @@ var _WebhookActionResponse = class _WebhookActionResponse {
    * processing the webhook. This helps with debugging and error tracking.
    *
    * @param message - Optional error message describing what went wrong
-   * @param exceptionClass - Optional exception class name for categorization (e.g., 'Magento\\Framework\\Exception\\LocalizedException')
+   * @param exceptionType - Optional exception type name for categorization (e.g., 'Magento\\Framework\\Exception\\LocalizedException')
    * @returns An exception response object
    *
    * @example
@@ -6423,15 +6445,15 @@ var _WebhookActionResponse = class _WebhookActionResponse {
    * });
    * ```
    */
-  static exception(message, exceptionClass) {
+  static exception(message, exceptionType) {
     const response = {
       op: "exception" /* EXCEPTION */
     };
     if (message !== void 0) {
       response.message = message;
     }
-    if (exceptionClass !== void 0) {
-      response.class = exceptionClass;
+    if (exceptionType !== void 0) {
+      response.type = exceptionType;
     }
     return response;
   }
@@ -11694,6 +11716,166 @@ __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, and pulls up to
+   * `effectiveBatch = min(batchSize, messageCount)` messages via channel.get.
+   * Messages are processed in parallel windows of `maxParallel`. channel.get returns
+   * false when the queue is empty, so the method exits deterministically without any
+   * cancellation logic. 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 {
+      try {
+        await channel?.close();
+      } catch {
+      }
+      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`), the message is still counted as published and the
+   * method waits for the channel's `drain` event before continuing, to respect backpressure
+   * without losing messages. Only genuine send errors (thrown exceptions) are counted as
+   * failures. 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 await this.publishBatch(channel, queueName, payloads);
+    } finally {
+      try {
+        await channel?.close();
+      } catch {
+      }
+      await connection.close();
+    }
+  }
+  /**
+   * Sends each payload to the queue via `sendToQueue`. Tracks published and failed counts.
+   * When `sendToQueue` returns `false` (write buffer full / backpressure), the message is
+   * still counted as published — it is already accepted by the channel — and the loop
+   * pauses until the channel emits `drain` before continuing, preventing unbounded memory
+   * pressure. A payload is only counted as failed when `sendToQueue` throws an error.
+   */
+  async 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 });
+        stats.published++;
+        if (!sent) {
+          await new Promise((resolve) => channel.once("drain", resolve));
+        }
+      } 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 pulls up to
+   * `effectiveBatch = min(batchSize, messageCount)` messages using channel.get
+   * (AMQP basic.get). Messages are processed in parallel windows of `maxParallel`:
+   * each window pulls up to `maxParallel` messages sequentially, then processes them
+   * concurrently via Promise.all before moving to the next window.
+   *
+   * channel.get returns false when the queue is empty, so the loop exits immediately
+   * if siblings have drained the queue — no consumer registration, no cancel, no hang.
+   */
+  async processBatch(channel, queueName, options, handler) {
+    const stats = { consumed: 0, acked: 0, nacked: 0, errors: [] };
+    const { batchSize, maxParallel } = options;
+    const { messageCount } = await channel.checkQueue(queueName);
+    if (messageCount === 0) return stats;
+    const effectiveBatch = Math.min(batchSize, messageCount);
+    while (stats.consumed < effectiveBatch) {
+      const windowSize = Math.min(maxParallel, effectiveBatch - stats.consumed);
+      const window = [];
+      for (let i = 0; i < windowSize; i++) {
+        const msg = await channel.get(queueName, { noAck: false });
+        if (!msg) break;
+        window.push(msg);
+        stats.consumed++;
+      }
+      if (window.length === 0) break;
+      await Promise.all(
+        window.map((msg) => this.processMessage(channel, queueName, msg, stats, options, handler))
+      );
+      if (window.length < windowSize) break;
+    }
+    return stats;
+  }
+  /**
+   * 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 +12895,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,