@netlify/edge-bundler 14.6.0 → 14.7.1

package/deno/vendor/deno.land/x/eszip@v0.55.2/eszip.ts

@@ -107,8 +107,11 @@ export async function loadESZIP(filename: string): Promise<ESZIP> {
   return await V1.load(bytes);
 }
 
-function url2path(url: string) {
-  return join(...(new URL(url).pathname.split("/").filter(Boolean)));
+function url2path(urlString: string) {
+  const url = new URL(urlString);
+  const tail = url.pathname.split("/").filter(Boolean);
+  const relativePath = tail.length === 0 ? [".root"] : tail;
+  return join(url.hostname, ...relativePath);
 }
 
 async function write(path: string, content: string) {

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 = "^2.4.2";
+export declare const 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 {
@@ -40,7 +40,13 @@ export declare class DenoBridge {
     versionRange: string;
     constructor(options: DenoOptions);
     private downloadBinary;
-    getBinaryVersion(binaryPath: string): Promise<string | undefined>;
+    getBinaryVersion(binaryPath: string): Promise<{
+        version: string;
+        error?: undefined;
+    } | {
+        version?: undefined;
+        error: Error;
+    }>;
     private getCachedBinary;
     private getGlobalBinary;
     private getRemoteBinary;

package/dist/node/bridge.js

@@ -12,7 +12,8 @@ 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
-export const DENO_VERSION_RANGE = '^2.4.2';
+export const DENO_VERSION_RANGE = '1.39.0 - 2.2.4';
+const NEXT_DENO_VERSION_RANGE = '^2.4.2';
 export class DenoBridge {
     cacheDirectory;
     currentDownload;
@@ -31,24 +32,35 @@ export class DenoBridge {
         this.onAfterDownload = options.onAfterDownload;
         this.onBeforeDownload = options.onBeforeDownload;
         this.useGlobal = options.useGlobal ?? true;
-        this.versionRange = options.versionRange ?? DENO_VERSION_RANGE;
+        const useNextDeno = options.featureFlags?.edge_bundler_generate_tarball || options.featureFlags?.edge_bundler_deno_v2;
+        this.versionRange = options.versionRange ?? (useNextDeno ? NEXT_DENO_VERSION_RANGE : DENO_VERSION_RANGE);
     }
     async downloadBinary() {
         await this.onBeforeDownload?.();
         await this.ensureCacheDirectory();
         this.logger.system(`Downloading Deno CLI to ${this.cacheDirectory}`);
         const binaryPath = await download(this.cacheDirectory, this.versionRange, this.logger);
-        const downloadedVersion = await this.getBinaryVersion(binaryPath);
-        // We should never get here, because it means that `DENO_VERSION_RANGE` is
-        // a malformed semver range. If this does happen, let's throw an error so
-        // that the tests catch it.
-        if (downloadedVersion === undefined) {
-            const error = new Error('There was a problem setting up the Edge Functions environment. To try a manual installation, visit https://ntl.fyi/install-deno.');
+        const result = await this.getBinaryVersion(binaryPath);
+        // If we can't execute the downloaded binary, provide actionable info to diagnose and self-heal if possible
+        if (result.error) {
+            const error = new Error(`Failed to set up Deno for Edge Functions.
+Error: ${result.error.message}
+Downloaded to: ${binaryPath}
+Platform: ${process.platform}/${process.arch}
+
+This may be caused by permissions, antivirus software, or platform incompatibility.
+
+Try clearing the Deno cache directory and retrying:
+  ${this.cacheDirectory}
+
+Supported Deno versions: ${this.versionRange}
+
+To install Deno manually: https://ntl.fyi/install-deno`);
             await this.onAfterDownload?.(error);
             this.logger.system('Could not run downloaded Deno CLI', error);
             throw error;
         }
-        await this.writeVersionFile(downloadedVersion);
+        await this.writeVersionFile(result.version);
         await this.onAfterDownload?.();
         return binaryPath;
     }
@@ -58,12 +70,13 @@ export class DenoBridge {
             const version = stdout.match(/^deno ([\d.]+)/);
             if (!version) {
                 this.logger.system(`getBinaryVersion no version found. binaryPath ${binaryPath}`);
-                return;
+                return { error: new Error('Could not parse Deno version from output') };
             }
-            return version[1];
+            return { version: version[1] };
         }
         catch (error) {
             this.logger.system('getBinaryVersion failed', error);
+            return { error: error instanceof Error ? error : new Error(String(error)) };
         }
     }
     async getCachedBinary() {
@@ -88,9 +101,9 @@ export class DenoBridge {
             return;
         }
         const globalBinaryName = 'deno';
-        const globalVersion = await this.getBinaryVersion(globalBinaryName);
-        if (globalVersion === undefined || !semver.satisfies(globalVersion, this.versionRange)) {
-            this.logger.system(`No globalVersion or semver not satisfied. globalVersion: ${globalVersion}, versionRange: ${this.versionRange}`);
+        const result = await this.getBinaryVersion(globalBinaryName);
+        if (result.error || !semver.satisfies(result.version, this.versionRange)) {
+            this.logger.system(`No globalVersion or semver not satisfied. globalVersion: ${result.version}, versionRange: ${this.versionRange}`);
             return;
         }
         return globalBinaryName;

package/dist/node/bridge.test.js

@@ -101,3 +101,41 @@ test('Does inherit environment variables if `extendEnv` is not set', async () =>
     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 });
+});

package/dist/node/bundler.js

@@ -98,6 +98,7 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
         basePath,
         deno,
         eszipPath,
+        featureFlags,
         importMap,
         internalFunctions,
         log: logger,
@@ -127,7 +128,7 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
     }
     return { functions, manifest };
 };
-const getFunctionConfigs = async ({ basePath, deno, eszipPath, importMap, log, internalFunctions, userFunctions, }) => {
+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 })]);
@@ -140,7 +141,7 @@ const getFunctionConfigs = async ({ basePath, deno, eszipPath, importMap, log, i
         };
     }
     catch (err) {
-        if (!(err instanceof Error && err.cause === 'IMPORT_ASSERT') || !eszipPath) {
+        if (!(err instanceof Error && err.cause === 'IMPORT_ASSERT') || !eszipPath || !featureFlags?.edge_bundler_deno_v2) {
             throw err;
         }
         // We failed to extract the configuration because there is an import assert

package/dist/node/bundler.test.js

@@ -505,6 +505,9 @@ test('Emits a system log when import assertions are used', async () => {
     const systemLogger = vi.fn();
     await bundle([sourceDirectory], distPath, [], {
         basePath,
+        featureFlags: {
+            edge_bundler_deno_v2: true,
+        },
         systemLogger,
         vendorDirectory: vendorDirectory.path,
     });

package/dist/node/config.js

@@ -38,7 +38,8 @@ export const getFunctionConfig = async ({ deno, functionPath, importMap, log, })
     // with the extractor.
     const collector = await tmp.file();
     // Retrieving the version of Deno.
-    const version = new SemVer((await deno.getBinaryVersion((await deno.getBinaryPath({ silent: true })).path)) || '');
+    const result = await deno.getBinaryVersion((await deno.getBinaryPath({ silent: true })).path);
+    const version = new SemVer(result.version || '');
     // The extractor will use its exit code to signal different error scenarios,
     // based on the list of exit codes we send as an argument. We then capture
     // the exit code to know exactly what happened and guide people accordingly.

package/dist/node/feature_flags.d.ts

@@ -1,10 +1,12 @@
 declare const defaultFlags: {
     edge_bundler_generate_tarball: boolean;
+    edge_bundler_deno_v2: boolean;
 };
 type FeatureFlag = keyof typeof defaultFlags;
 type FeatureFlags = Partial<Record<FeatureFlag, boolean>>;
 declare const getFlags: (input?: Record<string, boolean>, flags?: {
     edge_bundler_generate_tarball: boolean;
+    edge_bundler_deno_v2: boolean;
 }) => FeatureFlags;
 export { defaultFlags, getFlags };
 export type { FeatureFlag, FeatureFlags };

package/dist/node/feature_flags.js

@@ -1,5 +1,6 @@
 const defaultFlags = {
     edge_bundler_generate_tarball: false,
+    edge_bundler_deno_v2: false,
 };
 const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
     ...result,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "14.6.0",
+  "version": "14.7.1",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -80,5 +80,5 @@
     "urlpattern-polyfill": "8.0.2",
     "uuid": "^11.0.0"
   },
-  "gitHead": "3dfa7bd62ac0c8fe4b9b61128b8c2315d1272b4f"
+  "gitHead": "b08cf327fc8a631e3520c5f3326ace1d40e22c85"
 }