@netlify/edge-bundler 8.14.2 → 8.15.0

package/dist/node/bundler.test.js

@@ -283,13 +283,13 @@ test('Loads declarations and import maps from the deploy configuration and in-so
     expect(generatedFiles.length).toBe(2);
     const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
-    const { bundles, function_config: functionConfig } = manifest;
+    const { bundles, function_config: functionConfig, routes } = manifest;
     expect(bundles.length).toBe(1);
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
     // respects excludedPath from deploy config
+    expect(routes[0].excluded_patterns).toEqual(['^/func2/skip/?$']);
     expect(functionConfig.func2).toEqual({
-        excluded_patterns: ['^/func2/skip/?$'],
         name: 'Function two',
         generator: '@netlify/fake-plugin@1.0.0',
     });

package/dist/node/config.test.js

@@ -160,14 +160,14 @@ test('Loads function paths from the in-source `config` function', async () => {
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
     expect(routes.length).toBe(6);
-    expect(routes[0]).toEqual({ function: 'framework-func2', pattern: '^/framework-func2/?$' });
-    expect(routes[1]).toEqual({ function: 'user-func2', pattern: '^/user-func2/?$' });
-    expect(routes[2]).toEqual({ function: 'framework-func1', pattern: '^/framework-func1/?$' });
-    expect(routes[3]).toEqual({ function: 'user-func1', pattern: '^/user-func1/?$' });
-    expect(routes[4]).toEqual({ function: 'user-func3', pattern: '^/user-func3/?$' });
-    expect(routes[5]).toEqual({ function: 'user-func5', pattern: '^/user-func5/.*/?$' });
+    expect(routes[0]).toEqual({ function: 'framework-func2', pattern: '^/framework-func2/?$', excluded_patterns: [] });
+    expect(routes[1]).toEqual({ function: 'user-func2', pattern: '^/user-func2/?$', excluded_patterns: [] });
+    expect(routes[2]).toEqual({ function: 'framework-func1', pattern: '^/framework-func1/?$', excluded_patterns: [] });
+    expect(routes[3]).toEqual({ function: 'user-func1', pattern: '^/user-func1/?$', excluded_patterns: [] });
+    expect(routes[4]).toEqual({ function: 'user-func3', pattern: '^/user-func3/?$', excluded_patterns: [] });
+    expect(routes[5]).toEqual({ function: 'user-func5', pattern: '^/user-func5/.*/?$', excluded_patterns: [] });
     expect(postCacheRoutes.length).toBe(1);
-    expect(postCacheRoutes[0]).toEqual({ function: 'user-func4', pattern: '^/user-func4/?$' });
+    expect(postCacheRoutes[0]).toEqual({ function: 'user-func4', pattern: '^/user-func4/?$', excluded_patterns: [] });
     expect(Object.keys(functionConfig)).toHaveLength(1);
     expect(functionConfig['user-func5']).toEqual({
         excluded_patterns: ['^/user-func5/excluded/?$'],

package/dist/node/declaration.d.ts

@@ -8,11 +8,11 @@ interface BaseDeclaration {
 }
 type DeclarationWithPath = BaseDeclaration & {
     path: Path;
-    excludedPath?: Path;
+    excludedPath?: Path | Path[];
 };
 type DeclarationWithPattern = BaseDeclaration & {
     pattern: string;
-    excludedPattern?: string;
+    excludedPattern?: string | string[];
 };
 export type Declaration = DeclarationWithPath | DeclarationWithPattern;
 export declare const mergeDeclarations: (tomlDeclarations: Declaration[], userFunctionsConfig: Record<string, FunctionConfig>, internalFunctionsConfig: Record<string, FunctionConfig>, deployConfigDeclarations: Declaration[], _featureFlags?: FeatureFlags) => Declaration[];

package/dist/node/manifest.d.ts

@@ -7,6 +7,7 @@ import { Layer } from './layer.js';
 interface Route {
     function: string;
     pattern: string;
+    excluded_patterns: string[];
 }
 interface EdgeFunctionConfig {
     excluded_patterns: string[];

package/dist/node/manifest.js

@@ -58,14 +58,12 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
             return;
         }
         const pattern = getRegularExpression(declaration, featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_fail_unsupported_regex);
+        const excludedPattern = getExcludedRegularExpressions(declaration, featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_fail_unsupported_regex);
         const route = {
             function: func.name,
             pattern: serializePattern(pattern),
+            excluded_patterns: excludedPattern.map(serializePattern),
         };
-        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));
-        }
         if (declaration.cache === "manual" /* Cache.Manual */) {
             postCacheRoutes.push(route);
         }
@@ -114,23 +112,29 @@ const getRegularExpression = (declaration, failUnsupportedRegex = false) => {
     }
     return pathToRegularExpression(declaration.path);
 };
-const getExcludedRegularExpression = (declaration, failUnsupportedRegex = false) => {
+const getExcludedRegularExpressions = (declaration, failUnsupportedRegex = false) => {
     if ('excludedPattern' in declaration && declaration.excludedPattern) {
-        try {
-            return parsePattern(declaration.excludedPattern);
-        }
-        catch (error) {
-            // eslint-disable-next-line max-depth
-            if (failUnsupportedRegex) {
-                throw new Error(`Could not parse path declaration of function '${declaration.function}': ${error.message}`);
+        const excludedPatterns = Array.isArray(declaration.excludedPattern)
+            ? declaration.excludedPattern
+            : [declaration.excludedPattern];
+        return excludedPatterns.map((excludedPattern) => {
+            try {
+                return parsePattern(excludedPattern);
             }
-            console.warn(`Function '${declaration.function}' uses an unsupported regular expression and will therefore not be invoked: ${error.message}`);
-            return declaration.excludedPattern;
-        }
+            catch (error) {
+                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 excludedPattern;
+            }
+        });
     }
     if ('path' in declaration && declaration.excludedPath) {
-        return pathToRegularExpression(declaration.excludedPath);
+        const paths = Array.isArray(declaration.excludedPath) ? declaration.excludedPath : [declaration.excludedPath];
+        return paths.map(pathToRegularExpression);
     }
+    return [];
 };
 const writeManifest = async ({ distDirectory, ...rest }) => {
     const manifest = generateManifest(rest);

package/dist/node/manifest.test.js

@@ -21,7 +21,7 @@ test('Generates a manifest with different bundles', () => {
         { asset: bundle1.hash + bundle1.extension, format: bundle1.format },
         { asset: bundle2.hash + bundle2.extension, format: bundle2.format },
     ];
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$' }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [] }];
     expect(manifest.bundles).toEqual(expectedBundles);
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.bundler_version).toBe(env.npm_package_version);
@@ -35,7 +35,7 @@ test('Generates a manifest with display names', () => {
         },
     };
     const manifest = generateManifest({ bundles: [], declarations, functions, internalFunctionConfig });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$' }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$', excluded_patterns: [] }];
     expect(manifest.function_config).toEqual({
         'func-1': { name: 'Display Name' },
     });
@@ -51,7 +51,7 @@ test('Generates a manifest with a generator field', () => {
         },
     };
     const manifest = generateManifest({ bundles: [], declarations, functions, internalFunctionConfig });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$' }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$', excluded_patterns: [] }];
     const expectedFunctionConfig = { 'func-1': { generator: '@netlify/fake-plugin@1.0.0' } };
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.function_config).toEqual(expectedFunctionConfig);
@@ -65,21 +65,17 @@ test('Generates a manifest with excluded paths and patterns', () => {
     ];
     const declarations = [
         { function: 'func-1', path: '/f1/*', excludedPath: '/f1/exclude' },
-        { function: 'func-2', pattern: '^/f2/.*/?$', excludedPattern: '^/f2/exclude$' },
+        { function: 'func-2', pattern: '^/f2/.*/?$', excludedPattern: ['^/f2/exclude$', '^/f2/exclude-as-well$'] },
         { function: 'func-3', path: '/*', excludedPath: '/**/*.html' },
     ];
     const manifest = generateManifest({ bundles: [], declarations, functions });
     const expectedRoutes = [
-        { function: 'func-1', pattern: '^/f1/.*/?$' },
-        { function: 'func-2', pattern: '^/f2/.*/?$' },
-        { function: 'func-3', pattern: '^/.*/?$' },
+        { function: 'func-1', pattern: '^/f1/.*/?$', excluded_patterns: ['^/f1/exclude/?$'] },
+        { function: 'func-2', pattern: '^/f2/.*/?$', excluded_patterns: ['^/f2/exclude$', '^/f2/exclude-as-well$'] },
+        { function: 'func-3', pattern: '^/.*/?$', excluded_patterns: ['^/.*/.*\\.html/?$'] },
     ];
     expect(manifest.routes).toEqual(expectedRoutes);
-    expect(manifest.function_config).toEqual({
-        'func-1': { excluded_patterns: ['^/f1/exclude/?$'] },
-        'func-2': { excluded_patterns: ['^/f2/exclude$'] },
-        'func-3': { excluded_patterns: ['^/.*/.*\\.html/?$'] },
-    });
+    expect(manifest.function_config).toEqual({});
     expect(manifest.bundler_version).toBe(env.npm_package_version);
     const matcher = getRouteMatcher(manifest);
     expect((_a = matcher('/f1/hello')) === null || _a === void 0 ? void 0 : _a.function).toBe('func-1');
@@ -92,7 +88,7 @@ test('TOML-defined paths can be combined with ISC-defined excluded paths', () =>
         'func-1': { excludedPath: '/f1/exclude' },
     };
     const manifest = generateManifest({ bundles: [], declarations, functions, userFunctionConfig });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$' }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$', excluded_patterns: [] }];
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.function_config).toEqual({
         'func-1': { excluded_patterns: ['^/f1/exclude/?$'] },
@@ -149,6 +145,49 @@ test('Filters out internal in-source configurations in user created functions',
         },
     });
 });
