fix: resolve circuit breaker bug

Author: jbl428

lib/builders/circuit-breaker.builder.spec.ts

@@ -0,0 +1,45 @@
+import { describe, test, expect } from 'vitest';
+import { CircuitBreakerBuilder } from './circuit-breaker.builder';
+
+describe('CircuitBreakerBuilder', () => {
+  test('should not apply circuit breaker if option is not given', async () => {
+    // given
+    let executeCount = 0;
+    const executor = async (): Promise<Response> => {
+      executeCount++;
+      throw new Error('error');
+    };
+    const request = new CircuitBreakerBuilder().build(executor);
+
+    // when
+    for (let i = 0; i < 10; i++) {
+      await request().catch(() => 0);
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+
+    // then
+    expect(executeCount).toBe(10);
+  });
+
+  test('should apply circuit breaker if option is given', async () => {
+    // given
+    let executeCount = 0;
+    const executor = async (): Promise<Response> => {
+      executeCount++;
+      throw new Error('error');
+    };
+    const request = new CircuitBreakerBuilder({
+      errorThresholdPercentage: 50,
+      resetTimeout: 1000,
+    }).build(executor);
+
+    // when
+    for (let i = 0; i < 10; i++) {
+      await request().catch(() => 0);
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+
+    // then
+    expect(executeCount).toBe(1);
+  });
+});

lib/builders/circuit-breaker.builder.ts

@@ -1,13 +1,19 @@
 import CircuitBreaker from 'opossum';
 
 export class CircuitBreakerBuilder {
-  constructor(private readonly options?: CircuitBreaker.Options) {}
+  constructor(readonly options?: CircuitBreaker.Options) {}
 
-  async build(executor: () => Promise<Response>): Promise<Response> {
+  build(
+    executor: (...args: never[]) => Promise<any>,
+  ): (...args: never[]) => Promise<any> {
     if (this.options == null) {
-      return await executor();
+      return executor;
     }
 
-    return await new CircuitBreaker(executor, this.options).fire();
+    const circuitBreaker = new CircuitBreaker(executor, this.options);
+
+    return async (...args) => {
+      return await circuitBreaker.fire(...args);
+    };
   }
 }

lib/decorators/circuit-breaker.decorator.spec.ts

@@ -0,0 +1,26 @@
+import { describe, test, expect } from 'vitest';
+import { CircuitBreaker } from './circuit-breaker.decorator';
+import { CIRCUIT_BREAKER_METADATA } from './constants';
+import { type CircuitBreakerBuilder } from '../builders/circuit-breaker.builder';
+
+describe('CircuitBreaker', () => {
+  test('should set circuit breaker metadata', () => {
+    // given
+    class TestService {
+      @CircuitBreaker({ resetTimeout: 1000 })
+      async request(): Promise<string> {
+        return '';
+      }
+    }
+
+    // when
+    const result: CircuitBreakerBuilder = Reflect.getMetadata(
+      CIRCUIT_BREAKER_METADATA,
+      TestService.prototype,
+      'request',
+    );
+
+    // then
+    expect(result.options).toEqual({ resetTimeout: 1000 });
+  });
+});

lib/decorators/circuit-breaker.decorator.ts

@@ -0,0 +1,15 @@
+import { type Options } from 'opossum';
+import { CIRCUIT_BREAKER_METADATA } from './constants';
+import { CircuitBreakerBuilder } from '../builders/circuit-breaker.builder';
+import { type AsyncFunction } from '../types';
+
+export const CircuitBreaker =
+  (options: Options) =>
+  <P extends string>(target: Record<P, AsyncFunction>, propertyKey: P) => {
+    Reflect.defineMetadata(
+      CIRCUIT_BREAKER_METADATA,
+      new CircuitBreakerBuilder(options),
+      target,
+      propertyKey,
+    );
+  };

lib/supports/node-fetch.injector.ts

@@ -55,27 +55,23 @@ export class NodeFetchInjector implements OnModuleInit {
 
       httpRequestBuilder.setBaseUrl(baseUrl);
 
-      wrapper.instance[methodName] = async (...args: never[]) =>
-        await circuitBreaker
-          .build(
-            async () =>
-              await this.httpClient.request(
-                httpRequestBuilder.build(args),
-                httpRequestBuilder.options,
-              ),
-          )
-          .then(async (response) => {
-            if (responseBodyBuilder != null) {
-              const res = await response.json();
+      wrapper.instance[methodName] = circuitBreaker.build(
+        async (...args: never[]) =>
+          await this.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,
-              );
-            }
+                return responseBodyBuilder.build(
+                  res,
+                  this.httpInterfaceConfig?.transformOption,
+                );
+              }
 
-            return await response.text();
-          });
+              return await response.text();
+            }),
+      );
     });
   }