fix(gatsby-adapter-netlify): adapter use headerRoutes

e2e-tests/adapters/cypress/e2e/headers.cy.ts

@@ -0,0 +1,54 @@
+import { title } from "../../constants"
+
+describe("Headers", () => {
+  function checkHeaders(routeAlias, expectedHeaders) {
+    cy.wait(routeAlias).then(interception => {
+      Object.keys(expectedHeaders).forEach(headerKey => {
+        expect(interception.response.headers[headerKey]).to.eq(
+          expectedHeaders[headerKey]
+        )
+      })
+    })
+  }
+
+  const defaultHeaders = {
+    "x-xss-protection": "1; mode=block",
+    "x-content-type-options": "nosniff",
+    "referrer-policy": "same-origin",
+    "x-frame-options": "DENY",
+  }
+
+  it("should contain correct headers for index page", () => {
+    cy.intercept("/").as("index")
+    cy.visit("/")
+
+    checkHeaders("@index", {
+      ...defaultHeaders,
+      "x-custom-header": "my custom header value",
+    })
+  })
+
+  //   it("should contain correct headers for static assets", () => {
+  //     @todo
+  //   })
+
+  it("should contain correct headers for ssr page", () => {
+    cy.intercept("routes/ssr/static").as("ssr")
+    cy.visit("routes/ssr/static")
+
+    checkHeaders("@ssr", {
+      ...defaultHeaders,
+      "x-ssr-header": "my custom header value from config",
+    })
+  })
+
+  it("should contain correct headers for dsg page", () => {
+    cy.intercept("routes/dsg/static").as("dsg")
+    cy.visit("routes/dsg/static")
+
+    checkHeaders("@dsg", {
+      ...defaultHeaders,
+      "x-dsg-header": "my custom header value",
+    })
+  })
+})

e2e-tests/adapters/debug-adapter.ts

@@ -1,7 +1,7 @@
 import { inspect } from "util"
 import type { AdapterInit } from "gatsby"
 
-const createTestingAdapter: AdapterInit = (adapterOptions) => {
+const createTestingAdapter: AdapterInit = adapterOptions => {
   return {
     name: `gatsby-adapter-debug`,
     cache: {
@@ -10,28 +10,36 @@ const createTestingAdapter: AdapterInit = (adapterOptions) => {
       },
       store({ directories, reporter }) {
         reporter.info(`[gatsby-adapter-debug] cache.store() ${directories}`)
-      }
+      },
     },
     adapt({
       routesManifest,
+      headerRoutes,
       functionsManifest,
       pathPrefix,
       trailingSlash,
       reporter,
     }) {
       reporter.info(`[gatsby-adapter-debug] adapt()`)
 
-      console.log(`[gatsby-adapter-debug] adapt()`, inspect({
-        routesManifest,
-        functionsManifest,
-        pathPrefix,
-        trailingSlash,
-      }, {
-        depth: Infinity,
-        colors: true
-      }))
-    }
+      console.log(
+        `[gatsby-adapter-debug] adapt()`,
+        inspect(
+          {
+            routesManifest,
+            headerRoutes,
+            functionsManifest,
+            pathPrefix,
+            trailingSlash,
+          },
+          {
+            depth: Infinity,
+            colors: true,
+          }
+        )
+      )
+    },
   }
 }
 
-export default createTestingAdapter
+export default createTestingAdapter

e2e-tests/adapters/gatsby-config.ts

@@ -3,7 +3,8 @@ import debugAdapter from "./debug-adapter"
 import { siteDescription, title } from "./constants"
 
 const shouldUseDebugAdapter = process.env.USE_DEBUG_ADAPTER ?? false
-const trailingSlash = (process.env.TRAILING_SLASH || `never`) as GatsbyConfig["trailingSlash"]
+const trailingSlash = (process.env.TRAILING_SLASH ||
+  `never`) as GatsbyConfig["trailingSlash"]
 
 let configOverrides: GatsbyConfig = {}
 
