@netlify/edge-bundler 8.9.0 → 8.11.0

package/dist/node/bridge.test.js

@@ -1,5 +1,5 @@
 import { Buffer } from 'buffer';
-import fs from 'fs';
+import { rm } from 'fs/promises';
 import { createRequire } from 'module';
 import { platform, env } from 'process';
 import { PassThrough } from 'stream';
@@ -53,7 +53,7 @@ test('Does not inherit environment variables if `extendEnv` is false', async ()
     });
     output = output.trim().replace(/\n+/g, '\n');
     expect(output).toBe('LULU=LALA');
-    await fs.promises.rmdir(tmpDir.path, { recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true });
 });
 test('Does inherit environment variables if `extendEnv` is true', async () => {
     var _a;
@@ -78,7 +78,7 @@ test('Does inherit environment variables if `extendEnv` is true', async () => {
     // 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 });
+    await rm(tmpDir.path, { force: true, recursive: true });
 });
 test('Does inherit environment variables if `extendEnv` is not set', async () => {
     var _a;
@@ -103,5 +103,5 @@ test('Does inherit environment variables if `extendEnv` is not set', async () =>
     // 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 });
+    await rm(tmpDir.path, { force: true, recursive: true });
 });

package/dist/node/bundler.d.ts

@@ -1,5 +1,6 @@
 import { OnAfterDownloadHook, OnBeforeDownloadHook } from './bridge.js';
 import { Declaration } from './declaration.js';
+import { EdgeFunction } from './edge_function.js';
 import { FeatureFlags } from './feature_flags.js';
 import { LogFunction } from './logger.js';
 interface BundleOptions {
@@ -13,10 +14,26 @@ interface BundleOptions {
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
     systemLogger?: LogFunction;
+    internalSrcFolder?: string;
 }
-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[];
+declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, }?: BundleOptions) => Promise<{
+    functions: EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;
+export declare const addGeneratorFieldIfMissing: (declaration: Declaration, functions: EdgeFunction[], internalFunctionsPath?: string) => {
+    generator: string | undefined;
+    cache?: string | undefined;
+    function: string;
+    name?: string | undefined;
+    path: string;
+    excludedPath?: string | undefined;
+} | {
+    generator: string | undefined;
+    cache?: string | undefined;
+    function: string;
+    name?: string | undefined;
+    pattern: string;
+    excludedPattern?: string | undefined;
+};
 export { bundle };
 export type { BundleOptions };

package/dist/node/bundler.js

@@ -1,6 +1,7 @@
 import { promises as fs } from 'fs';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import commonPathPrefix from 'common-path-prefix';
+import isPathInside from 'is-path-inside';
 import { v4 as uuidv4 } from 'uuid';
 import { importMapSpecifier } from '../shared/consts.js';
 import { DenoBridge } from './bridge.js';
@@ -14,7 +15,7 @@ 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, importMapPaths = [], onAfterDownload, onBeforeDownload, systemLogger, } = {}) => {
+const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, } = {}) => {
     const logger = getLogger(systemLogger, debug);
     const featureFlags = getFlags(inputFeatureFlags);
     const options = {
@@ -24,7 +25,8 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
         onAfterDownload,
         onBeforeDownload,
     };
-    if (cacheDirectory !== undefined && featureFlags.edge_functions_cache_deno_dir) {
+    const internalFunctionsPath = internalSrcFolder && resolve(internalSrcFolder);
+    if (cacheDirectory !== undefined) {
         options.denoDir = join(cacheDirectory, 'deno_dir');
     }
     const deno = new DenoBridge(options);
@@ -59,17 +61,17 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
     // rename the bundles to their permanent names.
     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, importMap, deno, logger);
-    }));
+    const functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig(func, importMap, deno, logger, featureFlags)));
     // 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 file with the
     // deploy configuration API and the in-source configuration.
