@netlify/edge-bundler 11.2.2 → 11.3.0

package/dist/node/declaration.d.ts

@@ -19,8 +19,7 @@ export type Declaration = DeclarationWithPath | DeclarationWithPattern;
 export declare const mergeDeclarations: (tomlDeclarations: Declaration[], userFunctionsConfig: Record<string, FunctionConfig>, internalFunctionsConfig: Record<string, FunctionConfig>, deployConfigDeclarations: Declaration[], _featureFlags?: FeatureFlags) => Declaration[];
 /**
  * Normalizes a regular expression, ensuring it has a leading `^` and trailing
- * `$` characters. It also converts the regular expression from PCRE to RE2 if
- * needed.
+ * `$` characters.
  */
-export declare const parsePattern: (pattern: string, pcreRegexpEngine: boolean) => string;
+export declare const normalizePattern: (pattern: string) => string;
 export {};

package/dist/node/declaration.js

@@ -1,4 +1,3 @@
-import regexpAST from 'regexp-tree';
 export const mergeDeclarations = (tomlDeclarations, userFunctionsConfig, internalFunctionsConfig, deployConfigDeclarations, 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 _featureFlags = {}) => {
@@ -68,10 +67,9 @@ const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited
 };
 /**
  * Normalizes a regular expression, ensuring it has a leading `^` and trailing
- * `$` characters. It also converts the regular expression from PCRE to RE2 if
- * needed.
+ * `$` characters.
  */
