@netlify/edge-bundler 8.3.0 → 8.5.0

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/formats/javascript.js

@@ -3,7 +3,7 @@ import { join } from 'path';
 import { env } from 'process';
 import { pathToFileURL } from 'url';
 import { deleteAsync } from 'del';
-const BOOTSTRAP_LATEST = 'https://63c67470ca761b0008582aff--edge.netlify.com/bootstrap/index-combined.ts';
+const BOOTSTRAP_LATEST = 'https://63c7dea30898f20009dd4da8--edge.netlify.com/bootstrap/index-combined.ts';
 const defaultFormatExportTypeError = (name) => `The Edge Function "${name}" has failed to load. Does it have a function as the default export?`;
 const defaultFormatImpoortError = (name) => `There was an error with Edge Function "${name}".`;
 const generateStage2 = async ({ distDirectory, fileName, formatExportTypeError, formatImportError, functions, }) => {

package/dist/node/manifest.d.ts

@@ -1,6 +1,6 @@
 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 { Layer } from './layer.js';
 interface Route {

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)) {
@@ -69,17 +74,27 @@ 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) => {
     if ('pattern' in declaration) {
-        return new RegExp(declaration.pattern);
+        try {
+            return parsePattern(declaration.pattern);
+        }
+        catch (error) {
+            throw new Error(`Could not parse path declaration of function '${declaration.function}': ${error.message}`);
+        }
     }
     return pathToRegularExpression(declaration.path);
 };
 const getExcludedRegularExpression = (declaration) => {
-    if ('pattern' in declaration && declaration.excludedPattern) {
-        return new RegExp(declaration.excludedPattern);
+    if ('excludedPattern' in declaration && declaration.excludedPattern) {
+        try {
+            return parsePattern(declaration.excludedPattern);
+        }
+        catch (error) {
+            throw new Error(`Could not parse path declaration of function '${declaration.function}': ${error.message}`);
+        }
     }
     if ('path' in declaration && declaration.excludedPath) {
         return pathToRegularExpression(declaration.excludedPath);

package/dist/node/manifest.test.js

@@ -164,3 +164,14 @@ 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', () => {
+    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+    const declarations = [{ function: 'func-1', pattern: '^/\\w+(?=\\d)$' }];
+    expect(() => generateManifest({ bundles: [], declarations, 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.3.0",
+  "version": "8.5.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())
-  }
-})