-    const declarations = getDeclarationsFromConfig(tomlDeclarations, functionsWithConfig, deployConfig);
+    const declarationsFromConfig = getDeclarationsFromConfig(tomlDeclarations, functionsWithConfig, deployConfig);
+    // If any declarations are autogenerated and are missing the generator field
+    // add a default string.
+    const declarations = internalFunctionsPath
+        ? declarationsFromConfig.map((declaration) => addGeneratorFieldIfMissing(declaration, functions, internalFunctionsPath))
+        : declarationsFromConfig;
     const manifest = await writeManifest({
         bundles: [functionBundle],
         declarations,
@@ -105,4 +107,12 @@ const getBasePath = (sourceDirectories, inputBasePath) => {
     }
     return commonPathPrefix(sourceDirectories);
 };
+export const addGeneratorFieldIfMissing = (declaration, functions, internalFunctionsPath) => {
+    var _a;
+    const fullFuncPath = (_a = functions === null || functions === void 0 ? void 0 : functions.find((func) => func.name === declaration.function)) === null || _a === void 0 ? void 0 : _a.path;
+    // If function path is in the internalFunctionsPath, we assume it is autogenerated.
+    const isInternal = Boolean(internalFunctionsPath && fullFuncPath && isPathInside(fullFuncPath, internalFunctionsPath));
+    const generatorFallback = isInternal ? 'internalFunc' : undefined;
+    return { ...declaration, generator: declaration.generator || generatorFallback };
+};
 export { bundle };

package/dist/node/bundler.test.js

@@ -147,8 +147,8 @@ test('Does not add a custom error property to system errors during bundling', as
         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(6);
+test('Uses the cache directory as the `DENO_DIR` value', async () => {
+    expect.assertions(3);
     const { basePath, cleanup, distPath } = await useFixture('with_import_maps');
     const sourceDirectory = join(basePath, 'functions');
     const cacheDir = await tmp.dir();
@@ -163,29 +163,12 @@ test('Uses the cache directory as the `DENO_DIR` value if the `edge_functions_ca
         cacheDirectory: cacheDir.path,
         configPath: join(sourceDirectory, 'config.json'),
     };
-    // Run #1, feature flag off: The directory should not be populated.
-    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);
-    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], distPath, declarations, {
-        ...options,
-        featureFlags: {
-            edge_functions_cache_deno_dir: true,
-        },
-    });
-    const outFiles2 = await fs.readdir(distPath);
-    expect(result2.functions.length).toBe(1);
-    expect(outFiles2.length).toBe(2);
-    const denoDir2 = await fs.readdir(join(cacheDir.path, 'deno_dir'));
-    expect(denoDir2.includes('gen')).toBe(true);
+    const result = await bundle([sourceDirectory], distPath, declarations, options);
+    const outFiles = await fs.readdir(distPath);
+    expect(result.functions.length).toBe(1);
+    expect(outFiles.length).toBe(2);
+    const denoDir = await fs.readdir(join(cacheDir.path, 'deno_dir'));
+    expect(denoDir.includes('gen')).toBe(true);
     await cleanup();
 });
 test('Supports import maps with relative paths', async () => {
@@ -264,7 +247,7 @@ test('Processes a function that imports a custom layer', async () => {
             path: '/func1',
         },
     ];
-    const layer = { name: 'layer:test', flag: 'edge-functions-layer-test' };
+    const layer = { name: 'https://edge-function-layer-template.netlify.app/mod.ts', flag: 'edge-functions-layer-test' };
     const result = await bundle([sourceDirectory], distPath, declarations, {
         basePath,
         configPath: join(sourceDirectory, 'config.json'),
@@ -292,17 +275,22 @@ test('Loads declarations and import maps from the deploy configuration', async (
     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'),
+        configPath: join(basePath, '.netlify', 'edge-functions', 'manifest.json'),
+        internalSrcFolder: directories[1],
     });
     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);
-    const { bundles, function_config: functionConfig } = manifest;
+    const { routes, bundles, function_config: functionConfig } = manifest;
     expect(bundles.length).toBe(1);
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
+    expect(routes[0].generator).toBeUndefined();
+    expect(routes[1].name).toBe('Function two');
+    expect(routes[1].generator).toBe('@netlify/fake-plugin@1.0.0');
+    expect(routes[2].generator).toBe('internalFunc');
     // respects excludedPath from deploy config
     expect(functionConfig.func2).toEqual({ excluded_patterns: ['^/func2/skip/?$'] });
     await cleanup();
@@ -318,7 +306,7 @@ test("Ignores entries in `importMapPaths` that don't point to an existing import
             helper: pathToFileURL(join(basePath, 'helper.ts')).toString(),
         },
         scopes: {
-            [pathToFileURL(join(sourceDirectory, 'func3')).toString()]: {
+            [pathToFileURL(join(sourceDirectory, 'func3/func3.ts')).toString()]: {
                 helper: pathToFileURL(join(basePath, 'helper2.ts')).toString(),
             },
         },

package/dist/node/config.d.ts

@@ -1,14 +1,18 @@
 import { DenoBridge } from './bridge.js';
 import { EdgeFunction } from './edge_function.js';
+import { FeatureFlags } from './feature_flags.js';
 import { ImportMap } from './import_map.js';
 import { Logger } from './logger.js';
 export declare const enum Cache {
     Off = "off",
     Manual = "manual"
 }
+export type OnError = 'fail' | 'bypass' | `/${string}`;
+export declare const isValidOnError: (value: unknown) => value is OnError;
 export interface FunctionConfig {
     cache?: Cache;
     path?: string | string[];
     excludedPath?: string | string[];
+    onError?: OnError;
 }
-export declare const getFunctionConfig: (func: EdgeFunction, importMap: ImportMap, deno: DenoBridge, log: Logger) => Promise<FunctionConfig>;
+export declare const getFunctionConfig: (func: EdgeFunction, importMap: ImportMap, deno: DenoBridge, log: Logger, featureFlags: FeatureFlags) => Promise<FunctionConfig>;

package/dist/node/config.js

@@ -14,12 +14,19 @@ var ConfigExitCode;
     ConfigExitCode[ConfigExitCode["SerializationError"] = 5] = "SerializationError";
     ConfigExitCode[ConfigExitCode["InvalidDefaultExport"] = 6] = "InvalidDefaultExport";
 })(ConfigExitCode || (ConfigExitCode = {}));
+export const isValidOnError = (value) => {
+    if (typeof value === 'undefined')
+        return true;
+    if (typeof value !== 'string')
+        return false;
+    return value === 'fail' || value === 'bypass' || value.startsWith('/');
+};
 const getConfigExtractor = () => {
     const packagePath = getPackagePath();
     const configExtractorPath = join(packagePath, 'deno', 'config.ts');
     return configExtractorPath;
 };
-export const getFunctionConfig = async (func, importMap, deno, log) => {
+export const getFunctionConfig = async (func, importMap, deno, log, featureFlags) => {
     // The extractor is a Deno script that will import the function and run its
     // `config` export, if one exists.
     const extractorPath = getConfigExtractor();
@@ -46,38 +53,57 @@ export const getFunctionConfig = async (func, importMap, deno, log) => {
         JSON.stringify(ConfigExitCode),
     ], { rejectOnExitCode: false });
     if (exitCode !== ConfigExitCode.Success) {
-        logConfigError(func, exitCode, stderr, log);
+        handleConfigError(func, exitCode, stderr, log, featureFlags);
         return {};
     }
     if (stdout !== '') {
         log.user(stdout);
     }
+    let collectorData = {};
     try {
-        const collectorData = await fs.readFile(collector.path, 'utf8');
-        return JSON.parse(collectorData);
+        const collectorDataJSON = await fs.readFile(collector.path, 'utf8');
+        collectorData = JSON.parse(collectorDataJSON);
     }
     catch {
-        logConfigError(func, ConfigExitCode.UnhandledError, stderr, log);
-        return {};
+        handleConfigError(func, ConfigExitCode.UnhandledError, stderr, log, featureFlags);
     }
     finally {
         await collector.cleanup();
     }
+    if (!isValidOnError(collectorData.onError)) {
+        throw new BundleError(new Error(`The 'onError' configuration property in edge function at '${func.path}' must be one of 'fail', 'bypass', or a path starting with '/'. Got '${collectorData.onError}'. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
+    }
+    return collectorData;
 };
-const logConfigError = (func, exitCode, stderr, log) => {
+const handleConfigError = (func, exitCode, stderr, log, featureFlags) => {
     switch (exitCode) {
         case ConfigExitCode.ImportError:
-            log.user(`Could not load edge function at '${func.path}'`);
             log.user(stderr);
+            if (featureFlags.edge_functions_invalid_config_throw) {
+                throw new BundleError(new Error(`Could not load edge function at '${func.path}'. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
+            }
+            else {
+                log.user(`Could not load edge function at '${func.path}'`);
+            }
             break;
         case ConfigExitCode.NoConfig:
             log.system(`No in-source config found for edge function at '${func.path}'`);
             break;
         case ConfigExitCode.InvalidExport:
-            log.user(`'config' export in edge function at '${func.path}' must be an object`);
+            if (featureFlags.edge_functions_invalid_config_throw) {
+                throw new BundleError(new Error(`The 'config' export in edge function at '${func.path}' must be an object. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
+            }
+            else {
+                log.user(`'config' export in edge function at '${func.path}' must be an object`);
+            }
             break;
         case ConfigExitCode.SerializationError:
-            log.user(`'config' object in edge function at '${func.path}' must contain primitive values only`);
+            if (featureFlags.edge_functions_invalid_config_throw) {
+                throw new BundleError(new Error(`The 'config' object in the edge function at '${func.path}' must contain primitive values only. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
+            }
+            else {
+                log.user(`'config' object in edge function at '${func.path}' must contain primitive values only`);
+            }
             break;
         case ConfigExitCode.InvalidDefaultExport:
             throw new BundleError(new Error(`Default export in '${func.path}' must be a function. More on the Edge Functions API at https://ntl.fyi/edge-api.`));

package/dist/node/config.test.js

@@ -3,7 +3,7 @@ import { join, resolve } from 'path';
 import { pathToFileURL } from 'url';
 import { deleteAsync } from 'del';
 import tmp from 'tmp-promise';
-import { test, expect, vi } from 'vitest';
+import { test, expect, vi, describe } from 'vitest';
 import { fixturesDir, useFixture } from '../test/util.js';
 import { DenoBridge } from './bridge.js';
 import { bundle } from './bundler.js';
@@ -16,102 +16,138 @@ const importMapFile = {
     },
 };
 const invalidDefaultExportErr = (path) => `Default export in '${path}' must be a function. More on the Edge Functions API at https://ntl.fyi/edge-api.`;
-test('`getFunctionConfig` extracts configuration properties from function file', async () => {
-    const { path: tmpDir } = await tmp.dir();
-    const deno = new DenoBridge({
-        cacheDirectory: tmpDir,
-    });
-    const functions = [
-        // No config
-        {
-            expectedConfig: {},
-            name: 'func1',
-            source: `export default async () => new Response("Hello from function one")`,
-        },
-        // Empty config
-        {
-            expectedConfig: {},
-            name: 'func2',
-            source: `
+const functions = [
+    {
+        testName: 'no config',
+        expectedConfig: {},
+        name: 'func1',
+        source: `export default async () => new Response("Hello from function one")`,
+    },
+    {
+        testName: 'empty config',
+        expectedConfig: {},
+        name: 'func2',
+        source: `
         export default async () => new Response("Hello from function two")
 
         export const config = {}
       `,
+    },
+    {
+        testName: 'config with wrong type (throw)',
+        expectedConfig: {},
+        name: 'func3',
+        source: `
+      export default async () => new Response("Hello from function two")
+
+      export const config = () => ({})
+    `,
+        error: /^The 'config' export in edge function at '(.*)' must be an object\. More on the Edge Functions API at https:\/\/ntl\.fyi\/edge-api\.$/,
+        featureFlags: {
+            edge_functions_invalid_config_throw: true,
         },
-        // Config with the wrong type
-        {
-            expectedConfig: {},
-            name: 'func3',
-            source: `
+    },
+    {
+        testName: 'config with wrong type (log)',
+        expectedConfig: {},
+        name: 'func3',
+        source: `
       export default async () => new Response("Hello from function two")
 
       export const config = () => ({})
     `,
-            userLog: /^'config' export in edge function at '(.*)' must be an object$/,
+        userLog: /^'config' export in edge function at '(.*)' must be an object$/,
+        featureFlags: {
+            edge_functions_invalid_config_throw: false,
         },
-        // Config with a syntax error
-        {
-            expectedConfig: {},
-            name: 'func4',
-            source: `
+    },
+    {
+        testName: 'config with syntax error (throw)',
+        expectedConfig: {},
+        name: 'func4',
+        source: `
+      export default async () => new Response("Hello from function two")
+
+      export const config
+    `,
+        error: /^Could not load edge function at '(.*)'\. More on the Edge Functions API at https:\/\/ntl\.fyi\/edge-api\.$/,
+        featureFlags: {
+            edge_functions_invalid_config_throw: true,
+        },
+    },
+    {
+        testName: 'config with syntax error (log)',
+        expectedConfig: {},
+        name: 'func4',
+        source: `
       export default async () => new Response("Hello from function two")
 
       export const config
     `,
-            userLog: /^Could not load edge function at '(.*)'$/,
+        userLog: /^Could not load edge function at '(.*)'$/,
+        featureFlags: {
+            edge_functions_invalid_config_throw: false,
         },
-        // Config with `path`
-        {
-            expectedConfig: { path: '/home' },
-            name: 'func6',
-            source: `
+    },
+    {
+        testName: 'config with correct onError',
+        expectedConfig: { onError: 'bypass' },
+        name: 'func5',
+        source: `
+      export default async () => new Response("Hello from function two")
+      export const config = { onError: "bypass" }
+    `,
+    },
+    {
+        testName: 'config with wrong onError',
+        name: 'func7',
+        source: `
+      export default async () => new Response("Hello from function two")
+      export const config = { onError: "foo" }
+    `,
+        error: /The 'onError' configuration property in edge function at .*/,
+    },
+    {
+        testName: 'config with `path`',
+        expectedConfig: { path: '/home' },
+        name: 'func6',
+        source: `
         export default async () => new Response("Hello from function three")
 
         export const config = { path: "/home" }
       `,
-        },
-    ];
-    for (const func of functions) {
+    },
+];
+describe('`getFunctionConfig` extracts configuration properties from function file', () => {
+    test.each(functions)('$testName', async (func) => {
+        const { path: tmpDir } = await tmp.dir();
+        const deno = new DenoBridge({
+            cacheDirectory: tmpDir,
+        });
         const logger = {
             user: vi.fn().mockResolvedValue(null),
             system: vi.fn().mockResolvedValue(null),
         };
         const path = join(tmpDir, `${func.name}.js`);
         await fs.writeFile(path, func.source);
-        const config = await getFunctionConfig({
+        const funcCall = () => getFunctionConfig({
             name: func.name,
             path,
-        }, new ImportMap([importMapFile]), deno, logger);
-        expect(config).toEqual(func.expectedConfig);
-        if (func.userLog) {
-            expect(logger.user).toHaveBeenNthCalledWith(1, expect.stringMatching(func.userLog));
+        }, new ImportMap([importMapFile]), deno, logger, func.featureFlags || {});
+        if (func.error) {
+            await expect(funcCall()).rejects.toThrowError(func.error);
+        }
+        else if (func.userLog) {
+            await expect(funcCall()).resolves.not.toThrowError();
+            expect(logger.user).toHaveBeenCalledWith(expect.stringMatching(func.userLog));
         }
         else {
+            const config = await funcCall();
+            expect(config).toEqual(func.expectedConfig);
             expect(logger.user).not.toHaveBeenCalled();
         }
-    }
-    await deleteAsync(tmpDir, { force: true });
-});
-test('Ignores function paths from the in-source `config` function if the feature flag is off', async () => {
-    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], distPath, declarations, {
-        basePath,
-        configPath: join(internalDirectory, 'config.json'),
+        await deleteAsync(tmpDir, { force: true });
     });
-    const generatedFiles = await fs.readdir(distPath);
-    expect(result.functions.length).toBe(7);
-    expect(generatedFiles.length).toBe(2);
-    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 cleanup();
 });
 test('Loads function paths from the in-source `config` function', async () => {
     const { basePath, cleanup, distPath } = await useFixture('with_config');
@@ -130,9 +166,6 @@ test('Loads function paths from the in-source `config` function', async () => {
     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(distPath);
     expect(result.functions.length).toBe(7);
@@ -176,12 +209,10 @@ test('Passes validation if default export exists and is a function', async () =>
     };
     const path = join(tmpDir, `${func.name}.ts`);
     await fs.writeFile(path, func.source);
-    expect(async () => {
-        await getFunctionConfig({
-            name: func.name,
-            path,
-        }, new ImportMap([importMapFile]), deno, logger);
-    }).not.toThrow();
+    await expect(getFunctionConfig({
+        name: func.name,
+        path,
+    }, new ImportMap([importMapFile]), deno, logger, {})).resolves.not.toThrow();
     await deleteAsync(tmpDir, { force: true });
 });
 test('Fails validation if default export is not function', async () => {
@@ -205,7 +236,7 @@ test('Fails validation if default export is not function', async () => {
     const config = getFunctionConfig({
         name: func.name,
         path,
-    }, new ImportMap([importMapFile]), deno, logger);
+    }, new ImportMap([importMapFile]), deno, logger, {});
     await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
     await deleteAsync(tmpDir, { force: true });
 });
@@ -229,7 +260,7 @@ test('Fails validation if default export is not present', async () => {
     const config = getFunctionConfig({
         name: func.name,
         path,
-    }, new ImportMap([importMapFile]), deno, logger);
+    }, new ImportMap([importMapFile]), deno, logger, {});
     await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
     await deleteAsync(tmpDir, { force: true });
 });

package/dist/node/deploy_config.test.js

@@ -26,6 +26,7 @@ test('Returns a config object with declarations, layers, and import map', async
             {
                 function: 'func1',
                 path: '/func1',
+                generator: 'internalFunc',
             },
         ],
         layers: [

package/dist/node/downloader.test.js

@@ -1,4 +1,4 @@
-import { promises as fs } from 'fs';
+import { rm } from 'fs/promises';
 import { platform } from 'process';
 import { PassThrough } from 'stream';
 import { execa } from 'execa';
@@ -20,7 +20,7 @@ beforeEach(async (ctx) => {
     ctx.tmpDir = tmpDir.path;
 });
 afterEach(async (ctx) => {
-    await fs.rmdir(ctx.tmpDir, { recursive: true });
+    await rm(ctx.tmpDir, { force: true, recursive: true });
 });
 test('tries downloading binary up to 4 times', async (ctx) => {
     nock.disableNetConnect();

package/dist/node/feature_flags.d.ts

@@ -1,6 +1,12 @@
-declare const defaultFlags: Record<string, boolean>;
+declare const defaultFlags: {
+    edge_functions_fail_unsupported_regex: boolean;
+    edge_functions_invalid_config_throw: boolean;
+};
 type FeatureFlag = keyof typeof defaultFlags;
-type FeatureFlags = Record<FeatureFlag, boolean>;
-declare const getFlags: (input?: Record<string, boolean>, flags?: Record<string, boolean>) => FeatureFlags;
+type FeatureFlags = Partial<Record<FeatureFlag, boolean>>;
+declare const getFlags: (input?: Record<string, boolean>, flags?: {
+    edge_functions_fail_unsupported_regex: boolean;
+    edge_functions_invalid_config_throw: boolean;
+}) => FeatureFlags;
 export { defaultFlags, getFlags };
 export type { FeatureFlag, FeatureFlags };

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_fail_unsupported_regex: false,
+    edge_functions_invalid_config_throw: false,
 };
 const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
     ...result,

package/dist/node/formats/javascript.js

@@ -3,7 +3,7 @@ import { join } from 'path';
 import { env } from 'process';
 import { pathToFileURL } from 'url';
 import { deleteAsync } from 'del';
-const BOOTSTRAP_LATEST = 'https://6400da4c63e35700091e09d5--edge.netlify.com/bootstrap/index-combined.ts';
+const BOOTSTRAP_LATEST = 'https://64071f3033a1800007cc20f8--edge.netlify.com/bootstrap/index-combined.ts';
 const defaultFormatExportTypeError = (name) => `The Edge Function "${name}" has failed to load. Does it have a function as the default export?`;
 const defaultFormatImpoortError = (name) => `There was an error with Edge Function "${name}".`;
 const generateStage2 = async ({ distDirectory, fileName, formatExportTypeError, formatImportError, functions, }) => {

package/dist/node/main.test.js

@@ -1,5 +1,5 @@
 import { Buffer } from 'buffer';
-import fs from 'fs';
+import { rm } from 'fs/promises';
 import { createRequire } from 'module';
 import { platform } from 'process';
 import { PassThrough } from 'stream';
@@ -43,5 +43,5 @@ test('Downloads the Deno CLI on demand and caches it for subsequent calls', asyn
     expect((_d = output2 === null || output2 === void 0 ? void 0 : output2.stdout) !== null && _d !== void 0 ? _d : '').toMatch(expectedOutput);
     expect(beforeDownload).toHaveBeenCalledTimes(1);
     expect(afterDownload).toHaveBeenCalledTimes(1);
-    await fs.promises.rmdir(tmpDir.path, { recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true });
 });

package/dist/node/manifest.d.ts

@@ -12,6 +12,7 @@ interface Route {
 }
 interface EdgeFunctionConfig {
     excluded_patterns: string[];
+    on_error?: string;
 }
 interface Manifest {
     bundler_version: string;
@@ -37,12 +38,6 @@ interface GenerateManifestOptions {
     importMap?: string;
     layers?: Layer[];
 }
-interface Route {
-    function: string;
-    name?: string;
-    pattern: string;
-    generator?: string;
-}
 declare const generateManifest: ({ bundles, declarations, featureFlags, functions, functionConfig, importMap, layers, }: GenerateManifestOptions) => Manifest;
 interface WriteManifestOptions extends GenerateManifestOptions {
     distDirectory: string;

package/dist/node/manifest.js

@@ -12,7 +12,7 @@ const serializePattern = (pattern) => pattern.replace(/\\\//g, '/');
 const sanitizeEdgeFunctionConfig = (config) => {
     const newConfig = {};
     for (const [name, functionConfig] of Object.entries(config)) {
-        if (functionConfig.excluded_patterns.length !== 0) {
+        if (functionConfig.excluded_patterns.length !== 0 || functionConfig.on_error) {
             newConfig[name] = functionConfig;
         }
     }
@@ -22,12 +22,15 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
     const preCacheRoutes = [];
     const postCacheRoutes = [];
     const manifestFunctionConfig = Object.fromEntries(functions.map(({ name }) => [name, { excluded_patterns: [] }]));
-    for (const [name, { excludedPath }] of Object.entries(functionConfig)) {
+    for (const [name, { excludedPath, onError }] of Object.entries(functionConfig)) {
         if (excludedPath) {
             const paths = Array.isArray(excludedPath) ? excludedPath : [excludedPath];
             const excludedPatterns = paths.map(pathToRegularExpression).map(serializePattern);
             manifestFunctionConfig[name].excluded_patterns.push(...excludedPatterns);
         }
+        if (onError) {
+            manifestFunctionConfig[name].on_error = onError;
+        }
     }
     declarations.forEach((declaration) => {
         const func = functions.find(({ name }) => declaration.function === name);

package/dist/node/manifest.test.js

@@ -84,6 +84,25 @@ test('Generates a manifest with excluded paths and patterns', () => {
     });
     expect(manifest.bundler_version).toBe(env.npm_package_version);
 });
+test('Includes failure modes in manifest', () => {
+    const functions = [
+        { name: 'func-1', path: '/path/to/func-1.ts' },
+        { name: 'func-2', path: '/path/to/func-2.ts' },
+    ];
+    const declarations = [
+        { function: 'func-1', name: 'Display Name', path: '/f1/*' },
+        { function: 'func-2', pattern: '^/f2/.*/?$' },
+    ];
+    const functionConfig = {
+        'func-1': {
+            onError: '/custom-error',
+        },
+    };
+    const manifest = generateManifest({ bundles: [], declarations, functions, functionConfig });
+    expect(manifest.function_config).toEqual({
+        'func-1': { excluded_patterns: [], on_error: '/custom-error' },
+    });
+});
 test('Excludes functions for which there are function files but no matching config declarations', () => {
     const bundle1 = {
         extension: '.ext2',

package/dist/node/server/server.js

@@ -42,7 +42,7 @@ const prepareServer = ({ deno, distDirectory, flags: denoFlags, formatExportType
         });
         let functionsConfig = [];
         if (options.getFunctionsConfig) {
-            functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig(func, importMap, deno, logger)));
+            functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig(func, importMap, deno, logger, {})));
         }
         const success = await waitForServer(port, processRef.ps);
         return {

package/dist/node/types.test.js

@@ -1,4 +1,4 @@
-import { promises as fs } from 'fs';
+import { readFile, rm, writeFile } from 'fs/promises';
 import { join } from 'path';
 import nock from 'nock';
 import tmp from 'tmp-promise';
@@ -18,20 +18,20 @@ test('`ensureLatestTypes` updates the Deno CLI cache if the local version of typ
     // @ts-expect-error return value not used
     const mock = vi.spyOn(deno, 'run').mockResolvedValue({});
     await ensureLatestTypes(deno, testLogger, mockURL);
-    const versionFile = await fs.readFile(join(tmpDir.path, 'types-version.txt'), 'utf8');
+    const versionFile = await readFile(join(tmpDir.path, 'types-version.txt'), 'utf8');
     expect(latestVersionMock.isDone()).toBe(true);
     expect(mock).toHaveBeenCalledTimes(1);
     expect(mock).toHaveBeenCalledWith(['cache', '-r', mockURL]);
     expect(versionFile).toBe(mockVersion);
     mock.mockRestore();
-    await fs.rmdir(tmpDir.path, { recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true });
 });
 test('`ensureLatestTypes` does not update the Deno CLI cache if the local version of types is up-to-date', async () => {
     const mockURL = 'https://edge.netlify';
     const mockVersion = '987654321';
     const tmpDir = await tmp.dir();
     const versionFilePath = join(tmpDir.path, 'types-version.txt');
-    await fs.writeFile(versionFilePath, mockVersion);
+    await writeFile(versionFilePath, mockVersion);
     const latestVersionMock = nock(mockURL).get('/version.txt').reply(200, mockVersion);
     const deno = new DenoBridge({
         cacheDirectory: tmpDir.path,
@@ -43,7 +43,7 @@ test('`ensureLatestTypes` does not update the Deno CLI cache if the local versio
     expect(latestVersionMock.isDone()).toBe(true);
     expect(mock).not.toHaveBeenCalled();
     mock.mockRestore();
-    await fs.rmdir(tmpDir.path, { recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true });
 });
 test('`ensureLatestTypes` does not throw if the types URL is not available', async () => {
     const mockURL = 'https://edge.netlify';
@@ -59,5 +59,5 @@ test('`ensureLatestTypes` does not throw if the types URL is not available', asy
     expect(latestVersionMock.isDone()).toBe(true);
     expect(mock).not.toHaveBeenCalled();
     mock.mockRestore();
-    await fs.rmdir(tmpDir.path, { recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true });
 });

package/dist/node/validation/manifest/index.test.js

@@ -1,5 +1,9 @@
+import chalk from 'chalk';
 import { test, expect, describe } from 'vitest';
 import { validateManifest, ManifestValidationError } from './index.js';
+// We need to disable all color outputs for the tests as they are different on different platforms, CI, etc.
+// This only works if this is the same instance of chalk that better-ajv-errors uses
+chalk.level = 0;
 // Factory so we have a new object per test
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const getBaseManifest = () => ({

package/dist/node/validation/manifest/schema.d.ts

@@ -106,6 +106,9 @@ declare const edgeManifestSchema: {
                             errorMessage: string;
                         };
                     };
+                    on_error: {
+                        type: string;
+                    };
                 };
             };
         };

package/dist/node/validation/manifest/schema.js

@@ -34,6 +34,7 @@ const functionConfigSchema = {
                 errorMessage: 'excluded_patterns needs to be an array of regex that starts with ^ and ends with $ without any additional slashes before and afterwards',
             },
         },
+        on_error: { type: 'string' },
     },
 };
 const layersSchema = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "8.9.0",
+  "version": "8.11.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -14,6 +14,7 @@
   ],
   "scripts": {
     "build": "tsc",
+    "build:dev": "tsc -w",
     "prepare": "husky install node_modules/@netlify/eslint-config-node/.husky/",
     "prepublishOnly": "npm ci && npm test",
     "prepack": "npm run build",
@@ -28,10 +29,10 @@
     "format:fix:prettier": "cross-env-shell prettier --write $npm_package_config_prettier",
     "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:vitest": "vitest run",
+    "test:dev:vitest:watch": "vitest watch",
     "test:dev:deno": "deno test --allow-all deno",
-    "test:ci:vitest": "cross-env FORCE_COLOR=0 vitest run",
+    "test:ci:vitest": "vitest run",
     "test:ci:deno": "deno test --allow-all deno",
     "test:integration": "node --experimental-modules test/integration/test.js"
   },
@@ -52,7 +53,7 @@
   "devDependencies": {
     "@commitlint/cli": "^17.0.0",
     "@commitlint/config-conventional": "^17.0.0",
-    "@netlify/eslint-config-node": "^4.1.7",
+    "@netlify/eslint-config-node": "^7.0.1",
     "@types/glob-to-regexp": "^0.4.1",
     "@types/node": "^14.18.32",
     "@types/semver": "^7.3.9",
@@ -60,6 +61,7 @@
     "@types/uuid": "^9.0.0",
     "@vitest/coverage-c8": "^0.25.0",
     "archiver": "^5.3.1",
+    "chalk": "^4.1.2",
     "cpy": "^9.0.1",
     "cross-env": "^7.0.3",
     "husky": "^8.0.0",
@@ -84,6 +86,7 @@
     "find-up": "^6.3.0",
     "get-port": "^6.1.2",
     "glob-to-regexp": "^0.4.1",
+    "is-path-inside": "^4.0.0",
     "jsonc-parser": "^3.2.0",
     "node-fetch": "^3.1.1",
     "node-stream-zip": "^1.15.0",