@netlify/edge-bundler 14.1.0 → 14.2.1

package/dist/node/config.test.js

@@ -265,14 +265,14 @@ test('Loads function paths from the in-source `config` function', async () => {
         path: '/user-func1',
         headers: {
             'x-must-be-there': {
-                style: 'exists',
+                matcher: 'exists',
             },
             'x-must-match': {
                 pattern: '^(foo|bar)$',
-                style: 'regex',
+                matcher: 'regex',
             },
             'x-must-not-be-there': {
-                style: 'missing',
+                matcher: 'missing',
             },
         },
     });

package/dist/node/declaration.d.ts

@@ -2,9 +2,9 @@ import { FunctionConfig, HeadersConfig, HTTPMethod, Path } from './config.js';
 import { FeatureFlags } from './feature_flags.js';
 export type HeaderMatch = {
     pattern: string;
-    style: 'regex';
+    matcher: 'regex';
 } | {
-    style: 'exists' | 'missing';
+    matcher: 'exists' | 'missing';
 };
 type HeaderMatchers = Record<string, HeaderMatch>;
 interface BaseDeclaration {

package/dist/node/declaration.js

@@ -130,10 +130,10 @@ export const getHeaderMatchers = (headers) => {
     }
     for (const header in headers) {
         if (typeof headers[header] === 'boolean') {
-            matchers[header] = { style: headers[header] ? 'exists' : 'missing' };
+            matchers[header] = { matcher: headers[header] ? 'exists' : 'missing' };
         }
         else if (typeof headers[header] === 'string') {
-            matchers[header] = { style: 'regex', pattern: normalizePattern(headers[header]) };
+            matchers[header] = { matcher: 'regex', pattern: normalizePattern(headers[header]) };
         }
         else {
             throw new BundleError(new Error(headerConfigError));

package/dist/node/manifest.test.js

@@ -215,11 +215,11 @@ test('excludedPath from ISC goes into function_config, TOML goes into routes', (
         },
     });
     const matcher = getRouteMatcher(manifest);
-    expect(matcher('/showcases/boho-style')).toBeDefined();
+    expect(matcher('/showcases/boho-matcher')).toBeDefined();
     expect(matcher('/checkout/address')).toBeDefined();
     expect(matcher('/checkout/terms-and-conditions')).toBeUndefined();
     expect(matcher('/checkout/scrooge-mc-duck-animation.css')).toBeUndefined();
-    expect(matcher('/showcases/boho-style/expensive-chair.jpg')).toBeUndefined();
+    expect(matcher('/showcases/boho-matcher/expensive-chair.jpg')).toBeUndefined();
 });
 test('URLPattern named groups are supported', () => {
     const functions = [{ name: 'customisation', path: '/path/to/customisation.ts' }];
@@ -570,25 +570,25 @@ describe('Header matching', () => {
                 path: '/f1/*',
                 headers: {
                     'x-absent': {
-                        style: 'missing',
+                        matcher: 'missing',
                     },
                     'x-also-present': {
-                        style: 'exists',
+                        matcher: 'exists',
                     },
                     'x-match-exact': {
                         pattern: '^exact$',
-                        style: 'regex',
+                        matcher: 'regex',
                     },
                     'x-match-prefix': {
                         pattern: '^prefix(.*)$',
-                        style: 'regex',
+                        matcher: 'regex',
                     },
                     'x-match-suffix': {
                         pattern: '^(.*)suffix$',
-                        style: 'regex',
+                        matcher: 'regex',
                     },
                     'x-present': {
-                        style: 'exists',
+                        matcher: 'exists',
                     },
                 },
             },

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 matcher', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-custom-header': {
+                matcher: 'exists',
+            },
+        };
+        expect(() => validateManifest(manifest)).not.toThrowError();
+    });
+    test('should accept valid headers with missing matcher', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-custom-header': {
+                matcher: 'missing',
+            },
+        };
+        expect(() => validateManifest(manifest)).not.toThrowError();
+    });
+    test('should accept valid headers with regex matcher and pattern', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-custom-header': {
+                matcher: 'regex',
+                pattern: '^Bearer .+$',
+            },
+        };
+        expect(() => validateManifest(manifest)).not.toThrowError();
+    });
+    test('should throw on missing matcher property', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-custom-header': {
+                pattern: '^Bearer .+$',
+            },
+        };
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should throw on invalid matcher value', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-custom-header': {
+                matcher: 'invalid',
+            },
+        };
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should throw when matcher is regex but pattern is missing', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-custom-header': {
+                matcher: 'regex',
+            },
+        };
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should throw on invalid pattern format', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-custom-header': {
+                matcher: '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': {
+                matcher: 'exists',
+                foo: 'bar',
+            },
+        };
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should accept multiple headers with different matchers', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].headers = {
+            'x-exists-header': {
+                matcher: 'exists',
+            },
+            'x-missing-header': {
+                matcher: 'missing',
+            },
+            authorization: {
+                matcher: '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;
+                                    };
+                                    matcher: {
+                                        type: string;
+                                        enum: string[];
+                                    };
+                                };
+                                additionalProperties: boolean;
+                                if: {
+                                    properties: {
+                                        matcher: {
+                                            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;
+                                    };
+                                    matcher: {
+                                        type: string;
+                                        enum: string[];
+                                    };
+                                };
+                                additionalProperties: boolean;
+                                if: {
+                                    properties: {
+                                        matcher: {
+                                            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: ['matcher'],
+            properties: {
+                pattern: {
+                    type: 'string',
+                    format: 'regexPattern',
+                },
+                matcher: {
+                    type: 'string',
+                    enum: ['exists', 'missing', 'regex'],
+                },
+            },
+            additionalProperties: false,
+            if: {
+                properties: {
+                    matcher: { 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.1.0",
+  "version": "14.2.1",
   "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": "ea236c6df25a511cc0f0412759610da917c10b20"
+  "gitHead": "18c4e2a28edc081235558f151b4c2d41b8e204e8"
 }