@netlify/edge-bundler 14.8.3 → 14.8.4

package/dist/node/bridge.d.ts

@@ -2,7 +2,7 @@ import { type WriteStream } from 'fs';
 import { type ExecaChildProcess } from 'execa';
 import { FeatureFlags } from './feature_flags.js';
 import { Logger } from './logger.js';
-export declare const DENO_VERSION_RANGE = "1.39.0 - 2.2.4";
+export declare const LEGACY_DENO_VERSION_RANGE = "1.39.0 - 2.2.4";
 export type OnBeforeDownloadHook = () => void | Promise<void>;
 export type OnAfterDownloadHook = (error?: Error) => void | Promise<void>;
 export interface DenoOptions {

package/dist/node/bridge.js

@@ -9,11 +9,11 @@ import { getPathInHome } from './home_path.js';
 import { getLogger } from './logger.js';
 import { getBinaryExtension } from './platform.js';
 const DENO_VERSION_FILE = 'version.txt';
+export const LEGACY_DENO_VERSION_RANGE = '1.39.0 - 2.2.4';
 // 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
-export const DENO_VERSION_RANGE = '1.39.0 - 2.2.4';
-const NEXT_DENO_VERSION_RANGE = '^2.4.2';
+const DENO_VERSION_RANGE = '^2.4.2';
 export class DenoBridge {
     cacheDirectory;
     currentDownload;
@@ -35,7 +35,7 @@ export class DenoBridge {
         const useNextDeno = options.featureFlags?.edge_bundler_dry_run_generate_tarball ||
             options.featureFlags?.edge_bundler_generate_tarball ||
             options.featureFlags?.edge_bundler_deno_v2;
-        this.versionRange = options.versionRange ?? (useNextDeno ? NEXT_DENO_VERSION_RANGE : DENO_VERSION_RANGE);
+        this.versionRange = options.versionRange ?? (useNextDeno ? DENO_VERSION_RANGE : LEGACY_DENO_VERSION_RANGE);
     }
     async downloadBinary() {
         await this.onBeforeDownload?.();

package/dist/node/bundler.js

@@ -1,15 +1,15 @@
 import { promises as fs } from 'fs';
-import { join, relative } from 'path';
+import { join } from 'path';
 import commonPathPrefix from 'common-path-prefix';
 import { v4 as uuidv4 } from 'uuid';
 import { importMapSpecifier } from '../shared/consts.js';
-import { DenoBridge } from './bridge.js';
+import { DenoBridge, LEGACY_DENO_VERSION_RANGE, } from './bridge.js';
 import { getFunctionConfig } from './config.js';
 import { mergeDeclarations } from './declaration.js';
 import { load as loadDeployConfig } from './deploy_config.js';
 import { getFlags } from './feature_flags.js';
 import { findFunctions } from './finder.js';
-import { bundle as bundleESZIP, extension as eszipExtension, extract as extractESZIP } from './formats/eszip.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 } from './logger.js';
@@ -17,7 +17,7 @@ import { writeManifest } from './manifest.js';
 import { vendorNPMSpecifiers } from './npm_dependencies.js';
 import { ensureLatestTypes } from './types.js';
 import { nonNullable } from './utils/non_nullable.js';
-import { BundleError } from './bundle_error.js';
+import { getPathInHome } from './home_path.js';
 export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], internalSrcFolder, onAfterDownload, onBeforeDownload, rootPath, userLogger, systemLogger, vendorDirectory, } = {}) => {
     const logger = getLogger(systemLogger, userLogger, debug);
     const featureFlags = getFlags(inputFeatureFlags);
@@ -110,13 +110,9 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
     // 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.
-    const bundlePaths = await createFinalBundles(bundles, distDirectory, buildID);
-    const eszipPath = bundlePaths.find((path) => path.endsWith(eszipExtension));
+    await createFinalBundles(bundles, distDirectory, buildID);
     const { internalFunctions: internalFunctionsWithConfig, userFunctions: userFunctionsWithConfig } = await getFunctionConfigs({
-        basePath,
         deno,
-        eszipPath,
-        featureFlags,
         importMap,
         internalFunctions,
         log: logger,
@@ -146,45 +142,44 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
     }
     return { functions, manifest };
 };
-const getFunctionConfigs = async ({ basePath, deno, eszipPath, featureFlags, importMap, log, internalFunctions, userFunctions, }) => {
-    try {
-        const internalConfigPromises = internalFunctions.map(async (func) => [func.name, await getFunctionConfig({ functionPath: func.path, importMap, deno, log })]);
-        const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig({ functionPath: func.path, importMap, deno, log })]);
-        // Creating a hash of function names to configuration objects.
-        const internalFunctionsWithConfig = Object.fromEntries(await Promise.all(internalConfigPromises));
-        const userFunctionsWithConfig = Object.fromEntries(await Promise.all(userConfigPromises));
-        return {
-            internalFunctions: internalFunctionsWithConfig,
-            userFunctions: userFunctionsWithConfig,
-        };
-    }
-    catch (err) {
-        if (!(err instanceof Error && err.cause === 'IMPORT_ASSERT') || !eszipPath || !featureFlags?.edge_bundler_deno_v2) {
-            throw err;
-        }
-        log.user('WARNING: Import assertions are deprecated and will be removed soon. Refer to https://ntl.fyi/import-assert for more information.');
-        try {
-            // We failed to extract the configuration because there is an import assert
-            // in the function code, a deprecated feature that we used to support with
-            // Deno 1.x. To avoid a breaking change, we treat this error as a special
-            // case, using the generated ESZIP to extract the configuration. This works
-            // because import asserts are transpiled to import attributes.
-            const extractedESZIP = await extractESZIP(deno, eszipPath);
-            const configs = await Promise.all([...internalFunctions, ...userFunctions].map(async (func) => {
-                const relativePath = relative(basePath, func.path);
-                const functionPath = join(extractedESZIP.path, relativePath);
-                return [func.name, await getFunctionConfig({ functionPath, importMap, deno, log })];
-            }));
-            await extractedESZIP.cleanup();
-            return {
-                internalFunctions: Object.fromEntries(configs.slice(0, internalFunctions.length)),
-                userFunctions: Object.fromEntries(configs.slice(internalFunctions.length)),
-            };
-        }
-        catch (err) {
-            throw new BundleError(new Error('An error occurred while building an edge function that uses an import assertion. Refer to https://ntl.fyi/import-assert for more information.'), { cause: err });
+const getFunctionConfigs = async ({ deno, importMap, log, internalFunctions, userFunctions, }) => {
+    const functions = [...internalFunctions, ...userFunctions];
+    const results = await Promise.allSettled(functions.map(async (func) => {
+        return [func.name, await getFunctionConfig({ functionPath: func.path, importMap, deno, log })];
+    }));
+    const legacyDeno = new DenoBridge({
+        cacheDirectory: getPathInHome('deno-cli-v1'),
+        useGlobal: false,
+        versionRange: LEGACY_DENO_VERSION_RANGE,
+    });
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const func = functions[i];
+        // We offer support for some features of Deno 1.x that have been removed
+        // from 2.x, such as import assertions and the `window` global. When we
+        // see that we failed to extract a config due to those edge cases, re-run
+        // the script with Deno 1.x so we can extract the config.
+        if (result.status === 'rejected' &&
+            result.reason instanceof Error &&
+            (result.reason.cause === 'IMPORT_ASSERT' || result.reason.cause === 'WINDOW_GLOBAL')) {
+            try {
+                const fallbackConfig = await getFunctionConfig({ functionPath: func.path, importMap, deno: legacyDeno, log });
+                results[i] = { status: 'fulfilled', value: [func.name, fallbackConfig] };
+            }
+            catch {
+                throw result.reason;
+            }
         }
     }
+    const failure = results.find((result) => result.status === 'rejected');
+    if (failure) {
+        throw failure.reason;
+    }
+    const configs = results.map((config) => config.value);
+    return {
+        internalFunctions: Object.fromEntries(configs.slice(0, internalFunctions.length)),
+        userFunctions: Object.fromEntries(configs.slice(internalFunctions.length)),
+    };
 };
 const createFinalBundles = async (bundles, distDirectory, buildID) => {
     const renamingOps = bundles.map(async ({ extension, hash }) => {

package/dist/node/config.js

@@ -84,10 +84,15 @@ export const getFunctionConfig = async ({ deno, functionPath, importMap, log, })
 };
 const handleConfigError = (functionPath, exitCode, stderr, log) => {
     let cause;
-    if (stderr.includes('Import assertions are deprecated')) {
+    if (stderr.includes('Import assertions are deprecated') ||
+        stderr.includes(`SyntaxError: Unexpected identifier 'assert'`)) {
         log.system(`Edge function uses import assertions: ${functionPath}`);
         cause = 'IMPORT_ASSERT';
     }
+    if (stderr.includes('ReferenceError: window is not defined')) {
+        log.system(`Edge function uses the window global: ${functionPath}`);
+        cause = 'WINDOW_GLOBAL';
+    }
     switch (exitCode) {
         case ConfigExitCode.ImportError:
             log.user(stderr);

package/dist/node/formats/eszip.d.ts

@@ -17,8 +17,4 @@ interface BundleESZIPOptions {
     vendorDirectory?: string;
 }
 export declare const bundle: ({ basePath, buildID, debug, deno, distDirectory, externals, functions, importMap, vendorDirectory, }: BundleESZIPOptions) => Promise<Bundle>;
-export declare const extract: (deno: DenoBridge, functionPath: string) => Promise<{
-    cleanup: () => Promise<void>;
-    path: string;
-}>;
 export {};

package/dist/node/formats/eszip.js

@@ -1,6 +1,5 @@
 import { join } from 'path';
 import { pathToFileURL } from 'url';
-import tmp from 'tmp-promise';
 import { virtualRoot, virtualVendorRoot } from '../../shared/consts.js';
 import { BundleFormat } from '../bundle.js';
 import { wrapBundleError } from '../bundle_error.js';
@@ -49,13 +48,3 @@ const getESZIPPaths = () => {
         importMap: join(denoPath, 'vendor', 'import_map.json'),
     };
 };
-export const extract = async (deno, functionPath) => {
-    const tmpDir = await tmp.dir({ unsafeCleanup: true });
-    const { extractor, importMap } = getESZIPPaths();
-    const flags = ['--allow-all', '--no-config', '--no-lock', `--import-map=${importMap}`, '--quiet'];
-    await deno.run(['run', ...flags, extractor, functionPath, tmpDir.path], { pipeOutput: true });
-    return {
-        cleanup: tmpDir.cleanup,
-        path: join(tmpDir.path, 'source', 'root'),
-    };
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "14.8.3",
+  "version": "14.8.4",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -9,6 +9,7 @@
     "deno/**",
     "!deno/**/*.test.ts",
     "dist/**/*.js",
+    "!dist/**/*.test.js",
     "dist/**/*.d.ts",
     "shared/**"
   ],
@@ -64,7 +65,7 @@
     "better-ajv-errors": "^1.2.0",
     "common-path-prefix": "^3.0.0",
     "env-paths": "^3.0.0",
-    "esbuild": "0.25.10",
+    "esbuild": "0.25.11",
     "execa": "^8.0.0",
     "find-up": "^7.0.0",
     "get-port": "^7.0.0",
@@ -79,5 +80,5 @@
     "urlpattern-polyfill": "8.0.2",
     "uuid": "^11.0.0"
   },
-  "gitHead": "ba28f3d0b3bde3f5d43ad79e11fcc48f681dbc3c"
+  "gitHead": "eae1c7c9d0d7ab598aa676f72d298160a5fee92a"
 }

package/deno/extract.ts

@@ -1,7 +0,0 @@
-import { loadESZIP } from 'https://deno.land/x/eszip@v0.55.2/eszip.ts'
-
-const [functionPath, destPath] = Deno.args
-
-const eszip = await loadESZIP(functionPath)
-
-await eszip.extract(destPath)

package/dist/node/bridge.test.js

@@ -1,141 +0,0 @@
-import { Buffer } from 'buffer';
-import { rm } from 'fs/promises';
-import { createRequire } from 'module';
-import { platform, env } from 'process';
-import { PassThrough } from 'stream';
-import nock from 'nock';
-import semver from 'semver';
-import tmp from 'tmp-promise';
-import { test, expect } from 'vitest';
-import { DenoBridge, DENO_VERSION_RANGE } from './bridge.js';
-import { getPlatformTarget } from './platform.js';
-const require = createRequire(import.meta.url);
-const archiver = require('archiver');
-const getMockDenoBridge = function (tmpDir, mockBinaryOutput) {
-    const latestVersion = semver.minVersion(DENO_VERSION_RANGE)?.version ?? '';
-    const data = new PassThrough();
-    const archive = archiver('zip', { zlib: { level: 9 } });
-    archive.pipe(data);
-    archive.append(Buffer.from(mockBinaryOutput.replace(/@@@latestVersion@@@/g, latestVersion)), {
-        name: platform === 'win32' ? 'deno.exe' : 'deno',
-    });
-    archive.finalize();
-    const target = getPlatformTarget();
-    nock('https://dl.deno.land').get('/release-latest.txt').reply(200, `v${latestVersion}`);
-    nock('https://dl.deno.land')
-        .get(`/release/v${latestVersion}/deno-${target}.zip`)
-        .reply(200, () => data);
-    return new DenoBridge({
-        cacheDirectory: tmpDir.path,
-        useGlobal: false,
-    });
-};
-test('Does not inherit environment variables if `extendEnv` is false', async () => {
-    const tmpDir = await tmp.dir();
-    const deno = getMockDenoBridge(tmpDir, `#!/usr/bin/env sh
-
-    if [ "$1" = "test"  ]
-    then
-      env
-    else
-      echo "deno @@@latestVersion@@@"
-    fi`);
-    // The environment sets some variables so let us see what they are and remove them from the result
-    const referenceOutput = await deno.run(['test'], { env: {}, extendEnv: false });
-    env.TADA = 'TUDU';
-    const result = await deno.run(['test'], { env: { LULU: 'LALA' }, extendEnv: false });
-    let output = result?.stdout ?? '';
-    delete env.TADA;
-    referenceOutput?.stdout.split('\n').forEach((line) => {
-        output = output.replace(line.trim(), '');
-    });
-    output = output.trim().replace(/\n+/g, '\n');
-    expect(output).toBe('LULU=LALA');
-    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
-});
-test('Does inherit environment variables if `extendEnv` is true', async () => {
-    const tmpDir = await tmp.dir();
-    const deno = getMockDenoBridge(tmpDir, `#!/usr/bin/env sh
-
-  if [ "$1" = "test"  ]
-  then
-    env
-  else
-    echo "deno @@@latestVersion@@@"
-  fi`);
-    // The environment sets some variables so let us see what they are and remove them from the result
-    const referenceOutput = await deno.run(['test'], { env: {}, extendEnv: true });
-    env.TADA = 'TUDU';
-    const result = await deno.run(['test'], { env: { LULU: 'LALA' }, extendEnv: true });
-    let output = result?.stdout ?? '';
-    delete env.TADA;
-    referenceOutput?.stdout.split('\n').forEach((line) => {
-        output = output.replace(line.trim(), '');
-    });
-    // lets remove holes, split lines and sort lines by name, as different OSes might order them different
-    const environmentVariables = output.trim().replace(/\n+/g, '\n').split('\n').sort();
-    expect(environmentVariables).toEqual(['LULU=LALA', 'TADA=TUDU']);
-    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
-});
-test('Does inherit environment variables if `extendEnv` is not set', async () => {
-    const tmpDir = await tmp.dir();
-    const deno = getMockDenoBridge(tmpDir, `#!/usr/bin/env sh
-
-    if [ "$1" = "test"  ]
-    then
-      env
-    else
-      echo "deno @@@latestVersion@@@"
-    fi`);
-    // The environment sets some variables so let us see what they are and remove them from the result
-    const referenceOutput = await deno.run(['test'], { env: {}, extendEnv: true });
-    env.TADA = 'TUDU';
-    const result = await deno.run(['test'], { env: { LULU: 'LALA' } });
-    let output = result?.stdout ?? '';
-    delete env.TADA;
-    referenceOutput?.stdout.split('\n').forEach((line) => {
-        output = output.replace(line.trim(), '');
-    });
-    // lets remove holes, split lines and sort lines by name, as different OSes might order them different
-    const environmentVariables = output.trim().replace(/\n+/g, '\n').split('\n').sort();
-    expect(environmentVariables).toEqual(['LULU=LALA', 'TADA=TUDU']);
-    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
-});
-test('Provides actionable error message when downloaded binary cannot be executed', async () => {
-    const tmpDir = await tmp.dir();
-    const latestVersion = semver.minVersion(DENO_VERSION_RANGE)?.version ?? '';
-    const data = new PassThrough();
-    const archive = archiver('zip', { zlib: { level: 9 } });
-    archive.pipe(data);
-    // Create a binary that will fail to execute (invalid content)
-    archive.append(Buffer.from('invalid binary content'), {
-        name: platform === 'win32' ? 'deno.exe' : 'deno',
-    });
-    archive.finalize();
-    const target = getPlatformTarget();
-    nock('https://dl.deno.land').get('/release-latest.txt').reply(200, `v${latestVersion}`);
-    nock('https://dl.deno.land')
-        .get(`/release/v${latestVersion}/deno-${target}.zip`)
-        .reply(200, () => data);
-    const deno = new DenoBridge({
-        cacheDirectory: tmpDir.path,
-        useGlobal: false,
-    });
-    try {
-        await deno.getBinaryPath();
-        expect.fail('Should have thrown an error');
-    }
-    catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        const errorMessage = error.message;
-        expect(errorMessage).toContain('Failed to set up Deno for Edge Functions');
-        expect(errorMessage).toMatch(/Error:/);
-        expect(errorMessage).toMatch(/Downloaded to: .+deno(\.exe)?/);
-        expect(errorMessage).toContain(tmpDir.path);
-        expect(errorMessage).toMatch(/Platform: (darwin|linux|win32)\/(x64|arm64|ia32)/);
-        expect(errorMessage).toContain('This may be caused by permissions, antivirus software, or platform incompatibility');
-        expect(errorMessage).toContain('Try clearing the Deno cache directory and retrying');
-        expect(errorMessage).toContain('https://ntl.fyi/install-deno');
-    }
-    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
-});