refactor: use shared fetch logic for github api

Author: t128n

server/api/github/contributors-evolution/[owner]/[repo].get.ts

@@ -1,4 +1,3 @@
-import { setTimeout } from 'node:timers/promises'
 import { CACHE_MAX_AGE_ONE_DAY } from '#shared/utils/constants'
 
 type GitHubContributorWeek = {
@@ -26,38 +25,13 @@ export default defineCachedEventHandler(
     }
 
     const url = `https://api.github.com/repos/${owner}/${repo}/stats/contributors`
-    const headers = {
-      'User-Agent': 'npmx',
-      'Accept': 'application/vnd.github+json',
-    }
-
-    const maxAttempts = 6
-    let delayMs = 1000
 
     try {
-      for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-        const response = await $fetch.raw<GitHubContributorStats[]>(url, { headers })
-        const status = response.status
-
-        if (status === 200) {
-          return Array.isArray(response._data) ? response._data : []
-        }
-
-        if (status === 204) {
-          return []
-        }
-
-        if (status === 202) {
-          if (attempt === maxAttempts - 1) return []
-          await setTimeout(delayMs)
-          delayMs = Math.min(delayMs * 2, 16_000)
-          continue
-        }
-
-        return []
-      }
+      const data = await fetchGitHubWithRetries<GitHubContributorStats[]>(url, {
+        maxAttempts: 6,
+      })
 
-      return []
+      return Array.isArray(data) ? data : []
     } catch {
       return []
     }

server/api/github/issues/[owner]/[repo].get.ts

@@ -1,12 +1,5 @@
-import { setTimeout } from 'node:timers/promises'
 import { CACHE_MAX_AGE_ONE_HOUR } from '#shared/utils/constants'
 
-const GITHUB_HEADERS = {
-  'Accept': 'application/vnd.github.v3+json',
-  'User-Agent': 'npmx',
-  'X-GitHub-Api-Version': '2022-11-28',
-} as const
-
 interface GitHubSearchResponse {
   total_count: number
 }
@@ -32,50 +25,23 @@ export default defineCachedEventHandler(
     const query = `repo:${owner}/${repo} is:issue is:open`
     const url = `https://api.github.com/search/issues?q=${encodeURIComponent(query)}&per_page=1`
 
-    const maxAttempts = 3
-    let delayMs = 1000
-
-    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-      try {
-        const response = await $fetch.raw<GitHubSearchResponse>(url, {
-          headers: GITHUB_HEADERS,
-          timeout: 10000,
-        })
-
-        if (response.status === 200) {
-          return {
-            owner,
-            repo,
-            issues:
-              typeof response._data?.total_count === 'number' ? response._data.total_count : null,
-          }
-        }
-
-        if (response.status === 202) {
-          if (attempt === maxAttempts - 1) break
-          await setTimeout(delayMs)
-          delayMs = Math.min(delayMs * 2, 16_000)
-          continue
-        }
+    try {
+      const data = await fetchGitHubWithRetries<GitHubSearchResponse>(url, {
+        maxAttempts: 3,
+        timeout: 10000,
+      })
 
-        break
-      } catch (error: any) {
-        if (attempt === maxAttempts - 1) {
-          throw createError({
-            statusCode: error.response?.status || 500,
-            statusMessage:
-              error.response?._data?.message || 'Failed to fetch issue count from GitHub',
-          })
-        }
-        await setTimeout(delayMs)
-        delayMs = Math.min(delayMs * 2, 16_000)
+      return {
+        owner,
+        repo,
+        issues: typeof data?.total_count === 'number' ? data.total_count : null,
       }
+    } catch {
+      throw createError({
+        statusCode: 500,
+        statusMessage: 'Failed to fetch issue count from GitHub',
+      })
     }
-
-    throw createError({
-      statusCode: 500,
-      statusMessage: 'Failed to fetch issue count from GitHub after retries',
-    })
   },
   {
     maxAge: CACHE_MAX_AGE_ONE_HOUR,

server/utils/github.ts

@@ -0,0 +1,57 @@
+import { setTimeout } from 'node:timers/promises'
+import type { NitroFetchOptions } from 'nitropack'
+
+export interface GitHubFetchOptions extends NitroFetchOptions<string> {
+  maxAttempts?: number
+}
+
+export async function fetchGitHubWithRetries<T>(
+  url: string,
+  options: GitHubFetchOptions = {},
+): Promise<T | null> {
+  const { maxAttempts = 3, ...fetchOptions } = options
+  let delayMs = 1000
+
+  const defaultHeaders = {
+    'Accept': 'application/vnd.github+json',
+    'User-Agent': 'npmx',
+    'X-GitHub-Api-Version': '2026-03-10',
+  }
+
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    try {
+      const response = await $fetch.raw(url, {
+        ...fetchOptions,
+        headers: {
+          ...defaultHeaders,
+          ...fetchOptions.headers,
+        },
+      })
+
+      if (response.status === 200) {
+        return (response._data as T) ?? null
+      }
+
+      if (response.status === 204) {
+        return null
+      }
+
+      if (response.status === 202) {
+        if (attempt === maxAttempts - 1) break
+        await setTimeout(delayMs)
+        delayMs = Math.min(delayMs * 2, 16_000)
+        continue
+      }
+
+      break
+    } catch (error: unknown) {
+      if (attempt === maxAttempts - 1) {
+        throw error
+      }
+      await setTimeout(delayMs)
+      delayMs = Math.min(delayMs * 2, 16_000)
+    }
+  }
+
+  throw new Error(`Failed to fetch from GitHub after ${maxAttempts} attempts`)
+}