@netlify/edge-bundler 6.1.0 → 7.0.1

package/dist/node/bundler.d.ts

@@ -9,11 +9,12 @@ interface BundleOptions {
     debug?: boolean;
     distImportMapPath?: string;
     featureFlags?: FeatureFlags;
+    importMapPaths?: (string | undefined)[];
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
     systemLogger?: LogFunction;
 }
-declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, onAfterDownload, onBeforeDownload, systemLogger, }?: BundleOptions) => Promise<{
+declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, onAfterDownload, onBeforeDownload, systemLogger, }?: BundleOptions) => Promise<{
     functions: import("./edge_function.js").EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;

package/dist/node/bundler.js

@@ -6,16 +6,15 @@ import { importMapSpecifier } from '../shared/consts.js';
 import { DenoBridge } from './bridge.js';
 import { getFunctionConfig } from './config.js';
 import { getDeclarationsFromConfig } from './declaration.js';
-import { getConfig as getDenoConfig } from './deno_config.js';
 import { load as loadDeployConfig } from './deploy_config.js';
 import { getFlags } from './feature_flags.js';
 import { findFunctions } from './finder.js';
 import { bundle as bundleESZIP } from './formats/eszip.js';
-import { ImportMap, readFile as readImportMapFile } from './import_map.js';
+import { ImportMap } from './import_map.js';
 import { getLogger } from './logger.js';
 import { writeManifest } from './manifest.js';
 import { ensureLatestTypes } from './types.js';
-const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, onAfterDownload, onBeforeDownload, systemLogger, } = {}) => {
+const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], onAfterDownload, onBeforeDownload, systemLogger, } = {}) => {
     const logger = getLogger(systemLogger, debug);
     const featureFlags = getFlags(inputFeatureFlags);
     const options = {
@@ -42,19 +41,7 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
     // not actually included in the bundle.
     const externals = deployConfig.layers.map((layer) => layer.name);
     const importMap = new ImportMap();
-    if (deployConfig.importMap) {
-        importMap.add(deployConfig.importMap);
-    }
-    if (featureFlags.edge_functions_read_deno_config) {
-        // Look for a Deno config file and read it if one exists.
-        const denoConfig = await getDenoConfig(logger, basePath);
-        // If the Deno config file defines an import map, read the file and add the
-        // imports to the global import map.
-        if (denoConfig === null || denoConfig === void 0 ? void 0 : denoConfig.importMap) {
-            const importMapFile = await readImportMapFile(denoConfig.importMap);
-            importMap.add(importMapFile);
-        }
-    }
+    await importMap.addFiles([deployConfig === null || deployConfig === void 0 ? void 0 : deployConfig.importMap, ...importMapPaths], logger);
     const functions = await findFunctions(sourceDirectories);
     const functionBundle = await bundleESZIP({
         basePath,

package/dist/node/bundler.test.js

@@ -1,14 +1,15 @@
 import { promises as fs } from 'fs';
 import { join, resolve } from 'path';
 import process from 'process';
+import { pathToFileURL } from 'url';
 import { deleteAsync } from 'del';
 import tmp from 'tmp-promise';
-import { test, expect } from 'vitest';
+import { test, expect, vi } from 'vitest';
 import { importMapSpecifier } from '../shared/consts.js';
-import { useFixture } from '../test/util.js';
+import { runESZIP, useFixture } from '../test/util.js';
 import { BundleError } from './bundle_error.js';
 import { bundle } from './bundler.js';
-import { isNodeError } from './utils/error.js';
+import { isFileNotFoundError } from './utils/error.js';
 import { validateManifest } from './validation/manifest/index.js';
 test('Produces an ESZIP bundle', async () => {
     const { basePath, cleanup, distPath } = await useFixture('with_import_maps');
@@ -23,12 +24,10 @@ test('Produces an ESZIP bundle', async () => {
     const result = await bundle([userDirectory, internalDirectory], distPath, declarations, {
         basePath,
         configPath: join(internalDirectory, 'config.json'),
-        featureFlags: {
-            edge_functions_read_deno_config: true,
-        },
+        importMapPaths: [join(userDirectory, 'import_map.json')],
     });
     const generatedFiles = await fs.readdir(distPath);
-    expect(result.functions.length).toBe(2);
+    expect(result.functions.length).toBe(3);
     expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
@@ -38,6 +37,11 @@ test('Produces an ESZIP bundle', async () => {
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
     expect(importMapURL).toBe(importMapSpecifier);
+    const bundlePath = join(distPath, bundles[0].asset);
+    const { func1, func2, func3 } = await runESZIP(bundlePath);
+    expect(func1).toBe('HELLO, JANE DOE!');
+    expect(func2).toBe('Jane Doe');
+    expect(func3).toBe('hello, netlify!');
     await cleanup();
 });
 test('Uses the vendored eszip module instead of fetching it from deno.land', async () => {
@@ -218,7 +222,7 @@ test('Ignores any user-defined `deno.json` files', async () => {
         throw new Error(`The file at '${denoConfigPath} would be overwritten by this test. Please move the file to a different location and try again.'`);
     }
     catch (error) {
-        if (isNodeError(error) && error.code !== 'ENOENT') {
+        if (!isFileNotFoundError(error)) {
             throw error;
         }
     }
@@ -280,3 +284,38 @@ test('Loads declarations and import maps from the deploy configuration', async (
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
     await cleanup();
 });
+test("Ignores entries in `importMapPaths` that don't point to an existing import map file", async () => {
+    const systemLogger = vi.fn();
+    const { basePath, cleanup, distPath } = await useFixture('with_import_maps');
+    const sourceDirectory = join(basePath, 'user-functions');
+    // Creating import map file
+    const importMap = await tmp.file();
+    const importMapContents = {
+        imports: {
+            helper: pathToFileURL(join(basePath, 'helper.ts')).toString(),
+        },
+        scopes: {
+            [pathToFileURL(join(sourceDirectory, 'func3')).toString()]: {
+                helper: pathToFileURL(join(basePath, 'helper2.ts')).toString(),
+            },
+        },
+    };
+    await fs.writeFile(importMap.path, JSON.stringify(importMapContents));
+    const nonExistingImportMapPath = join(distPath, 'some-file-that-does-not-exist.json');
+    const result = await bundle([sourceDirectory], distPath, [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ], {
+        basePath,
+        importMapPaths: [nonExistingImportMapPath, importMap.path],
+        systemLogger,
+    });
+    const generatedFiles = await fs.readdir(distPath);
+    expect(result.functions.length).toBe(2);
+    expect(generatedFiles.length).toBe(2);
+    expect(systemLogger).toHaveBeenCalledWith(`Did not find an import map file at '${nonExistingImportMapPath}'.`);
+    await cleanup();
+    await importMap.cleanup();
+});

package/dist/node/deploy_config.d.ts

@@ -1,10 +1,9 @@
 import type { Declaration } from './declaration.js';
-import { ImportMapFile } from './import_map.js';
 import type { Layer } from './layer.js';
 import type { Logger } from './logger.js';
 export interface DeployConfig {
     declarations: Declaration[];
-    importMap?: ImportMapFile;
+    importMap?: string;
     layers: Layer[];
 }
 export declare const load: (path: string | undefined, logger: Logger) => Promise<DeployConfig>;

package/dist/node/deploy_config.js

@@ -1,7 +1,6 @@
 import { promises as fs } from 'fs';
 import { dirname, resolve } from 'path';
-import { readFile as readImportMap } from './import_map.js';
-import { isNodeError } from './utils/error.js';
+import { isFileNotFoundError } from './utils/error.js';
 export const load = async (path, logger) => {
     if (path === undefined) {
         return {
@@ -15,7 +14,7 @@ export const load = async (path, logger) => {
         return parse(config, path);
     }
     catch (error) {
-        if (isNodeError(error) && error.code !== 'ENOENT') {
+        if (!isFileNotFoundError(error)) {
             logger.system('Error while parsing internal edge functions manifest:', error);
         }
     }
@@ -24,7 +23,7 @@ export const load = async (path, logger) => {
         layers: [],
     };
 };
-const parse = async (data, path) => {
+const parse = (data, path) => {
     var _a, _b;
     if (data.version !== 1) {
         throw new Error(`Unsupported file version: ${data.version}`);
@@ -35,11 +34,7 @@ const parse = async (data, path) => {
     };
     if (data.import_map) {
         const importMapPath = resolve(dirname(path), data.import_map);
-        const importMap = await readImportMap(importMapPath);
-        return {
-            ...config,
-            importMap,
-        };
+        config.importMap = importMapPath;
     }
     return config;
 };

package/dist/node/deploy_config.test.js

@@ -1,7 +1,6 @@
 import { promises as fs } from 'fs';
 import { join } from 'path';
 import { cwd } from 'process';
-import { pathToFileURL } from 'url';
 import tmp from 'tmp-promise';
 import { test, expect } from 'vitest';
 import { load } from './deploy_config.js';
@@ -14,8 +13,7 @@ test('Returns an empty config object if there is no file at the given path', asy
     expect(config.layers).toEqual([]);
 });
 test('Returns a config object with declarations, layers, and import map', async () => {
-    var _a, _b;
-    const importMapFile = await tmp.file();
+    const importMapFile = await tmp.file({ postfix: '.json' });
     const importMap = {
         imports: {
             'https://deno.land/': 'https://black.hole/',
@@ -42,9 +40,8 @@ test('Returns a config object with declarations, layers, and import map', async
     };
     await fs.writeFile(configFile.path, JSON.stringify(config));
     const parsedConfig = await load(configFile.path, logger);
+    await importMapFile.cleanup();
     expect(parsedConfig.declarations).toEqual(config.functions);
     expect(parsedConfig.layers).toEqual(config.layers);
-    expect(parsedConfig.importMap).toBeTruthy();
-    expect((_a = parsedConfig.importMap) === null || _a === void 0 ? void 0 : _a.baseURL).toEqual(pathToFileURL(importMapFile.path));
-    expect((_b = parsedConfig.importMap) === null || _b === void 0 ? void 0 : _b.imports).toEqual(importMap.imports);
+    expect(parsedConfig.importMap).toBe(importMapFile.path);
 });

package/dist/node/feature_flags.js

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

package/dist/node/import_map.d.ts

@@ -1,22 +1,29 @@
-interface ImportMapFile {
+import { Logger } from './logger.js';
+type Imports = Record<string, string>;
+interface ImportMapSource {
     baseURL: URL;
-    imports: Record<string, string>;
-    scopes?: Record<string, Record<string, string>>;
+    imports: Imports;
+    scopes?: Record<string, Imports>;
 }
 declare class ImportMap {
-    files: ImportMapFile[];
-    constructor(files?: ImportMapFile[]);
-    static resolve(importMapFile: ImportMapFile, basePath?: string, prefix?: string): {
+    sources: ImportMapSource[];
+    constructor(sources?: ImportMapSource[]);
+    static resolve(source: ImportMapSource, basePath?: string, prefix?: string): {
         imports: Record<string, string>;
-        scopes?: import("@import-maps/resolve/types/src/types").ParsedScopesMap | undefined;
+        scopes: Record<string, Imports>;
     };
-    add(file: ImportMapFile): void;
+    static resolveImports(imports: Record<string, URL | null>, basePath?: string, prefix?: string): Record<string, string>;
+    static resolvePath(url: URL, basePath?: string, prefix?: string): string;
+    add(source: ImportMapSource): void;
+    addFile(path: string, logger: Logger): Promise<void>;
+    addFiles(paths: (string | undefined)[], logger: Logger): Promise<void>;
     getContents(basePath?: string, prefix?: string): {
-        imports: Record<string, string>;
+        imports: Imports;
+        scopes: Record<string, Imports>;
     };
     toDataURL(): string;
     writeToFile(path: string): Promise<void>;
 }
-declare const readFile: (path: string) => Promise<ImportMapFile>;
+declare const readFile: (path: string, logger: Logger) => Promise<ImportMapSource>;
 export { ImportMap, readFile };
-export type { ImportMapFile };
+export type { ImportMapSource as ImportMapFile };

package/dist/node/import_map.js

@@ -3,25 +3,37 @@ import { promises as fs } from 'fs';
 import { dirname, posix, relative, sep } from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { parse } from '@import-maps/resolve';
+import { isFileNotFoundError } from './utils/error.js';
 const INTERNAL_IMPORTS = {
     'netlify:edge': 'https://edge.netlify.com/v1/index.ts',
 };
 // ImportMap can take several import map files and merge them into a final
 // import map object, also adding the internal imports in the right order.
 class ImportMap {
-    constructor(files = []) {
-        this.files = [];
-        files.forEach((file) => {
+    constructor(sources = []) {
+        this.sources = [];
+        sources.forEach((file) => {
             this.add(file);
         });
     }
     // Transforms an import map by making any relative paths use a different path
     // as a base.
-    static resolve(importMapFile, basePath, prefix = 'file://') {
-        const { baseURL, ...importMap } = importMapFile;
+    static resolve(source, basePath, prefix = 'file://') {
+        const { baseURL, ...importMap } = source;
         const parsedImportMap = parse(importMap, baseURL);
-        const { imports = {} } = parsedImportMap;
-        const newImports = {};
+        const { imports = {}, scopes = {} } = parsedImportMap;
+        const resolvedImports = ImportMap.resolveImports(imports, basePath, prefix);
+        const resolvedScopes = {};
+        Object.keys(scopes).forEach((path) => {
+            const resolvedPath = ImportMap.resolvePath(new URL(path), basePath, prefix);
+            resolvedScopes[resolvedPath] = ImportMap.resolveImports(scopes[path], basePath, prefix);
+        });
+        return { ...parsedImportMap, imports: resolvedImports, scopes: resolvedScopes };
+    }
+    // Takes an imports object and resolves relative specifiers with a given base
+    // path and URL prefix.
+    static resolveImports(imports, basePath, prefix) {
+        const resolvedImports = {};
         Object.keys(imports).forEach((specifier) => {
             const url = imports[specifier];
             // If there's no URL, don't even add the specifier to the final imports.
@@ -29,37 +41,62 @@ class ImportMap {
                 return;
             }
             // If this is a file URL, we might want to transform it to use another
-            // base path, as long as one is provided.
-            if (url.protocol === 'file:' && basePath !== undefined) {
-                const path = fileURLToPath(url);
-                const relativePath = relative(basePath, path);
-                if (relativePath.startsWith('..')) {
-                    throw new Error(`Import map cannot reference '${path}' as it's outside of the base directory '${basePath}'`);
-                }
-                // We want to use POSIX paths for the import map regardless of the OS
-                // we're building in.
-                let normalizedPath = relativePath.split(sep).join(posix.sep);
-                // If the original URL had a trailing slash, ensure the normalized path
-                // has one too.
-                if (normalizedPath !== '' && url.pathname.endsWith(posix.sep) && !normalizedPath.endsWith(posix.sep)) {
-                    normalizedPath += posix.sep;
-                }
-                const newURL = new URL(normalizedPath, prefix);
-                newImports[specifier] = newURL.toString();
+            // base path.
+            if (url.protocol === 'file:') {
+                resolvedImports[specifier] = ImportMap.resolvePath(url, basePath, prefix);
                 return;
             }
-            newImports[specifier] = url.toString();
+            resolvedImports[specifier] = url.toString();
         });
-        return { ...parsedImportMap, imports: newImports };
+        return resolvedImports;
+    }
+    // Takes a URL, turns it into a path relative to the given base, and prepends
+    // a prefix (such as the virtual root prefix).
+    static resolvePath(url, basePath, prefix) {
+        if (basePath === undefined) {
+            return url.toString();
+        }
+        const path = fileURLToPath(url);
+        const relativePath = relative(basePath, path);
+        if (relativePath.startsWith('..')) {
+            throw new Error(`Import map cannot reference '${path}' as it's outside of the base directory '${basePath}'`);
+        }
+        // We want to use POSIX paths for the import map regardless of the OS
+        // we're building in.
+        let normalizedPath = relativePath.split(sep).join(posix.sep);
+        // If the original URL had a trailing slash, ensure the normalized path
+        // has one too.
+        if (normalizedPath !== '' && url.pathname.endsWith(posix.sep) && !normalizedPath.endsWith(posix.sep)) {
+            normalizedPath += posix.sep;
+        }
+        const newURL = new URL(normalizedPath, prefix);
+        return newURL.toString();
     }
-    add(file) {
-        this.files.push(file);
+    add(source) {
+        this.sources.push(source);
+    }
+    async addFile(path, logger) {
+        const source = await readFile(path, logger);
+        if (Object.keys(source.imports).length === 0) {
+            return;
+        }
+        return this.add(source);
+    }
+    async addFiles(paths, logger) {
+        for (const path of paths) {
+            if (path === undefined) {
+                continue;
+            }
+            await this.addFile(path, logger);
+        }
     }
     getContents(basePath, prefix) {
         let imports = {};
-        this.files.forEach((file) => {
+        let scopes = {};
+        this.sources.forEach((file) => {
             const importMap = ImportMap.resolve(file, basePath, prefix);
             imports = { ...imports, ...importMap.imports };
+            scopes = { ...scopes, ...importMap.scopes };
         });
         // Internal imports must come last, because we need to guarantee that
         // `netlify:edge` isn't user-defined.
@@ -69,6 +106,7 @@ class ImportMap {
         });
         return {
             imports,
+            scopes,
         };
     }
     toDataURL() {
@@ -83,7 +121,7 @@ class ImportMap {
         await fs.writeFile(path, JSON.stringify(contents));
     }
 }
-const readFile = async (path) => {
+const readFile = async (path, logger) => {
     const baseURL = pathToFileURL(path);
     try {
         const data = await fs.readFile(path, 'utf8');
@@ -93,8 +131,13 @@ const readFile = async (path) => {
             baseURL,
         };
     }
-    catch {
-        // no-op
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            logger.system(`Did not find an import map file at '${path}'.`);
+        }
+        else {
+            logger.user(`Error while loading import map at '${path}':`, error);
+        }
     }
     return {
         baseURL,

package/dist/node/server/server.d.ts

@@ -6,7 +6,6 @@
 import { OnAfterDownloadHook, OnBeforeDownloadHook } from '../bridge.js';
 import { FunctionConfig } from '../config.js';
 import type { EdgeFunction } from '../edge_function.js';
-import { ImportMapFile } from '../import_map.js';
 import { LogFunction } from '../logger.js';
 type FormatFunction = (name: string) => string;
 interface StartServerOptions {
@@ -18,12 +17,11 @@ interface InspectSettings {
     address?: string;
 }
 interface ServeOptions {
-    basePath: string;
     certificatePath?: string;
     debug?: boolean;
     distImportMapPath?: string;
     inspectSettings?: InspectSettings;
-    importMaps?: ImportMapFile[];
+    importMapPaths?: string[];
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
     formatExportTypeError?: FormatFunction;
@@ -31,7 +29,7 @@ interface ServeOptions {
     port: number;
     systemLogger?: LogFunction;
 }
-declare const serve: ({ basePath, certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMaps, onAfterDownload, onBeforeDownload, port, systemLogger, }: ServeOptions) => Promise<(functions: EdgeFunction[], env?: NodeJS.ProcessEnv, options?: StartServerOptions) => Promise<{
+declare const serve: ({ certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMapPaths, onAfterDownload, onBeforeDownload, port, systemLogger, }: ServeOptions) => Promise<(functions: EdgeFunction[], env?: NodeJS.ProcessEnv, options?: StartServerOptions) => Promise<{
     functionsConfig: FunctionConfig[];
     graph: any;
     success: boolean;

package/dist/node/server/server.js

@@ -1,9 +1,8 @@
 import { tmpName } from 'tmp-promise';
 import { DenoBridge } from '../bridge.js';
 import { getFunctionConfig } from '../config.js';
-import { getConfig as getDenoConfig } from '../deno_config.js';
 import { generateStage2 } from '../formats/javascript.js';
-import { ImportMap, readFile as readImportMapFile } from '../import_map.js';
+import { ImportMap } from '../import_map.js';
 import { getLogger } from '../logger.js';
 import { ensureLatestTypes } from '../types.js';
 import { killProcess, waitForServer } from './util.js';
@@ -54,7 +53,7 @@ const prepareServer = ({ deno, distDirectory, flags: denoFlags, formatExportType
     };
     return startServer;
 };
-const serve = async ({ basePath, certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMaps, onAfterDownload, onBeforeDownload, port, systemLogger, }) => {
+const serve = async ({ certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMapPaths = [], onAfterDownload, onBeforeDownload, port, systemLogger, }) => {
     const logger = getLogger(systemLogger, debug);
     const deno = new DenoBridge({
         debug,
@@ -69,17 +68,8 @@ const serve = async ({ basePath, certificatePath, debug, distImportMapPath, insp
     await deno.getBinaryPath();
     // Downloading latest types if needed.
     await ensureLatestTypes(deno, logger);
-    // Creating an ImportMap instance with any import maps supplied by the user,
-    // if any.
-    const importMap = new ImportMap(importMaps);
-    // Look for a Deno config file and read it if one exists.
-    const denoConfig = await getDenoConfig(logger, basePath);
-    // If the Deno config file defines an import map, read the file and add the
-    // imports to the global import map.
-    if (denoConfig === null || denoConfig === void 0 ? void 0 : denoConfig.importMap) {
-        const importMapFile = await readImportMapFile(denoConfig.importMap);
-        importMap.add(importMapFile);
-    }
+    const importMap = new ImportMap();
+    await importMap.addFiles(importMapPaths, logger);
     const flags = ['--allow-all', '--unstable', `--import-map=${importMap.toDataURL()}`, '--no-config'];
     if (certificatePath) {
         flags.push(`--cert=${certificatePath}`);

package/dist/node/server/server.test.js

@@ -1,5 +1,4 @@
 import { join } from 'path';
-import { pathToFileURL } from 'url';
 import getPort from 'get-port';
 import fetch from 'node-fetch';
 import { v4 as uuidv4 } from 'uuid';
@@ -8,30 +7,24 @@ import { fixturesDir } from '../../test/util.js';
 import { serve } from '../index.js';
 test('Starts a server and serves requests for edge functions', async () => {
     const basePath = join(fixturesDir, 'serve_test');
-    const functionPaths = {
-        internal: join(basePath, '.netlify', 'edge-functions', 'greet.ts'),
-        user: join(basePath, 'netlify', 'edge-functions', 'echo_env.ts'),
+    const paths = {
+        internal: join(basePath, '.netlify', 'edge-functions'),
+        user: join(basePath, 'netlify', 'edge-functions'),
     };
     const port = await getPort();
-    const internalImportMap = {
-        baseURL: pathToFileURL(functionPaths.internal),
-        imports: {
-            'internal-helper': '../../helper.ts',
-        },
-    };
+    const importMapPaths = [join(paths.internal, 'import_map.json'), join(paths.user, 'import-map.json')];
     const server = await serve({
-        basePath,
-        importMaps: [internalImportMap],
+        importMapPaths,
         port,
     });
     const functions = [
         {
             name: 'echo_env',
-            path: functionPaths.user,
+            path: join(paths.user, 'echo_env.ts'),
         },
         {
             name: 'greet',
-            path: functionPaths.internal,
+            path: join(paths.internal, 'greet.ts'),
         },
     ];
     const options = {
@@ -42,10 +35,10 @@ test('Starts a server and serves requests for edge functions', async () => {
     }, options);
     expect(success).toBe(true);
     expect(functionsConfig).toEqual([{ path: '/my-function' }, {}]);
-    for (const key in functionPaths) {
+    for (const key in functions) {
         const graphEntry = graph === null || graph === void 0 ? void 0 : graph.modules.some(
         // @ts-expect-error TODO: Module graph is currently not typed
-        ({ kind, mediaType, local }) => kind === 'esm' && mediaType === 'TypeScript' && local === functionPaths[key]);
+        ({ kind, mediaType, local }) => kind === 'esm' && mediaType === 'TypeScript' && local === functions[key].path);
         expect(graphEntry).toBe(true);
     }
     const response1 = await fetch(`http://0.0.0.0:${port}/foo`, {

package/dist/node/utils/error.d.ts

@@ -1,2 +1,3 @@
 /// <reference types="node" />
 export declare const isNodeError: (error: any) => error is NodeJS.ErrnoException;
+export declare const isFileNotFoundError: (error: any) => boolean;

package/dist/node/utils/error.js

@@ -1,2 +1,4 @@
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const isNodeError = (error) => error instanceof Error;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isFileNotFoundError = (error) => isNodeError(error) && error.code === 'ENOENT';

package/dist/test/util.d.ts

@@ -5,4 +5,5 @@ declare const useFixture: (fixtureName: string) => Promise<{
     cleanup: () => Promise<void>;
     distPath: string;
 }>;
-export { fixturesDir, testLogger, useFixture };
+declare const runESZIP: (eszipPath: string) => Promise<any>;
+export { fixturesDir, testLogger, runESZIP, useFixture };

package/dist/test/util.js

@@ -1,6 +1,8 @@
 import { promises as fs } from 'fs';
 import { join, resolve } from 'path';
-import { fileURLToPath } from 'url';
+import { stderr, stdout } from 'process';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { execa } from 'execa';
 import tmp from 'tmp-promise';
 import { getLogger } from '../node/logger.js';
 const testLogger = getLogger(() => {
@@ -10,14 +12,58 @@ const url = new URL(import.meta.url);
 const dirname = fileURLToPath(url);
 const fixturesDir = resolve(dirname, '..', 'fixtures');
 const useFixture = async (fixtureName) => {
-    const tmpDir = await tmp.dir();
-    const cleanup = () => fs.rmdir(tmpDir.path, { recursive: true });
+    const tmpDir = await tmp.dir({ unsafeCleanup: true });
     const fixtureDir = resolve(fixturesDir, fixtureName);
     const distPath = join(tmpDir.path, '.netlify', 'edge-functions-dist');
     return {
         basePath: fixtureDir,
-        cleanup,
+        cleanup: tmpDir.cleanup,
         distPath,
     };
 };
-export { fixturesDir, testLogger, useFixture };
+const inspectFunction = (path) => `
+  import { functions } from "${pathToFileURL(path)}.js";
+
+  const responses = {};
+
+  for (const functionName in functions) {
+    const req = new Request("https://test.netlify");
+    const res = await functions[functionName](req);
+
+    responses[functionName] = await res.text();
+  }
+  
+  console.log(JSON.stringify(responses));
+`;
+const runESZIP = async (eszipPath) => {
+    var _a, _b, _c;
+    const tmpDir = await tmp.dir({ unsafeCleanup: true });
+    // Extract ESZIP into temporary directory.
+    const extractCommand = execa('deno', [
+        'run',
+        '--allow-all',
+        'https://deno.land/x/eszip@v0.28.0/eszip.ts',
+        'x',
+        eszipPath,
+        tmpDir.path,
+    ]);
+    (_a = extractCommand.stderr) === null || _a === void 0 ? void 0 : _a.pipe(stderr);
+    (_b = extractCommand.stdout) === null || _b === void 0 ? void 0 : _b.pipe(stdout);
+    await extractCommand;
+    const virtualRootPath = join(tmpDir.path, 'source', 'root');
+    const stage2Path = join(virtualRootPath, '..', 'bootstrap-stage2');
+    const importMapPath = join(virtualRootPath, '..', 'import-map');
+    for (const path of [importMapPath, stage2Path]) {
+        const file = await fs.readFile(path, 'utf8');
+        const normalizedFile = file.replace(/file:\/\/\/root/g, pathToFileURL(virtualRootPath).toString());
+        await fs.writeFile(path, normalizedFile);
+    }
+    await fs.rename(stage2Path, `${stage2Path}.js`);
+    // Run function that imports the extracted stage 2 and invokes each function.
+    const evalCommand = execa('deno', ['eval', '--no-check', '--import-map', importMapPath, inspectFunction(stage2Path)]);
+    (_c = evalCommand.stderr) === null || _c === void 0 ? void 0 : _c.pipe(stderr);
+    const result = await evalCommand;
+    await tmpDir.cleanup();
+    return JSON.parse(result.stdout);
+};
+export { fixturesDir, testLogger, runESZIP, useFixture };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "6.1.0",
+  "version": "7.0.1",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",

package/dist/node/deno_config.d.ts

@@ -1,6 +0,0 @@
-import { Logger } from './logger.js';
-interface DenoConfigFile {
-    importMap?: string;
-}
-export declare const getConfig: (logger: Logger, basePath?: string) => Promise<DenoConfigFile | undefined>;
-export {};

package/dist/node/deno_config.js

@@ -1,43 +0,0 @@
-import { promises as fs } from 'fs';
-import { join, resolve } from 'path';
-import { parse as parseJSONC } from 'jsonc-parser';
-import { isNodeError } from './utils/error.js';
-const filenames = ['deno.json', 'deno.jsonc'];
-export const getConfig = async (logger, basePath) => {
-    if (basePath === undefined) {
-        logger.system('No base path specified, will not attempt to read Deno config');
-        return;
-    }
-    for (const filename of filenames) {
-        const candidatePath = join(basePath, filename);
-        const config = await getConfigFromFile(candidatePath);
-        if (config !== undefined) {
-            logger.system('Loaded Deno config file from path', candidatePath);
-            return normalizeConfig(config, basePath);
-        }
-    }
-    logger.system('No Deno config file found at base path', basePath);
-};
-const getConfigFromFile = async (filePath) => {
-    try {
-        const data = await fs.readFile(filePath, 'utf8');
-        const config = parseJSONC(data);
-        return config;
-    }
-    catch (error) {
-        if (isNodeError(error) && error.code === 'ENOENT') {
-            return;
-        }
-        return {};
-    }
-};
-const normalizeConfig = (rawConfig, basePath) => {
-    const config = {};
-    if (rawConfig.importMap) {
-        if (typeof rawConfig.importMap !== 'string') {
-            throw new TypeError(`'importMap' property in Deno config must be a string`);
-        }
-        config.importMap = resolve(basePath, rawConfig.importMap);
-    }
-    return config;
-};

package/dist/node/deno_config.test.d.ts

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

package/dist/node/deno_config.test.js

@@ -1,92 +0,0 @@
-import { promises as fs } from 'fs';
-import { join } from 'path';
-import tmp from 'tmp-promise';
-import { expect, test } from 'vitest';
-import { testLogger } from '../test/util.js';
-import { getConfig } from './deno_config.js';
-test('Returns `undefined` if no config file is found', async () => {
-    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
-    const config = await getConfig(testLogger, path);
-    expect(config).toBeUndefined();
-    await cleanup();
-});
-test('Returns an empty object if the config file cannot be parsed', async () => {
-    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
-    const configPath = join(path, 'deno.json');
-    await fs.writeFile(configPath, '{');
-    const config = await getConfig(testLogger, path);
-    expect(config).toEqual({});
-    await cleanup();
-});
-test('Throws a type error if the `importMap` contains anything other than a string', async () => {
-    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
-    const configPath = join(path, 'deno.json');
-    const data = JSON.stringify({ importMap: { imports: { foo: './bar/' } } });
-    await fs.writeFile(configPath, data);
-    await expect(getConfig(testLogger, path)).rejects.toThrowError(TypeError);
-    await cleanup();
-});
-test('Excludes unsupported properties', async () => {
-    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
-    const configPath = join(path, 'deno.json');
-    const data = JSON.stringify({
-        compilerOptions: {
-            allowJs: true,
-            lib: ['deno.window'],
-            strict: true,
-        },
-        importMap: 'import_map.json',
-        lint: {
-            files: {
-                include: ['src/'],
-                exclude: ['src/testdata/'],
-            },
-            rules: {
-                tags: ['recommended'],
-                include: ['ban-untagged-todo'],
-                exclude: ['no-unused-vars'],
-            },
-        },
-        fmt: {
-            files: {
-                include: ['src/'],
-                exclude: ['src/testdata/'],
-            },
-            options: {
-                useTabs: true,
-                lineWidth: 80,
-                indentWidth: 4,
-                singleQuote: true,
-                proseWrap: 'preserve',
-            },
-        },
-        test: {
-            files: {
-                include: ['src/'],
-                exclude: ['src/testdata/'],
-            },
-        },
-    });
-    await fs.writeFile(configPath, data);
-    const config = await getConfig(testLogger, path);
-    expect(Object.keys(config !== null && config !== void 0 ? config : {})).toEqual(['importMap']);
-    await cleanup();
-});
-test('Resolves `importMap` into an absolute path', async () => {
-    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
-    const configPath = join(path, 'deno.json');
-    const data = JSON.stringify({ importMap: 'import_map.json' });
-    await fs.writeFile(configPath, data);
-    const config = await getConfig(testLogger, path);
-    expect(config).toEqual({ importMap: join(path, 'import_map.json') });
-    await cleanup();
-});
-test('Supports JSONC', async () => {
-    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
-    const configPath = join(path, 'deno.jsonc');
-    const data = JSON.stringify({ importMap: 'import_map.json' });
-    await fs.writeFile(configPath, `// This is a comment\n${data}`);
-    const config = await getConfig(testLogger, path);
-    expect(config).toEqual({ importMap: join(path, 'import_map.json') });
-    await cleanup();
-});