@netlify/edge-bundler 8.18.0 → 8.19.1

package/deno/bundle.ts

@@ -3,4 +3,12 @@ import { writeStage2 } from './lib/stage2.ts'
 const [payload] = Deno.args
 const { basePath, destPath, externals, functions, importMapData } = JSON.parse(payload)
 
-await writeStage2({ basePath, destPath, externals, functions, importMapData })
+try {
+  await writeStage2({ basePath, destPath, externals, functions, importMapData })
+} catch (error) {
+  if (error instanceof Error && error.message.includes("The module's source code could not be parsed")) {
+    delete error.stack
+  }
+
+  throw error
+}

package/deno/config.ts

@@ -1,7 +1,9 @@
-const [functionURL, collectorURL, bootstrapURL, rawExitCodes] = Deno.args
+// this needs to be updated whenever there's a change to globalThis.Netlify in bootstrap
+import { Netlify } from "https://64e8753eae24930008fac6d9--edge.netlify.app/bootstrap/index-combined.ts"
+
+const [functionURL, collectorURL, rawExitCodes] = Deno.args
 const exitCodes = JSON.parse(rawExitCodes)
 
-const { Netlify } = await import(bootstrapURL)
 globalThis.Netlify = Netlify
 
 let func

package/deno/lib/consts.ts

@@ -1,4 +1,5 @@
-export const PUBLIC_SPECIFIER = 'netlify:edge'
+export const LEGACY_PUBLIC_SPECIFIER = 'netlify:edge'
+export const PUBLIC_SPECIFIER = '@netlify/edge-functions'
 export const STAGE1_SPECIFIER = 'netlify:bootstrap-stage1'
 export const STAGE2_SPECIFIER = 'netlify:bootstrap-stage2'
 export const virtualRoot = 'file:///root/'

package/deno/lib/stage2.ts

@@ -4,7 +4,7 @@ import * as path from 'https://deno.land/std@0.177.0/path/mod.ts'
 
 import type { InputFunction, WriteStage2Options } from '../../shared/stage2.ts'
 import { importMapSpecifier, virtualRoot } from '../../shared/consts.ts'
-import { PUBLIC_SPECIFIER, STAGE2_SPECIFIER } from './consts.ts'
+import { LEGACY_PUBLIC_SPECIFIER, PUBLIC_SPECIFIER, STAGE2_SPECIFIER } from './consts.ts'
 import { inlineModule, loadFromVirtualRoot, loadWithRetry } from './common.ts'
 
 interface FunctionReference {
@@ -75,7 +75,12 @@ const stage2Loader = (basePath: string, functions: InputFunction[], externals: S
       return inlineModule(specifier, importMapData)
     }
 
-    if (specifier === PUBLIC_SPECIFIER || externals.has(specifier) || specifier.startsWith('node:')) {
+    if (
+      specifier === LEGACY_PUBLIC_SPECIFIER ||
+      specifier === PUBLIC_SPECIFIER ||
+      externals.has(specifier) ||
+      specifier.startsWith('node:')
+    ) {
       return {
         kind: 'external',
         specifier,

package/dist/node/bundle_error.js

@@ -20,6 +20,10 @@ class BundleError extends Error {
  */
 const wrapBundleError = (input, options) => {
     if (input instanceof Error) {
+        if (input.message.includes("The module's source code could not be parsed")) {
+            // eslint-disable-next-line no-param-reassign
+            input.message = input.stderr;
+        }
         return new BundleError(input, options);
     }
     return input;

package/dist/node/bundler.d.ts

@@ -16,7 +16,7 @@ interface BundleOptions {
     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, bootstrapURL, }?: BundleOptions) => Promise<{
+declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, }?: 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, bootstrapURL = 'https://edge.netlify.com/bootstrap/index-combined.ts', } = {}) => {
+const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, } = {}) => {
     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, log: logger, bootstrapURL })]);
-    const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig({ func, importMap, deno, log: logger, bootstrapURL })]);
+    const internalConfigPromises = internalFunctions.map(async (func) => [func.name, await getFunctionConfig({ func, importMap, deno, log: logger })]);
+    const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig({ func, importMap, deno, log: logger })]);
     // 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/bundler.test.js

