@da440dil/cbr 0.0.0 → 0.2.0

package/README.md

@@ -1,138 +1,76 @@
 # @da440dil/cbr
 
-![GitHub Actions](https://github.com/da440dil/js-cbr/actions/workflows/ci.yml/badge.svg)
+[![CI](https://github.com/da440dil/js-cbr/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/da440dil/js-cbr/actions/workflows/ci.yml)
 [![Coverage Status](https://coveralls.io/repos/github/da440dil/js-cbr/badge.svg?branch=main)](https://coveralls.io/github/da440dil/js-cbr?branch=main)
 
 [Circuit breaker](https://martinfowler.com/bliki/CircuitBreaker.html).
 
-[Example](./examples/decorator.ts) decorator ([typescript](https://www.typescriptlang.org/) [version](https://github.com/microsoft/TypeScript/releases/tag/v5.0.2) >= 5):
+[Example](https://github.com/da440dil/js-cbr/blob/main/examples/decorator.ts):
 ```typescript
-import { promisify } from 'util';
-import http from 'http';
-import { CircuitBreaker } from '@da440dil/cbr';
+import http from 'node:http';
+import { once } from 'node:events';
+import { setTimeout } from 'node:timers/promises';
+import { fixedWindow, Breakable } from '@da440dil/cbr';
 
-// Create the circuit breaker which 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 breaker = new CircuitBreaker({ errorThreshold: 1, resetTimeout: 100, successThreshold: 1 });
+// 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 = fixedWindow({ windowSize: 10000, resetTimeout: 100 });
 
-class Client {
-	private url = 'http://localhost:3000';
-	// Decorate the class method with circuit breaker logic.
-	@CircuitBreaker.Breakable(breaker)
-	public get(): Promise<string> {
-		return new Promise((resolve, reject) => {
-			const req = http.get(this.url, (res) => {
-				if (res.statusCode !== 200) {
-					res.resume();
-					return reject(new Error(`Failed with statusCode ${String(res.statusCode)}`));
-				}
-				let data = '';
-				res.on('data', (chunk) => { data += chunk; });
-				res.on('end', () => { resolve(data); });
-			});
-			req.on('error', reject);
-		});
-	}
-}
-const client = new Client();
-const get = async () => {
-	try {
-		const data = await client.get();
-		console.log(`DATA: ${data}`);
-	} catch (err) {
-		console.log(err instanceof Error ? `ERROR: ${(err).message}` : err);
-	}
-};
-
-let x = 0;
-const server = http.createServer((_, res) => {
-	const statusCode = x > 2 || x % 2 ? 418 : 200; // { 0 => 200, 1 => 418, 2 => 200, ... => 418 }
-	res.writeHead(statusCode).end(`{ x: ${x} }`);
-	x++;
+circuit.on('state', (state) => {
+	console.log(`STATE: ${state}`);
 });
-server.listen(3000);
-
-async function main() {
-	for (let i = 0; i < 3; i++) {
-		await get();
-	}
-	await promisify(setTimeout)(100);
-	await get();
-	// Output:
-	// DATA: { x: 0 }
-	// ERROR: Failed with statusCode 418
-	// ERROR: Circuit broken
-	// DATA: { x: 2 }
-}
-
-main().then(() => { process.exit(0); }).catch((err) => { console.error(err); process.exit(1); });
-```
-```
-npm run file examples/decorator.ts
-```
-
-[Example](./examples/function.ts) function:
-```typescript
-import { promisify } from 'util';
-import http from 'http';
-import { CircuitBreaker } from '@da440dil/cbr';
 
 class Client {
-	// Create the circuit breaker which switches from "Closed" to "Open" state on first error,
-	// from "Open" to "HalfOpen" state after 100ms, from "HalfOpen" to "Closed" state on first success.
-	private breaker = new CircuitBreaker({ errorThreshold: 1, resetTimeout: 100, successThreshold: 1 });
-	private url = 'http://localhost:3000';
-	public get(): Promise<string> {
-		// Execute the function with circuit breaker logic.
-		return this.breaker.exec(() => {
-			return new Promise((resolve, reject) => {
-				const req = http.get(this.url, (res) => {
-					if (res.statusCode !== 200) {
-						res.resume();
-						return reject(new Error(`Failed with statusCode ${String(res.statusCode)}`));
-					}
-					let data = '';
-					res.on('data', (chunk) => { data += chunk; });
-					res.on('end', () => { resolve(data); });
-				});
-				req.on('error', reject);
-			});
-		});
+	// Decorate class method with circuit breaker logic.
+	@Breakable(circuit)
+	public async get(): Promise<string> {
+		const res = await fetch('http://localhost:3000');
+		if (res.status !== 200) {
+			throw new Error(`Failed with status ${res.status}`);
+		}
+		return res.text();
 	}
 }
-const client = new Client();
-const get = async () => {
-	try {
-		const data = await client.get();
-		console.log(`DATA: ${data}`);
-	} catch (err) {
-		console.log(err instanceof Error ? `ERROR: ${(err).message}` : err);
-	}
-};
-
-let x = 0;
-const server = http.createServer((_, res) => {
-	const statusCode = x > 2 || x % 2 ? 418 : 200; // { 0 => 200, 1 => 418, 2 => 200, ... => 418 }
-	res.writeHead(statusCode).end(`{ x: ${x} }`);
-	x++;
-});
-server.listen(3000);
 
 async function main() {
+	let x = 0;
+	const server = http.createServer((_, res) => {
+		// { 0 => 200, 1 => 418, 2 => 200, ... => 418 }
+		res.writeHead(x > 2 || x % 2 ? 418 : 200).end(`{ x: ${x++} }`);
+	});
+	server.listen(3000);
+	await once(server, 'listening');
+
+	const client = new Client();
 	for (let i = 0; i < 3; i++) {
-		await get();
+		try {
+			const data = await client.get();
+			console.log(`DATA: ${data}`);
+		} catch (err) {
+			console.log(`ERROR: ${err}`);
+		}
 	}
-	await promisify(setTimeout)(100);
-	await get();
+	console.log(`TIMEOUT ${circuit.resetTimeout}ms`);
+	await setTimeout(circuit.resetTimeout);
+	const data = await client.get();
+	console.log(`DATA: ${data}`);
 	// Output:
 	// DATA: { x: 0 }
-	// ERROR: Failed with statusCode 418
-	// ERROR: Circuit broken
+	// STATE: 1
+	// ERROR: Error: Failed with status 418
+	// ERROR: CircuitError: Circuit broken
+	// TIMEOUT 100ms
+	// STATE: 2
+	// STATE: 0
 	// DATA: { x: 2 }
+
+	server.close();
+	await once(server, 'close');
 }
 
-main().then(() => { process.exit(0); }).catch((err) => { console.error(err); process.exit(1); });
+main().catch(console.error);
 ```
 ```
-npm run file examples/function.ts
+npm run file examples/decorator.ts
 ```

package/lib/Breakable.d.ts

@@ -0,0 +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>, _ctx: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Promise<Return>>) => (this: This, ...args: Args) => Promise<Return>;

package/lib/Breakable.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Breakable = void 0;
+const Breaker_1 = require("./Breaker");
+/** Decorate a class method with circuit breaker logic. */
+const Breakable = (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));
+        };
+    };
+};
+exports.Breakable = Breakable;

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

@@ -0,0 +1,87 @@
+import { EventEmitter } from 'node:events';
+import { ICounter } from './ICounter';
+import { CircuitState } from './CircuitState';
+export declare class Circuit extends EventEmitter<{
+    state: [CircuitState];
+}> {
+    /** 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;
+    private expireAt;
+    private timer?;
+    constructor({ state, errorThreshold, volumeThreshold, resetTimeout, successThreshold, counter }: Omit<CircuitOptions, 'windowSize'> & {
+        counter: ICounter;
+    });
+    /**
+     * Increments request counter if circuit state is "HalfOpen" and number of requests is not greater than `successThreshold`.
+     *
+     * Returns `false` if circuit is "broken": circuit state is "Open" or "HalfOpen" +
+     * number of requests is greater than `successThreshold`.
+     */
+    request(): boolean;
+    /** Increments success request counter if circuit state is "Closed" or "HalfOpen". */
+    success(): void;
+    /** Increments error counter if circuit state is "Closed". */
+    error(): void;
+    private open;
+    private setState;
+    /** 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 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. 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.
+     *
+     * 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.
+     */
+    errorThreshold?: number;
+    /**
+     * The minimum number of requests within specified `windowSize`,
+     * upon reaching which the circuit state switches from "Closed" to "Open".
+     * 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".
+     */
+    volumeThreshold?: number;
+    /**
+     * The period of time in milliseconds, when passed the circuit state switches from "Open" to "HalfOpen".
+     * Default: 30 seconds.
+     */
+    resetTimeout?: number;
+    /**
+     * The number of success requests within specified `windowSize`,
+     * upon reaching which the circuit state switches from "HalfOpen" to "Closed".
+     * Default: 1.
+     */
+    successThreshold?: number;
+};

package/lib/Circuit.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Circuit = void 0;
+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 {
+    /** 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 });
+    }
+    /** 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 = 30000, successThreshold = 1, counter }) {
+        super();
+        this.expireAt = 0;
+        this.circuitState = state;
+        this.errorThreshold = errorThreshold;
+        this.volumeThreshold = volumeThreshold;
+        this.resetTimeout = resetTimeout;
+        this.successThreshold = successThreshold;
+        this.counter = counter;
+        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`.
+     *
+     * Returns `false` if circuit is "broken": circuit state is "Open" or "HalfOpen" +
+     * number of requests is greater than `successThreshold`.
+     */
+    request() {
+        if (this.circuitState === CircuitState_1.CircuitState.Open) {
+            return false;
+        }
+        else if (this.circuitState === CircuitState_1.CircuitState.HalfOpen) {
+            if (this.counter.get(request) >= this.successThreshold) {
+                return false;
+            }
+            this.counter.incr(request);
+        }
+        return true;
+    }
+    /** Increments success request counter if circuit state is "Closed" or "HalfOpen". */
+    success() {
+        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);
+                }
+            }
+        }
+    }
+    /** Increments error counter if circuit state is "Closed". */
+    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.circuitState === CircuitState_1.CircuitState.HalfOpen) {
+            this.open();
+        }
+    }
+    open() {
+        this.setState(CircuitState_1.CircuitState.Open);
+        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.circuitState = state;
+        this.counter.reset();
+        this.emit('state', this.circuitState);
+    }
+    /** Destroys circuit: stops internal timers. */
+    destroy() {
+        this.counter.stop();
+        clearTimeout(this.timer);
+        this.expireAt = 0;
+        this.timer = undefined;
+    }
+    /** 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;

package/lib/CircuitError.d.ts

@@ -1,4 +1,9 @@
-/** Service unavailable: either the circuit state is "Open", or the circuit state is "HalfOpen" and the number of requests exceeds the limit. */
-export declare const CircuitBroken = "Circuit broken";
+/**
+ * Service unavailable: either the circuit state is "Open",
+ * 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

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CircuitError = exports.CircuitBroken = void 0;
-/** Service unavailable: either the circuit state is "Open", or the circuit state is "HalfOpen" and the number of requests exceeds the limit. */
-exports.CircuitBroken = 'Circuit broken';
+exports.CircuitError = void 0;
+/**
+ * Service unavailable: either the circuit state is "Open",
+ * 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 = exports.CircuitBroken;

package/lib/CircuitState.d.ts

@@ -1,10 +1,10 @@
 /** Circuit state: "Closed", "Open", "HalfOpen". */
 export declare const CircuitState: {
-    /** Requests are allowed. Switches to "Open" state if errors threshold is reached. */
+    /** Requests are allowed. Switches to "Open" state if `errorThreshold` is reached. */
     readonly Closed: 0;
-    /** Requests are disallowed. Switches to "HalfOpen" state after reset timeout passed. */
+    /** Requests are disallowed. Switches to "HalfOpen" state after `resetTimeout` passed. */
     readonly Open: 1;
-    /** Limited number of requests are allowed. Switches to "Closed" state if success threshold is reached. */
+    /** Limited number of requests are allowed. Switches to "Closed" state if `successThreshold` is reached. */
     readonly HalfOpen: 2;
 };
 export type CircuitState = typeof CircuitState[keyof typeof CircuitState];

