feat: implement http method to injector

Co-authored-by: imdudu1 <[email protected]>

Author: jbl428

lib/node-fetch.injector.spec.ts

@@ -1,9 +1,15 @@
 import { MetadataScanner } from "@nestjs/core";
 import { beforeEach, describe, test, expect } from "vitest";
 import {
+  DeleteExchange,
   GetExchange,
+  HeadExchange,
   HttpInterface,
+  OptionsExchange,
+  PatchExchange,
   PathVariable,
+  PostExchange,
+  PutExchange,
   RequestParam,
 } from "./decorators";
 import { StubDiscoveryService } from "./fixture/stub-discovery.service";
@@ -25,6 +31,25 @@ describe("NodeFetchInjector", () => {
     discoveryService.clear();
   });
 
+  test("should not wrap method if there is no http interface decorator", async () => {
+    // given
+    class SampleClient {
+      @GetExchange("/api")
+      async request(): Promise<string> {
+        return "request";
+      }
+    }
+    const instance = discoveryService.addProvider(SampleClient);
+    nodeFetchInjector.onModuleInit();
+
+    // when
+    const actual = await instance.request();
+
+    // then
+    expect(actual).toBe("request");
+    expect(httpClient.requestInfo).toHaveLength(0);
+  });
+
   test("should not wrap method if there is no http exchange", async () => {
     // given
     @HttpInterface()
@@ -161,4 +186,33 @@ describe("NodeFetchInjector", () => {
       "https://example.com/api?keyword=search&page=1&isActive=true"
     );
   });
+
+  test.each([
+    ["GET", GetExchange],
+    ["POST", PostExchange],
+    ["PUT", PutExchange],
+    ["DELETE", DeleteExchange],
+    ["PATCH", PatchExchange],
+    ["HEAD", HeadExchange],
+    ["OPTIONS", OptionsExchange],
+  ])("should make the request using %s method", async (method, decorator) => {
+    // given
+    @HttpInterface()
+    class SampleClient {
+      @decorator("https://example.com/api")
+      async request(): Promise<string> {
+        return "request";
+      }
+    }
+    const instance = discoveryService.addProvider(SampleClient);
+    httpClient.addResponse({ status: "ok" });
+    nodeFetchInjector.onModuleInit();
+
+    // when
+    await instance.request();
+
+    // then
+    expect(httpClient.requestInfo).toHaveLength(1);
+    expect(httpClient.requestInfo[0].method).toBe(method);
+  });
 });

lib/node-fetch.injector.ts

@@ -26,45 +26,54 @@ export class NodeFetchInjector implements OnModuleInit {
 
     httpProviders.forEach((wrapper) => {
       const prototype = wrapper.metatype.prototype;
-      const baseUrl: string = Reflect.getMetadata(
+      const baseUrl: string | undefined = Reflect.getMetadata(
         HTTP_INTERFACE_METADATA,
         prototype
       );
-      const methodNames = this.metadataScanner.getAllMethodNames(prototype);
 
-      methodNames.forEach((methodName) => {
-        const getMetadata = this.makeMetadataGetter(prototype, methodName);
-        const httpExchangeMetadata = getMetadata<HttpExchangeMetadata>(
-          HTTP_EXCHANGE_METADATA
-        );
+      if (typeof baseUrl === "undefined") {
+        return;
+      }
 
-        if (typeof httpExchangeMetadata === "undefined") {
-          return;
-        }
+      this.metadataScanner
+        .getAllMethodNames(prototype)
+        .forEach((methodName) => {
+          const getMetadata = this.makeMetadataGetter(prototype, methodName);
+          const httpExchangeMetadata = getMetadata<HttpExchangeMetadata>(
+            HTTP_EXCHANGE_METADATA
+          );
 
-        const pathMetadata = getMetadata<PathVariableMetadata>(
-          PATH_VARIABLE_METADATA
-        );
-        const requestParamMetadata = getMetadata<RequestParamMetadata>(
-          REQUEST_PARAM_METADATA
-        );
+          if (typeof httpExchangeMetadata === "undefined") {
+            return;
+          }
 
-        wrapper.instance[methodName] = async (...args: any[]) => {
-          const urlBuilder = new URLBuilder(
-            baseUrl,
-            httpExchangeMetadata.url,
-            args,
-            {
-              pathParam: pathMetadata,
-              queryParam: requestParamMetadata,
-            }
+          const pathMetadata = getMetadata<PathVariableMetadata>(
+            PATH_VARIABLE_METADATA
+          );
+          const requestParamMetadata = getMetadata<RequestParamMetadata>(
+            REQUEST_PARAM_METADATA
           );
 
-          return await this.httpClient
-            .request(new Request(urlBuilder.build()))
-            .then(async (response) => await response.json());
-        };
-      });
+          wrapper.instance[methodName] = async (...args: any[]) => {
+            const urlBuilder = new URLBuilder(
+              baseUrl,
+              httpExchangeMetadata.url,
+              args,
+              {
+                pathParam: pathMetadata,
+                queryParam: requestParamMetadata,
+              }
+            );
+
+            return await this.httpClient
+              .request(
+                new Request(urlBuilder.build(), {
+                  method: httpExchangeMetadata.method,
+                })
+              )
+              .then(async (response) => await response.json());
+          };
+        });
     });
   }