@theholocron/http-client 1.54.1 → 1.55.0

package/dist/index.d.mts

@@ -94,6 +94,14 @@ interface RestClientConfig {
    * Defaults to a no-op.
    */
   errors?: ErrorSink;
+  /**
+   * How many times to send a request again after a transport failure that is safe to repeat (see `worthRetrying`):
+   * the connection never opened, or a read was dropped. HTTP error statuses are never retried. Defaults to 2; 0
+   * turns it off.
+   */
+  retries?: number;
+  /** Milliseconds before the first retry; each later one waits three times as long. Defaults to 300. */
+  retryDelayMs?: number;
 }
 interface RequestOptions {
   method?: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";

package/dist/index.mjs

@@ -47,12 +47,55 @@ var ProviderApiError = class extends Error {
 	}
 };
 //#endregion
+//#region src/transport.ts
+/**
+* Node's `fetch` rejects with a bare `TypeError: fetch failed`; the reason (a DNS miss, a connect timeout, a reset) is on
+* `cause`, and for a host with both IPv4 and IPv6 addresses it is one level deeper, in an `AggregateError`.
+*/
+function transportCode(err) {
+	const cause = err instanceof Error ? err.cause : void 0;
+	if (!cause || typeof cause !== "object") return void 0;
+	const { code, errors } = cause;
+	if (typeof code === "string") return code;
+	if (Array.isArray(errors)) {
+		const inner = errors.find((e) => typeof e?.code === "string");
+		if (inner) return inner.code;
+	}
+}
+/** Failures that happen before a request reaches the server, so retrying cannot apply it twice, whatever the method. */
+const NEVER_SENT = /* @__PURE__ */ new Set([
+	"UND_ERR_CONNECT_TIMEOUT",
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"ECONNREFUSED",
+	"ENETUNREACH",
+	"EHOSTUNREACH"
+]);
+/** Failures after the connection was made, where the server may or may not have seen the request. */
+const DROPPED = /* @__PURE__ */ new Set([
+	"ECONNRESET",
+	"EPIPE",
+	"UND_ERR_SOCKET",
+	"ETIMEDOUT"
+]);
+/**
+* Whether a failed request is worth sending again: always when it never left, and for a read when the connection
+* dropped (a repeat read changes nothing). A write that may have arrived is never repeated.
+*/
+function worthRetrying(code, method) {
+	if (!code) return false;
+	if (NEVER_SENT.has(code)) return true;
+	return DROPPED.has(code) && (method === "GET" || method === "HEAD");
+}
+//#endregion
 //#region src/rest-client.ts
 function createRestClient(config) {
 	const fetchImpl = config.fetch ?? globalThis.fetch;
 	const vendor = config.vendor ?? "";
 	const logger = config.logger ?? new NoopLogger();
 	const errors = config.errors ?? new NoopErrorSink();
+	const maxRetries = config.retries ?? 2;
+	const retryDelay = config.retryDelayMs ?? 300;
 	let baseUrl = config.baseUrl;
 	while (baseUrl.endsWith("/")) baseUrl = baseUrl.slice(0, -1);
 	const staticHeaders = { accept: "application/json" };
@@ -82,10 +125,23 @@ function createRestClient(config) {
 				path
 			}, "request");
 			let res;
-			try {
+			for (let attempt = 0;; attempt++) try {
 				res = await fetchImpl(url.toString(), init);
+				break;
 			} catch (err) {
-				const apiErr = new ProviderApiError(`${tag} failed: ${err instanceof Error ? `${err.name}: ${err.message}` : String(err)}`, 0, void 0);
+				const code = transportCode(err);
+				if (attempt < maxRetries && worthRetrying(code, init.method)) {
+					logger.debug({
+						vendor,
+						method: init.method,
+						path,
+						code,
+						attempt: attempt + 1
+					}, "retrying");
+					await new Promise((resolve) => setTimeout(resolve, retryDelay * 3 ** attempt));
+					continue;
+				}
+				const apiErr = new ProviderApiError(`${tag} failed: ${err instanceof Error ? `${err.name}: ${err.message}` : String(err)}${code ? ` (${code})` : ""}`, 0, void 0);
 				errors.captureException(apiErr);
 				throw apiErr;
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theholocron/http-client",
-  "version": "1.54.1",
+  "version": "1.55.0",
   "description": "Shared HTTP primitives for theholocron — REST client factory, auth resolver, and error types",
   "keywords": [
     "typescript",