feat: implement response body decorator

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

Author: jbl428

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

@@ -0,0 +1,19 @@
+import { describe, test, expect } from 'vitest';
+import { ResponseBodyBuilder } from './response-body.builder';
+
+describe('ResponseBodyBuilder', () => {
+  test('should build response body', () => {
+    // given
+    class TestResponse {
+      constructor(public value: string) {}
+    }
+    const builder = new ResponseBodyBuilder(TestResponse);
+
+    // when
+    const result: TestResponse = builder.build({ value: 'test' });
+
+    // then
+    expect(result).toBeInstanceOf(TestResponse);
+    expect(result.value).toBe('test');
+  });
+});

lib/builders/response-body.builder.ts

@@ -0,0 +1,16 @@
+import {
+  type ClassConstructor,
+  type ClassTransformOptions,
+  plainToInstance,
+} from 'class-transformer';
+
+export class ResponseBodyBuilder<T> {
+  constructor(
+    readonly cls: ClassConstructor<T>,
+    readonly options?: ClassTransformOptions,
+  ) {}
+
+  build(plain: Record<string, unknown>): T {
+    return plainToInstance(this.cls, plain, this.options);
+  }
+}

lib/decorators/constants.ts

@@ -3,5 +3,6 @@ export const HTTP_EXCHANGE_METADATA = Symbol('HTTP_EXCHANGE_METADATA');
 export const PATH_VARIABLE_METADATA = Symbol('PATH_VARIABLE_METADATA');
 export const REQUEST_PARAM_METADATA = Symbol('REQUEST_PARAM_METADATA');
 export const REQUEST_BODY_METADATA = Symbol('REQUEST_BODY_METADATA');
-export const REQUEST_FORM_METADATA = Symbol('REQUEST_BODY_METADATA');
+export const REQUEST_FORM_METADATA = Symbol('REQUEST_FORM_METADATA');
 export const REQUEST_HEADER_METADATA = Symbol('REQUEST_HEADER_METADATA');
+export const RESPONSE_BODY_METADATA = Symbol('RESPONSE_BODY_METADATA');

lib/decorators/response-body.decorator.spec.ts

@@ -0,0 +1,28 @@
+import { describe, test, expect } from 'vitest';
+import { RESPONSE_BODY_METADATA } from './constants';
+import { ResponseBody } from './response-body.decorator';
+import { type ResponseBodyBuilder } from '../builders/response-body.builder';
+
+describe('ResponseBody', () => {
+  test('should set response body metadata', () => {
+    // given
+    class TestResponse {}
+    class TestService {
+      @ResponseBody(TestResponse, { version: 1 })
+      async request(): Promise<string> {
+        return '';
+      }
+    }
+
+    // when
+    const result: ResponseBodyBuilder<unknown> = Reflect.getMetadata(
+      RESPONSE_BODY_METADATA,
+      TestService.prototype,
+      'request',
+    );
+
+    // then
+    expect(result.cls).toBe(TestResponse);
+    expect(result.options).toEqual({ version: 1 });
+  });
+});

lib/decorators/response-body.decorator.ts

@@ -0,0 +1,20 @@
+import {
+  type ClassConstructor,
+  type ClassTransformOptions,
+} from 'class-transformer';
+import { RESPONSE_BODY_METADATA } from './constants';
+import { ResponseBodyBuilder } from '../builders/response-body.builder';
+
+export function ResponseBody<T>(
+  cls: ClassConstructor<T>,
+  options?: ClassTransformOptions,
+): MethodDecorator {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(
+      RESPONSE_BODY_METADATA,
+      new ResponseBodyBuilder(cls, options),
+      target,
+      propertyKey,
+    );
+  };
+}

lib/node-fetch.injector.spec.ts renamed to lib/supports/node-fetch.injector.spec.ts

@@ -1,5 +1,7 @@
 import { MetadataScanner } from '@nestjs/core';
 import { beforeEach, describe, test, expect } from 'vitest';