@@ -21,6 +22,39 @@ const config: GatsbyConfig = {
   },
   trailingSlash,
   plugins: [],
+  headers: [
+    {
+      source: `/*`,
+      headers: [
+        {
+          key: "x-custom-header",
+          value: "my custom header value",
+        },
+      ],
+    },
+    {
+      source: `routes/ssr/*`,
+      headers: [
+        {
+          key: "x-ssr-header",
+          value: "my custom header value from config",
+        },
+        {
+          key: "x-ssr-header-overwrite",
+          value: "my custom header value from config",
+        },
+      ],
+    },
+    {
+      source: `routes/dsg/*`,
+      headers: [
+        {
+          key: "x-dsg-header",
+          value: "my custom header value",
+        },
+      ],
+    },
+  ],
   ...configOverrides,
 }
 

packages/gatsby-adapter-netlify/src/index.ts

@@ -62,9 +62,14 @@ const createNetlifyAdapter: AdapterInit<INetlifyAdapterOptions> = options => {
         }
       },
     },
-    async adapt({ routesManifest, functionsManifest }): Promise<void> {
+    async adapt({
+      routesManifest,
+      functionsManifest,
+      headerRoutes,
+    }): Promise<void> {
       const { lambdasThatUseCaching } = await handleRoutesManifest(
-        routesManifest
+        routesManifest,
+        headerRoutes
       )
 
       // functions handling

packages/gatsby-adapter-netlify/src/route-handler.ts

@@ -1,4 +1,4 @@
-import type { RoutesManifest } from "gatsby"
+import type { RoutesManifest, HeaderRoutes } from "gatsby"
 import { tmpdir } from "os"
 import { Transform } from "stream"
 import { join, basename } from "path"
@@ -130,7 +130,17 @@ export async function injectEntries(
   await fs.move(tmpFile, fileName)
 }
 
-export function processRoutesManifest(routesManifest: RoutesManifest): {
+function buildHeaderString(path, headers): string {
+  return `${encodeURI(path)}\n${headers.reduce((acc, curr) => {
+    acc += `  ${curr.key}: ${curr.value}\n`
+    return acc
+  }, ``)}`
+}
+
+export function processRoutesManifest(
+  routesManifest: RoutesManifest,
+  headerRoutes: HeaderRoutes
+): {
   redirects: string
   headers: string
   lambdasThatUseCaching: Map<string, string>
@@ -212,25 +222,33 @@ export function processRoutesManifest(routesManifest: RoutesManifest): {
         )}  200\n`
       }
 
-      _headers += `${encodeURI(fromPath)}\n${route.headers.reduce(
-        (acc, curr) => {
-          acc += `  ${curr.key}: ${curr.value}\n`
-          return acc
-        },
-        ``
-      )}`
+      if (!headerRoutes) {
+        // don't generate _headers from routesManifest if headerRoutes are provided
+        _headers += buildHeaderString(route.path, route.headers)
+      }
+    }
+
+    if (headerRoutes) {
+      _headers = headerRoutes.reduce((acc, curr) => {
+        acc += buildHeaderString(curr.path, curr.headers)
+        return acc
+      }, ``)
     }
   }
   return { redirects: _redirects, headers: _headers, lambdasThatUseCaching }
 }
 
 export async function handleRoutesManifest(
-  routesManifest: RoutesManifest
+  routesManifest: RoutesManifest,
+  headerRoutes: HeaderRoutes
 ): Promise<{
   lambdasThatUseCaching: Map<string, string>
 }> {
-  const { redirects, headers, lambdasThatUseCaching } =
-    processRoutesManifest(routesManifest)
+  const { redirects, headers, lambdasThatUseCaching } = processRoutesManifest(
+    routesManifest,
+    headerRoutes
+  )
+
   await injectEntries(`public/_redirects`, redirects)
   await injectEntries(`public/_headers`, headers)