@netlify/edge-bundler 8.16.4 → 8.17.1

package/deno/config.ts

@@ -1,6 +1,9 @@
-const [functionURL, collectorURL, rawExitCodes] = Deno.args
+const [functionURL, collectorURL, bootstrapURL, rawExitCodes] = Deno.args
 const exitCodes = JSON.parse(rawExitCodes)
 
+const { Netlify } = await import(bootstrapURL)
+globalThis.Netlify = Netlify
+
 let func
 
 try {

package/dist/node/bundler.d.ts

@@ -14,8 +14,9 @@ interface BundleOptions {
     onBeforeDownload?: OnBeforeDownloadHook;
     systemLogger?: LogFunction;
     internalSrcFolder?: string;
+    bootstrapURL?: string;
 }
-declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, }?: BundleOptions) => Promise<{
+declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, bootstrapURL, }?: BundleOptions) => Promise<{
     functions: import("./edge_function.js").EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;

package/dist/node/bundler.js

@@ -14,7 +14,7 @@ import { ImportMap } from './import_map.js';
 import { getLogger } from './logger.js';
 import { writeManifest } from './manifest.js';
 import { ensureLatestTypes } from './types.js';
-const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, } = {}) => {
+const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, bootstrapURL = 'https://edge.netlify.com/bootstrap/index-combined.ts', } = {}) => {
     const logger = getLogger(systemLogger, debug);
     const featureFlags = getFlags(inputFeatureFlags);
     const options = {
@@ -63,8 +63,8 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
     await createFinalBundles([functionBundle], distDirectory, buildID);
     // Retrieving a configuration object for each function.
     // Run `getFunctionConfig` in parallel as it is a non-trivial operation and spins up deno
-    const internalConfigPromises = internalFunctions.map(async (func) => [func.name, await getFunctionConfig(func, importMap, deno, logger)]);
-    const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig(func, importMap, deno, logger)]);
+    const internalConfigPromises = internalFunctions.map(async (func) => [func.name, await getFunctionConfig({ func, importMap, deno, log: logger, bootstrapURL })]);
+    const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig({ func, importMap, deno, log: logger, bootstrapURL })]);
     // Creating a hash of function names to configuration objects.
     const internalFunctionsWithConfig = Object.fromEntries(await Promise.all(internalConfigPromises));
     const userFunctionsWithConfig = Object.fromEntries(await Promise.all(userConfigPromises));

package/dist/node/config.d.ts

@@ -17,4 +17,10 @@ export interface FunctionConfig {
     name?: string;
     generator?: string;
 }
-export declare const getFunctionConfig: (func: EdgeFunction, importMap: ImportMap, deno: DenoBridge, log: Logger) => Promise<FunctionConfig>;
+export declare const getFunctionConfig: ({ func, importMap, deno, bootstrapURL, log, }: {
+    func: EdgeFunction;
+    importMap: ImportMap;
+    deno: DenoBridge;
+    bootstrapURL: string;
+    log: Logger;
+}) => Promise<FunctionConfig>;

package/dist/node/config.js

@@ -26,7 +26,7 @@ const getConfigExtractor = () => {
     const configExtractorPath = join(packagePath, 'deno', 'config.ts');
     return configExtractorPath;
 };
-export const getFunctionConfig = async (func, importMap, deno, log) => {
+export const getFunctionConfig = async ({ func, importMap, deno, bootstrapURL, log, }) => {
     // The extractor is a Deno script that will import the function and run its
     // `config` export, if one exists.
     const extractorPath = getConfigExtractor();
@@ -50,6 +50,7 @@ export const getFunctionConfig = async (func, importMap, deno, log) => {
         extractorPath,
         pathToFileURL(func.path).href,
         pathToFileURL(collector.path).href,
+        bootstrapURL,
         JSON.stringify(ConfigExitCode),
     ], { rejectOnExitCode: false });
     if (exitCode !== ConfigExitCode.Success) {

package/dist/node/config.test.js

@@ -9,6 +9,7 @@ import { DenoBridge } from './bridge.js';
 import { bundle } from './bundler.js';
 import { getFunctionConfig } from './config.js';
 import { ImportMap } from './import_map.js';
+const bootstrapURL = 'https://edge.netlify.com/bootstrap/index-combined.ts';
 const importMapFile = {
     baseURL: new URL('file:///some/path/import-map.json'),
     imports: {
@@ -114,9 +115,15 @@ describe('`getFunctionConfig` extracts configuration properties from function fi
         const path = join(tmpDir, `${func.name}.js`);
         await fs.writeFile(path, func.source);
         const funcCall = () => getFunctionConfig({
-            name: func.name,
-            path,
-        }, new ImportMap([importMapFile]), deno, logger);
+            func: {
+                name: func.name,
+                path,
+            },
+            importMap: new ImportMap([importMapFile]),
+            deno,
+            log: logger,
+            bootstrapURL,
+        });
         if (func.error) {
             await expect(funcCall()).rejects.toThrowError(func.error);
         }
@@ -149,6 +156,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 +173,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);
@@ -193,9 +201,15 @@ test('Passes validation if default export exists and is a function', async () =>
     const path = join(tmpDir, `${func.name}.ts`);
     await fs.writeFile(path, func.source);
     await expect(getFunctionConfig({
-        name: func.name,
-        path,
-    }, new ImportMap([importMapFile]), deno, logger)).resolves.not.toThrow();
+        func: {
+            name: func.name,
+            path,
+        },
+        importMap: new ImportMap([importMapFile]),
+        deno,
+        log: logger,
+        bootstrapURL,
+    })).resolves.not.toThrow();
     await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Fails validation if default export is not function', async () => {
