Simplify away lastHeader to getHeaderValue instead

Author: pimterry

src/components/editor/content-viewer.tsx

@@ -10,7 +10,7 @@ import { styled } from '../../styles';
 import { ObservablePromise, isObservablePromise } from '../../util/observable';
 import { asError, unreachableCheck } from '../../util/error';
 import { stringToBuffer } from '../../util/buffer';
-import { lastHeader } from '../../util/headers';
+import { getHeaderValue } from '../../util/headers';
 
 import { ViewableContentType } from '../../model/events/content-types';
 import { Formatters, isEditorFormatter } from '../../model/events/body-formatting';
@@ -201,7 +201,7 @@ export class ContentViewer extends React.Component<ContentViewerProps> {
             return <FormatterContainer expanded={this.props.expanded}>
                 <formatterConfig.Component
                     content={this.contentBuffer}
-                    rawContentType={lastHeader(this.props.headers?.['content-type'])}
+                    rawContentType={getHeaderValue(this.props.headers, 'content-type')}
                 />
             </FormatterContainer>;
         }

src/components/send/sent-response-body.tsx

@@ -7,7 +7,7 @@ import * as portals from 'react-reverse-portal';
 import { ExchangeMessage } from '../../types';
 
 import { ErrorLike } from '../../util/error';
-import { getHeaderValue, lastHeader } from '../../util/headers';
+import { getHeaderValue } from '../../util/headers';
 
 import { ViewableContentType, getCompatibleTypes } from '../../model/events/content-types';
 
@@ -80,7 +80,7 @@ export class SentResponseBodyCard extends React.Component<ExpandableCardProps &
         const compatibleContentTypes = message
             ? getCompatibleTypes(
                 message.contentType,
-                lastHeader(message.headers['content-type']),
+                getHeaderValue(message.headers, 'content-type'),
                 message.body,
                 message.headers,
             )

src/components/view/http/http-body-card.tsx

@@ -8,7 +8,7 @@ import * as portals from 'react-reverse-portal';
 import { ExchangeMessage } from '../../../types';
 
 import { ErrorLike } from '../../../util/error';
-import { getHeaderValue, lastHeader } from '../../../util/headers';
+import { getHeaderValue } from '../../../util/headers';
 
 import { ViewableContentType, getCompatibleTypes } from '../../../model/events/content-types';
 
