@netlify/edge-bundler 14.0.7 → 14.2.0

package/dist/node/config.d.ts

@@ -11,8 +11,10 @@ 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 type HeadersConfig = Record<string, boolean | string>;
 interface BaseFunctionConfig {
     cache?: Cache;
+    header?: HeadersConfig;
     onError?: OnError;
     name?: string;
     generator?: string;

package/dist/node/config.test.js

@@ -263,6 +263,18 @@ test('Loads function paths from the in-source `config` function', async () => {
         pattern: '^/user-func1/?$',
         excluded_patterns: [],
         path: '/user-func1',
+        headers: {
+            'x-must-be-there': {
+                style: 'exists',
+            },
+            'x-must-match': {
+                pattern: '^(foo|bar)$',
+                style: 'regex',
+            },
+            'x-must-not-be-there': {
+                style: 'missing',
+            },
+        },
     });
     expect(routes[7]).toEqual({
         function: 'user-func3',

package/dist/node/declaration.d.ts

@@ -1,8 +1,16 @@
-import { FunctionConfig, HTTPMethod, Path } from './config.js';
+import { FunctionConfig, HeadersConfig, HTTPMethod, Path } from './config.js';
 import { FeatureFlags } from './feature_flags.js';
+export type HeaderMatch = {
+    pattern: string;
+    style: 'regex';
+} | {
+    style: 'exists' | 'missing';
+};
+type HeaderMatchers = Record<string, HeaderMatch>;
 interface BaseDeclaration {
     cache?: string;
     function: string;
+    header?: HeadersConfig;
     method?: HTTPMethod | HTTPMethod[];
     name?: string;
     generator?: string;
@@ -22,4 +30,5 @@ export declare const mergeDeclarations: (tomlDeclarations: Declaration[], userFu
  * `$` characters.
  */
 export declare const normalizePattern: (pattern: string) => string;
+export declare const getHeaderMatchers: (headers?: HeadersConfig) => HeaderMatchers;
 export {};

package/dist/node/declaration.js

@@ -1,3 +1,4 @@
+import { BundleError } from './bundle_error.js';
 export const mergeDeclarations = (tomlDeclarations, userFunctionsConfig, internalFunctionsConfig, deployConfigDeclarations, _featureFlags = {}) => {
     const functionsVisited = new Set();
     const declarations = [
@@ -58,7 +59,7 @@ const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited
         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 { header, pattern, excludedPattern } = functionConfig;
                 const patterns = Array.isArray(pattern) ? pattern : [pattern];
                 patterns.forEach((singlePattern) => {
                     const declaration = { function: name, pattern: singlePattern };
@@ -71,12 +72,15 @@ const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited
                     if (excludedPattern) {
                         declaration.excludedPattern = excludedPattern;
                     }
+                    if (header) {
+                        declaration.header = header;
+                    }
                     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 { header, path, excludedPath } = functionConfig;
                 const paths = Array.isArray(path) ? path : [path];
                 paths.forEach((singlePath) => {
                     const declaration = { function: name, path: singlePath };
@@ -89,6 +93,9 @@ const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited
                     if (excludedPath) {
                         declaration.excludedPath = excludedPath;
                     }
+                    if (header) {
+                        declaration.header = header;
+                    }
                     declarations.push(declaration);
                 });
             }
@@ -112,3 +119,25 @@ export const normalizePattern = (pattern) => {
     // Strip leading and forward slashes.
     return regexp.toString().slice(1, -1);
 };
+const headerConfigError = `The 'header' configuration property must be an object where keys are strings and values are either booleans or strings (e.g. { "x-header-present": true, "x-header-absent": false, "x-header-matching": "^prefix" }).`;
+export const getHeaderMatchers = (headers) => {
+    const matchers = {};
+    if (!headers) {
+        return matchers;
+    }
+    if (Object.getPrototypeOf(headers) !== Object.prototype) {
+        throw new BundleError(new Error(headerConfigError));
+    }
+    for (const header in headers) {
+        if (typeof headers[header] === 'boolean') {
+            matchers[header] = { style: headers[header] ? 'exists' : 'missing' };
+        }
+        else if (typeof headers[header] === 'string') {
+            matchers[header] = { style: 'regex', pattern: normalizePattern(headers[header]) };
+        }
+        else {
+            throw new BundleError(new Error(headerConfigError));
+        }
+    }
+    return matchers;
+};

package/dist/node/manifest.d.ts

@@ -1,11 +1,12 @@
 import type { Bundle } from './bundle.js';
 import { FunctionConfig } from './config.js';
-import { Declaration } from './declaration.js';
+import { Declaration, type HeaderMatch } from './declaration.js';
 import { EdgeFunction } from './edge_function.js';
 import { FeatureFlags } from './feature_flags.js';
 import { Layer } from './layer.js';
 interface Route {
     function: string;
+    headers?: Record<string, HeaderMatch>;
     pattern: string;
     excluded_patterns: string[];
     path?: string;

package/dist/node/manifest.js

@@ -1,7 +1,7 @@
 import { promises as fs } from 'fs';
 import { join } from 'path';
 import { wrapBundleError } from './bundle_error.js';
-import { normalizePattern } from './declaration.js';
+import { getHeaderMatchers, normalizePattern } from './declaration.js';
 import { getPackageVersion } from './package_json.js';
 import { RateLimitAction, RateLimitAlgorithm, RateLimitAggregator } from './rate_limit.js';
 import { nonNullable } from './utils/non_nullable.js';
@@ -119,6 +119,9 @@ const generateManifest = ({ bundles = [], declarations = [], functions, userFunc
         if ('method' in declaration) {
             route.methods = normalizeMethods(declaration.method, func.name);
         }
+        if ('header' in declaration) {
+            route.headers = getHeaderMatchers(declaration.header);
+        }
         if ('path' in declaration) {
             route.path = declaration.path;
         }

package/dist/node/manifest.test.js

@@ -1,4 +1,4 @@
-import { test, expect } from 'vitest';
+import { describe, test, expect } from 'vitest';
 // @ts-expect-error current tsconfig.json doesn't allow this, but I don't want to change it
 import { version } from '../package.json' assert { type: 'json' };
 import { getRouteMatcher } from '../test/util.js';
@@ -514,3 +514,85 @@ test('Generates a manifest with rewrite config', () => {
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.function_config).toEqual(expectedFunctionConfig);
 });
+describe('Header matching', () => {
+    test('Throws a bundling error if the type is incorrect', () => {
+        const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+        expect(() => generateManifest({
+            bundles: [],
+            // @ts-expect-error Incorrect type
+            declarations: [{ function: 'func-1', path: '/f1/*', header: 'foo' }],
+            functions,
+        })).toThrowError(BundleError);
+        expect(() => generateManifest({
+            bundles: [],
+            declarations: [
+                {
+                    function: 'func-1',
+                    path: '/f1/*',
+                    header: {
+                        'x-correct': true,
+                        // @ts-expect-error Incorrect type
+                        'x-not-correct': {
+                            problem: true,
+                        },
+                    },
+                },
+            ],
+            functions,
+        })).toThrowError(BundleError);
+    });
+    test('Writes header matching rules to the manifest', () => {
+        const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+        const declarations = [
+            {
+                function: 'func-1',
+                path: '/f1/*',
+                header: {
+                    'x-present': true,
+                    'x-also-present': true,
+                    'x-absent': false,
+                    'x-match-prefix': '^prefix(.*)',
+                    'x-match-exact': 'exact',
+                    'x-match-suffix': '(.*)suffix$',
+                },
+            },
+        ];
+        const { manifest } = generateManifest({
+            bundles: [],
+            declarations,
+            functions,
+        });
+        const expectedRoutes = [
+            {
+                function: 'func-1',
+                pattern: '^/f1(?:/(.*))/?$',
+                excluded_patterns: [],
+                path: '/f1/*',
+                headers: {
+                    'x-absent': {
+                        style: 'missing',
+                    },
+                    'x-also-present': {
+                        style: 'exists',
+                    },
+                    'x-match-exact': {
+                        pattern: '^exact$',
+                        style: 'regex',
+                    },
+                    'x-match-prefix': {
+                        pattern: '^prefix(.*)$',
+                        style: 'regex',
+                    },
+                    'x-match-suffix': {
+                        pattern: '^(.*)suffix$',
+                        style: 'regex',
+                    },
+                    'x-present': {
+                        style: 'exists',
+                    },
+                },
+            },
+        ];
+        expect(manifest.routes).toEqual(expectedRoutes);
+    });
+});

package/dist/node/validation/manifest/index.test.js

@@ -142,3 +142,96 @@ describe('import map URL', () => {
         expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
     });
 });
+describe('route headers', () => {
+    test('should accept valid headers with exists style', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-custom-header': {
+                style: 'exists',
+            },
+        };
+        expect(() => validateManifest(manifest)).not.toThrowError();
+    });
+    test('should accept valid headers with missing style', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-custom-header': {
+                style: 'missing',
+            },
+        };
+        expect(() => validateManifest(manifest)).not.toThrowError();
+    });
+    test('should accept valid headers with regex style and pattern', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-custom-header': {
+                style: 'regex',
+                pattern: '^Bearer .+$',
+            },
+        };
+        expect(() => validateManifest(manifest)).not.toThrowError();
+    });
+    test('should throw on missing style property', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-custom-header': {
+                pattern: '^Bearer .+$',
+            },
+        };
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should throw on invalid style value', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-custom-header': {
+                style: 'invalid',
+            },
+        };
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should throw when style is regex but pattern is missing', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-custom-header': {
+                style: 'regex',
+            },
+        };
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should throw on invalid pattern format', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-custom-header': {
+                style: 'regex',
+                pattern: '/^Bearer .+/',
+            },
+        };
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should throw on additional property in headers', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-custom-header': {
+                style: 'exists',
+                foo: 'bar',
+            },
+        };
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should accept multiple headers with different styles', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-exists-header': {
+                style: 'exists',
+            },
+            'x-missing-header': {
+                style: 'missing',
+            },
+            authorization: {
+                style: 'regex',
+                pattern: '^Bearer [a-zA-Z0-9]+$',
+            },
+        };
+        expect(() => validateManifest(manifest)).not.toThrowError();
+    });
+});

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

