tsarr 2.9.0 → 2.10.0

package/dist/clients/qbittorrent.js

@@ -18,6 +18,93 @@ class ConnectionError extends TsarrError {
   }
 }
 
+// src/core/fetch.ts
+var DEFAULT_TIMEOUT = 30000;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_INITIAL_DELAY = 1000;
+var DEFAULT_MAX_DELAY = 1e4;
+var RETRYABLE_STATUS_CODES = new Set([408, 429, 502, 503, 504]);
+function isRetryable(error) {
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return false;
+  }
+  if (error instanceof TypeError) {
+    return true;
+  }
+  return false;
+}
+function getRetryDelay(attempt, initialDelayMs, maxDelayMs) {
+  const delay = initialDelayMs * 2 ** attempt;
+  const jitter = delay * 0.2 * Math.random();
+  return Math.min(delay + jitter, maxDelayMs);
+}
+function createResilientFetch(options = {}) {
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  const maxRetries = options.retry ? options.retry.maxRetries ?? DEFAULT_MAX_RETRIES : 0;
+  const initialDelayMs = options.retry?.initialDelayMs ?? DEFAULT_INITIAL_DELAY;
+  const maxDelayMs = options.retry?.maxDelayMs ?? DEFAULT_MAX_DELAY;
+  const resilientFetch = async (input, init) => {
+    let lastError;
+    const template = createRequestTemplate(input, init);
+    for (let attempt = 0;attempt <= maxRetries; attempt++) {
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      const callerSignal = init?.signal;
+      if (callerSignal?.aborted) {
+        clearTimeout(timeoutId);
+        throw callerSignal.reason ?? new DOMException("The operation was aborted.", "AbortError");
+      }
+      const onCallerAbort = () => controller.abort(callerSignal.reason);
+      callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
+      try {
+        const response = await globalThis.fetch(new Request(template.clone(), { signal: controller.signal }));
+        clearTimeout(timeoutId);
+        callerSignal?.removeEventListener("abort", onCallerAbort);
+        if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < maxRetries) {
+          lastError = new ConnectionError(`Request failed with status ${response.status}`);
+          const delay = getRetryDelay(attempt, initialDelayMs, maxDelayMs);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+        return response;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        callerSignal?.removeEventListener("abort", onCallerAbort);
+        if (callerSignal?.aborted) {
+          throw callerSignal.reason ?? new DOMException("The operation was aborted.", "AbortError");
+        }
+        if (error instanceof DOMException && error.name === "AbortError") {
+          lastError = new ConnectionError(`Request timed out after ${timeout}ms`);
+          if (attempt < maxRetries) {
+            const delay = getRetryDelay(attempt, initialDelayMs, maxDelayMs);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            continue;
+          }
+          throw lastError;
+        }
+        if (isRetryable(error) && attempt < maxRetries) {
+          lastError = error;
+          const delay = getRetryDelay(attempt, initialDelayMs, maxDelayMs);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw lastError;
+  };
+  return Object.assign(resilientFetch, {
+    preconnect: globalThis.fetch.preconnect?.bind(globalThis.fetch)
+  });
+}
+function createRequestTemplate(input, init) {
+  const { signal: _signal, ...requestInit } = init ?? {};
+  if (input instanceof Request) {
+    return init ? new Request(input.clone(), requestInit) : input.clone();
+  }
+  return new Request(input, requestInit);
+}
+
 // src/generated/qbittorrent/core/bodySerializer.gen.ts
 var serializeUrlSearchParamsPair = (data, key, value) => {
   if (typeof value === "string") {
@@ -917,11 +1004,14 @@ var torrentsDeletePost = (options) => (options.client ?? client).post({
   }
 });
 // src/clients/qbittorrent.ts
+var DEFAULT_TIMEOUT_MS = 30000;
+
 class QBittorrentClient {
   baseUrl;
   username;
   password;
   sid = null;
+  fetch;
   constructor(config) {
     if (!config.baseUrl) {
       throw new ConnectionError("No base URL provided");
@@ -929,9 +1019,14 @@ class QBittorrentClient {
     this.baseUrl = config.baseUrl.replace(/\/$/, "");
     this.username = config.username;
     this.password = config.password;
+    this.fetch = createResilientFetch({
+      timeout: config.timeout ?? DEFAULT_TIMEOUT_MS,
+      retry: config.retry
+    });
     client.setConfig({
       baseUrl: `${this.baseUrl}/api/v2`,
-      auth: () => this.ensureAuth()
+      auth: () => this.ensureAuth(),
+      fetch: this.fetch
     });
   }
   async ensureAuth() {
@@ -941,7 +1036,7 @@ class QBittorrentClient {
     return this.sid;
   }
   async login() {
-    const response = await fetch(`${this.baseUrl}/api/v2/auth/login`, {
+    const response = await this.fetch(`${this.baseUrl}/api/v2/auth/login`, {
       method: "POST",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded",