feat: use blob key encoding (#108)

* feat: upload/get/set static blob files with suffix

* feat: upload/get/set prerendered blob content with suffix

* chore: update tests

* feat: revert to manually adding suffix

* chore: update tests

* fix: remove leading slashes from keyds

* feat: switch to base64 encoding blob keys

* chore: update comments

* fix: remove tags manifest to simplify and fix failing test

* chore: update test

Author: orinokai

src/build/content/prerendered.ts

@@ -1,5 +1,6 @@
 import type { NetlifyPluginOptions } from '@netlify/build'
 import glob from 'fast-glob'
+import { Buffer } from 'node:buffer'
 import { existsSync } from 'node:fs'
 import { mkdir, readFile, writeFile } from 'node:fs/promises'
 import { dirname, resolve } from 'node:path'
@@ -39,39 +40,48 @@ type FetchCacheValue = {
   }
 }
 
+/**
+ * Write a cache entry to the blob upload directory using
+ * base64 keys to avoid collisions with directories
+ */
 const writeCacheEntry = async (key: string, value: CacheValue) => {
-  await mkdir(dirname(resolve(BLOB_DIR, key)), { recursive: true })
-  await writeFile(
-    resolve(BLOB_DIR, key),
-    JSON.stringify({ lastModified: Date.now(), value } satisfies CacheEntry),
-    'utf-8',
-  )
+  const path = resolve(BLOB_DIR, Buffer.from(key).toString('base64'))
+  const entry = JSON.stringify({
+    lastModified: Date.now(),
+    value,
+  } satisfies CacheEntry)
+
+  await mkdir(dirname(path), { recursive: true })
+  await writeFile(path, entry, 'utf-8')
 }
 
