feat: add supports for override default http config

Co-authored-by: imdudu1 <cd80@kakao.com>

Author: jbl428

lib/builders/http-request.builder.ts

@@ -10,7 +10,7 @@ import {
   REQUEST_HEADER_METADATA,
   REQUEST_PARAM_METADATA,
 } from '../decorators';
-import { type HttpMethod } from '../types';
+import { type HttpClientOptions, type HttpMethod } from '../types';
 
 export class HttpRequestBuilder {
   private baseUrl = '';
@@ -25,6 +25,7 @@ export class HttpRequestBuilder {
     readonly method: HttpMethod,
     readonly url: string,
     readonly gqlQuery?: string,
+    readonly options?: HttpClientOptions,
   ) {
     this.pathVariableBuilder = this.getMetadata(PATH_VARIABLE_METADATA);
     this.requestParamBuilder = this.getMetadata(REQUEST_PARAM_METADATA);

lib/decorators/graphql-exchange.decorator.ts

@@ -1,15 +1,19 @@
 import { HTTP_EXCHANGE_METADATA } from './constants';
 import { HttpRequestBuilder } from '../builders/http-request.builder';
-import { type AsyncFunction } from '../types';
+import { type AsyncFunction, type HttpClientOptions } from '../types';
 
-export function GraphQLExchange(query: string, url = '/graphql') {
+export function GraphQLExchange(
+  query: string,
+  url = '/graphql',
+  options?: HttpClientOptions,
+) {
   return <P extends string>(
     target: Record<P, AsyncFunction>,
     propertyKey: P,
   ) => {
     Reflect.defineMetadata(
       HTTP_EXCHANGE_METADATA,
-      new HttpRequestBuilder(target, propertyKey, 'POST', url, query),
+      new HttpRequestBuilder(target, propertyKey, 'POST', url, query, options),
       target,
       propertyKey,
     );

lib/decorators/http-exchange.decorator.ts

@@ -1,23 +1,41 @@
 import { HTTP_EXCHANGE_METADATA } from './constants';
 import { HttpRequestBuilder } from '../builders/http-request.builder';
-import { type AsyncFunction, type HttpMethod } from '../types';
+import {
+  type AsyncFunction,
+  type HttpClientOptions,
+  type HttpMethod,
+} from '../types';
 
 export const HttpExchange =
-  (method: HttpMethod, url: string) =>
+  (method: HttpMethod, url: string, options?: HttpClientOptions) =>
   <P extends string>(target: Record<P, AsyncFunction>, propertyKey: P) => {
     Reflect.defineMetadata(
       HTTP_EXCHANGE_METADATA,
-      new HttpRequestBuilder(target, propertyKey, method, url),
+      new HttpRequestBuilder(
+        target,
+        propertyKey,
+        method,
+        url,
+        undefined,
+        options,
+      ),
       target,
       propertyKey,
     );
   };
 
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
-export const GetExchange = (url = '') => HttpExchange('GET', url);
-export const PostExchange = (url = '') => HttpExchange('POST', url);
-export const PutExchange = (url = '') => HttpExchange('PUT', url);
-export const DeleteExchange = (url = '') => HttpExchange('DELETE', url);
-export const PatchExchange = (url = '') => HttpExchange('PATCH', url);
-export const HeadExchange = (url = '') => HttpExchange('HEAD', url);
-export const OptionsExchange = (url = '') => HttpExchange('OPTIONS', url);
+export const GetExchange = (url = '', options?: HttpClientOptions) =>
+  HttpExchange('GET', url, options);
+export const PostExchange = (url = '', options?: HttpClientOptions) =>
+  HttpExchange('POST', url, options);
+export const PutExchange = (url = '', options?: HttpClientOptions) =>
+  HttpExchange('PUT', url, options);
+export const DeleteExchange = (url = '', options?: HttpClientOptions) =>
+  HttpExchange('DELETE', url, options);
+export const PatchExchange = (url = '', options?: HttpClientOptions) =>
+  HttpExchange('PATCH', url, options);
+export const HeadExchange = (url = '', options?: HttpClientOptions) =>
+  HttpExchange('HEAD', url, options);
+export const OptionsExchange = (url = '', options?: HttpClientOptions) =>
+  HttpExchange('OPTIONS', url, options);

lib/fixtures/stub-http-client.ts

@@ -1,11 +1,16 @@
-import { type HttpClient } from '../types/http-client.interface';
+import { type HttpClient, type HttpClientOptions } from '../types';
 
 export class StubHttpClient implements HttpClient {
   #requestInfo: Request[] = [];
   #responses: Response[] = [];
+  #options: Array<HttpClientOptions | undefined> = [];
 
-  async request(request: Request): Promise<Response> {
+  async request(
+    request: Request,
+    options?: HttpClientOptions,
+  ): Promise<Response> {
     this.#requestInfo.push(request);
+    this.#options.push(options);
 
     const response = this.#responses.shift();
 
@@ -16,6 +21,10 @@ export class StubHttpClient implements HttpClient {
     return this.#requestInfo;
   }
 
+  get options(): Array<HttpClientOptions | undefined> {
+    return this.#options;
+  }
+
   addResponse(body: Record<string, unknown> | string): void {
     const response = new Response(JSON.stringify(body));
     this.#responses.push(response);

lib/supports/fetch-http-client.spec.ts

@@ -109,4 +109,19 @@ describe('FetchHttpClient', () => {
     // then
     await expect(doRequest).rejects.toThrowError('Request Timeout: 3000ms');
   });
+
+  test('should use given option if provided', async () => {
+    // given
+    const address = fastify.server.address() as AddressInfo;
+    const httpClient = new FetchHttpClient(60000);
+    const request = new Request(`http://localhost:${address.port}/timeout`);
+    const httpClientOptions = { timeout: 300 };
+
+    // when
+    const doRequest = async (): Promise<Response> =>
+      await httpClient.request(request, httpClientOptions);
+
+    // then
+    await expect(doRequest).rejects.toThrowError('Request Timeout: 300ms');
+  });
 });

lib/supports/fetch-http-client.ts

@@ -1,4 +1,4 @@
-import { type HttpClient } from '../types';
+import { type HttpClient, type HttpClientOptions } from '../types';
 
 export class FetchHttpClient implements HttpClient {
   readonly #timeout: number;
@@ -7,16 +7,20 @@ export class FetchHttpClient implements HttpClient {
     this.#timeout = timeout;
   }
 
-  async request(request: Request): Promise<Response> {
+  async request(
+    request: Request,
+    options?: HttpClientOptions,
+  ): Promise<Response> {
     const controller = new AbortController();
+    const timeout = options?.timeout ?? this.#timeout;
 
     return await Promise.race<Response>([
       fetch(request, { signal: controller.signal }),
       new Promise((resolve, reject) =>
         setTimeout(() => {
           controller.abort();
-          reject(new Error(`Request Timeout: ${this.#timeout}ms`));
-        }, this.#timeout),
+          reject(new Error(`Request Timeout: ${timeout}ms`));
+        }, timeout),
       ),
     ]);
   }

lib/supports/node-fetch.injector.ts

@@ -49,7 +49,7 @@ export class NodeFetchInjector implements OnModuleInit {
 
       wrapper.instance[methodName] = async (...args: never[]) =>
         await this.httpClient
-          .request(httpRequestBuilder.build(args))
+          .request(httpRequestBuilder.build(args), httpRequestBuilder.options)
           .then(async (response) => {
             if (responseBodyBuilder != null) {
               const res = await response.json();

lib/types/http-client.interface.ts

@@ -1,3 +1,7 @@
+import { type HttpInterfaceConfig } from '../http-interface.module';
+
+export type HttpClientOptions = Omit<HttpInterfaceConfig, 'httpClient'>;
+
 export interface HttpClient {
-  request: (request: Request) => Promise<Response>;
+  request: (request: Request, options?: HttpClientOptions) => Promise<Response>;
 }