@netlify/edge-bundler 8.16.4 → 8.17.0

package/dist/node/config.test.js

@@ -149,6 +149,7 @@ 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_path_urlpattern: true },
     });
     const generatedFiles = await fs.readdir(distPath);
     expect(result.functions.length).toBe(7);
@@ -165,7 +166,7 @@ test('Loads function paths from the in-source `config` function', async () => {
     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(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/?$', excluded_patterns: [] });
     expect(Object.keys(functionConfig)).toHaveLength(1);

package/dist/node/feature_flags.d.ts

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

package/dist/node/feature_flags.js

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

package/dist/node/manifest.js

@@ -4,6 +4,7 @@ import globToRegExp from 'glob-to-regexp';
 import { parsePattern } from './declaration.js';
 import { getPackageVersion } from './package_json.js';
 import { nonNullable } from './utils/non_nullable.js';
+import { ExtendedURLPattern } from './utils/urlpattern.js';
 const removeEmptyConfigValues = (functionConfig) => Object.entries(functionConfig).reduce((acc, [key, value]) => {
     if (value && !(Array.isArray(value) && value.length === 0)) {
         return { ...acc, [key]: value };
@@ -25,10 +26,10 @@ const sanitizeEdgeFunctionConfig = (config) => {
     }
     return newConfig;
 };
-const addExcludedPatterns = (name, manifestFunctionConfig, excludedPath) => {
+const addExcludedPatterns = (name, manifestFunctionConfig, excludedPath, featureFlags) => {
     if (excludedPath) {
         const paths = Array.isArray(excludedPath) ? excludedPath : [excludedPath];
-        const excludedPatterns = paths.map(pathToRegularExpression).map(serializePattern);
+        const excludedPatterns = paths.map((path) => pathToRegularExpression(path, featureFlags)).map(serializePattern);
         manifestFunctionConfig[name].excluded_patterns.push(...excludedPatterns);
     }
 };
@@ -41,7 +42,7 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
         if (manifestFunctionConfig[name] === undefined) {
             continue;
         }
-        addExcludedPatterns(name, manifestFunctionConfig, excludedPath);
+        addExcludedPatterns(name, manifestFunctionConfig, excludedPath, featureFlags);
         manifestFunctionConfig[name] = { ...manifestFunctionConfig[name], on_error: onError };
     }
     for (const [name, { excludedPath, path, onError, ...rest }] of Object.entries(internalFunctionConfig)) {
@@ -49,7 +50,7 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
         if (manifestFunctionConfig[name] === undefined) {
             continue;
         }
-        addExcludedPatterns(name, manifestFunctionConfig, excludedPath);
+        addExcludedPatterns(name, manifestFunctionConfig, excludedPath, featureFlags);
         manifestFunctionConfig[name] = { ...manifestFunctionConfig[name], on_error: onError, ...rest };
     }
     declarations.forEach((declaration) => {
@@ -57,8 +58,8 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
         if (func === undefined) {
             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 pattern = getRegularExpression(declaration, featureFlags);
+        const excludedPattern = getExcludedRegularExpressions(declaration, featureFlags);
         const route = {
             function: func.name,
             pattern: serializePattern(pattern),
@@ -86,7 +87,18 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
     };
     return manifest;
 };
-const pathToRegularExpression = (path) => {
+const pathToRegularExpression = (path, featureFlags) => {
+    if (featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_path_urlpattern) {
+        const pattern = new ExtendedURLPattern({ pathname: path });
+        // Removing the `^` and `$` delimiters because we'll need to modify what's
+        // between them.
+        const source = pattern.regexp.pathname.source.slice(1, -1);
+        // Wrapping the expression source with `^` and `$`. Also, adding an optional
+        // trailing slash, so that a declaration of `path: "/foo"` matches requests
+        // for both `/foo` and `/foo/`.
+        const normalizedSource = `^${source}\\/?$`;
+        return normalizedSource;
+    }
     // We use the global flag so that `globToRegExp` will not wrap the expression
     // with `^` and `$`. We'll do that ourselves.
     const regularExpression = globToRegExp(path, { flags: 'g' });
@@ -96,23 +108,23 @@ const pathToRegularExpression = (path) => {
     const normalizedSource = `^${regularExpression.source}\\/?$`;
     return normalizedSource;
 };
-const getRegularExpression = (declaration, failUnsupportedRegex = false) => {
+const getRegularExpression = (declaration, featureFlags) => {
     if ('pattern' in declaration) {
         try {
             return parsePattern(declaration.pattern);
         }
         catch (error) {
             // eslint-disable-next-line max-depth
-            if (failUnsupportedRegex) {
+            if (featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_fail_unsupported_regex) {
                 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);
+    return pathToRegularExpression(declaration.path, featureFlags);
 };
-const getExcludedRegularExpressions = (declaration, failUnsupportedRegex = false) => {
+const getExcludedRegularExpressions = (declaration, featureFlags) => {
     if ('excludedPattern' in declaration && declaration.excludedPattern) {
         const excludedPatterns = Array.isArray(declaration.excludedPattern)
             ? declaration.excludedPattern
@@ -122,7 +134,7 @@ const getExcludedRegularExpressions = (declaration, failUnsupportedRegex = false
                 return parsePattern(excludedPattern);
             }
             catch (error) {
-                if (failUnsupportedRegex) {
+                if (featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_fail_unsupported_regex) {
                     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}`);
@@ -132,7 +144,7 @@ const getExcludedRegularExpressions = (declaration, failUnsupportedRegex = false
     }
     if ('path' in declaration && declaration.excludedPath) {
         const paths = Array.isArray(declaration.excludedPath) ? declaration.excludedPath : [declaration.excludedPath];
-        return paths.map(pathToRegularExpression);
+        return paths.map((path) => pathToRegularExpression(path, featureFlags));
     }
     return [];
 };

package/dist/node/manifest.test.js

@@ -34,8 +34,14 @@ test('Generates a manifest with display names', () => {
             name: 'Display Name',
         },
     };
-    const manifest = generateManifest({ bundles: [], declarations, functions, internalFunctionConfig });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$', excluded_patterns: [] }];
+    const manifest = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        internalFunctionConfig,
+        featureFlags: { edge_functions_path_urlpattern: true },
+    });
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [] }];
     expect(manifest.function_config).toEqual({
         'func-1': { name: 'Display Name' },
     });
@@ -50,8 +56,14 @@ test('Generates a manifest with a generator field', () => {
             generator: '@netlify/fake-plugin@1.0.0',
         },
     };
-    const manifest = generateManifest({ bundles: [], declarations, functions, internalFunctionConfig });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$', excluded_patterns: [] }];
+    const manifest = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        internalFunctionConfig,
+        featureFlags: { edge_functions_path_urlpattern: true },
+    });
+    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,14 +77,23 @@ 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$', '^/f2/exclude-as-well$'] },
+        { 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 manifest = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        featureFlags: { edge_functions_path_urlpattern: true },
+    });
     const expectedRoutes = [
-        { 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/?$'] },
+        { 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({});
@@ -87,8 +108,14 @@ test('TOML-defined paths can be combined with ISC-defined excluded paths', () =>
     const userFunctionConfig = {
         'func-1': { excludedPath: '/f1/exclude' },
     };
-    const manifest = generateManifest({ bundles: [], declarations, functions, userFunctionConfig });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$', excluded_patterns: [] }];
+    const manifest = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        userFunctionConfig,
+        featureFlags: { edge_functions_path_urlpattern: true },
+    });
+    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/?$'] },
@@ -102,7 +129,7 @@ test('Filters out internal in-source configurations in user created functions',
     ];
     const declarations = [
         { function: 'func-1', path: '/f1/*' },
-        { function: 'func-2', pattern: '^/f2/.*/?$' },
+        { function: 'func-2', pattern: '^/f2(?:/(.*))/?$' },
     ];
     const userFunctionConfig = {
         'func-1': {
@@ -163,22 +190,23 @@ test('excludedPath from ISC goes into function_config, TOML goes into routes', (
         functions,
         userFunctionConfig,
         internalFunctionConfig,
+        featureFlags: { edge_functions_path_urlpattern: true },
     });
     expect(manifest.routes).toEqual([
         {
             function: 'customisation',
-            pattern: '^/showcases/.*/?$',
+            pattern: '^/showcases(?:/(.*))/?$',
             excluded_patterns: [],
         },
         {
             function: 'customisation',
-            pattern: '^/checkout/.*/?$',
-            excluded_patterns: ['^/.*/terms-and-conditions/?$'],
+            pattern: '^/checkout(?:/(.*))/?$',
+            excluded_patterns: ['^(?:/(.*))/terms-and-conditions/?$'],
         },
     ]);
     expect(manifest.function_config).toEqual({
         customisation: {
-            excluded_patterns: ['^/.*\\.css/?$', '^/.*\\.jpg/?$'],
+            excluded_patterns: ['^(?:/(.*))\\.css/?$', '^(?:/(.*))\\.jpg/?$'],
         },
     });
     const matcher = getRouteMatcher(manifest);
@@ -195,7 +223,7 @@ test('Includes failure modes in manifest', () => {
     ];
     const declarations = [
         { function: 'func-1', path: '/f1/*' },
-        { function: 'func-2', pattern: '^/f2/.*/?$' },
+        { function: 'func-2', pattern: '^/f2(?:/(.*))/?$' },
     ];
     const userFunctionConfig = {
         'func-1': {
@@ -292,8 +320,8 @@ test('Generates a manifest with layers', () => {
         { function: 'func-2', path: '/f2/*' },
     ];
     const expectedRoutes = [
-        { function: 'func-1', pattern: '^/f1/.*/?$', excluded_patterns: [] },
-        { function: 'func-2', pattern: '^/f2/.*/?$', excluded_patterns: [] },
+        { function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [] },
+        { function: 'func-2', pattern: '^/f2(?:/(.*))/?$', excluded_patterns: [] },
     ];
     const layers = [
         {
@@ -301,8 +329,19 @@ test('Generates a manifest with layers', () => {
             flag: 'edge_functions_onion_layer',
         },
     ];
-    const manifest1 = generateManifest({ bundles: [], declarations, functions });
-    const manifest2 = generateManifest({ bundles: [], declarations, functions, layers });
+    const manifest1 = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        featureFlags: { edge_functions_path_urlpattern: true },
+    });
+    const manifest2 = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        layers,
+        featureFlags: { edge_functions_path_urlpattern: true },
+    });
     expect(manifest1.routes).toEqual(expectedRoutes);
     expect(manifest1.layers).toEqual([]);
     expect(manifest2.routes).toEqual(expectedRoutes);

package/dist/node/utils/urlpattern.d.ts

@@ -0,0 +1,4 @@
+import { URLPattern } from 'urlpattern-polyfill';
+export declare class ExtendedURLPattern extends URLPattern {
+    regexp: Record<string, RegExp>;
+}

package/dist/node/utils/urlpattern.js

@@ -0,0 +1,3 @@
+import { URLPattern } from 'urlpattern-polyfill';
+export class ExtendedURLPattern extends URLPattern {
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "8.16.4",
+  "version": "8.17.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -93,6 +93,7 @@
     "regexp-tree": "^0.1.24",
     "semver": "^7.3.8",
     "tmp-promise": "^3.0.3",
+    "urlpattern-polyfill": "8.0.2",
     "uuid": "^9.0.0"
   }
 }