@@ -217,9 +231,15 @@ test('Fails validation if default export is not function', async () => {
     const path = join(tmpDir, `${func.name}.ts`);
     await fs.writeFile(path, func.source);
     const config = getFunctionConfig({
-        name: func.name,
-        path,
-    }, new ImportMap([importMapFile]), deno, logger);
+        func: {
+            name: func.name,
+            path,
+        },
+        importMap: new ImportMap([importMapFile]),
+        deno,
+        log: logger,
+        bootstrapURL,
+    });
     await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
     await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });
@@ -241,9 +261,15 @@ test('Fails validation if default export is not present', async () => {
     const path = join(tmpDir, `${func.name}.ts`);
     await fs.writeFile(path, func.source);
     const config = getFunctionConfig({
-        name: func.name,
-        path,
-    }, new ImportMap([importMapFile]), deno, logger);
+        func: {
+            name: func.name,
+            path,
+        },
+        importMap: new ImportMap([importMapFile]),
+        deno,
+        log: logger,
+        bootstrapURL,
+    });
     await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
     await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });

package/dist/node/declaration.js

@@ -66,7 +66,12 @@ const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited
 // Validates and normalizes a pattern so that it's a valid regular expression
 // in Go, which is the engine used by our edge nodes.
 export const parsePattern = (pattern) => {
-    const regexp = new RegExp(pattern);
+    let enclosedPattern = pattern;
+    if (!pattern.startsWith('^'))
+        enclosedPattern = `^${enclosedPattern}`;
+    if (!pattern.endsWith('$'))
+        enclosedPattern = `${enclosedPattern}$`;
+    const regexp = new RegExp(enclosedPattern);
     const newRegexp = regexpAST.transform(regexp, {
         Assertion(path) {
             // Lookaheads are not supported. If we find one, throw an error.

package/dist/node/declaration.test.js

@@ -126,3 +126,9 @@ test('Escapes front slashes in a regex pattern', () => {
     const actual = parsePattern(regexPattern);
     expect(actual).toEqual(expected);
 });
+test('Ensures pattern match on the whole path', () => {
+    const regexPattern = '/foo/.*/bar';
+    const expected = '^\\/foo\\/.*\\/bar$';
+    const actual = parsePattern(regexPattern);
+    expect(actual).toEqual(expected);
+});

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/server/server.js

@@ -43,7 +43,7 @@ const prepareServer = ({ bootstrapURL, deno, distDirectory, flags: denoFlags, fo
         });
         let functionsConfig = [];
         if (options.getFunctionsConfig) {
-            functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig(func, importMap, deno, logger)));
+            functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig({ func, importMap, deno, bootstrapURL, log: logger })));
         }
         const success = await waitForServer(port, processRef.ps);
         return {

package/dist/node/server/server.test.js

@@ -27,6 +27,10 @@ test('Starts a server and serves requests for edge functions', async () => {
             name: 'greet',
             path: join(paths.internal, 'greet.ts'),
         },
+        {
+            name: 'global_netlify',
+            path: join(paths.user, 'global_netlify.ts'),
+        },
     ];
     const options = {
         getFunctionsConfig: true,
@@ -35,7 +39,7 @@ test('Starts a server and serves requests for edge functions', async () => {
         very_secret_secret: 'i love netlify',
     }, options);
     expect(success).toBe(true);
-    expect(functionsConfig).toEqual([{ path: '/my-function' }, {}]);
+    expect(functionsConfig).toEqual([{ path: '/my-function' }, {}, { path: '/global-netlify' }]);
     for (const key in functions) {
         const graphEntry = graph === null || graph === void 0 ? void 0 : graph.modules.some(
         // @ts-expect-error TODO: Module graph is currently not typed
@@ -60,4 +64,15 @@ test('Starts a server and serves requests for edge functions', async () => {
     });
     expect(response2.status).toBe(200);
     expect(await response2.text()).toBe('HELLO!');
+    const response3 = await fetch(`http://0.0.0.0:${port}/global-netlify`, {
+        headers: {
+            'x-nf-edge-functions': 'global_netlify',
+            'x-ef-passthrough': 'passthrough',
+            'X-NF-Request-ID': uuidv4(),
+        },
+    });
+    expect(await response3.json()).toEqual({
+        global: 'i love netlify',
+        local: 'i love netlify',
+    });
 });

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.1",
   "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"
   }
 }