@netlify/edge-bundler 8.13.2 → 8.14.0

package/dist/node/declaration.js

@@ -76,9 +76,8 @@ const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited
 // 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}/`, {
+    const regexp = new RegExp(pattern);
+    const newRegexp = regexpAST.transform(regexp, {
         Assertion(path) {
             // Lookaheads are not supported. If we find one, throw an error.
             if (path.node.kind === 'Lookahead') {
@@ -99,5 +98,5 @@ export const parsePattern = (pattern) => {
         },
     });
     // Strip leading and forward slashes.
-    return regex.toString().slice(1, -1);
+    return newRegexp.toString().slice(1, -1);
 };

package/dist/node/declaration.test.js

@@ -1,5 +1,5 @@
 import { test, expect } from 'vitest';
-import { mergeDeclarations } from './declaration.js';
+import { mergeDeclarations, parsePattern } from './declaration.js';
 const deployConfigDeclarations = [];
 test('Ensure the order of edge functions with FF', () => {
     const deployConfigDeclarations = [
@@ -137,3 +137,15 @@ test('netlify.toml-defined excludedPath are respected', () => {
     const declarations = mergeDeclarations(tomlConfig, funcConfig, {}, deployConfigDeclarations);
     expect(declarations).toEqual(expectedDeclarations);
 });
+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);
+});
+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);
+});

package/dist/node/manifest.d.ts

@@ -44,4 +44,4 @@ interface WriteManifestOptions extends GenerateManifestOptions {
     distDirectory: string;
 }
 declare const writeManifest: ({ distDirectory, ...rest }: WriteManifestOptions) => Promise<Manifest>;
-export { generateManifest, Manifest, writeManifest };
+export { generateManifest, Manifest, Route, writeManifest };

package/dist/node/manifest.test.js

@@ -1,5 +1,6 @@
 import { env } from 'process';
 import { test, expect, vi } from 'vitest';
+import { getRouteMatcher } from '../test/util.js';
 import { BundleFormat } from './bundle.js';
 import { generateManifest } from './manifest.js';
 test('Generates a manifest with different bundles', () => {
@@ -56,23 +57,45 @@ test('Generates a manifest with a generator field', () => {
     expect(manifest.function_config).toEqual(expectedFunctionConfig);
 });
 test('Generates a manifest with excluded paths and patterns', () => {
+    var _a, _b;
     const functions = [
         { name: 'func-1', path: '/path/to/func-1.ts' },
         { name: 'func-2', path: '/path/to/func-2.ts' },
+        { name: 'func-3', path: '/path/to/func-3.ts' },
     ];
     const declarations = [
         { function: 'func-1', path: '/f1/*', excludedPath: '/f1/exclude' },
         { function: 'func-2', pattern: '^/f2/.*/?$', excludedPattern: '^/f2/exclude$' },
+        { function: 'func-3', path: '/*', excludedPath: '/**/*.html' },
     ];
     const manifest = generateManifest({ bundles: [], declarations, functions });
     const expectedRoutes = [
         { function: 'func-1', pattern: '^/f1/.*/?$' },
         { function: 'func-2', pattern: '^/f2/.*/?$' },
+        { function: 'func-3', pattern: '^/.*/?$' },
     ];
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.function_config).toEqual({
         'func-1': { excluded_patterns: ['^/f1/exclude/?$'] },
         'func-2': { excluded_patterns: ['^/f2/exclude$'] },
+        'func-3': { excluded_patterns: ['^/.*/.*\\.html/?$'] },
+    });
+    expect(manifest.bundler_version).toBe(env.npm_package_version);
+    const matcher = getRouteMatcher(manifest);
+    expect((_a = matcher('/f1/hello')) === null || _a === void 0 ? void 0 : _a.function).toBe('func-1');
+    expect((_b = matcher('/grandparent/parent/child/grandchild.html')) === null || _b === void 0 ? void 0 : _b.function).toBeUndefined();
+});
+test('TOML-defined paths can be combined with ISC-defined excluded paths', () => {
+    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+    const declarations = [{ function: 'func-1', path: '/f1/*' }];
+    const userFunctionConfig = {
+        'func-1': { excludedPath: '/f1/exclude' },
+    };
+    const manifest = generateManifest({ bundles: [], declarations, functions, userFunctionConfig });
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$' }];
+    expect(manifest.routes).toEqual(expectedRoutes);
+    expect(manifest.function_config).toEqual({
+        'func-1': { excluded_patterns: ['^/f1/exclude/?$'] },
     });
     expect(manifest.bundler_version).toBe(env.npm_package_version);
 });

package/dist/test/util.d.ts

@@ -1,3 +1,4 @@
+import type { Manifest } from '../node/manifest.js';
 declare const testLogger: import("../node/logger.js").Logger;
 declare const fixturesDir: string;
 declare const useFixture: (fixtureName: string) => Promise<{
@@ -5,5 +6,6 @@ declare const useFixture: (fixtureName: string) => Promise<{
     cleanup: () => Promise<void>;
     distPath: string;
 }>;
+declare const getRouteMatcher: (manifest: Manifest) => (candidate: string) => import("../node/manifest.js").Route | undefined;
 declare const runESZIP: (eszipPath: string) => Promise<any>;
-export { fixturesDir, testLogger, runESZIP, useFixture };
+export { fixturesDir, getRouteMatcher, testLogger, runESZIP, useFixture };

package/dist/test/util.js

@@ -35,6 +35,15 @@ const inspectFunction = (path) => `
   
   console.log(JSON.stringify(responses));
 `;
+const getRouteMatcher = (manifest) => (candidate) => manifest.routes.find((route) => {
+    const regex = new RegExp(route.pattern);
+    if (!regex.test(candidate)) {
+        return false;
+    }
+    const excludedPattern = manifest.function_config[route.function].excluded_patterns;
+    const isExcluded = excludedPattern.some((pattern) => new RegExp(pattern).test(candidate));
+    return !isExcluded;
+});
 const runESZIP = async (eszipPath) => {
     var _a, _b, _c;
     const tmpDir = await tmp.dir({ unsafeCleanup: true });
@@ -66,4 +75,4 @@ const runESZIP = async (eszipPath) => {
     await tmpDir.cleanup();
     return JSON.parse(result.stdout);
 };
-export { fixturesDir, testLogger, runESZIP, useFixture };
+export { fixturesDir, getRouteMatcher, testLogger, runESZIP, useFixture };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "8.13.2",
+  "version": "8.14.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -42,7 +42,7 @@
   },
   "keywords": [],
   "license": "MIT",
-  "repository": "netlify/edge-bundler",
+  "repository": "https://github.com/netlify/edge-bundler",
   "bugs": {
     "url": "https://github.com/netlify/edge-bundler/issues"
   },