fix: fix generation of EF tar file (#6616)

Author: eduardoboucas

packages/edge-bundler/node/bundler.test.ts

@@ -5,6 +5,7 @@ import process from 'process'
 import { pathToFileURL } from 'url'
 
 import { gte, lt } from 'semver'
+import * as tar from 'tar'
 import tmp from 'tmp-promise'
 import { test, expect, vi, describe } from 'vitest'
 
@@ -770,6 +771,17 @@ describe.skipIf(lt(denoVersion, '2.4.2'))(
       const tarballResult = await runTarball(tarballPath)
       expect(tarballResult).toStrictEqual(expectedOutput)
 
+      const entries: string[] = []
+
+      await tar.list({
+        file: tarballPath,
+        onReadEntry: (entry) => {
+          entries.push(entry.path)
+        },
+      })
+
+      expect(entries).toStrictEqual(['___netlify-edge-functions.json', 'deno.json', 'func1.js'])
+
       const eszipPath = join(distPath, manifest.bundles[1].asset)
       const eszipResult = await runESZIP(eszipPath)
       expect(eszipResult).toStrictEqual(expectedOutput)

packages/edge-bundler/node/formats/tarball.ts

@@ -9,8 +9,9 @@ import { DenoBridge } from '../bridge.js'
 import { Bundle, BundleFormat } from '../bundle.js'
 import { EdgeFunction } from '../edge_function.js'
 import { FeatureFlags } from '../feature_flags.js'
+import { listRecursively } from '../utils/fs.js'
 import { ImportMap } from '../import_map.js'
-import { getDirectoryHash, getStringHash } from '../utils/sha256.js'
+import { getFileHash } from '../utils/sha256.js'
 
 const TARBALL_EXTENSION = '.tar'
 
@@ -42,8 +43,8 @@ export const bundle = async ({
   importMap,
   vendorDirectory,
 }: BundleTarballOptions): Promise<Bundle> => {
-  const sideFilesDir = await tmp.dir({ unsafeCleanup: true })
-  const cleanup = [sideFilesDir.cleanup]
+  const bundleDir = await tmp.dir({ unsafeCleanup: true })
+  const cleanup = [bundleDir.cleanup]
 
   let denoDir = vendorDirectory ? path.join(vendorDirectory, 'deno_dir') : undefined
 
@@ -87,71 +88,47 @@ export const bundle = async ({
       '--quiet',
       '--code-splitting',
       '--outdir',
-      distDirectory,
+      bundleDir.path,
       ...functions.map((func) => func.path),
     ],
     {
       cwd: basePath,
     },
   )
 
-  const manifestPath = path.join(sideFilesDir.path, 'manifest.json')
+  const manifestPath = path.join(bundleDir.path, '___netlify-edge-functions.json')
   const manifestContents = JSON.stringify(manifest)
   await fs.writeFile(manifestPath, manifestContents)
 
-  const denoConfigPath = path.join(sideFilesDir.path, 'deno.json')
+  const denoConfigPath = path.join(bundleDir.path, 'deno.json')
   const denoConfigContents = JSON.stringify(importMap.getContentsWithRelativePaths())
   await fs.writeFile(denoConfigPath, denoConfigContents)
 
-  const rootLevel = await fs.readdir(distDirectory)
-  const hash = await getDirectoryHash(distDirectory)
   const tarballPath = path.join(distDirectory, buildID + TARBALL_EXTENSION)
-
   await fs.mkdir(path.dirname(tarballPath), { recursive: true })
 
-  // Adding all the bundled files.
   await tar.create(
     {
-      cwd: distDirectory,
-      file: tarballPath,
-      onWriteEntry(entry) {
-        entry.path = getUnixPath(`./${entry.path}`)
-      },
-    },
-    rootLevel,
-  )
-
-  // Adding `deno.json`.
-  await tar.update(
-    {
-      cwd: distDirectory,
+      cwd: bundleDir.path,
       file: tarballPath,
+      noDirRecurse: true,
       onWriteEntry(entry) {
-        entry.path = './deno.json'
-      },
-    },
-    [denoConfigPath],
-  )
+        const relativePath = path.relative(bundleDir.path, path.join('/', entry.path))
+        const normalizedPath = getUnixPath(relativePath)
 
-  // Adding the manifest file.
-  await tar.update(
-    {
-      cwd: distDirectory,
-      file: tarballPath,
-      onWriteEntry(entry) {
-        entry.path = './___netlify-edge-functions.json'
+        entry.path = normalizedPath
       },
     },
-    [manifestPath],
+    await listRecursively(bundleDir.path),
   )
 
-  await Promise.all(cleanup)
+  const hash = await getFileHash(tarballPath)
 
-  const finalHash = [hash, getStringHash(manifestContents), getStringHash(denoConfigContents)].join('')
+  await Promise.allSettled(cleanup)
 
   return {
     extension: TARBALL_EXTENSION,
     format: BundleFormat.TARBALL,
-    hash: finalHash,
+    hash,
   }
 }

packages/edge-bundler/node/utils/fs.ts

@@ -1,4 +1,26 @@
-import path from 'path'
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+
+export const listRecursively = async (dirPath: string): Promise<string[]> => {
+  const entries: string[] = []
+
+  async function walk(currentPath: string): Promise<void> {
+    const dirents = await fs.readdir(currentPath, { withFileTypes: true })
+    for (const dirent of dirents) {
+      const fullPath = path.join(currentPath, dirent.name)
+
+      if (dirent.isDirectory()) {
+        await walk(fullPath)
+      } else if (dirent.isFile() || dirent.isSymbolicLink()) {
+        entries.push(fullPath)
+      }
+    }
+  }
+
+  await walk(dirPath)
+
+  return entries.sort((a, b) => a.localeCompare(b))
+}
 
 /**
  * Returns all the directories obtained by traversing `inner` and its parents

packages/edge-bundler/node/utils/sha256.ts

@@ -1,29 +1,5 @@
 import crypto from 'node:crypto'
-import { createReadStream, promises as fs } from 'node:fs'
-import path from 'node:path'
-
-export const getDirectoryHash = async (dirPath: string): Promise<string> => {
-  const entries: string[] = []
-
-  async function walk(currentPath: string): Promise<void> {
-    const dirents = await fs.readdir(currentPath, { withFileTypes: true })
-    for (const dirent of dirents) {
-      const fullPath = path.join(currentPath, dirent.name)
-      const relativePath = path.relative(dirPath, fullPath)
-
-      if (dirent.isDirectory()) {
-        await walk(fullPath)
-      } else if (dirent.isFile() || dirent.isSymbolicLink()) {
-        const fileHash = await getFileHash(fullPath)
-        entries.push(`${relativePath}:${fileHash}`)
-      }
-    }
-  }
-
-  await walk(dirPath)
-
-  return getStringHash(entries.sort((a, b) => a.localeCompare(b)).join('\n'))
-}
+import { createReadStream } from 'node:fs'
 
 export const getFileHash = (path: string): Promise<string> => {
   const hash = crypto.createHash('sha256')