重试机制

// src/lib/simple-retry.ts
async function fetchWithRetry(url: string, options: RequestInit) {
  const MAX_RETRIES = 3
 
  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
    try {
      const response = await fetch(url, options)
 
      if (response.ok) {
        return response
      }
 
      console.warn(`Attempt ${attempt + 1} failed: ${response.status}`)
    } catch (error) {
      console.warn(`Attempt ${attempt + 1} threw: ${error}`)
    }
  }
 
  throw new Error(`All ${MAX_RETRIES + 1} attempts failed for ${url}`)
}

// src/lib/retryable.ts
function isRetryableError(status: number): boolean {
  return status === 429 || (status >= 500 && status <= 599)
}
 
function isNetworkError(error: unknown): boolean {
  // fetch 在网络层面失败时（DNS、超时、连接断开），会抛出 TypeError
  return error instanceof TypeError
}

// src/lib/exponential-backoff.ts
function getDelay(attempt: number, baseDelay = 1000): number {
  // attempt 从 0 开始，第 1 次重试 attempt=0，等待 baseDelay * 2^0 = 1000ms
  return baseDelay * Math.pow(2, attempt)
}
 
// 验证一下输出
// attempt=0 → 1000ms (1s)
// attempt=1 → 2000ms (2s)
// attempt=2 → 4000ms (4s)
// attempt=3 → 8000ms (8s)

// src/lib/delay.ts
function sleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms))
}

// src/lib/jitter.ts
function getDelayWithJitter(attempt: number, baseDelay = 1000): number {
  const exponentialDelay = baseDelay * Math.pow(2, attempt)
  const half = exponentialDelay / 2
  // 前半段固定等待 + 后半段随机
  return half + Math.random() * half
}
 
// attempt=0 → 500~1000ms
// attempt=1 → 1000~2000ms
// attempt=2 → 2000~4000ms

// src/lib/retry.ts
type RetryOptions = {
  maxRetries?: number
  baseDelay?: number
  shouldRetry?: (status: number) => boolean
}
 
const DEFAULT_RETRY_OPTIONS: Required<RetryOptions> = {
  maxRetries: 3,
  baseDelay: 1000,
  shouldRetry: (status) => status === 429 || (status >= 500 && status <= 599),
}
 
async function fetchWithRetry(
  url: string,
  options: RequestInit = {},
  userOptions: RetryOptions = {}
): Promise<Response> {
  const { maxRetries, baseDelay, shouldRetry } = {
    ...DEFAULT_RETRY_OPTIONS,
    ...userOptions,
  }
 
  let lastError: unknown
 
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch(url, options)
 
      // 成功，或者是不应该重试的错误，直接返回
      if (response.ok || !shouldRetry(response.status)) {
        return response
      }
 
      // 如果是最后一次尝试，不再等待，直接返回失败响应
      if (attempt === maxRetries) {
        return response
      }
 
      // 检查 Retry-After 头部（429 响应通常会带），没有则用等值抖动
      const retryAfter = parseRetryAfterHeader(response.headers.get('Retry-After'))
      const delay = retryAfter ?? getDelayWithJitter(attempt, baseDelay)
 
      console.log(`[Retry] ${attempt + 1}/${maxRetries}, status=${response.status}, wait=${delay}ms`)
      await sleep(delay)
    } catch (error) {
      lastError = error
 
      if (attempt === maxRetries) break
 
      const delay = getDelayWithJitter(attempt, baseDelay)
      console.log(`[Retry] ${attempt + 1}/${maxRetries}, network error, wait=${delay}ms`)
      await sleep(delay)
    }
  }
 
  if (lastError instanceof TypeError) throw lastError
  throw new Error(`All ${maxRetries + 1} attempts failed for ${url}`)
}
 
function parseRetryAfterHeader(header: string | null): number | null {
  if (!header) return null
  const seconds = Number(header)
  if (!Number.isNaN(seconds)) return seconds * 1000
  const date = Date.parse(header)
  return Number.isNaN(date) ? null : Math.max(0, date - Date.now())
}
 
function getDelayWithJitter(attempt: number, baseDelay: number): number {
  const exponentialDelay = baseDelay * Math.pow(2, attempt)
  return exponentialDelay / 2 + Math.random() * (exponentialDelay / 2)
}
 
function sleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms))
}
 
export { fetchWithRetry, type RetryOptions }

// src/routes/image-generate.ts
import { Hono } from 'hono'
import type { AppEnv } from '../types'
import { fetchWithRetry } from '../lib/retry'
 
export const imageGenerateApp = new Hono<AppEnv>()
 
imageGenerateApp.post('/api/image/generate', async (c) => {
  const body = await c.req.json<{ prompt: string }>()
  const { prompt } = body
 
  if (!prompt || typeof prompt !== 'string') {
    return c.json({ error: 'prompt is required' }, 400)
  }
 
  try {
    const response = await fetchWithRetry(
      'https://api.ai-provider.com/v1/generate',
      {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          Authorization: `Bearer ${c.env.AI_API_KEY}`,
        },
        body: JSON.stringify({
          prompt,
          model: 'stable-diffusion-xl',
          size: '1024x1024',
        }),
      },
      {
        maxRetries: 3,
        baseDelay: 2000, // AI 接口响应慢，基础延迟设大一些
      }
    )
 
    if (!response.ok) {
      const errorBody = await response.text()
      return c.json(
        { error: 'AI service error', detail: errorBody },
        response.status as 500
      )
    }
 
    const data = await response.json()
    return c.json({ imageUrl: data.url })
  } catch (error) {
    console.error('Image generation failed after all retries:', error)
    return c.json({ error: 'Service temporarily unavailable' }, 503)
  }
})

// src/lib/idempotent-fetch.ts
async function createOrderWithRetry(
  orderData: OrderPayload,
  idempotencyKey: string
) {
  return fetchWithRetry('https://api.order-service.com/orders', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      // 服务端用这个 key 判断是否是重复请求
      'Idempotency-Key': idempotencyKey,
    },
    body: JSON.stringify(orderData),
  })
}
 
// 调用方生成一个唯一的幂等键
const idempotencyKey = crypto.randomUUID()
await createOrderWithRetry(orderData, idempotencyKey)

// src/lib/retry-with-timeout.ts
async function fetchWithRetryAndTimeout(
  url: string,
  options: RequestInit = {},
  totalTimeoutMs = 30000,
  retryOptions: RetryOptions = {}
): Promise<Response> {
  const controller = new AbortController()
  const timer = setTimeout(() => controller.abort(), totalTimeoutMs)
 
  try {
    return await fetchWithRetry(url, {
      ...options,
      signal: controller.signal,
    }, retryOptions)
  } finally {
    clearTimeout(timer)
  }
}

// src/lib/retry-logger.ts
function logRetryAttempt(entry: {
  url: string
  attempt: number
  maxRetries: number
  status?: number
  delayMs: number
}): void {
  console.log(JSON.stringify({
    level: 'warn',
    event: 'retry_attempt',
    ...entry,
    timestamp: new Date().toISOString(),
  }))
}