-const urlPathToFilePath = (path: string) => (path === '/' ? '/index' : path)
+/**
+ * Normalize routes by stripping leading slashes and ensuring root path is index
+ */
+const routeToFilePath = (path: string) => path.replace(/^\//, '') || 'index'
 
 const buildPagesCacheValue = async (path: string): Promise<PageCacheValue> => ({
   kind: 'PAGE',
-  html: await readFile(resolve(`${path}.html`), 'utf-8'),
-  pageData: JSON.parse(await readFile(resolve(`${path}.json`), 'utf-8')),
+  html: await readFile(`${path}.html`, 'utf-8'),
+  pageData: JSON.parse(await readFile(`${path}.json`, 'utf-8')),
 })
 
 const buildAppCacheValue = async (path: string): Promise<PageCacheValue> => ({
   kind: 'PAGE',
-  html: await readFile(resolve(`${path}.html`), 'utf-8'),
-  pageData: await readFile(resolve(`${path}.rsc`), 'utf-8'),
-  ...JSON.parse(await readFile(resolve(`${path}.meta`), 'utf-8')),
+  html: await readFile(`${path}.html`, 'utf-8'),
+  pageData: await readFile(`${path}.rsc`, 'utf-8'),
+  ...JSON.parse(await readFile(`${path}.meta`, 'utf-8')),
 })
 
 const buildRouteCacheValue = async (path: string): Promise<RouteCacheValue> => ({
   kind: 'ROUTE',
-  body: await readFile(resolve(`${path}.body`), 'utf-8'),
-  ...JSON.parse(await readFile(resolve(`${path}.meta`), 'utf-8')),
+  body: await readFile(`${path}.body`, 'utf-8'),
+  ...JSON.parse(await readFile(`${path}.meta`, 'utf-8')),
 })
 
 const buildFetchCacheValue = async (path: string): Promise<FetchCacheValue> => ({
   kind: 'FETCH',
-  ...JSON.parse(await readFile(resolve(path), 'utf-8')),
+  ...JSON.parse(await readFile(path, 'utf-8')),
 })
 
 /**
@@ -86,31 +96,27 @@ export const copyPrerenderedContent = async ({
   try {
     // read prerendered content and build JSON key/values for the blob store
     const manifest = await getPrerenderManifest({ PUBLISH_DIR })
-    const routes = Object.entries(manifest.routes)
-    const notFoundRoute = 'server/app/_not-found'
 
     await Promise.all(
-      routes.map(async ([path, route]) => {
-        let key, value
+      Object.entries(manifest.routes).map(async ([route, meta]) => {
+        const key = routeToFilePath(route)
+        let value: CacheValue
 
         switch (true) {
-          case route.dataRoute?.endsWith('.json'):
-            key = `server/pages/${urlPathToFilePath(path)}`
-            value = await buildPagesCacheValue(resolve(PUBLISH_DIR, key))
+          case meta.dataRoute?.endsWith('.json'):
+            value = await buildPagesCacheValue(resolve(PUBLISH_DIR, 'server/pages', key))
             break
 
-          case route.dataRoute?.endsWith('.rsc'):
-            key = `server/app/${urlPathToFilePath(path)}`
-            value = await buildAppCacheValue(resolve(PUBLISH_DIR, key))
+          case meta.dataRoute?.endsWith('.rsc'):
+            value = await buildAppCacheValue(resolve(PUBLISH_DIR, 'server/app', key))
             break
 
-          case route.dataRoute === null:
-            key = `server/app/${urlPathToFilePath(path)}`
-            value = await buildRouteCacheValue(resolve(PUBLISH_DIR, key))
+          case meta.dataRoute === null:
+            value = await buildRouteCacheValue(resolve(PUBLISH_DIR, 'server/app', key))
             break
 
           default:
-            throw new Error(`Unrecognized prerendered content: ${path}`)
+            throw new Error(`Unrecognized content: ${route}`)
         }
 
         await writeCacheEntry(key, value)
@@ -119,11 +125,10 @@ export const copyPrerenderedContent = async ({
 
     // app router 404 pages are not in the prerender manifest
     // so we need to check for them manually
-    if (existsSync(resolve(PUBLISH_DIR, `${notFoundRoute}.html`))) {
-      await writeCacheEntry(
-        notFoundRoute,
-        await buildAppCacheValue(resolve(PUBLISH_DIR, notFoundRoute)),
-      )
+    if (existsSync(resolve(PUBLISH_DIR, `server/app/_not-found.html`))) {
+      const key = '404'
+      const value = await buildAppCacheValue(resolve(PUBLISH_DIR, 'server/app/_not-found'))
+      await writeCacheEntry(key, value)
     }
   } catch (error) {
     failBuild(
@@ -143,14 +148,15 @@ export const copyFetchContent = async ({
   },
 }: Pick<NetlifyPluginOptions, 'constants' | 'utils'>) => {
   try {
-    const paths = await glob([`cache/fetch-cache/!(*.*)`], {
-      cwd: resolve(PUBLISH_DIR),
+    const paths = await glob(['!(*.*)'], {
+      cwd: resolve(PUBLISH_DIR, 'cache/fetch-cache'),
       extglob: true,
     })
 
     await Promise.all(
       paths.map(async (key) => {
-        await writeCacheEntry(key, await buildFetchCacheValue(resolve(PUBLISH_DIR, key)))
+        const value = await buildFetchCacheValue(resolve(PUBLISH_DIR, 'cache/fetch-cache', key))
+        await writeCacheEntry(key, value)
       }),
     )
   } catch (error) {

src/build/content/static.test.ts

@@ -99,10 +99,11 @@ test<FixtureTestContext>('should copy the static pages to the publish directory
     utils,
   })
 
-  expect((await glob('**/*', { cwd: join(cwd, BLOB_DIR), dot: true })).sort()).toEqual([
-    'server/pages/test.html',
-    'server/pages/test2.html',
-  ])
+  expect(
+    (await glob('**/*', { cwd: join(cwd, BLOB_DIR), dot: true }))
+      .map((path) => Buffer.from(path, 'base64').toString('utf-8'))
+      .sort(),
+  ).toEqual(['test.html', 'test2.html'])
 })
 
 test<FixtureTestContext>('should not copy the static pages to the publish directory if there are corresponding JSON files', async (ctx) => {

src/build/content/static.ts

@@ -1,8 +1,9 @@
 import type { NetlifyPluginOptions } from '@netlify/build'
 import glob from 'fast-glob'
+import { Buffer } from 'node:buffer'
 import { existsSync } from 'node:fs'
 import { cp, mkdir, rename, rm } from 'node:fs/promises'
-import { resolve } from 'node:path'
+import { join, resolve } from 'node:path'
 import { BLOB_DIR, STATIC_DIR } from '../constants.js'
 
 /**
@@ -15,7 +16,7 @@ export const copyStaticContent = async ({
   },
 }: Pick<NetlifyPluginOptions, 'constants' | 'utils'>): Promise<void> => {
   const srcDir = resolve(PUBLISH_DIR, 'server/pages')
-  const destDir = resolve(BLOB_DIR, 'server/pages')
+  const destDir = resolve(BLOB_DIR)
 
   const paths = await glob('**/*.+(html|json)', {
     cwd: srcDir,
@@ -27,7 +28,8 @@ export const copyStaticContent = async ({
       paths
         .filter((path) => !paths.includes(`${path.slice(0, -5)}.json`))
         .map(async (path) => {
-          await cp(resolve(srcDir, path), resolve(destDir, path), { recursive: true })
+          const key = Buffer.from(path).toString('base64')
+          await cp(join(srcDir, path), join(destDir, key), { recursive: true })
         }),
     )
   } catch (error) {