@netlify/edge-bundler 11.1.0 → 11.2.1

package/dist/node/bridge.d.ts

@@ -1,4 +1,6 @@
 /// <reference types="node" />
+/// <reference types="node" />
+import { type WriteStream } from 'fs';
 import { ExecaChildProcess } from 'execa';
 import { Logger } from './logger.js';
 declare const DENO_VERSION_RANGE = "^1.37.0";
@@ -18,9 +20,11 @@ interface ProcessRef {
     ps?: ExecaChildProcess<string>;
 }
 interface RunOptions {
-    pipeOutput?: boolean;
     env?: NodeJS.ProcessEnv;
     extendEnv?: boolean;
+    pipeOutput?: boolean;
+    stderr?: WriteStream;
+    stdout?: WriteStream;
     rejectOnExitCode?: boolean;
 }
 declare class DenoBridge {
@@ -47,8 +51,8 @@ declare class DenoBridge {
         path: string;
     }>;
     getEnvironmentVariables(inputEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-    run(args: string[], { pipeOutput, env: inputEnv, extendEnv, rejectOnExitCode }?: RunOptions): Promise<import("execa").ExecaReturnValue<string>>;
-    runInBackground(args: string[], ref?: ProcessRef, { pipeOutput, env: inputEnv, extendEnv }?: RunOptions): Promise<void>;
+    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>;
 }
 export { DENO_VERSION_RANGE, DenoBridge };
 export type { DenoOptions, OnAfterDownloadHook, OnBeforeDownloadHook, ProcessRef };

package/dist/node/bridge.js

@@ -93,13 +93,21 @@ class DenoBridge {
         }
         return this.currentDownload;
     }
