@netlify/edge-bundler 8.5.0 → 8.7.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/declaration.d.ts

@@ -4,6 +4,7 @@ interface BaseDeclaration {
     cache?: string;
     function: string;
     name?: string;
+    generator?: string;
 }
 type DeclarationWithPath = BaseDeclaration & {
     path: string;

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,11 +2,13 @@ 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;
     name?: string;
     pattern: string;
+    generator?: string;
 }
 interface EdgeFunctionConfig {
     excluded_patterns: string[];
@@ -29,6 +31,7 @@ interface Manifest {
 interface GenerateManifestOptions {
     bundles?: Bundle[];
     declarations?: Declaration[];
+    featureFlags?: FeatureFlags;
     functions: EdgeFunction[];
     functionConfig?: Record<string, FunctionConfig>;
     importMap?: string;
@@ -38,8 +41,9 @@ interface Route {
     function: string;
     name?: string;
     pattern: string;
+    generator?: 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,14 @@ 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),
+            generator: declaration.generator,
         };
-        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 +77,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', () => {
@@ -42,6 +42,27 @@ test('Generates a manifest with display names', () => {
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.bundler_version).toBe(env.npm_package_version);
 });
+test('Generates a manifest with a generator field', () => {
+    const functions = [
+        { name: 'func-1', path: '/path/to/func-1.ts' },
+        { name: 'func-2', path: '/path/to/func-2.ts' },
+        { name: 'func-3', path: '/path/to/func-3.ts' },
+    ];
+    const declarations = [
+        { function: 'func-1', generator: '@netlify/fake-plugin@1.0.0', path: '/f1/*' },
+        { function: 'func-2', path: '/f2/*' },
+        { function: 'func-3', generator: '@netlify/fake-plugin@1.0.0', cache: 'manual', path: '/f3' },
+    ];
+    const manifest = generateManifest({ bundles: [], declarations, functions });
+    const expectedRoutes = [
+        { function: 'func-1', generator: '@netlify/fake-plugin@1.0.0', pattern: '^/f1/.*/?$' },
+        { function: 'func-2', pattern: '^/f2/.*/?$' },
+    ];
+    const expectedPostCacheRoutes = [{ function: 'func-3', generator: '@netlify/fake-plugin@1.0.0', pattern: '^/f3/?$' }];
+    expect(manifest.routes).toEqual(expectedRoutes);
+    expect(manifest.post_cache_routes).toEqual(expectedPostCacheRoutes);
+    expect(manifest.bundler_version).toBe(env.npm_package_version);
+});
 test('Generates a manifest with excluded paths and patterns', () => {
     const functions = [
         { name: 'func-1', path: '/path/to/func-1.ts' },
@@ -164,10 +185,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)$' }];
+    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, functions })).toThrowError(/^Could not parse path declaration of function 'func-1': Regular expressions with lookaheads are not supported$/);
+    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/dist/node/validation/manifest/index.test.js

@@ -14,6 +14,7 @@ const getBaseManifest = () => ({
             name: 'name',
             function: 'hello',
             pattern: '^/hello/?$',
+            generator: '@netlify/fake-plugin@1.0.0',
         },
     ],
     post_cache_routes: [
@@ -21,6 +22,7 @@ const getBaseManifest = () => ({
             name: 'name',
             function: 'hello',
             pattern: '^/hello/?$',
+            generator: '@netlify/fake-plugin@1.0.0',
         },
     ],
     layers: [

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

@@ -36,6 +36,9 @@ declare const edgeManifestSchema: {
                         format: string;
                         errorMessage: string;
                     };
+                    generator: {
+                        type: string;
+                    };
                 };
                 additionalProperties: boolean;
             };
@@ -57,6 +60,9 @@ declare const edgeManifestSchema: {
                         format: string;
                         errorMessage: string;
                     };
+                    generator: {
+                        type: string;
+                    };
                 };
                 additionalProperties: boolean;
             };

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

@@ -18,6 +18,7 @@ const routesSchema = {
             format: 'regexPattern',
             errorMessage: 'pattern needs to be a regex that starts with ^ and ends with $ without any additional slashes before and afterwards',
         },
+        generator: { type: 'string' },
     },
     additionalProperties: false,
 };

package/package.json

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