test: update mock fixtures

Author: danielroe

modules/runtime/server/cache.ts

@@ -281,6 +281,67 @@ async function processSingleFastNpmMeta(
   return result
 }
 
+/**
+ * Process a single package for the /versions/ endpoint.
+ * Returns PackageVersionsInfo shape: { name, distTags, versions, specifier, time, lastSynced }
+ */
+async function processSingleVersionsMeta(
+  packageQuery: string,
+  storage: ReturnType<typeof useStorage>,
+  metadata: boolean,
+): Promise<Record<string, unknown>> {
+  let packageName = packageQuery
+  let specifier = '*'
+
+  if (packageName.startsWith('@')) {
+    const atIndex = packageName.indexOf('@', 1)
+    if (atIndex !== -1) {
+      specifier = packageName.slice(atIndex + 1)
+      packageName = packageName.slice(0, atIndex)
+    }
+  } else {
+    const atIndex = packageName.indexOf('@')
+    if (atIndex !== -1) {
+      specifier = packageName.slice(atIndex + 1)
+      packageName = packageName.slice(0, atIndex)
+    }
+  }
+
+  if (packageName.includes('does-not-exist') || packageName.includes('nonexistent')) {
+    return { name: packageName, error: 'not_found' }
+  }
+
+  const fixturePath = getFixturePath('packument', packageName)
+  const packument = await storage.getItem<any>(fixturePath)
+
+  if (!packument) {
+    return { name: packageName, error: 'not_found' }
+  }
+
+  const result: Record<string, unknown> = {
+    name: packageName,
+    specifier,
+    distTags: packument['dist-tags'] || {},
+    versions: Object.keys(packument.versions || {}),
+    time: packument.time || {},
+    lastSynced: Date.now(),
+  }
+
+  if (metadata) {
+    const versionsMeta: Record<string, Record<string, unknown>> = {}
+    for (const [ver, data] of Object.entries(packument.versions || {})) {
+      const meta: Record<string, unknown> = { version: ver }
+      const vData = data as Record<string, unknown>
+      if (vData.deprecated) meta.deprecated = vData.deprecated
+      if (packument.time?.[ver]) meta.time = packument.time[ver]
+      versionsMeta[ver] = meta
+    }
+    result.versionsMeta = versionsMeta
+  }
+
+  return result
+}
+
 async function handleFastNpmMeta(
   url: string,
   storage: ReturnType<typeof useStorage>,
@@ -296,22 +357,27 @@ async function handleFastNpmMeta(
 
   if (host !== 'npm.antfu.dev') return null
 
-  const pathPart = decodeURIComponent(pathname.slice(1))
-  if (!pathPart) return null
+  const rawPath = decodeURIComponent(pathname.slice(1))
+  if (!rawPath) return null
 
   const metadata = searchParams.get('metadata') === 'true'
 
+  // Determine if this is a /versions/ request
+  const isVersions = rawPath.startsWith('versions/')
+  const pathPart = isVersions ? rawPath.slice('versions/'.length) : rawPath
+  const processFn = isVersions
+    ? (pkg: string) => processSingleVersionsMeta(pkg, storage, metadata)
+    : (pkg: string) => processSingleFastNpmMeta(pkg, storage, metadata)
+
   // Handle batch requests (package1+package2+...)
   if (pathPart.includes('+')) {
     const packages = pathPart.split('+')
-    const results = await Promise.all(
-      packages.map(pkg => processSingleFastNpmMeta(pkg, storage, metadata)),
-    )
+    const results = await Promise.all(packages.map(processFn))
     return { data: results }
   }
 
   // Handle single package request
-  const result = await processSingleFastNpmMeta(pathPart, storage, metadata)
+  const result = await processFn(pathPart)
   if ('error' in result) {
     return { data: null }
   }

server/api/registry/package-meta/[...pkg].get.ts

@@ -24,11 +24,12 @@ export default defineCachedEventHandler(
       throw createError({ statusCode: 404, message: 'Package name is required' })
     }
 
-    const encodedName = encodePackageName(pkgParam)
+    const packageName = decodeURIComponent(pkgParam)
+    const encodedName = encodePackageName(packageName)
 
     try {
       const [packument, downloads] = await Promise.all([
-        fetchNpmPackage(pkgParam),
+        fetchNpmPackage(packageName),
         $fetch<NpmDownloadCount>(`${NPM_API}/downloads/point/last-week/${encodedName}`).catch(
           () => null,
         ),

test/fixtures/mock-routes.cjs

@@ -204,36 +204,54 @@ function matchOsvApi(urlString) {
 }
 
 /**
- * @param {string} urlString
- * @returns {MockResponse | null}
+ * Parse a package query string into name and specifier.
+ * Handles scoped packages: "@scope/name@specifier" and "name@specifier".
+ *
+ * @param {string} query
+ * @param {string} defaultSpecifier
+ * @returns {{ name: string; specifier: string }}
  */
-function matchFastNpmMeta(urlString) {
-  const url = new URL(urlString)
-  let packageName = decodeURIComponent(url.pathname.slice(1))
-
-  if (!packageName) return null
-
-  let specifier = 'latest'
-  if (packageName.startsWith('@')) {
-    const atIndex = packageName.indexOf('@', 1)
+function parsePackageQuery(query, defaultSpecifier) {
+  let name = query
+  let specifier = defaultSpecifier
+  if (name.startsWith('@')) {
+    const atIndex = name.indexOf('@', 1)
     if (atIndex !== -1) {
-      specifier = packageName.slice(atIndex + 1)
-      packageName = packageName.slice(0, atIndex)
+      specifier = name.slice(atIndex + 1)
+      name = name.slice(0, atIndex)
     }
   } else {
-    const atIndex = packageName.indexOf('@')
+    const atIndex = name.indexOf('@')
     if (atIndex !== -1) {
-      specifier = packageName.slice(atIndex + 1)
-      packageName = packageName.slice(0, atIndex)
+      specifier = name.slice(atIndex + 1)
+      name = name.slice(0, atIndex)
     }
   }
+  return { name, specifier }
+}
+
+/**
+ * Build a latest-version response for a single package (GET /:pkg endpoint).
+ *
+ * @param {string} query
+ * @returns {object}
+ */
+function resolveSingleLatest(query) {
+  const { name, specifier } = parsePackageQuery(query, 'latest')
+  const packument = readFixture(packageToFixturePath(name))
 
-  const packument = readFixture(packageToFixturePath(packageName))
-  if (!packument) return null
+  if (!packument) {
+    return {
+      name,
+      specifier,
+      version: '0.0.0',
+      publishedAt: new Date().toISOString(),
+      lastSynced: Date.now(),
+    }
+  }
 
   const distTags = packument['dist-tags']
   const versions = packument.versions
-  const time = packument.time
 
   let version
   if (specifier === 'latest' || !specifier) {
@@ -246,15 +264,72 @@ function matchFastNpmMeta(urlString) {
     version = distTags && distTags.latest
   }
 
-  if (!version) return null
+  if (!version) {
+    return {
+      name,
+      specifier,
+      version: '0.0.0',
+      publishedAt: new Date().toISOString(),
+      lastSynced: Date.now(),
+    }
+  }
 
-  return json({
-    name: packageName,
+  return {
+    name,
     specifier,
     version,
-    publishedAt: (time && time[version]) || new Date().toISOString(),
+    publishedAt: (packument.time && packument.time[version]) || new Date().toISOString(),
     lastSynced: Date.now(),
-  })
+  }
+}
+
+/**
+ * Build a versions response for a single package (GET /versions/:pkg endpoint).
+ *
+ * @param {string} query
+ * @returns {object}
+ */
+function resolveSingleVersions(query) {
+  const { name, specifier } = parsePackageQuery(query, '*')
+  const packument = readFixture(packageToFixturePath(name))
+
+  if (!packument) {
+    return { name, error: `"https://registry.npmjs.org/${name}": 404 Not Found` }
+  }
+
+  return {
+    name,
+    specifier,
+    distTags: packument['dist-tags'] || {},
+    versions: Object.keys(packument.versions || {}),
+    time: packument.time || {},
+    lastSynced: Date.now(),
+  }
+}
+
+/**
+ * @param {string} urlString
+ * @returns {MockResponse | null}
+ */
+function matchFastNpmMeta(urlString) {
+  const url = new URL(urlString)
+  let pathPart = decodeURIComponent(url.pathname.slice(1))
+
+  if (!pathPart) return null
+
+  // /versions/ endpoint returns version lists (used by getVersionsBatch)
+  const isVersions = pathPart.startsWith('versions/')
+  if (isVersions) pathPart = pathPart.slice('versions/'.length)
+
+  const resolveFn = isVersions ? resolveSingleVersions : resolveSingleLatest
+
+  // Batch requests: package1+package2+...
+  if (pathPart.includes('+')) {
+    const results = pathPart.split('+').map(resolveFn)
+    return json(results)
+  }
+
+  return json(resolveFn(pathPart))
 }
 
 /**