feat: generate edge function tarballs (#6568)

* feat: deploy edge functions as tarballs

* chore: cleanup

* refactor: abstract TS transpilation logic

* chore: remove comment

* chore: fix test

* chore: update CI versions

* chore: remove node prefix

* fix: add type check

* chore: support Node 14

* chore: update test

* fix: fix test

* fix: fix lint issue

* refactor: use deno bundle

* chore: add comment

* chore: update Deno version

* refactor: remove unused files

* chore: remove lock file

* refactor: revert lock flag

* fix: fix test

* chore: update Deno

* refactor: revert lock flag

* chore: add debug log

* chore: add more debug

* refactor: fix path generation

* chore: clean up test util

* refactor: revert version bump

* chore: simplify test

* chore: do not use lock file

* fix: read feature flag

* refactor: revert fixture change

* fix: use stable hash

* fix: fix file type check

* fix: improve sorting

Author: eduardoboucas

.github/workflows/workflow.yml

@@ -50,7 +50,9 @@ jobs:
         os: [ubuntu-24.04, macos-14, windows-2025]
         node-version: ['22']
         # Must include the minimum deno version from the `DENO_VERSION_RANGE` constant in `node/bridge.ts`.
-        deno-version: ['v1.39.0', 'v2.2.4']
+        # We're adding v2.4.2 here because it's needed for the upcoming nimble release, so we can test
+        # those workflows ahead of time before we can update the base version across the board.
+        deno-version: ['v1.39.0', 'v2.2.4', 'v2.4.2']
         include:
           - os: ubuntu-24.04
             # Earliest supported version

package-lock.json

@@ -42,7 +42,7 @@ const loadWithRetry = (specifier: string, delay = 1000, maxTry = 3) => {
       maxTry,
     });
   } catch (error) {
-    if (isTooManyTries(error as Error)) {
+    if (error instanceof Error && isTooManyTries(error)) {
       console.error(`Loading ${specifier} failed after ${maxTry} tries.`);
     }
     throw error;

packages/edge-bundler/deno/lib/common.ts

@@ -7,6 +7,7 @@ import pathKey from 'path-key'
 import semver from 'semver'
 
 import { download } from './downloader.js'
+import { FeatureFlags } from './feature_flags.js'
 import { getPathInHome } from './home_path.js'
 import { getLogger, Logger } from './logger.js'
 import { getBinaryExtension } from './platform.js'
@@ -16,27 +17,31 @@ const DENO_VERSION_FILE = 'version.txt'
 // When updating DENO_VERSION_RANGE, ensure that the deno version
 // on the netlify/buildbot build image satisfies this range!
 // https://github.com/netlify/buildbot/blob/f9c03c9dcb091d6570e9d0778381560d469e78ad/build-image/noble/Dockerfile#L410
-const DENO_VERSION_RANGE = '1.39.0 - 2.2.4'
+export const DENO_VERSION_RANGE = '1.39.0 - 2.2.4'
 
-type OnBeforeDownloadHook = () => void | Promise<void>
-type OnAfterDownloadHook = (error?: Error) => void | Promise<void>
+const NEXT_DENO_VERSION_RANGE = '^2.4.2'
 
-interface DenoOptions {
+export type OnBeforeDownloadHook = () => void | Promise<void>
+export type OnAfterDownloadHook = (error?: Error) => void | Promise<void>
+
+export interface DenoOptions {
   cacheDirectory?: string
   debug?: boolean
   denoDir?: string
+  featureFlags?: FeatureFlags
   logger?: Logger
   onAfterDownload?: OnAfterDownloadHook
   onBeforeDownload?: OnBeforeDownloadHook
   useGlobal?: boolean
   versionRange?: string
 }
 
-interface ProcessRef {
+export interface ProcessRef {
   ps?: ExecaChildProcess<string>
 }
 
 interface RunOptions {
+  cwd?: string
   env?: NodeJS.ProcessEnv
   extendEnv?: boolean
   pipeOutput?: boolean
@@ -45,7 +50,7 @@ interface RunOptions {
   rejectOnExitCode?: boolean
 }
 
-class DenoBridge {
+export class DenoBridge {
   cacheDirectory: string
   currentDownload?: ReturnType<DenoBridge['downloadBinary']>
   debug: boolean
@@ -64,7 +69,9 @@ class DenoBridge {
     this.onAfterDownload = options.onAfterDownload
     this.onBeforeDownload = options.onBeforeDownload
     this.useGlobal = options.useGlobal ?? true
-    this.versionRange = options.versionRange ?? DENO_VERSION_RANGE
+    this.versionRange =
+      options.versionRange ??
+      (options.featureFlags?.edge_bundler_generate_tarball ? NEXT_DENO_VERSION_RANGE : DENO_VERSION_RANGE)
   }
 
   private async downloadBinary() {
@@ -245,11 +252,11 @@ class DenoBridge {
   // process, awaiting its execution.
   async run(
     args: string[],
-    { env: inputEnv, extendEnv = true, rejectOnExitCode = true, stderr, stdout }: RunOptions = {},
+    { cwd, env: inputEnv, extendEnv = true, rejectOnExitCode = true, stderr, stdout }: RunOptions = {},
   ) {
     const { path: binaryPath } = await this.getBinaryPath()
     const env = this.getEnvironmentVariables(inputEnv)
-    const options: Options = { env, extendEnv, reject: rejectOnExitCode }
+    const options: Options = { cwd, env, extendEnv, reject: rejectOnExitCode }
 
     return DenoBridge.runWithBinary(binaryPath, args, { options, stderr, stdout })
   }
@@ -271,6 +278,3 @@ class DenoBridge {
     }
   }
 }
-
-export { DENO_VERSION_RANGE, DenoBridge }
-export type { DenoOptions, OnAfterDownloadHook, OnBeforeDownloadHook, ProcessRef }

packages/edge-bundler/node/bridge.ts

@@ -1,6 +1,7 @@
 export enum BundleFormat {
   ESZIP2 = 'eszip2',
   JS = 'js',
+  TARBALL = 'tar',
 }
 
 export interface Bundle {

packages/edge-bundler/node/bundle.ts

@@ -1,14 +1,16 @@
 import { Buffer } from 'buffer'
+import { execSync } from 'node:child_process'
 import { access, readdir, readFile, rm, writeFile } from 'fs/promises'
 import { join, resolve } from 'path'
 import process from 'process'
 import { pathToFileURL } from 'url'
 
+import { lt } from 'semver'
 import tmp from 'tmp-promise'
-import { test, expect, vi } from 'vitest'
+import { test, expect, vi, describe } from 'vitest'
 
 import { importMapSpecifier } from '../shared/consts.js'
-import { runESZIP, useFixture } from '../test/util.js'
+import { runESZIP, runTarball, useFixture } from '../test/util.js'
 
 import { BundleError } from './bundle_error.js'
 import { bundle, BundleOptions } from './bundler.js'
@@ -48,7 +50,6 @@ test('Produces an ESZIP bundle', async () => {
   expect(importMapURL).toBe(importMapSpecifier)
 
   const bundlePath = join(distPath, bundles[0].asset)
-
   const { func1, func2, func3 } = await runESZIP(bundlePath)
 
   expect(func1).toBe('HELLO, JANE DOE!')
@@ -499,7 +500,7 @@ test('Loads npm modules from bare specifiers', async () => {
   const { func1 } = await runESZIP(bundlePath, vendorDirectory.path)
 
   expect(func1).toBe(
-    `<parent-1><child-1>JavaScript</child-1></parent-1>, <parent-2><child-2><grandchild-1>APIs<cwd>${process.cwd()}</cwd></grandchild-1></child-2></parent-2>, <parent-3><child-2><grandchild-1>Markup<cwd>${process.cwd()}</cwd></grandchild-1></child-2></parent-3>`,
+    `<parent-1><child-1>JavaScript</child-1></parent-1>, <parent-2><child-2><grandchild-1>APIs<cwd>${process.cwd()}</cwd></grandchild-1></child-2></parent-2>, <parent-3><child-2><grandchild-1>Markup<cwd>${process.cwd()}</cwd></grandchild-1></child-2></parent-3>, TmV0bGlmeQ==`,
   )
 
   await cleanup()
@@ -692,3 +693,98 @@ test('Loads edge functions from the Frameworks API', async () => {
 
   await cleanup()
 })
+
+const denoVersion = execSync('deno eval --no-lock "console.log(Deno.version.deno)"').toString()
+
+describe.skipIf(lt(denoVersion, '2.4.2'))(
+  'Produces a tarball bundle',
+  () => {
+    test('With only local imports', async () => {
+      const systemLogger = vi.fn()
+      const { basePath, cleanup, distPath } = await useFixture('imports_node_builtin', { copyDirectory: true })
+      const declarations: Declaration[] = [
+        {
+          function: 'func1',
+          path: '/func1',
+        },
+      ]
+      const vendorDirectory = await tmp.dir()
+
+      await bundle([join(basePath, 'netlify/edge-functions')], distPath, declarations, {
+        basePath,
+        configPath: join(basePath, '.netlify/edge-functions/config.json'),
+        featureFlags: {
+          edge_bundler_generate_tarball: true,
+        },
+        systemLogger,
+      })
+
+      expect(
+        systemLogger.mock.calls.find((call) => call[0] === 'Could not track dependencies in edge function:'),
+      ).toBeUndefined()
+
+      const expectedOutput = {
+        func1: 'ok',
+      }
+
+      const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8')
+      const manifest = JSON.parse(manifestFile)
+
+      const tarballPath = join(distPath, manifest.bundles[0].asset)
+      const tarballResult = await runTarball(tarballPath)
+      expect(tarballResult).toStrictEqual(expectedOutput)
+
+      const eszipPath = join(distPath, manifest.bundles[1].asset)
+      const eszipResult = await runESZIP(eszipPath)
+      expect(eszipResult).toStrictEqual(expectedOutput)
+
+      await cleanup()
+      await rm(vendorDirectory.path, { force: true, recursive: true })
+    })
+
+    // TODO: https://github.com/denoland/deno/issues/30187
+    test.todo('Using npm modules', async () => {
+      const systemLogger = vi.fn()
+      const { basePath, cleanup, distPath } = await useFixture('imports_npm_module', { copyDirectory: true })
+      const sourceDirectory = join(basePath, 'functions')
+      const declarations: Declaration[] = [
+        {
+          function: 'func1',
+          path: '/func1',
+        },
+      ]
+      const vendorDirectory = await tmp.dir()
+
+      await bundle([sourceDirectory], distPath, declarations, {
+        basePath,
+        featureFlags: {
+          edge_bundler_generate_tarball: true,
+        },
+        importMapPaths: [join(basePath, 'import_map.json')],
+        vendorDirectory: vendorDirectory.path,
+        systemLogger,
+      })
+
+      expect(
+        systemLogger.mock.calls.find((call) => call[0] === 'Could not track dependencies in edge function:'),
+      ).toBeUndefined()
+
+      const expectedOutput = `<parent-1><child-1>JavaScript</child-1></parent-1>, <parent-2><child-2><grandchild-1>APIs<cwd>${process.cwd()}</cwd></grandchild-1></child-2></parent-2>, <parent-3><child-2><grandchild-1>Markup<cwd>${process.cwd()}</cwd></grandchild-1></child-2></parent-3>, TmV0bGlmeQ==`
+
+      const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8')
+      const manifest = JSON.parse(manifestFile)
+
+      const tarballPath = join(distPath, manifest.bundles[0].asset)
+      const tarballResult = await runTarball(tarballPath)
+      expect(tarballResult.func1).toBe(expectedOutput)
+
+      const eszipPath = join(distPath, manifest.bundles[1].asset)
+      const eszipResult = await runESZIP(eszipPath, vendorDirectory.path)
+      expect(eszipResult.func1).toBe(expectedOutput)
+
+      await cleanup()
+      await rm(vendorDirectory.path, { force: true, recursive: true })
+    })
+  },
+  10_000,
+)

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

@@ -15,6 +15,7 @@ import { EdgeFunction } from './edge_function.js'
 import { FeatureFlags, getFlags } from './feature_flags.js'
 import { findFunctions } from './finder.js'
 import { bundle as bundleESZIP } from './formats/eszip.js'
+import { bundle as bundleTarball } from './formats/tarball.js'
 import { ImportMap } from './import_map.js'
 import { getLogger, LogFunction, Logger } from './logger.js'
 import { writeManifest } from './manifest.js'
@@ -66,6 +67,7 @@ export const bundle = async (
   const options: DenoOptions = {
     debug,
     cacheDirectory,
+    featureFlags,
     logger,
     onAfterDownload,
     onBeforeDownload,
@@ -114,27 +116,47 @@ export const bundle = async (
     vendorDirectory,
   })
 
+  const bundles: Bundle[] = []
+
+  if (featureFlags.edge_bundler_generate_tarball) {
+    bundles.push(
+      await bundleTarball({
+        basePath,
+        buildID,
+        debug,
+        deno,
+        distDirectory,
+        functions,
+        featureFlags,
+        importMap: importMap.clone(),
+        vendorDirectory: vendor?.directory,
+      }),
+    )
+  }
+
   if (vendor) {
     importMap.add(vendor.importMap)
   }
 
-  const functionBundle = await bundleESZIP({
-    basePath,
-    buildID,
-    debug,
-    deno,
-    distDirectory,
-    externals,
-    functions,
-    featureFlags,
-    importMap,
-    vendorDirectory: vendor?.directory,
-  })
+  bundles.push(
+    await bundleESZIP({
+      basePath,
+      buildID,
+      debug,
+      deno,
+      distDirectory,
+      externals,
+      functions,
+      featureFlags,
+      importMap,
+      vendorDirectory: vendor?.directory,
+    }),
+  )
 
   // The final file name of the bundles contains a SHA256 hash of the contents,
   // which we can only compute now that the files have been generated. So let's
   // rename the bundles to their permanent names.
-  await createFinalBundles([functionBundle], distDirectory, buildID)
+  await createFinalBundles(bundles, distDirectory, buildID)
 
   // Retrieving a configuration object for each function.
   // Run `getFunctionConfig` in parallel as it is a non-trivial operation and spins up deno
@@ -165,7 +187,7 @@ export const bundle = async (
   })
 
   const manifest = await writeManifest({
-    bundles: [functionBundle],
+    bundles,
     declarations,
     distDirectory,
     featureFlags,