refactor: fetch JSON with native fetch instead of ofetch

danielroe · danielroe · commit ea82130e74cd · 2026-07-26T22:28:30.000+01:00
diff --git a/packages/nuxt-cli/package.json b/packages/nuxt-cli/package.json
@@ -63,7 +63,6 @@
     "magicast": "^0.5.3",
     "nypm": "^0.6.8",
     "obug": "^2.1.1",
-    "ofetch": "^1.5.1",
     "ohash": "^2.0.11",
     "pathe": "^2.0.3",
     "perfect-debounce": "^2.1.0",
diff --git a/packages/nuxt-cli/src/commands/init.ts b/packages/nuxt-cli/src/commands/init.ts
@@ -13,7 +13,6 @@ import { box, cancel, confirm, intro, isCancel, outro, S_BAR, select, spinner, t
 import { defineCommand, showUsage } from 'citty'
 import { downloadTemplate, startShell } from 'giget'
 import { detectPackageManager } from 'nypm'
-import { $fetch } from 'ofetch'
 import { basename, join, relative, resolve } from 'pathe'
 import colors from 'picocolors'
 import { findFile, readPackageJSON, writePackageJSON } from 'pkg-types'
@@ -22,6 +21,7 @@ import { x } from 'tinyexec'
 
 import { runCommandDef as runCommand } from '../run-command'
 import { nuxtIcon, themeColor } from '../utils/ascii'
+import { fetchJson } from '../utils/fetch'
 import { createInstallLog, resolvePackageManagerDescriptor, runInstall, takeUnreportedIgnoredBuilds } from '../utils/install'
 import { debug, logger } from '../utils/logger'
 import { classifyNetworkError, describeNetworkError, logNetworkError, probeNetworkError } from '../utils/network'
@@ -429,7 +429,7 @@ export default defineCommand({
       const nightlySpinner = spinner()
       nightlySpinner.start('Fetching nightly version info')
 
-      const response = await $fetch<{ 'dist-tags': Record<string, string> }>(NIGHTLY_DIST_TAGS_URL).catch((err) => {
+      const response = await fetchJson<{ 'dist-tags': Record<string, string> }>(NIGHTLY_DIST_TAGS_URL).catch((err) => {
         nightlySpinner.error('Failed to fetch nightly version info')
         logNetworkError(err, { url: NIGHTLY_DIST_TAGS_URL })
         process.exit(1)
@@ -772,7 +772,7 @@ export default defineCommand({
 async function getModuleDependencies(moduleName: string) {
   const url = `https://registry.npmjs.org/${moduleName}/latest`
   try {
-    const response = await $fetch(url)
+    const response = await fetchJson<{ dependencies?: Record<string, string> }>(url)
     const dependencies = response.dependencies || {}
     return Object.keys(dependencies)
   }
diff --git a/packages/nuxt-cli/src/commands/module/_utils.ts b/packages/nuxt-cli/src/commands/module/_utils.ts
@@ -4,11 +4,11 @@ import type { PackageJson } from 'pkg-types'
 import { existsSync } from 'node:fs'
 
 import { confirm, isCancel } from '@clack/prompts'
-import { $fetch } from 'ofetch'
 import { resolve } from 'pathe'
 import colors from 'picocolors'
 import { satisfies } from 'verkit'
 
+import { fetchJson } from '../../utils/fetch'
 import { logger } from '../../utils/logger'
 import { relativeToProcess } from '../../utils/paths'
 import { cwdArgs, logLevelArgs } from '../_shared'
@@ -109,7 +109,7 @@ export interface NuxtModule {
 export const MODULES_API_URL = 'https://api.nuxt.com/modules?version=all'
 
 export async function fetchModules(): Promise<NuxtModule[]> {
-  const { modules } = await $fetch<NuxtApiModulesResponse>(MODULES_API_URL)
+  const { modules } = await fetchJson<NuxtApiModulesResponse>(MODULES_API_URL)
   return modules
 }
 
diff --git a/packages/nuxt-cli/src/commands/module/add.ts b/packages/nuxt-cli/src/commands/module/add.ts
@@ -8,7 +8,6 @@ import process from 'node:process'
 import { cancel, confirm, isCancel, select, spinner } from '@clack/prompts'
 import { defineCommand } from 'citty'
 import { detectPackageManager, packageManagers } from 'nypm'
-import { $fetch } from 'ofetch'
 import { resolve } from 'pathe'
 import colors from 'picocolors'
 import { readPackageJSON } from 'pkg-types'
@@ -17,6 +16,7 @@ import { satisfies } from 'verkit'
 
 import { runCommandDef as runCommand } from '../../run-command'
 import { updateConfig } from '../../utils/config'
+import { fetchJson } from '../../utils/fetch'
 import { createInstallLog, resolvePackageManagerDescriptor, runInstall, takeUnreportedIgnoredBuilds } from '../../utils/install'
 import { logger } from '../../utils/logger'
 import { logNetworkError } from '../../utils/network'
@@ -447,7 +447,7 @@ async function resolveModule(moduleName: string, cwd: string): Promise<ModuleRes
 
   // TODO: spinner
   const pkgUrl = joinURL(meta.registry, `${pkgName}`)
-  const pkgDetails = await $fetch(pkgUrl, { headers }).catch((err: unknown) => {
+  const pkgDetails = await fetchJson<any>(pkgUrl, { headers }).catch((err: unknown) => {
     logNetworkError(err, { url: pkgUrl, prefix: `Failed to fetch package details for ${colors.cyan(pkgName)}.` })
     return null
   })
diff --git a/packages/nuxt-cli/src/utils/fetch.ts b/packages/nuxt-cli/src/utils/fetch.ts
@@ -0,0 +1,58 @@
+/** Status codes worth a second attempt: transient overload, throttling and gateway faults. */
+const RETRY_STATUS_CODES = new Set([408, 409, 425, 429, 500, 502, 503, 504])
+
+export interface FetchJsonOptions {
+  headers?: Record<string, string>
+  /** Milliseconds before the request is aborted. Unlimited when omitted. */
+  timeout?: number
+  /** Extra attempts after the first. Defaults to one. */
+  retry?: number
+}
+
+interface FetchJsonError extends Error {
+  status: number
+  response: Response
+}
+
+/**
+ * `GET` a JSON document, throwing on a non-2xx response.
+ *
+ * Errors carry `status` and `response` so `classifyNetworkError` can tell an HTTP
+ * failure from a transport failure. Transport errors and the status codes above
+ * are retried, since `fetch` itself will not.
+ *
+ * This module deliberately has no imports: it is loaded directly by
+ * `scripts/generate-data.ts` under Node's type stripping, where extensionless
+ * relative specifiers do not resolve.
+ */
+export async function fetchJson<T>(url: string, options: FetchJsonOptions = {}): Promise<T> {
+  const attempts = (options.retry ?? 1) + 1
+  let lastError: unknown
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    try {
+      const response = await fetch(url, {
+        headers: options.headers,
+        signal: options.timeout ? AbortSignal.timeout(options.timeout) : undefined,
+      })
+      if (response.ok) {
+        return await response.json() as T
+      }
+      lastError = Object.assign(
+        new Error(`Request to ${url} failed with ${response.status} ${response.statusText}`),
+        { status: response.status, response },
+      ) satisfies FetchJsonError
+      if (!RETRY_STATUS_CODES.has(response.status)) {
+        break
+      }
+    }
+    catch (error) {
+      lastError = error
+      // A timeout is a deliberate deadline, so retrying would silently double it.
+      const name = (error as Error | undefined)?.name
+      if (name === 'TimeoutError' || name === 'AbortError') {
+        break
+      }
+    }
+  }
+  throw lastError
+}
diff --git a/packages/nuxt-cli/src/utils/starter-templates.ts b/packages/nuxt-cli/src/utils/starter-templates.ts
@@ -1,5 +1,6 @@
 import process from 'node:process'
-import { $fetch } from 'ofetch'
+
+import { fetchJson } from './fetch.ts'
 
 export const hiddenTemplates = [
   'doc-driven',
@@ -26,7 +27,6 @@ const fetchOptions = {
   // than 3s. The template list is prefetched and has a static fallback, so a
   // slightly longer deadline only ever delays the prompt on a broken network.
   timeout: 5000,
-  responseType: 'json',
   headers: {
     'user-agent': '@nuxt/cli',
     ...process.env.GITHUB_TOKEN ? { authorization: `token ${process.env.GITHUB_TOKEN}` } : {},
@@ -45,7 +45,7 @@ export async function getTemplates() {
 export async function fetchTemplates() {
   const templates = {} as Record<string, TemplateData>
 
-  const files = await $fetch<Array<{ name: string, type: string, download_url?: string }>>(
+  const files = await fetchJson<Array<{ name: string, type: string, download_url?: string }>>(
     TEMPLATES_API_URL,
     fetchOptions,
   )
@@ -59,7 +59,7 @@ export async function fetchTemplates() {
       return
     }
     templates[templateName] = undefined as unknown as TemplateData
-    templates[templateName] = await $fetch(file.download_url, fetchOptions)
+    templates[templateName] = await fetchJson<TemplateData>(file.download_url, fetchOptions)
   }))
 
   return templates
diff --git a/packages/nuxt-cli/src/utils/update.ts b/packages/nuxt-cli/src/utils/update.ts
@@ -1,13 +1,13 @@
 import process from 'node:process'
 
 import { box } from '@clack/prompts'
-import { $fetch } from 'ofetch'
 import colors from 'picocolors'
 import { readUser, updateUser } from 'rc9'
 import { isCI, isTest, provider } from 'std-env'
 import { joinURL } from 'ufo'
 import { isGreater, tryParse } from 'verkit'
 
+import { fetchJson } from './fetch'
 import { debug } from './logger'
 import { detectNpmRegistry } from './registry'
 
@@ -78,7 +78,7 @@ async function resolveLatestVersion(): Promise<string | undefined> {
   let latest: string | undefined
   try {
     const { registry, authToken } = await detectNpmRegistry(null)
-    latest = (await $fetch<{ latest?: string }>(joinURL(registry, '-/package/nuxt/dist-tags'), {
+    latest = (await fetchJson<{ latest?: string }>(joinURL(registry, '-/package/nuxt/dist-tags'), {
       headers: authToken ? { Authorization: `Bearer ${authToken}` } : undefined,
       timeout: FETCH_TIMEOUT,
       retry: 0,
diff --git a/packages/nuxt-cli/src/utils/versions.ts b/packages/nuxt-cli/src/utils/versions.ts
@@ -1,11 +1,11 @@
 import { readFileSync } from 'node:fs'
 import { resolveModulePath } from 'exsolve'
-import { $fetch } from 'ofetch'
 import { readPackageJSON } from 'pkg-types'
 import { joinURL } from 'ufo'
 import { coerce, findMaxSatisfying } from 'verkit'
 
 import { resolveCatalogEntry } from './catalog'
+import { fetchJson } from './fetch'
 import { tryResolveNuxt } from './kit'
 import { debug } from './logger'
 import { detectNpmRegistry } from './registry'
@@ -45,7 +45,7 @@ export async function resolveRegistryVersion(pkg: string, range: string): Promis
     const scope = pkg.startsWith('@') ? pkg.split('/')[0]! : null
     const { registry, authToken } = await detectNpmRegistry(scope)
 
-    packument = await $fetch(joinURL(registry, pkg), {
+    packument = await fetchJson(joinURL(registry, pkg), {
       headers: {
         // The abbreviated packument is a fraction of the size of the full one and
         // still carries every version and dist-tag.
diff --git a/packages/nuxt-cli/test/unit/commands/add.spec.ts b/packages/nuxt-cli/test/unit/commands/add.spec.ts
@@ -40,9 +40,9 @@ vi.mock('pkg-types', async () => {
   }
 })
 
-vi.mock('ofetch', async () => {
+vi.mock('../../../src/utils/fetch', async () => {
   return {
-    $fetch: mock$fetch,
+    fetchJson: mock$fetch,
   }
 })
 
diff --git a/packages/nuxt-cli/test/unit/commands/module/add-config.spec.ts b/packages/nuxt-cli/test/unit/commands/module/add-config.spec.ts
@@ -22,8 +22,8 @@ vi.mock('nypm', () => ({
 vi.mock('pkg-types', () => ({
   readPackageJSON: () => Promise.resolve({ devDependencies: { nuxt: '3.0.0' } }),
 }))
-vi.mock('ofetch', () => ({
-  $fetch: vi.fn(() => Promise.resolve({
+vi.mock('../../../../src/utils/fetch', () => ({
+  fetchJson: vi.fn(() => Promise.resolve({
     'dist-tags': { latest: '1.0.0' },
     'versions': { '1.0.0': manifest },
   })),
diff --git a/packages/nuxt-cli/test/unit/commands/module/add.spec.ts b/packages/nuxt-cli/test/unit/commands/module/add.spec.ts
@@ -43,9 +43,9 @@ function applyMocks() {
       },
     }
   })
-  vi.mock('ofetch', async () => {
+  vi.mock('../../../../src/utils/fetch', async () => {
     return {
-      $fetch: vi.fn(() => Promise.resolve({
+      fetchJson: vi.fn(() => Promise.resolve({
         'name': '@nuxt/content',
         'npm': '@nuxt/content',
         'devDependencies': {
diff --git a/packages/nuxt-cli/test/unit/utils/network.spec.ts b/packages/nuxt-cli/test/unit/utils/network.spec.ts
@@ -10,7 +10,6 @@ import { join } from 'node:path'
 import { stripVTControlCharacters } from 'node:util'
 
 import { downloadTemplate } from 'giget'
-import { $fetch } from 'ofetch'
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
 
 const logs: Array<[string, string]> = []
@@ -25,6 +24,7 @@ vi.mock('../../../src/utils/logger', () => ({
 }))
 
 const { classifyNetworkError, describeNetworkError, formatRetryCommand, getProxyHint, hasProxyEnv, isEnvProxyActive, logNetworkError, probeNetworkError, setupProxySupport, supportsEnvProxy } = await import('../../../src/utils/network')
+const { fetchJson } = await import('../../../src/utils/fetch')
 
 const NUXI_ARGV = ['/usr/bin/node', '/project/node_modules/.bin/nuxi.mjs', 'init', 'my app']
 
@@ -140,23 +140,23 @@ describe('describeNetworkError with real failures', () => {
     expect(clean(describeNetworkError(err, url))).toBe(`Connection to 127.0.0.1:${closedPort} was refused.`)
   })
 
-  it('describes a real refused connection from `ofetch`', async () => {
+  it('describes a real refused connection from `fetchJson`', async () => {
     const url = `http://127.0.0.1:${closedPort}/`
-    const err = await captureError(() => $fetch(url))
+    const err = await captureError(() => fetchJson(url))
     expect(classifyNetworkError(err).kind).toBe('refused')
     expect(clean(describeNetworkError(err, url))).toBe(`Connection to 127.0.0.1:${closedPort} was refused.`)
   })
 
-  it('describes a real `ofetch` non-2xx response', async () => {
+  it('describes a real `fetchJson` non-2xx response', async () => {
     const url = `http://127.0.0.1:${port}/teapot`
-    const err = await captureError(() => $fetch(url))
+    const err = await captureError(() => fetchJson(url))
     expect(classifyNetworkError(err)).toMatchObject({ kind: 'http', status: 418 })
     expect(clean(describeNetworkError(err, url))).toBe(`Request to 127.0.0.1:${port} failed with status 418.`)
   })
 
-  it('describes a real `ofetch` timeout, whose code is a DOMException number', async () => {
+  it('describes a real `fetchJson` timeout, whose code is a DOMException number', async () => {
     const url = `http://127.0.0.1:${port}/slow`
-    const err = await captureError(() => $fetch(url, { timeout: 20 }))
+    const err = await captureError(() => fetchJson(url, { timeout: 20 }))
     expect(classifyNetworkError(err).kind).toBe('timeout')
     expect(clean(describeNetworkError(err, url))).toBe(`Connection to 127.0.0.1:${port} timed out.`)
   })
diff --git a/packages/nuxt-cli/test/unit/utils/starter-templates.spec.ts b/packages/nuxt-cli/test/unit/utils/starter-templates.spec.ts
@@ -6,11 +6,6 @@ import { fetchTemplates, TEMPLATES_API_URL } from '../../../src/utils/starter-te
 function respondAfter(delay: number) {
   return vi.fn((url: string | URL | Request, init?: RequestInit) => {
     const signal = init?.signal
-    // `fetch` rejects straight away when handed a spent signal, which is what
-    // `ofetch` does on its retry.
-    if (signal?.aborted) {
-      return Promise.reject(signal.reason)
-    }
 
     // Only the template listing is slowed down; the per-template fetches that
     // follow it answer immediately so the test pays the delay once. Matched on
@@ -56,13 +51,9 @@ describe('fetchTemplates', () => {
       return respondAfter(60_000)(url, init)
     })
 
-    // Asserting on the abort rather than the settled promise keeps the test from
-    // waiting out `ofetch`'s retry of the same doomed request.
-    const pending = fetchTemplates().catch((err: unknown) => err)
-    await vi.waitFor(() => expect(signals[0]?.aborted).toBe(true), { timeout: 8000, interval: 100 })
+    const error = await fetchTemplates().catch((err: unknown) => err)
 
-    expect(describeNetworkError(signals[0]!.reason, TEMPLATES_API_URL)).toContain('timed out')
-    // The retry of the same doomed request is left to time out unobserved.
-    void pending
+    expect(signals[0]?.aborted).toBe(true)
+    expect(describeNetworkError(error, TEMPLATES_API_URL)).toContain('timed out')
   }, 15_000)
 })
diff --git a/packages/nuxt-cli/test/unit/utils/update.spec.ts b/packages/nuxt-cli/test/unit/utils/update.spec.ts
@@ -33,7 +33,7 @@ vi.mock('rc9', async () => {
   }
 })
 
-vi.mock('ofetch', () => ({ $fetch: fetchMock }))
+vi.mock('../../../src/utils/fetch', () => ({ fetchJson: fetchMock }))
 
 vi.mock('../../../src/utils/registry', () => ({
   detectNpmRegistry: async () => registry.current,
diff --git a/packages/nuxt-cli/test/unit/utils/versions.spec.ts b/packages/nuxt-cli/test/unit/utils/versions.spec.ts
@@ -2,13 +2,13 @@ import { mkdtemp, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
-import { $fetch } from 'ofetch'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
+import { fetchJson } from '../../../src/utils/fetch'
 import { detectNpmRegistry } from '../../../src/utils/registry'
 import { getNuxtVersion, resolveRegistryVersion } from '../../../src/utils/versions'
 
-vi.mock('ofetch', () => ({ $fetch: vi.fn() }))
+vi.mock('../../../src/utils/fetch', () => ({ fetchJson: vi.fn() }))
 vi.mock('../../../src/utils/registry', () => ({ detectNpmRegistry: vi.fn() }))
 
 describe('getNuxtVersion', () => {
@@ -56,25 +56,25 @@ describe('resolveRegistryVersion', () => {
   })
 
   it('should prefer a matching dist-tag', async () => {
-    vi.mocked($fetch).mockResolvedValue({ 'dist-tags': { latest: '4.2.0' }, 'versions': { '4.2.0': {}, '5.0.0-rc.1': {} } })
+    vi.mocked(fetchJson).mockResolvedValue({ 'dist-tags': { latest: '4.2.0' }, 'versions': { '4.2.0': {}, '5.0.0-rc.1': {} } })
 
     expect(await resolveRegistryVersion('nuxt', 'latest')).toBe('4.2.0')
   })
 
   it('should pick the highest matching version regardless of publication order', async () => {
-    vi.mocked($fetch).mockResolvedValue({ 'dist-tags': { latest: '4.2.0' }, 'versions': { '3.17.0': {}, '3.19.0': {}, '3.18.1': {} } })
+    vi.mocked(fetchJson).mockResolvedValue({ 'dist-tags': { latest: '4.2.0' }, 'versions': { '3.17.0': {}, '3.19.0': {}, '3.18.1': {} } })
 
     expect(await resolveRegistryVersion('nuxt', '3')).toBe('3.19.0')
   })
 
   it('should return nothing when no version matches', async () => {
-    vi.mocked($fetch).mockResolvedValue({ 'dist-tags': { latest: '4.2.0' }, 'versions': { '4.2.0': {} } })
+    vi.mocked(fetchJson).mockResolvedValue({ 'dist-tags': { latest: '4.2.0' }, 'versions': { '4.2.0': {} } })
 
     expect(await resolveRegistryVersion('nuxt', '99')).toBeUndefined()
   })
 
   it('should return nothing when the registry cannot be reached', async () => {
-    vi.mocked($fetch).mockRejectedValue(new Error('ECONNREFUSED'))
+    vi.mocked(fetchJson).mockRejectedValue(new Error('ECONNREFUSED'))
 
     expect(await resolveRegistryVersion('nuxt', 'latest')).toBeUndefined()
   })
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml

Original file line number	Diff line number	Diff line change
`@@ -40,9 +40,9 @@ vi.mock('pkg-types', async () => {`
`40`	`40`	`}`
`41`	`41`	`})`
`42`	`42`
`43`		`-vi.mock('ofetch', async () => {`
	`43`	`+vi.mock('../../../src/utils/fetch', async () => {`
`44`	`44`	`return {`
`45`		`- $fetch: mock$fetch,`
	`45`	`+ fetchJson: mock$fetch,`
`46`	`46`	`}`
`47`	`47`	`})`
`48`	`48`