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

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

These types were very weak, containing plentiful `any`s, both explicit and implicit, as
well as some incorrect inferred types.

* chore(tsconfig): simplify tsconfig strict config

We should be opting *into* strict mode and only opting *out* of some flags incrementally
while we fix errors.

This commit:
- flips the global `strict` on
- removes values being set to the default via the above
- stops disabling flags that obscured no errors (or very few, which I then fixed)
- moves a few flag disablings to the specific packages that require it
- explictly configures strict flags for already rather strict packages

* fix(types): mark netlify.toml [[headers]].values required

* style: add empty line after imports

* refactor: improve variable name

* docs: add inline comment explain funky type

* refactor: remove incorrect extraneous property from type

* fix(parseAllHeaders)!: mark `minimal` as required

All callers already pass in a non-nil `boolean`, so this is only technically breaking.

* fix(types)!: increase strictness of optional types

* fix(types): add missing PollingStrategy.name type

* feat(types): export Category, PollingStrategy

Author: serhalp

packages/build-info/src/frameworks/framework.ts

@@ -20,7 +20,8 @@ export enum Accuracy {
 }
 
 export type PollingStrategy = {
-  name
+  // TODO(serhalp) Define an enum
+  name: string
 }
 
 /** Information on how it was detected and how accurate the detection is */

packages/build-info/src/index.ts

@@ -1,6 +1,6 @@
 export * from './file-system.js'
 export * from './logger.js'
-export { DetectedFramework, FrameworkInfo } from './frameworks/framework.js'
+export type { Category, DetectedFramework, FrameworkInfo, PollingStrategy } from './frameworks/framework.js'
 export * from './get-framework.js'
 export * from './project.js'
 export * from './settings/get-build-settings.js'

packages/build-info/src/settings/netlify-toml.ts

@@ -324,7 +324,7 @@ export type RequestHeaders = {
  */
 export type Headers = {
   for: For
-  values?: Values
+  values: Values
 }
 /**
  * Define the actual headers.

packages/build/tsconfig.json

@@ -1,7 +1,8 @@
 {
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "outDir": "lib" /* Specify an output folder for all emitted files. */
+    "outDir": "lib" /* Specify an output folder for all emitted files. */,
+    "strictBindCallApply": false /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
   },
   "include": ["src/**/*.js", "src/**/*.ts"],
   "exclude": ["tests/**"]

packages/config/src/headers.js

