@netlify/edge-bundler 14.0.6 → 14.1.0

package/deno/vendor/deno.land/std@0.98.0/async/mux_async_iterator.ts

@@ -13,7 +13,7 @@ interface TaggedYieldedValue<T> {
  */
 export class MuxAsyncIterator<T> implements AsyncIterable<T> {
   private iteratorCount = 0;
-  private yields: Array<TaggedYieldedValue<T>> = [];
+  private yields: TaggedYieldedValue<T>[] = [];
   // deno-lint-ignore no-explicit-any
   private throws: any[] = [];
   private signal: Deferred<void> = deferred();

package/deno/vendor/deno.land/std@0.98.0/async/pool.ts

@@ -31,7 +31,7 @@ export function pooledMap<T, R>(
   // Start processing items from the iterator
   (async () => {
     const writer = res.writable.getWriter();
-    const executing: Array<Promise<unknown>> = [];
+    const executing: Promise<unknown>[] = [];
     try {
       for await (const item of array) {
         const p = Promise.resolve().then(() => iteratorFn(item));

package/deno/vendor/deno.land/x/eszip@v0.55.2/eszip_wasm.generated.js

@@ -703,8 +703,8 @@ const imports = {
   },
 };
 
-import { Loader } from "https://deno.land/x/wasmbuild@0.15.1/loader.ts";
 import { cacheToLocalDir } from "https://deno.land/x/wasmbuild@0.15.1/cache.ts";
+import { Loader } from "https://deno.land/x/wasmbuild@0.15.1/loader.ts";
 
 const loader = new Loader({
   imports,

package/dist/node/bridge.d.ts

@@ -1,5 +1,5 @@
 import { type WriteStream } from 'fs';
-import { ExecaChildProcess } from 'execa';
+import { type ExecaChildProcess } from 'execa';
 import { Logger } from './logger.js';
 declare const DENO_VERSION_RANGE = "1.39.0 - 2.2.4";
 type OnBeforeDownloadHook = () => void | Promise<void>;

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,6 +1,5 @@
-export const mergeDeclarations = (tomlDeclarations, userFunctionsConfig, internalFunctionsConfig, deployConfigDeclarations, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-_featureFlags = {}) => {
+import { BundleError } from './bundle_error.js';
+export const mergeDeclarations = (tomlDeclarations, userFunctionsConfig, internalFunctionsConfig, deployConfigDeclarations, _featureFlags = {}) => {
     const functionsVisited = new Set();
     const declarations = [
         // INTEGRATIONS
@@ -45,7 +44,6 @@ 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, pattern, excludedPattern, ...rest } = config;
             declarations.push({ ...declaration, ...rest });
         }
@@ -61,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 };
@@ -74,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 };
@@ -92,6 +93,9 @@ const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited
                     if (excludedPath) {
                         declaration.excludedPath = excludedPath;
                     }
+                    if (header) {
+                        declaration.header = header;
+                    }
                     declarations.push(declaration);
                 });
             }
@@ -115,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';
@@ -83,7 +83,6 @@ const generateManifest = ({ bundles = [], declarations = [], functions, userFunc
         if (manifestFunctionConfig[name] === undefined) {
             continue;
         }
-        // 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);
@@ -120,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/server/util.d.ts

@@ -1,4 +1,4 @@
-import { ExecaChildProcess } from 'execa';
+import { type ExecaChildProcess } from 'execa';
 declare const killProcess: (ps: ExecaChildProcess<string>) => Promise<unknown> | undefined;
 declare const waitForServer: (port: number, ps?: ExecaChildProcess<string>) => Promise<boolean>;
 export { killProcess, waitForServer };

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

@@ -19,7 +19,6 @@ const initializeValidator = () => {
     return manifestValidator;
 };
 // throws on validation error
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 export const validateManifest = (manifestData, _featureFlags = {}) => {
     const validate = initializeValidator();
     const valid = validate(manifestData);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "14.0.6",
+  "version": "14.1.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -42,12 +42,13 @@
     "test": "test/node"
   },
   "devDependencies": {
-    "@types/node": "^18.0.0",
+    "@types/node": "^18.19.111",
     "@types/semver": "^7.3.9",
     "@types/uuid": "^10.0.0",
     "@vitest/coverage-v8": "^3.0.0",
     "archiver": "^7.0.0",
     "chalk": "^5.4.0",
+    "cpy": "^11.1.0",
     "nock": "^14.0.0",
     "npm-run-all2": "^6.0.0",
     "tar": "^7.0.0",
@@ -64,7 +65,7 @@
     "better-ajv-errors": "^1.2.0",
     "common-path-prefix": "^3.0.0",
     "env-paths": "^3.0.0",
-    "esbuild": "0.25.5",
+    "esbuild": "0.25.6",
     "execa": "^8.0.0",
     "find-up": "^7.0.0",
     "get-package-name": "^2.2.0",
@@ -80,5 +81,5 @@
     "urlpattern-polyfill": "8.0.2",
     "uuid": "^11.0.0"
   },
-  "gitHead": "4a0f587ae4efe1c2e62c25c11374e3fbaa9aebce"
+  "gitHead": "ea236c6df25a511cc0f0412759610da917c10b20"
 }