package/lib/CircuitState.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CircuitState = void 0;
 /** Circuit state: "Closed", "Open", "HalfOpen". */
 exports.CircuitState = {
-    /** Requests are allowed. Switches to "Open" state if errors threshold is reached. */
+    /** Requests are allowed. Switches to "Open" state if `errorThreshold` is reached. */
     Closed: 0,
-    /** Requests are disallowed. Switches to "HalfOpen" state after reset timeout passed. */
+    /** Requests are disallowed. Switches to "HalfOpen" state after `resetTimeout` passed. */
     Open: 1,
-    /** Limited number of requests are allowed. Switches to "Closed" state if success threshold is reached. */
+    /** Limited number of requests are allowed. Switches to "Closed" state if `successThreshold` is reached. */
     HalfOpen: 2
 };

package/lib/CounterFixed.d.ts

@@ -0,0 +1,13 @@
+import { ICounter } from './ICounter';
+/** "Fixed Window" algorithm. */
+export declare class CounterFixed implements ICounter {
+    private data;
+    private size;
+    private timer?;
+    constructor(size: number);
+    start(): void;
+    stop(): void;
+    incr(key: string): void;
+    get(key: string): number;
+    reset(): void;
+}

package/lib/CounterFixed.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CounterFixed = void 0;
+/** "Fixed Window" algorithm. */
+class CounterFixed {
+    constructor(size) {
+        this.data = {};
+        this.size = 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;
+    }
+    incr(key) {
+        const v = this.data[key] || 0;
+        this.data[key] = v + 1;
+    }
+    get(key) {
+        return this.data[key] || 0;
+    }
+    reset() {
+        this.data = {};
+    }
+}
+exports.CounterFixed = CounterFixed;

