@thorprovider/medusa-extended 1.1.1 → 1.2.0

package/src/request-resilience.ts

@@ -0,0 +1,81 @@
+import { ProviderAPIError, backendCircuitBreaker } from '@thorprovider/adapters'
+
+type RetryConfig = {
+  maxRetries?: number
+  initialDelayMs?: number
+  backoffMultiplier?: number
+  maxDelayMs?: number
+  timeoutMs?: number
+  retryableStatusCodes?: number[]
+}
+
+const DEFAULT_RETRY_CONFIG: Required<RetryConfig> = {
+  maxRetries: 3,
+  initialDelayMs: 300,
+  backoffMultiplier: 2,
+  maxDelayMs: 5000,
+  timeoutMs: 10000,
+  retryableStatusCodes: [408, 429, 500, 502, 503, 504],
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function calculateDelay(attempt: number, config: Required<RetryConfig>): number {
+  const delay = config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt)
+  return Math.min(delay, config.maxDelayMs)
+}
+
+function isRetryableError(error: unknown, config: Required<RetryConfig>): boolean {
+  const err = error as { name?: string; message?: string; status?: number }
+
+  if (err.name === 'TypeError' || err.message?.includes('fetch failed')) return true
+  if (err.name === 'AbortError' || err.message?.includes('timeout')) return true
+  if (typeof err.status === 'number' && config.retryableStatusCodes.includes(err.status)) return true
+  return false
+}
+
+async function fetchWithRetry(url: string, init: RequestInit, retryConfig?: RetryConfig): Promise<Response> {
+  const config = { ...DEFAULT_RETRY_CONFIG, ...retryConfig }
+  let lastError: unknown
+
+  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+    try {
+      const controller = new AbortController()
+      const timeoutId = setTimeout(() => controller.abort(), config.timeoutMs)
+
+      const response = await fetch(url, { ...init, signal: controller.signal })
+      clearTimeout(timeoutId)
+
+      if (!response.ok && config.retryableStatusCodes.includes(response.status)) {
+        const error = new Error(`HTTP ${response.status}: ${response.statusText}`) as Error & { status?: number }
+        error.status = response.status
+        throw error
+      }
+
+      return response
+    } catch (error) {
+      lastError = error
+      const shouldRetry = attempt < config.maxRetries && isRetryableError(error, config)
+
+      if (shouldRetry) {
+        await sleep(calculateDelay(attempt, config))
+        continue
+      }
+
+      break
+    }
+  }
+
+  throw lastError instanceof Error ? lastError : new Error('Backend request failed')
+}
+
+export async function fetchBackendWithResilience(url: string, init: RequestInit, retryConfig?: RetryConfig): Promise<Response> {
+  try {
+    return await backendCircuitBreaker.execute(() => fetchWithRetry(url, init, retryConfig))
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    throw new ProviderAPIError(`Backend request failed: ${message}`, 'backend', 503)
+  }
+}