feat: implement payload builder

Author: jbl428

lib/builders/http-request.builder.ts

@@ -1,6 +1,5 @@
 import { type PathVariableBuilder } from "./path-variable.builder";
-import { type RequestBodyBuilder } from "./request-body.builder";
-import { type RequestFormBuilder } from "./request-form.builder";
+import { PayloadBuilder } from "./payload.builder";
 import { type RequestHeaderBuilder } from "./request-header.builder";
 import { type RequestParamBuilder } from "./request-param.builder";
 import { UrlBuilder } from "./url.builder";
@@ -17,9 +16,8 @@ export class HttpRequestBuilder {
   private baseUrl = "";
   private readonly pathVariableBuilder?: PathVariableBuilder;
   private readonly requestParamBuilder?: RequestParamBuilder;
-  private readonly requestBodyBuilder?: RequestBodyBuilder;
-  private readonly requestFormBuilder?: RequestFormBuilder;
   private readonly requestHeaderBuilder?: RequestHeaderBuilder;
+  private readonly payloadBuilder: PayloadBuilder;
 
   constructor(
     readonly target: object,
@@ -29,31 +27,34 @@ 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);
     this.requestHeaderBuilder = this.getMetadata(REQUEST_HEADER_METADATA);
+    this.payloadBuilder = new PayloadBuilder(
+      this.getMetadata(REQUEST_BODY_METADATA),
+      this.getMetadata(REQUEST_FORM_METADATA)
+    );
   }
 
   setBaseUrl(baseUrl: string): void {
     this.baseUrl = baseUrl;
   }
 
   build(args: any[]): Request {
-    const payload =
-      this.requestBodyBuilder?.build(args) ??
-      this.requestFormBuilder?.build(args);
     const urlBuilder = new UrlBuilder(
       this.baseUrl,
       this.url,
       args,
       this.pathVariableBuilder,
       this.requestParamBuilder
     );
+    const payload = this.payloadBuilder.build(args);
     const headers = this.requestHeaderBuilder?.build(args);
 
     return new Request(urlBuilder.build(), {
       method: this.method,
-      headers,
+      headers: {
+        ...headers,
+        ...this.payloadBuilder.contentType,
+      },
       body: payload,
     });
   }

lib/builders/payload.builder.ts

@@ -0,0 +1,28 @@
+import { type RequestBodyBuilder } from "./request-body.builder";
+import { type RequestFormBuilder } from "./request-form.builder";
+
+export class PayloadBuilder {
+  constructor(
+    private readonly requestBodyBuilder?: RequestBodyBuilder,
+    private readonly requestFormBuilder?: RequestFormBuilder
+  ) {}
+
+  get contentType(): { "Content-Type": string } | undefined {
+    if (this.requestBodyBuilder != null) {
+      return { "Content-Type": "application/json" };
+    }
+
+    if (this.requestFormBuilder != null) {
+      return { "Content-Type": "application/x-www-form-urlencoded" };
+    }
+
+    return undefined;
+  }
+
+  build(args: any[]): BodyInit | undefined {
+    return (
+      this.requestBodyBuilder?.build(args) ??
+      this.requestFormBuilder?.build(args)
+    );
+  }
+}

lib/node-fetch.injector.ts

@@ -17,33 +17,36 @@ export class NodeFetchInjector implements OnModuleInit {
     const httpProviders = this.getHttpProviders();
 
     httpProviders.forEach((wrapper) => {
-      const prototype = wrapper.metatype.prototype;
       const baseUrl: string | undefined = Reflect.getMetadata(
         HTTP_INTERFACE_METADATA,
-        prototype
+        wrapper.metatype.prototype
       );
 
       if (baseUrl == null) {
         return;
       }
 
-      this.metadataScanner
-        .getAllMethodNames(prototype)
-        .forEach((methodName) => {
-          const httpRequestBuilder: HttpRequestBuilder | undefined =
-            Reflect.getMetadata(HTTP_EXCHANGE_METADATA, prototype, methodName);
+      this.wrapMethods(wrapper, baseUrl);
+    });
+  }
+
+  private wrapMethods(wrapper: InstanceWrapper, baseUrl: string): void {
+    const prototype = wrapper.metatype.prototype;
 
-          if (httpRequestBuilder == null) {
-            return;
-          }
+    this.metadataScanner.getAllMethodNames(prototype).forEach((methodName) => {
+      const httpRequestBuilder: HttpRequestBuilder | undefined =
+        Reflect.getMetadata(HTTP_EXCHANGE_METADATA, prototype, methodName);
+
+      if (httpRequestBuilder == null) {
+        return;
+      }
 
-          httpRequestBuilder.setBaseUrl(baseUrl);
+      httpRequestBuilder.setBaseUrl(baseUrl);
 
-          wrapper.instance[methodName] = async (...args: never[]) =>
-            await this.httpClient
-              .request(httpRequestBuilder.build(args))
-              .then(async (response) => await response.json());
-        });
+      wrapper.instance[methodName] = async (...args: never[]) =>
+        await this.httpClient
+          .request(httpRequestBuilder.build(args))
+          .then(async (response) => await response.json());
     });
   }