refactor: separated request creation logic into a new builder

jbl428 · jbl428 · commit 64f3460956a7 · 2023-04-16T20:49:30.000+09:00
diff --git a/lib/builders/http-request.builder.ts b/lib/builders/http-request.builder.ts
@@ -0,0 +1,68 @@
+import { type PathVariableBuilder } from "./path-variable.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;
+
+  constructor(
+    readonly target: object,
+    readonly propertyKey: string,
+    readonly method: HttpMethod,
+    readonly url: string
+  ) {
+    this.pathVariableBuilder = this.getMetadata(PATH_VARIABLE_METADATA);
+    this.requestParamBuilder = this.getMetadata(REQUEST_PARAM_METADATA);
+    this.requestBodyMetadata = 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 urlBuilder = new UrlBuilder(this.baseUrl, this.url, args, {
+      pathParam: this.pathVariableBuilder,
+      queryParam: this.requestParamBuilder,
+    });
+
+    return new Request(urlBuilder.build(), {
+      method: this.method,
+      headers:
+        typeof payload !== "undefined"
+          ? { "Content-Type": "application/json" }
+          : undefined,
+      body:
+        typeof payload !== "undefined" ? JSON.stringify(payload) : undefined,
+    });
+  }
+
+  getMetadata<T>(key: symbol): T | undefined {
+    return Reflect.getMetadata(key, this.target, this.propertyKey);
+  }
+}
diff --git a/lib/builders/url.builder.ts b/lib/builders/url.builder.ts
@@ -2,8 +2,8 @@ import { type PathVariableBuilder } from "./path-variable.builder";
 import { type RequestParamBuilder } from "./request-param.builder";
 
 export class UrlBuilder {
-  #pathVariableBuilder: PathVariableBuilder | undefined;
-  #requestParamBuilder: RequestParamBuilder | undefined;
+  private readonly pathVariableBuilder: PathVariableBuilder | undefined;
+  private readonly requestParamBuilder: RequestParamBuilder | undefined;
 
   constructor(
     private readonly host: string,
@@ -18,14 +18,14 @@ export class UrlBuilder {
       this.host = this.path;
       this.path = "";
     }
-    this.#pathVariableBuilder = metadata.pathParam;
-    this.#requestParamBuilder = metadata.queryParam;
+    this.pathVariableBuilder = metadata.pathParam;
+    this.requestParamBuilder = metadata.queryParam;
   }
 
   build(): string {
     return (
-      (this.#pathVariableBuilder?.build(this.url, this.args) ?? this.url) +
-      (this.#requestParamBuilder?.build(this.args) ?? "")
+      (this.pathVariableBuilder?.build(this.url, this.args) ?? this.url) +
+      (this.requestParamBuilder?.build(this.args) ?? "")
     );
   }
 
diff --git a/lib/decorators/http-exchange.decorator.spec.ts b/lib/decorators/http-exchange.decorator.spec.ts
@@ -1,7 +1,6 @@
 import { describe, test, expect } from "vitest";
 import { HTTP_EXCHANGE_METADATA } from "./constants";
 import {
-  type HttpExchangeMetadata,
   GetExchange,
   PostExchange,
   PutExchange,
@@ -10,6 +9,7 @@ import {
   PatchExchange,
   HeadExchange,
 } from "./http-exchange.decorator";
+import { type HttpRequestBuilder } from "../builders/http-request.builder";
 
 describe("HttpExchange", () => {
   test.each([
@@ -30,13 +30,15 @@ describe("HttpExchange", () => {
     }
 
     // when
-    const result: HttpExchangeMetadata = Reflect.getMetadata(
+    const result: HttpRequestBuilder = Reflect.getMetadata(
       HTTP_EXCHANGE_METADATA,
       TestService.prototype,
       "request"
     );
 
     // then
+    expect(result.target).toBe(TestService.prototype);
+    expect(result.propertyKey).toBe("request");
     expect(result.method).toBe(method);
     expect(result.url).toBe("/api/v1/sample");
   });
diff --git a/lib/decorators/http-exchange.decorator.ts b/lib/decorators/http-exchange.decorator.ts
@@ -1,18 +1,6 @@
 import { HTTP_EXCHANGE_METADATA } from "./constants";
-
-type HttpMethod =
-  | "GET"
-  | "POST"
-  | "PUT"
-  | "DELETE"
-  | "PATCH"
-  | "HEAD"
-  | "OPTIONS";
-
-export interface HttpExchangeMetadata {
-  method: HttpMethod;
-  url: string;
-}
+import { HttpRequestBuilder } from "../builders/http-request.builder";
+import { type HttpMethod } from "../types/http-method";
 
 type AsyncFunction = (...args: any[]) => Promise<unknown>;
 
@@ -23,7 +11,7 @@ export function HttpExchange(method: HttpMethod, url: string) {
   ) {
     Reflect.defineMetadata(
       HTTP_EXCHANGE_METADATA,
-      { method, url },
+      new HttpRequestBuilder(target, propertyKey, method, url),
       target,
       propertyKey
     );
diff --git a/lib/node-fetch.injector.ts b/lib/node-fetch.injector.ts
@@ -1,19 +1,8 @@
 import { Injectable, type OnModuleInit } from "@nestjs/common";
 import { DiscoveryService, MetadataScanner } from "@nestjs/core";
 import { type InstanceWrapper } from "@nestjs/core/injector/instance-wrapper";
-import { type PathVariableBuilder } from "./builders/path-variable.builder";
-import { type RequestParamBuilder } from "./builders/request-param.builder";
-import { TupleArrayBuilder } from "./builders/tuple-array.builder";
-import { UrlBuilder } from "./builders/url.builder";
-import {
-  HTTP_EXCHANGE_METADATA,
-  HTTP_INTERFACE_METADATA,
-  type HttpExchangeMetadata,
-  PATH_VARIABLE_METADATA,
-  REQUEST_BODY_METADATA,
-  REQUEST_PARAM_METADATA,
-  type RequestBodyMetadata,
-} from "./decorators";
+import { type HttpRequestBuilder } from "./builders/http-request.builder";
+import { HTTP_EXCHANGE_METADATA, HTTP_INTERFACE_METADATA } from "./decorators";
 import { HttpClient } from "./types/http-client.interface";
 
 @Injectable()
@@ -34,82 +23,26 @@ export class NodeFetchInjector implements OnModuleInit {
         prototype
       );
 
-      if (typeof baseUrl === "undefined") {
+      if (baseUrl == null) {
         return;
       }
 
       this.metadataScanner
         .getAllMethodNames(prototype)
         .forEach((methodName) => {
-          const getMetadata = this.makeMetadataGetter(prototype, methodName);
-          const httpExchangeMetadata = getMetadata<HttpExchangeMetadata>(
-            HTTP_EXCHANGE_METADATA
-          );
+          const httpRequestBuilder: HttpRequestBuilder | undefined =
+            Reflect.getMetadata(HTTP_EXCHANGE_METADATA, prototype, methodName);
 
-          if (typeof httpExchangeMetadata === "undefined") {
+          if (httpRequestBuilder == null) {
             return;
           }
 
-          const pathMetadata = getMetadata<PathVariableBuilder>(
-            PATH_VARIABLE_METADATA
-          );
-          const requestParamMetadata = getMetadata<RequestParamBuilder>(
-            REQUEST_PARAM_METADATA
-          );
-          const requestBodyMetadata = getMetadata<RequestBodyMetadata>(
-            REQUEST_BODY_METADATA
-          );
+          httpRequestBuilder.setBaseUrl(baseUrl);
 
-          wrapper.instance[methodName] = async (...args: never[]) => {
-            const payload = 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 urlBuilder = new UrlBuilder(
-              baseUrl,
-              httpExchangeMetadata.url,
-              args,
-              {
-                pathParam: pathMetadata,
-                queryParam: requestParamMetadata,
-              }
-            );
-
-            return await this.httpClient
-              .request(
-                new Request(urlBuilder.build(), {
-                  method: httpExchangeMetadata.method,
-                  headers:
-                    typeof payload !== "undefined"
-                      ? { "Content-Type": "application/json" }
-                      : undefined,
-                  body:
-                    typeof payload !== "undefined"
-                      ? JSON.stringify(payload)
-                      : undefined,
-                })
-              )
+          wrapper.instance[methodName] = async (...args: never[]) =>
+            await this.httpClient
+              .request(httpRequestBuilder.build(args))
               .then(async (response) => await response.json());
-          };
         });
     });
   }
@@ -123,12 +56,4 @@ export class NodeFetchInjector implements OnModuleInit {
       return typeof metadata !== "undefined" || metadata !== null;
     });
   }
-
-  private makeMetadataGetter(
-    prototype: object,
-    methodName: string
-  ): <T>(key: symbol) => T | undefined {
-    return (metadataKey: symbol) =>
-      Reflect.getMetadata(metadataKey, prototype, methodName);
-  }
 }
diff --git a/lib/types/http-method.ts b/lib/types/http-method.ts
@@ -0,0 +1,8 @@
+export type HttpMethod =
+  | "GET"
+  | "POST"
+  | "PUT"
+  | "DELETE"
+  | "PATCH"
+  | "HEAD"
+  | "OPTIONS";
