ag-common 0.0.905 → 0.0.906

package/dist/common/helpers/withRetry.d.ts

@@ -1,4 +1,6 @@
+export declare const isRetryableError: (error: unknown) => boolean;
 export declare const withRetry: <T>(operation: () => Promise<T>, operationName: string, opt?: {
     /** default 3. null for infinite */
     maxRetries?: number | null;
+    sleep?: (delay: number) => Promise<void>;
 }) => Promise<T>;

package/dist/common/helpers/withRetry.js

@@ -1,36 +1,120 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withRetry = void 0;
+exports.withRetry = exports.isRetryableError = void 0;
+const const_1 = require("../const");
 const log_1 = require("./log");
 const sleep_1 = require("./sleep");
+const RETRYABLE_ERROR_NAMES = new Set([
+    "BandwidthLimitExceeded",
+    "EC2ThrottledException",
+    "LimitExceededException",
+    "PriorRequestNotComplete",
+    "ProvisionedThroughputExceededException",
+    "RequestLimitExceeded",
+    "RequestThrottled",
+    "RequestThrottledException",
+    "SlowDown",
+    "ThrottledException",
+    "Throttling",
+    "ThrottlingException",
+    "TimeoutError",
+    "TooManyRequestsException",
+    "TransactionInProgressException",
+].map((name) => name.toLowerCase()));
+const RETRYABLE_NETWORK_CODES = new Set([
+    "EAI_AGAIN",
+    "ECONNREFUSED",
+    "ECONNRESET",
+    "EHOSTUNREACH",
+    "ENETDOWN",
+    "ENETUNREACH",
+    "EPIPE",
+    "ETIMEDOUT",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_HEADERS_TIMEOUT",
+].map((code) => code.toLowerCase()));
+const RETRYABLE_MESSAGE_PATTERNS = [
+    /\bthrottl(?:e|ed|ing|ingexception)\b/i,
+    /\bprovisioned\s*throughput\s*exceeded\b/i,
+    /\bthroughput\s*exceeds\b/i,
+    /\brate[\s-]*limit(?:ed|ing)?\b/i,
+    /\btoo\s*many\s*requests\b/i,
+    /\btoo\s*large\b/i,
+];
+const HTTP_STATUS_MESSAGE_PATTERN = new RegExp(`\\b(?:http(?:\\s+error)?|status(?:\\s*code)?)[^0-9]{0,16}(?:${const_1.retryHttpCodes.join("|")})\\b`, "i");
+const isRecord = (value) => typeof value === "object" && value !== null;
+const isRetryableStatus = (value) => {
+    const status = typeof value === "string" && /^\d+$/.test(value) ? Number(value) : value;
+    return typeof status === "number" && const_1.retryHttpCodes.includes(status);
+};
+const getErrorText = (error, record) => {
+    if (typeof error === "string")
+        return error;
+    const message = typeof record?.message === "string" ? record.message : "";
+    const name = typeof record?.name === "string" ? record.name : "";
+    return `${name} ${message}`.trim();
+};
+const isRetryableErrorInternal = (error, seen) => {
+    if (seen.has(error))
+        return false;
+    seen.add(error);
+    if (isRetryableStatus(error))
+        return true;
+    const record = isRecord(error) ? error : undefined;
+    const retryable = isRecord(record?.$retryable) ? record.$retryable : undefined;
+    if (retryable?.throttling === true)
+        return true;
+    const metadata = isRecord(record?.$metadata) ? record.$metadata : undefined;
+    const response = isRecord(record?.response) ? record.response : undefined;
+    if ([
+        record?.code,
+        record?.status,
+        record?.statusCode,
+        metadata?.httpStatusCode,
+        response?.status,
+        response?.statusCode,
+    ].some(isRetryableStatus)) {
+        return true;
+    }
+    const errorName = typeof record?.name === "string" ? record.name.toLowerCase() : "";
+    const errorCode = typeof record?.code === "string" ? record.code.toLowerCase() : "";
+    if (RETRYABLE_ERROR_NAMES.has(errorName) ||
+        RETRYABLE_ERROR_NAMES.has(errorCode) ||
+        RETRYABLE_NETWORK_CODES.has(errorCode)) {
+        return true;
+    }
+    const errorText = getErrorText(error, record);
+    if (/^429$/i.test(errorText.trim()) ||
+        HTTP_STATUS_MESSAGE_PATTERN.test(errorText) ||
+        RETRYABLE_MESSAGE_PATTERNS.some((pattern) => pattern.test(errorText))) {
+        return true;
+    }
+    return record?.cause !== undefined ? isRetryableErrorInternal(record.cause, seen) : false;
+};
+const isRetryableError = (error) => isRetryableErrorInternal(error, new Set());
+exports.isRetryableError = isRetryableError;
 const withRetry = async (operation, operationName, opt) => {
     let retryCount = 0;
     const baseDelay = 2000;
-    const { maxRetries = 3 } = opt ?? {};
+    const { maxRetries = 3, sleep: sleepFor = sleep_1.sleep } = opt ?? {};
     for (;;) {
         try {
             // oxlint-disable-next-line no-await-in-loop -- retries are intentionally sequential
-            return operation();
+            const result = await operation();
+            return result;
         }
-        catch (e) {
-            const error = e;
-            const errorString = error.toString().toLowerCase().replace(/\s+/gim, "");
-            if (errorString.includes("429") ||
-                errorString.includes("provisionedthroughputexceeded") ||
-                errorString.includes("toolarge") ||
-                errorString.includes("ratelimited")) {
-                retryCount++;
-                if (maxRetries !== null && retryCount >= maxRetries) {
-                    (0, log_1.warn)(`${operationName}: Max retries exceeded`);
-                    throw error;
-                }
-                const delay = baseDelay + retryCount * 1000;
-                (0, log_1.warn)(`${operationName}: Throttled. Retry ${retryCount}. Sleeping for ${delay}ms`);
-                // oxlint-disable-next-line no-await-in-loop -- backoff must complete before retrying
-                await (0, sleep_1.sleep)(delay);
-                continue;
+        catch (error) {
+            if (!(0, exports.isRetryableError)(error))
+                throw error;
+            if (maxRetries !== null && retryCount >= maxRetries) {
+                (0, log_1.warn)(`${operationName}: Max retries exceeded`);
+                throw error;
             }
-            throw error;
+            retryCount++;
+            const delay = baseDelay + retryCount * 1000;
+            (0, log_1.warn)(`${operationName}: Retryable failure. Retry ${retryCount}. Sleeping for ${delay}ms`);
+            // oxlint-disable-next-line no-await-in-loop -- backoff must complete before retrying
+            await sleepFor(delay);
         }
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ag-common",
-  "version": "0.0.905",
+  "version": "0.0.906",
   "license": "ISC",
   "author": "admin@gec.dev",
   "repository": {