@netlify/edge-bundler 8.0.0 → 8.1.1

package/dist/node/bundler.js

@@ -75,6 +75,7 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
         declarations,
         distDirectory,
         functions,
+        functionConfig: functionsWithConfig,
         importMap: importMapSpecifier,
         layers: deployConfig.layers,
     });

package/dist/node/bundler.test.js

@@ -299,12 +299,12 @@ test('Loads declarations and import maps from the deploy configuration', async (
     expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
-    const { bundles, routes } = manifest;
+    const { bundles, function_config: functionConfig } = manifest;
     expect(bundles.length).toBe(1);
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
     // respects excludedPath from deploy config
-    expect(routes[1].excluded_pattern).toEqual('^/func2/skip/?$');
+    expect(functionConfig.func2).toEqual({ excluded_patterns: ['^/func2/skip/?$'] });
     await cleanup();
 });
 test("Ignores entries in `importMapPaths` that don't point to an existing import map file", async () => {

package/dist/node/config.d.ts

@@ -9,5 +9,6 @@ export declare const enum Cache {
 export interface FunctionConfig {
     cache?: Cache;
     path?: string | string[];
+    excludedPath?: string | string[];
 }
 export declare const getFunctionConfig: (func: EdgeFunction, importMap: ImportMap, deno: DenoBridge, log: Logger) => Promise<FunctionConfig>;

package/dist/node/config.test.js

@@ -102,7 +102,7 @@ test('Ignores function paths from the in-source `config` function if the feature
         configPath: join(internalDirectory, 'config.json'),
     });
     const generatedFiles = await fs.readdir(distPath);
-    expect(result.functions.length).toBe(6);
+    expect(result.functions.length).toBe(7);
     expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
@@ -135,22 +135,27 @@ test('Loads function paths from the in-source `config` function', async () => {
         },
     });
     const generatedFiles = await fs.readdir(distPath);
-    expect(result.functions.length).toBe(6);
+    expect(result.functions.length).toBe(7);
     expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
-    const { bundles, routes, post_cache_routes: postCacheRoutes } = manifest;
+    const { bundles, routes, post_cache_routes: postCacheRoutes, function_config: functionConfig } = manifest;
     expect(bundles.length).toBe(1);
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
-    expect(routes.length).toBe(5);
+    expect(routes.length).toBe(6);
     expect(routes[0]).toEqual({ function: 'framework-func2', pattern: '^/framework-func2/?$' });
     expect(routes[1]).toEqual({ function: 'user-func2', pattern: '^/user-func2/?$' });
     expect(routes[2]).toEqual({ function: 'framework-func1', pattern: '^/framework-func1/?$' });
     expect(routes[3]).toEqual({ function: 'user-func1', pattern: '^/user-func1/?$' });
     expect(routes[4]).toEqual({ function: 'user-func3', pattern: '^/user-func3/?$' });
+    expect(routes[5]).toEqual({ function: 'user-func5', pattern: '^/user-func5/.*/?$' });
     expect(postCacheRoutes.length).toBe(1);
     expect(postCacheRoutes[0]).toEqual({ function: 'user-func4', pattern: '^/user-func4/?$' });
+    expect(Object.keys(functionConfig)).toHaveLength(1);
+    expect(functionConfig['user-func5']).toEqual({
+        excluded_patterns: ['^/user-func5/excluded/?$'],
+    });
     await cleanup();
 });
 test('Passes validation if default export exists and is a function', async () => {

package/dist/node/declaration.js

@@ -17,13 +17,13 @@ export const getDeclarationsFromConfig = (tomlDeclarations, functionsConfig, dep
         else if ((_a = config.path) === null || _a === void 0 ? void 0 : _a.length) {
             const paths = Array.isArray(config.path) ? config.path : [config.path];
             paths.forEach((path) => {
-                declarations.push({ ...declaration, ...config, path });
+                declarations.push({ ...declaration, cache: config.cache, path });
             });
             // With an in-source config without a path, add the config to the declaration
         }
         else {
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const { path, ...rest } = config;
+            const { path, excludedPath, ...rest } = config;
             declarations.push({ ...declaration, ...rest });
         }
         functionsVisited.add(declaration.function);
@@ -31,13 +31,12 @@ export const getDeclarationsFromConfig = (tomlDeclarations, functionsConfig, dep
     // Finally, we must create declarations for functions that are not declared
     // in the TOML at all.
     for (const name in functionsConfig) {
-        const { ...config } = functionsConfig[name];
-        const { path } = functionsConfig[name];
+        const { cache, path } = functionsConfig[name];
         // If we have path specified create a declaration for each path
         if (!functionsVisited.has(name) && path) {
             const paths = Array.isArray(path) ? path : [path];
             paths.forEach((singlePath) => {
-                declarations.push({ ...config, function: name, path: singlePath });
+                declarations.push({ cache, function: name, path: singlePath });
             });
         }
     }

package/dist/node/manifest.d.ts

@@ -1,19 +1,15 @@
 import type { Bundle } from './bundle.js';
+import { FunctionConfig } from './config.js';
 import type { Declaration } from './declaration.js';
 import { EdgeFunction } from './edge_function.js';
 import { Layer } from './layer.js';
-interface GenerateManifestOptions {
-    bundles?: Bundle[];
-    declarations?: Declaration[];
-    functions: EdgeFunction[];
-    importMap?: string;
-    layers?: Layer[];
-}
 interface Route {
     function: string;
     name?: string;
     pattern: string;
-    excluded_pattern?: string;
+}
+interface EdgeFunctionConfig {
+    excluded_patterns: string[];
 }
 interface Manifest {
     bundler_version: string;
@@ -28,20 +24,24 @@ interface Manifest {
     }[];
     routes: Route[];
     post_cache_routes: Route[];
+    function_config: Record<string, EdgeFunctionConfig>;
+}
+interface GenerateManifestOptions {
+    bundles?: Bundle[];
+    declarations?: Declaration[];
+    functions: EdgeFunction[];
+    functionConfig?: Record<string, FunctionConfig>;
+    importMap?: string;
+    layers?: Layer[];
 }
 interface Route {
     function: string;
     name?: string;
     pattern: string;
 }
-declare const generateManifest: ({ bundles, declarations, functions, importMap, layers, }: GenerateManifestOptions) => Manifest;
-interface WriteManifestOptions {
-    bundles: Bundle[];
-    declarations: Declaration[];
+declare const generateManifest: ({ bundles, declarations, functions, functionConfig, importMap, layers, }: GenerateManifestOptions) => Manifest;
+interface WriteManifestOptions extends GenerateManifestOptions {
     distDirectory: string;
-    functions: EdgeFunction[];
-    importMap?: string;
-    layers?: Layer[];
 }
-declare const writeManifest: ({ bundles, declarations, distDirectory, functions, importMap, layers, }: WriteManifestOptions) => Promise<Manifest>;
+declare const writeManifest: ({ distDirectory, ...rest }: WriteManifestOptions) => Promise<Manifest>;
 export { generateManifest, Manifest, writeManifest };

package/dist/node/manifest.js

@@ -4,9 +4,26 @@ import globToRegExp from 'glob-to-regexp';
 import { getPackageVersion } from './package_json.js';
 import { nonNullable } from './utils/non_nullable.js';
 const serializePattern = (regex) => regex.source.replace(/\\\//g, '/');
-const generateManifest = ({ bundles = [], declarations = [], functions, importMap, layers = [], }) => {
+const sanitizeEdgeFunctionConfig = (config) => {
+    const newConfig = {};
+    for (const [name, functionConfig] of Object.entries(config)) {
+        if (functionConfig.excluded_patterns.length !== 0) {
+            newConfig[name] = functionConfig;
+        }
+    }
+    return newConfig;
+};
+const generateManifest = ({ bundles = [], declarations = [], functions, functionConfig = {}, importMap, layers = [], }) => {
     const preCacheRoutes = [];
     const postCacheRoutes = [];
+    const manifestFunctionConfig = Object.fromEntries(functions.map(({ name }) => [name, { excluded_patterns: [] }]));
+    for (const [name, { excludedPath }] of Object.entries(functionConfig)) {
+        if (excludedPath) {
+            const paths = Array.isArray(excludedPath) ? excludedPath : [excludedPath];
+            const excludedPatterns = paths.map(pathToRegularExpression).map(serializePattern);
+            manifestFunctionConfig[name].excluded_patterns.push(...excludedPatterns);
+        }
+    }
     declarations.forEach((declaration) => {
         const func = functions.find(({ name }) => declaration.function === name);
         if (func === undefined) {
@@ -20,7 +37,7 @@ const generateManifest = ({ bundles = [], declarations = [], functions, importMa
         };
         const excludedPattern = getExcludedRegularExpression(declaration);
         if (excludedPattern) {
-            route.excluded_pattern = serializePattern(excludedPattern);
+            manifestFunctionConfig[func.name].excluded_patterns.push(serializePattern(excludedPattern));
         }
         if (declaration.cache === "manual" /* Cache.Manual */) {
             postCacheRoutes.push(route);
@@ -40,6 +57,7 @@ const generateManifest = ({ bundles = [], declarations = [], functions, importMa
         bundler_version: getPackageVersion(),
         layers,
         import_map: importMap,
+        function_config: sanitizeEdgeFunctionConfig(manifestFunctionConfig),
     };
     return manifest;
 };
@@ -67,8 +85,8 @@ const getExcludedRegularExpression = (declaration) => {
         return pathToRegularExpression(declaration.excludedPath);
     }
 };
-const writeManifest = async ({ bundles, declarations = [], distDirectory, functions, importMap, layers, }) => {
-    const manifest = generateManifest({ bundles, declarations, functions, importMap, layers });
+const writeManifest = async ({ distDirectory, ...rest }) => {
+    const manifest = generateManifest(rest);
     const manifestPath = join(distDirectory, 'manifest.json');
     await fs.writeFile(manifestPath, JSON.stringify(manifest));
     return manifest;

package/dist/node/manifest.test.js

@@ -53,10 +53,14 @@ test('Generates a manifest with excluded paths and patterns', () => {
     ];
     const manifest = generateManifest({ bundles: [], declarations, functions });
     const expectedRoutes = [
-        { function: 'func-1', name: 'Display Name', pattern: '^/f1/.*/?$', excluded_pattern: '^/f1/exclude/?$' },
-        { function: 'func-2', pattern: '^/f2/.*/?$', excluded_pattern: '^/f2/exclude$' },
+        { function: 'func-1', name: 'Display Name', pattern: '^/f1/.*/?$' },
+        { function: 'func-2', pattern: '^/f2/.*/?$' },
     ];
     expect(manifest.routes).toEqual(expectedRoutes);
+    expect(manifest.function_config).toEqual({
+        'func-1': { excluded_patterns: ['^/f1/exclude/?$'] },
+        'func-2': { excluded_patterns: ['^/f2/exclude$'] },
+    });
     expect(manifest.bundler_version).toBe(env.npm_package_version);
 });
 test('Excludes functions for which there are function files but no matching config declarations', () => {

package/dist/node/validation/manifest/schema.d.ts

@@ -86,6 +86,23 @@ declare const edgeManifestSchema: {
         bundler_version: {
             type: string;
         };
+        function_config: {
+            type: string;
+            items: {
+                type: string;
+                required: never[];
+                properties: {
+                    excluded_patterns: {
+                        type: string;
+                        items: {
+                            type: string;
+                            format: string;
+                            errorMessage: string;
+                        };
+                    };
+                };
+            };
+        };
     };
     additionalProperties: boolean;
 };

package/dist/node/validation/manifest/schema.js

@@ -21,6 +21,20 @@ const routesSchema = {
     },
     additionalProperties: false,
 };
+const functionConfigSchema = {
+    type: 'object',
+    required: [],
+    properties: {
+        excluded_patterns: {
+            type: 'array',
+            items: {
+                type: 'string',
+                format: 'regexPattern',
+                errorMessage: 'excluded_patterns needs to be an array of regex that starts with ^ and ends with $ without any additional slashes before and afterwards',
+            },
+        },
+    },
+};
 const layersSchema = {
     type: 'object',
     required: ['flag', 'name'],
@@ -53,6 +67,7 @@ const edgeManifestSchema = {
         },
         import_map: { type: 'string' },
         bundler_version: { type: 'string' },
+        function_config: { type: 'object', items: functionConfigSchema },
     },
     additionalProperties: false,
 };

package/package.json

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