+test('excludedPath from ISC goes into function_config, TOML goes into routes', () => {
+    const functions = [{ name: 'customisation', path: '/path/to/customisation.ts' }];
+    const declarations = [
+        { function: 'customisation', path: '/showcases/*' },
+        { function: 'customisation', path: '/checkout/*', excludedPath: ['/*/terms-and-conditions'] },
+    ];
+    const userFunctionConfig = {
+        customisation: {
+            excludedPath: ['/*.css', '/*.jpg'],
+        },
+    };
+    const internalFunctionConfig = {};
+    const manifest = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        userFunctionConfig,
+        internalFunctionConfig,
+    });
+    expect(manifest.routes).toEqual([
+        {
+            function: 'customisation',
+            pattern: '^/showcases/.*/?$',
+            excluded_patterns: [],
+        },
+        {
+            function: 'customisation',
+            pattern: '^/checkout/.*/?$',
+            excluded_patterns: ['^/.*/terms-and-conditions/?$'],
+        },
+    ]);
+    expect(manifest.function_config).toEqual({
+        customisation: {
+            excluded_patterns: ['^/.*\\.css/?$', '^/.*\\.jpg/?$'],
+        },
+    });
+    const matcher = getRouteMatcher(manifest);
+    expect(matcher('/showcases/boho-style')).toBeDefined();
+    expect(matcher('/checkout/address')).toBeDefined();
+    expect(matcher('/checkout/terms-and-conditions')).toBeUndefined();
+    expect(matcher('/checkout/scrooge-mc-duck-animation.css')).toBeUndefined();
+    expect(matcher('/showcases/boho-style/expensive-chair.jpg')).toBeUndefined();
+});
 test('Includes failure modes in manifest', () => {
     const functions = [
         { name: 'func-1', path: '/path/to/func-1.ts' },
@@ -180,7 +219,7 @@ test('Excludes functions for which there are function files but no matching conf
     ];
     const declarations = [{ function: 'func-1', path: '/f1' }];
     const manifest = generateManifest({ bundles: [bundle1], declarations, functions });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$' }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [] }];
     expect(manifest.routes).toEqual(expectedRoutes);
 });
 test('Excludes functions for which there are config declarations but no matching function files', () => {
@@ -195,14 +234,14 @@ test('Excludes functions for which there are config declarations but no matching
         { function: 'func-2', path: '/f2' },
     ];
     const manifest = generateManifest({ bundles: [bundle1], declarations, functions });
-    const expectedRoutes = [{ function: 'func-2', pattern: '^/f2/?$' }];
+    const expectedRoutes = [{ function: 'func-2', pattern: '^/f2/?$', excluded_patterns: [] }];
     expect(manifest.routes).toEqual(expectedRoutes);
 });
 test('Generates a manifest without bundles', () => {
     const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
     const declarations = [{ function: 'func-1', path: '/f1' }];
     const manifest = generateManifest({ bundles: [], declarations, functions });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$' }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [] }];
     expect(manifest.bundles).toEqual([]);
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.bundler_version).toBe(env.npm_package_version);
@@ -234,10 +273,10 @@ test('Generates a manifest with pre and post-cache routes', () => {
         { asset: bundle2.hash + bundle2.extension, format: bundle2.format },
     ];
     const expectedPreCacheRoutes = [
-        { function: 'func-1', name: undefined, pattern: '^/f1/?$' },
-        { function: 'func-2', name: undefined, pattern: '^/f2/?$' },
+        { function: 'func-1', name: undefined, pattern: '^/f1/?$', excluded_patterns: [] },
+        { function: 'func-2', name: undefined, pattern: '^/f2/?$', excluded_patterns: [] },
     ];
-    const expectedPostCacheRoutes = [{ function: 'func-3', name: undefined, pattern: '^/f3/?$' }];
+    const expectedPostCacheRoutes = [{ function: 'func-3', name: undefined, pattern: '^/f3/?$', excluded_patterns: [] }];
     expect(manifest.bundles).toEqual(expectedBundles);
     expect(manifest.routes).toEqual(expectedPreCacheRoutes);
     expect(manifest.post_cache_routes).toEqual(expectedPostCacheRoutes);
@@ -253,8 +292,8 @@ test('Generates a manifest with layers', () => {
         { function: 'func-2', path: '/f2/*' },
     ];
     const expectedRoutes = [
-        { function: 'func-1', pattern: '^/f1/.*/?$' },
-        { function: 'func-2', pattern: '^/f2/.*/?$' },
+        { function: 'func-1', pattern: '^/f1/.*/?$', excluded_patterns: [] },
+        { function: 'func-2', pattern: '^/f2/.*/?$', excluded_patterns: [] },
     ];
     const layers = [
         {
@@ -281,7 +320,7 @@ test('Shows a warning if the regular expression contains a negative lookahead',
         functions,
     });
     console.warn = consoleWarn;
-    expect(manifest.routes).toEqual([{ function: 'func-1', pattern: '^/\\w+(?=\\d)$' }]);
+    expect(manifest.routes).toEqual([{ function: 'func-1', pattern: '^/\\w+(?=\\d)$', excluded_patterns: [] }]);
     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");
 });
@@ -299,5 +338,5 @@ test('Converts named capture groups to unnamed capture groups in regular express
     const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
     const declarations = [{ function: 'func-1', pattern: '^/(?<name>\\w+)$' }];
     const manifest = generateManifest({ bundles: [], declarations, functions });
-    expect(manifest.routes).toEqual([{ function: 'func-1', pattern: '^/(\\w+)$' }]);
+    expect(manifest.routes).toEqual([{ function: 'func-1', pattern: '^/(\\w+)$', excluded_patterns: [] }]);
 });

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

@@ -36,6 +36,14 @@ declare const edgeManifestSchema: {
                         format: string;
                         errorMessage: string;
                     };
+                    excluded_patterns: {
+                        type: string;
+                        items: {
+                            type: string;
+                            format: string;
+                            errorMessage: string;
+                        };
+                    };
                     generator: {
                         type: string;
                     };
@@ -60,6 +68,14 @@ declare const edgeManifestSchema: {
                         format: string;
                         errorMessage: string;
                     };
+                    excluded_patterns: {
+                        type: string;
+                        items: {
+                            type: string;
+                            format: string;
+                            errorMessage: string;
+                        };
+                    };
                     generator: {
                         type: string;
                     };

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

@@ -7,6 +7,14 @@ const bundlesSchema = {
     },
     additionalProperties: false,
 };
+const excludedPatternsSchema = {
+    type: 'array',
+    items: {
+        type: 'string',
+        format: 'regexPattern',
+        errorMessage: 'excluded_patterns must be an array of regex that starts with ^ and ends with $ (e.g. ^/blog/[d]{4}$)',
+    },
+};
 const routesSchema = {
     type: 'object',
     required: ['function', 'pattern'],
@@ -18,6 +26,7 @@ const routesSchema = {
             format: 'regexPattern',
             errorMessage: 'pattern must be a regex that starts with ^ and ends with $ (e.g. ^/blog/[d]{4}$)',
         },
+        excluded_patterns: excludedPatternsSchema,
         generator: { type: 'string' },
     },
     additionalProperties: false,
@@ -26,14 +35,7 @@ const functionConfigSchema = {
     type: 'object',
     required: [],
     properties: {
-        excluded_patterns: {
-            type: 'array',
-            items: {
-                type: 'string',
-                format: 'regexPattern',
-                errorMessage: 'excluded_patterns must be an array of regex that starts with ^ and ends with $ (e.g. ^/blog/[d]{4}$)',
-            },
-        },
+        excluded_patterns: excludedPatternsSchema,
         on_error: { type: 'string' },
     },
 };

package/dist/test/util.js

@@ -36,12 +36,16 @@ const inspectFunction = (path) => `
   console.log(JSON.stringify(responses));
 `;
 const getRouteMatcher = (manifest) => (candidate) => manifest.routes.find((route) => {
+    var _a, _b;
     const regex = new RegExp(route.pattern);
     if (!regex.test(candidate)) {
         return false;
     }
-    const excludedPattern = manifest.function_config[route.function].excluded_patterns;
-    const isExcluded = excludedPattern.some((pattern) => new RegExp(pattern).test(candidate));
+    if (route.excluded_patterns.some((pattern) => new RegExp(pattern).test(candidate))) {
+        return false;
+    }
+    const excludedPatterns = (_b = (_a = manifest.function_config[route.function]) === null || _a === void 0 ? void 0 : _a.excluded_patterns) !== null && _b !== void 0 ? _b : [];
+    const isExcluded = excludedPatterns.some((pattern) => new RegExp(pattern).test(candidate));
     return !isExcluded;
 });
 const runESZIP = async (eszipPath) => {

package/package.json

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