+import { imitation } from './imitation';
+import { NodeFetchInjector } from './node-fetch.injector';
 import {
   DeleteExchange,
   GetExchange,
@@ -14,10 +16,10 @@ import {
   RequestForm,
   RequestHeader,
   RequestParam,
-} from './decorators';
-import { StubDiscoveryService } from './fixtures/stub-discovery.service';
-import { StubHttpClient } from './fixtures/stub-http-client';
-import { NodeFetchInjector } from './node-fetch.injector';
+} from '../decorators';
+import { ResponseBody } from '../decorators/response-body.decorator';
+import { StubDiscoveryService } from '../fixtures/stub-discovery.service';
+import { StubHttpClient } from '../fixtures/stub-http-client';
 
 describe('NodeFetchInjector', () => {
   const metadataScanner = new MetadataScanner();
@@ -334,4 +336,49 @@ describe('NodeFetchInjector', () => {
     expect(httpClient.requestInfo).toHaveLength(1);
     expect(httpClient.requestInfo[0].headers.get('Cookie')).toBe('value');
   });
+
+  test('should response text if there is no response body decorator', async () => {
+    // given
+    @HttpInterface()
+    class SampleClient {
+      @GetExchange('https://example.com/api')
+      async request(): Promise<string> {
+        return 'request';
+      }
+    }
+    const instance = discoveryService.addProvider(SampleClient);
+    httpClient.addResponse({ status: 'ok' });
+    nodeFetchInjector.onModuleInit();
+
+    // when
+    const result = await instance.request();
+
+    // then
+    expect(result).toBe('{"status":"ok"}');
+  });
+
+  test('should response instance provided with response body decorator', async () => {
+    // given
+    class ResponseTest {
+      constructor(readonly value: string) {}
+    }
+    @HttpInterface()
+    class SampleClient {
+      @GetExchange('https://example.com/api')
+      @ResponseBody(ResponseTest)
+      async request(): Promise<ResponseTest> {
+        return imitation();
+      }
+    }
+    const instance = discoveryService.addProvider(SampleClient);
+    httpClient.addResponse({ value: 'ok' });
+    nodeFetchInjector.onModuleInit();
+
+    // when
+    const result = await instance.request();
+
+    // then
+    expect(result).toBeInstanceOf(ResponseTest);
+    expect(result.value).toBe('ok');
+  });
 });

lib/node-fetch.injector.ts renamed to lib/supports/node-fetch.injector.ts

@@ -1,9 +1,14 @@
 import { Injectable, type OnModuleInit } from '@nestjs/common';
 import { DiscoveryService, MetadataScanner } from '@nestjs/core';
 import { type InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
-import { type HttpRequestBuilder } from './builders/http-request.builder';
-import { HTTP_EXCHANGE_METADATA, HTTP_INTERFACE_METADATA } from './decorators';
-import { HttpClient } from './types/http-client.interface';
+import { type HttpRequestBuilder } from '../builders/http-request.builder';
+import { type ResponseBodyBuilder } from '../builders/response-body.builder';
+import {
+  HTTP_EXCHANGE_METADATA,
+  HTTP_INTERFACE_METADATA,
+  RESPONSE_BODY_METADATA,
+} from '../decorators';
+import { HttpClient } from '../types/http-client.interface';
 
 @Injectable()
 export class NodeFetchInjector implements OnModuleInit {
@@ -41,12 +46,23 @@ export class NodeFetchInjector implements OnModuleInit {
         return;
       }
 
+      const responseBodyBuilder: ResponseBodyBuilder<unknown> | undefined =
+        Reflect.getMetadata(RESPONSE_BODY_METADATA, prototype, methodName);
+
       httpRequestBuilder.setBaseUrl(baseUrl);
 
       wrapper.instance[methodName] = async (...args: never[]) =>
         await this.httpClient
           .request(httpRequestBuilder.build(args))
-          .then(async (response) => await response.json());
+          .then(async (response) => {
+            if (responseBodyBuilder != null) {
+              const res = await response.json();
+
+              return responseBodyBuilder.build(res);
+            }
+
+            return await response.text();
+          });
     });
   }