@vercel/queue 0.2.1 → 0.3.1

package/dist/index.mjs

@@ -120,6 +120,15 @@ var MessageLockedError = class extends Error {
     this.retryAfter = retryAfter;
   }
 };
+var TooManyRequestsError = class extends Error {
+  /** Suggested retry delay in seconds, from the Retry-After header, if sent. */
+  retryAfter;
+  constructor(message = "Too many requests", retryAfter) {
+    super(message);
+    this.name = "TooManyRequestsError";
+    this.retryAfter = retryAfter;
+  }
+};
 var UnauthorizedError = class extends Error {
   constructor(message = "Missing or invalid authentication token") {
     super(message);
@@ -185,6 +194,8 @@ var MIN_VISIBILITY_TIMEOUT_SECONDS = 30;
 var MAX_RENEWAL_INTERVAL_SECONDS = 60;
 var MIN_RENEWAL_INTERVAL_SECONDS = 10;
 var RETRY_INTERVAL_MS = 3e3;
+var DIRECTIVE_CALL_ATTEMPTS = 3;
+var DIRECTIVE_CALL_RETRY_DELAY_MS = 250;
 function calculateRenewalInterval(visibilityTimeoutSeconds) {
   return Math.min(
     MAX_RENEWAL_INTERVAL_SECONDS,
@@ -228,6 +239,54 @@ var ConsumerGroup = class {
     error instanceof UnauthorizedError || // 401 - auth failed
     error instanceof ForbiddenError;
   }
+  /**
+   * Network-level failures (DNS, connection reset, socket close) surface
+   * from fetch as TypeError with the cause attached; any response that
+   * actually reached the server — whatever its HTTP status — does not.
+   */
+  isNetworkError(error) {
+    return error instanceof TypeError;
+  }
+  /**
+   * Run a directive call (acknowledge / changeVisibility) with bounded
+   * retries. Only failures that are worth re-attempting in process are
+   * retried:
+   * - network-level failures (the request may never have reached the
+   *   server), with jittered linear backoff;
+   * - 429 responses that carry a Retry-After header, waiting the
+   *   indicated delay.
+   * Everything else — other 4xx, 5xx, 429 without Retry-After — is
+   * thrown immediately.
+   */
+  async directiveCallWithRetries(fn) {
+    let lastError;
+    for (let attempt = 1; attempt <= DIRECTIVE_CALL_ATTEMPTS; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error;
+        if (attempt === DIRECTIVE_CALL_ATTEMPTS) {
+          throw error;
+        }
+        if (error instanceof TooManyRequestsError) {
+          if (error.retryAfter === void 0) {
+            throw error;
+          }
+          await new Promise(
+            (resolve2) => setTimeout(resolve2, error.retryAfter * 1e3)
+          );
+          continue;
+        }
+        if (!this.isNetworkError(error)) {
+          throw error;
+        }
+        const baseDelayMs = DIRECTIVE_CALL_RETRY_DELAY_MS * attempt;
+        const delayMs = baseDelayMs / 2 + Math.random() * (baseDelayMs / 2);
+        await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+      }
+    }
+    throw lastError;
+  }
   /**
    * Starts a background loop that periodically extends the visibility timeout for a message.
    *
@@ -372,11 +431,13 @@ var ConsumerGroup = class {
         if (directive) {
           if ("acknowledge" in directive && directive.acknowledge) {
             try {
-              await this.client.acknowledgeMessage({
-                queueName: this.topicName,
-                consumerGroup: this.consumerGroupName,
-                receiptHandle: message.receiptHandle
-              });
+              await this.directiveCallWithRetries(
+                () => this.client.acknowledgeMessage({
+                  queueName: this.topicName,
+                  consumerGroup: this.consumerGroupName,
+                  receiptHandle: message.receiptHandle
+                })
+              );
             } catch (ackError) {
               console.warn("Failed to acknowledge message:", ackError);
             }
@@ -385,12 +446,14 @@ var ConsumerGroup = class {
           }
           if ("afterSeconds" in directive && typeof directive.afterSeconds === "number") {
             try {
-              await this.client.changeVisibility({
-                queueName: this.topicName,
-                consumerGroup: this.consumerGroupName,
-                receiptHandle: message.receiptHandle,
-                visibilityTimeoutSeconds: directive.afterSeconds
-              });
+              await this.directiveCallWithRetries(
+                () => this.client.changeVisibility({
+                  queueName: this.topicName,
+                  consumerGroup: this.consumerGroupName,
+                  receiptHandle: message.receiptHandle,
+                  visibilityTimeoutSeconds: directive.afterSeconds
+                })
+              );
             } catch (changeError) {
               console.warn(
                 "Failed to reschedule message for retry:",
@@ -1452,10 +1515,28 @@ async function consumeStream(stream) {
     reader.releaseLock();
   }
 }
-function throwCommonHttpError(status, statusText, errorText, operation, badRequestDefault = "Invalid parameters") {
+function parseRetryAfterSeconds(value) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) {
+    return seconds;
+  }
+  const dateMs = Date.parse(value);
+  if (!Number.isNaN(dateMs)) {
+    return Math.max(0, (dateMs - Date.now()) / 1e3);
+  }
+  return void 0;
+}
+function throwCommonHttpError(status, statusText, errorText, operation, badRequestDefault = "Invalid parameters", retryAfterHeader) {
   if (status === 400) {
     throw new BadRequestError(errorText || badRequestDefault);
   }
+  if (status === 429) {
+    throw new TooManyRequestsError(
+      errorText || `Too many requests: ${operation}`,
+      parseRetryAfterSeconds(retryAfterHeader)
+    );
+  }
   if (status === 401) {
     throw new UnauthorizedError(errorText || void 0);
   }
@@ -1632,7 +1713,7 @@ Cause: ${cause}`
       }
       console.debug("[VQS Debug] Request:", JSON.stringify(logData, null, 2));
     }
-    init.headers.set("User-Agent", `@vercel/queue/${"0.2.1"}`);
+    init.headers.set("User-Agent", `@vercel/queue/${"0.3.1"}`);
     init.headers.set("Vqs-Client-Ts", (/* @__PURE__ */ new Date()).toISOString());
     const fetchInit = this.dispatcher ? { ...init, dispatcher: this.dispatcher } : init;
     const response = await fetch(url, fetchInit);
@@ -1726,6 +1807,7 @@ Cause: ${cause}`
       );
     }
     if (response.status === 202) {
+      await response.text();
       return { messageId: null };
     }
     const responseData = await response.json();
@@ -1763,6 +1845,7 @@ Cause: ${cause}`
       }
     );
     if (response.status === 204) {
+      await response.text();
       return;
     }
     if (!response.ok) {
@@ -1909,9 +1992,11 @@ Cause: ${cause}`
         response.statusText,
         errorText,
         "acknowledge message",
-        "Missing or invalid receipt handle"
+        "Missing or invalid receipt handle",
+        response.headers?.get("Retry-After") ?? null
       );
     }
+    await response.text();
     return { acknowledged: true };
   }
   async changeVisibility(options) {
@@ -1960,9 +2045,11 @@ Cause: ${cause}`
         response.statusText,
         errorText,
         "change visibility",
-        "Missing receipt handle or invalid visibility timeout"
+        "Missing receipt handle or invalid visibility timeout",
+        response.headers?.get("Retry-After") ?? null
       );
     }
+    await response.text();
     return { success: true };
   }
 };
@@ -2317,6 +2404,7 @@ export {
   QueueClient,
   QueueEmptyError,
   StreamTransport,
+  TooManyRequestsError,
   UnauthorizedError,
   handleCallback2 as handleCallback,
   parseCallback,