@netlify/edge-bundler 1.14.0 → 2.0.1

package/deno/bundle.ts

@@ -1,6 +1,6 @@
 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/stage2.ts

@@ -1,22 +1,11 @@
-import { build, LoadResponse } from 'https://deno.land/x/eszip@v0.18.0/mod.ts'
+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 '../../src/stage2.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}`
@@ -44,7 +33,7 @@ const getVirtualPath = (basePath: string, filePath: string) => {
   return url
 }
 
-const stage2Loader = (basePath: string, functions: InputFunction[], imports: Record<string, string> = {}) => {
+const stage2Loader = (basePath: string, functions: InputFunction[]) => {
   return async (specifier: string): Promise<LoadResponse | undefined> => {
     if (specifier === STAGE2_SPECIFIER) {
       const stage2Entry = getStage2Entry(basePath, functions)
@@ -59,10 +48,6 @@ const stage2Loader = (basePath: string, functions: InputFunction[], imports: Rec
       }
     }
 
-    if (imports[specifier] !== undefined) {
-      return await loadWithRetry(imports[specifier])
-    }
-
     if (specifier.startsWith(virtualRoot)) {
       return loadFromVirtualRoot(specifier, virtualRoot, basePath)
     }
@@ -71,9 +56,9 @@ const stage2Loader = (basePath: string, functions: InputFunction[], imports: Rec
   }
 }
 
-const writeStage2 = async ({ basePath, destPath, functions, imports }: WriteStage2Options) => {
-  const loader = stage2Loader(basePath, functions, imports)
-  const bytes = await build([STAGE2_SPECIFIER], loader)
+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)
 }

package/dist/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/downloader.d.ts

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

package/dist/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/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/import_map.d.ts

@@ -1,10 +1,12 @@
 interface ImportMapFile {
+    baseURL: URL;
     imports: Record<string, string>;
-    scopes?: Record<string, string>;
+    scopes?: Record<string, Record<string, string>>;
 }
 declare class ImportMap {
-    imports: Record<string, string>;
-    constructor(input?: ImportMapFile[]);
+    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>;

package/dist/import_map.js

@@ -1,15 +1,29 @@
 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': 'https://edge.netlify.com/v1/index.ts',
+    'netlify:edge': new URL('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 };
+    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 = {

package/dist/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/stage2.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "1.14.0",
+  "version": "2.0.1",
   "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",