@netlify/edge-bundler 1.13.0 → 2.0.0

package/deno/bundle.ts

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

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,66 @@
+import { build, LoadResponse } from 'https://deno.land/x/eszip@v0.28.0/mod.ts'
+
+import * as path from 'https://deno.land/std@0.127.0/path/mod.ts'
+
+import type { InputFunction, WriteStage2Options } from '../../common/stage2.ts'
+import { PUBLIC_SPECIFIER, STAGE2_SPECIFIER, virtualRoot } from './consts.ts'
+import { inlineModule, loadFromVirtualRoot, loadWithRetry } from './common.ts'
+
+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[]) => {
+  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 (specifier.startsWith(virtualRoot)) {
+      return loadFromVirtualRoot(specifier, virtualRoot, basePath)
+    }
+
+    return await loadWithRetry(specifier)
+  }
+}
+
+const writeStage2 = async ({ basePath, destPath, functions, importMapURL }: WriteStage2Options) => {
+  const loader = stage2Loader(basePath, functions)
+  const bytes = await build([STAGE2_SPECIFIER], loader, importMapURL)
+
+  return await Deno.writeFile(destPath, bytes)
+}
+
+export { writeStage2 }

package/dist/common/stage2.d.ts

@@ -0,0 +1,10 @@
+export interface InputFunction {
+    name: string;
+    path: string;
+}
+export interface WriteStage2Options {
+    basePath: string;
+    destPath: string;
+    functions: InputFunction[];
+    importMapURL?: string;
+}

package/dist/{bundler.d.ts → src/bundler.d.ts}

@@ -15,7 +15,7 @@ interface BundleOptions {
     onBeforeDownload?: OnBeforeDownloadHook;
     systemLogger?: LogFunction;
 }
-declare const bundle: (sourceDirectories: string[], distDirectory: string, declarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMaps, onAfterDownload, onBeforeDownload, systemLogger, }?: BundleOptions) => Promise<{
+declare const bundle: (sourceDirectories: string[], distDirectory: string, declarations?: Declaration[], { basePath, cacheDirectory, debug, distImportMapPath, featureFlags, importMaps, onAfterDownload, onBeforeDownload, systemLogger, }?: BundleOptions) => Promise<{
     functions: EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;

package/dist/src/downloader.d.ts

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

package/dist/{downloader.js → src/downloader.js}

@@ -1,51 +1,59 @@
-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 download = async (targetDirectory, versionRange, logger) => {
+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 downloadVersionWithRetry(versionRange, logger);
+    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;
 };
-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 });
     await zip.extract(binaryName, binaryPath);
     await zip.close();
-    await fs.promises.chmod(binaryPath, '755');
+    await fs.chmod(binaryPath, '755');
 };
 const getLatestVersion = async () => {
     try {
@@ -82,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/src/edge_function.js

@@ -0,0 +1 @@
+export {};

package/dist/{formats → src/formats}/eszip.js

@@ -10,7 +10,7 @@ const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, func
         basePath,
         destPath,
         functions,
-        imports: importMap.imports,
+        importMapURL: importMap.toDataURL(),
     };
     const flags = ['--allow-all'];
     if (!debug) {

package/dist/src/import_map.d.ts

@@ -0,0 +1,15 @@
+interface ImportMapFile {
+    baseURL: URL;
+    imports: Record<string, string>;
+    scopes?: Record<string, Record<string, string>>;
+}
+declare class ImportMap {
+    imports: Record<string, URL | null>;
+    constructor(files?: ImportMapFile[]);
+    static resolve(importMapFile: ImportMapFile): import("@import-maps/resolve/types/src/types").ParsedImportMap;
+    getContents(): string;
+    toDataURL(): string;
+    writeToFile(path: string): Promise<void>;
+}
+export { ImportMap };
+export type { ImportMapFile };

package/dist/src/import_map.js

@@ -0,0 +1,44 @@
+import { Buffer } from 'buffer';
+import { promises as fs } from 'fs';
+import { dirname } from 'path';
+import { parse } from '@import-maps/resolve';
+const INTERNAL_IMPORTS = {
+    'netlify:edge': new URL('https://edge.netlify.com/v1/index.ts'),
+};
+class ImportMap {
+    constructor(files = []) {
+        let imports = {};
+        files.forEach((file) => {
+            const importMap = ImportMap.resolve(file);
+            imports = { ...imports, ...importMap.imports };
+        });
+        // Internal imports must come last, because we need to guarantee that
+        // `netlify:edge` isn't user-defined.
+        Object.entries(INTERNAL_IMPORTS).forEach((internalImport) => {
+            const [specifier, url] = internalImport;
+            imports[specifier] = url;
+        });
+        this.imports = imports;
+    }
+    static resolve(importMapFile) {
+        const { baseURL, ...importMap } = importMapFile;
+        const parsedImportMap = parse(importMap, baseURL);
+        return parsedImportMap;
+    }
+    getContents() {
+        const contents = {
+            imports: this.imports,
+        };
+        return JSON.stringify(contents);
+    }
+    toDataURL() {
+        const encodedImportMap = Buffer.from(this.getContents()).toString('base64');
+        return `data:application/json;base64,${encodedImportMap}`;
+    }
+    async writeToFile(path) {
+        await fs.mkdir(dirname(path), { recursive: true });
+        const contents = this.getContents();
+        await fs.writeFile(path, contents);
+    }
+}
+export { ImportMap };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "1.13.0",
+  "version": "2.0.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/index.js",
@@ -79,6 +79,7 @@
     "node": "^12.20.0 || ^14.14.0 || >=16.0.0"
   },
   "dependencies": {
+    "@import-maps/resolve": "^1.0.1",
     "common-path-prefix": "^3.0.0",
     "del": "^6.0.0",
     "env-paths": "^3.0.0",

package/dist/downloader.d.ts

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

package/dist/import_map.d.ts

@@ -1,13 +0,0 @@
-interface ImportMapFile {
-    imports: Record<string, string>;
-    scopes?: Record<string, string>;
-}
-declare class ImportMap {
-    imports: Record<string, string>;
-    constructor(input?: ImportMapFile[]);
-    getContents(): string;
-    toDataURL(): string;
-    writeToFile(path: string): Promise<void>;
-}
-export { ImportMap };
-export type { ImportMapFile };

package/dist/import_map.js

@@ -1,30 +0,0 @@
-import { Buffer } from 'buffer';
-import { promises as fs } from 'fs';
-import { dirname } from 'path';
-const INTERNAL_IMPORTS = {
-    'netlify:edge': 'https://edge.netlify.com/v1/index.ts',
-};
-class ImportMap {
-    constructor(input = []) {
-        const inputImports = input.reduce((acc, { imports }) => ({ ...acc, ...imports }), {});
-        // `INTERNAL_IMPORTS` must come last,
-        // because we need to guarantee `netlify:edge` isn't user-defined.
-        this.imports = { ...inputImports, ...INTERNAL_IMPORTS };
-    }
-    getContents() {
-        const contents = {
-            imports: this.imports,
-        };
-        return JSON.stringify(contents);
-    }
-    toDataURL() {
-        const encodedImportMap = Buffer.from(this.getContents()).toString('base64');
-        return `data:application/json;base64,${encodedImportMap}`;
-    }
-    async writeToFile(path) {
-        await fs.mkdir(dirname(path), { recursive: true });
-        const contents = this.getContents();
-        await fs.writeFile(path, contents);
-    }
-}
-export { ImportMap };