@adobe-commerce/aio-toolkit 1.2.5 → 1.2.6

package/dist/index.js

@@ -38,6 +38,7 @@ __export(index_exports, {
   AdminUiSdk: () => AdminUiSdk,
   AdobeAuth: () => adobe_auth_default,
   AdobeCommerceClient: () => adobe_commerce_client_default,
+  AmazonSQSClient: () => amazon_sqs_client_default,
   BasicAuthConnection: () => basic_auth_connection_default,
   BearerToken: () => bearer_token_default,
   CreateEvents: () => create_events_default,
@@ -11940,6 +11941,213 @@ __name(_RabbitMQClient, "RabbitMQClient");
 var RabbitMQClient = _RabbitMQClient;
 var rabbit_mq_client_default = RabbitMQClient;
 
+// src/integration/amazon-sqs-client/index.ts
+var import_crypto5 = require("crypto");
+var import_client_sqs = require("@aws-sdk/client-sqs");
+
+// src/integration/amazon-sqs-client/types.ts
+var SQS_MAX_BATCH_SIZE = 10;
+var DEFAULT_VISIBILITY_TIMEOUT = 30;
+var DEFAULT_WAIT_TIME_SECONDS = 0;
+var DEFAULT_MESSAGE_GROUP_ID = "default";
+
+// src/integration/amazon-sqs-client/index.ts
+var _AmazonSQSClient = class _AmazonSQSClient {
+  /**
+   * @param config - AWS region, IAM credentials, target queue URL, and optional
+   *   consumer/FIFO settings (visibilityTimeout, waitTimeSeconds, messageGroupId).
+   */
+  constructor(config) {
+    this.queueUrl = config.queueUrl;
+    this.isFifo = config.queueUrl.endsWith(".fifo");
+    this.visibilityTimeout = config.visibilityTimeout ?? DEFAULT_VISIBILITY_TIMEOUT;
+    this.waitTimeSeconds = config.waitTimeSeconds ?? DEFAULT_WAIT_TIME_SECONDS;
+    this.messageGroupId = config.messageGroupId ?? DEFAULT_MESSAGE_GROUP_ID;
+    this.client = new import_client_sqs.SQSClient({
+      region: config.region,
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey
+      }
+    });
+  }
+  /**
+   * Publishes all `payloads` to the bound queue in batches of 10 (the SQS hard limit
+   * per `SendMessageBatch` call). Failed entries reported by SQS within a successful
+   * batch response are tracked individually in `stats.errors`. Transport errors
+   * (thrown exceptions) are captured per-batch so a single failing batch does not
+   * abort the rest.
+   *
+   * For FIFO queues (URL ends in `.fifo`), every entry is stamped with:
+   * - `MessageGroupId` — the value set at construction time (`config.messageGroupId`,
+   *   defaulting to `'default'`).
+   * - `MessageDeduplicationId` — a unique `randomUUID()` per entry, ensuring
+   *   at-most-once delivery within the 5-minute SQS deduplication window regardless
+   *   of whether content-based deduplication is enabled on the queue.
+   *
+   * @param payloads - Array of string message bodies to send.
+   * @returns Counts of published and failed messages plus per-failure details.
+   */
+  async publish(payloads) {
+    const stats = { published: 0, failed: 0, errors: [] };
+    if (payloads.length === 0) return stats;
+    const chunks = this.chunk(payloads, SQS_MAX_BATCH_SIZE);
+    let globalIndex = 0;
+    for (const chunk of chunks) {
+      await this.sendBatch(chunk, globalIndex, stats);
+      globalIndex += chunk.length;
+    }
+    return stats;
+  }
+  /**
+   * Pulls up to `batchSize` messages from the bound queue and processes each
+   * one via `handler`.
+   *
+   * Processing steps:
+   * 1. Receive messages in ReceiveMessage loops (≤ 10 per call) until `batchSize`
+   *    messages are accumulated or the queue returns empty.
+   * 2. Invoke `handler` concurrently for all received messages.
+   * 3. Delete every message whose handler resolved successfully.
+   *    Messages whose handler threw are left in the queue and become visible again
+   *    after the configured `visibilityTimeout` (set at construction time).
+   *
+   * @param batchSize - Total number of messages to pull per invocation.
+   * @param handler - Callback invoked with the SQS MessageId and raw body string.
+   * @returns Receive / process / delete / fail counts plus per-error details.
+   * @throws Propagates SQS transport errors (receive, delete) to the caller.
+   */
+  async consume(batchSize, handler) {
+    const stats = {
+      received: 0,
+      processed: 0,
+      deleted: 0,
+      failed: 0,
+      errors: []
+    };
+    const messages = await this.receiveMessages(batchSize);
+    stats.received = messages.length;
+    if (messages.length === 0) return stats;
+    const toDelete = [];
+    await Promise.all(
+      messages.map(async (msg) => {
+        stats.processed++;
+        try {
+          await handler(msg.MessageId ?? "", msg.Body ?? "");
+          toDelete.push(msg);
+        } catch (error) {
+          stats.failed++;
+          stats.errors.push({ messageId: msg.MessageId ?? "", error });
+        }
+      })
+    );
+    if (toDelete.length > 0) {
+      await this.deleteMessages(toDelete);
+      stats.deleted += toDelete.length;
+    }
+    return stats;
+  }
+  /**
+   * Loops ReceiveMessage calls until `batchSize` messages are accumulated
+   * or the queue returns an empty response (queue drained).
+   *
+   * The first call uses `this.waitTimeSeconds` (enabling long polling when > 0).
+   * Subsequent fill-up calls always use waitTimeSeconds = 0 to avoid blocking —
+   * if the first call returned messages the queue is clearly non-empty.
+   */
+  async receiveMessages(batchSize) {
+    const messages = [];
+    let isFirstCall = true;
+    while (messages.length < batchSize) {
+      const remaining = batchSize - messages.length;
+      const maxMessages = Math.min(remaining, SQS_MAX_BATCH_SIZE);
+      const response = await this.client.send(
+        new import_client_sqs.ReceiveMessageCommand({
+          QueueUrl: this.queueUrl,
+          MaxNumberOfMessages: maxMessages,
+          VisibilityTimeout: this.visibilityTimeout,
+          WaitTimeSeconds: isFirstCall ? this.waitTimeSeconds : 0
+        })
+      );
+      isFirstCall = false;
+      const received = response.Messages ?? [];
+      if (received.length === 0) break;
+      messages.push(...received);
+      if (received.length < maxMessages) break;
+    }
+    return messages;
+  }
+  /**
+   * Deletes messages from the queue after successful processing.
+   * Uses DeleteMessageBatch (≤ 10 per call).
+   */
+  async deleteMessages(messages) {
+    const chunks = this.chunk(messages, SQS_MAX_BATCH_SIZE);
+    for (const chunk of chunks) {
+      const entries = chunk.map((msg, i) => ({
+        Id: String(i),
+        ReceiptHandle: msg.ReceiptHandle ?? ""
+      }));
+      await this.client.send(
+        new import_client_sqs.DeleteMessageBatchCommand({ QueueUrl: this.queueUrl, Entries: entries })
+      );
+    }
+  }
+  /**
+   * Sends a single publish batch via `SendMessageBatchCommand`.
+   * `globalOffset` generates unique, stable entry IDs across consecutive batches
+   * (SQS requires unique IDs within each request, not globally).
+   * For FIFO queues, each entry is stamped with a `MessageGroupId` and a unique
+   * `MessageDeduplicationId` (randomUUID).
+   * Per-entry SQS failures are captured in `stats.errors`; transport exceptions
+   * mark all entries in the chunk as failed without re-throwing.
+   */
+  async sendBatch(chunk, globalOffset, stats) {
+    const entries = chunk.map((payload, i) => ({
+      Id: String(globalOffset + i),
+      MessageBody: payload,
+      ...this.isFifo && {
+        MessageGroupId: this.messageGroupId,
+        MessageDeduplicationId: (0, import_crypto5.randomUUID)()
+      }
+    }));
+    try {
+      const response = await this.client.send(
+        new import_client_sqs.SendMessageBatchCommand({ QueueUrl: this.queueUrl, Entries: entries })
+      );
+      const successful = response.Successful ?? [];
+      const failed = response.Failed ?? [];
+      stats.published += successful.length;
+      for (const failure of failed) {
+        const entryIndex = Number(failure.Id) - globalOffset;
+        const payload = chunk[entryIndex] ?? "";
+        const error = new Error(
+          `SQS batch entry failed [Id=${failure.Id}] Code=${failure.Code}: ${failure.Message ?? "unknown"}`
+        );
+        stats.failed++;
+        stats.errors.push({ payload, error });
+      }
+    } catch (error) {
+      for (const payload of chunk) {
+        stats.failed++;
+        stats.errors.push({ payload, error });
+      }
+    }
+  }
+  /**
+   * Splits `items` into sequential chunks of at most `size` elements.
+   */
+  chunk(items, size) {
+    const chunks = [];
+    for (let i = 0; i < items.length; i += size) {
+      chunks.push(items.slice(i, i + size));
+    }
+    return chunks;
+  }
+};
+__name(_AmazonSQSClient, "AmazonSQSClient");
+var AmazonSQSClient = _AmazonSQSClient;
+var amazon_sqs_client_default = AmazonSQSClient;
+
 // src/commerce/adobe-commerce-client/index.ts
 var import_got = __toESM(require("got"));
 var _AdobeCommerceClient = class _AdobeCommerceClient {
@@ -12934,6 +13142,7 @@ var AdminUiSdk = _AdminUiSdk;
   AdminUiSdk,
   AdobeAuth,
   AdobeCommerceClient,
+  AmazonSQSClient,
   BasicAuthConnection,
   BearerToken,
   CreateEvents,