@@ -57,6 +57,37 @@ declare const edgeManifestSchema: {
                             enum: string[];
                         };
                     };
+                    headers: {
+                        type: string;
+                        patternProperties: {
+                            '.*': {
+                                type: string;
+                                required: string[];
+                                properties: {
+                                    pattern: {
+                                        type: string;
+                                        format: string;
+                                    };
+                                    style: {
+                                        type: string;
+                                        enum: string[];
+                                    };
+                                };
+                                additionalProperties: boolean;
+                                if: {
+                                    properties: {
+                                        style: {
+                                            const: string;
+                                        };
+                                    };
+                                };
+                                then: {
+                                    required: string[];
+                                };
+                            };
+                        };
+                        additionalProperties: boolean;
+                    };
                 };
                 additionalProperties: boolean;
             };
@@ -99,6 +130,37 @@ declare const edgeManifestSchema: {
                             enum: string[];
                         };
                     };
+                    headers: {
+                        type: string;
+                        patternProperties: {
+                            '.*': {
+                                type: string;
+                                required: string[];
+                                properties: {
+                                    pattern: {
+                                        type: string;
+                                        format: string;
+                                    };
+                                    style: {
+                                        type: string;
+                                        enum: string[];
+                                    };
+                                };
+                                additionalProperties: boolean;
+                                if: {
+                                    properties: {
+                                        style: {
+                                            const: string;
+                                        };
+                                    };
+                                };
+                                then: {
+                                    required: string[];
+                                };
+                            };
+                        };
+                        additionalProperties: boolean;
+                    };
                 };
                 additionalProperties: boolean;
             };

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