@@ -81,7 +81,7 @@ export class HttpBodyCard extends React.Component<ExpandableCardProps & {
 
         const compatibleContentTypes = getCompatibleTypes(
             message.contentType,
-            lastHeader(message.headers['content-type']),
+            getHeaderValue(message.headers, 'content-type'),
             message.body,
             message.headers,
         );

src/model/api/openapi.ts

@@ -21,7 +21,7 @@ import {
     Html
 } from "../../types";
 import { firstMatch, empty } from '../../util';
-import { lastHeader } from '../../util/headers';
+import { getHeaderValue } from '../../util/headers';
 import { formatAjvError } from '../../util/json-schema';
 
 import {
@@ -235,7 +235,7 @@ export function getBodySchema(
 ): SchemaObject {
     if (!bodyDefinition || !message || message === 'aborted') return {};
 
-    const contentType = lastHeader(message.headers['content-type']) || '*/*';
+    const contentType = getHeaderValue(message.headers, 'content-type') || '*/*';
 
     const schemasByType = bodyDefinition.content;
     if (!schemasByType) return {};
@@ -352,7 +352,7 @@ export function matchOpenApiOperation(api: OpenApiMetadata, request: HtkRequest)
     }
 
     const method = (
-        lastHeader(request.headers['x-http-method-override']) || request.method
+        getHeaderValue(request.headers, 'x-http-method-override') || request.method
     ).toLowerCase();
 
     let operation: OperationObject | undefined = get(pathSpec, method);

src/model/events/categorization.ts

@@ -2,19 +2,19 @@ import * as _ from 'lodash';
 
 import { ExchangeMessage } from '../../types';
 import { Theme } from '../../styles';
-import { lastHeader } from '../../util/headers';
+import { getHeaderValue } from '../../util/headers';
 
 import { getBaseContentType } from './content-types';
 
 import { HTKEventBase } from './event-base';
 import { HttpExchange, SuccessfulExchange } from '../http/exchange';
 
 export const getMessageBaseAcceptTypes = (message: ExchangeMessage) =>
-    (lastHeader(message.headers['accept'])?.split(',') || [])
+    (getHeaderValue(message.headers, 'accept')?.split(',') || [])
         .map((acceptType) => getBaseContentType(acceptType));
 
 export const getMessageBaseContentType = (message: ExchangeMessage) =>
-    getBaseContentType(lastHeader(message.headers['content-type']));
+    getBaseContentType(getHeaderValue(message.headers, 'content-type'));
 
 const isMutatativeExchange = (exchange: HttpExchange) => _.includes([
     'POST',

src/model/http/caching.ts

@@ -8,7 +8,7 @@ import {
 } from 'date-fns';
 
 import { HttpExchange, ExchangeMessage } from '../../types';
-import { lastHeader, asHeaderArray } from '../../util/headers';
+import { getHeaderValue, asHeaderArray } from '../../util/headers';
 import { joinAnd } from '../../util/text';
 import { escapeForMarkdownEmbedding } from '../ui/markdown';
 
@@ -106,7 +106,7 @@ export function explainCacheability(exchange: HttpExchange): (
             // This is a CORS preflight request - it's not really cacheable, but the CORS
             // headers specifically (probably the only interesting bit) are, via their
             // own separate funky mechanism.
-            const maxAgeHeader = lastHeader(response.headers['access-control-max-age']);
+            const maxAgeHeader = getHeaderValue(response.headers, 'access-control-max-age');
             const maxAge = maxAgeHeader ? parseInt(maxAgeHeader, 10) : undefined;
 
             if (maxAge !== undefined && maxAge >= 1) {
@@ -238,7 +238,7 @@ export function explainCacheability(exchange: HttpExchange): (
         `;
 
         const contentLocationUrl = response.headers['content-location'] ?
-            new URL(lastHeader(response.headers['content-location']!), request.url) : undefined;
+            new URL(getHeaderValue(response.headers, 'content-location')!, request.url) : undefined;
 
         const hasFreshnessInfo =
             !!responseCCDirectives['max-age'] ||
@@ -272,7 +272,7 @@ export function explainCacheability(exchange: HttpExchange): (
         let warning: string | undefined;
 
         const responseDateHeader = response.headers['date'] ?
-            parseDate(lastHeader(response.headers['date'])!)
+            parseDate(getHeaderValue(response.headers, 'date')!)
             : undefined;
 
         if (!responseDateHeader) {
@@ -287,7 +287,7 @@ export function explainCacheability(exchange: HttpExchange): (
                 predictably.
             `;
         } else if (response.headers['expires'] && Math.abs(differenceInSeconds(
-            parseDate(lastHeader(response.headers['expires']!)),
+            parseDate(getHeaderValue(response.headers, 'expires')!),
             addSeconds(responseDateHeader, responseCCDirectives['max-age'])
         )) > 60) {
             warning = dedent`
@@ -318,7 +318,7 @@ export function explainCacheability(exchange: HttpExchange): (
         };
     }
 
-    if (lastHeader(response.headers['expires']) !== undefined) {
+    if (getHeaderValue(response.headers, 'expires') !== undefined) {
         // Expires set, but not max-age (checked above).
         return {
             cacheable: true,
@@ -649,7 +649,7 @@ export function explainCacheLifetime(exchange: HttpExchange): Explanation | unde
     const responseCCDirectives = parseCCDirectives(response);
 
     if (request.method === 'OPTIONS') {
-        const maxAgeHeader = lastHeader(response.headers['access-control-max-age']);
+        const maxAgeHeader = getHeaderValue(response.headers, 'access-control-max-age');
 
         if (maxAgeHeader) {
             const maxAge = parseInt(maxAgeHeader!, 10);
@@ -694,8 +694,8 @@ export function explainCacheLifetime(exchange: HttpExchange): Explanation | unde
         };
     }
 
-    const dateHeader = lastHeader(response.headers['date']);
-    const expiresHeader = lastHeader(response.headers['expires']);
+    const dateHeader = getHeaderValue(response.headers, 'date');
+    const expiresHeader = getHeaderValue(response.headers, 'expires');
     const maxAge = responseCCDirectives['max-age'];
     const sharedMaxAge = responseCCDirectives['s-maxage'] !== undefined ?
         responseCCDirectives['s-maxage'] : maxAge;

src/model/http/exchange-breakpoint.ts

@@ -138,7 +138,7 @@ export abstract class Breakpoint<T extends BreakpointInProgress> {
             newValue: newEncodedLength
         }) => {
             const { rawHeaders } = this.resultMetadata;
-            const previousContentLength = parseInt(getHeaderValue(rawHeaders, 'Content-Length') || '', 10);
+            const previousContentLength = parseInt(getHeaderValue(rawHeaders, 'content-length') || '', 10);
 
             // If the content-length was previously correct, keep it correct:
             if (previousContentLength === previousEncodedLength) {
@@ -151,8 +151,8 @@ export abstract class Breakpoint<T extends BreakpointInProgress> {
         });
 
         // When content-length is first added, default to the correct value
-        let oldContentLength = getHeaderValue(this.resultMetadata.rawHeaders, 'Content-Length');
-        reaction(() => getHeaderValue(this.resultMetadata.rawHeaders, 'Content-Length'), (newContentLength) => {
+        let oldContentLength = getHeaderValue(this.resultMetadata.rawHeaders, 'content-length');
+        reaction(() => getHeaderValue(this.resultMetadata.rawHeaders, 'content-length'), (newContentLength) => {
             if (oldContentLength === undefined && newContentLength === "") {
                 const { rawHeaders } = this.resultMetadata;
                 this.updateMetadata({

src/model/http/exchange.ts

@@ -25,7 +25,7 @@ import { UnreachableCheck } from '../../util/error';
 import { lazyObservablePromise, ObservablePromise, observablePromise } from "../../util/observable";
 import {
     asHeaderArray,
-    lastHeader
+    getHeaderValue
 } from '../../util/headers';
 
 import { logError } from '../../errors';
@@ -86,7 +86,7 @@ function addRequestMetadata(request: InputRequest): HtkRequest {
                 ? MANUALLY_SENT_SOURCE
                 : parseSource(request.headers['user-agent']),
             body: new HttpBody(request, request.headers),
-            contentType: getContentType(lastHeader(request.headers['content-type'])) || 'text',
+            contentType: getContentType(getHeaderValue(request.headers, 'content-type')) || 'text',
             cache: observable.map(new Map<symbol, unknown>(), { deep: false })
         }) as HtkRequest;
     } catch (e) {
@@ -98,10 +98,7 @@ function addRequestMetadata(request: InputRequest): HtkRequest {
 function addResponseMetadata(response: InputResponse): HtkResponse {
     return Object.assign(response, {
         body: new HttpBody(response, response.headers),
-        contentType: getContentType(
-            // There should only ever be one. If we get multiple though, just use the last.
-            lastHeader(response.headers['content-type'])
-        ) || 'text',
+        contentType: getContentType(getHeaderValue(response.headers, 'content-type')) || 'text',
         cache: observable.map(new Map<symbol, unknown>(), { deep: false })
     }) as HtkResponse;
 }

src/model/http/har.ts

@@ -19,7 +19,7 @@ import {
 } from '../../types';
 
 import { stringToBuffer } from '../../util/buffer';
-import { getHeaderValues, lastHeader } from '../../util/headers';
+import { getHeaderValues, getHeaderValue } from '../../util/headers';
 import { ObservablePromise } from '../../util/observable';
 import { unreachableCheck } from '../../util/error';
 
@@ -227,7 +227,7 @@ export function generateHarRequest(
             try {
                 requestEntry.postData = generateHarPostBody(
                     UTF8Decoder.decode(request.body.decoded),
-                    lastHeader(request.headers['content-type']) || 'application/octet-stream'
+                    getHeaderValue(request.headers, 'content-type') || 'application/octet-stream'
                 );
             } catch (e) {
                 if (e instanceof TypeError) {
@@ -362,7 +362,7 @@ async function generateHarResponse(
         headers: asHarHeaders(response.headers),
         content: Object.assign(
             {
-                mimeType: lastHeader(response.headers['content-type']) ||
+                mimeType: getHeaderValue(response.headers, 'content-type') ||
                     'application/octet-stream',
                 size: response.body.decoded?.byteLength || 0
             },

src/util/headers.ts

@@ -43,15 +43,18 @@ export const rawHeadersToHeaders = (headers: RawHeaders): Headers =>
 
 /**
  * Get the header value for the given header key. Case insensitive. If there are multiple values,
- * this will return the last value. If there are no values this returns undefined.
+ * this will return the last value. If there are no values or the headers themselves aren't defined,
+ * this returns undefined.
  */
-export const getHeaderValue = (headers: Headers | RawHeaders, headerKey: string): string | undefined => {
+export function getHeaderValue(
+    headers: Headers | RawHeaders | undefined,
+    headerKey: Lowercase<string>
+): string | undefined {
     if (Array.isArray(headers)) {
-        headerKey = headerKey.toLowerCase();
         const headerPair = _.findLast(headers, ([key]) => key.toLowerCase() === headerKey);
         return headerPair?.[1];
     } else {
-        const headerValue = headers[headerKey];
+        const headerValue = headers?.[headerKey];
 
         if (Array.isArray(headerValue)) {
             return headerValue[headerValue.length - 1];
@@ -146,15 +149,6 @@ export const withHeaderValue = <T extends Headers | RawHeaders>(headers: T, head
     return headers;
 }
 
-// This fairly meaningless override combo seems to be
-// required to make it ok to use this when T = X | undefined.
-export function lastHeader<T>(val: T | T[]): T;
-export function lastHeader<T>(val: T | T[] | undefined): T | undefined;
-export function lastHeader<T>(val: T | T[] | undefined): T | undefined {
-    if (Array.isArray(val)) return val[val.length - 1];
-    else return val;
-}
-
 export function asHeaderArray(val: string | string[] | undefined, sep = ','): string[] {
     if (Array.isArray(val)) {
         // Split individual values, as multiple headers can still have multiple values