@xiboplayer/utils 0.3.6 → 0.4.0

package/src/config.js

@@ -25,6 +25,7 @@ function loadFromEnv() {
     displayName: env.DISPLAY_NAME || '',
     hardwareKey: env.HARDWARE_KEY || '',
     xmrChannel: env.XMR_CHANNEL || '',
+    googleGeoApiKey: env.GOOGLE_GEO_API_KEY || '',
   };
 
   // Return env config if any value is set
@@ -322,6 +323,9 @@ export class Config {
   get xmrChannel() { return this.data.xmrChannel; }
   get xmrPubKey() { return this.data.xmrPubKey || ''; }
   get xmrPrivKey() { return this.data.xmrPrivKey || ''; }
+
+  get googleGeoApiKey() { return this.data.googleGeoApiKey || ''; }
+  set googleGeoApiKey(val) { this.data.googleGeoApiKey = val; this.save(); }
 }
 
 export const config = new Config();

package/src/fetch-retry.js

@@ -10,6 +10,37 @@ import { createLogger } from './logger.js';
 
 const log = createLogger('FetchRetry');
 
+const DEFAULT_429_DELAY_MS = 30000;
+const MAX_429_DELAY_MS = 120000;
+
+/**
+ * Parse a Retry-After header value into milliseconds.
+ * Supports both delta-seconds ("120") and HTTP-date ("Fri, 21 Feb 2026 12:00:00 GMT").
+ * Returns a sensible default if the header is missing or unparseable.
+ * The returned delay is NOT capped by maxDelayMs — the server's rate-limit
+ * instruction takes priority over our backoff ceiling.
+ * @param {string|null} headerValue
+ * @returns {number} delay in milliseconds (clamped to MAX_429_DELAY_MS)
+ */
+function parseRetryAfter(headerValue) {
+  if (!headerValue) return DEFAULT_429_DELAY_MS;
+
+  // Try delta-seconds first (most common)
+  const seconds = Number(headerValue);
+  if (!isNaN(seconds) && seconds >= 0) {
+    return Math.min(seconds * 1000, MAX_429_DELAY_MS);
+  }
+
+  // Try HTTP-date format (RFC 7231 §7.1.3)
+  const date = new Date(headerValue);
+  if (!isNaN(date.getTime())) {
+    const delayMs = date.getTime() - Date.now();
+    return Math.min(Math.max(delayMs, 0), MAX_429_DELAY_MS);
+  }
+
+  return DEFAULT_429_DELAY_MS;
+}
+
 /**
  * Fetch with automatic retry on failure
  * @param {string|URL} url - URL to fetch
@@ -29,7 +60,21 @@ export async function fetchWithRetry(url, options = {}, retryOptions = {}) {
     try {
       const response = await fetch(url, options);
 
-      // Don't retry client errors (4xx) — they won't change with retries
+      // HTTP 429 Too Many Requests — respect Retry-After header
+      if (response.status === 429) {
+        const delayMs = parseRetryAfter(response.headers.get('Retry-After'));
+        log.debug(`429 Rate limited, waiting ${delayMs}ms (Retry-After: ${response.headers.get('Retry-After')})`);
+        lastResponse = response;
+        lastError = new Error(`HTTP 429: Too Many Requests`);
+        lastError.status = 429;
+        if (attempt < maxRetries) {
+          await new Promise(resolve => setTimeout(resolve, delayMs));
+          continue; // Skip the normal backoff delay below
+        }
+        break; // Exhausted retries
+      }
+
+      // Don't retry other client errors (4xx) — they won't change with retries
       if (response.ok || (response.status >= 400 && response.status < 500)) {
         return response;
       }

package/src/fetch-retry.test.js

@@ -105,4 +105,110 @@ describe('fetchWithRetry', () => {
     expect(response.status).toBe(500);
     expect(mockFetch).toHaveBeenCalledTimes(4);
   });
+
+  it('should retry on HTTP 429 with Retry-After header', async () => {
+    const headers429 = { get: (name) => name === 'Retry-After' ? '1' : null };
+    mockFetch
+      .mockResolvedValueOnce({ ok: false, status: 429, statusText: 'Too Many Requests', headers: headers429 })
+      .mockResolvedValueOnce({ ok: true, status: 200 });
+
+    const promise = fetchWithRetry('https://example.com', {}, { maxRetries: 2, baseDelayMs: 100 });
+
+    // Advance past the 1s Retry-After delay
+    await vi.advanceTimersByTimeAsync(1500);
+
+    const response = await promise;
+    expect(response.ok).toBe(true);
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
+
+  it('should return 429 response when retries exhausted', async () => {
+    const headers429 = { get: (name) => name === 'Retry-After' ? '1' : null };
+    mockFetch.mockResolvedValue({ ok: false, status: 429, statusText: 'Too Many Requests', headers: headers429 });
+
+    const promise = fetchWithRetry('https://example.com', {}, { maxRetries: 1, baseDelayMs: 100 });
+
+    // Advance past the Retry-After delay
+    await vi.advanceTimersByTimeAsync(2000);
+
+    const response = await promise;
+    expect(response.status).toBe(429);
+    expect(mockFetch).toHaveBeenCalledTimes(2); // 1 original + 1 retry
+  });
+
+  it('should parse Retry-After as HTTP-date', async () => {
+    // Set a date 2 seconds in the future
+    const futureDate = new Date(Date.now() + 2000).toUTCString();
+    const headers429 = { get: (name) => name === 'Retry-After' ? futureDate : null };
+    mockFetch
+      .mockResolvedValueOnce({ ok: false, status: 429, statusText: 'Too Many Requests', headers: headers429 })
+      .mockResolvedValueOnce({ ok: true, status: 200 });
+
+    const promise = fetchWithRetry('https://example.com', {}, { maxRetries: 2, baseDelayMs: 100 });
+
+    // Advance past the ~2s date-based delay
+    await vi.advanceTimersByTimeAsync(3000);
+
+    const response = await promise;
+    expect(response.ok).toBe(true);
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
+
+  it('should not cap 429 delay at maxDelayMs', async () => {
+    // Server asks for 5s, but maxDelayMs is only 1s — 429 should still wait 5s
+    const headers429 = { get: (name) => name === 'Retry-After' ? '5' : null };
+    mockFetch
+      .mockResolvedValueOnce({ ok: false, status: 429, statusText: 'Too Many Requests', headers: headers429 })
+      .mockResolvedValueOnce({ ok: true, status: 200 });
+
+    const promise = fetchWithRetry('https://example.com', {}, { maxRetries: 2, baseDelayMs: 100, maxDelayMs: 1000 });
+
+    // 1s is not enough — should still be waiting
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+
+    // 5s total should be enough
+    await vi.advanceTimersByTimeAsync(4500);
+
+    const response = await promise;
+    expect(response.ok).toBe(true);
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
+
+  it('should use default 30s delay when Retry-After header is missing on 429', async () => {
+    const headers429 = { get: () => null };
+    mockFetch
+      .mockResolvedValueOnce({ ok: false, status: 429, statusText: 'Too Many Requests', headers: headers429 })
+      .mockResolvedValueOnce({ ok: true, status: 200 });
+
+    const promise = fetchWithRetry('https://example.com', {}, { maxRetries: 2, baseDelayMs: 100 });
+
+    // 10s is not enough — default is 30s
+    await vi.advanceTimersByTimeAsync(10000);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+
+    // 30s total should be enough
+    await vi.advanceTimersByTimeAsync(21000);
+
+    const response = await promise;
+    expect(response.ok).toBe(true);
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
+
+  it('should handle Retry-After date in the past as immediate retry', async () => {
+    const pastDate = new Date(Date.now() - 5000).toUTCString();
+    const headers429 = { get: (name) => name === 'Retry-After' ? pastDate : null };
+    mockFetch
+      .mockResolvedValueOnce({ ok: false, status: 429, statusText: 'Too Many Requests', headers: headers429 })
+      .mockResolvedValueOnce({ ok: true, status: 200 });
+
+    const promise = fetchWithRetry('https://example.com', {}, { maxRetries: 2, baseDelayMs: 100 });
+
+    // Past date means delay=0, should retry immediately
+    await vi.advanceTimersByTimeAsync(100);
+
+    const response = await promise;
+    expect(response.ok).toBe(true);
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
 });