package/lib/CounterSliding.d.ts

@@ -0,0 +1,15 @@
+import { ICounter } from './ICounter';
+/** "Sliding Window" algorithm. */
+export declare class CounterSliding implements ICounter {
+    private prevData;
+    private currData;
+    private size;
+    private time;
+    private timer?;
+    constructor(size: number);
+    start(): void;
+    stop(): void;
+    incr(key: string): void;
+    get(key: string): number;
+    reset(): void;
+}

package/lib/CounterSliding.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CounterSliding = void 0;
+/** "Sliding Window" algorithm. */
+class CounterSliding {
+    constructor(size) {
+        this.prevData = {};
+        this.currData = {};
+        this.time = 0;
+        this.size = 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;
+    }
+    incr(key) {
+        const v = this.currData[key] || 0;
+        this.currData[key] = v + 1;
+    }
+    get(key) {
+        const prev = this.prevData[key] || 0;
+        let curr = this.currData[key] || 0;
+        if (prev) {
+            const rest = this.size - (Date.now() - this.time);
+            if (rest > 0) {
+                curr += Math.floor(prev * (rest / this.size));
+            }
+        }
+        return curr;
+    }
+    reset() {
+        this.prevData = {};
+        this.currData = {};
+    }
+}
+exports.CounterSliding = CounterSliding;

