refactor: separated headers creation logic into a new builder

Author: jbl428

lib/builders/http-request.builder.ts

@@ -1,12 +1,14 @@
 import { type PathVariableBuilder } from "./path-variable.builder";
 import { type RequestBodyBuilder } from "./request-body.builder";
 import { type RequestFormBuilder } from "./request-form.builder";
+import { type RequestHeaderBuilder } from "./request-header.builder";
 import { type RequestParamBuilder } from "./request-param.builder";
 import { UrlBuilder } from "./url.builder";
 import {
   PATH_VARIABLE_METADATA,
   REQUEST_BODY_METADATA,
   REQUEST_FORM_METADATA,
+  REQUEST_HEADER_METADATA,
   REQUEST_PARAM_METADATA,
 } from "../decorators";
 import { type HttpMethod } from "../types/http-method";
@@ -17,6 +19,7 @@ export class HttpRequestBuilder {
   private readonly requestParamBuilder?: RequestParamBuilder;
   private readonly requestBodyBuilder?: RequestBodyBuilder;
   private readonly requestFormBuilder?: RequestFormBuilder;
+  private readonly requestHeaderBuilder?: RequestHeaderBuilder;
 
   constructor(
     readonly target: object,
@@ -28,6 +31,7 @@ export class HttpRequestBuilder {
     this.requestParamBuilder = this.getMetadata(REQUEST_PARAM_METADATA);
     this.requestBodyBuilder = this.getMetadata(REQUEST_BODY_METADATA);
     this.requestFormBuilder = this.getMetadata(REQUEST_FORM_METADATA);
+    this.requestHeaderBuilder = this.getMetadata(REQUEST_HEADER_METADATA);
   }
 
   setBaseUrl(baseUrl: string): void {
@@ -45,13 +49,11 @@ export class HttpRequestBuilder {
       this.pathVariableBuilder,
       this.requestParamBuilder
     );
+    const headers = this.requestHeaderBuilder?.build(args);
 
     return new Request(urlBuilder.build(), {
       method: this.method,
-      headers:
-        payload !== undefined
-          ? { "Content-Type": "application/json" }
-          : undefined,
+      headers,
       body: payload,
     });
   }

lib/builders/path-variable.builder.ts

@@ -12,7 +12,7 @@ export class PathVariableBuilder {
   build(url: string, args: any[]): string {
     return this.metadata.reduce<string>(
       (acc, [index, key]) =>
-        acc.replace(new RegExp(`{${key}}`, "g"), args[index]),
+        acc.replace(new RegExp(`{${key}}`, "g"), String(args[index])),
       url
     );
   }

lib/builders/request-form.builder.ts

@@ -16,12 +16,12 @@ export class RequestFormBuilder {
 
     this.metadata.forEach(([index, key]) => {
       if (key != null) {
-        form.append(key, args[index]);
+        form.append(key, String(args[index]));
         return;
       }
 
       TupleArrayBuilder.of<string, any>(args[index]).forEach(([key, value]) => {
-        form.append(key, value);
+        form.append(key, String(value));
       });
     });
 

lib/builders/request-header.builder.spec.ts

@@ -0,0 +1,28 @@
+import { describe, test, expect } from "vitest";
+import { RequestHeaderBuilder } from "./request-header.builder";
+
+describe("RequestHeaderBuilder", () => {
+  test("should build header with explicit key", () => {
+    // given
+    const builder = new RequestHeaderBuilder(0, "keyword");
+    const args = ["search"];
+
+    // when
+    const actual = builder.build(args);
+
+    // then
+    expect(actual).toEqual({ keyword: "search" });
+  });
+
+  test("should build header without key", () => {
+    // given
+    const builder = new RequestHeaderBuilder(1);
+    const args = ["invalid", { foo: "bar" }];
+
+    // when
+    const actual = builder.build(args);
+
+    // then
+    expect(actual).toEqual({ foo: "bar" });
+  });
+});

lib/builders/request-header.builder.ts

@@ -0,0 +1,30 @@
+import { TupleArrayBuilder } from "./tuple-array.builder";
+
+export class RequestHeaderBuilder {
+  metadata: Array<[index: number, key: string | undefined]> = [];
+
+  constructor(index: number, key?: string) {
+    this.add(index, key);
+  }
+
+  add(index: number, key?: string): void {
+    this.metadata.push([index, key]);
+  }
+
+  build(args: any[]): HeadersInit {
+    return this.metadata.reduce<Record<string, string>>((acc, [index, key]) => {
+      if (key != null) {
+        acc[key] = String(args[index]);
+        return acc;
+      }
+
+      TupleArrayBuilder.of<string, unknown>(args[index]).forEach(
+        ([key, value]) => {
+          acc[key] = String(value);
+        }
+      );
+
+      return acc;
+    }, {});
+  }
+}

lib/builders/request-param.builder.ts

@@ -16,13 +16,13 @@ export class RequestParamBuilder {
     const result = this.metadata.reduce<Record<string, any>>(
       (acc, [index, key]) => {
         if (key != null) {
-          acc[key] = args[index];
+          acc[key] = String(args[index]);
           return acc;
         }
 
         TupleArrayBuilder.of<string, unknown>(args[index]).forEach(
           ([key, value]) => {
-            acc[key] = value;
+            acc[key] = String(value);
           }
         );
 

lib/builders/tuple-array.builder.spec.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "vitest";
+import { TupleArrayBuilder } from "./tuple-array.builder";
+
+describe("TupleArrayBuilder", () => {
+  test("should return empty array when value is null", () => {
+    // given
+    const value = null;
+
+    // when
+    const actual = TupleArrayBuilder.of(value);
+
+    // then
+    expect(actual).toEqual([]);
+  });
+
+  test("should return empty array when value is undefined", () => {
+    // given
+    const value = undefined;
+
+    // when
+    const actual = TupleArrayBuilder.of(value);
+
+    // then
+    expect(actual).toEqual([]);
+  });
+
+  test("should return empty array when value is not an object", () => {
+    // given
+    const value = "string";
+
+    // when
+    const actual = TupleArrayBuilder.of(value);
+
+    // then
+    expect(actual).toEqual([]);
+  });
+
+  test("should return array of tuples when value is an object", () => {
+    // given
+    const value = { foo: "bar" };
+
+    // when
+    const actual = TupleArrayBuilder.of(value);
+
+    // then
+    expect(actual).toEqual([["foo", "bar"]]);
+  });
+
+  test("should return array of tuples when value is an object with multiple keys", () => {
+    // given
+    const value = { foo: "bar", baz: "qux" };
+
+    // when
+    const actual = TupleArrayBuilder.of(value);
+
+    // then
+    expect(actual).toEqual([
+      ["foo", "bar"],
+      ["baz", "qux"],
+    ]);
+  });
+});

lib/builders/tuple-array.builder.ts

@@ -1,14 +1,10 @@
 export class TupleArrayBuilder {
   static of<A, B>(value: unknown): Array<[A, B]> {
-    if (value === undefined) {
+    if (value == null) {
       return [];
     }
 
-    if (value instanceof Map) {
-      return [...value.entries()];
-    }
-
-    if (typeof value === "object" && value !== null) {
+    if (typeof value === "object") {
       return Object.entries(value) as Array<[A, B]>;
     }
 

lib/decorators/request-header.decorator.spec.ts

@@ -1,9 +1,7 @@
 import { describe, test, expect } from "vitest";
 import { REQUEST_HEADER_METADATA } from "./constants";
-import {
-  RequestHeader,
-  type RequestHeaderMetadata,
-} from "./request-header.decorator";
+import { RequestHeader } from "./request-header.decorator";
+import { type RequestHeaderBuilder } from "../builders/request-header.builder";
 
 describe("RequestHeader", () => {
   test("should set request header metadata with empty key", () => {
@@ -15,15 +13,14 @@ describe("RequestHeader", () => {
     }
 
     // when
-    const result: RequestHeaderMetadata = Reflect.getMetadata(
+    const result: RequestHeaderBuilder = Reflect.getMetadata(
       REQUEST_HEADER_METADATA,
       TestService.prototype,
       "request"
     );
 
     // then
-    expect(result).toHaveLength(1);
-    expect(result.get(0)).toBeUndefined();
+    expect(result.metadata).toEqual([[0, undefined]]);
   });
 
   test("should set request header metadata with key", () => {
@@ -35,14 +32,13 @@ describe("RequestHeader", () => {
     }
 
     // when
-    const result: RequestHeaderMetadata = Reflect.getMetadata(
+    const result: RequestHeaderBuilder = Reflect.getMetadata(
       REQUEST_HEADER_METADATA,
       TestService.prototype,
       "request"
     );
 
     // then
-    expect(result).toHaveLength(1);
-    expect(result.get(0)).toBe("foo");
+    expect(result.metadata).toEqual([[0, "foo"]]);
   });
 });

lib/decorators/request-header.decorator.ts

@@ -1,23 +1,26 @@
 import { REQUEST_HEADER_METADATA } from "./constants";
-import { MetadataMap } from "../types/metadata-map";
-
-export type RequestHeaderMetadata = MetadataMap<number, string>;
+import { RequestHeaderBuilder } from "../builders/request-header.builder";
 
 export function RequestHeader(key?: string): ParameterDecorator {
   return (target, propertyKey, parameterIndex) => {
-    if (typeof propertyKey === "undefined") {
+    if (propertyKey == null) {
       return;
     }
 
-    const metadata =
-      Reflect.getMetadata(REQUEST_HEADER_METADATA, target, propertyKey) ??
-      new MetadataMap();
+    const builder: RequestHeaderBuilder | undefined = Reflect.getMetadata(
+      REQUEST_HEADER_METADATA,
+      target,
+      propertyKey
+    );
 
-    metadata.set(parameterIndex, key);
+    if (builder != null) {
+      builder.add(parameterIndex, key);
+      return;
+    }
 
     Reflect.defineMetadata(
       REQUEST_HEADER_METADATA,
-      metadata,
+      new RequestHeaderBuilder(parameterIndex, key),
       target,
       propertyKey
     );