@netlify/edge-bundler 5.2.0 → 5.3.0

package/deno/lib/stage2.ts

@@ -3,7 +3,8 @@ 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 '../../shared/stage2.ts'
-import { PUBLIC_SPECIFIER, STAGE2_SPECIFIER, virtualRoot } from './consts.ts'
+import { virtualRoot } from '../../shared/consts.ts'
+import { PUBLIC_SPECIFIER, STAGE2_SPECIFIER } from './consts.ts'
 import { inlineModule, loadFromVirtualRoot, loadWithRetry } from './common.ts'
 
 interface FunctionReference {

package/dist/node/bundle.d.ts

@@ -6,4 +6,5 @@ export interface Bundle {
     extension: string;
     format: BundleFormat;
     hash: string;
+    importMapURL?: string;
 }

package/dist/node/bundler.js

@@ -76,6 +76,7 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
         declarations,
         distDirectory,
         functions,
+        importMapURL: functionBundle.importMapURL,
         layers: deployConfig.layers,
     });
     if (distImportMapPath) {

package/dist/node/bundler.test.js

@@ -4,62 +4,65 @@ import process from 'process';
 import { deleteAsync } from 'del';
 import tmp from 'tmp-promise';
 import { test, expect } from 'vitest';
-import { fixturesDir } from '../test/util.js';
+import { useFixture } from '../test/util.js';
 import { BundleError } from './bundle_error.js';
 import { bundle } from './bundler.js';
 import { isNodeError } from './utils/error.js';
 test('Produces an ESZIP bundle', async () => {
-    const sourceDirectory = resolve(fixturesDir, 'with_import_maps', 'functions');
-    const tmpDir = await tmp.dir();
+    const { basePath, cleanup, distPath } = await useFixture('with_import_maps');
     const declarations = [
         {
             function: 'func1',
             path: '/func1',
         },
     ];
-    const result = await bundle([sourceDirectory], tmpDir.path, declarations, {
-        basePath: fixturesDir,
+    const sourceDirectory = join(basePath, 'functions');
+    const result = await bundle([sourceDirectory], distPath, declarations, {
+        basePath,
         configPath: join(sourceDirectory, 'config.json'),
     });
-    const generatedFiles = await fs.readdir(tmpDir.path);
+    const generatedFiles = await fs.readdir(distPath);
     expect(result.functions.length).toBe(1);
-    expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(tmpDir.path, 'manifest.json'), 'utf8');
+    // ESZIP, manifest and import map.
+    expect(generatedFiles.length).toBe(3);
+    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
-    const { bundles } = manifest;
+    const { bundles, import_map: importMapURL } = manifest;
     expect(bundles.length).toBe(1);
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
-    await fs.rmdir(tmpDir.path, { recursive: true });
+    expect(importMapURL).toBe('file:///root/.netlify/edge-functions-dist/import_map.json');
+    await cleanup();
 });
 test('Uses the vendored eszip module instead of fetching it from deno.land', async () => {
-    const sourceDirectory = resolve(fixturesDir, 'with_import_maps', 'functions');
-    const tmpDir = await tmp.dir();
+    const { basePath, cleanup, distPath } = await useFixture('with_import_maps');
     const declarations = [
         {
             function: 'func1',
             path: '/func1',
         },
     ];
-    const result = await bundle([sourceDirectory], tmpDir.path, declarations, {
-        basePath: fixturesDir,
+    const sourceDirectory = join(basePath, 'functions');
+    const result = await bundle([sourceDirectory], distPath, declarations, {
+        basePath,
         configPath: join(sourceDirectory, 'config.json'),
     });
-    const generatedFiles = await fs.readdir(tmpDir.path);
+    const generatedFiles = await fs.readdir(distPath);
     expect(result.functions.length).toBe(1);
-    expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(tmpDir.path, 'manifest.json'), 'utf8');
+    // ESZIP, manifest and import map.
+    expect(generatedFiles.length).toBe(3);
+    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles } = manifest;
     expect(bundles.length).toBe(1);
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
-    await fs.rmdir(tmpDir.path, { recursive: true });
+    await cleanup();
 });
 test('Adds a custom error property to user errors during bundling', async () => {
     expect.assertions(2);
-    const sourceDirectory = resolve(fixturesDir, 'invalid_functions', 'functions');
-    const tmpDir = await tmp.dir();
+    const { basePath, cleanup, distPath } = await useFixture('invalid_functions');
+    const sourceDirectory = join(basePath, 'functions');
     const declarations = [
         {
             function: 'func1',
@@ -67,7 +70,7 @@ test('Adds a custom error property to user errors during bundling', async () =>
         },
     ];
     try {
-        await bundle([sourceDirectory], tmpDir.path, declarations);
+        await bundle([sourceDirectory], distPath, declarations, { basePath });
     }
     catch (error) {
         expect(error).toBeInstanceOf(BundleError);
@@ -79,11 +82,14 @@ test('Adds a custom error property to user errors during bundling', async () =>
             type: 'functionsBundling',
         });
     }
+    finally {
+        await cleanup();
+    }
 });
 test('Prints a nice error message when user tries importing NPM module', async () => {
     expect.assertions(2);
-    const sourceDirectory = resolve(fixturesDir, 'imports_npm_module', 'functions');
-    const tmpDir = await tmp.dir();
+    const { basePath, cleanup, distPath } = await useFixture('imports_npm_module');
+    const sourceDirectory = join(basePath, 'functions');
     const declarations = [
         {
             function: 'func1',
@@ -91,18 +97,21 @@ test('Prints a nice error message when user tries importing NPM module', async (
         },
     ];
     try {
-        await bundle([sourceDirectory], tmpDir.path, declarations);
+        await bundle([sourceDirectory], distPath, declarations, { basePath });
     }
     catch (error) {
         expect(error).toBeInstanceOf(BundleError);
         expect(error.message).toEqual(`It seems like you're trying to import an npm module. This is only supported in Deno via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/p-retry"'?`);
     }
+    finally {
+        await cleanup();
+    }
 });
 test('Does not add a custom error property to system errors during bundling', async () => {
     expect.assertions(1);
     try {
         // @ts-expect-error Sending bad input to `bundle` to force a system error.
-        await bundle([123, 321], tmpDir.path, declarations);
+        await bundle([123, 321], '/some/directory', declarations);
     }
     catch (error) {
         expect(error).not.toBeInstanceOf(BundleError);
@@ -110,8 +119,8 @@ test('Does not add a custom error property to system errors during bundling', as
 });
 test('Uses the cache directory as the `DENO_DIR` value if the `edge_functions_cache_deno_dir` feature flag is set', async () => {
     expect.assertions(6);
-    const sourceDirectory = resolve(fixturesDir, 'with_import_maps', 'functions');
-    const outDir = await tmp.dir();
+    const { basePath, cleanup, distPath } = await useFixture('with_import_maps');
+    const sourceDirectory = join(basePath, 'functions');
     const cacheDir = await tmp.dir();
     const declarations = [
         {
@@ -120,15 +129,16 @@ test('Uses the cache directory as the `DENO_DIR` value if the `edge_functions_ca
         },
     ];
     const options = {
-        basePath: fixturesDir,
+        basePath,
         cacheDirectory: cacheDir.path,
         configPath: join(sourceDirectory, 'config.json'),
     };
     // Run #1, feature flag off: The directory should not be populated.
-    const result1 = await bundle([sourceDirectory], outDir.path, declarations, options);
-    const outFiles1 = await fs.readdir(outDir.path);
+    const result1 = await bundle([sourceDirectory], distPath, declarations, options);
+    const outFiles1 = await fs.readdir(distPath);
     expect(result1.functions.length).toBe(1);
-    expect(outFiles1.length).toBe(2);
+    // ESZIP, manifest and import map.
+    expect(outFiles1.length).toBe(3);
     try {
         await fs.readdir(join(cacheDir.path, 'deno_dir'));
     }
@@ -136,46 +146,48 @@ test('Uses the cache directory as the `DENO_DIR` value if the `edge_functions_ca
         expect(error).toBeInstanceOf(Error);
     }
     // Run #2, feature flag on: The directory should be populated.
-    const result2 = await bundle([sourceDirectory], outDir.path, declarations, {
+    const result2 = await bundle([sourceDirectory], distPath, declarations, {
         ...options,
         featureFlags: {
             edge_functions_cache_deno_dir: true,
         },
     });
-    const outFiles2 = await fs.readdir(outDir.path);
+    const outFiles2 = await fs.readdir(distPath);
     expect(result2.functions.length).toBe(1);
-    expect(outFiles2.length).toBe(2);
+    // ESZIP, manifest and import map.
+    expect(outFiles2.length).toBe(3);
     const denoDir2 = await fs.readdir(join(cacheDir.path, 'deno_dir'));
     expect(denoDir2.includes('gen')).toBe(true);
-    await fs.rmdir(outDir.path, { recursive: true });
+    await cleanup();
 });
 test('Supports import maps with relative paths', async () => {
-    const sourceDirectory = resolve(fixturesDir, 'with_import_maps', 'functions');
-    const tmpDir = await tmp.dir();
+    const { basePath, cleanup, distPath } = await useFixture('with_import_maps');
+    const sourceDirectory = join(basePath, 'functions');
     const declarations = [
         {
             function: 'func1',
             path: '/func1',
         },
     ];
-    const result = await bundle([sourceDirectory], tmpDir.path, declarations, {
-        basePath: fixturesDir,
+    const result = await bundle([sourceDirectory], distPath, declarations, {
+        basePath,
         configPath: join(sourceDirectory, 'config.json'),
     });
-    const generatedFiles = await fs.readdir(tmpDir.path);
+    const generatedFiles = await fs.readdir(distPath);
     expect(result.functions.length).toBe(1);
-    expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(tmpDir.path, 'manifest.json'), 'utf8');
+    // ESZIP, manifest and import map.
+    expect(generatedFiles.length).toBe(3);
+    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles } = manifest;
     expect(bundles.length).toBe(1);
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
-    await fs.rmdir(tmpDir.path, { recursive: true });
+    await cleanup();
 });
 test('Ignores any user-defined `deno.json` files', async () => {
-    const fixtureDir = join(fixturesDir, 'with_import_maps');
-    const tmpDir = await tmp.dir();
+    const { basePath, cleanup, distPath } = await useFixture('with_import_maps');
+    const sourceDirectory = join(basePath, 'functions');
     const declarations = [
         {
             function: 'func1',
@@ -209,15 +221,16 @@ test('Ignores any user-defined `deno.json` files', async () => {
         }
     }
     await fs.writeFile(denoConfigPath, JSON.stringify(denoConfig));
-    expect(() => bundle([join(fixtureDir, 'functions')], tmpDir.path, declarations, {
-        basePath: fixturesDir,
-        configPath: join(fixtureDir, 'functions', 'config.json'),
+    expect(() => bundle([sourceDirectory], distPath, declarations, {
+        basePath,
+        configPath: join(sourceDirectory, 'config.json'),
     })).not.toThrow();
-    await deleteAsync([tmpDir.path, denoConfigPath, importMapFile.path], { force: true });
+    await cleanup();
+    await deleteAsync([denoConfigPath, importMapFile.path], { force: true });
 });
 test('Processes a function that imports a custom layer', async () => {
-    const sourceDirectory = resolve(fixturesDir, 'with_layers', 'functions');
-    const tmpDir = await tmp.dir();
+    const { basePath, cleanup, distPath } = await useFixture('with_layers');
+    const sourceDirectory = join(basePath, 'functions');
     const declarations = [
         {
             function: 'func1',
@@ -225,44 +238,45 @@ test('Processes a function that imports a custom layer', async () => {
         },
     ];
     const layer = { name: 'layer:test', flag: 'edge-functions-layer-test' };
-    const result = await bundle([sourceDirectory], tmpDir.path, declarations, {
-        basePath: fixturesDir,
+    const result = await bundle([sourceDirectory], distPath, declarations, {
+        basePath,
         configPath: join(sourceDirectory, 'config.json'),
     });
-    const generatedFiles = await fs.readdir(tmpDir.path);
+    const generatedFiles = await fs.readdir(distPath);
     expect(result.functions.length).toBe(1);
-    expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(tmpDir.path, 'manifest.json'), 'utf8');
+    // ESZIP, manifest and import map.
+    expect(generatedFiles.length).toBe(3);
+    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles, layers } = manifest;
     expect(bundles.length).toBe(1);
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
     expect(layers).toEqual([layer]);
-    await fs.rmdir(tmpDir.path, { recursive: true });
+    await cleanup();
 });
 test('Loads declarations and import maps from the deploy configuration', async () => {
-    const fixtureDir = resolve(fixturesDir, 'with_deploy_config');
-    const tmpDir = await tmp.dir();
+    const { basePath, cleanup, distPath } = await useFixture('with_deploy_config');
     const declarations = [
         {
             function: 'func1',
             path: '/func1',
         },
     ];
-    const directories = [join(fixtureDir, 'netlify', 'edge-functions'), join(fixtureDir, '.netlify', 'edge-functions')];
-    const result = await bundle(directories, tmpDir.path, declarations, {
-        basePath: fixtureDir,
-        configPath: join(fixtureDir, '.netlify', 'edge-functions', 'config.json'),
+    const directories = [join(basePath, 'netlify', 'edge-functions'), join(basePath, '.netlify', 'edge-functions')];
+    const result = await bundle(directories, distPath, declarations, {
+        basePath,
+        configPath: join(basePath, '.netlify', 'edge-functions', 'config.json'),
     });
-    const generatedFiles = await fs.readdir(tmpDir.path);
+    const generatedFiles = await fs.readdir(distPath);
     expect(result.functions.length).toBe(2);
-    expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(tmpDir.path, 'manifest.json'), 'utf8');
+    // ESZIP, manifest and import map.
+    expect(generatedFiles.length).toBe(3);
+    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles } = manifest;
     expect(bundles.length).toBe(1);
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
-    await fs.rmdir(tmpDir.path, { recursive: true });
+    await cleanup();
 });

package/dist/node/config.d.ts

@@ -8,6 +8,6 @@ export declare const enum Cache {
 }
 export interface FunctionConfig {
     cache?: Cache;
-    path?: string;
+    path?: string | string[];
 }
 export declare const getFunctionConfig: (func: EdgeFunction, importMap: ImportMap, deno: DenoBridge, log: Logger) => Promise<FunctionConfig>;

package/dist/node/config.test.js

@@ -4,7 +4,7 @@ import { pathToFileURL } from 'url';
 import { deleteAsync } from 'del';
 import tmp from 'tmp-promise';
 import { test, expect, vi } from 'vitest';
-import { fixturesDir } from '../test/util.js';
+import { fixturesDir, useFixture } from '../test/util.js';
 import { DenoBridge } from './bridge.js';
 import { bundle } from './bundler.js';
 import { getFunctionConfig } from './config.js';
@@ -121,30 +121,31 @@ test('`getFunctionConfig` extracts configuration properties from function file',
     await deleteAsync(tmpDir, { force: true });
 });
 test('Ignores function paths from the in-source `config` function if the feature flag is off', async () => {
-    const userDirectory = resolve(fixturesDir, 'with_config', 'netlify', 'edge-functions');
-    const internalDirectory = resolve(fixturesDir, 'with_config', '.netlify', 'edge-functions');
-    const tmpDir = await tmp.dir();
+    const { basePath, cleanup, distPath } = await useFixture('with_config');
+    const userDirectory = resolve(basePath, 'netlify', 'edge-functions');
+    const internalDirectory = resolve(basePath, '.netlify', 'edge-functions');
     const declarations = [];
-    const result = await bundle([internalDirectory, userDirectory], tmpDir.path, declarations, {
-        basePath: fixturesDir,
+    const result = await bundle([internalDirectory, userDirectory], distPath, declarations, {
+        basePath,
         configPath: join(internalDirectory, 'config.json'),
     });
-    const generatedFiles = await fs.readdir(tmpDir.path);
+    const generatedFiles = await fs.readdir(distPath);
     expect(result.functions.length).toBe(6);
-    expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(tmpDir.path, 'manifest.json'), 'utf8');
+    // ESZIP, manifest and import map.
+    expect(generatedFiles.length).toBe(3);
+    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles, routes } = manifest;
     expect(bundles.length).toBe(1);
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
     expect(routes.length).toBe(0);
-    await fs.rmdir(tmpDir.path, { recursive: true });
+    await cleanup();
 });
 test('Loads function paths from the in-source `config` function', async () => {
-    const userDirectory = resolve(fixturesDir, 'with_config', 'netlify', 'edge-functions');
-    const internalDirectory = resolve(fixturesDir, 'with_config', '.netlify', 'edge-functions');
-    const tmpDir = await tmp.dir();
+    const { basePath, cleanup, distPath } = await useFixture('with_config');
+    const userDirectory = resolve(basePath, 'netlify', 'edge-functions');
+    const internalDirectory = resolve(basePath, '.netlify', 'edge-functions');
     const declarations = [
         {
             function: 'framework-func2',
@@ -155,17 +156,18 @@ test('Loads function paths from the in-source `config` function', async () => {
             path: '/user-func2',
         },
     ];
-    const result = await bundle([internalDirectory, userDirectory], tmpDir.path, declarations, {
-        basePath: fixturesDir,
+    const result = await bundle([internalDirectory, userDirectory], distPath, declarations, {
+        basePath,
         configPath: join(internalDirectory, 'config.json'),
         featureFlags: {
             edge_functions_config_export: true,
         },
     });
-    const generatedFiles = await fs.readdir(tmpDir.path);
+    const generatedFiles = await fs.readdir(distPath);
     expect(result.functions.length).toBe(6);
-    expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(tmpDir.path, 'manifest.json'), 'utf8');
+    // ESZIP, manifest and import map.
+    expect(generatedFiles.length).toBe(3);
+    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles, routes, post_cache_routes: postCacheRoutes } = manifest;
     expect(bundles.length).toBe(1);
@@ -179,7 +181,7 @@ test('Loads function paths from the in-source `config` function', async () => {
     expect(routes[4]).toEqual({ function: 'user-func3', pattern: '^/user-func3/?$' });
     expect(postCacheRoutes.length).toBe(1);
     expect(postCacheRoutes[0]).toEqual({ function: 'user-func4', pattern: '^/user-func4/?$' });
-    await fs.rmdir(tmpDir.path, { recursive: true });
+    await cleanup();
 });
 test('Passes validation if default export exists and is a function', async () => {
     const { path: tmpDir } = await tmp.dir();

package/dist/node/declaration.js

@@ -7,16 +7,38 @@ export const getDeclarationsFromConfig = (tomlDeclarations, functionsConfig, dep
     // a function configuration object, we replace the path because that object
     // takes precedence.
     for (const declaration of [...tomlDeclarations, ...deployConfig.declarations]) {
-        const config = (_a = functionsConfig[declaration.function]) !== null && _a !== void 0 ? _a : {};
+        const config = functionsConfig[declaration.function];
+        // If no config is found, add the declaration as is
+        if (!config) {
+            declarations.push(declaration);
+            // If we have a path specified as either a string or non-empty array
+            // create a declaration for each path
+        }
+        else if ((_a = config.path) === null || _a === void 0 ? void 0 : _a.length) {
+            const paths = Array.isArray(config.path) ? config.path : [config.path];
+            paths.forEach((path) => {
+                declarations.push({ ...declaration, ...config, path });
+            });
+            // With an in-source config without a path, add the config to the declaration
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { path, ...rest } = config;
+            declarations.push({ ...declaration, ...rest });
+        }
         functionsVisited.add(declaration.function);
-        declarations.push({ ...declaration, ...config });
     }
     // Finally, we must create declarations for functions that are not declared
     // in the TOML at all.
     for (const name in functionsConfig) {
-        const { path, ...config } = functionsConfig[name];
+        const { ...config } = functionsConfig[name];
+        const { path } = functionsConfig[name];
+        // If we have path specified create a declaration for each path
         if (!functionsVisited.has(name) && path) {
-            declarations.push({ ...config, function: name, path });
+            const paths = Array.isArray(path) ? path : [path];
+            paths.forEach((singlePath) => {
+                declarations.push({ ...config, function: name, path: singlePath });
+            });
         }
     }
     return declarations;

package/dist/node/declaration.test.js

@@ -5,29 +5,30 @@ const deployConfig = {
     declarations: [],
     layers: [],
 };
-test('In source config takes precedence over netlify.toml config', () => {
+test('In-source config takes precedence over netlify.toml config', () => {
     const tomlConfig = [
         { function: 'geolocation', path: '/geo', cache: 'off' },
         { function: 'json', path: '/json', cache: 'manual' },
     ];
     const funcConfig = {
-        geolocation: { path: '/geo-isc', cache: 'manual' },
+        geolocation: { path: ['/geo-isc', '/*'], cache: 'manual' },
         json: { path: '/json', cache: 'off' },
     };
     const expectedDeclarations = [
         { function: 'geolocation', path: '/geo-isc', cache: 'manual' },
+        { function: 'geolocation', path: '/*', cache: 'manual' },
         { function: 'json', path: '/json', cache: 'off' },
     ];
     const declarations = getDeclarationsFromConfig(tomlConfig, funcConfig, deployConfig);
     expect(declarations).toEqual(expectedDeclarations);
 });
-test("Declarations don't break if no in source config is provided", () => {
+test("Declarations don't break if no in-source config is provided", () => {
     const tomlConfig = [
         { function: 'geolocation', path: '/geo', cache: 'off' },
         { function: 'json', path: '/json', cache: 'manual' },
     ];
     const funcConfig = {
-        geolocation: { path: '/geo-isc', cache: 'manual' },
+        geolocation: { path: ['/geo-isc'], cache: 'manual' },
         json: {},
     };
     const expectedDeclarations = [
@@ -37,10 +38,10 @@ test("Declarations don't break if no in source config is provided", () => {
     const declarations = getDeclarationsFromConfig(tomlConfig, funcConfig, deployConfig);
     expect(declarations).toEqual(expectedDeclarations);
 });
-test('In source config works independent of the netlify.toml file if a path is defined and otherwise if no path is set', () => {
+test('In-source config works independent of the netlify.toml file if a path is defined and otherwise if no path is set', () => {
     const tomlConfig = [{ function: 'geolocation', path: '/geo', cache: 'off' }];
     const funcConfigWithPath = {
-        json: { path: '/json', cache: 'off' },
+        json: { path: ['/json', '/json-isc'], cache: 'off' },
     };
     const funcConfigWithoutPath = {
         json: { cache: 'off' },
@@ -48,6 +49,7 @@ test('In source config works independent of the netlify.toml file if a path is d
     const expectedDeclarationsWithISCPath = [
         { function: 'geolocation', path: '/geo', cache: 'off' },
         { function: 'json', path: '/json', cache: 'off' },
+        { function: 'json', path: '/json-isc', cache: 'off' },
     ];
     const expectedDeclarationsWithoutISCPath = [{ function: 'geolocation', path: '/geo', cache: 'off' }];
     const declarationsWithISCPath = getDeclarationsFromConfig(tomlConfig, funcConfigWithPath, deployConfig);
@@ -55,3 +57,38 @@ test('In source config works independent of the netlify.toml file if a path is d
     const declarationsWithoutISCPath = getDeclarationsFromConfig(tomlConfig, funcConfigWithoutPath, deployConfig);
     expect(declarationsWithoutISCPath).toEqual(expectedDeclarationsWithoutISCPath);
 });
+test('In-source config works if only the cache config property is set', () => {
+    const tomlConfig = [{ function: 'geolocation', path: '/geo', cache: 'off' }];
+    const funcConfig = {
+        geolocation: { cache: 'manual' },
+    };
+    const expectedDeclarations = [{ function: 'geolocation', path: '/geo', cache: 'manual' }];
+    expect(getDeclarationsFromConfig(tomlConfig, funcConfig, deployConfig)).toEqual(expectedDeclarations);
+});
+test("In-source config path property works if it's not an array", () => {
+    const tomlConfig = [{ function: 'json', path: '/json-toml', cache: 'off' }];
+    const funcConfig = {
+        json: { path: '/json', cache: 'manual' },
+    };
+    const expectedDeclarations = [{ function: 'json', path: '/json', cache: 'manual' }];
+    expect(getDeclarationsFromConfig(tomlConfig, funcConfig, deployConfig)).toEqual(expectedDeclarations);
+});
+test("In-source config path property works if it's not an array and it's not present in toml or deploy config", () => {
+    const tomlConfig = [{ function: 'geolocation', path: '/geo', cache: 'off' }];
+    const funcConfig = {
+        json: { path: '/json-isc', cache: 'manual' },
+    };
+    const expectedDeclarations = [
+        { function: 'geolocation', path: '/geo', cache: 'off' },
+        { function: 'json', path: '/json-isc', cache: 'manual' },
+    ];
+    expect(getDeclarationsFromConfig(tomlConfig, funcConfig, deployConfig)).toEqual(expectedDeclarations);
+});
+test('In-source config works if path property is an empty array with cache value specified', () => {
+    const tomlConfig = [{ function: 'json', path: '/json-toml', cache: 'off' }];
+    const funcConfig = {
+        json: { path: [], cache: 'manual' },
+    };
+    const expectedDeclarations = [{ function: 'json', path: '/json-toml', cache: 'manual' }];
+    expect(getDeclarationsFromConfig(tomlConfig, funcConfig, deployConfig)).toEqual(expectedDeclarations);
+});

package/dist/node/formats/eszip.js

@@ -1,4 +1,5 @@
-import { join } from 'path';
+import { join, relative } from 'path';
+import { virtualRoot } from '../../shared/consts.js';
 import { BundleFormat } from '../bundle.js';
 import { wrapBundleError } from '../bundle_error.js';
 import { wrapNpmImportError } from '../npm_import_error.js';
@@ -8,20 +9,18 @@ const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, exte
     const extension = '.eszip';
     const destPath = join(distDirectory, `${buildID}${extension}`);
     const { bundler, importMap: bundlerImportMap } = getESZIPPaths();
+    const importMapURL = await createUserImportMap(importMap, basePath, distDirectory);
     const payload = {
         basePath,
         destPath,
         externals,
         functions,
-        importMapURL: importMap.toDataURL(),
+        importMapURL,
     };
-    const flags = ['--allow-all', '--no-config'];
+    const flags = ['--allow-all', '--no-config', `--import-map=${bundlerImportMap}`];
     if (!debug) {
         flags.push('--quiet');
     }
-    // To actually vendor the eszip module, we need to supply the import map that
-    // redirects `https://deno.land/` URLs to the local files.
-    flags.push(`--import-map=${bundlerImportMap}`);
     try {
         await deno.run(['run', ...flags, bundler, JSON.stringify(payload)], { pipeOutput: true });
     }
@@ -29,7 +28,16 @@ const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, exte
         throw wrapBundleError(wrapNpmImportError(error), { format: 'eszip' });
     }
     const hash = await getFileHash(destPath);
-    return { extension, format: BundleFormat.ESZIP2, hash };
+    return { extension, format: BundleFormat.ESZIP2, hash, importMapURL };
+};
+// Takes an import map, writes it to a file on disk, and gets its URL relative
+// to the ESZIP root (i.e. using the virtual root prefix).
+const createUserImportMap = async (importMap, basePath, distDirectory) => {
+    const destPath = join(distDirectory, 'import_map.json');
+    await importMap.writeToFile(destPath);
+    const relativePath = relative(basePath, destPath);
+    const importMapURL = new URL(relativePath, virtualRoot);
+    return importMapURL.toString();
 };
 const getESZIPPaths = () => {
     const denoPath = join(getPackagePath(), 'deno');

package/dist/node/import_map.d.ts

@@ -6,9 +6,12 @@ interface ImportMapFile {
 declare class ImportMap {
     files: ImportMapFile[];
     constructor(files?: ImportMapFile[]);
-    static resolve(importMapFile: ImportMapFile): import("@import-maps/resolve/types/src/types").ParsedImportMap;
+    static resolve(importMapFile: ImportMapFile, rootPath?: string): {
+        imports: Record<string, string>;
+        scopes?: import("@import-maps/resolve/types/src/types").ParsedScopesMap | undefined;
+    };
     add(file: ImportMapFile): void;
-    getContents(): string;
+    getContents(rootPath?: string): string;
     toDataURL(): string;
     writeToFile(path: string): Promise<void>;
 }

package/dist/node/import_map.js

@@ -1,10 +1,10 @@
 import { Buffer } from 'buffer';
 import { promises as fs } from 'fs';
-import { dirname } from 'path';
-import { pathToFileURL } from 'url';
+import { dirname, isAbsolute, posix, relative, sep } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
 import { parse } from '@import-maps/resolve';
 const INTERNAL_IMPORTS = {
-    'netlify:edge': new URL('https://edge.netlify.com/v1/index.ts'),
+    '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.
@@ -15,18 +15,40 @@ class ImportMap {
             this.add(file);
         });
     }
-    static resolve(importMapFile) {
+    // Transforms an import map by making any relative paths use a different path
+    // as a base.
+    static resolve(importMapFile, rootPath) {
         const { baseURL, ...importMap } = importMapFile;
         const parsedImportMap = parse(importMap, baseURL);
-        return parsedImportMap;
+        const { imports = {} } = parsedImportMap;
+        const newImports = {};
+        Object.keys(imports).forEach((specifier) => {
+            const url = imports[specifier];
+            // If there's no URL, don't even add the specifier to the final imports.
+            if (url === null) {
+                return;
+            }
+            // If this is a file URL, we might want to transform it to use another
+            // root path, as long as that root path is defined.
+            if (url.protocol === 'file:' && rootPath !== undefined) {
+                // We want to use POSIX paths for the import map regardless of the OS
+                // we're building in.
+                const path = relative(rootPath, fileURLToPath(url)).split(sep).join(posix.sep);
+                const value = isAbsolute(path) ? path : `.${posix.sep}${path}`;
+                newImports[specifier] = value;
+                return;
+            }
+            newImports[specifier] = url.toString();
+        });
+        return { ...parsedImportMap, imports: newImports };
     }
     add(file) {
         this.files.push(file);
     }
-    getContents() {
+    getContents(rootPath) {
         let imports = {};
         this.files.forEach((file) => {
-            const importMap = ImportMap.resolve(file);
+            const importMap = ImportMap.resolve(file, rootPath);
             imports = { ...imports, ...importMap.imports };
         });
         // Internal imports must come last, because we need to guarantee that
@@ -45,8 +67,9 @@ class ImportMap {
         return `data:application/json;base64,${encodedImportMap}`;
     }
     async writeToFile(path) {
-        await fs.mkdir(dirname(path), { recursive: true });
-        const contents = this.getContents();
+        const distDirectory = dirname(path);
+        await fs.mkdir(distDirectory, { recursive: true });
+        const contents = this.getContents(distDirectory);
         await fs.writeFile(path, contents);
     }
 }

package/dist/node/import_map.test.js

@@ -1,14 +1,18 @@
+import { join } from 'path';
+import { cwd } from 'process';
+import { pathToFileURL } from 'url';
 import { test, expect } from 'vitest';
 import { ImportMap } from './import_map.js';
 test('Handles import maps with full URLs without specifying a base URL', () => {
+    const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
     const inputFile1 = {
-        baseURL: new URL('file:///some/path/import-map.json'),
+        baseURL: pathToFileURL(basePath),
         imports: {
             'alias:jamstack': 'https://jamstack.org',
         },
     };
     const inputFile2 = {
-        baseURL: new URL('file:///some/path/import-map.json'),
+        baseURL: pathToFileURL(basePath),
         imports: {
             'alias:pets': 'https://petsofnetlify.com/',
         },
@@ -19,15 +23,30 @@ test('Handles import maps with full URLs without specifying a base URL', () => {
     expect(imports['alias:jamstack']).toBe('https://jamstack.org/');
     expect(imports['alias:pets']).toBe('https://petsofnetlify.com/');
 });
-test('Handles import maps with relative paths', () => {
+test('Resolves relative paths to absolute paths if a root path is not provided', () => {
+    const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
     const inputFile1 = {
-        baseURL: new URL('file:///Users/jane-doe/my-site/import-map.json'),
+        baseURL: pathToFileURL(basePath),
         imports: {
             'alias:pets': './heart/pets/',
         },
     };
     const map = new ImportMap([inputFile1]);
     const { imports } = JSON.parse(map.getContents());
+    const expectedPath = join(cwd(), 'my-cool-site', 'heart', 'pets');
     expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
-    expect(imports['alias:pets']).toBe('file:///Users/jane-doe/my-site/heart/pets/');
+    expect(imports['alias:pets']).toBe(`${pathToFileURL(expectedPath).toString()}/`);
+});
+test('Transforms relative paths so that they use the root path as a base', () => {
+    const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
+    const inputFile1 = {
+        baseURL: pathToFileURL(basePath),
+        imports: {
+            'alias:pets': './heart/pets/',
+        },
+    };
+    const map = new ImportMap([inputFile1]);
+    const { imports } = JSON.parse(map.getContents(cwd()));
+    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
+    expect(imports['alias:pets']).toBe('./my-cool-site/heart/pets');
 });

package/dist/node/manifest.d.ts

@@ -6,6 +6,7 @@ interface GenerateManifestOptions {
     bundles?: Bundle[];
     declarations?: Declaration[];
     functions: EdgeFunction[];
+    importMapURL?: string;
     layers?: Layer[];
 }
 interface Manifest {
@@ -14,6 +15,11 @@ interface Manifest {
         asset: string;
         format: string;
     }[];
+    import_map?: string;
+    layers: {
+        name: string;
+        flag: string;
+    }[];
     routes: {
         function: string;
         name?: string;
@@ -24,18 +30,15 @@ interface Manifest {
         name?: string;
         pattern: string;
     }[];
-    layers: {
-        name: string;
-        flag: string;
-    }[];
 }
-declare const generateManifest: ({ bundles, declarations, functions, layers }: GenerateManifestOptions) => Manifest;
+declare const generateManifest: ({ bundles, declarations, functions, importMapURL, layers, }: GenerateManifestOptions) => Manifest;
 interface WriteManifestOptions {
     bundles: Bundle[];
     declarations: Declaration[];
     distDirectory: string;
     functions: EdgeFunction[];
+    importMapURL?: string;
     layers?: Layer[];
 }
-declare const writeManifest: ({ bundles, declarations, distDirectory, functions, layers, }: WriteManifestOptions) => Promise<Manifest>;
+declare const writeManifest: ({ bundles, declarations, distDirectory, functions, importMapURL, layers, }: WriteManifestOptions) => Promise<Manifest>;
 export { generateManifest, Manifest, writeManifest };

package/dist/node/manifest.js

@@ -3,7 +3,7 @@ import { join } from 'path';
 import globToRegExp from 'glob-to-regexp';
 import { getPackageVersion } from './package_json.js';
 import { nonNullable } from './utils/non_nullable.js';
-const generateManifest = ({ bundles = [], declarations = [], functions, layers = [] }) => {
+const generateManifest = ({ bundles = [], declarations = [], functions, importMapURL, layers = [], }) => {
     const preCacheRoutes = [];
     const postCacheRoutes = [];
     declarations.forEach((declaration) => {
@@ -35,6 +35,7 @@ const generateManifest = ({ bundles = [], declarations = [], functions, layers =
         post_cache_routes: postCacheRoutes.filter(nonNullable),
         bundler_version: getPackageVersion(),
         layers,
+        import_map: importMapURL,
     };
     return manifest;
 };
@@ -51,8 +52,8 @@ const getRegularExpression = (declaration) => {
     const normalizedSource = `^${regularExpression.source}\\/?$`;
     return new RegExp(normalizedSource);
 };
-const writeManifest = async ({ bundles, declarations = [], distDirectory, functions, layers, }) => {
-    const manifest = generateManifest({ bundles, declarations, functions, layers });
+const writeManifest = async ({ bundles, declarations = [], distDirectory, functions, importMapURL, layers, }) => {
+    const manifest = generateManifest({ bundles, declarations, functions, importMapURL, layers });
     const manifestPath = join(distDirectory, 'manifest.json');
     await fs.writeFile(manifestPath, JSON.stringify(manifest));
     return manifest;

package/dist/shared/consts.d.ts

@@ -0,0 +1 @@
+export declare const virtualRoot = "file:///root/";

package/dist/shared/consts.js

@@ -0,0 +1 @@
+export const virtualRoot = 'file:///root/';

package/dist/test/util.d.ts

@@ -1,3 +1,8 @@
 declare const testLogger: import("../node/logger.js").Logger;
 declare const fixturesDir: string;
-export { fixturesDir, testLogger };
+declare const useFixture: (fixtureName: string) => Promise<{
+    basePath: string;
+    cleanup: () => Promise<void>;
+    distPath: string;
+}>;
+export { fixturesDir, testLogger, useFixture };

package/dist/test/util.js

@@ -1,9 +1,24 @@
-import { resolve } from 'path';
+import { promises as fs } from 'fs';
+import { join, resolve } from 'path';
 import { fileURLToPath } from 'url';
+import cpy from 'cpy';
+import tmp from 'tmp-promise';
 import { getLogger } from '../node/logger.js';
 // eslint-disable-next-line @typescript-eslint/no-empty-function
 const testLogger = getLogger(() => { });
 const url = new URL(import.meta.url);
 const dirname = fileURLToPath(url);
 const fixturesDir = resolve(dirname, '..', 'fixtures');
-export { fixturesDir, testLogger };
+const useFixture = async (fixtureName) => {
+    const tmpDir = await tmp.dir();
+    const cleanup = () => fs.rmdir(tmpDir.path, { recursive: true });
+    const fixtureDir = resolve(fixturesDir, fixtureName);
+    await cpy(`${fixtureDir}/**`, tmpDir.path);
+    const distPath = join(tmpDir.path, '.netlify', 'edge-functions-dist');
+    return {
+        basePath: tmpDir.path,
+        cleanup,
+        distPath,
+    };
+};
+export { fixturesDir, testLogger, useFixture };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "5.2.0",
+  "version": "5.3.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -29,6 +29,7 @@
     "test:dev": "run-s test:dev:*",
     "test:ci": "run-s test:ci:*",
     "test:dev:vitest": "cross-env FORCE_COLOR=0 vitest run",
+    "test:dev:vitest:watch": "cross-env FORCE_COLOR=0 vitest watch",
     "test:dev:deno": "deno test --allow-all deno",
     "test:ci:vitest": "cross-env FORCE_COLOR=0 vitest run",
     "test:ci:deno": "deno test --allow-all deno",
@@ -59,6 +60,7 @@
     "@types/uuid": "^8.3.4",
     "@vitest/coverage-c8": "^0.25.0",
     "archiver": "^5.3.1",
+    "cpy": "^9.0.1",
     "cross-env": "^7.0.3",
     "husky": "^8.0.0",
     "nock": "^13.2.4",

package/shared/consts.ts

@@ -0,0 +1 @@
+export const virtualRoot = 'file:///root/'