@netlify/edge-bundler 12.1.1 → 12.2.1

package/dist/node/bridge.d.ts

@@ -1,7 +1,7 @@
 import { type WriteStream } from 'fs';
 import { ExecaChildProcess } from 'execa';
 import { Logger } from './logger.js';
-declare const DENO_VERSION_RANGE = "^1.37.0";
+declare const DENO_VERSION_RANGE = "1.37.0 - 1.44.4";
 type OnBeforeDownloadHook = () => void | Promise<void>;
 type OnAfterDownloadHook = (error?: Error) => void | Promise<void>;
 interface DenoOptions {

package/dist/node/bridge.js

@@ -11,7 +11,9 @@ import { getBinaryExtension } from './platform.js';
 const DENO_VERSION_FILE = 'version.txt';
 // When updating DENO_VERSION_RANGE, ensure that the deno version installed in the
 // build-image/buildbot does satisfy this range!
-const DENO_VERSION_RANGE = '^1.37.0';
+// We're pinning the range because of an issue with v1.45.0 of the Deno CLI:
+// https://linear.app/netlify/issue/FRP-775/deno-cli-v1450-causing-issues
+const DENO_VERSION_RANGE = '1.37.0 - 1.44.4';
 class DenoBridge {
     constructor(options) {
         var _a, _b, _c, _d, _e;

package/dist/node/config.d.ts

@@ -11,19 +11,28 @@ export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS'
 export type Path = `/${string}`;
 export type OnError = 'fail' | 'bypass' | Path;
 export declare const isValidOnError: (value: unknown) => value is OnError;
-export interface FunctionConfig {
+interface BaseFunctionConfig {
     cache?: Cache;
-    path?: Path | Path[];
-    excludedPath?: Path | Path[];
     onError?: OnError;
     name?: string;
     generator?: string;
     method?: HTTPMethod | HTTPMethod[];
     rateLimit?: RateLimit;
 }
+interface FunctionConfigWithPath extends BaseFunctionConfig {
+    path?: Path | Path[];
+    excludedPath?: Path | Path[];
+}
+interface FunctionConfigWithPattern extends BaseFunctionConfig {
+    pattern: string | string[];
+    excludedPattern?: string | string[];
+}
+export type FunctionConfig = FunctionConfigWithPath | FunctionConfigWithPattern;
+export type FunctionConfigWithAllPossibleFields = BaseFunctionConfig & Partial<FunctionConfigWithPath & FunctionConfigWithPattern>;
 export declare const getFunctionConfig: ({ func, importMap, deno, log, }: {
     func: EdgeFunction;
     importMap: ImportMap;
     deno: DenoBridge;
     log: Logger;
 }) => Promise<FunctionConfig>;
+export {};

package/dist/node/config.test.js

@@ -215,7 +215,7 @@ test('Loads function paths from the in-source `config` function', async () => {
         configPath: join(internalDirectory, 'config.json'),
     });
     const generatedFiles = await fs.readdir(distPath);
-    expect(result.functions.length).toBe(7);
+    expect(result.functions.length).toBe(11);
     expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
@@ -223,7 +223,7 @@ test('Loads function paths from the in-source `config` function', async () => {
     expect(bundles.length).toBe(1);
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
-    expect(routes.length).toBe(6);
+    expect(routes.length).toBe(12);
     expect(routes[0]).toEqual({
         function: 'framework-func2',
         pattern: '^/framework-func2/?$',
@@ -244,24 +244,54 @@ test('Loads function paths from the in-source `config` function', async () => {
         path: '/framework-func1',
     });
     expect(routes[3]).toEqual({
+        function: 'framework-func3',
+        pattern: '^/framework-func3(/.*)?$',
+        excluded_patterns: ['^/framework-func3/excluded$'],
+    });
+    expect(routes[4]).toEqual({
+        function: 'framework-func4',
+        pattern: '^/framework-func4(/.*)?$',
+        excluded_patterns: ['^/framework-func4/excluded$', '^/framework-func4-alt/excluded$'],
+    });
+    expect(routes[5]).toEqual({
+        function: 'framework-func4',
+        pattern: '^/framework-func4-alt(/.*)?$',
+        excluded_patterns: ['^/framework-func4/excluded$', '^/framework-func4-alt/excluded$'],
+    });
+    expect(routes[6]).toEqual({
         function: 'user-func1',
         pattern: '^/user-func1/?$',
         excluded_patterns: [],
         path: '/user-func1',
     });
-    expect(routes[4]).toEqual({
+    expect(routes[7]).toEqual({
         function: 'user-func3',
         pattern: '^/user-func3/?$',
         excluded_patterns: [],
         path: '/user-func3',
     });
-    expect(routes[5]).toEqual({
+    expect(routes[8]).toEqual({
         function: 'user-func5',
         pattern: '^/user-func5(?:/(.*))/?$',
         excluded_patterns: ['^/user-func5/excluded/?$'],
         path: '/user-func5/*',
         methods: ['GET'],
     });
+    expect(routes[9]).toEqual({
+        function: 'user-func6',
+        pattern: '^/user-func6(/.*)?$',
+        excluded_patterns: ['^/user-func6/excluded$'],
+    });
+    expect(routes[10]).toEqual({
+        function: 'user-func7',
+        pattern: '^/user-func7(/.*)?$',
+        excluded_patterns: ['^/user-func7/excluded$', '^/user-func7-alt/excluded$'],
+    });
+    expect(routes[11]).toEqual({
+        function: 'user-func7',
+        pattern: '^/user-func7-alt(/.*)?$',
+        excluded_patterns: ['^/user-func7/excluded$', '^/user-func7-alt/excluded$'],
+    });
     expect(postCacheRoutes.length).toBe(1);
     expect(postCacheRoutes[0]).toEqual({
         function: 'user-func4',
@@ -270,10 +300,22 @@ test('Loads function paths from the in-source `config` function', async () => {
         path: '/user-func4',
         methods: ['POST', 'PUT'],
     });
-    expect(Object.keys(functionConfig)).toHaveLength(1);
+    expect(Object.keys(functionConfig)).toHaveLength(5);
     expect(functionConfig['user-func5']).toEqual({
         excluded_patterns: ['^/user-func5/excluded/?$'],
     });
+    expect(functionConfig['user-func6']).toEqual({
+        excluded_patterns: ['^/user-func6/excluded$'],
+    });
+    expect(functionConfig['user-func7']).toEqual({
+        excluded_patterns: ['^/user-func7/excluded$', '^/user-func7-alt/excluded$'],
+    });
+    expect(functionConfig['framework-func3']).toEqual({
+        excluded_patterns: ['^/framework-func3/excluded$'],
+    });
+    expect(functionConfig['framework-func4']).toEqual({
+        excluded_patterns: ['^/framework-func4/excluded$', '^/framework-func4-alt/excluded$'],
+    });
     await cleanup();
 });
 test('Passes validation if default export exists and is a function', async () => {

package/dist/node/declaration.js

@@ -17,7 +17,7 @@ _featureFlags = {}) => {
     return declarations;
 };
 const getDeclarationsFromInput = (inputDeclarations, functionConfigs, functionsVisited) => {
-    var _a;
+    var _a, _b;
     const declarations = [];
     // For any declaration for which we also have a function configuration object,
     // we replace the path because that object takes precedence.
@@ -27,7 +27,15 @@ const getDeclarationsFromInput = (inputDeclarations, functionConfigs, functionsV
             // If no config is found, add the declaration as is.
             declarations.push(declaration);
         }
-        else if ((_a = config.path) === null || _a === void 0 ? void 0 : _a.length) {
+        else if ('pattern' in config && ((_a = config.pattern) === null || _a === void 0 ? void 0 : _a.length)) {
+            // If we have a pattern specified as either a string or non-empty array,
+            // create a declaration for each pattern.
+            const patterns = Array.isArray(config.pattern) ? config.pattern : [config.pattern];
+            patterns.forEach((pattern) => {
+                declarations.push({ ...declaration, cache: config.cache, pattern });
+            });
+        }
+        else if ('path' in config && ((_b = config.path) === null || _b === void 0 ? void 0 : _b.length)) {
             // If we have a path specified as either a string or non-empty array,
             // create a declaration for each path.
             const paths = Array.isArray(config.path) ? config.path : [config.path];
@@ -38,7 +46,7 @@ const getDeclarationsFromInput = (inputDeclarations, functionConfigs, functionsV
         else {
             // With an in-source config without a path, add the config to the declaration.
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const { path, excludedPath, ...rest } = config;
+            const { path, excludedPath, pattern, excludedPattern, ...rest } = config;
             declarations.push({ ...declaration, ...rest });
         }
         functionsVisited.add(declaration.function);
@@ -48,23 +56,45 @@ const getDeclarationsFromInput = (inputDeclarations, functionConfigs, functionsV
 const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited) => {
     const declarations = [];
     for (const name in functionConfigs) {
-        const { cache, excludedPath, path, method } = functionConfigs[name];
-        // If we have a path specified, create a declaration for each path.
-        if (!functionsVisited.has(name) && path) {
-            const paths = Array.isArray(path) ? path : [path];
-            paths.forEach((singlePath) => {
-                const declaration = { function: name, path: singlePath };
-                if (cache) {
-                    declaration.cache = cache;
-                }
-                if (method) {
-                    declaration.method = method;
-                }
-                if (excludedPath) {
-                    declaration.excludedPath = excludedPath;
-                }
-                declarations.push(declaration);
-            });
+        const functionConfig = functionConfigs[name];
+        const { cache, method } = functionConfigs[name];
+        if (!functionsVisited.has(name)) {
+            // If we have a pattern specified, create a declaration for each pattern.
+            if ('pattern' in functionConfig && functionConfig.pattern) {
+                const { pattern, excludedPattern } = functionConfig;
+                const patterns = Array.isArray(pattern) ? pattern : [pattern];
+                patterns.forEach((singlePattern) => {
+                    const declaration = { function: name, pattern: singlePattern };
+                    if (cache) {
+                        declaration.cache = cache;
+                    }
+                    if (method) {
+                        declaration.method = method;
+                    }
+                    if (excludedPattern) {
+                        declaration.excludedPattern = excludedPattern;
+                    }
+                    declarations.push(declaration);
+                });
+            }
+            // If we don't have a pattern but we have a path specified, create a declaration for each path.
+            else if ('path' in functionConfig && functionConfig.path) {
+                const { path, excludedPath } = functionConfig;
+                const paths = Array.isArray(path) ? path : [path];
+                paths.forEach((singlePath) => {
+                    const declaration = { function: name, path: singlePath };
+                    if (cache) {
+                        declaration.cache = cache;
+                    }
+                    if (method) {
+                        declaration.method = method;
+                    }
+                    if (excludedPath) {
+                        declaration.excludedPath = excludedPath;
+                    }
+                    declarations.push(declaration);
+                });
+            }
         }
     }
     return declarations;

package/dist/node/manifest.js

@@ -27,13 +27,20 @@ const sanitizeEdgeFunctionConfig = (config) => {
     }
     return newConfig;
 };
-const addExcludedPatterns = (name, manifestFunctionConfig, excludedPath) => {
+const addManifestExcludedPatternsFromConfigExcludedPath = (name, manifestFunctionConfig, excludedPath) => {
     if (excludedPath) {
         const paths = Array.isArray(excludedPath) ? excludedPath : [excludedPath];
         const excludedPatterns = paths.map(pathToRegularExpression).filter(nonNullable).map(serializePattern);
         manifestFunctionConfig[name].excluded_patterns.push(...excludedPatterns);
     }
 };
+const addManifestExcludedPatternsFromConfigExcludedPattern = (name, manifestFunctionConfig, excludedPattern) => {
+    if (excludedPattern) {
+        const excludedPatterns = Array.isArray(excludedPattern) ? excludedPattern : [excludedPattern];
+        const normalizedExcludedPatterns = excludedPatterns.filter(nonNullable).map(normalizePattern).map(serializePattern);
+        manifestFunctionConfig[name].excluded_patterns.push(...normalizedExcludedPatterns);
+    }
+};
 /**
  * Normalizes method names into arrays of uppercase strings.
  * (e.g. "get" becomes ["GET"])
@@ -53,25 +60,37 @@ const generateManifest = ({ bundles = [], declarations = [], functions, userFunc
     const manifestFunctionConfig = Object.fromEntries(functions.map(({ name }) => [name, { excluded_patterns: [] }]));
     const routedFunctions = new Set();
     const declarationsWithoutFunction = new Set();
-    for (const [name, { excludedPath, onError, rateLimit }] of Object.entries(userFunctionConfig)) {
+    for (const [name, singleUserFunctionConfig] of Object.entries(userFunctionConfig)) {
         // If the config block is for a function that is not defined, discard it.
         if (manifestFunctionConfig[name] === undefined) {
             continue;
         }
-        addExcludedPatterns(name, manifestFunctionConfig, excludedPath);
+        const { excludedPath, pattern, excludedPattern, onError, rateLimit } = singleUserFunctionConfig;
+        if (pattern && excludedPattern) {
+            addManifestExcludedPatternsFromConfigExcludedPattern(name, manifestFunctionConfig, excludedPattern);
+        }
+        else {
+            addManifestExcludedPatternsFromConfigExcludedPath(name, manifestFunctionConfig, excludedPath);
+        }
         manifestFunctionConfig[name] = {
             ...manifestFunctionConfig[name],
             on_error: onError,
             traffic_rules: getTrafficRulesConfig(rateLimit),
         };
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    for (const [name, { excludedPath, path, onError, rateLimit, ...rest }] of Object.entries(internalFunctionConfig)) {
+    for (const [name, singleInternalFunctionConfig] of Object.entries(internalFunctionConfig)) {
         // If the config block is for a function that is not defined, discard it.
         if (manifestFunctionConfig[name] === undefined) {
             continue;
         }
-        addExcludedPatterns(name, manifestFunctionConfig, excludedPath);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { onError, rateLimit, path, excludedPath, pattern, excludedPattern, ...rest } = singleInternalFunctionConfig;
+        if (pattern && excludedPattern) {
+            addManifestExcludedPatternsFromConfigExcludedPattern(name, manifestFunctionConfig, excludedPattern);
+        }
+        else {
+            addManifestExcludedPatternsFromConfigExcludedPath(name, manifestFunctionConfig, excludedPath);
+        }
         manifestFunctionConfig[name] = {
             ...manifestFunctionConfig[name],
             on_error: onError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "12.1.1",
+  "version": "12.2.1",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -84,5 +84,5 @@
     "urlpattern-polyfill": "8.0.2",
     "uuid": "^9.0.0"
   },
-  "gitHead": "b993b18469d4355e164f605e742e69dcb5612905"
+  "gitHead": "3a237a7c2582fd9b48f18c482d26d0566dd6d4f0"
 }