@netlify/edge-bundler 2.2.0 → 2.3.0

package/deno/config.ts

@@ -0,0 +1,38 @@
+const [functionURL, collectorURL, rawExitCodes] = Deno.args
+const exitCodes = JSON.parse(rawExitCodes)
+
+let func
+
+try {
+  func = await import(functionURL)
+} catch {
+  Deno.exit(exitCodes.ImportError)
+}
+
+if (func.config === undefined) {
+  Deno.exit(exitCodes.NoConfig)
+}
+
+if (typeof func.config !== 'function') {
+  Deno.exit(exitCodes.InvalidExport)
+}
+
+let config
+
+try {
+  config = await func.config()
+} catch (error) {
+  console.error(error)
+
+  Deno.exit(exitCodes.RuntimeError)
+}
+
+try {
+  const result = JSON.stringify(config)
+
+  await Deno.writeTextFile(new URL(collectorURL), result)
+} catch {
+  Deno.exit(exitCodes.SerializationError)
+}
+
+Deno.exit(exitCodes.Success)

package/deno/lib/stage2.test.ts

@@ -0,0 +1,58 @@
+import { assertEquals, assertStringIncludes } from 'https://deno.land/std@0.127.0/testing/asserts.ts'
+
+import { join } from 'https://deno.land/std@0.155.0/path/mod.ts'
+import { pathToFileURL } from 'https://deno.land/std@0.155.0/node/url.ts'
+
+import { getStage2Entry } from './stage2.ts'
+import { virtualRoot } from './consts.ts'
+
+Deno.test('`getStage2Entry` returns a valid stage 2 file', async () => {
+  const directory = await Deno.makeTempDir()
+  const functions = [
+    {
+      name: 'func1',
+      path: join(directory, 'func1.ts'),
+      response: 'Hello from function 1',
+    },
+    {
+      name: 'func2',
+      path: join(directory, 'func2.ts'),
+      response: 'Hello from function 2',
+    },
+  ]
+
+  for (const func of functions) {
+    const contents = `export default async () => new Response(${JSON.stringify(func.response)})`
+
+    await Deno.writeTextFile(func.path, contents)
+  }
+
+  const baseURL = pathToFileURL(directory)
+  const stage2 = getStage2Entry(
+    directory,
+    functions.map(({ name, path }) => ({ name, path })),
+  )
+
+  // Ensuring that the stage 2 paths have the virtual root before we strip it.
+  assertStringIncludes(stage2, virtualRoot)
+
+  // Replacing the virtual root with the URL of the temporary directory so that
+  // we can actually import the module.
+  const normalizedStage2 = stage2.replaceAll(virtualRoot, `${baseURL.href}/`)
+
+  const stage2Path = join(directory, 'stage2.ts')
+  const stage2URL = pathToFileURL(stage2Path)
+
+  await Deno.writeTextFile(stage2Path, normalizedStage2)
+
+  const mod = await import(stage2URL.href)
+
+  await Deno.remove(directory, { recursive: true })
+
+  for (const func of functions) {
+    const result = await mod.functions[func.name]()
+
+    assertEquals(await result.text(), func.response)
+    assertEquals(mod.metadata.functions[func.name].url, pathToFileURL(func.path).toString())
+  }
+})

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

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

package/dist/node/bootstrap.test.js

@@ -0,0 +1,26 @@
+import { Buffer } from 'buffer';
+import { env } from 'process';
+import fetch, { Headers } from 'node-fetch';
+import { test, expect } from 'vitest';
+import { getBootstrapURL } from './formats/javascript.js';
+test('Imports the bootstrap layer from a valid URL', async () => {
+    const importURL = new URL(getBootstrapURL());
+    const headers = new Headers();
+    // `node-fetch` doesn't let us send credentials as part of the URL, so we
+    // have to transform them into an `Authorization` header.
+    if (importURL.username) {
+        const auth = Buffer.from(`${importURL.username}:${importURL.password}`);
+        importURL.username = '';
+        importURL.password = '';
+        headers.set('Authorization', `Basic ${auth.toString('base64')}`);
+    }
+    const canonicalURL = importURL.toString();
+    const { status } = await fetch(canonicalURL, { headers });
+    expect(status).toBe(200);
+});
+test('Imports the bootstrap layer from the URL present in the `NETLIFY_EDGE_BOOTSTRAP` environment variable, if present', () => {
+    const mockURL = 'https://example.com/boot.ts';
+    env.NETLIFY_EDGE_BOOTSTRAP = mockURL;
+    expect(getBootstrapURL()).toBe(mockURL);
+    env.NETLIFY_EDGE_BOOTSTRAP = undefined;
+});

