@doist/comms-sdk 3.0.1 → 3.0.2

package/dist/esm/transport/fetch-with-retry.js

@@ -79,22 +79,30 @@ function describeTransportFailure(error, attempts) {
 }
 function describeCauseChain(error) {
     const descriptions = [];
-    const seen = new Set();
-    let current = error?.cause;
-    while (current instanceof Error &&
-        !seen.has(current) &&
-        descriptions.length < CAUSE_CHAIN_LIMIT) {
-        seen.add(current);
-        const description = describeCause(current);
+    for (const cause of causeChain(error)) {
+        const description = describeCause(cause);
         if (description) {
             descriptions.push(description);
         }
-        // A failed connect can carry one error per address it tried; the first
-        // one is representative and the rest are the same failure repeated.
+    }
+    return descriptions.length > 0 ? descriptions.join(' <- ') : undefined;
+}
+/**
+ * Walks an error's `cause` chain, stopping at {@link CAUSE_CHAIN_LIMIT} and on
+ * a cycle. A failed connect can carry one error per address it tried; the first
+ * is representative and the rest repeat the same failure.
+ */
+function* causeChain(error) {
+    const seen = new Set();
+    let current = error?.cause;
+    let depth = 0;
+    while (current instanceof Error && !seen.has(current) && depth < CAUSE_CHAIN_LIMIT) {
+        seen.add(current);
+        depth++;
+        yield current;
         const aggregated = current instanceof AggregateError ? current.errors[0] : undefined;
         current = aggregated ?? current.cause;
     }
-    return descriptions.length > 0 ? descriptions.join(' <- ') : undefined;
 }
 function describeCause(error) {
     const code = error.code;
@@ -134,13 +142,60 @@ function createTimeoutError(timeoutMs) {
     error.name = timeoutErrorName;
     return error;
 }
+/**
+ * Transport-level failure codes worth another attempt: the request never got an
+ * answer, so nothing about the response argues against retrying. `UND_ERR_SOCKET`
+ * covers the HTTP/2 `GOAWAY` an edge proxy sends when it retires a pooled
+ * connection, which is otherwise indistinguishable from any other `fetch failed`.
+ */
+const NETWORK_ERROR_CODES = new Set([
+    'ECONNREFUSED',
+    'ECONNRESET',
+    'EAI_AGAIN',
+    'ENOTFOUND',
+    'EPIPE',
+    'ETIMEDOUT',
+    'UND_ERR_SOCKET',
+]);
 function isNetworkError(error) {
     return (error.name === 'TypeError' ||
         error.name === timeoutErrorName ||
-        error.message.toLowerCase().includes('network'));
+        error.message.toLowerCase().includes('network') ||
+        hasNetworkErrorCode(error));
+}
+function hasNetworkErrorCode(error) {
+    // The code can be on the error itself — a `customFetch` is free to reject
+    // with one directly — or on anything `fetch` wrapped to produce it.
+    if (hasRetryableCode(error)) {
+        return true;
+    }
+    for (const cause of causeChain(error)) {
+        if (hasRetryableCode(cause)) {
+            return true;
+        }
+    }
+    return false;
 }
+function hasRetryableCode(error) {
+    const code = error.code;
+    return typeof code === 'string' && NETWORK_ERROR_CODES.has(code);
+}
+/** First retry delay, doubling by {@link RETRY_DELAY_FACTOR} per attempt. */
+const RETRY_BASE_DELAY_MS = 100;
+const RETRY_DELAY_FACTOR = 4;
+const RETRY_MAX_DELAY_MS = 2000;
+/**
+ * How long to wait before retry `retryCount` (1-based).
+ *
+ * A retired connection takes a moment to be torn down and replaced, so retrying
+ * immediately just re-dispatches onto the socket that is going away and burns
+ * the whole retry budget inside a second. The delay grows so the later attempts
+ * land on a fresh connection, and carries jitter because one retirement hits
+ * every pooled connection at once: without it, every caller reconnects in step.
+ */
 function getRetryDelay(retryCount) {
-    return retryCount === 1 ? 0 : 500;
+    const delay = Math.min(RETRY_BASE_DELAY_MS * RETRY_DELAY_FACTOR ** (retryCount - 1), RETRY_MAX_DELAY_MS);
+    return delay / 2 + Math.random() * (delay / 2);
 }
 function createTimeoutSignal(timeoutMs, existingSignal) {
     const controller = new AbortController();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/comms-sdk",
-    "version": "3.0.1",
+    "version": "3.0.2",
     "description": "A TypeScript wrapper for the Comms REST API.",
     "author": "Doist developers",
     "homepage": "https://doist.github.io/comms-sdk-typescript/",