redeye-breaker 0.1.0

package/dist/store.d.ts

@@ -0,0 +1,55 @@
+import { CircuitBreakerState } from './types';
+export interface Store {
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, ttlSeconds: number): Promise<void>;
+    del(key: string): Promise<void>;
+    /**
+     * Atomically increments the stored failure count for `key` and decides
+     * `isOpen` in a single round trip, so concurrent callers across instances
+     * can't race and lose an increment the way a plain get-then-set would.
+     *
+     * If omitted, the breaker falls back to a non-atomic get-then-set, which
+     * has a narrow race window under concurrent failures (see README).
+     */
+    recordFailureAtomic?(key: string, opts: {
+        ttlSeconds: number;
+        failureThreshold: number;
+        now: number;
+    }): Promise<CircuitBreakerState>;
+    /**
+     * Atomically claims a short-lived, exclusive "trial" slot for `key`
+     * (conceptually a SET-if-not-exists). Returns `true` if this call won the
+     * claim. Used to implement half-open: only the winner gets to make the
+     * trial call while a breaker is transitioning from open back to closed;
+     * everyone else stays blocked until the trial resolves.
+     *
+     * If omitted, the breaker falls back to letting every caller through
+     * once the reset window elapses (a thundering herd on recovery — see
+     * README).
+     */
+    claimTrial?(key: string, ttlSeconds: number): Promise<boolean>;
+    /**
+     * `strategy: 'errorRate'` only. Atomically folds one call's outcome into
+     * an EWMA failure-rate estimate and decides `isOpen` in a single round
+     * trip, the same atomicity guarantee `recordFailureAtomic` provides for
+     * the `'consecutive'` strategy. Called on every closed-phase call
+     * (success or failure), not just failures.
+     *
+     * `openedNow` distinguishes "this call is what tripped the breaker" from
+     * "the breaker was already open," so the caller can fire `onStateChange`
+     * exactly once per transition.
+     *
+     * If omitted, the breaker falls back to a non-atomic get-then-set.
+     */
+    recordOutcomeAtomic?(key: string, opts: {
+        success: boolean;
+        decay: number;
+        minimumCalls: number;
+        errorRateThreshold: number;
+        ttlSeconds: number;
+        now: number;
+    }): Promise<CircuitBreakerState & {
+        openedNow: boolean;
+    }>;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAE9C,MAAM,WAAW,KAAK;IACpB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IACvC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjE,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhC;;;;;;;OAOG;IACH,mBAAmB,CAAC,CAClB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAClE,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAEhC;;;;;;;;;;OAUG;IACH,UAAU,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAE/D;;;;;;;;;;;;OAYG;IACH,mBAAmB,CAAC,CAClB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAC3H,OAAO,CAAC,mBAAmB,GAAG;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAC1D"}

package/dist/store.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=store.js.map

package/dist/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":""}

package/dist/stores/redis-store.d.ts

@@ -0,0 +1,40 @@
+import type { Redis } from 'ioredis';
+import { Store } from '../store';
+import { CircuitBreakerState } from '../types';
+/**
+ * Redis-backed Store implementation. Import this from
+ * `redeye/redis-store` so the core package has no hard dependency on
+ * `ioredis` — only consumers who use RedisStore need it installed.
+ *
+ * Implements all three optional atomic capabilities (`recordFailureAtomic`
+ * and `recordOutcomeAtomic` via Lua scripts, `claimTrial` via `SET ... NX`),
+ * so breakers backed by RedisStore get exact counting and real single-trial
+ * half-open behavior under both strategies instead of best-effort fallbacks.
+ */
+export declare class RedisStore implements Store {
+    private readonly redis;
+    private readonly prefix;
+    constructor(redis: Redis, options?: {
+        keyPrefix?: string;
+    });
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, ttlSeconds: number): Promise<void>;
+    del(key: string): Promise<void>;
+    recordFailureAtomic(key: string, opts: {
+        ttlSeconds: number;
+        failureThreshold: number;
+        now: number;
+    }): Promise<CircuitBreakerState>;
+    recordOutcomeAtomic(key: string, opts: {
+        success: boolean;
+        decay: number;
+        minimumCalls: number;
+        errorRateThreshold: number;
+        ttlSeconds: number;
+        now: number;
+    }): Promise<CircuitBreakerState & {
+        openedNow: boolean;
+    }>;
+    claimTrial(key: string, ttlSeconds: number): Promise<boolean>;
+}
+//# sourceMappingURL=redis-store.d.ts.map

package/dist/stores/redis-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-store.d.ts","sourceRoot":"","sources":["../../src/stores/redis-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AA0F/C;;;;;;;;;GASG;AACH,qBAAa,UAAW,YAAW,KAAK;IAG1B,OAAO,CAAC,QAAQ,CAAC,KAAK;IAFlC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEH,KAAK,EAAE,KAAK,EAAE,OAAO,GAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAO;IAIzE,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAMtC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIhE,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/B,mBAAmB,CACvB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAClE,OAAO,CAAC,mBAAmB,CAAC;IAYzB,mBAAmB,CACvB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAC3H,OAAO,CAAC,mBAAmB,GAAG;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC;IAelD,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAIpE"}

