@netlify/edge-bundler 8.5.0 → 8.6.0

package/dist/node/bundler.js

@@ -74,6 +74,7 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
         bundles: [functionBundle],
         declarations,
         distDirectory,
+        featureFlags,
         functions,
         functionConfig: functionsWithConfig,
         importMap: importMapSpecifier,

package/dist/node/feature_flags.js

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

package/dist/node/manifest.d.ts

@@ -2,6 +2,7 @@ import type { Bundle } from './bundle.js';
 import { FunctionConfig } from './config.js';
 import { Declaration } from './declaration.js';
 import { EdgeFunction } from './edge_function.js';
+import { FeatureFlags } from './feature_flags.js';
 import { Layer } from './layer.js';
 interface Route {
     function: string;
@@ -29,6 +30,7 @@ interface Manifest {
 interface GenerateManifestOptions {
     bundles?: Bundle[];
     declarations?: Declaration[];
+    featureFlags?: FeatureFlags;
     functions: EdgeFunction[];
     functionConfig?: Record<string, FunctionConfig>;
     importMap?: string;
@@ -39,7 +41,7 @@ interface Route {
     name?: string;
     pattern: string;
 }
-declare const generateManifest: ({ bundles, declarations, functions, functionConfig, importMap, layers, }: GenerateManifestOptions) => Manifest;
+declare const generateManifest: ({ bundles, declarations, featureFlags, functions, functionConfig, importMap, layers, }: GenerateManifestOptions) => Manifest;
 interface WriteManifestOptions extends GenerateManifestOptions {
     distDirectory: string;
 }

package/dist/node/manifest.js

@@ -18,7 +18,7 @@ const sanitizeEdgeFunctionConfig = (config) => {
     }
     return newConfig;
 };
-const generateManifest = ({ bundles = [], declarations = [], functions, functionConfig = {}, importMap, layers = [], }) => {
+const generateManifest = ({ bundles = [], declarations = [], featureFlags, functions, functionConfig = {}, importMap, layers = [], }) => {
     const preCacheRoutes = [];
     const postCacheRoutes = [];
     const manifestFunctionConfig = Object.fromEntries(functions.map(({ name }) => [name, { excluded_patterns: [] }]));
@@ -34,13 +34,13 @@ const generateManifest = ({ bundles = [], declarations = [], functions, function
         if (func === undefined) {
             return;
         }
-        const pattern = getRegularExpression(declaration);
+        const pattern = getRegularExpression(declaration, featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_fail_unsupported_regex);
         const route = {
             function: func.name,
             name: declaration.name,
             pattern: serializePattern(pattern),
         };
-        const excludedPattern = getExcludedRegularExpression(declaration);
+        const excludedPattern = getExcludedRegularExpression(declaration, featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_fail_unsupported_regex);
         if (excludedPattern) {
             manifestFunctionConfig[func.name].excluded_patterns.push(serializePattern(excludedPattern));
         }
@@ -76,24 +76,34 @@ const pathToRegularExpression = (path) => {
     const normalizedSource = `^${regularExpression.source}\\/?$`;
     return normalizedSource;
 };
-const getRegularExpression = (declaration) => {
+const getRegularExpression = (declaration, failUnsupportedRegex = false) => {
     if ('pattern' in declaration) {
         try {
             return parsePattern(declaration.pattern);
         }
         catch (error) {
-            throw new Error(`Could not parse path declaration of function '${declaration.function}': ${error.message}`);
+            // eslint-disable-next-line max-depth
+            if (failUnsupportedRegex) {
+                throw new Error(`Could not parse path declaration of function '${declaration.function}': ${error.message}`);
+            }
+            console.warn(`Function '${declaration.function}' uses an unsupported regular expression and will not be invoked: ${error.message}`);
+            return declaration.pattern;
         }
     }
     return pathToRegularExpression(declaration.path);
 };
-const getExcludedRegularExpression = (declaration) => {
+const getExcludedRegularExpression = (declaration, failUnsupportedRegex = false) => {
     if ('excludedPattern' in declaration && declaration.excludedPattern) {
         try {
             return parsePattern(declaration.excludedPattern);
         }
         catch (error) {
-            throw new Error(`Could not parse path declaration of function '${declaration.function}': ${error.message}`);
+            // eslint-disable-next-line max-depth
+            if (failUnsupportedRegex) {
+                throw new Error(`Could not parse path declaration of function '${declaration.function}': ${error.message}`);
+            }
+            console.warn(`Function '${declaration.function}' uses an unsupported regular expression and will therefore not be invoked: ${error.message}`);
+            return declaration.excludedPattern;
         }
     }
     if ('path' in declaration && declaration.excludedPath) {

package/dist/node/manifest.test.js

@@ -1,5 +1,5 @@
 import { env } from 'process';
-import { test, expect } from 'vitest';
+import { test, expect, vi } from 'vitest';
 import { BundleFormat } from './bundle.js';
 import { generateManifest } from './manifest.js';
 test('Generates a manifest with different bundles', () => {
@@ -164,10 +164,31 @@ test('Generates a manifest with layers', () => {
     expect(manifest2.routes).toEqual(expectedRoutes);
     expect(manifest2.layers).toEqual(layers);
 });
-test('Throws an error if the regular expression contains a negative lookahead', () => {
+test('Shows a warning if the regular expression contains a negative lookahead', () => {
+    const mockConsoleWarn = vi.fn();
+    const consoleWarn = console.warn;
+    console.warn = mockConsoleWarn;
     const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
     const declarations = [{ function: 'func-1', pattern: '^/\\w+(?=\\d)$' }];
-    expect(() => generateManifest({ bundles: [], declarations, functions })).toThrowError(/^Could not parse path declaration of function 'func-1': Regular expressions with lookaheads are not supported$/);
+    const manifest = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+    });
+    console.warn = consoleWarn;
+    expect(manifest.routes).toEqual([{ function: 'func-1', pattern: '^/\\w+(?=\\d)$' }]);
+    expect(mockConsoleWarn).toHaveBeenCalledOnce();
+    expect(mockConsoleWarn).toHaveBeenCalledWith("Function 'func-1' uses an unsupported regular expression and will not be invoked: Regular expressions with lookaheads are not supported");
+});
+test('Throws an error if the regular expression contains a negative lookahead and the `edge_functions_fail_unsupported_regex` flag is set', () => {
+    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+    const declarations = [{ function: 'func-1', pattern: '^/\\w+(?=\\d)$' }];
+    expect(() => generateManifest({
+        bundles: [],
+        declarations,
+        featureFlags: { edge_functions_fail_unsupported_regex: true },
+        functions,
+    })).toThrowError(/^Could not parse path declaration of function 'func-1': Regular expressions with lookaheads are not supported$/);
 });
 test('Converts named capture groups to unnamed capture groups in regular expressions', () => {
     const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];

package/package.json

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