@@ -12,17 +12,11 @@ export const getHeadersPath = function ({ build: { publish } }) {
 const HEADERS_FILENAME = '_headers'
 
 // Add `config.headers`
-export const addHeaders = async function ({
-  config: { headers: configHeaders, ...config },
-  headersPath,
-  logs,
-  featureFlags,
-}) {
+export const addHeaders = async function ({ config: { headers: configHeaders, ...config }, headersPath, logs }) {
   const { headers, errors } = await parseAllHeaders({
     headersFiles: [headersPath],
     configHeaders,
     minimal: true,
-    featureFlags,
   })
   warnHeadersParsing(logs, errors)
   warnHeadersCaseSensitivity(logs, headers)

packages/config/src/main.ts

@@ -288,7 +288,7 @@ const getFullConfig = async function ({
       base: baseA,
     } = await resolveFiles({ packagePath, config: configA, repositoryRoot, base, baseRelDir })
     const headersPath = getHeadersPath(configB)
-    const configC = await addHeaders({ config: configB, headersPath, logs, featureFlags })
+    const configC = await addHeaders({ config: configB, headersPath, logs })
     const redirectsPath = getRedirectsPath(configC)
     const configD = await addRedirects({ config: configC, redirectsPath, logs, featureFlags })
     return { configPath, config: configD, buildDir, base: baseA, redirectsPath, headersPath }

packages/config/src/mutations/update.js

@@ -33,7 +33,7 @@ export const updateConfig = async function (
   const inlineConfig = applyMutations({}, configMutations)
   const normalizedInlineConfig = ensureConfigPriority(inlineConfig, context, branch)
   const updatedConfig = await mergeWithConfig(normalizedInlineConfig, configPath)
-  const configWithHeaders = await addHeaders({ config: updatedConfig, headersPath, logs, featureFlags })
+  const configWithHeaders = await addHeaders({ config: updatedConfig, headersPath, logs })
   const finalConfig = await addRedirects({ config: configWithHeaders, redirectsPath, logs, featureFlags })
   const simplifiedConfig = simplifyConfig(finalConfig)
 

packages/headers-parser/src/all.ts

@@ -3,14 +3,22 @@ import { mergeHeaders } from './merge.js'
 import { parseConfigHeaders } from './netlify_config_parser.js'
 import { normalizeHeaders } from './normalize.js'
 import { splitResults, concatResults } from './results.js'
+import type { Header, MinimalHeader } from './types.js'
+
+export type { Header, MinimalHeader }
 
 // Parse all headers from `netlify.toml` and `_headers` file, then normalize
 // and validate those.
 export const parseAllHeaders = async function ({
   headersFiles = [],
   netlifyConfigPath,
   configHeaders = [],
-  minimal = false,
+  minimal,
+}: {
+  headersFiles: undefined | string[]
+  netlifyConfigPath?: undefined | string
+  configHeaders: undefined | MinimalHeader[]
+  minimal: boolean
 }) {
   const [
     { headers: fileHeaders, errors: fileParseErrors },
@@ -37,12 +45,12 @@ export const parseAllHeaders = async function ({
   return { headers, errors }
 }
 
-const getFileHeaders = async function (headersFiles) {
+const getFileHeaders = async function (headersFiles: string[]) {
   const resultsArrays = await Promise.all(headersFiles.map(parseFileHeaders))
   return concatResults(resultsArrays)
 }
 
-const getConfigHeaders = async function (netlifyConfigPath) {
+const getConfigHeaders = async function (netlifyConfigPath?: string) {
   if (netlifyConfigPath === undefined) {
     return splitResults([])
   }

packages/headers-parser/src/for_regexp.js packages/headers-parser/src/for_regexp.ts

@@ -1,16 +1,16 @@
 import escapeStringRegExp from 'escape-string-regexp'
 
 // Retrieve `forRegExp` which is a `RegExp` used to match the `for` path
-export const getForRegExp = function (forPath) {
+export const getForRegExp = function (forPath: string): RegExp {
   const pattern = forPath.split('/').map(trimString).filter(Boolean).map(getPartRegExp).join('/')
   return new RegExp(`^/${pattern}/?$`, 'iu')
 }
 
-const trimString = function (part) {
+const trimString = function (part: string): string {
   return part.trimEnd()
 }
 
-const getPartRegExp = function (part) {
+const getPartRegExp = function (part: string): string {
   // Placeholder like `/segment/:placeholder/test`
   // Matches everything up to a /
   if (part.startsWith(':')) {

packages/headers-parser/src/index.ts

@@ -1 +1 @@
-export { parseAllHeaders } from './all.js'
+export { parseAllHeaders, type Header, type MinimalHeader } from './all.js'

packages/headers-parser/src/line_parser.ts

@@ -1,20 +1,28 @@
-import { promises as fs } from 'fs'
+import fs from 'fs/promises'
 
 import { pathExists } from 'path-exists'
 
 import { splitResults } from './results.js'
+import type { MinimalHeader } from './types.js'
+
+type RawHeaderFileLine = { path: string } | { name: string; value: string }
+
+export interface ParseHeadersResult {
+  headers: MinimalHeader[]
+  errors: Error[]
+}
 
 // Parse `_headers` file to an array of objects following the same syntax as
 // the `headers` property in `netlify.toml`
-export const parseFileHeaders = async function (headersFile: string) {
+export const parseFileHeaders = async function (headersFile: string): Promise<ParseHeadersResult> {
   const results = await parseHeaders(headersFile)
   const { headers, errors: parseErrors } = splitResults(results)
   const { headers: reducedHeaders, errors: reducedErrors } = headers.reduce(reduceLine, { headers: [], errors: [] })
   const errors = [...parseErrors, ...reducedErrors]
   return { headers: reducedHeaders, errors }
 }
 
-const parseHeaders = async function (headersFile: string) {
+const parseHeaders = async function (headersFile: string): Promise<Array<Error | RawHeaderFileLine>> {
   if (!(await pathExists(headersFile))) {
     return []
   }
@@ -23,7 +31,12 @@ const parseHeaders = async function (headersFile: string) {
   if (typeof text !== 'string') {
     return [text]
   }
-  return text.split('\n').map(normalizeLine).filter(hasHeader).map(parseLine).filter(Boolean)
+  return text
+    .split('\n')
+    .map(normalizeLine)
+    .filter(hasHeader)
+    .map(parseLine)
+    .filter((line): line is RawHeaderFileLine => line != null)
 }
 
 const readHeadersFile = async function (headersFile: string) {
@@ -38,22 +51,22 @@ const normalizeLine = function (line: string, index: number) {
   return { line: line.trim(), index }
 }
 
-const hasHeader = function ({ line }) {
+const hasHeader = function ({ line }: { line: string }) {
   return line !== '' && !line.startsWith('#')
 }
 
-const parseLine = function ({ line, index }) {
+const parseLine = function ({ line, index }: { line: string; index: number }) {
   try {
     return parseHeaderLine(line)
   } catch (error) {
     return new Error(`Could not parse header line ${index + 1}:
   ${line}
-${error.message}`)
+${error instanceof Error ? error.message : error?.toString()}`)
   }
 }
 
 // Parse a single header line
-const parseHeaderLine = function (line: string) {
+const parseHeaderLine = function (line: string): undefined | RawHeaderFileLine {
   if (isPathLine(line)) {
     return { path: line }
   }
@@ -63,7 +76,7 @@ const parseHeaderLine = function (line: string) {
   }
 
   const [rawName, ...rawValue] = line.split(HEADER_SEPARATOR)
-  const name = rawName.trim()
+  const name = rawName?.trim() ?? ''
 
   if (name === '') {
     throw new Error(`Missing header name`)
@@ -83,18 +96,23 @@ const isPathLine = function (line: string) {
 
 const HEADER_SEPARATOR = ':'
 
-const reduceLine = function ({ headers, errors }, { path, name, value }) {
-  if (path !== undefined) {
+const reduceLine = function (
+  { headers, errors }: ParseHeadersResult,
+  parsedHeader: RawHeaderFileLine,
+): ParseHeadersResult {
+  if ('path' in parsedHeader) {
+    const { path } = parsedHeader
     return { headers: [...headers, { for: path, values: {} }], errors }
   }
 
-  if (headers.length === 0) {
+  const { name, value } = parsedHeader
+  const previousHeaders = headers.slice(0, -1)
+  const currentHeader = headers[headers.length - 1]
+  if (headers.length === 0 || currentHeader == null) {
     const error = new Error(`Path should come before header "${name}"`)
     return { headers, errors: [...errors, error] }
   }
 
-  const previousHeaders = headers.slice(0, -1)
-  const currentHeader = headers[headers.length - 1]
   const { values } = currentHeader
   const newValue = values[name] === undefined ? value : `${values[name]}, ${value}`
   const newHeaders = [...previousHeaders, { ...currentHeader, values: { ...values, [name]: newValue } }]

packages/headers-parser/src/merge.ts

@@ -1,7 +1,7 @@
 import stringify from 'fast-safe-stringify'
 
 import { splitResults } from './results.js'
-import type { Header } from './types.js'
+import type { Header, MinimalHeader } from './types.js'
 
 // Merge headers from `_headers` with the ones from `netlify.toml`.
 // When:
@@ -21,8 +21,8 @@ export const mergeHeaders = function ({
   fileHeaders,
   configHeaders,
 }: {
-  fileHeaders: (Error | Header)[]
-  configHeaders: (Error | Header)[]
+  fileHeaders: MinimalHeader[] | Header[]
+  configHeaders: MinimalHeader[] | Header[]
 }) {
   const results = [...fileHeaders, ...configHeaders]
   const { headers, errors } = splitResults(results)
@@ -35,23 +35,22 @@ export const mergeHeaders = function ({
 // `netlifyConfig.headers` is modified by plugins.
 // The latest duplicate value is the one kept, hence why we need to iterate the
 // array backwards and reverse it at the end
-const removeDuplicates = function (headers: Header[]) {
+const removeDuplicates = function (headers: MinimalHeader[] | Header[]) {
   const uniqueHeaders = new Set()
-  const result: Header[] = []
-  for (let i = headers.length - 1; i >= 0; i--) {
-    const h = headers[i]
-    const key = generateHeaderKey(h)
+  const result: (MinimalHeader | Header)[] = []
+  for (const header of [...headers].reverse()) {
+    const key = generateHeaderKey(header)
     if (uniqueHeaders.has(key)) continue
     uniqueHeaders.add(key)
-    result.push(h)
+    result.push(header)
   }
   return result.reverse()
 }
 
 // We generate a unique header key based on JSON stringify. However, because some
 // properties can be regexes, we need to replace those by their toString representation
 // given the default will be and empty object
-const generateHeaderKey = function (header: Header) {
+const generateHeaderKey = function (header: MinimalHeader | Header): string {
   return stringify.default.stableStringify(header, (_, value) => {
     if (value instanceof RegExp) return value.toString()
     return value

packages/headers-parser/src/netlify_config_parser.ts

@@ -4,6 +4,7 @@ import { parse as loadToml } from '@iarna/toml'
 import { pathExists } from 'path-exists'
 
 import { splitResults } from './results.js'
+import type { MinimalHeader } from './types.js'
 
 // Parse `headers` field in "netlify.toml" to an array of objects.
 // This field is already an array of objects, so it only validates and
@@ -27,7 +28,8 @@ const parseConfig = async function (configPath: string) {
     if (!Array.isArray(headers)) {
       throw new TypeError(`"headers" must be an array`)
     }
-    return headers
+    // TODO(serhalp) Validate shape instead of assuming and asserting type
+    return headers as MinimalHeader[]
   } catch (error) {
     return [new Error(`Could not parse configuration file: ${error}`)]
   }