package/dist/node/bridge.d.ts

@@ -21,6 +21,7 @@ interface RunOptions {
     pipeOutput?: boolean;
     env?: NodeJS.ProcessEnv;
     extendEnv?: boolean;
+    rejectOnExitCode?: boolean;
 }
 declare class DenoBridge {
     cacheDirectory: string;
@@ -46,7 +47,7 @@ declare class DenoBridge {
         path: string;
     }>;
     getEnvironmentVariables(inputEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-    run(args: string[], { pipeOutput, env: inputEnv, extendEnv }?: RunOptions): Promise<import("execa").ExecaReturnValue<string>>;
+    run(args: string[], { pipeOutput, env: inputEnv, extendEnv, rejectOnExitCode }?: RunOptions): Promise<import("execa").ExecaReturnValue<string>>;
     runInBackground(args: string[], ref?: ProcessRef, { pipeOutput, env: inputEnv, extendEnv }?: RunOptions): Promise<void>;
 }
 export { DENO_VERSION_RANGE, DenoBridge };

package/dist/node/bridge.js

@@ -131,10 +131,10 @@ class DenoBridge {
     }
     // Runs the Deno CLI in the background and returns a reference to the child
     // process, awaiting its execution.
-    async run(args, { pipeOutput, env: inputEnv, extendEnv = true } = {}) {
+    async run(args, { pipeOutput, env: inputEnv, extendEnv = true, rejectOnExitCode = true } = {}) {
         const { path: binaryPath } = await this.getBinaryPath();
         const env = this.getEnvironmentVariables(inputEnv);
-        const options = { env, extendEnv };
+        const options = { env, extendEnv, reject: rejectOnExitCode };
         return DenoBridge.runWithBinary(binaryPath, args, options, pipeOutput);
     }
     // Runs the Deno CLI in the background, assigning a reference of the child

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

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

package/dist/node/bridge.test.js

@@ -0,0 +1,112 @@
+import { Buffer } from 'buffer';
+import fs from 'fs';
+import { createRequire } from 'module';
+import { platform, env } from 'process';
+import { PassThrough } from 'stream';
+import nock from 'nock';
+import semver from 'semver';
+import { spy } from 'sinon';
+import tmp from 'tmp-promise';
+import { test, expect } from 'vitest';
+import { DenoBridge, DENO_VERSION_RANGE } from './bridge.js';
+import { getPlatformTarget } from './platform.js';
+const require = createRequire(import.meta.url);
+const archiver = require('archiver');
+const getMockDenoBridge = function (tmpDir, mockBinaryOutput) {
+    var _a, _b;
+    const latestVersion = (_b = (_a = semver.minVersion(DENO_VERSION_RANGE)) === null || _a === void 0 ? void 0 : _a.version) !== null && _b !== void 0 ? _b : '';
+    const data = new PassThrough();
+    const archive = archiver('zip', { zlib: { level: 9 } });
+    archive.pipe(data);
+    archive.append(Buffer.from(mockBinaryOutput.replace(/@@@latestVersion@@@/g, latestVersion)), {
+        name: platform === 'win32' ? 'deno.exe' : 'deno',
+    });
+    archive.finalize();
+    const target = getPlatformTarget();
+    nock('https://dl.deno.land').get('/release-latest.txt').reply(200, `v${latestVersion}`);
+    nock('https://dl.deno.land')
+        .get(`/release/v${latestVersion}/deno-${target}.zip`)
+        .reply(200, () => data);
+    const beforeDownload = spy();
+    const afterDownload = spy();
+    return new DenoBridge({
+        cacheDirectory: tmpDir.path,
+        onBeforeDownload: beforeDownload,
+        onAfterDownload: afterDownload,
+        useGlobal: false,
+    });
+};
+test('Does not inherit environment variables if `extendEnv` is false', async () => {
+    var _a;
+    const tmpDir = await tmp.dir();
+    const deno = getMockDenoBridge(tmpDir, `#!/usr/bin/env sh
+
+    if [ "$1" = "test"  ]
+    then
+      env
+    else
+      echo "deno @@@latestVersion@@@"
+    fi`);
+    // The environment sets some variables so let us see what they are and remove them from the result
+    const referenceOutput = await deno.run(['test'], { env: {}, extendEnv: false });
+    env.TADA = 'TUDU';
+    const result = await deno.run(['test'], { env: { LULU: 'LALA' }, extendEnv: false });
+    let output = (_a = result === null || result === void 0 ? void 0 : result.stdout) !== null && _a !== void 0 ? _a : '';
+    delete env.TADA;
+    referenceOutput === null || referenceOutput === void 0 ? void 0 : referenceOutput.stdout.split('\n').forEach((line) => {
+        output = output.replace(line.trim(), '');
+    });
+    output = output.trim().replace(/\n+/g, '\n');
+    expect(output).toBe('LULU=LALA');
+    await fs.promises.rmdir(tmpDir.path, { recursive: true });
+});
+test('Does inherit environment variables if `extendEnv` is true', async () => {
+    var _a;
+    const tmpDir = await tmp.dir();
+    const deno = getMockDenoBridge(tmpDir, `#!/usr/bin/env sh
+
+  if [ "$1" = "test"  ]
+  then
+    env
+  else
+    echo "deno @@@latestVersion@@@"
+  fi`);
+    // The environment sets some variables so let us see what they are and remove them from the result
+    const referenceOutput = await deno.run(['test'], { env: {}, extendEnv: true });
+    env.TADA = 'TUDU';
+    const result = await deno.run(['test'], { env: { LULU: 'LALA' }, extendEnv: true });
+    let output = (_a = result === null || result === void 0 ? void 0 : result.stdout) !== null && _a !== void 0 ? _a : '';
+    delete env.TADA;
+    referenceOutput === null || referenceOutput === void 0 ? void 0 : referenceOutput.stdout.split('\n').forEach((line) => {
+        output = output.replace(line.trim(), '');
+    });
+    // lets remove holes, split lines and sort lines by name, as different OSes might order them different
+    const environmentVariables = output.trim().replace(/\n+/g, '\n').split('\n').sort();
+    expect(environmentVariables).toEqual(['LULU=LALA', 'TADA=TUDU']);
+    await fs.promises.rmdir(tmpDir.path, { recursive: true });
+});
+test('Does inherit environment variables if `extendEnv` is not set', async () => {
+    var _a;
+    const tmpDir = await tmp.dir();
+    const deno = getMockDenoBridge(tmpDir, `#!/usr/bin/env sh
+
+    if [ "$1" = "test"  ]
+    then
+      env
+    else
+      echo "deno @@@latestVersion@@@"
+    fi`);
+    // The environment sets some variables so let us see what they are and remove them from the result
+    const referenceOutput = await deno.run(['test'], { env: {}, extendEnv: true });
+    env.TADA = 'TUDU';
+    const result = await deno.run(['test'], { env: { LULU: 'LALA' } });
+    let output = (_a = result === null || result === void 0 ? void 0 : result.stdout) !== null && _a !== void 0 ? _a : '';
+    delete env.TADA;
+    referenceOutput === null || referenceOutput === void 0 ? void 0 : referenceOutput.stdout.split('\n').forEach((line) => {
+        output = output.replace(line.trim(), '');
+    });
+    // lets remove holes, split lines and sort lines by name, as different OSes might order them different
+    const environmentVariables = output.trim().replace(/\n+/g, '\n').split('\n').sort();
+    expect(environmentVariables).toEqual(['LULU=LALA', 'TADA=TUDU']);
+    await fs.promises.rmdir(tmpDir.path, { recursive: true });
+});

package/dist/node/bundler.d.ts

@@ -1,5 +1,5 @@
 import { OnAfterDownloadHook, OnBeforeDownloadHook } from './bridge.js';
-import type { Declaration } from './declaration.js';
+import { Declaration } from './declaration.js';
 import { EdgeFunction } from './edge_function.js';
 import { FeatureFlags } from './feature_flags.js';
 import { ImportMapFile } from './import_map.js';
@@ -15,7 +15,7 @@ interface BundleOptions {
     onBeforeDownload?: OnBeforeDownloadHook;
     systemLogger?: LogFunction;
 }
-declare const bundle: (sourceDirectories: string[], distDirectory: string, declarations?: Declaration[], { basePath, cacheDirectory, debug, distImportMapPath, featureFlags, importMaps, onAfterDownload, onBeforeDownload, systemLogger, }?: BundleOptions) => Promise<{
+declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath, cacheDirectory, debug, distImportMapPath, featureFlags, importMaps, onAfterDownload, onBeforeDownload, systemLogger, }?: BundleOptions) => Promise<{
     functions: EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;

package/dist/node/bundler.js

@@ -3,6 +3,8 @@ import { join } from 'path';
 import commonPathPrefix from 'common-path-prefix';
 import { v4 as uuidv4 } from 'uuid';
 import { DenoBridge } from './bridge.js';
+import { getFunctionConfig } from './config.js';
+import { getDeclarationsFromConfig } from './declaration.js';
 import { getFlags } from './feature_flags.js';
 import { findFunctions } from './finder.js';
 import { bundle as bundleESZIP } from './formats/eszip.js';
@@ -11,10 +13,9 @@ import { ImportMap } from './import_map.js';
 import { getLogger } from './logger.js';
 import { writeManifest } from './manifest.js';
 import { ensureLatestTypes } from './types.js';
-const createBundleOps = ({ basePath, buildID, debug, deno, distDirectory, functions, importMap, featureFlags, }) => {
-    const bundleOps = [];
+const createBundle = ({ basePath, buildID, debug, deno, distDirectory, functions, importMap, featureFlags, }) => {
     if (featureFlags.edge_functions_produce_eszip) {
-        bundleOps.push(bundleESZIP({
+        return bundleESZIP({
             basePath,
             buildID,
             debug,
@@ -22,21 +23,18 @@ const createBundleOps = ({ basePath, buildID, debug, deno, distDirectory, functi
             distDirectory,
             functions,
             importMap,
-        }));
+        });
     }
-    else {
-        bundleOps.push(bundleJS({
-            buildID,
-            debug,
-            deno,
-            distDirectory,
-            functions,
-            importMap,
-        }));
-    }
-    return bundleOps;
+    return bundleJS({
+        buildID,
+        debug,
+        deno,
+        distDirectory,
+        functions,
+        importMap,
+    });
 };
-const bundle = async (sourceDirectories, distDirectory, declarations = [], { basePath: inputBasePath, cacheDirectory, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMaps, onAfterDownload, onBeforeDownload, systemLogger, } = {}) => {
+const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMaps, onAfterDownload, onBeforeDownload, systemLogger, } = {}) => {
     const logger = getLogger(systemLogger, debug);
     const featureFlags = getFlags(inputFeatureFlags);
     const options = {
@@ -60,7 +58,7 @@ const bundle = async (sourceDirectories, distDirectory, declarations = [], { bas
     // if any.
     const importMap = new ImportMap(importMaps);
     const functions = await findFunctions(sourceDirectories);
-    const bundleOps = createBundleOps({
+    const functionBundle = await createBundle({
         basePath,
         buildID,
         debug,
@@ -70,13 +68,24 @@ const bundle = async (sourceDirectories, distDirectory, declarations = [], { bas
         importMap,
         featureFlags,
     });
-    const bundles = await Promise.all(bundleOps);
     // The final file name of the bundles contains a SHA256 hash of the contents,
     // which we can only compute now that the files have been generated. So let's
     // rename the bundles to their permanent names.
-    await createFinalBundles(bundles, distDirectory, buildID);
+    await createFinalBundles([functionBundle], distDirectory, buildID);
+    // Retrieving a configuration object for each function.
+    const functionsConfig = await Promise.all(functions.map((func) => {
+        if (!featureFlags.edge_functions_config_export) {
+            return {};
+        }
+        return getFunctionConfig(func, deno, logger);
+    }));
+    // Creating a hash of function names to configuration objects.
+    const functionsWithConfig = functions.reduce((acc, func, index) => ({ ...acc, [func.name]: functionsConfig[index] }), {});
+    // Creating a final declarations array by combining the TOML entries with the
+    // function configuration objects.
+    const declarations = getDeclarationsFromConfig(tomlDeclarations, functionsWithConfig);
     const manifest = await writeManifest({
-        bundles,
+        bundles: [functionBundle],
         declarations,
         distDirectory,
         functions,

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

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

package/dist/node/bundler.test.js

@@ -0,0 +1,246 @@
+import { promises as fs } from 'fs';
+import { join, resolve } from 'path';
+import process from 'process';
+import { pathToFileURL } from 'url';
+import del from 'del';
+import tmp from 'tmp-promise';
+import { test, expect } from 'vitest';
+import { fixturesDir } from '../test/util.js';
+import { BundleError } from './bundle_error.js';
+import { bundle } from './bundler.js';
+test('Produces a JavaScript bundle and a manifest file', async () => {
+    const sourceDirectory = resolve(fixturesDir, 'with_import_maps', 'functions');
+    const tmpDir = await tmp.dir();
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    const result = await bundle([sourceDirectory], tmpDir.path, declarations, {
+        basePath: fixturesDir,
+        importMaps: [
+            {
+                baseURL: pathToFileURL(join(fixturesDir, 'import-map.json')),
+                imports: {
+                    'alias:helper': pathToFileURL(join(fixturesDir, 'helper.ts')).toString(),
+                },
+            },
+        ],
+    });
+    const generatedFiles = await fs.readdir(tmpDir.path);
+    expect(result.functions.length).toBe(1);
+    expect(generatedFiles.length).toBe(2);
+    const manifestFile = await fs.readFile(resolve(tmpDir.path, 'manifest.json'), 'utf8');
+    const manifest = JSON.parse(manifestFile);
+    const { bundles } = manifest;
+    expect(bundles.length).toBe(1);
+    expect(bundles[0].format).toBe('js');
+    expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
+    expect(result.manifest).toEqual(manifest);
+    await fs.rmdir(tmpDir.path, { recursive: true });
+}, 10000);
+test('Produces only a ESZIP bundle when the `edge_functions_produce_eszip` feature flag is set', async () => {
+    const sourceDirectory = resolve(fixturesDir, 'with_import_maps', 'functions');
+    const tmpDir = await tmp.dir();
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    const result = await bundle([sourceDirectory], tmpDir.path, declarations, {
+        basePath: fixturesDir,
+        featureFlags: {
+            edge_functions_produce_eszip: true,
+        },
+        importMaps: [
+            {
+                baseURL: pathToFileURL(join(fixturesDir, 'import-map.json')),
+                imports: {
+                    'alias:helper': pathToFileURL(join(fixturesDir, 'helper.ts')).toString(),
+                },
+            },
+        ],
+    });
+    const generatedFiles = await fs.readdir(tmpDir.path);
+    expect(result.functions.length).toBe(1);
+    expect(generatedFiles.length).toBe(2);
+    const manifestFile = await fs.readFile(resolve(tmpDir.path, '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 });
+}, 10000);
+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 declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    try {
+        await bundle([sourceDirectory], tmpDir.path, declarations);
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(BundleError);
+        expect(error.customErrorInfo).toEqual({
+            location: {
+                format: 'javascript',
+                runtime: 'deno',
+            },
+            type: 'functionsBundling',
+        });
+    }
+}, 10000);
+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);
+    }
+    catch (error) {
+        expect(error).not.toBeInstanceOf(BundleError);
+    }
+});
+test('Uses the cache directory as the `DENO_DIR` value if the `edge_functions_cache_deno_dir` feature flag is set', async () => {
+    expect.assertions(7);
+    const sourceDirectory = resolve(fixturesDir, 'with_import_maps', 'functions');
+    const outDir = await tmp.dir();
+    const cacheDir = await tmp.dir();
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    const options = {
+        basePath: fixturesDir,
+        cacheDirectory: cacheDir.path,
+        importMaps: [
+            {
+                baseURL: pathToFileURL(join(fixturesDir, 'import-map.json')),
+                imports: {
+                    'alias:helper': pathToFileURL(join(fixturesDir, 'helper.ts')).toString(),
+                },
+            },
+        ],
+    };
+    // 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);
+    expect(result1.functions.length).toBe(1);
+    expect(outFiles1.length).toBe(2);
+    try {
+        await fs.readdir(join(cacheDir.path, 'deno_dir'));
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(Error);
+    }
+    // Run #2, feature flag on: The directory should be populated.
+    const result2 = await bundle([sourceDirectory], outDir.path, declarations, {
+        ...options,
+        featureFlags: {
+            edge_functions_cache_deno_dir: true,
+        },
+    });
+    const outFiles2 = await fs.readdir(outDir.path);
+    expect(result2.functions.length).toBe(1);
+    expect(outFiles2.length).toBe(2);
+    const denoDir2 = await fs.readdir(join(cacheDir.path, 'deno_dir'));
+    expect(denoDir2.includes('deps')).toBe(true);
+    expect(denoDir2.includes('gen')).toBe(true);
+    await fs.rmdir(outDir.path, { recursive: true });
+}, 10000);
+test('Supports import maps with relative paths', async () => {
+    const sourceDirectory = resolve(fixturesDir, 'with_import_maps', 'functions');
+    const tmpDir = await tmp.dir();
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    const result = await bundle([sourceDirectory], tmpDir.path, declarations, {
+        basePath: fixturesDir,
+        featureFlags: {
+            edge_functions_produce_eszip: true,
+        },
+        importMaps: [
+            {
+                baseURL: pathToFileURL(join(fixturesDir, 'import-map.json')),
+                imports: {
+                    'alias:helper': './helper.ts',
+                },
+            },
+        ],
+    });
+    const generatedFiles = await fs.readdir(tmpDir.path);
+    expect(result.functions.length).toBe(1);
+    expect(generatedFiles.length).toBe(2);
+    const manifestFile = await fs.readFile(resolve(tmpDir.path, '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 });
+}, 10000);
+test('Ignores any user-defined `deno.json` files', async () => {
+    const fixtureDir = join(fixturesDir, 'with_import_maps');
+    const tmpDir = await tmp.dir();
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    // Creating an import map file that rewires the URL of the Deno registry to
+    // an invalid location.
+    const importMapFile = await tmp.file();
+    const importMap = {
+        imports: {
+            'https://deno.land/': 'https://black.hole/',
+        },
+    };
+    await fs.writeFile(importMapFile.path, JSON.stringify(importMap));
+    // Deno configuration files need to be in the current working directory.
+    // There's not a great way for us to set the working directory of the `deno`
+    // process that we'll run, so our best bet is to write the file to whatever
+    // is the current working directory now and then clean it up.
+    const denoConfigPath = join(process.cwd(), 'deno.json');
+    const denoConfig = {
+        importMap: importMapFile.path,
+    };
+    try {
+        await fs.access(denoConfigPath);
+        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) {
+        // @ts-expect-error Error is not typed
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    await fs.writeFile(denoConfigPath, JSON.stringify(denoConfig));
+    expect(() => bundle([join(fixtureDir, 'functions')], tmpDir.path, declarations, {
+        basePath: fixturesDir,
+        featureFlags: {
+            edge_functions_produce_eszip: true,
+        },
+        importMaps: [
+            {
+                baseURL: pathToFileURL(join(fixturesDir, 'import-map.json')),
+                imports: {
+                    'alias:helper': pathToFileURL(join(fixturesDir, 'helper.ts')).toString(),
+                },
+            },
+        ],
+    })).not.toThrow();
+    await del([tmpDir.path, denoConfigPath, importMapFile.path], { force: true });
+}, 10000);

package/dist/node/config.d.ts

@@ -0,0 +1,7 @@
+import { DenoBridge } from './bridge.js';
+import { EdgeFunction } from './edge_function.js';
+import { Logger } from './logger.js';
+export interface FunctionConfig {
+    path?: string;
+}
+export declare const getFunctionConfig: (func: EdgeFunction, deno: DenoBridge, log: Logger) => Promise<FunctionConfig>;