@netlify/edge-bundler 1.12.1 → 1.14.1

package/deno/bundle.ts

@@ -1,4 +1,4 @@
-import { writeStage2 } from 'https://62ea8d05a6858300091547ed--edge.netlify.com/bundler/mod.ts'
+import { writeStage2 } from './lib/stage2.ts'
 
 const [payload] = Deno.args
 const { basePath, destPath, functions, imports } = JSON.parse(payload)

package/deno/lib/common.ts

@@ -0,0 +1,47 @@
+import { load } from "https://deno.land/x/eszip@v0.18.0/loader.ts";
+import { LoadResponse } from "https://deno.land/x/eszip@v0.18.0/mod.ts";
+import * as path from "https://deno.land/std@0.127.0/path/mod.ts";
+import { retryAsync } from "https://deno.land/x/retry@v2.0.0/mod.ts";
+
+const inlineModule = (
+  specifier: string,
+  content: string,
+): LoadResponse => {
+  return {
+    content,
+    headers: {
+      "content-type": "application/typescript",
+    },
+    kind: "module",
+    specifier,
+  };
+};
+
+const loadFromVirtualRoot = async (
+  specifier: string,
+  virtualRoot: string,
+  basePath: string,
+) => {
+  const basePathURL = path.toFileUrl(basePath).toString();
+  const filePath = specifier.replace(virtualRoot.slice(0, -1), basePathURL);
+  const file = await load(filePath);
+
+  if (file === undefined) {
+    throw new Error(`Could not find file: ${filePath}`);
+  }
+
+  return { ...file, specifier };
+};
+
+const loadWithRetry = (specifier: string, delay = 1000, maxTry = 3) => {
+  if (!specifier.startsWith("https://")) {
+    return load(specifier);
+  }
+
+  return retryAsync(() => load(specifier), {
+    delay,
+    maxTry,
+  });
+};
+
+export { inlineModule, loadFromVirtualRoot, loadWithRetry };

package/deno/lib/consts.ts

@@ -0,0 +1,4 @@
+export const PUBLIC_SPECIFIER = "netlify:edge";
+export const STAGE1_SPECIFIER = "netlify:bootstrap-stage1";
+export const STAGE2_SPECIFIER = "netlify:bootstrap-stage2";
+export const virtualRoot = "file:///root/";

package/deno/lib/stage2.ts

@@ -0,0 +1,81 @@
+import { build, LoadResponse } from 'https://deno.land/x/eszip@v0.18.0/mod.ts'
+
+import * as path from 'https://deno.land/std@0.127.0/path/mod.ts'
+
+import { PUBLIC_SPECIFIER, STAGE2_SPECIFIER, virtualRoot } from './consts.ts'
+import { inlineModule, loadFromVirtualRoot, loadWithRetry } from './common.ts'
+
+interface InputFunction {
+  name: string
+  path: string
+}
+
+interface WriteStage2Options {
+  basePath: string
+  destPath: string
+  functions: InputFunction[]
+  imports?: Record<string, string>
+}
+
+const getFunctionReference = (basePath: string, func: InputFunction, index: number) => {
+  const importName = `func${index}`
+  const exportLine = `"${func.name}": ${importName}`
+  const url = getVirtualPath(basePath, func.path)
+
+  return {
+    exportLine,
+    importLine: `import ${importName} from "${url}";`,
+  }
+}
+
+const getStage2Entry = (basePath: string, functions: InputFunction[]) => {
+  const lines = functions.map((func, index) => getFunctionReference(basePath, func, index))
+  const importLines = lines.map(({ importLine }) => importLine).join('\n')
+  const exportLines = lines.map(({ exportLine }) => exportLine).join(', ')
+  const exportDeclaration = `export const functions = {${exportLines}};`
+
+  return [importLines, exportDeclaration].join('\n\n')
+}
+
+const getVirtualPath = (basePath: string, filePath: string) => {
+  const relativePath = path.relative(basePath, filePath)
+  const url = new URL(relativePath, virtualRoot)
+
+  return url
+}
+
+const stage2Loader = (basePath: string, functions: InputFunction[], imports: Record<string, string> = {}) => {
+  return async (specifier: string): Promise<LoadResponse | undefined> => {
+    if (specifier === STAGE2_SPECIFIER) {
+      const stage2Entry = getStage2Entry(basePath, functions)
+
+      return inlineModule(specifier, stage2Entry)
+    }
+
+    if (specifier === PUBLIC_SPECIFIER) {
+      return {
+        kind: 'external',
+        specifier,
+      }
+    }
+
+    if (imports[specifier] !== undefined) {
+      return await loadWithRetry(imports[specifier])
+    }
+
+    if (specifier.startsWith(virtualRoot)) {
+      return loadFromVirtualRoot(specifier, virtualRoot, basePath)
+    }
+
+    return await loadWithRetry(specifier)
+  }
+}
+
+const writeStage2 = async ({ basePath, destPath, functions, imports }: WriteStage2Options) => {
+  const loader = stage2Loader(basePath, functions, imports)
+  const bytes = await build([STAGE2_SPECIFIER], loader)
+
+  return await Deno.writeFile(destPath, bytes)
+}
+
+export { writeStage2 }