package/lib/ICounter.d.ts

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

package/lib/ICounter.js

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

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,2 +1,13 @@
-export { CircuitBreaker } from './CircuitBreaker';
-export { CircuitError, CircuitBroken } from './CircuitError';
+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 { CircuitError } from './CircuitError';
+export { Breaker, type BreakerOptions, type ExecFunction } from './Breaker';
+export { Breakable } from './Breakable';

package/lib/index.js

@@ -1,8 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CircuitBroken = exports.CircuitError = exports.CircuitBreaker = void 0;
-var CircuitBreaker_1 = require("./CircuitBreaker");
-Object.defineProperty(exports, "CircuitBreaker", { enumerable: true, get: function () { return CircuitBreaker_1.CircuitBreaker; } });
+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; } });
-Object.defineProperty(exports, "CircuitBroken", { enumerable: true, get: function () { return CircuitError_1.CircuitBroken; } });
+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.0.0",
+  "version": "0.2.0",
   "description": "Circuit breaker",
   "main": "lib/index.js",
   "scripts": {
@@ -20,16 +20,16 @@
   "author": "Anatoly Demidovich",
   "license": "MIT",
   "engines": {
-    "node": ">=14"
+    "node": ">=18"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.0",
-    "@typescript-eslint/eslint-plugin": "^5.57.0",
-    "@typescript-eslint/parser": "^5.57.0",
-    "eslint": "^8.37.0",
-    "jest": "^29.5.0",
-    "ts-jest": "^29.1.0",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "@eslint/js": "^9.31.0",
+    "@types/jest": "^30.0.0",
+    "eslint": "^9.31.0",
+    "jest": "^30.0.4",
+    "ts-jest": "^29.4.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.37.0"
   }
 }

package/.github/workflows/ci.yml

@@ -1,30 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  test:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [14.x, 16.x, 18.x, 20.x]
-
-    steps:
-      - uses: actions/checkout@v3
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v3
-        with:
-          node-version: ${{ matrix.node-version }}
-      - run: npm install
-      - run: npm run test:coverage
-
-      - name: Coveralls
-        uses: coverallsapp/github-action@master
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}

package/lib/CircuitBreaker.d.ts

