@netlify/edge-bundler 8.4.0 → 8.6.0

package/dist/node/bundler.js

@@ -74,6 +74,7 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
         bundles: [functionBundle],
         declarations,
         distDirectory,
+        featureFlags,
         functions,
         functionConfig: functionsWithConfig,
         importMap: importMapSpecifier,

package/dist/node/declaration.d.ts

@@ -15,4 +15,5 @@ type DeclarationWithPattern = BaseDeclaration & {
 };
 type Declaration = DeclarationWithPath | DeclarationWithPattern;
 export declare const getDeclarationsFromConfig: (tomlDeclarations: Declaration[], functionsConfig: Record<string, FunctionConfig>, deployConfig: DeployConfig) => Declaration[];
+export declare const parsePattern: (pattern: string) => string;
 export { Declaration, DeclarationWithPath, DeclarationWithPattern };

package/dist/node/declaration.js

@@ -1,3 +1,4 @@
+import regexpAST from 'regexp-tree';
 export const getDeclarationsFromConfig = (tomlDeclarations, functionsConfig, deployConfig) => {
     var _a;
     const declarations = [];
@@ -42,3 +43,31 @@ export const getDeclarationsFromConfig = (tomlDeclarations, functionsConfig, dep
     }
     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) => {
+    // Escaping forward slashes with back slashes.
+    const normalizedPattern = pattern.replace(/\//g, '\\/');
+    const regex = regexpAST.transform(`/${normalizedPattern}/`, {
+        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,
+                });
+            }
+        },
+    });
+    // Strip leading and forward slashes.
+    return regex.toString().slice(1, -1);
+};

package/dist/node/feature_flags.js

@@ -1,6 +1,7 @@
 const defaultFlags = {
     edge_functions_cache_deno_dir: false,
     edge_functions_config_export: false,
+    edge_functions_fail_unsupported_regex: false,
 };
 const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
     ...result,

package/dist/node/manifest.d.ts

@@ -1,7 +1,8 @@
 import type { Bundle } from './bundle.js';
 import { FunctionConfig } from './config.js';
-import type { Declaration } from './declaration.js';
+import { Declaration } from './declaration.js';
 import { EdgeFunction } from './edge_function.js';
