refactor: separated form creation logic into a new builder

Author: jbl428

lib/builders/http-request.builder.ts

@@ -1,19 +1,22 @@
 import { type PathVariableBuilder } from "./path-variable.builder";
 import { type RequestBodyBuilder } from "./request-body.builder";
+import { type RequestFormBuilder } from "./request-form.builder";
 import { type RequestParamBuilder } from "./request-param.builder";
 import { UrlBuilder } from "./url.builder";
 import {
   PATH_VARIABLE_METADATA,
   REQUEST_BODY_METADATA,
+  REQUEST_FORM_METADATA,
   REQUEST_PARAM_METADATA,
 } 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 requestBodyBuilder: RequestBodyBuilder | undefined;
+  private readonly pathVariableBuilder?: PathVariableBuilder;
+  private readonly requestParamBuilder?: RequestParamBuilder;
+  private readonly requestBodyBuilder?: RequestBodyBuilder;
+  private readonly requestFormBuilder?: RequestFormBuilder;
 
   constructor(
     readonly target: object,
@@ -24,18 +27,24 @@ export class HttpRequestBuilder {
     this.pathVariableBuilder = this.getMetadata(PATH_VARIABLE_METADATA);
     this.requestParamBuilder = this.getMetadata(REQUEST_PARAM_METADATA);
     this.requestBodyBuilder = this.getMetadata(REQUEST_BODY_METADATA);
+    this.requestFormBuilder = this.getMetadata(REQUEST_FORM_METADATA);
   }
 
   setBaseUrl(baseUrl: string): void {
     this.baseUrl = baseUrl;
   }
 
   build(args: any[]): Request {
-    const payload = this.requestBodyBuilder?.build(args);
-    const urlBuilder = new UrlBuilder(this.baseUrl, this.url, args, {
-      pathParam: this.pathVariableBuilder,
-      queryParam: this.requestParamBuilder,
-    });
+    const payload =
+      this.requestBodyBuilder?.build(args) ??
+      this.requestFormBuilder?.build(args);
+    const urlBuilder = new UrlBuilder(
+      this.baseUrl,
+      this.url,
+      args,
+      this.pathVariableBuilder,
+      this.requestParamBuilder
+    );
 
     return new Request(urlBuilder.build(), {
       method: this.method,

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

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

lib/builders/request-form.builder.ts

@@ -0,0 +1,30 @@
+import { TupleArrayBuilder } from "./tuple-array.builder";
+
+export class RequestFormBuilder {
+  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[]): FormData {
+    const form = new FormData();
+
+    this.metadata.forEach(([index, key]) => {
+      if (key != null) {
+        form.append(key, args[index]);
+        return;
+      }
+
+      TupleArrayBuilder.of<string, any>(args[index]).forEach(([key, value]) => {
+        form.append(key, value);
+      });
+    });
+
+    return form;
+  }
+}

lib/builders/url.builder.spec.ts

@@ -23,8 +23,8 @@ describe("UrlBuilder", () => {
     const host = "https://example.com";
     const path = "api/users/{id}";
     const args = [1, 2];
-    const pathParam = new PathVariableBuilder(1, "id");
-    const urlBuilder = new UrlBuilder(host, path, args, { pathParam });
+    const pathBuilder = new PathVariableBuilder(1, "id");
+    const urlBuilder = new UrlBuilder(host, path, args, pathBuilder);
 
     // when
     const actual = urlBuilder.build();
@@ -38,8 +38,14 @@ describe("UrlBuilder", () => {
     const host = "https://example.com";
     const path = "";
     const args = ["search"];
-    const queryParam = new RequestParamBuilder(0, "keyword");
-    const urlBuilder = new UrlBuilder(host, path, args, { queryParam });
+    const paramBuilder = new RequestParamBuilder(0, "keyword");
+    const urlBuilder = new UrlBuilder(
+      host,
+      path,
+      args,
+      undefined,
+      paramBuilder
+    );
 
     // when
     const actual = urlBuilder.build();
@@ -53,8 +59,14 @@ describe("UrlBuilder", () => {
     const host = "https://example.com";
     const path = "api/user";
     const args = [{ keyword: "search" }];
-    const queryParam = new RequestParamBuilder(0, undefined);
-    const urlBuilder = new UrlBuilder(host, path, args, { queryParam });
+    const paramBuilder = new RequestParamBuilder(0, undefined);
+    const urlBuilder = new UrlBuilder(
+      host,
+      path,
+      args,
+      undefined,
+      paramBuilder
+    );
 
     // when
     const actual = urlBuilder.build();

lib/builders/url.builder.ts

@@ -2,24 +2,17 @@ import { type PathVariableBuilder } from "./path-variable.builder";
 import { type RequestParamBuilder } from "./request-param.builder";
 
 export class UrlBuilder {
-  private readonly pathVariableBuilder: PathVariableBuilder | undefined;
-  private readonly requestParamBuilder: RequestParamBuilder | undefined;
-
   constructor(
     private readonly host: string,
     private readonly path: string,
     private readonly args: any[],
-    metadata: {
-      pathParam?: PathVariableBuilder;
-      queryParam?: RequestParamBuilder;
-    } = {}
+    private readonly pathVariableBuilder?: PathVariableBuilder,
+    private readonly requestParamBuilder?: RequestParamBuilder
   ) {
-    if (this.host.length === 0) {
+    if (this.host === "") {
       this.host = this.path;
       this.path = "";
     }
-    this.pathVariableBuilder = metadata.pathParam;
-    this.requestParamBuilder = metadata.queryParam;
   }
 
   build(): string {

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

@@ -1,9 +1,8 @@
 import { describe, test, expect } from "vitest";
 import { REQUEST_FORM_METADATA } from "./constants";
-import {
-  RequestForm,
-  type RequestFormMetadata,
-} from "./request-form.decorator";
+import { RequestForm } from "./request-form.decorator";
+import { type RequestFormBuilder } from "../builders/request-form.builder";
+import { type RequestParamBuilder } from "../builders/request-param.builder";
 
 describe("RequestForm", () => {
   test("should set request form metadata with empty key", () => {
@@ -15,15 +14,14 @@ describe("RequestForm", () => {
     }
 
     // when
-    const result: RequestFormMetadata = Reflect.getMetadata(
+    const result: RequestFormBuilder = Reflect.getMetadata(
       REQUEST_FORM_METADATA,
       TestService.prototype,
       "request"
     );
 
     // then
-    expect(result).toHaveLength(1);
-    expect(result.get(0)).toBeUndefined();
+    expect(result.metadata).toEqual([[0, undefined]]);
   });
 
   test("should set request form metadata with key", () => {
@@ -35,14 +33,38 @@ describe("RequestForm", () => {
     }
 
     // when
-    const result: RequestFormMetadata = Reflect.getMetadata(
+    const result: RequestFormBuilder = Reflect.getMetadata(
       REQUEST_FORM_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 form metadata with multiple decorator", () => {
+    // given
+    class TestService {
+      request(
+        @RequestForm("foo") foo: string,
+        @RequestForm() bar: { bar: string }
+      ): string {
+        return foo;
+      }
+    }
+
+    // when
+    const result: RequestParamBuilder = Reflect.getMetadata(
+      REQUEST_FORM_METADATA,
+      TestService.prototype,
+      "request"
+    );
+
+    // then
+    expect(result.metadata).toEqual([
+      [1, undefined],
+      [0, "foo"],
+    ]);
   });
 });

lib/decorators/request-form.decorator.ts

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