refactor: apply configuration class

Author: jbl428

lib/http-interface.module.spec.ts

@@ -4,9 +4,9 @@ import { GetExchange, HttpInterface } from './decorators';
 import { StubHttpClient } from './fixtures/stub-http-client';
 import { HttpInterfaceModule } from './http-interface.module';
 import { imitation } from './supports';
+import { type Configuration } from './supports/configuration';
 import { FetchHttpClient } from './supports/fetch-http-client';
 import { NodeFetchInjector } from './supports/node-fetch.injector';
-import { type HttpClient } from './types';
 
 describe('HttpInterfaceModule', () => {
   @HttpInterface('http://localhost:3000')
@@ -26,10 +26,12 @@ describe('HttpInterfaceModule', () => {
     const app = module.createNestApplication();
 
     // when
-    const injector = app.get<{ httpClient: HttpClient }>(NodeFetchInjector);
+    const injector = app.get<{ configuration: Configuration }>(
+      NodeFetchInjector,
+    );
 
     // then
-    expect(injector.httpClient).toBeInstanceOf(FetchHttpClient);
+    expect(injector.configuration.httpClient).toBeInstanceOf(FetchHttpClient);
   });
 
   test('should request with given client', async () => {

lib/http-interface.module.ts

@@ -4,12 +4,12 @@ import {
   DiscoveryService,
   MetadataScanner,
 } from '@nestjs/core';
-import { FetchHttpClient } from './supports/fetch-http-client';
+import { Configuration } from './supports/configuration';
 import { NodeFetchInjector } from './supports/node-fetch.injector';
 import { type HttpInterfaceConfig } from './types';
 
 export class HttpInterfaceModule {
-  static forRoot(config: HttpInterfaceConfig = {}): DynamicModule {
+  static forRoot(config?: HttpInterfaceConfig): DynamicModule {
     return {
       global: true,
       imports: [DiscoveryModule],
@@ -21,16 +21,12 @@ export class HttpInterfaceModule {
           useFactory: (
             metadataScanner: MetadataScanner,
             discoveryService: DiscoveryService,
-          ) => {
-            const timeout = config.timeout ?? 5000;
-
-            return new NodeFetchInjector(
+          ) =>
+            new NodeFetchInjector(
               metadataScanner,
               discoveryService,
-              config.httpClient ?? new FetchHttpClient(timeout),
-              config,
-            );
-          },
+              new Configuration(config),
+            ),
         },
       ],
     };

lib/supports/configuration.spec.ts

@@ -0,0 +1,107 @@
+import { type ClassTransformOptions } from 'class-transformer';
+import type CircuitBreaker from 'opossum';
+import { describe, expect, test } from 'vitest';
+import { Configuration } from './configuration';
+import { StubHttpClient } from '../fixtures/stub-http-client';
+
+describe('Configuration', () => {
+  describe('default values', () => {
+    const configuration = new Configuration();
+
+    test('timeout', () => {
+      // when
+      const timeout = configuration.timeout;
+
+      // then
+      expect(timeout).toBe(Configuration.DEFAULT_TIMEOUT);
+    });
+
+    test('http client', () => {
+      // given
+      const configuration = new Configuration();
+
+      // when
+      const httpClient = configuration.httpClient;
+
+      // then
+      expect(httpClient).toBeInstanceOf(Configuration.DEFAULT_HTTP_CLIENT);
+    });
+
+    test('transform option', () => {
+      // when
+      const transformOption = configuration.transformOption;
+
+      // then
+      expect(transformOption).toBeUndefined();
+    });
+
+    test('circuit breaker option', () => {
+      // when
+      const circuitBreakerOption = configuration.circuitBreakerOption;
+
+      // then
+      expect(circuitBreakerOption).toBeUndefined();
+    });
+  });
+
+  describe('custom values', () => {
+    test('timeout', () => {
+      // given
+      const timeout = 1000;
+
+      // when
+      const configuration = new Configuration({ timeout });
+
+      // then
+      expect(configuration.timeout).toBe(timeout);
+    });
+
+    test('http client', () => {
+      // given
+      const httpClient = new StubHttpClient();
+
+      // when
+      const configuration = new Configuration({ httpClient });
+
+      // then
+      expect(configuration.httpClient).toBe(httpClient);
+    });
+
+    test('transform option', () => {
+      // given
+      const transformOption: ClassTransformOptions = {
+        enableImplicitConversion: true,
+      };
+
+      // when
+      const configuration = new Configuration({ transformOption });
+
+      // then
+      expect(configuration.transformOption).toBe(transformOption);
+    });
+
+    test('circuit breaker option', () => {
+      // given
+      const circuitBreakerOption: CircuitBreaker.Options = {
+        errorThresholdPercentage: 50,
+        resetTimeout: 1000,
+      };
+      const timeout = 10000;
+
+      // when
+      const configuration = new Configuration({
+        circuitBreakerOption,
+        timeout,
+      });
+
+      // then
+      expect(configuration.circuitBreakerOption).toMatchInlineSnapshot(`
+        {
+          "errorThresholdPercentage": 50,
+          "resetTimeout": 1000,
+          "timeout": 10000,
+        }
+      `);
+    });
+  });
+});

lib/supports/configuration.ts

@@ -0,0 +1,37 @@
+import { type ClassTransformOptions } from 'class-transformer';
+import type CircuitBreaker from 'opossum';
+import { FetchHttpClient } from './fetch-http-client';
+import { type HttpClient, type HttpInterfaceConfig } from '../types';
+
+export class Configuration {
+  static DEFAULT_TIMEOUT = 5000;
+  static DEFAULT_HTTP_CLIENT = FetchHttpClient;
+
+  constructor(private readonly config: HttpInterfaceConfig = {}) {}
+
+  get timeout(): number {
+    return this.config.timeout ?? Configuration.DEFAULT_TIMEOUT;
+  }
+
+  get httpClient(): HttpClient {
+    return (
+      this.config.httpClient ??
+      new Configuration.DEFAULT_HTTP_CLIENT(this.timeout)
+    );
+  }
+
+  get transformOption(): ClassTransformOptions | undefined {
+    return this.config.transformOption;
+  }
+
+  get circuitBreakerOption(): CircuitBreaker.Options | undefined {
+    if (this.config.circuitBreakerOption == null) {
+      return undefined;
+    }
+
+    return {
+      ...this.config.circuitBreakerOption,
+      timeout: this.timeout,
+    };
+  }
+}

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

@@ -1,5 +1,6 @@
 import { MetadataScanner } from '@nestjs/core';
 import { beforeEach, describe, test, expect } from 'vitest';
+import { Configuration } from './configuration';
 import { imitation } from './imitation';
 import { NodeFetchInjector } from './node-fetch.injector';
 import {
@@ -30,7 +31,7 @@ describe('NodeFetchInjector', () => {
   const nodeFetchInjector = new NodeFetchInjector(
     metadataScanner,
     discoveryService,
-    httpClient,
+    new Configuration({ httpClient }),
   );
 
   beforeEach(() => {
@@ -525,8 +526,10 @@ describe('NodeFetchInjector', () => {
     const nodeFetchInjector = new NodeFetchInjector(
       metadataScanner,
       discoveryService,
-      httpClient,
-      { transformOption: { strategy: 'excludeAll' } },
+      new Configuration({
+        httpClient,
+        transformOption: { strategy: 'excludeAll' },
+      }),
     );
     class ResponseTest {
       constructor(readonly status: string) {}

lib/supports/node-fetch.injector.ts

@@ -1,6 +1,7 @@
 import { Injectable, type OnModuleInit } from '@nestjs/common';
 import { DiscoveryService, MetadataScanner } from '@nestjs/core';
 import { type InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+import { Configuration } from './configuration';
 import { CircuitBreakerBuilder } from '../builders/circuit-breaker.builder';
 import { type HttpRequestBuilder } from '../builders/http-request.builder';
 import { type ResponseBodyBuilder } from '../builders/response-body.builder';
@@ -10,15 +11,13 @@ import {
   HTTP_INTERFACE_METADATA,
   RESPONSE_BODY_METADATA,
 } from '../decorators';
-import { HttpClient, HttpInterfaceConfig } from '../types';
 
 @Injectable()
 export class NodeFetchInjector implements OnModuleInit {
   constructor(
     private readonly metadataScanner: MetadataScanner,
     private readonly discoveryService: DiscoveryService,
-    private readonly httpClient: HttpClient,
-    private readonly httpInterfaceConfig?: HttpInterfaceConfig,
+    private readonly configuration: Configuration,
   ) {}
 
   onModuleInit(): void {
@@ -47,25 +46,23 @@ export class NodeFetchInjector implements OnModuleInit {
 
       const circuitBreaker: CircuitBreakerBuilder =
         Reflect.getMetadata(CIRCUIT_BREAKER_METADATA, prototype, methodName) ??
-        new CircuitBreakerBuilder(
-          this.httpInterfaceConfig?.circuitBreakerOption,
-        );
+        new CircuitBreakerBuilder(this.configuration.circuitBreakerOption);
       const responseBodyBuilder: ResponseBodyBuilder<unknown> | undefined =
         Reflect.getMetadata(RESPONSE_BODY_METADATA, prototype, methodName);
 
       httpRequestBuilder.setBaseUrl(baseUrl);
 
       wrapper.instance[methodName] = circuitBreaker.build(
         async (...args: never[]) =>
-          await this.httpClient
+          await this.configuration.httpClient
             .request(httpRequestBuilder.build(args), httpRequestBuilder.options)
             .then(async (response) => {
               if (responseBodyBuilder != null) {
                 const res = await response.json();
 
                 return responseBodyBuilder.build(
                   res,
-                  this.httpInterfaceConfig?.transformOption,
+                  this.configuration.transformOption,
                 );
               }
 

lib/types/http-interface-config.ts

@@ -6,5 +6,5 @@ export interface HttpInterfaceConfig {
   timeout?: number;
   httpClient?: HttpClient;
   transformOption?: ClassTransformOptions;
-  circuitBreakerOption?: CircuitBreaker.Options;
+  circuitBreakerOption?: Omit<CircuitBreaker.Options, 'timeout'>;
 }