@netlify/edge-bundler 1.12.0 → 1.14.0

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

@@ -2,6 +2,7 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import process from 'process';
 import { execa } from 'execa';
+import pathKey from 'path-key';
 import semver from 'semver';
 import { download } from './downloader.js';
 import { getPathInHome } from './home_path.js';
@@ -26,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
@@ -34,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);
@@ -45,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);
@@ -59,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()}`;
@@ -75,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;
@@ -121,6 +125,8 @@ class DenoBridge {
         if (this.denoDir !== undefined) {
             env.DENO_DIR = this.denoDir;
         }
+        // Ensure PATH is always set as otherwise we are not able to find the global deno binary
+        env[pathKey()] = inputEnv[pathKey({ env: inputEnv })] || process.env[pathKey()];
         return env;
     }
     // Runs the Deno CLI in the background and returns a reference to the child

package/dist/downloader.d.ts

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

package/dist/downloader.js

@@ -2,11 +2,12 @@ import fs from 'fs';
 import path from 'path';
 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 download = async (targetDirectory, versionRange) => {
+const download = async (targetDirectory, versionRange, logger) => {
     const zipPath = path.join(targetDirectory, 'deno-cli-latest.zip');
-    const data = await downloadVersion(versionRange);
+    const data = await downloadVersionWithRetry(versionRange, logger);
     const binaryName = `deno${getBinaryExtension()}`;
     const binaryPath = path.join(targetDirectory, binaryName);
     const file = fs.createWriteStream(zipPath);
@@ -33,6 +34,12 @@ const downloadVersion = async (versionRange) => {
     }
     return res.body;
 };
+const downloadVersionWithRetry = async (versionRange, logger) => await pRetry(async () => await downloadVersion(versionRange), {
+    retries: 3,
+    onFailedAttempt: (error) => {
+        logger.system('Deno CLI download retry attempt error', error);
+    },
+});
 const extractBinaryFromZip = async (zipPath, binaryPath, binaryName) => {
     const { async: StreamZipAsync } = StreamZip;
     const zip = new StreamZipAsync({ file: zipPath });

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.0",
+  "version": "1.14.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/index.js",
@@ -86,7 +86,9 @@
     "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",
     "tmp-promise": "^3.0.3",
     "uuid": "^8.3.2"