package/dist/stores/redis-store.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStore = void 0;
+/**
+ * Atomically increments the stored failure count and decides `isOpen` in one
+ * round trip: GET -> decode -> increment -> compute isOpen -> SET, all inside
+ * Redis's single-threaded script execution, so two instances failing at the
+ * same instant cannot race and lose an increment. Used by the `'consecutive'`
+ * strategy.
+ */
+const RECORD_FAILURE_SCRIPT = `
+local raw = redis.call('GET', KEYS[1])
+local failures = 0
+local openCount = 0
+local errorRate = 0
+local sampleCount = 0
+if raw then
+  local ok, decoded = pcall(cjson.decode, raw)
+  if ok and decoded then
+    failures = tonumber(decoded.failures) or 0
+    openCount = tonumber(decoded.openCount) or 0
+    errorRate = tonumber(decoded.errorRate) or 0
+    sampleCount = tonumber(decoded.sampleCount) or 0
+  end
+end
+failures = failures + 1
+local threshold = tonumber(ARGV[2])
+local state = {
+  failures = failures,
+  lastFailure = tonumber(ARGV[3]),
+  isOpen = failures >= threshold,
+  openCount = openCount,
+  errorRate = errorRate,
+  sampleCount = sampleCount
+}
+redis.call('SET', KEYS[1], cjson.encode(state), 'EX', tonumber(ARGV[1]))
+return cjson.encode(state)
+`;
+/**
+ * Atomically folds one call's outcome into an EWMA failure-rate estimate and
+ * decides `isOpen` in one round trip. Used by the `'errorRate'` strategy;
+ * called on every closed-phase call, not just failures. Also reports
+ * whether this specific call is what tripped the breaker (`openedNow`), so
+ * the caller can fire `onStateChange` exactly once per transition without a
+ * separate read.
+ */
+const RECORD_OUTCOME_SCRIPT = `
+local raw = redis.call('GET', KEYS[1])
+local failures = 0
+local openCount = 0
+local errorRate = 0
+local sampleCount = 0
+local wasOpen = false
+if raw then
+  local ok, decoded = pcall(cjson.decode, raw)
+  if ok and decoded then
+    failures = tonumber(decoded.failures) or 0
+    openCount = tonumber(decoded.openCount) or 0
+    errorRate = tonumber(decoded.errorRate) or 0
+    sampleCount = tonumber(decoded.sampleCount) or 0
+    wasOpen = decoded.isOpen or false
+  end
+end
+local decay = tonumber(ARGV[1])
+local isFailure = tonumber(ARGV[2])
+local minimumCalls = tonumber(ARGV[3])
+local threshold = tonumber(ARGV[4])
+local ttlSeconds = tonumber(ARGV[5])
+local now = tonumber(ARGV[6])
+
+errorRate = errorRate * decay + isFailure * (1 - decay)
+sampleCount = sampleCount + 1
+local isOpen = (sampleCount >= minimumCalls) and (errorRate >= threshold)
+
+local state = {
+  failures = failures,
+  lastFailure = now,
+  isOpen = isOpen,
+  openCount = openCount,
+  errorRate = errorRate,
+  sampleCount = sampleCount
+}
+redis.call('SET', KEYS[1], cjson.encode(state), 'EX', ttlSeconds)
+
+local result = {}
+for k, v in pairs(state) do result[k] = v end
+result.openedNow = isOpen and not wasOpen
+return cjson.encode(result)
+`;
+/**
+ * Redis-backed Store implementation. Import this from
+ * `redeye/redis-store` so the core package has no hard dependency on
+ * `ioredis` — only consumers who use RedisStore need it installed.
+ *
+ * Implements all three optional atomic capabilities (`recordFailureAtomic`
+ * and `recordOutcomeAtomic` via Lua scripts, `claimTrial` via `SET ... NX`),
+ * so breakers backed by RedisStore get exact counting and real single-trial
+ * half-open behavior under both strategies instead of best-effort fallbacks.
+ */
+class RedisStore {
+    constructor(redis, options = {}) {
+        this.redis = redis;
+        this.prefix = options.keyPrefix ?? '';
+    }
+    async get(key) {
+        const raw = await this.redis.get(this.prefix + key);
+        if (raw === null)
+            return null;
+        return JSON.parse(raw);
+    }
+    async set(key, value, ttlSeconds) {
+        await this.redis.set(this.prefix + key, JSON.stringify(value), 'EX', Math.max(1, Math.ceil(ttlSeconds)));
+    }
+    async del(key) {
+        await this.redis.del(this.prefix + key);
+    }
+    async recordFailureAtomic(key, opts) {
+        const raw = (await this.redis.eval(RECORD_FAILURE_SCRIPT, 1, this.prefix + key, Math.max(1, Math.ceil(opts.ttlSeconds)), opts.failureThreshold, opts.now));
+        return JSON.parse(raw);
+    }
+    async recordOutcomeAtomic(key, opts) {
+        const raw = (await this.redis.eval(RECORD_OUTCOME_SCRIPT, 1, this.prefix + key, opts.decay, opts.success ? 0 : 1, opts.minimumCalls, opts.errorRateThreshold, Math.max(1, Math.ceil(opts.ttlSeconds)), opts.now));
+        return JSON.parse(raw);
+    }
+    async claimTrial(key, ttlSeconds) {
+        const result = await this.redis.set(this.prefix + key, '1', 'EX', Math.max(1, Math.ceil(ttlSeconds)), 'NX');
+        return result === 'OK';
+    }
+}
+exports.RedisStore = RedisStore;
+//# sourceMappingURL=redis-store.js.map