@@ -1,32 +0,0 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-export declare class CircuitBreaker extends EventEmitter {
-    /** Decorate a class method with circuit breaker logic. */
-    static Breakable<This, Args extends unknown[], Return>(breaker: CircuitBreaker): (fn: (this: This, ...args: Args) => Promise<Return>, _: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Promise<Return>>) => (this: This, ...args: Args) => Promise<Return>;
-    private state;
-    private requestCount;
-    private failureCount;
-    private successCount;
-    private expiresAt;
-    private errorThreshold;
-    private resetTimeout;
-    private successThreshold;
-    constructor({ errorThreshold, resetTimeout, successThreshold, isBreakable }: {
-        /** The number of consecutive errors, if reached the circuit state switches from "Closed" to "Open". By default equals 1. */
-        errorThreshold?: number;
-        /** The period of time, when passed the circuit state switches from "Open" to "HalfOpen". */
-        resetTimeout: number;
-        /** The number of consecutive successes, if reached the circuit state switches from "HalfOpen" to "Closed". By default equals 1. */
-        successThreshold?: number;
-        /** Error checking function. Answers the question: should the error be taken into account or not. By default, all errors are taken into account. */
-        isBreakable?: (err: unknown) => boolean;
-    });
-    /** Execute a function with circuit breaker logic. */
-    exec<T>(fn: () => Promise<T>): Promise<T>;
-    private broken;
-    private success;
-    private failure;
-    private setExpiresAt;
-    private setState;
-    private isBreakable;
-}

package/lib/CircuitBreaker.js

@@ -1,100 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CircuitBreaker = void 0;
-const events_1 = require("events");
-const CircuitState_1 = require("./CircuitState");
-const CircuitError_1 = require("./CircuitError");
-class CircuitBreaker extends events_1.EventEmitter {
-    /** Decorate a class method with circuit breaker logic. */
-    static Breakable(breaker) {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        return (fn, _) => {
-            return function breakable(...args) {
-                return breaker.exec(() => fn.apply(this, args));
-            };
-        };
-    }
-    constructor({ errorThreshold = 1, resetTimeout, successThreshold = 1, isBreakable }) {
-        super();
-        this.state = CircuitState_1.CircuitState.Closed;
-        this.requestCount = 0;
-        this.failureCount = 0;
-        this.successCount = 0;
-        this.expiresAt = 0;
-        this.errorThreshold = errorThreshold;
-        this.resetTimeout = resetTimeout;
-        this.successThreshold = successThreshold;
-        if (isBreakable) {
-            this.isBreakable = isBreakable;
-        }
-    }
-    /** Execute a function with circuit breaker logic. */
-    async exec(fn) {
-        if (this.broken()) {
-            throw new CircuitError_1.CircuitError();
-        }
-        try {
-            const v = await fn();
-            this.success();
-            return v;
-        }
-        catch (err) {
-            if (this.isBreakable(err)) {
-                this.failure();
-            }
-            throw err;
-        }
-    }
-    broken() {
-        if (this.state === CircuitState_1.CircuitState.Open) {
-            if (this.expiresAt < Date.now()) {
-                this.setState(CircuitState_1.CircuitState.HalfOpen);
-                this.expiresAt = 0;
-            }
-            else {
-                return true;
-            }
-        }
-        else if (this.state === CircuitState_1.CircuitState.HalfOpen && this.requestCount >= this.successThreshold) {
-            return true;
-        }
-        this.requestCount++;
-        return false;
-    }
-    success() {
-        if (this.state !== CircuitState_1.CircuitState.Open) {
-            this.successCount++;
-            if (this.state === CircuitState_1.CircuitState.HalfOpen && this.successCount >= this.successThreshold) {
-                this.setState(CircuitState_1.CircuitState.Closed);
-            }
-        }
-    }
-    failure() {
-        if (this.state === CircuitState_1.CircuitState.Closed) {
-            this.failureCount++;
-            if (this.failureCount >= this.errorThreshold) {
-                this.setState(CircuitState_1.CircuitState.Open);
-                this.setExpiresAt();
-            }
-        }
-        else if (this.state === CircuitState_1.CircuitState.HalfOpen) {
-            this.setState(CircuitState_1.CircuitState.Open);
-            this.setExpiresAt();
-        }
-    }
-    setExpiresAt() {
-        this.expiresAt = Date.now() + this.resetTimeout;
-    }
-    setState(state) {
-        this.state = state;
-        this.requestCount = 0;
-        this.failureCount = 0;
-        this.successCount = 0;
-        this.emit('state', this.state);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    isBreakable(_) {
-        return true;
-    }
-}
-exports.CircuitBreaker = CircuitBreaker;