feat: match edge functions by header (#7439)

* feat: match edge functions by header

* refactor: update checks

* chore: fix formatting

* refactor: remove unnecessary check

* fix: surface build errors

Author: eduardoboucas

src/lib/edge-functions/proxy.ts

@@ -165,7 +165,7 @@ export const initializeProxy = async ({
     await registry.initialize()
 
     const url = new URL(req.url!, `http://${LOCAL_HOST}:${mainPort}`)
-    const { functionNames, invocationMetadata } = registry.matchURLPath(url.pathname, req.method!)
+    const { functionNames, invocationMetadata } = registry.matchURLPath(url.pathname, req.method!, req.headers)
 
     if (functionNames.length === 0) {
       return

src/lib/edge-functions/registry.ts

@@ -21,7 +21,7 @@ import type { FeatureFlags } from '../../utils/feature-flags.js'
 import { MultiMap } from '../../utils/multimap.js'
 import { getPathInProject } from '../settings.js'
 
-import { INTERNAL_EDGE_FUNCTIONS_FOLDER } from './consts.js'
+import { DIST_IMPORT_MAP_PATH, INTERNAL_EDGE_FUNCTIONS_FOLDER } from './consts.js'
 
 type DependencyCache = Record<string, string[]>
 type EdgeFunctionEvent = 'buildError' | 'loaded' | 'reloaded' | 'reloading' | 'removed'
@@ -166,8 +166,8 @@ export class EdgeFunctionsRegistry {
       this.functions.forEach((func) => {
         this.logEvent('loaded', { functionName: func.name, warnings: warnings[func.name] })
       })
-    } catch {
-      // no-op
+    } catch (error) {
+      this.logEvent('buildError', { buildError: error as NodeJS.ErrnoException })
     }
   }
 
@@ -408,7 +408,7 @@ export class EdgeFunctionsRegistry {
    * Returns the functions in the registry that should run for a given URL path
    * and HTTP method, based on the routes registered for each function.
    */
-  matchURLPath(urlPath: string, method: string) {
+  matchURLPath(urlPath: string, method: string, headers: Record<string, string | string[] | undefined>) {
     const functionNames: string[] = []
     const routeIndexes: number[] = []
 
@@ -421,6 +421,34 @@ export class EdgeFunctionsRegistry {
         return
       }
 
+      if (route.headers) {
+        const headerMatches = Object.entries(route.headers).every(([headerName, headerMatch]) => {
+          const headerValueString = Array.isArray(headers[headerName])
+            ? headers[headerName].filter(Boolean).join(',')
+            : headers[headerName]
+
+          if (headerMatch?.matcher === 'exists') {
+            return headers[headerName] !== undefined
+          }
+
+          if (headerMatch?.matcher === 'missing') {
+            return headers[headerName] === undefined
+          }
+
+          if (headerValueString && headerMatch?.matcher === 'regex') {
+            const pattern = new RegExp(headerMatch.pattern)
+
+            return pattern.test(headerValueString)
+          }
+
+          return false
+        })
+
+        if (!headerMatches) {
+          return
+        }
+      }
+
       const isExcludedForFunction = this.manifest?.function_config[route.function]?.excluded_patterns?.some((pattern) =>
         new RegExp(pattern).test(urlPath),
       )
@@ -533,6 +561,10 @@ export class EdgeFunctionsRegistry {
     return join(this.projectDir, getPathInProject([INTERNAL_EDGE_FUNCTIONS_FOLDER]))
   }
 
+  private get internalImportMapPath() {
+    return join(this.projectDir, getPathInProject([DIST_IMPORT_MAP_PATH]))
+  }
+
   private async readDeployConfig() {
     const manifestPath = join(this.internalDirectory, 'manifest.json')
     try {
@@ -615,7 +647,7 @@ export class EdgeFunctionsRegistry {
   }
 
   private async setupWatcherForDirectory() {
-    const ignored = [`${this.servePath}/**`]
+    const ignored = [`${this.servePath}/**`, this.internalImportMapPath]
     const watcher = await watchDebounced(this.projectDir, {
       ignored,
       onAdd: () => this.checkForAddedOrDeletedFunctions(),

tests/integration/__fixtures__/dev-server-with-header-matching-edge-functions/netlify.toml

@@ -0,0 +1,2 @@
+[build]
+publish = "public"

tests/integration/__fixtures__/dev-server-with-header-matching-edge-functions/netlify/edge-functions/header-exists.js

@@ -0,0 +1,10 @@
+export default async (request) => {
+  return new Response('header-exists-matched')
+}
+
+export const config = {
+  path: '/header-exists',
+  header: {
+    'x-test-header': true,
+  },
+}

tests/integration/__fixtures__/dev-server-with-header-matching-edge-functions/netlify/edge-functions/header-missing.js

@@ -0,0 +1,10 @@
+export default async (request) => {
+  return new Response('header-missing-matched')
+}
+
+export const config = {
+  path: '/header-missing',
+  header: {
+    'x-forbidden-header': false,
+  },
+}

tests/integration/__fixtures__/dev-server-with-header-matching-edge-functions/netlify/edge-functions/header-regex.js

@@ -0,0 +1,10 @@
+export default async (request) => {
+  return new Response('header-regex-matched')
+}
+
+export const config = {
+  path: '/header-regex',
+  header: {
+    'x-api-key': '^api-key-\\d+$',
+  },
+}

tests/integration/__fixtures__/dev-server-with-header-matching-edge-functions/public/index.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Header Matching Test</title>
+  </head>
+  <body>
+    <h1>Header Matching Test Site</h1>
+    <p>This is a test site for header matching edge functions.</p>
+  </body>
+</html>

tests/integration/commands/dev/edge-functions.test.ts

@@ -287,4 +287,51 @@ describe.skipIf(isWindows)('edge functions', async () => {
       })
     },
   )
+
+  await setupFixtureTests(
+    'dev-server-with-header-matching-edge-functions',
+    { devServer: true, mockApi: { routes } },
+    () => {
+      test<FixtureTestContext>('should match edge functions with header exists condition', async ({ devServer }) => {
+        // Request without header - should not match
+        const responseWithoutHeader = await fetch(`http://localhost:${devServer!.port}/header-exists`)
+        expect(responseWithoutHeader.status).toBe(404)
+
+        // Request with header - should match
+        const responseWithHeader = await fetch(`http://localhost:${devServer!.port}/header-exists`, {
+          headers: { 'x-test-header': 'any-value' },
+        })
+        expect(responseWithHeader.status).toBe(200)
+        expect(await responseWithHeader.text()).toBe('header-exists-matched')
+      })
+
+      test<FixtureTestContext>('should match edge functions with header missing condition', async ({ devServer }) => {
+        // Request without header - should match
+        const responseWithoutHeader = await fetch(`http://localhost:${devServer!.port}/header-missing`)
+        expect(responseWithoutHeader.status).toBe(200)
+        expect(await responseWithoutHeader.text()).toBe('header-missing-matched')
+
+        // Request with header - should not match
+        const responseWithHeader = await fetch(`http://localhost:${devServer!.port}/header-missing`, {
+          headers: { 'x-forbidden-header': 'any-value' },
+        })
+        expect(responseWithHeader.status).toBe(404)
+      })
+
+      test<FixtureTestContext>('should match edge functions with header regex condition', async ({ devServer }) => {
+        // Request with non-matching header - should not match
+        const responseWithBadHeader = await fetch(`http://localhost:${devServer!.port}/header-regex`, {
+          headers: { 'x-api-key': 'invalid-key' },
+        })
+        expect(responseWithBadHeader.status).toBe(404)
+
+        // Request with matching header - should match
+        const responseWithGoodHeader = await fetch(`http://localhost:${devServer!.port}/header-regex`, {
+          headers: { 'x-api-key': 'api-key-123' },
+        })
+        expect(responseWithGoodHeader.status).toBe(200)
+        expect(await responseWithGoodHeader.text()).toBe('header-regex-matched')
+      })
+    },
+  )
 })