package/dist/stores/redis-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-store.js","sourceRoot":"","sources":["../../src/stores/redis-store.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+export interface CircuitBreakerState {
+    failures: number;
+    lastFailure: number;
+    isOpen: boolean;
+    /** Number of consecutive times a half-open trial has failed since the breaker last fully closed. Drives backoff growth. */
+    openCount: number;
+    /** `errorRate` strategy only: current EWMA estimate of the failure rate, 0-1. */
+    errorRate: number;
+    /** `errorRate` strategy only: number of calls folded into `errorRate` since the breaker last fully closed. */
+    sampleCount: number;
+}
+export interface CircuitMetrics {
+    totalCalls: number;
+    totalSuccesses: number;
+    totalFailures: number;
+    /** Calls rejected without invoking the wrapped function because the breaker was open. */
+    totalRejections: number;
+    /** Distributed mode only: store read/write failures encountered. */
+    totalStoreErrors: number;
+}
+export declare const CLOSED_STATE: CircuitBreakerState;
+export declare const emptyMetrics: () => CircuitMetrics;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,2HAA2H;IAC3H,SAAS,EAAE,MAAM,CAAC;IAClB,iFAAiF;IACjF,SAAS,EAAE,MAAM,CAAC;IAClB,8GAA8G;IAC9G,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,yFAAyF;IACzF,eAAe,EAAE,MAAM,CAAC;IACxB,oEAAoE;IACpE,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,YAAY,EAAE,mBAO1B,CAAC;AAEF,eAAO,MAAM,YAAY,QAAO,cAM9B,CAAC"}

package/dist/types.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyMetrics = exports.CLOSED_STATE = void 0;
+exports.CLOSED_STATE = {
+    failures: 0,
+    lastFailure: 0,
+    isOpen: false,
+    openCount: 0,
+    errorRate: 0,
+    sampleCount: 0,
+};
+const emptyMetrics = () => ({
+    totalCalls: 0,
+    totalSuccesses: 0,
+    totalFailures: 0,
+    totalRejections: 0,
+    totalStoreErrors: 0,
+});
+exports.emptyMetrics = emptyMetrics;
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;AAsBa,QAAA,YAAY,GAAwB;IAC/C,QAAQ,EAAE,CAAC;IACX,WAAW,EAAE,CAAC;IACd,MAAM,EAAE,KAAK;IACb,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,CAAC;IACZ,WAAW,EAAE,CAAC;CACf,CAAC;AAEK,MAAM,YAAY,GAAG,GAAmB,EAAE,CAAC,CAAC;IACjD,UAAU,EAAE,CAAC;IACb,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,CAAC;IAChB,eAAe,EAAE,CAAC;IAClB,gBAAgB,EAAE,CAAC;CACpB,CAAC,CAAC;AANU,QAAA,YAAY,gBAMtB"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "redeye-breaker",
+  "version": "0.1.0",
+  "description": "A circuit breaker for Node.js with an optional Redis-backed distributed mode, so breaker state can be shared across multiple app instances instead of being tracked per-process.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./redis-store": {
+      "types": "./dist/stores/redis-store.d.ts",
+      "default": "./dist/stores/redis-store.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "redis-store": ["dist/stores/redis-store.d.ts"]
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "jest",
+    "test:integration": "jest --config jest.integration.config.js",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run lint && npm run test && npm run build"
+  },
+  "keywords": [
+    "circuit-breaker",
+    "resilience",
+    "redis",
+    "distributed-systems",
+    "fault-tolerance",
+    "microservices"
+  ],
+  "author": "Laurels Echichinwo",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/laurells/redeye.git"
+  },
+  "bugs": {
+    "url": "https://github.com/laurells/redeye/issues"
+  },
+  "homepage": "https://github.com/laurells/redeye#readme",
+  "peerDependencies": {
+    "ioredis": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "ioredis": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.0",
+    "ioredis": "^5.4.1",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.4.5"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}