@@ -15,6 +15,35 @@ const excludedPatternsSchema = {
         errorMessage: 'excluded_patterns must be an array of regex that starts with ^ and ends with $ (e.g. ^/blog/[d]{4}$)',
     },
 };
+const headersSchema = {
+    type: 'object',
+    patternProperties: {
+        '.*': {
+            type: 'object',
+            required: ['style'],
+            properties: {
+                pattern: {
+                    type: 'string',
+                    format: 'regexPattern',
+                },
+                style: {
+                    type: 'string',
+                    enum: ['exists', 'missing', 'regex'],
+                },
+            },
+            additionalProperties: false,
+            if: {
+                properties: {
+                    style: { const: 'regex' },
+                },
+            },
+            then: {
+                required: ['pattern'],
+            },
+        },
+    },
+    additionalProperties: false,
+};
 const routesSchema = {
     type: 'object',
     required: ['function', 'pattern'],
@@ -33,6 +62,7 @@ const routesSchema = {
             type: 'array',
             items: { type: 'string', enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'] },
         },
+        headers: headersSchema,
     },
     additionalProperties: false,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "14.0.7",
+  "version": "14.2.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -81,5 +81,5 @@
     "urlpattern-polyfill": "8.0.2",
     "uuid": "^11.0.0"
   },
-  "gitHead": "e471abe7b07fb8a34110d06bd8857c89f1d84142"
+  "gitHead": "9ba8975b7363b7003117aa0b224ad0d129c11ef4"
 }