-export const parsePattern = (pattern, pcreRegexpEngine) => {
+export const normalizePattern = (pattern) => {
     let enclosedPattern = pattern;
     if (!pattern.startsWith('^')) {
         enclosedPattern = `^${enclosedPattern}`;
@@ -80,34 +78,6 @@ export const parsePattern = (pattern, pcreRegexpEngine) => {
         enclosedPattern = `${enclosedPattern}$`;
     }
     const regexp = new RegExp(enclosedPattern);
-    const regexpString = pcreRegexpEngine ? regexp.toString() : transformPCRERegexp(regexp);
     // Strip leading and forward slashes.
-    return regexpString.slice(1, -1);
-};
-/**
- * Transforms a PCRE regular expression into a RE2 expression, compatible
- * with the Go engine used in our edge nodes.
- */
-const transformPCRERegexp = (regexp) => {
-    const newRegexp = regexpAST.transform(regexp, {
-        Assertion(path) {
-            // Lookaheads are not supported. If we find one, throw an error.
-            if (path.node.kind === 'Lookahead') {
-                throw new Error('Regular expressions with lookaheads are not supported');
-            }
-        },
-        Group(path) {
-            // Named captured groups in JavaScript use a different syntax than in Go.
-            // If we find one, convert it to an unnamed capture group, which is valid
-            // in both engines.
-            if ('name' in path.node && path.node.name !== undefined) {
-                path.replace({
-                    ...path.node,
-                    name: undefined,
-                    nameRaw: undefined,
-                });
-            }
-        },
-    });
-    return newRegexp.toString();
+    return regexp.toString().slice(1, -1);
 };

package/dist/node/declaration.test.js

@@ -1,5 +1,5 @@
 import { test, expect } from 'vitest';
-import { mergeDeclarations, parsePattern } from './declaration.js';
+import { mergeDeclarations, normalizePattern } from './declaration.js';
 const deployConfigDeclarations = [];
 test('Ensure the order of edge functions with FF', () => {
     const deployConfigDeclarations = [
@@ -117,18 +117,15 @@ test('netlify.toml-defined excludedPath are respected', () => {
 test('Does not escape front slashes in a regex pattern if they are already escaped', () => {
     const regexPattern = '^(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/([^/.]{1,}))\\/shows(?:\\/(.*))(.json)?[\\/#\\?]?$';
     const expected = '^(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/([^/.]{1,}))\\/shows(?:\\/(.*))(.json)?[\\/#\\?]?$';
-    expect(parsePattern(regexPattern, false)).toEqual(expected);
-    expect(parsePattern(regexPattern, true)).toEqual(expected);
+    expect(normalizePattern(regexPattern)).toEqual(expected);
 });
 test('Escapes front slashes in a regex pattern', () => {
     const regexPattern = '^(?:/(_next/data/[^/]{1,}))?(?:/([^/.]{1,}))/shows(?:/(.*))(.json)?[/#\\?]?$';
     const expected = '^(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/([^/.]{1,}))\\/shows(?:\\/(.*))(.json)?[/#\\?]?$';
-    expect(parsePattern(regexPattern, false)).toEqual(expected);
-    expect(parsePattern(regexPattern, true)).toEqual(expected);
+    expect(normalizePattern(regexPattern)).toEqual(expected);
 });
 test('Ensures pattern match on the whole path', () => {
     const regexPattern = '/foo/.*/bar';
     const expected = '^\\/foo\\/.*\\/bar$';
-    expect(parsePattern(regexPattern, false)).toEqual(expected);
-    expect(parsePattern(regexPattern, true)).toEqual(expected);
+    expect(normalizePattern(regexPattern)).toEqual(expected);
 });

package/dist/node/feature_flags.d.ts

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

package/dist/node/feature_flags.js

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

package/dist/node/manifest.d.ts

@@ -42,7 +42,7 @@ interface GenerateManifestOptions {
     layers?: Layer[];
     userFunctionConfig?: Record<string, FunctionConfig>;
 }
-declare const generateManifest: ({ bundles, declarations, featureFlags, functions, userFunctionConfig, internalFunctionConfig, importMap, layers, }: GenerateManifestOptions) => {
+declare const generateManifest: ({ bundles, declarations, functions, userFunctionConfig, internalFunctionConfig, importMap, layers, }: GenerateManifestOptions) => {
     declarationsWithoutFunction: string[];
     manifest: Manifest;
     unroutedFunctions: string[];

package/dist/node/manifest.js

@@ -1,7 +1,7 @@
 import { promises as fs } from 'fs';
 import { join } from 'path';
 import { wrapBundleError } from './bundle_error.js';
-import { parsePattern } from './declaration.js';
+import { normalizePattern } from './declaration.js';
 import { getPackageVersion } from './package_json.js';
 import { nonNullable } from './utils/non_nullable.js';
 import { ExtendedURLPattern } from './utils/urlpattern.js';
@@ -46,7 +46,7 @@ const normalizeMethods = (method, name) => {
         return method.toUpperCase();
     });
 };
-const generateManifest = ({ bundles = [], declarations = [], featureFlags, functions, userFunctionConfig = {}, internalFunctionConfig = {}, importMap, layers = [], }) => {
+const generateManifest = ({ bundles = [], declarations = [], functions, userFunctionConfig = {}, internalFunctionConfig = {}, importMap, layers = [], }) => {
     const preCacheRoutes = [];
     const postCacheRoutes = [];
     const manifestFunctionConfig = Object.fromEntries(functions.map(({ name }) => [name, { excluded_patterns: [] }]));
@@ -74,14 +74,14 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
             declarationsWithoutFunction.add(declaration.function);
             return;
         }
-        const pattern = getRegularExpression(declaration, Boolean(featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_bundler_pcre_regexp));
+        const pattern = getRegularExpression(declaration);
         // If there is no `pattern`, the declaration will never be triggered, so we
         // can discard it.
         if (!pattern) {
             return;
         }
         routedFunctions.add(declaration.function);
-        const excludedPattern = getExcludedRegularExpressions(declaration, Boolean(featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_bundler_pcre_regexp));
+        const excludedPattern = getExcludedRegularExpressions(declaration);
         const route = {
             function: func.name,
             pattern: serializePattern(pattern),
@@ -135,10 +135,10 @@ const pathToRegularExpression = (path) => {
         throw wrapBundleError(error);
     }
 };
-const getRegularExpression = (declaration, pcreRegexpEngine) => {
+const getRegularExpression = (declaration) => {
     if ('pattern' in declaration) {
         try {
-            return parsePattern(declaration.pattern, pcreRegexpEngine);
+            return normalizePattern(declaration.pattern);
         }
         catch (error) {
             throw wrapBundleError(new Error(`Could not parse path declaration of function '${declaration.function}': ${error.message}`));
@@ -146,14 +146,14 @@ const getRegularExpression = (declaration, pcreRegexpEngine) => {
     }
     return pathToRegularExpression(declaration.path);
 };
-const getExcludedRegularExpressions = (declaration, pcreRegexpEngine) => {
+const getExcludedRegularExpressions = (declaration) => {
     if ('excludedPattern' in declaration && declaration.excludedPattern) {
         const excludedPatterns = Array.isArray(declaration.excludedPattern)
             ? declaration.excludedPattern
             : [declaration.excludedPattern];
         return excludedPatterns.map((excludedPattern) => {
             try {
-                return parsePattern(excludedPattern, pcreRegexpEngine);
+                return normalizePattern(excludedPattern);
             }
             catch (error) {
                 throw wrapBundleError(new Error(`Could not parse path declaration of function '${declaration.function}': ${error.message}`));

package/dist/node/manifest.test.js

@@ -386,22 +386,12 @@ test('Generates a manifest with layers', () => {
     expect(manifest2.routes).toEqual(expectedRoutes);
     expect(manifest2.layers).toEqual(layers);
 });
-test('Throws an error if the regular expression contains a negative lookahead and support for the PCRE engine is disabled', () => {
-    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
-    const declarations = [{ function: 'func-1', pattern: '^\\/((?!api|_next\\/static|_next\\/image|favicon.ico).*)$' }];
-    expect(() => generateManifest({
-        bundles: [],
-        declarations,
-        functions,
-    })).toThrowError(/^Could not parse path declaration of function 'func-1': Regular expressions with lookaheads are not supported$/);
-});
-test('Accepts regular expressions with lookaheads if support for the PCRE engine is enabled', () => {
+test('Accepts regular expressions with lookaheads', () => {
     const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
     const declarations = [{ function: 'func-1', pattern: '^\\/((?!api|_next\\/static|_next\\/image|favicon.ico).*)$' }];
     const { manifest } = generateManifest({
         bundles: [],
         declarations,
-        featureFlags: { edge_bundler_pcre_regexp: true },
         functions,
     });
     const [route] = manifest.routes;
@@ -409,11 +399,11 @@ test('Accepts regular expressions with lookaheads if support for the PCRE engine
     expect(regexp.test('/foo')).toBeTruthy();
     expect(regexp.test('/_next/static/foo')).toBeFalsy();
 });
-test('Converts named capture groups to unnamed capture groups in regular expressions', () => {
+test('Accepts regular expressions with named capture groups', () => {
     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+)$', excluded_patterns: [] }]);
+    expect(manifest.routes).toEqual([{ function: 'func-1', pattern: '^/(?<name>\\w+)$', excluded_patterns: [] }]);
 });
 test('Returns functions without a declaration and unrouted functions', () => {
     const bundle = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "11.2.2",
+  "version": "11.3.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -81,7 +81,7 @@
     "better-ajv-errors": "^1.2.0",
     "common-path-prefix": "^3.0.0",
     "env-paths": "^3.0.0",
-    "esbuild": "0.19.11",
+    "esbuild": "0.20.0",
     "execa": "^6.0.0",
     "find-up": "^6.3.0",
     "get-package-name": "^2.2.0",
@@ -93,7 +93,6 @@
     "p-retry": "^5.1.1",
     "p-wait-for": "^4.1.0",
     "path-key": "^4.0.0",
-    "regexp-tree": "^0.1.24",
     "semver": "^7.3.8",
     "tmp-promise": "^3.0.3",
     "urlpattern-polyfill": "8.0.2",