@@ -68,7 +68,8 @@ test('Uses the vendored eszip module instead of fetching it from deno.land', asy
     await cleanup();
 });
 test('Adds a custom error property to user errors during bundling', async () => {
-    expect.assertions(2);
+    process.env.NO_COLOR = 'true';
+    expect.assertions(3);
     const { basePath, cleanup, distPath } = await useFixture('invalid_functions');
     const sourceDirectory = join(basePath, 'functions');
     const declarations = [
@@ -82,6 +83,16 @@ test('Adds a custom error property to user errors during bundling', async () =>
     }
     catch (error) {
         expect(error).toBeInstanceOf(BundleError);
+        const [messageBeforeStack] = error.message.split('at <anonymous> (file://');
+        expect(messageBeforeStack).toMatchInlineSnapshot(`
+      "error: Uncaught (in promise) Error: The module's source code could not be parsed: Unexpected eof at file:///root/functions/func1.ts:1:27
+
+        export default async () => 
+                                  ~
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+                        ^
+          "
+    `);
         expect(error.customErrorInfo).toEqual({
             location: {
                 format: 'eszip',

package/dist/node/config.d.ts

@@ -6,6 +6,7 @@ export declare const enum Cache {
     Off = "off",
     Manual = "manual"
 }
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS';
 export type Path = `/${string}`;
 export type OnError = 'fail' | 'bypass' | Path;
 export declare const isValidOnError: (value: unknown) => value is OnError;
@@ -16,11 +17,11 @@ export interface FunctionConfig {
     onError?: OnError;
     name?: string;
     generator?: string;
+    method?: HTTPMethod | HTTPMethod[];
 }
-export declare const getFunctionConfig: ({ func, importMap, deno, bootstrapURL, log, }: {
+export declare const getFunctionConfig: ({ func, importMap, deno, 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, bootstrapURL, log, }) => {
+export const getFunctionConfig = async ({ func, importMap, deno, log, }) => {
     // The extractor is a Deno script that will import the function and run its
     // `config` export, if one exists.
     const extractorPath = getConfigExtractor();
@@ -50,7 +50,6 @@ export const getFunctionConfig = async ({ func, importMap, deno, bootstrapURL, l
         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,7 +9,6 @@ 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: {
@@ -122,7 +121,6 @@ describe('`getFunctionConfig` extracts configuration properties from function fi
             importMap: new ImportMap([importMapFile]),
             deno,
             log: logger,
-            bootstrapURL,
         });
         if (func.error) {
             await expect(funcCall()).rejects.toThrowError(func.error);
@@ -151,12 +149,12 @@ test('Loads function paths from the in-source `config` function', async () => {
         {
             function: 'user-func2',
             path: '/user-func2',
+            method: ['PATCH'],
         },
     ];
     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);
@@ -179,6 +177,7 @@ test('Loads function paths from the in-source `config` function', async () => {
         pattern: '^/user-func2/?$',
         excluded_patterns: [],
         path: '/user-func2',
+        methods: ['PATCH'],
     });
     expect(routes[2]).toEqual({
         function: 'framework-func1',
@@ -203,6 +202,7 @@ test('Loads function paths from the in-source `config` function', async () => {
         pattern: '^/user-func5(?:/(.*))/?$',
         excluded_patterns: [],
         path: '/user-func5/*',
+        methods: ['GET'],
     });
     expect(postCacheRoutes.length).toBe(1);
     expect(postCacheRoutes[0]).toEqual({
@@ -210,6 +210,7 @@ test('Loads function paths from the in-source `config` function', async () => {
         pattern: '^/user-func4/?$',
         excluded_patterns: [],
         path: '/user-func4',
+        methods: ['POST', 'PUT'],
     });
     expect(Object.keys(functionConfig)).toHaveLength(1);
     expect(functionConfig['user-func5']).toEqual({
@@ -243,7 +244,6 @@ test('Passes validation if default export exists and is a function', async () =>
         importMap: new ImportMap([importMapFile]),
         deno,
         log: logger,
-        bootstrapURL,
     })).resolves.not.toThrow();
     await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });
@@ -273,7 +273,6 @@ test('Fails validation if default export is not function', async () => {
         importMap: new ImportMap([importMapFile]),
         deno,
         log: logger,
-        bootstrapURL,
     });
     await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
     await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
@@ -303,7 +302,6 @@ test('Fails validation if default export is not present', async () => {
         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.d.ts

@@ -1,8 +1,9 @@
-import { FunctionConfig, Path } from './config.js';
+import { FunctionConfig, HTTPMethod, Path } from './config.js';
 import { FeatureFlags } from './feature_flags.js';
 interface BaseDeclaration {
     cache?: string;
     function: string;
+    method?: HTTPMethod | HTTPMethod[];
     name?: string;
     generator?: string;
 }

package/dist/node/declaration.js

@@ -48,7 +48,7 @@ const getDeclarationsFromInput = (inputDeclarations, functionConfigs, functionsV
 const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited) => {
     const declarations = [];
     for (const name in functionConfigs) {
-        const { cache, path } = functionConfigs[name];
+        const { cache, path, method } = functionConfigs[name];
         // If we have a path specified, create a declaration for each path.
         if (!functionsVisited.has(name) && path) {
             const paths = Array.isArray(path) ? path : [path];
@@ -57,6 +57,9 @@ const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited
                 if (cache) {
                     declaration.cache = cache;
                 }
+                if (method) {
+                    declaration.method = method;
+                }
                 declarations.push(declaration);
             });
         }

package/dist/node/feature_flags.d.ts

@@ -1,12 +1,10 @@
 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,6 +1,5 @@
 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/import_map.js

@@ -5,7 +5,8 @@ import { fileURLToPath, pathToFileURL } from 'url';
 import { parse } from '@import-maps/resolve';
 import { isFileNotFoundError } from './utils/error.js';
 const INTERNAL_IMPORTS = {
-    'netlify:edge': 'https://edge.netlify.com/v1/index.ts',
+    '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
+    'netlify:edge': 'https://edge.netlify.com/v1/index.ts?v=legacy',
 };
 // ImportMap can take several import map files and merge them into a final
 // import map object, also adding the internal imports in the right order.

package/dist/node/import_map.test.js

@@ -21,7 +21,8 @@ test('Handles import maps with full URLs without specifying a base URL', () => {
     };
     const map = new ImportMap([inputFile1, inputFile2]);
     const { imports } = map.getContents();
-    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
+    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
+    expect(imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
     expect(imports['alias:jamstack']).toBe('https://jamstack.org/');
     expect(imports['alias:pets']).toBe('https://petsofnetlify.com/');
 });
@@ -36,7 +37,8 @@ test('Resolves relative paths to absolute paths if a base path is not provided',
     const map = new ImportMap([inputFile1]);
     const { imports } = map.getContents();
     const expectedPath = join(cwd(), 'my-cool-site', 'heart', 'pets');
-    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
+    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
+    expect(imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
     expect(imports['alias:pets']).toBe(`${pathToFileURL(expectedPath).toString()}/`);
 });
 describe('Returns the fully resolved import map', () => {
@@ -69,7 +71,8 @@ describe('Returns the fully resolved import map', () => {
             specifier3: 'file:///different/full/path/file3.js',
             specifier2: 'file:///some/full/path/file2.js',
             specifier1: 'file:///some/full/path/file.js',
-            'netlify:edge': 'https://edge.netlify.com/v1/index.ts',
+            '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
+            'netlify:edge': 'https://edge.netlify.com/v1/index.ts?v=legacy',
         });
         expect(scopes).toStrictEqual({
             'file:///some/cool/path/with/scopes/': {
@@ -90,7 +93,8 @@ describe('Returns the fully resolved import map', () => {
             specifier3: 'file:///vendor/full/path/file3.js',
             specifier2: 'file:///root/full/path/file2.js',
             specifier1: 'file:///root/full/path/file.js',
-            'netlify:edge': 'https://edge.netlify.com/v1/index.ts',
+            '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
+            'netlify:edge': 'https://edge.netlify.com/v1/index.ts?v=legacy',
         });
         expect(scopes).toStrictEqual({
             'file:///root/cool/path/with/scopes/': {
@@ -126,6 +130,7 @@ test('Writes import map file to disk', async () => {
     const { imports } = JSON.parse(createdFile);
     const expectedPath = join(cwd(), 'my-cool-site', 'heart', 'pets', 'file.ts');
     await file.cleanup();
-    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
+    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
+    expect(imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
     expect(imports['alias:pets']).toBe(pathToFileURL(expectedPath).toString());
 });

package/dist/node/manifest.d.ts

@@ -9,6 +9,7 @@ interface Route {
     pattern: string;
     excluded_patterns: string[];
     path?: string;
+    methods?: string[];
 }
 interface EdgeFunctionConfig {
     excluded_patterns: string[];

package/dist/node/manifest.js

@@ -1,6 +1,5 @@
 import { promises as fs } from 'fs';
 import { join } from 'path';
-import globToRegExp from 'glob-to-regexp';
 import { wrapBundleError } from './bundle_error.js';
 import { parsePattern } from './declaration.js';
 import { getPackageVersion } from './package_json.js';
@@ -27,13 +26,26 @@ const sanitizeEdgeFunctionConfig = (config) => {
     }
     return newConfig;
 };
-const addExcludedPatterns = (name, manifestFunctionConfig, excludedPath, featureFlags) => {
+const addExcludedPatterns = (name, manifestFunctionConfig, excludedPath) => {
     if (excludedPath) {
         const paths = Array.isArray(excludedPath) ? excludedPath : [excludedPath];
-        const excludedPatterns = paths.map((path) => pathToRegularExpression(path, featureFlags)).map(serializePattern);
+        const excludedPatterns = paths.map((path) => pathToRegularExpression(path)).map(serializePattern);
         manifestFunctionConfig[name].excluded_patterns.push(...excludedPatterns);
     }
 };
+/**
+ * Normalizes method names into arrays of uppercase strings.
+ * (e.g. "get" becomes ["GET"])
+ */
+const normalizeMethods = (method, name) => {
+    const methods = Array.isArray(method) ? method : [method];
+    return methods.map((method) => {
+        if (typeof method !== 'string') {
+            throw new TypeError(`Could not parse method declaration of function '${name}'. Expecting HTTP Method, got ${method}`);
+        }
+        return method.toUpperCase();
+    });
+};
 const generateManifest = ({ bundles = [], declarations = [], featureFlags, functions, userFunctionConfig = {}, internalFunctionConfig = {}, importMap, layers = [], }) => {
     const preCacheRoutes = [];
     const postCacheRoutes = [];
@@ -43,7 +55,7 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
         if (manifestFunctionConfig[name] === undefined) {
             continue;
         }
-        addExcludedPatterns(name, manifestFunctionConfig, excludedPath, featureFlags);
+        addExcludedPatterns(name, manifestFunctionConfig, excludedPath);
         manifestFunctionConfig[name] = { ...manifestFunctionConfig[name], on_error: onError };
     }
     for (const [name, { excludedPath, path, onError, ...rest }] of Object.entries(internalFunctionConfig)) {
@@ -51,7 +63,7 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
         if (manifestFunctionConfig[name] === undefined) {
             continue;
         }
-        addExcludedPatterns(name, manifestFunctionConfig, excludedPath, featureFlags);
+        addExcludedPatterns(name, manifestFunctionConfig, excludedPath);
         manifestFunctionConfig[name] = { ...manifestFunctionConfig[name], on_error: onError, ...rest };
     }
     declarations.forEach((declaration) => {
@@ -66,6 +78,9 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
             pattern: serializePattern(pattern),
             excluded_patterns: excludedPattern.map(serializePattern),
         };
+        if ('method' in declaration) {
+            route.methods = normalizeMethods(declaration.method, func.name);
+        }
         if ('path' in declaration) {
             route.path = declaration.path;
         }
@@ -91,31 +106,21 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
     };
     return manifest;
 };
-const pathToRegularExpression = (path, featureFlags) => {
-    if (featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_path_urlpattern) {
-        try {
-            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;
-        }
-        catch (error) {
-            throw wrapBundleError(error);
-        }
+const pathToRegularExpression = (path) => {
+    try {
+        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;
+    }
+    catch (error) {
+        throw wrapBundleError(error);
     }
-    // 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' });
-    // 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 = `^${regularExpression.source}\\/?$`;
-    return normalizedSource;
 };
 const getRegularExpression = (declaration, featureFlags) => {
     if ('pattern' in declaration) {
@@ -131,7 +136,7 @@ const getRegularExpression = (declaration, featureFlags) => {
             return declaration.pattern;
         }
     }
-    return pathToRegularExpression(declaration.path, featureFlags);
+    return pathToRegularExpression(declaration.path);
 };
 const getExcludedRegularExpressions = (declaration, featureFlags) => {
     if ('excludedPattern' in declaration && declaration.excludedPattern) {
@@ -153,7 +158,7 @@ const getExcludedRegularExpressions = (declaration, featureFlags) => {
     }
     if ('path' in declaration && declaration.excludedPath) {
         const paths = Array.isArray(declaration.excludedPath) ? declaration.excludedPath : [declaration.excludedPath];
-        return paths.map((path) => pathToRegularExpression(path, featureFlags));
+        return paths.map((path) => pathToRegularExpression(path));
     }
     return [];
 };

package/dist/node/manifest.test.js

@@ -40,7 +40,6 @@ test('Generates a manifest with display names', () => {
         declarations,
         functions,
         internalFunctionConfig,
-        featureFlags: { edge_functions_path_urlpattern: true },
     });
     const expectedRoutes = [{ function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [], path: '/f1/*' }];
     expect(manifest.function_config).toEqual({
@@ -62,7 +61,6 @@ test('Generates a manifest with a generator field', () => {
         declarations,
         functions,
         internalFunctionConfig,
-        featureFlags: { edge_functions_path_urlpattern: true },
     });
     const expectedRoutes = [{ function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [], path: '/f1/*' }];
     const expectedFunctionConfig = { 'func-1': { generator: '@netlify/fake-plugin@1.0.0' } };
@@ -85,7 +83,6 @@ test('Generates a manifest with excluded paths and patterns', () => {
         bundles: [],
         declarations,
         functions,
-        featureFlags: { edge_functions_path_urlpattern: true },
     });
     const expectedRoutes = [
         { function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: ['^/f1/exclude/?$'], path: '/f1/*' },
@@ -119,7 +116,6 @@ test('TOML-defined paths can be combined with ISC-defined excluded paths', () =>
         declarations,
         functions,
         userFunctionConfig,
-        featureFlags: { edge_functions_path_urlpattern: true },
     });
     const expectedRoutes = [{ function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [], path: '/f1/*' }];
     expect(manifest.routes).toEqual(expectedRoutes);
@@ -196,7 +192,6 @@ 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([
         {
@@ -235,7 +230,6 @@ test('URLPattern named groups are supported', () => {
         functions,
         userFunctionConfig,
         internalFunctionConfig,
-        featureFlags: { edge_functions_path_urlpattern: true },
     });
     expect(manifest.routes).toEqual([
         {
@@ -259,7 +253,6 @@ test('Invalid Path patterns throw bundling errors', () => {
         functions,
         userFunctionConfig,
         internalFunctionConfig,
-        featureFlags: { edge_functions_path_urlpattern: true },
     })).toThrowError(BundleError);
 });
 test('Includes failure modes in manifest', () => {
@@ -381,14 +374,12 @@ test('Generates a manifest with layers', () => {
         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([]);

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, bootstrapURL, log: logger })));
+            functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig({ func, importMap, deno, log: logger })));
         }
         const success = await waitForServer(port, processRef.ps);
         return {

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

@@ -50,6 +50,13 @@ declare const edgeManifestSchema: {
                     path: {
                         type: string;
                     };
+                    methods: {
+                        type: string;
+                        items: {
+                            type: string;
+                            enum: string[];
+                        };
+                    };
                 };
                 additionalProperties: boolean;
             };
@@ -85,6 +92,13 @@ declare const edgeManifestSchema: {
                     path: {
                         type: string;
                     };
+                    methods: {
+                        type: string;
+                        items: {
+                            type: string;
+                            enum: string[];
+                        };
+                    };
                 };
                 additionalProperties: boolean;
             };

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

@@ -29,6 +29,10 @@ const routesSchema = {
         excluded_patterns: excludedPatternsSchema,
         generator: { type: 'string' },
         path: { type: 'string' },
+        methods: {
+            type: 'array',
+            items: { type: 'string', enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'] },
+        },
     },
     additionalProperties: false,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "8.18.0",
+  "version": "8.19.1",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -82,7 +82,6 @@
     "execa": "^6.0.0",
     "find-up": "^6.3.0",
     "get-port": "^6.1.2",
-    "glob-to-regexp": "^0.4.1",
     "is-path-inside": "^4.0.0",
     "jsonc-parser": "^3.2.0",
     "node-fetch": "^3.1.1",