+import { FeatureFlags } from './feature_flags.js';
 import { Layer } from './layer.js';
 interface Route {
     function: string;
@@ -29,6 +30,7 @@ interface Manifest {
 interface GenerateManifestOptions {
     bundles?: Bundle[];
     declarations?: Declaration[];
+    featureFlags?: FeatureFlags;
     functions: EdgeFunction[];
     functionConfig?: Record<string, FunctionConfig>;
     importMap?: string;
@@ -39,7 +41,7 @@ interface Route {
     name?: string;
     pattern: string;
 }
-declare const generateManifest: ({ bundles, declarations, functions, functionConfig, importMap, layers, }: GenerateManifestOptions) => Manifest;
+declare const generateManifest: ({ bundles, declarations, featureFlags, functions, functionConfig, importMap, layers, }: GenerateManifestOptions) => Manifest;
 interface WriteManifestOptions extends GenerateManifestOptions {
     distDirectory: string;
 }

package/dist/node/manifest.js

@@ -1,9 +1,14 @@
 import { promises as fs } from 'fs';
 import { join } from 'path';
 import globToRegExp from 'glob-to-regexp';
+import { parsePattern } from './declaration.js';
 import { getPackageVersion } from './package_json.js';
 import { nonNullable } from './utils/non_nullable.js';
-const serializePattern = (regex) => regex.source.replace(/\\\//g, '/');
+// JavaScript regular expressions are converted to strings with leading and
+// trailing slashes, so any slashes inside the expression itself are escaped
+// as `//`. This function deserializes that back into a single slash, which
+// is the format we want to use in the manifest.
+const serializePattern = (pattern) => pattern.replace(/\\\//g, '/');
 const sanitizeEdgeFunctionConfig = (config) => {
     const newConfig = {};
     for (const [name, functionConfig] of Object.entries(config)) {
@@ -13,7 +18,7 @@ const sanitizeEdgeFunctionConfig = (config) => {
     }
     return newConfig;
 };
-const generateManifest = ({ bundles = [], declarations = [], functions, functionConfig = {}, importMap, layers = [], }) => {
+const generateManifest = ({ bundles = [], declarations = [], featureFlags, functions, functionConfig = {}, importMap, layers = [], }) => {
     const preCacheRoutes = [];
     const postCacheRoutes = [];
     const manifestFunctionConfig = Object.fromEntries(functions.map(({ name }) => [name, { excluded_patterns: [] }]));
@@ -29,13 +34,13 @@ const generateManifest = ({ bundles = [], declarations = [], functions, function
         if (func === undefined) {
             return;
         }
-        const pattern = getRegularExpression(declaration);
+        const pattern = getRegularExpression(declaration, featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_fail_unsupported_regex);
         const route = {
             function: func.name,
             name: declaration.name,
             pattern: serializePattern(pattern),
         };
-        const excludedPattern = getExcludedRegularExpression(declaration);
+        const excludedPattern = getExcludedRegularExpression(declaration, featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_fail_unsupported_regex);
         if (excludedPattern) {
             manifestFunctionConfig[func.name].excluded_patterns.push(serializePattern(excludedPattern));
         }
@@ -69,17 +74,37 @@ const pathToRegularExpression = (path) => {
     // trailing slash, so that a declaration of `path: "/foo"` matches requests
     // for both `/foo` and `/foo/`.
     const normalizedSource = `^${regularExpression.source}\\/?$`;
-    return new RegExp(normalizedSource);
+    return normalizedSource;
 };
-const getRegularExpression = (declaration) => {
+const getRegularExpression = (declaration, failUnsupportedRegex = false) => {
     if ('pattern' in declaration) {
-        return new RegExp(declaration.pattern);
+        try {
+            return parsePattern(declaration.pattern);
+        }
+        catch (error) {
+            // eslint-disable-next-line max-depth
+            if (failUnsupportedRegex) {
+                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);
 };
-const getExcludedRegularExpression = (declaration) => {
-    if ('pattern' in declaration && declaration.excludedPattern) {
-        return new RegExp(declaration.excludedPattern);
+const getExcludedRegularExpression = (declaration, failUnsupportedRegex = false) => {
+    if ('excludedPattern' in declaration && declaration.excludedPattern) {
+        try {
+            return parsePattern(declaration.excludedPattern);
+        }
+        catch (error) {
+            // eslint-disable-next-line max-depth
+            if (failUnsupportedRegex) {
+                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}`);
+            return declaration.excludedPattern;
+        }
     }
     if ('path' in declaration && declaration.excludedPath) {
         return pathToRegularExpression(declaration.excludedPath);

package/dist/node/manifest.test.js

@@ -1,5 +1,5 @@
 import { env } from 'process';
-import { test, expect } from 'vitest';
+import { test, expect, vi } from 'vitest';
 import { BundleFormat } from './bundle.js';
 import { generateManifest } from './manifest.js';
 test('Generates a manifest with different bundles', () => {
@@ -164,3 +164,35 @@ test('Generates a manifest with layers', () => {
     expect(manifest2.routes).toEqual(expectedRoutes);
     expect(manifest2.layers).toEqual(layers);
 });
+test('Shows a warning if the regular expression contains a negative lookahead', () => {
+    const mockConsoleWarn = vi.fn();
+    const consoleWarn = console.warn;
+    console.warn = mockConsoleWarn;
+    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+    const declarations = [{ function: 'func-1', pattern: '^/\\w+(?=\\d)$' }];
+    const manifest = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+    });
+    console.warn = consoleWarn;
+    expect(manifest.routes).toEqual([{ function: 'func-1', pattern: '^/\\w+(?=\\d)$' }]);
+    expect(mockConsoleWarn).toHaveBeenCalledOnce();
+    expect(mockConsoleWarn).toHaveBeenCalledWith("Function 'func-1' uses an unsupported regular expression and will not be invoked: Regular expressions with lookaheads are not supported");
+});
+test('Throws an error if the regular expression contains a negative lookahead and the `edge_functions_fail_unsupported_regex` flag is set', () => {
+    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+    const declarations = [{ function: 'func-1', pattern: '^/\\w+(?=\\d)$' }];
+    expect(() => generateManifest({
+        bundles: [],
+        declarations,
+        featureFlags: { edge_functions_fail_unsupported_regex: true },
+        functions,
+    })).toThrowError(/^Could not parse path declaration of function 'func-1': Regular expressions with lookaheads are not supported$/);
+});
+test('Converts named capture groups to unnamed capture groups in regular expressions', () => {
+    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+)$' }]);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "8.4.0",
+  "version": "8.6.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -90,6 +90,7 @@
     "p-retry": "^5.1.1",
     "p-wait-for": "^4.1.0",
     "path-key": "^4.0.0",
+    "regexp-tree": "^0.1.24",
     "semver": "^7.3.5",
     "tmp-promise": "^3.0.3",
     "uuid": "^9.0.0"

package/deno/lib/stage2.test.ts

@@ -1,58 +0,0 @@
-import { assertEquals, assertStringIncludes } from 'https://deno.land/std@0.127.0/testing/asserts.ts'
-
-import { join } from 'https://deno.land/std@0.155.0/path/mod.ts'
-import { pathToFileURL } from 'https://deno.land/std@0.155.0/node/url.ts'
-
-import { getStage2Entry } from './stage2.ts'
-import { virtualRoot } from './consts.ts'
-
-Deno.test('`getStage2Entry` returns a valid stage 2 file', async () => {
-  const directory = await Deno.makeTempDir()
-  const functions = [
-    {
-      name: 'func1',
-      path: join(directory, 'func1.ts'),
-      response: 'Hello from function 1',
-    },
-    {
-      name: 'func2',
-      path: join(directory, 'func2.ts'),
-      response: 'Hello from function 2',
-    },
-  ]
-
-  for (const func of functions) {
-    const contents = `export default async () => new Response(${JSON.stringify(func.response)})`
-
-    await Deno.writeTextFile(func.path, contents)
-  }
-
-  const baseURL = pathToFileURL(directory)
-  const stage2 = getStage2Entry(
-    directory,
-    functions.map(({ name, path }) => ({ name, path })),
-  )
-
-  // Ensuring that the stage 2 paths have the virtual root before we strip it.
-  assertStringIncludes(stage2, virtualRoot)
-
-  // Replacing the virtual root with the URL of the temporary directory so that
-  // we can actually import the module.
-  const normalizedStage2 = stage2.replaceAll(virtualRoot, `${baseURL.href}/`)
-
-  const stage2Path = join(directory, 'stage2.ts')
-  const stage2URL = pathToFileURL(stage2Path)
-
-  await Deno.writeTextFile(stage2Path, normalizedStage2)
-
-  const mod = await import(stage2URL.href)
-
-  await Deno.remove(directory, { recursive: true })
-
-  for (const func of functions) {
-    const result = await mod.functions[func.name]()
-
-    assertEquals(await result.text(), func.response)
-    assertEquals(mod.metadata.functions[func.name].url, pathToFileURL(func.path).toString())
-  }
-})