-    static runWithBinary(binaryPath, args, options, pipeOutput) {
-        var _a, _b;
+    static runWithBinary(binaryPath, args, { options, pipeOutput, stderr, stdout, }) {
+        var _a, _b, _c, _d;
         const runDeno = execa(binaryPath, args, options);
-        if (pipeOutput) {
-            (_a = runDeno.stdout) === null || _a === void 0 ? void 0 : _a.pipe(process.stdout);
+        if (stderr) {
+            (_a = runDeno.stderr) === null || _a === void 0 ? void 0 : _a.pipe(stderr);
+        }
+        else if (pipeOutput) {
             (_b = runDeno.stderr) === null || _b === void 0 ? void 0 : _b.pipe(process.stderr);
         }
+        if (stdout) {
+            (_c = runDeno.stdout) === null || _c === void 0 ? void 0 : _c.pipe(stdout);
+        }
+        else if (pipeOutput) {
+            (_d = runDeno.stdout) === null || _d === void 0 ? void 0 : _d.pipe(process.stdout);
+        }
         return runDeno;
     }
     async writeVersionFile(version) {
@@ -135,19 +143,19 @@ class DenoBridge {
     }
     // Runs the Deno CLI in the background and returns a reference to the child
     // process, awaiting its execution.
-    async run(args, { pipeOutput, env: inputEnv, extendEnv = true, rejectOnExitCode = true } = {}) {
+    async run(args, { env: inputEnv, extendEnv = true, rejectOnExitCode = true, stderr, stdout } = {}) {
         const { path: binaryPath } = await this.getBinaryPath();
         const env = this.getEnvironmentVariables(inputEnv);
         const options = { env, extendEnv, reject: rejectOnExitCode };
-        return DenoBridge.runWithBinary(binaryPath, args, options, pipeOutput);
+        return DenoBridge.runWithBinary(binaryPath, args, { options, stderr, stdout });
     }
     // 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, { pipeOutput, env: inputEnv, extendEnv = true } = {}) {
+    async runInBackground(args, ref, { env: inputEnv, extendEnv = true, stderr, stdout } = {}) {
         const { path: binaryPath } = await this.getBinaryPath();
         const env = this.getEnvironmentVariables(inputEnv);
         const options = { env, extendEnv };
-        const ps = DenoBridge.runWithBinary(binaryPath, args, options, pipeOutput);
+        const ps = DenoBridge.runWithBinary(binaryPath, args, { options, 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/dist/node/server/server.d.ts

@@ -3,6 +3,8 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
+import type { WriteStream } from 'fs';
 import { OnAfterDownloadHook, OnBeforeDownloadHook } from '../bridge.js';
 import { FunctionConfig } from '../config.js';
 import type { EdgeFunction } from '../edge_function.js';
@@ -34,10 +36,12 @@ interface ServeOptions {
     port: number;
     rootPath?: string;
     servePath: string;
+    stderr?: WriteStream;
+    stdout?: WriteStream;
     userLogger?: LogFunction;
     systemLogger?: LogFunction;
 }
-export declare const serve: ({ basePath, bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, featureFlags, formatExportTypeError, formatImportError, onAfterDownload, onBeforeDownload, port, rootPath, servePath, userLogger, systemLogger, }: ServeOptions) => Promise<(functions: EdgeFunction[], env?: NodeJS.ProcessEnv, options?: StartServerOptions) => Promise<{
+export declare const serve: ({ basePath, bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, featureFlags, formatExportTypeError, formatImportError, onAfterDownload, onBeforeDownload, port, rootPath, servePath, stderr, stdout, userLogger, systemLogger, }: ServeOptions) => Promise<(functions: EdgeFunction[], env?: NodeJS.ProcessEnv, options?: StartServerOptions) => Promise<{
     features: Record<string, boolean>;
     functionsConfig: FunctionConfig[];
     graph: ModuleGraphJson;

package/dist/node/server/server.js

@@ -18,7 +18,7 @@ const cleanDirectory = async (directory, except) => {
     const toBeDeleted = files.filter((file) => !except.includes(join(directory, file)));
     await Promise.all(toBeDeleted.map((file) => unlink(join(directory, file))));
 };
-const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImportMapPath, flags: denoFlags, formatExportTypeError, formatImportError, logger, port, rootPath, }) => {
+const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImportMapPath, flags: denoFlags, formatExportTypeError, formatImportError, logger, port, rootPath, stderr, stdout, }) => {
     const processRef = {};
     const startServer = async (functions, env = {}, options = {}) => {
         var _a;
@@ -77,9 +77,11 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
         // with variables from the user's system, since those will not be available
         // in the production environment.
         await deno.runInBackground(['run', ...denoFlags, ...extraDenoFlags, stage2Path, ...applicationFlags], processRef, {
-            pipeOutput: true,
             env,
             extendEnv: false,
+            pipeOutput: true,
+            stderr,
+            stdout,
         });
         let functionsConfig = [];
         if (options.getFunctionsConfig) {
@@ -165,6 +167,16 @@ rootPath,
  * operate.
  */
 servePath, 
+/**
+ * Writable stream to receive the stderr of the server process. If not set,
+ * the stderr of the parent process will be used.
+ */
+stderr, 
+/**
+ * Writable stream to receive the stdout of the server process. If not set,
+ * the stdout of the parent process will be used.
+ */
+stdout, 
 /**
  * Custom logging function to be used for user-facing messages. Defaults to
  * `console.log`.
@@ -214,6 +226,8 @@ systemLogger, }) => {
         formatExportTypeError,
         formatImportError,
         logger,
+        stderr,
+        stdout,
         port,
         rootPath,
     });

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

@@ -1,8 +1,10 @@
+import { createWriteStream } from 'fs';
 import { readFile } from 'fs/promises';
 import { join } from 'path';
 import process from 'process';
 import getPort from 'get-port';
 import fetch from 'node-fetch';
+import tmp from 'tmp-promise';
 import { v4 as uuidv4 } from 'uuid';
 import { test, expect } from 'vitest';
 import { fixturesDir } from '../../test/util.js';
@@ -86,6 +88,8 @@ test('Starts a server and serves requests for edge functions', async () => {
     expect(identidadeBarrelFile).toContain(`/// <reference types="${join('..', '..', 'node_modules', '@types', 'pt-committee__identidade', 'index.d.ts')}" />`);
 });
 test('Serves edge functions in a monorepo setup', async () => {
+    const tmpFile = await tmp.file();
+    const stderr = createWriteStream(tmpFile.path);
     const rootPath = join(fixturesDir, 'monorepo_npm_module');
     const basePath = join(rootPath, 'packages', 'frontend');
     const paths = {
@@ -100,6 +104,7 @@ test('Serves edge functions in a monorepo setup', async () => {
         port,
         rootPath,
         servePath,
+        stderr,
     });
     const functions = [
         {
@@ -131,4 +136,6 @@ test('Serves edge functions in a monorepo setup', async () => {
     });
     expect(response1.status).toBe(200);
     expect(await response1.text()).toBe(`<parent-1><child-1>JavaScript</child-1></parent-1>, <parent-2><child-2><grandchild-1>APIs<cwd>${process.cwd()}</cwd></grandchild-1></child-2></parent-2>, <parent-3><child-2><grandchild-1>Markup<cwd>${process.cwd()}</cwd></grandchild-1></child-2></parent-3>`);
+    expect(await readFile(tmpFile.path, 'utf8')).toContain('[func1] Something is on fire');
+    await tmpFile.cleanup();
 });

package/package.json

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