@netlify/edge-bundler 8.10.0 → 8.11.0

package/dist/node/config.d.ts

@@ -7,9 +7,12 @@ 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, featureFlags: FeatureFlags) => Promise<FunctionConfig>;

package/dist/node/config.js

@@ -14,6 +14,13 @@ 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');
@@ -52,17 +59,21 @@ export const getFunctionConfig = async (func, importMap, deno, log, featureFlags
     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 {
         handleConfigError(func, ConfigExitCode.UnhandledError, stderr, log, featureFlags);
-        return {};
     }
     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 handleConfigError = (func, exitCode, stderr, log, featureFlags) => {
     switch (exitCode) {

package/dist/node/config.test.js

@@ -89,6 +89,24 @@ const functions = [
             edge_functions_invalid_config_throw: false,
         },
     },
+    {
+        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' },

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/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.10.0",
+  "version": "8.11.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",