@adobe-commerce/aio-toolkit 1.2.3 → 1.2.4

package/dist/index.mjs

@@ -5978,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
@@ -6405,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
@@ -6427,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;
   }
@@ -11708,11 +11726,11 @@ var _RabbitMQClient = class _RabbitMQClient {
     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.
+   * 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).
@@ -11734,16 +11752,20 @@ var _RabbitMQClient = class _RabbitMQClient {
       }
       return await this.processBatch(channel, queueName, options, handler);
     } finally {
-      await channel?.close();
+      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`) 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.
+   * 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.
@@ -11756,27 +11778,30 @@ var _RabbitMQClient = class _RabbitMQClient {
     try {
       channel = await connection.createChannel();
       await channel.assertQueue(queueName, { durable: true });
-      return this.publishBatch(channel, queueName, payloads);
+      return await this.publishBatch(channel, queueName, payloads);
     } finally {
-      await channel?.close();
+      try {
+        await channel?.close();
+      } catch {
+      }
       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.
+   * 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.
    */
-  publishBatch(channel, queueName, payloads) {
+  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 });
-        if (sent) {
-          stats.published++;
-        } else {
-          stats.failed++;
-          stats.errors.push({ payload, error: new Error("Write buffer full") });
+        stats.published++;
+        if (!sent) {
+          await new Promise((resolve) => channel.once("drain", resolve));
         }
       } catch (error) {
         stats.failed++;
@@ -11796,63 +11821,37 @@ var _RabbitMQClient = class _RabbitMQClient {
     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.
+   * 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.
    *
-   * 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.
+   * 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 maxParallel = Math.floor(options.maxParallel);
-    const batchSize = Math.floor(options.batchSize);
+    const { batchSize, maxParallel } = options;
     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++;
+    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++;
-        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);
-    });
+      }
+      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.