fix(types)!: fix @netlify/headers-parser types

packages/headers-parser/src/all.ts

@@ -50,7 +50,7 @@ const getFileHeaders = async function (headersFiles: string[]) {
   return concatResults(resultsArrays)
 }
 
-const getConfigHeaders = async function (netlifyConfigPath?: undefined | string) {
+const getConfigHeaders = async function (netlifyConfigPath?: string) {
   if (netlifyConfigPath === undefined) {
     return splitResults([])
   }

packages/headers-parser/src/normalize.ts

@@ -98,7 +98,7 @@ function parseHeaderObject(
 }
 
 // Normalize and validate the `for` field
-const normalizePath = function (rawPath?: undefined | string): string {
+const normalizePath = function (rawPath?: string): string {
   if (rawPath === undefined) {
     throw new TypeError('Missing "for" field')
   }

packages/headers-parser/tests/all.test.ts

@@ -38,17 +38,29 @@ test.each([
       { for: '/path', values: { test: 'two' } },
     ],
   ],
-  ['invalid_mixed', { headersFiles: ['success'], configHeaders: {} }, [{ for: '/path', values: { test: 'one' } }]],
+  ['invalid_mixed', { headersFiles: ['success'], configHeaders: [] }, [{ for: '/path', values: { test: 'one' } }]],
 ])(`Parses netlify.toml and _headers | %s`, async (_, input, output) => {
-  const { headers } = await parseHeaders(input)
+  const { headers } = await parseHeaders({
+    headersFiles: undefined,
+    netlifyConfigPath: undefined,
+    configHeaders: undefined,
+    minimal: true,
+    ...input,
+  })
   expect(headers).toStrictEqual(output)
 })
 
 test.each([
   ['invalid_config_headers_array', { configHeaders: {} }, /must be an array/],
   ['invalid_mixed', { headersFiles: ['simple'], configHeaders: {} }, /must be an array/],
-])(`Validate syntax errors | %s`, async (_, input, errorMessage) => {
-  const { errors } = await parseHeaders(input)
+])(`Validates syntax errors | %s`, async (_, input, errorMessage) => {
+  // @ts-expect-error -- Intentional runtime test of invalid input for some reason
+  const { errors } = await parseHeaders({
+    headersFiles: undefined,
+    netlifyConfigPath: undefined,
+    minimal: true,
+    ...input,
+  })
   expect(errors).not.toHaveLength(0)
   expect(errors.some((error) => errorMessage.test(error.message))).toBeTruthy()
 })

packages/headers-parser/tests/for-regexp.test.ts

@@ -23,8 +23,10 @@ test.each([
   ['double_slash_multiple', '//a//b//', /^\/a\/b\/?$/iu],
 ])(`Add forRegExp when minimal is false | %s`, async (_, forPath, forRegExp) => {
   const { headers } = await parseHeaders({
+    headersFiles: undefined,
+    netlifyConfigPath: undefined,
     configHeaders: [{ for: forPath, values: { test: 'one' } }],
-    minimal: undefined,
+    minimal: false,
   })
   expect(headers).toStrictEqual([{ for: forPath.trim(), forRegExp, values: { test: 'one' } }])
 })

packages/headers-parser/tests/helpers/main.ts

@@ -8,20 +8,18 @@ export const parseHeaders = async function ({
   headersFiles,
   netlifyConfigPath,
   configHeaders,
-  ...input
+  minimal,
 }: {
-  headersFiles?: undefined | string[]
-  netlifyConfigPath?: undefined | string
-  configHeaders?: undefined | MinimalHeader[]
-  minimal?: undefined | boolean
+  headersFiles: undefined | string[]
+  netlifyConfigPath: undefined | string
+  configHeaders: undefined | MinimalHeader[]
+  minimal: boolean
 }) {
   return await parseAllHeaders({
     ...(headersFiles && { headersFiles: headersFiles.map(addFileFixtureDir) }),
     ...(netlifyConfigPath && { netlifyConfigPath: addConfigFixtureDir(netlifyConfigPath) }),
     configHeaders,
-    // Default `minimal` to `true` but still allows passing `undefined` to
-    // test the default value of that option
-    minimal: 'minimal' in input ? input.minimal : true,
+    minimal,
   })
 }
 

packages/headers-parser/tests/line-parser.test.ts

@@ -14,8 +14,13 @@ test.each([
   ['trim_name', { headersFiles: ['trim_name'] }, [{ for: '/path', values: { test: 'one' } }]],
   ['trim_value', { headersFiles: ['trim_value'] }, [{ for: '/path', values: { test: 'one' } }]],
   ['multiple_values', { headersFiles: ['multiple_values'] }, [{ for: '/path', values: { test: 'one, two' } }]],
-])(`Parses _headers | %s`, async (_, input, output) => {
-  const { headers } = await parseHeaders(input)
+])(`Parses _headers | %s`, async (_, { headersFiles }, output) => {
+  const { headers } = await parseHeaders({
+    headersFiles,
+    netlifyConfigPath: undefined,
+    configHeaders: undefined,
+    minimal: true,
+  })
   expect(headers).toStrictEqual(output)
 })
 
@@ -24,8 +29,13 @@ test.each([
   ['invalid_value_name', { headersFiles: ['invalid_value_name'] }, /Missing header name/],
   ['invalid_value_string', { headersFiles: ['invalid_value_string'] }, /Missing header value/],
   ['invalid_for_order', { headersFiles: ['invalid_for_order'] }, /Path should come before/],
-])(`Validate syntax errors | %s`, async (_, input, errorMessage) => {
-  const { errors } = await parseHeaders(input)
+])(`Validate syntax errors | %s`, async (_, { headersFiles }, errorMessage) => {
+  const { errors } = await parseHeaders({
+    headersFiles,
+    netlifyConfigPath: undefined,
+    configHeaders: undefined,
+    minimal: true,
+  })
   expect(errors).not.toHaveLength(0)
   expect(errors.some((error) => errorMessage.test(error.message))).toBeTruthy()
 })

packages/headers-parser/tests/merge.bench.ts

@@ -5,10 +5,12 @@ import { parseHeaders } from './helpers/main.js'
 bench('Merges large _headers file with config headers', async () => {
   const input = {
     headersFiles: ['large_headers_file'],
+    netlifyConfigPath: undefined,
     configHeaders: [
       { for: '/base/some-1', values: { test: 'some-1' } },
       { for: '/unique-header', values: { test: 'unique-value' } },
     ],
+    minimal: true,
   }
   const { headers, errors } = await parseHeaders(input)
   expect(errors).toHaveLength(0)

packages/headers-parser/tests/merge.test.ts

@@ -35,6 +35,12 @@ test.each([
     ],
   ],
 ])(`Merges _headers with netlify.toml headers | %s`, async (_, input, output) => {
-  const { headers } = await parseHeaders(input)
+  const { headers } = await parseHeaders({
+    headersFiles: undefined,
+    configHeaders: undefined,
+    netlifyConfigPath: undefined,
+    minimal: true,
+    ...input,
+  })
   expect(headers).toStrictEqual(output)
 })

packages/headers-parser/tests/netlify-config-parser.test.ts

@@ -14,8 +14,13 @@ test.each([
   ['values_undefined', { netlifyConfigPath: 'values_undefined' }, []],
   ['value_array', { netlifyConfigPath: 'value_array' }, [{ for: '/path', values: { test: 'one, two' } }]],
   ['for_path_no_slash', { netlifyConfigPath: 'for_path_no_slash' }, [{ for: 'path', values: { test: 'one' } }]],
-])(`Parses netlify.toml headers | %s`, async (_, input, output) => {
-  const { headers } = await parseHeaders(input)
+])(`Parses netlify.toml headers | %s`, async (_, { netlifyConfigPath }, output) => {
+  const { headers } = await parseHeaders({
+    headersFiles: undefined,
+    netlifyConfigPath,
+    configHeaders: undefined,
+    minimal: true,
+  })
   expect(headers).toStrictEqual(output)
 })
 
@@ -29,8 +34,13 @@ test.each([
   ['invalid_value_name', { netlifyConfigPath: 'invalid_value_name' }, /Empty header name/],
   ['invalid_value_string', { netlifyConfigPath: 'invalid_value_string' }, /must be a string/],
   ['invalid_value_array', { netlifyConfigPath: 'invalid_value_array' }, /must be a string/],
-])(`Validate syntax errors | %s`, async (_, input, errorMessage) => {
-  const { errors } = await parseHeaders(input)
+])(`Validate syntax errors | %s`, async (_, { netlifyConfigPath }, errorMessage) => {
+  const { errors } = await parseHeaders({
+    headersFiles: undefined,
+    netlifyConfigPath,
+    configHeaders: undefined,
+    minimal: true,
+  })
   expect(errors).not.toHaveLength(0)
   expect(errors.some((error) => errorMessage.test(error.message))).toBeTruthy()
 })