@da440dil/cbr 0.0.0 → 0.1.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](./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 { Circuit, 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 });
-
-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++;
+// 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
 });
-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';
+circuit.on('state', (state) => {
+	console.log(`STATE: ${state}`);
+});
 
 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();
+	await setTimeout(100);
+	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
+	// 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>, _: 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 CircuitBreaker_1 = require("./CircuitBreaker");
+/** Decorate a class method with circuit breaker logic. */
+const Breakable = (circuit) => {
+    const breaker = new CircuitBreaker_1.CircuitBreaker(circuit);
+    return (fn, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _) => {
+        return function breakable(...args) {
+            return breaker.exec(() => fn.apply(this, args));
+        };
+    };
+};
+exports.Breakable = Breakable;

package/lib/Circuit.d.ts

@@ -0,0 +1,74 @@
+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;
+    private counter;
+    private threshold;
+    constructor({ state, errorThreshold, volumeThreshold, resetTimeout, successThreshold, counter }: Omit<CircuitParams, '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;
+    /** 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;
+}
+export type CircuitParams = {
+    /** 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 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".
+     */
+    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,114 @@
+"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");
+class Circuit extends node_events_1.EventEmitter {
+    static fixed({ windowSize, ...rest }) {
+        return new Circuit({ ...rest, counter: new CounterFixed_1.CounterFixed(windowSize) });
+    }
+    static sliding({ windowSize, ...rest }) {
+        return new Circuit({ ...rest, counter: new CounterSliding_1.CounterSliding(windowSize) });
+    }
+    constructor({ state = CircuitState_1.CircuitState.Closed, errorThreshold = 1, volumeThreshold = 1, resetTimeout, successThreshold = 1, counter }) {
+        super();
+        this.expiry = 0;
+        this.state = state;
+        this.errorThreshold = errorThreshold;
+        this.volumeThreshold = volumeThreshold;
+        this.resetTimeout = resetTimeout;
+        this.successThreshold = successThreshold;
+        this.counter = counter;
+        this.threshold = errorThreshold < 1 && errorThreshold % 1 ? thresholdPercent : threshold;
+    }
+    /**
+     * 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.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);
+        }
+        else if (this.state === CircuitState_1.CircuitState.HalfOpen) {
+            this.counter.tidy();
+            if (this.counter.get(request) >= this.successThreshold) {
+                return false;
+            }
+            this.counter.count(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.counter.get(success) >= this.successThreshold) {
+                    this.setState(CircuitState_1.CircuitState.Closed);
+                }
+            }
+        }
+    }
+    /** 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.threshold(this.errorThreshold, this.volumeThreshold, this.counter.get(success), this.counter.get(error))) {
+                this.open();
+            }
+        }
+        else if (this.state === CircuitState_1.CircuitState.HalfOpen) {
+            this.open();
+        }
+    }
+    open() {
+        this.setState(CircuitState_1.CircuitState.Open);
+        this.expiry = Date.now() + this.resetTimeout;
+    }
+    setState(state) {
+        this.state = state;
+        this.counter.reset();
+        this.emit('state', this.state);
+    }
+    /** 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)
+        };
+    }
+    /**
+     * 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;
+    }
+}
+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/CircuitBreaker.d.ts

@@ -1,32 +1,12 @@
-/// <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;
-    });
+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>;
-    private broken;
-    private success;
-    private failure;
-    private setExpiresAt;
-    private setState;
-    private isBreakable;
+    /**
+     * 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,97 +1,32 @@
 "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;
-        }
+class CircuitBreaker {
+    constructor(circuit) {
+        this.circuit = circuit;
     }
     /** Execute a function with circuit breaker logic. */
     async exec(fn) {
-        if (this.broken()) {
+        if (!this.circuit.request()) {
             throw new CircuitError_1.CircuitError();
         }
         try {
             const v = await fn();
-            this.success();
+            this.circuit.success();
             return v;
         }
         catch (err) {
             if (this.isBreakable(err)) {
-                this.failure();
+                this.circuit.error();
             }
             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);
-    }
+    /**
+     * 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;

package/lib/CircuitError.d.ts

@@ -1,4 +1,6 @@
-/** 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 {
 }

package/lib/CircuitError.js

@@ -1,10 +1,12 @@
 "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 {
 }
 exports.CircuitError = CircuitError;
 CircuitError.prototype.name = 'CircuitError';
-CircuitError.prototype.message = exports.CircuitBroken;
+CircuitError.prototype.message = 'Circuit broken';

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/CircuitStats.d.ts

@@ -0,0 +1,12 @@
+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

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

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 key;
+    constructor(size: number);
+    private currKey;
+    count(key: string): void;
+    get(key: string): number;
+    tidy(): void;
+    reset(): void;
+}

package/lib/CounterFixed.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CounterFixed = void 0;
+/** "Fixed Window" algorithm. */
+class CounterFixed {
+    constructor(size) {
+        this.data = {};
+        this.size = size;
+        this.key = this.currKey(Date.now());
+    }
+    currKey(now) {
+        return now - now % this.size;
+    }
+    count(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 = {};
+    }
+}
+exports.CounterFixed = CounterFixed;

package/lib/CounterSliding.d.ts

@@ -0,0 +1,14 @@
+import { ICounter } from './ICounter';
+/** "Sliding Window" algorithm. */
+export declare class CounterSliding implements ICounter {
+    private prevData;
+    private currData;
+    private size;
+    private key;
+    constructor(size: number);
+    private currKey;
+    count(key: string): void;
+    get(key: string): number;
+    tidy(): void;
+    reset(): void;
+}

package/lib/CounterSliding.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CounterSliding = void 0;
+/** "Sliding Window" algorithm. */
+class CounterSliding {
+    constructor(size) {
+        this.prevData = {};
+        this.currData = {};
+        this.size = size;
+        this.key = this.currKey(Date.now());
+    }
+    currKey(now) {
+        return now - now % this.size;
+    }
+    count(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 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;
+            }
+            else {
+                this.prevData = {};
+            }
+            this.currData = {};
+            this.key = currKey;
+        }
+    }
+    reset() {
+        this.prevData = {};
+        this.currData = {};
+    }
+}
+exports.CounterSliding = CounterSliding;

package/lib/ICounter.d.ts

@@ -0,0 +1,10 @@
+export interface ICounter {
+    /** Increment key value. */
+    count(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/ICounter.js

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

package/lib/index.d.ts

@@ -1,2 +1,6 @@
+export { Circuit, CircuitParams } from './Circuit';
+export { CircuitState } from './CircuitState';
+export { CircuitStats } from './CircuitStats';
+export { CircuitError } from './CircuitError';
 export { CircuitBreaker } from './CircuitBreaker';
-export { CircuitError, CircuitBroken } from './CircuitError';
+export { Breakable } from './Breakable';

package/lib/index.js

@@ -1,8 +1,13 @@
 "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.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; } });
+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 CircuitBreaker_1 = require("./CircuitBreaker");
+Object.defineProperty(exports, "CircuitBreaker", { enumerable: true, get: function () { return CircuitBreaker_1.CircuitBreaker; } });
+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.1.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 }}