feat: Do not suppress errors on policy hooks

README.md

@@ -308,12 +308,6 @@ policy.onRetry(async () => {
 policy.onRetry(async () => {
     // then this will be awaited
 });
-
-// errors thrown by an onRetryFn will be caught and ignored
-policy.onRetry(() => {
-    // throwing an error has no effect outside the method
-    throw new Error();
-});
 ```
 
 Wait for the specified number of milliseconds before retrying:
@@ -434,12 +428,6 @@ policy.onFinally(async () => {
 policy.onFinally(async () => {
     // then this will be awaited
 });
-
-// errors thrown by an onFinallyFn will be caught and ignored
-policy.onFinally(() => {
-    // throwing an error has no effect outside the method
-    throw new Error();
-});
 ```
 
 #### FallbackPolicy
@@ -500,12 +488,6 @@ policy.onFallback(async () => {
 policy.onFallback(async () => {
     // then this will be awaited
 });
-
-// errors thrown by an onFallbackFn will be caught and ignored
-policy.onFallback(() => {
-    // throwing an error has no effect outside the method
-    throw new Error();
-});
 ```
 
 Perform certain actions after the execution and all fallbacks finished:
@@ -528,12 +510,6 @@ policy.onFinally(async () => {
 policy.onFinally(async () => {
     // then this will be awaited
 });
-
-// errors thrown by an onFinallyFn will be caught and ignored
-policy.onFinally(() => {
-    // throwing an error has no effect outside the method
-    throw new Error();
-});
 ```
 
 #### CircuitBreakerPolicy
@@ -645,12 +621,6 @@ policy.onClose(async () => {
 policy.onClose(async () => {
     // then this will be awaited
 });
-
-// errors thrown by an onCloseFn will be caught and ignored
-policy.onClose(() => {
-    // throwing an error has no effect outside the method
-    throw new Error();
-});
 ```
 
 ```typescript
@@ -666,12 +636,6 @@ policy.onOpen(async () => {
 policy.onOpen(async () => {
     // then this will be awaited
 });
-
-// errors thrown by an onOpenFn will be caught and ignored
-policy.onOpen(() => {
-    // throwing an error has no effect outside the method
-    throw new Error();
-});
 ```
 
 ```typescript
@@ -687,12 +651,6 @@ policy.onAttemptingClose(async () => {
 policy.onAttemptingClose(async () => {
     // then this will be awaited
 });
-
-// errors thrown by an onAttemptingCloseFn will be caught and ignored
-policy.onAttemptingClose(() => {
-    // throwing an error has no effect outside the method
-    throw new Error();
-});
 ```
 
 ```typescript
@@ -708,12 +666,6 @@ policy.onIsolate(async () => {
 policy.onIsolate(async () => {
     // then this will be awaited
 });
-
-// errors thrown by an onIsolateFn will be caught and ignored
-policy.onIsolate(() => {
-    // throwing an error has no effect outside the method
-    throw new Error();
-});
 ```
 
 ### Proactive policies
@@ -782,12 +734,6 @@ policy.onTimeout(async () => {
 policy.onTimeout(async () => {
     // then this will be awaited
 });
-
-// errors thrown by an onTimeoutFn will be caught and ignored
-policy.onTimeout(() => {
-    // throwing an error has no effect outside the method
-    throw new Error();
-});
 ```
 
 Throwing a `TimeoutException` from the executed method is not a timeout, therefore it does not trigger running `onTimeout` functions:
@@ -948,12 +894,6 @@ policy.onCacheGet(async () => {
 policy.onCacheGet(async () => {
     // then this will be awaited
 });
-
-// errors thrown by an onCacheGetFn will be caught and ignored
-policy.onCacheGet(() => {
-    // throwing an error has no effect outside the method
-    throw new Error();
-});
 ```
 
 ```typescript
@@ -970,12 +910,6 @@ policy.onCacheMiss(async () => {
 policy.onCacheMiss(async () => {
     // then this will be awaited
 });
-
-// errors thrown by an onCacheMissFn will be caught and ignored
-policy.onCacheMiss(() => {
-    // throwing an error has no effect outside the method
-    throw new Error();
-});
 ```
 
 ```typescript
@@ -992,12 +926,6 @@ policy.onCachePut(async () => {
 policy.onCachePut(async () => {
     // then this will be awaited
 });
-
-// errors thrown by an onCachePutFn will be caught and ignored
-policy.onCachePut(() => {
-    // throwing an error has no effect outside the method
-    throw new Error();
-});
 ```
 
 ### Helpers and utilities

src/policies/proactive/timeoutPolicy/timeoutPolicy.ts

@@ -56,11 +56,7 @@ export class TimeoutPolicy<ResultType> extends ProactivePolicy<ResultType> {
             const typedEx: ExecutionException | TimeoutException = ex;
             if (typedEx instanceof TimeoutException) {
                 for (const onTimeoutFn of this.onTimeoutFns) {
-                    try {
-                        await onTimeoutFn(typedEx.timedOutAfterMs);
-                    } catch (onTimeoutError) {
-                        // ignored
-                    }
+                    await onTimeoutFn(typedEx.timedOutAfterMs);
                 }
 
                 throw typedEx;

src/policies/reactive/circuitBreakerPolicy/circuitBreakerPolicy.ts

@@ -175,47 +175,31 @@ export class CircuitBreakerPolicy<ResultType> extends ReactivePolicy<ResultType>
             case 'Closed': {
                 this.validateTransition(new Set(['AttemptingClose', 'Isolated']));
                 for (const onCloseFn of this.onCloseFns) {
-                    try {
-                        await onCloseFn();
-                    } catch (ex) {
-                        // ignored
-                    }
+                    await onCloseFn();
                 }
                 break;
             }
 
             case 'Open': {
                 this.validateTransition(new Set(['Closed', 'AttemptingClose']));
                 for (const onOpenFn of this.onOpenFns) {
-                    try {
-                        await onOpenFn();
-                    } catch (ex) {
-                        // ignored
-                    }
+                    await onOpenFn();
                 }
                 break;
             }
 
             case 'AttemptingClose': {
                 this.validateTransition(new Set(['Open']));
                 for (const onAttemptingCloseFn of this.onAttemptingCloseFns) {
-                    try {
-                        await onAttemptingCloseFn();
-                    } catch (ex) {
-                        // ignored
-                    }
+                    await onAttemptingCloseFn();
                 }
                 break;
             }
 
             case 'Isolated': {
                 this.validateTransition(new Set(['Closed', 'Open', 'AttemptingClose']));
                 for (const onIsolateFn of this.onIsolateFns) {
-                    try {
-                        await onIsolateFn();
-                    } catch (ex) {
-                        // ignored
-                    }
+                    await onIsolateFn();
                 }
                 break;
             }

src/policies/reactive/fallbackPolicy/fallbackPolicy.ts

@@ -50,11 +50,7 @@ export class FallbackPolicy<ResultType> extends ReactivePolicy<ResultType> {
                     executor = nextExecutor;
 
                     for (const onFallbackFn of this.onFallbackFns) {
-                        try {
-                            await onFallbackFn(result, undefined);
-                        } catch (onFallbackError) {
-                            // ignored
-                        }
+                        await onFallbackFn(result, undefined);
                     }
 
                     continue;
@@ -76,23 +72,15 @@ export class FallbackPolicy<ResultType> extends ReactivePolicy<ResultType> {
                     executor = nextExecutor;
 
                     for (const onFallbackFn of this.onFallbackFns) {
-                        try {
-                            await onFallbackFn(undefined, ex);
-                        } catch (onFallbackError) {
-                            // ignored
-                        }
+                        await onFallbackFn(undefined, ex);
                     }
 
                     continue;
                 }
             }
         } finally {
             for (const onFinallyFn of this.onFinallyFns) {
-                try {
-                    await onFinallyFn();
-                } catch (onFinallyError) {
-                    // ignored
-                }
+                await onFinallyFn();
             }
         }
     }

src/policies/reactive/retryPolicy/retryPolicy.ts

@@ -75,11 +75,7 @@ export class RetryPolicy<ResultType> extends ReactivePolicy<ResultType> {
                     }
 
                     for (const onRetryFn of this.onRetryFns) {
-                        try {
-                            await onRetryFn(result, undefined, currentRetryCount);
-                        } catch (onRetryError) {
-                            // ignored
-                        }
+                        await onRetryFn(result, undefined, currentRetryCount);
                     }
 
                     continue;
@@ -100,23 +96,15 @@ export class RetryPolicy<ResultType> extends ReactivePolicy<ResultType> {
                     }
 
                     for (const onRetryFn of this.onRetryFns) {
-                        try {
-                            await onRetryFn(undefined, ex, currentRetryCount);
-                        } catch (onRetryError) {
-                            // ignored
-                        }
+                        await onRetryFn(undefined, ex, currentRetryCount);
                     }
 
                     continue;
                 }
             }
         } finally {
             for (const onFinallyFn of this.onFinallyFns) {
-                try {
-                    await onFinallyFn();
-                } catch (onFinallyError) {
-                    // ignored
-                }
+                await onFinallyFn();
             }
         }
     }

test/specs/policyCombination.test.ts

@@ -1,7 +1,5 @@
 import { expect } from 'chai';
 import { PolicyCombination } from '../../src/policies/policyCombination';
-import { TimeoutException } from '../../src/policies/proactive/timeoutPolicy/timeoutException';
-import { TimeoutPolicy } from '../../src/policies/proactive/timeoutPolicy/timeoutPolicy';
 import { FallbackPolicy } from '../../src/policies/reactive/fallbackPolicy/fallbackPolicy';
 import { RetryPolicy } from '../../src/policies/reactive/retryPolicy/retryPolicy';
 
@@ -70,53 +68,4 @@ describe('PolicyCombination', (): void => {
         expect(onRetryExecuted).to.equal(1);
         expect(onFallbackExecuted).to.equal(1);
     });
-
-    it('should construct a policy which combines the other policies sequentially', async (): Promise<void> => {
-        let onTimeoutExecuted = 0;
-        let onRetryExecuted = 0;
-        let onFallbackExecuted = 0;
-
-        const fallbackPolicy = new FallbackPolicy<void>();
-        fallbackPolicy.reactOnException((e): boolean => e instanceof TimeoutException);
-        fallbackPolicy.fallback((): void => {
-            // empty
-        });
-        fallbackPolicy.onFallback((): void => {
-            expect(onTimeoutExecuted).to.equal(1);
-            expect(onRetryExecuted).to.equal(1);
-            expect(onFallbackExecuted).to.equal(0);
-            onFallbackExecuted++;
-        });
-
-        const retryPolicy = new RetryPolicy<void>();
-        retryPolicy.reactOnException((e): boolean => e instanceof TimeoutException);
-        retryPolicy.onRetry((): void => {
-            expect(onTimeoutExecuted).to.equal(1);
-            expect(onRetryExecuted).to.equal(0);
-            expect(onFallbackExecuted).to.equal(0);
-            onRetryExecuted++;
-        });
-
-        const timeoutPolicy = new TimeoutPolicy<void>();
-        timeoutPolicy.timeoutAfter(1);
-        timeoutPolicy.onTimeout((): void => {
-            expect(onTimeoutExecuted).to.equal(0);
-            expect(onRetryExecuted).to.equal(0);
-            expect(onFallbackExecuted).to.equal(0);
-            onTimeoutExecuted++;
-        });
-
-        const wrappedPolicies = PolicyCombination.combine<void>([fallbackPolicy, retryPolicy, timeoutPolicy]);
-        await wrappedPolicies.execute(
-            async (): Promise<void> => {
-                return new Promise((resolve): void => {
-                    setTimeout(resolve, 5);
-                });
-            },
-        );
-
-        expect(onTimeoutExecuted).to.equal(1);
-        expect(onRetryExecuted).to.equal(1);
-        expect(onFallbackExecuted).to.equal(1);
-    });
 });