package/dist/bridge.js

@@ -27,7 +27,7 @@ class DenoBridge {
         await ((_a = this.onBeforeDownload) === null || _a === void 0 ? void 0 : _a.call(this));
         await this.ensureCacheDirectory();
         this.logger.system(`Downloading Deno CLI to ${this.cacheDirectory}`);
-        const binaryPath = await download(this.cacheDirectory, this.versionRange);
+        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
@@ -35,6 +35,7 @@ class DenoBridge {
         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.');
             await ((_b = this.onAfterDownload) === null || _b === void 0 ? void 0 : _b.call(this, error));
+            this.logger.system('Could not run downloaded Deno CLI', error);
             throw error;
         }
         await this.writeVersionFile(downloadedVersion);
@@ -46,13 +47,12 @@ class DenoBridge {
             const { stdout } = await execa(binaryPath, ['--version']);
             const version = stdout.match(/^deno ([\d.]+)/);
             if (!version) {
+                this.logger.system(`getBinaryVersion no version found. binaryPath ${binaryPath}`);
                 return;
             }
             return version[1];
         }
-        catch (error) {
-            this.logger.system('Error checking Deno binary version', error);
-        }
+        catch { }
     }
     async getCachedBinary() {
         const versionFilePath = path.join(this.cacheDirectory, DENO_VERSION_FILE);
@@ -60,10 +60,12 @@ class DenoBridge {
         try {
             cachedVersion = await fs.readFile(versionFilePath, 'utf8');
         }
-        catch {
+        catch (error) {
+            this.logger.system('Error getting cached binary', error);
             return;
         }
         if (!semver.satisfies(cachedVersion, this.versionRange)) {
+            this.logger.system(`semver not satisfied. cachedVersion: ${cachedVersion}, versionRange: ${this.versionRange}`);
             return;
         }
         const binaryName = `deno${getBinaryExtension()}`;
@@ -76,6 +78,7 @@ class DenoBridge {
         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}`);
             return;
         }
         return globalBinaryName;

package/dist/downloader.d.ts

@@ -1,2 +1,3 @@
-declare const download: (targetDirectory: string, versionRange: string) => Promise<string>;
-export { download };
+import { Logger } from './logger.js';
+declare const downloadWithRetry: (targetDirectory: string, versionRange: string, logger: Logger) => Promise<string>;
+export { downloadWithRetry as download };

package/dist/downloader.js

@@ -1,35 +1,50 @@
-import fs from 'fs';
+import { createWriteStream, promises as fs } from 'fs';
 import path from 'path';
+import { promisify } from 'util';
 import fetch from 'node-fetch';
 import StreamZip from 'node-stream-zip';
+import pRetry from 'p-retry';
 import semver from 'semver';
 import { getBinaryExtension, getPlatformTarget } from './platform.js';
+const downloadWithRetry = async (targetDirectory, versionRange, logger) => await pRetry(async () => await download(targetDirectory, versionRange), {
+    retries: 3,
+    onFailedAttempt: (error) => {
+        logger.system('Deno download with retry failed', error);
+    },
+});
 const download = async (targetDirectory, versionRange) => {
     const zipPath = path.join(targetDirectory, 'deno-cli-latest.zip');
     const data = await downloadVersion(versionRange);
     const binaryName = `deno${getBinaryExtension()}`;
     const binaryPath = path.join(targetDirectory, binaryName);
-    const file = fs.createWriteStream(zipPath);
-    await new Promise((resolve, reject) => {
-        data.pipe(file);
-        data.on('error', reject);
-        file.on('finish', resolve);
-    });
-    await extractBinaryFromZip(zipPath, binaryPath, binaryName);
+    const file = createWriteStream(zipPath);
     try {
-        await fs.promises.unlink(zipPath);
+        await new Promise((resolve, reject) => {
+            data.pipe(file);
+            data.on('error', reject);
+            file.on('finish', resolve);
+        });
+        await extractBinaryFromZip(zipPath, binaryPath, binaryName);
+        return binaryPath;
     }
-    catch {
-        // no-op
+    finally {
+        // Try closing and deleting the zip file in any case, error or not
+        await promisify(file.close.bind(file))();
+        try {
+            await fs.unlink(zipPath);
+        }
+        catch {
+            // no-op
+        }
     }
-    return binaryPath;
 };
 const downloadVersion = async (versionRange) => {
     const version = await getLatestVersionForRange(versionRange);
     const url = getReleaseURL(version);
     const res = await fetch(url);
-    if (res.body === null) {
-        throw new Error('Could not download Deno');
+    // eslint-disable-next-line no-magic-numbers
+    if (res.body === null || res.status < 200 || res.status > 299) {
+        throw new Error(`Download failed with status code ${res.status}`);
     }
     return res.body;
 };
@@ -38,7 +53,7 @@ const extractBinaryFromZip = async (zipPath, binaryPath, binaryName) => {
     const zip = new StreamZipAsync({ file: zipPath });
     await zip.extract(binaryName, binaryPath);
     await zip.close();
-    await fs.promises.chmod(binaryPath, '755');
+    await fs.chmod(binaryPath, '755');
 };
 const getLatestVersion = async () => {
     try {
@@ -75,4 +90,4 @@ const getReleaseURL = (version) => {
     const target = getPlatformTarget();
     return `https://dl.deno.land/release/v${version}/deno-${target}.zip`;
 };
-export { download };
+export { downloadWithRetry as download };

package/dist/formats/javascript.js

@@ -5,7 +5,7 @@ import { pathToFileURL } from 'url';
 import del from 'del';
 import { wrapBundleError } from '../bundle_error.js';
 import { getFileHash } from '../utils/sha256.js';
-const BOOTSTRAP_LATEST = 'https://62ea8d05a6858300091547ed--edge.netlify.com/bootstrap/index-combined.ts';
+const BOOTSTRAP_LATEST = 'https://62f5f45fbc76ed0009624267--edge.netlify.com/bootstrap/index-combined.ts';
 const bundleJS = async ({ buildID, debug, deno, distDirectory, functions, importMap, }) => {
     const stage2Path = await generateStage2({ distDirectory, functions, fileName: `${buildID}-pre.js` });
     const extension = '.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "1.12.1",
+  "version": "1.14.1",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/index.js",
@@ -86,6 +86,7 @@
     "glob-to-regexp": "^0.4.1",
     "node-fetch": "^3.1.1",
     "node-stream-zip": "^1.15.0",
+    "p-retry": "^5.1.1",
     "p-wait-for": "^4.1.0",
     "path-key": "^4.0.0",
     "semver": "^7.3.5",