@netlify/edge-bundler 11.2.0 → 11.2.2

package/dist/node/bridge.d.ts

@@ -52,7 +52,7 @@ declare class DenoBridge {
     }>;
     getEnvironmentVariables(inputEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
     run(args: string[], { env: inputEnv, extendEnv, rejectOnExitCode, stderr, stdout }?: RunOptions): Promise<import("execa").ExecaReturnValue<string>>;
-    runInBackground(args: string[], ref?: ProcessRef, { env: inputEnv, extendEnv, stderr, stdout }?: RunOptions): Promise<void>;
+    runInBackground(args: string[], ref?: ProcessRef, { env: inputEnv, extendEnv, pipeOutput, stderr, stdout }?: RunOptions): Promise<void>;
 }
 export { DENO_VERSION_RANGE, DenoBridge };
 export type { DenoOptions, OnAfterDownloadHook, OnBeforeDownloadHook, ProcessRef };

package/dist/node/bridge.js

@@ -151,11 +151,11 @@ class DenoBridge {
     }
     // Runs the Deno CLI in the background, assigning a reference of the child
     // process to a `ps` property in the `ref` argument, if one is supplied.
-    async runInBackground(args, ref, { env: inputEnv, extendEnv = true, stderr, stdout } = {}) {
+    async runInBackground(args, ref, { env: inputEnv, extendEnv = true, pipeOutput, stderr, stdout } = {}) {
         const { path: binaryPath } = await this.getBinaryPath();
         const env = this.getEnvironmentVariables(inputEnv);
         const options = { env, extendEnv };
-        const ps = DenoBridge.runWithBinary(binaryPath, args, { options, stderr, stdout });
+        const ps = DenoBridge.runWithBinary(binaryPath, args, { options, pipeOutput, stderr, stdout });
         if (ref !== undefined) {
             // eslint-disable-next-line no-param-reassign
             ref.ps = ps;

package/dist/node/declaration.d.ts

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

package/dist/node/declaration.js

@@ -66,15 +66,29 @@ const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited
     }
     return declarations;
 };
-// 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) => {
+/**
+ * Normalizes a regular expression, ensuring it has a leading `^` and trailing
+ * `$` characters. It also converts the regular expression from PCRE to RE2 if
+ * needed.
+ */
+export const parsePattern = (pattern, pcreRegexpEngine) => {
     let enclosedPattern = pattern;
-    if (!pattern.startsWith('^'))
+    if (!pattern.startsWith('^')) {
         enclosedPattern = `^${enclosedPattern}`;
-    if (!pattern.endsWith('$'))
+    }
+    if (!pattern.endsWith('$')) {
         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.
@@ -95,6 +109,5 @@ export const parsePattern = (pattern) => {
             }
         },
     });
-    // Strip leading and forward slashes.
-    return newRegexp.toString().slice(1, -1);
+    return newRegexp.toString();
 };

package/dist/node/declaration.test.js

@@ -117,18 +117,18 @@ 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)?[\\/#\\?]?$';
-    const actual = parsePattern(regexPattern);
-    expect(actual).toEqual(expected);
+    expect(parsePattern(regexPattern, false)).toEqual(expected);
+    expect(parsePattern(regexPattern, true)).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)?[/#\\?]?$';
-    const actual = parsePattern(regexPattern);
-    expect(actual).toEqual(expected);
+    expect(parsePattern(regexPattern, false)).toEqual(expected);
+    expect(parsePattern(regexPattern, true)).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);
+    expect(parsePattern(regexPattern, false)).toEqual(expected);
+    expect(parsePattern(regexPattern, true)).toEqual(expected);
 });

package/dist/node/manifest.js

@@ -137,11 +137,8 @@ const pathToRegularExpression = (path) => {
 };
 const getRegularExpression = (declaration, pcreRegexpEngine) => {
     if ('pattern' in declaration) {
-        if (pcreRegexpEngine) {
-            return declaration.pattern;
-        }
         try {
-            return parsePattern(declaration.pattern);
+            return parsePattern(declaration.pattern, pcreRegexpEngine);
         }
         catch (error) {
             throw wrapBundleError(new Error(`Could not parse path declaration of function '${declaration.function}': ${error.message}`));
@@ -154,12 +151,9 @@ const getExcludedRegularExpressions = (declaration, pcreRegexpEngine) => {
         const excludedPatterns = Array.isArray(declaration.excludedPattern)
             ? declaration.excludedPattern
             : [declaration.excludedPattern];
-        if (pcreRegexpEngine) {
-            return excludedPatterns;
-        }
         return excludedPatterns.map((excludedPattern) => {
             try {
-                return parsePattern(excludedPattern);
+                return parsePattern(excludedPattern, pcreRegexpEngine);
             }
             catch (error) {
                 throw wrapBundleError(new Error(`Could not parse path declaration of function '${declaration.function}': ${error.message}`));

package/package.json

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