refactor: separated body creation logic into a new builder

Author: jbl428

lib/builders/http-request.builder.ts

@@ -1,20 +1,19 @@
 import { type PathVariableBuilder } from "./path-variable.builder";
+import { type RequestBodyBuilder } from "./request-body.builder";
 import { type RequestParamBuilder } from "./request-param.builder";
-import { TupleArrayBuilder } from "./tuple-array.builder";
 import { UrlBuilder } from "./url.builder";
 import {
   PATH_VARIABLE_METADATA,
   REQUEST_BODY_METADATA,
   REQUEST_PARAM_METADATA,
-  type RequestBodyMetadata,
 } from "../decorators";
 import { type HttpMethod } from "../types/http-method";
 
 export class HttpRequestBuilder {
   private baseUrl = "";
   private readonly pathVariableBuilder: PathVariableBuilder | undefined;
   private readonly requestParamBuilder: RequestParamBuilder | undefined;
-  private readonly requestBodyMetadata: RequestBodyMetadata | undefined;
+  private readonly requestBodyBuilder: RequestBodyBuilder | undefined;
 
   constructor(
     readonly target: object,
@@ -24,28 +23,15 @@ export class HttpRequestBuilder {
   ) {
     this.pathVariableBuilder = this.getMetadata(PATH_VARIABLE_METADATA);
     this.requestParamBuilder = this.getMetadata(REQUEST_PARAM_METADATA);
-    this.requestBodyMetadata = this.getMetadata(REQUEST_BODY_METADATA);
+    this.requestBodyBuilder = this.getMetadata(REQUEST_BODY_METADATA);
   }
 
   setBaseUrl(baseUrl: string): void {
     this.baseUrl = baseUrl;
   }
 
   build(args: any[]): Request {
-    const payload = this.requestBodyMetadata
-      ?.toArray()
-      .reduce((acc: Record<string, unknown>, [index, value]: [number, any]) => {
-        if (typeof value !== "undefined") {
-          acc[value] = args[index];
-          return acc;
-        }
-
-        TupleArrayBuilder.of<string, unknown>(args[index]).forEach(([k, v]) => {
-          acc[k] = v;
-        });
-
-        return acc;
-      }, {});
+    const payload = this.requestBodyBuilder?.build(args);
     const urlBuilder = new UrlBuilder(this.baseUrl, this.url, args, {
       pathParam: this.pathVariableBuilder,
       queryParam: this.requestParamBuilder,
@@ -54,11 +40,10 @@ export class HttpRequestBuilder {
     return new Request(urlBuilder.build(), {
       method: this.method,
       headers:
-        typeof payload !== "undefined"
+        payload !== undefined
           ? { "Content-Type": "application/json" }
           : undefined,
-      body:
-        typeof payload !== "undefined" ? JSON.stringify(payload) : undefined,
+      body: payload,
     });
   }
 

lib/builders/path-variable.builder.spec.ts

@@ -1,8 +1,8 @@
-import { describe, it, expect } from "vitest";
+import { describe, test, expect } from "vitest";
 import { PathVariableBuilder } from "./path-variable.builder";
 
 describe("PathVariableBuilder", () => {
-  it("should replace url with given variable", () => {
+  test("should replace url with given variable", () => {
     // given
     const builder = new PathVariableBuilder(0, "id");
     const args = [123];
@@ -14,7 +14,7 @@ describe("PathVariableBuilder", () => {
     expect(actual).toBe("/user/123");
   });
 
-  it("should replace multiple variables in url", () => {
+  test("should replace multiple variables in url", () => {
     // given
     const builder = new PathVariableBuilder(0, "id");
     builder.add(1, "name");
@@ -28,7 +28,7 @@ describe("PathVariableBuilder", () => {
     expect(actual).toBe("/user/123/profile/john");
   });
 
-  it("should handle url without variables", () => {
+  test("should handle url without variables", () => {
     // given
     const builder = new PathVariableBuilder(0, "id");
     const args = [123];
@@ -40,7 +40,7 @@ describe("PathVariableBuilder", () => {
     expect(actual).toBe("/user/profile");
   });
 
-  it("should handle variables not replaced in url", () => {
+  test("should handle variables not replaced in url", () => {
     // given
     const builder = new PathVariableBuilder(0, "id");
     const args = [123];
@@ -52,7 +52,7 @@ describe("PathVariableBuilder", () => {
     expect(actual).toBe("/user/123/profile/{name}");
   });
 
-  it("should replace multiple variables with same name", () => {
+  test("should replace multiple variables with same name", () => {
     // given
     const builder = new PathVariableBuilder(0, "id");
     const args = [123];

lib/builders/payload-builder.spec.ts

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

lib/builders/payload-builder.ts

@@ -0,0 +1,35 @@
+import { TupleArrayBuilder } from "./tuple-array.builder";
+
+export class RequestBodyBuilder {
+  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[]): string {
+    const result = this.metadata.reduce<Record<string, any>>(
+      (acc, [index, key]) => {
+        if (key != null) {
+          acc[key] = args[index];
+          return acc;
+        }
+
+        TupleArrayBuilder.of<string, unknown>(args[index]).forEach(
+          ([key, value]) => {
+            acc[key] = value;
+          }
+        );
+
+        return acc;
+      },
+      {}
+    );
+
+    return JSON.stringify(result);
+  }
+}

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

@@ -1,8 +1,8 @@
-import { describe, it, expect } from "vitest";
+import { describe, test, expect } from "vitest";
 import { RequestParamBuilder } from "./request-param.builder";
 
 describe("RequestParamBuilder", () => {
-  it("should build query string with explicit key", () => {
+  test("should build query string with explicit key", () => {
     // given
     const builder = new RequestParamBuilder(0, "keyword");
     const args = ["search"];
@@ -14,7 +14,7 @@ describe("RequestParamBuilder", () => {
     expect(actual).toBe("?keyword=search");
   });
 
-  it("should build query string without key", () => {
+  test("should build query string without key", () => {
     // given
     const builder = new RequestParamBuilder(1);
     const args = ["invalid", { foo: "bar" }];
@@ -26,7 +26,7 @@ describe("RequestParamBuilder", () => {
     expect(actual).toBe("?foo=bar");
   });
 
-  it("should encode query string", () => {
+  test("should encode query string", () => {
     // given
     const builder = new RequestParamBuilder(0, "keyword");
     const args = ["?@#$%^&+ "];

lib/builders/request-body.builder.ts

@@ -1,9 +1,8 @@
 import { describe, test, expect } from "vitest";
 import { REQUEST_BODY_METADATA } from "./constants";
-import {
-  RequestBody,
-  type RequestBodyMetadata,
-} from "./request-body.decorator";
+import { RequestBody } from "./request-body.decorator";
+import { type RequestBodyBuilder } from "../builders/request-body.builder";
+import { type RequestParamBuilder } from "../builders/request-param.builder";
 
 describe("RequestBody", () => {
   test("should set request body metadata with empty key", () => {
@@ -15,15 +14,14 @@ describe("RequestBody", () => {
     }
 
     // when
-    const result: RequestBodyMetadata = Reflect.getMetadata(
+    const result: RequestBodyBuilder = Reflect.getMetadata(
       REQUEST_BODY_METADATA,
       TestService.prototype,
       "request"
     );
 
     // then
-    expect(result).toHaveLength(1);
-    expect(result.get(0)).toBeUndefined();
+    expect(result.metadata).toEqual([[0, undefined]]);
   });
 
   test("should set request body metadata with key", () => {
@@ -35,14 +33,38 @@ describe("RequestBody", () => {
     }
 
     // when
-    const result: RequestBodyMetadata = Reflect.getMetadata(
+    const result: RequestBodyBuilder = Reflect.getMetadata(
       REQUEST_BODY_METADATA,
       TestService.prototype,
       "request"
     );
 
     // then
-    expect(result).toHaveLength(1);
-    expect(result.get(0)).toBe("foo");
+    expect(result.metadata).toEqual([[0, "foo"]]);
+  });
+
+  test("should set request body metadata with multiple decorator", () => {
+    // given
+    class TestService {
+      request(
+        @RequestBody("foo") foo: string,
+        @RequestBody() bar: { bar: string }
+      ): string {
+        return foo;
+      }
+    }
+
+    // when
+    const result: RequestParamBuilder = Reflect.getMetadata(
+      REQUEST_BODY_METADATA,
+      TestService.prototype,
+      "request"
+    );
+
+    // then
+    expect(result.metadata).toEqual([
+      [1, undefined],
+      [0, "foo"],
+    ]);
   });
 });