@da440dil/cbr 0.1.0 → 0.2.0

package/README.md

@@ -5,19 +5,17 @@
 
 [Circuit breaker](https://martinfowler.com/bliki/CircuitBreaker.html).
 
-[Example](./examples/decorator.ts):
+[Example](https://github.com/da440dil/js-cbr/blob/main/examples/decorator.ts):
 ```typescript
 import http from 'node:http';
 import { once } from 'node:events';
 import { setTimeout } from 'node:timers/promises';
-import { Circuit, Breakable } from '@da440dil/cbr';
+import { fixedWindow, Breakable } from '@da440dil/cbr';
 
 // Create circuit which uses "Fixed Window" algorithm to store counters for 10s,
 // switches from "Closed" to "Open" state on first error, from "Open" to "HalfOpen" state after 100ms,
 // from "HalfOpen" to "Closed" state on first success.
-const circuit = Circuit.fixed({
-	windowSize: 10000, errorThreshold: 1, resetTimeout: 100, successThreshold: 1
-});
+const circuit = fixedWindow({ windowSize: 10000, resetTimeout: 100 });
 
 circuit.on('state', (state) => {
 	console.log(`STATE: ${state}`);
@@ -53,7 +51,8 @@ async function main() {
 			console.log(`ERROR: ${err}`);
 		}
 	}
-	await setTimeout(100);
+	console.log(`TIMEOUT ${circuit.resetTimeout}ms`);
+	await setTimeout(circuit.resetTimeout);
 	const data = await client.get();
 	console.log(`DATA: ${data}`);
 	// Output:
@@ -61,6 +60,7 @@ async function main() {
 	// STATE: 1
 	// ERROR: Error: Failed with status 418
 	// ERROR: CircuitError: Circuit broken
+	// TIMEOUT 100ms
 	// STATE: 2
 	// STATE: 0
 	// DATA: { x: 2 }

package/lib/Breakable.d.ts

@@ -1,3 +1,3 @@
 import { Circuit } from './Circuit';
 /** Decorate a class method with circuit breaker logic. */
-export declare const Breakable: <This, Args extends unknown[], Return>(circuit: Circuit) => (fn: (this: This, ...args: Args) => Promise<Return>, _: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Promise<Return>>) => (this: This, ...args: Args) => Promise<Return>;
+export declare const Breakable: <This, Args extends unknown[], Return>(circuit: Circuit) => (fn: (this: This, ...args: Args) => Promise<Return>, _ctx: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Promise<Return>>) => (this: This, ...args: Args) => Promise<Return>;

package/lib/Breakable.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Breakable = void 0;
-const CircuitBreaker_1 = require("./CircuitBreaker");
+const Breaker_1 = require("./Breaker");
 /** Decorate a class method with circuit breaker logic. */
 const Breakable = (circuit) => {
-    const breaker = new CircuitBreaker_1.CircuitBreaker(circuit);
+    const breaker = new Breaker_1.Breaker(circuit);
     return (fn, 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _) => {
+    _ctx) => {
         return function breakable(...args) {
             return breaker.exec(() => fn.apply(this, args));
         };

package/lib/Breaker.d.ts

@@ -0,0 +1,20 @@
+import { Circuit } from './Circuit';
+export declare class Breaker {
+    private circuit;
+    private timeout;
+    private run;
+    constructor(circuit: Circuit, { timeout, isBreakable }?: BreakerOptions);
+    /** Execute a function with circuit breaker logic. */
+    exec<T>(fn: ExecFunction<T>, signal?: AbortSignal): Promise<T>;
+    protected isBreakable(_err: unknown): boolean;
+}
+export type BreakerOptions = {
+    /** Maximum time in milliseconds to execute a function before timing out. Default: no timeout = 0. */
+    timeout?: number;
+    /**
+     * Error checking function. Answers the question: should the error be taken into account or not.
+     * Default: all errors are taken into account.
+     */
+    isBreakable?: (err: unknown) => boolean;
+};
+export type ExecFunction<T> = (signal?: AbortSignal) => Promise<T>;

package/lib/Breaker.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Breaker = void 0;
+const CircuitState_1 = require("./CircuitState");
+const CircuitError_1 = require("./CircuitError");
+class Breaker {
+    constructor(circuit, { timeout, isBreakable } = {}) {
+        this.timeout = 0;
+        this.run = run;
+        this.circuit = circuit;
+        if (timeout) {
+            this.timeout = timeout;
+            this.run = withTimeout(timeout);
+        }
+        if (isBreakable) {
+            this.isBreakable = isBreakable;
+        }
+    }
+    /** Execute a function with circuit breaker logic. */
+    async exec(fn, signal) {
+        if (!this.circuit.request()) {
+            if (this.circuit.state() === CircuitState_1.CircuitState.Open) {
+                throw new CircuitError_1.CircuitError('Circuit broken', this.circuit.ttl());
+            }
+            throw new CircuitError_1.CircuitError('Request rate limit exceeded', this.timeout);
+        }
+        try {
+            const v = signal ? await withSignal(fn, signal) : await this.run(fn);
+            this.circuit.success();
+            return v;
+        }
+        catch (err) {
+            if (this.isBreakable(err)) {
+                this.circuit.error();
+            }
+            throw err;
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    isBreakable(_err) {
+        return true;
+    }
+}
+exports.Breaker = Breaker;
+async function withSignal(fn, signal) {
+    const v = await fn(signal);
+    signal.throwIfAborted();
+    return v;
+}
+function run(fn) {
+    return fn();
+}
+function withTimeout(timeout) {
+    return async function withSignal(fn) {
+        const controller = new AbortController();
+        let timer;
+        const timeoutPromise = new Promise((resolve) => {
+            timer = setTimeout(() => {
+                controller.abort(new CircuitError_1.CircuitError('Request timeout exceeded'));
+                resolve();
+            }, timeout);
+        });
+        try {
+            const v = await Promise.race([fn(controller.signal), timeoutPromise]);
+            controller.signal.throwIfAborted();
+            return v;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+}

package/lib/Circuit.d.ts

@@ -1,21 +1,23 @@
 import { EventEmitter } from 'node:events';
 import { ICounter } from './ICounter';
 import { CircuitState } from './CircuitState';
-import { CircuitStats } from './CircuitStats';
 export declare class Circuit extends EventEmitter<{
     state: [CircuitState];
 }> {
-    static fixed({ windowSize, ...rest }: CircuitParams): Circuit;
-    static sliding({ windowSize, ...rest }: CircuitParams): Circuit;
-    private state;
-    expiry: number;
-    private errorThreshold;
-    private volumeThreshold;
-    private resetTimeout;
-    private successThreshold;
+    /** Create circuit which uses "Fixed Window" algorithm to store counters. */
+    static fixedWindow({ windowSize, ...rest }?: CircuitOptions): Circuit;
+    /** Create circuit which uses "Sliding Window" algorithm to store counters. */
+    static slidingWindow({ windowSize, ...rest }?: CircuitOptions): Circuit;
+    private circuitState;
+    readonly errorThreshold: number;
+    readonly volumeThreshold: number;
+    readonly resetTimeout: number;
+    readonly successThreshold: number;
     private counter;
     private threshold;
-    constructor({ state, errorThreshold, volumeThreshold, resetTimeout, successThreshold, counter }: Omit<CircuitParams, 'windowSize'> & {
+    private expireAt;
+    private timer?;
+    constructor({ state, errorThreshold, volumeThreshold, resetTimeout, successThreshold, counter }: Omit<CircuitOptions, 'windowSize'> & {
         counter: ICounter;
     });
     /**
@@ -31,22 +33,32 @@ export declare class Circuit extends EventEmitter<{
     error(): void;
     private open;
     private setState;
-    /** Current stats: state and counter values. */
-    stats(): CircuitStats;
-    /**
-     * Time in seconds during which the circuit state will not switch:
-     * `Cache-Control` header `max-age` value or `Retry-After` header value.
-     */
-    maxAge(): number;
+    /** Destroys circuit: stops internal timers. */
+    destroy(): void;
+    /** Circuit state: "Closed", "Open", "HalfOpen". */
+    state(): CircuitState;
+    /** Request counter. Increments at `Circuit.request()` method if circuit state is "HalfOpen". */
+    requestCount(): number;
+    /** Success request counter. Increments at `Circuit.success()` method if circuit state is "Closed" or "HalfOpen". */
+    successCount(): number;
+    /** Error counter. Increments at `Circuit.error()` method if circuit state is "Closed". */
+    errorCount(): number;
+    /** Timestamp upon reaching which the circuit state will switch from "Open" to "HalfOpen". */
+    expiry(): number;
+    /** Time in milliseconds during which the circuit state will not switch from "Open" to "HalfOpen". */
+    ttl(): number;
 }
-export type CircuitParams = {
-    /** Initial circuit state. Default "Closed". */
+export type CircuitOptions = {
+    /** Initial circuit state. Default: "Closed". */
     state?: CircuitState;
-    /** The size of the counter window for the total number of requests, successful requests, and errors, in milliseconds. */
-    windowSize: number;
+    /**
+     * The size of the counter window for the total number of requests, successful requests, and errors,
+     * in milliseconds. Default: 30 seconds.
+     */
+    windowSize?: number;
     /**
      * The number of errors within specified `windowSize`,
-     * upon reaching which the circuit state switches from "Closed" to "Open". Default 1.
+     * upon reaching which the circuit state switches from "Closed" to "Open". Default: 1.
      *
      * If the value is less than 1, then this is the error threshold in percent:
      * calculated based on the ratio of the number of errors to the total number of requests.
@@ -55,7 +67,7 @@ export type CircuitParams = {
     /**
      * The minimum number of requests within specified `windowSize`,
      * upon reaching which the circuit state switches from "Closed" to "Open".
-     * Default 1.
+     * Default: 1.
      *
      * It doesn't matter how many errors there were,
      * until a certain number of requests were made the circuit state will not switch from "Closed" to "Open".
@@ -63,12 +75,13 @@ export type CircuitParams = {
     volumeThreshold?: number;
     /**
      * The period of time in milliseconds, when passed the circuit state switches from "Open" to "HalfOpen".
+     * Default: 30 seconds.
      */
-    resetTimeout: number;
+    resetTimeout?: number;
     /**
      * The number of success requests within specified `windowSize`,
      * upon reaching which the circuit state switches from "HalfOpen" to "Closed".
-     * Default 1.
+     * Default: 1.
      */
     successThreshold?: number;
 };

package/lib/Circuit.js

@@ -5,23 +5,36 @@ const node_events_1 = require("node:events");
 const CounterFixed_1 = require("./CounterFixed");
 const CounterSliding_1 = require("./CounterSliding");
 const CircuitState_1 = require("./CircuitState");
+const Threshold_1 = require("./Threshold");
+const request = 'r';
+const success = 's';
+const error = 'e';
 class Circuit extends node_events_1.EventEmitter {
-    static fixed({ windowSize, ...rest }) {
-        return new Circuit({ ...rest, counter: new CounterFixed_1.CounterFixed(windowSize) });
+    /** Create circuit which uses "Fixed Window" algorithm to store counters. */
+    static fixedWindow({ windowSize = 30000, ...rest } = {}) {
+        const counter = new CounterFixed_1.CounterFixed(windowSize);
+        counter.start();
+        return new Circuit({ ...rest, counter });
     }
-    static sliding({ windowSize, ...rest }) {
-        return new Circuit({ ...rest, counter: new CounterSliding_1.CounterSliding(windowSize) });
+    /** Create circuit which uses "Sliding Window" algorithm to store counters. */
+    static slidingWindow({ windowSize = 30000, ...rest } = {}) {
+        const counter = new CounterSliding_1.CounterSliding(windowSize);
+        counter.start();
+        return new Circuit({ ...rest, counter });
     }
-    constructor({ state = CircuitState_1.CircuitState.Closed, errorThreshold = 1, volumeThreshold = 1, resetTimeout, successThreshold = 1, counter }) {
+    constructor({ state = CircuitState_1.CircuitState.Closed, errorThreshold = 1, volumeThreshold = 1, resetTimeout = 30000, successThreshold = 1, counter }) {
         super();
-        this.expiry = 0;
-        this.state = state;
+        this.expireAt = 0;
+        this.circuitState = state;
         this.errorThreshold = errorThreshold;
         this.volumeThreshold = volumeThreshold;
         this.resetTimeout = resetTimeout;
         this.successThreshold = successThreshold;
         this.counter = counter;
-        this.threshold = errorThreshold < 1 && errorThreshold % 1 ? thresholdPercent : threshold;
+        this.threshold = (0, Threshold_1.threshold)(errorThreshold);
+        if (state === CircuitState_1.CircuitState.Open) {
+            this.open();
+        }
     }
     /**
      * Increments request counter if circuit state is "HalfOpen" and number of requests is not greater than `successThreshold`.
@@ -30,29 +43,22 @@ class Circuit extends node_events_1.EventEmitter {
      * number of requests is greater than `successThreshold`.
      */
     request() {
-        if (this.state === CircuitState_1.CircuitState.Open) {
-            if (this.expiry > Date.now()) {
-                return false;
-            }
-            this.setState(CircuitState_1.CircuitState.HalfOpen);
-            this.expiry = 0;
-            this.counter.count(request);
+        if (this.circuitState === CircuitState_1.CircuitState.Open) {
+            return false;
         }
-        else if (this.state === CircuitState_1.CircuitState.HalfOpen) {
-            this.counter.tidy();
+        else if (this.circuitState === CircuitState_1.CircuitState.HalfOpen) {
             if (this.counter.get(request) >= this.successThreshold) {
                 return false;
             }
-            this.counter.count(request);
+            this.counter.incr(request);
         }
         return true;
     }
     /** Increments success request counter if circuit state is "Closed" or "HalfOpen". */
     success() {
-        if (this.state !== CircuitState_1.CircuitState.Open) {
-            this.counter.tidy();
-            this.counter.count(success);
-            if (this.state === CircuitState_1.CircuitState.HalfOpen) {
+        if (this.circuitState !== CircuitState_1.CircuitState.Open) {
+            this.counter.incr(success);
+            if (this.circuitState === CircuitState_1.CircuitState.HalfOpen) {
                 if (this.counter.get(success) >= this.successThreshold) {
                     this.setState(CircuitState_1.CircuitState.Closed);
                 }
@@ -61,54 +67,63 @@ class Circuit extends node_events_1.EventEmitter {
     }
     /** Increments error counter if circuit state is "Closed". */
     error() {
-        if (this.state === CircuitState_1.CircuitState.Closed) {
-            this.counter.tidy();
-            this.counter.count(error);
+        if (this.circuitState === CircuitState_1.CircuitState.Closed) {
+            this.counter.incr(error);
             if (this.threshold(this.errorThreshold, this.volumeThreshold, this.counter.get(success), this.counter.get(error))) {
                 this.open();
             }
         }
-        else if (this.state === CircuitState_1.CircuitState.HalfOpen) {
+        else if (this.circuitState === CircuitState_1.CircuitState.HalfOpen) {
             this.open();
         }
     }
     open() {
         this.setState(CircuitState_1.CircuitState.Open);
-        this.expiry = Date.now() + this.resetTimeout;
+        if (!this.timer) {
+            this.expireAt = Date.now() + this.resetTimeout;
+            this.timer = setTimeout(() => {
+                this.expireAt = 0;
+                this.timer = undefined;
+                this.setState(CircuitState_1.CircuitState.HalfOpen);
+            }, this.resetTimeout);
+        }
     }
     setState(state) {
-        this.state = state;
+        this.circuitState = state;
         this.counter.reset();
-        this.emit('state', this.state);
+        this.emit('state', this.circuitState);
     }
-    /** Current stats: state and counter values. */
-    stats() {
-        this.counter.tidy();
-        return {
-            state: this.state,
-            requestCount: this.counter.get(request),
-            successCount: this.counter.get(success),
-            errorCount: this.counter.get(error)
-        };
+    /** Destroys circuit: stops internal timers. */
+    destroy() {
+        this.counter.stop();
+        clearTimeout(this.timer);
+        this.expireAt = 0;
+        this.timer = undefined;
     }
-    /**
-     * Time in seconds during which the circuit state will not switch:
-     * `Cache-Control` header `max-age` value or `Retry-After` header value.
-     */
-    maxAge() {
-        const diff = this.expiry - Date.now();
-        return diff > 0 ? Math.ceil(diff / 1000) : 0;
+    /** Circuit state: "Closed", "Open", "HalfOpen". */
+    state() {
+        return this.circuitState;
+    }
+    /** Request counter. Increments at `Circuit.request()` method if circuit state is "HalfOpen". */
+    requestCount() {
+        return this.counter.get(request);
+    }
+    /** Success request counter. Increments at `Circuit.success()` method if circuit state is "Closed" or "HalfOpen". */
+    successCount() {
+        return this.counter.get(success);
+    }
+    /** Error counter. Increments at `Circuit.error()` method if circuit state is "Closed". */
+    errorCount() {
+        return this.counter.get(error);
+    }
+    /** Timestamp upon reaching which the circuit state will switch from "Open" to "HalfOpen". */
+    expiry() {
+        return this.expireAt;
+    }
+    /** Time in milliseconds during which the circuit state will not switch from "Open" to "HalfOpen". */
+    ttl() {
+        const diff = this.expireAt - Date.now();
+        return diff > 0 ? diff : 0;
     }
 }
 exports.Circuit = Circuit;
-const request = 'r';
-const success = 's';
-const error = 'e';
-const threshold = (errorThreshold, volumeThreshold, successCount, errorCount) => {
-    const total = successCount + errorCount;
-    return total >= volumeThreshold && errorCount >= errorThreshold;
-};
-const thresholdPercent = (errorThreshold, volumeThreshold, successCount, errorCount) => {
-    const total = successCount + errorCount;
-    return total >= volumeThreshold && errorCount / total >= errorThreshold;
-};

package/lib/CircuitError.d.ts

@@ -3,4 +3,7 @@
  * or the circuit state is "HalfOpen" and the number of requests exceeds the limit.
  */
 export declare class CircuitError extends Error {
+    /** Time in milliseconds during which the circuit state will not switch from "Open" to "HalfOpen". */
+    ttl: number;
+    constructor(message: string, ttl?: number);
 }

package/lib/CircuitError.js

@@ -6,7 +6,10 @@ exports.CircuitError = void 0;
  * or the circuit state is "HalfOpen" and the number of requests exceeds the limit.
  */
 class CircuitError extends Error {
+    constructor(message, ttl = 0) {
+        super(message);
+        this.ttl = ttl;
+    }
 }
 exports.CircuitError = CircuitError;
 CircuitError.prototype.name = 'CircuitError';
-CircuitError.prototype.message = 'Circuit broken';

package/lib/CounterFixed.d.ts

@@ -3,11 +3,11 @@ import { ICounter } from './ICounter';
 export declare class CounterFixed implements ICounter {
     private data;
     private size;
-    private key;
+    private timer?;
     constructor(size: number);
-    private currKey;
-    count(key: string): void;
+    start(): void;
+    stop(): void;
+    incr(key: string): void;
     get(key: string): number;
-    tidy(): void;
     reset(): void;
 }

package/lib/CounterFixed.js

@@ -6,25 +6,29 @@ class CounterFixed {
     constructor(size) {
         this.data = {};
         this.size = size;
-        this.key = this.currKey(Date.now());
     }
-    currKey(now) {
-        return now - now % this.size;
+    start() {
+        if (!this.timer) {
+            this.timer = setTimeout(() => {
+                this.data = {};
+                if (this.timer) {
+                    this.timer.refresh();
+                }
+            }, this.size);
+            this.timer.unref();
+        }
+    }
+    stop() {
+        clearTimeout(this.timer);
+        this.timer = undefined;
     }
-    count(key) {
+    incr(key) {
         const v = this.data[key] || 0;
         this.data[key] = v + 1;
     }
     get(key) {
         return this.data[key] || 0;
     }
-    tidy() {
-        const currKey = this.currKey(Date.now());
-        if (currKey > this.key) {
-            this.key = currKey;
-            this.data = {};
-        }
-    }
     reset() {
         this.data = {};
     }

package/lib/CounterSliding.d.ts

@@ -4,11 +4,12 @@ export declare class CounterSliding implements ICounter {
     private prevData;
     private currData;
     private size;
-    private key;
+    private time;
+    private timer?;
     constructor(size: number);
-    private currKey;
-    count(key: string): void;
+    start(): void;
+    stop(): void;
+    incr(key: string): void;
     get(key: string): number;
-    tidy(): void;
     reset(): void;
 }

package/lib/CounterSliding.js

@@ -6,13 +6,28 @@ class CounterSliding {
     constructor(size) {
         this.prevData = {};
         this.currData = {};
+        this.time = 0;
         this.size = size;
-        this.key = this.currKey(Date.now());
     }
-    currKey(now) {
-        return now - now % this.size;
+    start() {
+        if (!this.timer) {
+            this.time = Date.now();
+            this.timer = setTimeout(() => {
+                this.prevData = this.currData;
+                this.currData = {};
+                if (this.timer) {
+                    this.time = Date.now();
+                    this.timer.refresh();
+                }
+            }, this.size);
+            this.timer.unref();
+        }
+    }
+    stop() {
+        clearTimeout(this.timer);
+        this.timer = undefined;
     }
-    count(key) {
+    incr(key) {
         const v = this.currData[key] || 0;
         this.currData[key] = v + 1;
     }
@@ -20,26 +35,12 @@ class CounterSliding {
         const prev = this.prevData[key] || 0;
         let curr = this.currData[key] || 0;
         if (prev) {
-            const now = Date.now();
-            const currKey = this.currKey(now);
-            const remainder = this.size - (now - currKey);
-            curr += Math.floor(prev * (remainder / this.size));
-        }
-        return curr;
-    }
-    tidy() {
-        const currKey = this.currKey(Date.now());
-        const prevKey = currKey - this.size;
-        if (prevKey >= this.key) {
-            if (prevKey === this.key) {
-                this.prevData = this.currData;
+            const rest = this.size - (Date.now() - this.time);
+            if (rest > 0) {
+                curr += Math.floor(prev * (rest / this.size));
             }
-            else {
-                this.prevData = {};
-            }
-            this.currData = {};
-            this.key = currKey;
         }
+        return curr;
     }
     reset() {
         this.prevData = {};

package/lib/ICounter.d.ts

@@ -1,10 +1,12 @@
 export interface ICounter {
+    /** Start timer. */
+    start(): void;
+    /** Stop timer. */
+    stop(): void;
     /** Increment key value. */
-    count(key: string): void;
+    incr(key: string): void;
     /** Get key value. */
     get(key: string): number;
-    /** Actualize all values on current time. */
-    tidy(): void;
     /** Reset all values to zero. */
     reset(): void;
 }

package/lib/Threshold.d.ts

@@ -0,0 +1,2 @@
+export type Threshold = (errorThreshold: number, volumeThreshold: number, successCount: number, errorCount: number) => boolean;
+export declare const threshold: (errorThreshold: number) => Threshold;

package/lib/Threshold.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.threshold = void 0;
+const threshold = (errorThreshold) => {
+    return errorThreshold < 1 && errorThreshold % 1 ? percentThreshold : integerThreshold;
+};
+exports.threshold = threshold;
+const integerThreshold = (errorThreshold, volumeThreshold, successCount, errorCount) => {
+    const total = successCount + errorCount;
+    return total >= volumeThreshold && errorCount >= errorThreshold;
+};
+const percentThreshold = (errorThreshold, volumeThreshold, successCount, errorCount) => {
+    const total = successCount + errorCount;
+    return total >= volumeThreshold && errorCount / total >= errorThreshold;
+};

package/lib/index.d.ts

@@ -1,6 +1,13 @@
-export { Circuit, CircuitParams } from './Circuit';
+import { Circuit, CircuitOptions } from './Circuit';
+export type { Circuit, CircuitOptions };
+export declare const fixedWindow: typeof Circuit.fixedWindow;
+export declare const slidingWindow: typeof Circuit.slidingWindow;
+declare const _default: {
+    fixedWindow: typeof Circuit.fixedWindow;
+    slidingWindow: typeof Circuit.slidingWindow;
+};
+export default _default;
 export { CircuitState } from './CircuitState';
-export { CircuitStats } from './CircuitStats';
 export { CircuitError } from './CircuitError';
-export { CircuitBreaker } from './CircuitBreaker';
+export { Breaker, type BreakerOptions, type ExecFunction } from './Breaker';
 export { Breakable } from './Breakable';

package/lib/index.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Breakable = exports.CircuitBreaker = exports.CircuitError = exports.CircuitState = exports.Circuit = void 0;
-var Circuit_1 = require("./Circuit");
-Object.defineProperty(exports, "Circuit", { enumerable: true, get: function () { return Circuit_1.Circuit; } });
+exports.Breakable = exports.Breaker = exports.CircuitError = exports.CircuitState = exports.slidingWindow = exports.fixedWindow = void 0;
+const Circuit_1 = require("./Circuit");
+exports.fixedWindow = Circuit_1.Circuit.fixedWindow;
+exports.slidingWindow = Circuit_1.Circuit.slidingWindow;
+exports.default = { fixedWindow: exports.fixedWindow, slidingWindow: exports.slidingWindow };
 var CircuitState_1 = require("./CircuitState");
 Object.defineProperty(exports, "CircuitState", { enumerable: true, get: function () { return CircuitState_1.CircuitState; } });
 var CircuitError_1 = require("./CircuitError");
 Object.defineProperty(exports, "CircuitError", { enumerable: true, get: function () { return CircuitError_1.CircuitError; } });
-var CircuitBreaker_1 = require("./CircuitBreaker");
-Object.defineProperty(exports, "CircuitBreaker", { enumerable: true, get: function () { return CircuitBreaker_1.CircuitBreaker; } });
+var Breaker_1 = require("./Breaker");
+Object.defineProperty(exports, "Breaker", { enumerable: true, get: function () { return Breaker_1.Breaker; } });
 var Breakable_1 = require("./Breakable");
 Object.defineProperty(exports, "Breakable", { enumerable: true, get: function () { return Breakable_1.Breakable; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@da440dil/cbr",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Circuit breaker",
   "main": "lib/index.js",
   "scripts": {

package/lib/CircuitBreaker.d.ts

@@ -1,12 +0,0 @@
-import { Circuit } from './Circuit';
-export declare class CircuitBreaker {
-    private circuit;
-    constructor(circuit: Circuit);
-    /** Execute a function with circuit breaker logic. */
-    exec<T>(fn: () => Promise<T>): Promise<T>;
-    /**
-     * Error checking function. Answers the question: should the error be taken into account or not.
-     * Default: all errors are taken into account.
-     */
-    protected isBreakable(_: unknown): boolean;
-}

package/lib/CircuitBreaker.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CircuitBreaker = void 0;
-const CircuitError_1 = require("./CircuitError");
-class CircuitBreaker {
-    constructor(circuit) {
-        this.circuit = circuit;
-    }
-    /** Execute a function with circuit breaker logic. */
-    async exec(fn) {
-        if (!this.circuit.request()) {
-            throw new CircuitError_1.CircuitError();
-        }
-        try {
-            const v = await fn();
-            this.circuit.success();
-            return v;
-        }
-        catch (err) {
-            if (this.isBreakable(err)) {
-                this.circuit.error();
-            }
-            throw err;
-        }
-    }
-    /**
-     * Error checking function. Answers the question: should the error be taken into account or not.
-     * Default: all errors are taken into account.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    isBreakable(_) {
-        return true;
-    }
-}
-exports.CircuitBreaker = CircuitBreaker;

package/lib/CircuitStats.d.ts

@@ -1,12 +0,0 @@
-import { CircuitState } from './CircuitState';
-/** Current stats: state and counter values. */
-export type CircuitStats = {
-    /** Circuit state: "Closed", "Open", "HalfOpen". */
-    state: CircuitState;
-    /** Request counter. Increments at `Circuit.request()` method if circuit state is "HalfOpen". */
-    requestCount: number;
-    /** Success request counter. Increments at `Circuit.success()` method if circuit state is "Closed" or "HalfOpen". */
-    successCount: number;
-    /** Error counter. Increments at `Circuit.error()` method if circuit state is "Closed". */
-    errorCount: number;
-};

package/lib/CircuitStats.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });