@hazeljs/resilience 0.2.0-beta.41

package/dist/circuit-breaker/sliding-window.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Sliding Window implementations for Circuit Breaker
+ *
+ * Count-based: tracks the last N calls
+ * Time-based: tracks calls within a rolling time window
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeBasedSlidingWindow = exports.CountBasedSlidingWindow = void 0;
+exports.createSlidingWindow = createSlidingWindow;
+/**
+ * Count-based sliding window
+ * Tracks the last `size` calls regardless of time
+ */
+class CountBasedSlidingWindow {
+    constructor(size) {
+        this.size = size;
+        this.entries = [];
+    }
+    record(success) {
+        this.entries.push(success);
+        if (this.entries.length > this.size) {
+            this.entries.shift();
+        }
+    }
+    getResult() {
+        const total = this.entries.length;
+        if (total === 0) {
+            return { totalCalls: 0, failureCount: 0, failureRate: 0 };
+        }
+        const failures = this.entries.filter((s) => !s).length;
+        return {
+            totalCalls: total,
+            failureCount: failures,
+            failureRate: (failures / total) * 100,
+        };
+    }
+    reset() {
+        this.entries = [];
+    }
+}
+exports.CountBasedSlidingWindow = CountBasedSlidingWindow;
+/**
+ * Time-based sliding window
+ * Tracks calls within a rolling time window of `sizeMs` milliseconds
+ */
+class TimeBasedSlidingWindow {
+    constructor(sizeMs) {
+        this.sizeMs = sizeMs;
+        this.entries = [];
+    }
+    record(success) {
+        this.entries.push({ timestamp: Date.now(), success });
+        this.evict();
+    }
+    getResult() {
+        this.evict();
+        const total = this.entries.length;
+        if (total === 0) {
+            return { totalCalls: 0, failureCount: 0, failureRate: 0 };
+        }
+        const failures = this.entries.filter((e) => !e.success).length;
+        return {
+            totalCalls: total,
+            failureCount: failures,
+            failureRate: (failures / total) * 100,
+        };
+    }
+    reset() {
+        this.entries = [];
+    }
+    evict() {
+        const cutoff = Date.now() - this.sizeMs;
+        let i = 0;
+        while (i < this.entries.length && this.entries[i].timestamp < cutoff) {
+            i++;
+        }
+        if (i > 0) {
+            this.entries = this.entries.slice(i);
+        }
+    }
+}
+exports.TimeBasedSlidingWindow = TimeBasedSlidingWindow;
+/**
+ * Factory to create the appropriate sliding window
+ */
+function createSlidingWindow(type, size) {
+    return type === 'count' ? new CountBasedSlidingWindow(size) : new TimeBasedSlidingWindow(size);
+}

package/dist/decorators/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Resilience Decorators
+ * Decorator-based API consistent with HazelJS philosophy.
+ *
+ * Decorators compose in the order they are declared (outermost first).
+ * Example:
+ *   @CircuitBreaker(...)   <-- outermost wrapper
+ *   @Retry(...)            <-- wraps the timeout
+ *   @Timeout(5000)         <-- wraps the bulkhead
+ *   @Bulkhead(...)         <-- innermost wrapper around the original fn
+ */
+import 'reflect-metadata';
+import { CircuitBreakerConfig, RetryConfig, BulkheadConfig, RateLimiterConfig } from '../types';
+/**
+ * @CircuitBreaker decorator
+ * Wraps a method with circuit breaker protection.
+ */
+export declare function CircuitBreaker(config?: Partial<CircuitBreakerConfig>): MethodDecorator;
+/**
+ * @Retry decorator
+ * Wraps a method with retry logic.
+ */
+export declare function Retry(config?: Partial<RetryConfig>): MethodDecorator;
+/**
+ * @Timeout decorator
+ * Wraps a method with a timeout.
+ */
+export declare function Timeout(durationOrConfig: number | {
+    duration: number;
+    message?: string;
+}): MethodDecorator;
+/**
+ * @Bulkhead decorator
+ * Limits concurrent executions of a method.
+ */
+export declare function Bulkhead(config: BulkheadConfig): MethodDecorator;
+/**
+ * @Fallback decorator
+ * Marks a method as the fallback for a specified primary method.
+ *
+ * Usage:
+ *   @Fallback('processPayment')
+ *   async processPaymentFallback(...) { }
+ */
+export declare function Fallback(primaryMethodName: string): MethodDecorator;
+/**
+ * @RateLimit decorator
+ * Rate limits a method.
+ */
+export declare function RateLimit(config: RateLimiterConfig): MethodDecorator;
+//# sourceMappingURL=index.d.ts.map

package/dist/decorators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/decorators/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,kBAAkB,CAAC;AAM1B,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAKhG;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,GAAG,eAAe,CAyCtF;AAED;;;GAGG;AACH,wBAAgB,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,eAAe,CAWpE;AAED;;;GAGG;AACH,wBAAgB,OAAO,CACrB,gBAAgB,EAAE,MAAM,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAChE,eAAe,CAajB;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,eAAe,CAWhE;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,iBAAiB,EAAE,MAAM,GAAG,eAAe,CAMnE;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,iBAAiB,GAAG,eAAe,CAWpE"}

package/dist/decorators/index.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * Resilience Decorators
+ * Decorator-based API consistent with HazelJS philosophy.
+ *
+ * Decorators compose in the order they are declared (outermost first).
+ * Example:
+ *   @CircuitBreaker(...)   <-- outermost wrapper
+ *   @Retry(...)            <-- wraps the timeout
+ *   @Timeout(5000)         <-- wraps the bulkhead
+ *   @Bulkhead(...)         <-- innermost wrapper around the original fn
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreaker = CircuitBreaker;
+exports.Retry = Retry;
+exports.Timeout = Timeout;
+exports.Bulkhead = Bulkhead;
+exports.Fallback = Fallback;
+exports.RateLimit = RateLimit;
+require("reflect-metadata");
+const circuit_breaker_registry_1 = require("../circuit-breaker/circuit-breaker-registry");
+const retry_policy_1 = require("../retry/retry-policy");
+const timeout_1 = require("../timeout/timeout");
+const bulkhead_1 = require("../bulkhead/bulkhead");
+const rate_limiter_1 = require("../rate-limiter/rate-limiter");
+// Metadata keys
+const FALLBACK_KEY = Symbol('resilience:fallback');
+/**
+ * @CircuitBreaker decorator
+ * Wraps a method with circuit breaker protection.
+ */
+function CircuitBreaker(config) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const breakerName = `${target.constructor.name}.${String(propertyKey)}`;
+        descriptor.value = async function (...args) {
+            const breaker = circuit_breaker_registry_1.CircuitBreakerRegistry.getOrCreate(breakerName, config);
+            try {
+                return await breaker.execute(() => originalMethod.apply(this, args));
+            }
+            catch (error) {
+                // If there's a fallback configured, try it
+                if (config?.fallback) {
+                    const fallbackMethod = this[config.fallback];
+                    if (typeof fallbackMethod === 'function') {
+                        return fallbackMethod.apply(this, args);
+                    }
+                }
+                // Check for decorator-based fallback
+                const fallbackName = Reflect.getMetadata(FALLBACK_KEY, target, propertyKey);
+                if (fallbackName) {
+                    const fallbackMethod = this[fallbackName];
+                    if (typeof fallbackMethod === 'function') {
+                        return fallbackMethod.apply(this, args);
+                    }
+                }
+                throw error;
+            }
+        };
+        return descriptor;
+    };
+}
+/**
+ * @Retry decorator
+ * Wraps a method with retry logic.
+ */
+function Retry(config) {
+    return function (_target, _propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const retryPolicy = new retry_policy_1.RetryPolicy(config);
+        descriptor.value = async function (...args) {
+            return retryPolicy.execute(() => originalMethod.apply(this, args));
+        };
+        return descriptor;
+    };
+}
+/**
+ * @Timeout decorator
+ * Wraps a method with a timeout.
+ */
+function Timeout(durationOrConfig) {
+    return function (_target, _propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const timeout = new timeout_1.Timeout(typeof durationOrConfig === 'number' ? durationOrConfig : durationOrConfig);
+        descriptor.value = async function (...args) {
+            return timeout.execute(() => originalMethod.apply(this, args));
+        };
+        return descriptor;
+    };
+}
+/**
+ * @Bulkhead decorator
+ * Limits concurrent executions of a method.
+ */
+function Bulkhead(config) {
+    return function (_target, _propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const bulkhead = new bulkhead_1.Bulkhead(config);
+        descriptor.value = async function (...args) {
+            return bulkhead.execute(() => originalMethod.apply(this, args));
+        };
+        return descriptor;
+    };
+}
+/**
+ * @Fallback decorator
+ * Marks a method as the fallback for a specified primary method.
+ *
+ * Usage:
+ *   @Fallback('processPayment')
+ *   async processPaymentFallback(...) { }
+ */
+function Fallback(primaryMethodName) {
+    return function (target, propertyKey, descriptor) {
+        // Store the fallback mapping on the primary method
+        Reflect.defineMetadata(FALLBACK_KEY, String(propertyKey), target, primaryMethodName);
+        return descriptor;
+    };
+}
+/**
+ * @RateLimit decorator
+ * Rate limits a method.
+ */
+function RateLimit(config) {
+    return function (_target, _propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const limiter = new rate_limiter_1.RateLimiter(config);
+        descriptor.value = async function (...args) {
+            return limiter.execute(() => originalMethod.apply(this, args));
+        };
+        return descriptor;
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @hazeljs/resilience
+ * Fault-tolerance and resilience patterns for HazelJS
+ *
+ * Provides circuit breaker, retry, timeout, bulkhead, rate limiter,
+ * and metrics collection — all usable via decorators or programmatic API.
+ */
+export { CircuitState, CircuitBreakerConfig, CircuitBreakerMetrics, CircuitBreakerError, SlidingWindowConfig, RetryConfig, BackoffStrategy, RetryExhaustedError, TimeoutConfig, TimeoutError, BulkheadConfig, BulkheadMetrics, BulkheadError, RateLimiterConfig, RateLimiterStrategy, RateLimitError, MetricsSnapshot, MetricsEntry, ResilienceError, } from './types';
+export { CircuitBreaker } from './circuit-breaker/circuit-breaker';
+export { CircuitBreakerRegistry } from './circuit-breaker/circuit-breaker-registry';
+export { SlidingWindow, CountBasedSlidingWindow, TimeBasedSlidingWindow, createSlidingWindow, } from './circuit-breaker/sliding-window';
+export { RetryPolicy } from './retry/retry-policy';
+export { Timeout, withTimeout } from './timeout/timeout';
+export { Bulkhead } from './bulkhead/bulkhead';
+export { RateLimiter, TokenBucketLimiter, SlidingWindowLimiter } from './rate-limiter/rate-limiter';
+export { MetricsCollector, MetricsRegistry } from './metrics/metrics-collector';
+export { CircuitBreaker as WithCircuitBreaker, Retry as WithRetry, Timeout as WithTimeout, Bulkhead as WithBulkhead, Fallback, RateLimit as WithRateLimit, } from './decorators';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,WAAW,EACX,eAAe,EACf,mBAAmB,EACnB,aAAa,EACb,YAAY,EACZ,cAAc,EACd,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,eAAe,EACf,YAAY,EACZ,eAAe,GAChB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AACpF,OAAO,EACL,aAAa,EACb,uBAAuB,EACvB,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAGnD,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGzD,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAG/C,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAGpG,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAGhF,OAAO,EACL,cAAc,IAAI,kBAAkB,EACpC,KAAK,IAAI,SAAS,EAClB,OAAO,IAAI,WAAW,EACtB,QAAQ,IAAI,YAAY,EACxB,QAAQ,EACR,SAAS,IAAI,aAAa,GAC3B,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * @hazeljs/resilience
+ * Fault-tolerance and resilience patterns for HazelJS
+ *
+ * Provides circuit breaker, retry, timeout, bulkhead, rate limiter,
+ * and metrics collection — all usable via decorators or programmatic API.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithRateLimit = exports.Fallback = exports.WithBulkhead = exports.WithTimeout = exports.WithRetry = exports.WithCircuitBreaker = exports.MetricsRegistry = exports.MetricsCollector = exports.SlidingWindowLimiter = exports.TokenBucketLimiter = exports.RateLimiter = exports.Bulkhead = exports.withTimeout = exports.Timeout = exports.RetryPolicy = exports.createSlidingWindow = exports.TimeBasedSlidingWindow = exports.CountBasedSlidingWindow = exports.CircuitBreakerRegistry = exports.CircuitBreaker = exports.ResilienceError = exports.RateLimitError = exports.BulkheadError = exports.TimeoutError = exports.RetryExhaustedError = exports.CircuitBreakerError = exports.CircuitState = void 0;
+// Types & Errors
+var types_1 = require("./types");
+Object.defineProperty(exports, "CircuitState", { enumerable: true, get: function () { return types_1.CircuitState; } });
+Object.defineProperty(exports, "CircuitBreakerError", { enumerable: true, get: function () { return types_1.CircuitBreakerError; } });
+Object.defineProperty(exports, "RetryExhaustedError", { enumerable: true, get: function () { return types_1.RetryExhaustedError; } });
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return types_1.TimeoutError; } });
+Object.defineProperty(exports, "BulkheadError", { enumerable: true, get: function () { return types_1.BulkheadError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return types_1.RateLimitError; } });
+Object.defineProperty(exports, "ResilienceError", { enumerable: true, get: function () { return types_1.ResilienceError; } });
+// Circuit Breaker
+var circuit_breaker_1 = require("./circuit-breaker/circuit-breaker");
+Object.defineProperty(exports, "CircuitBreaker", { enumerable: true, get: function () { return circuit_breaker_1.CircuitBreaker; } });
+var circuit_breaker_registry_1 = require("./circuit-breaker/circuit-breaker-registry");
+Object.defineProperty(exports, "CircuitBreakerRegistry", { enumerable: true, get: function () { return circuit_breaker_registry_1.CircuitBreakerRegistry; } });
+var sliding_window_1 = require("./circuit-breaker/sliding-window");
+Object.defineProperty(exports, "CountBasedSlidingWindow", { enumerable: true, get: function () { return sliding_window_1.CountBasedSlidingWindow; } });
+Object.defineProperty(exports, "TimeBasedSlidingWindow", { enumerable: true, get: function () { return sliding_window_1.TimeBasedSlidingWindow; } });
+Object.defineProperty(exports, "createSlidingWindow", { enumerable: true, get: function () { return sliding_window_1.createSlidingWindow; } });
+// Retry
+var retry_policy_1 = require("./retry/retry-policy");
+Object.defineProperty(exports, "RetryPolicy", { enumerable: true, get: function () { return retry_policy_1.RetryPolicy; } });
+// Timeout
+var timeout_1 = require("./timeout/timeout");
+Object.defineProperty(exports, "Timeout", { enumerable: true, get: function () { return timeout_1.Timeout; } });
+Object.defineProperty(exports, "withTimeout", { enumerable: true, get: function () { return timeout_1.withTimeout; } });
+// Bulkhead
+var bulkhead_1 = require("./bulkhead/bulkhead");
+Object.defineProperty(exports, "Bulkhead", { enumerable: true, get: function () { return bulkhead_1.Bulkhead; } });
+// Rate Limiter
+var rate_limiter_1 = require("./rate-limiter/rate-limiter");
+Object.defineProperty(exports, "RateLimiter", { enumerable: true, get: function () { return rate_limiter_1.RateLimiter; } });
+Object.defineProperty(exports, "TokenBucketLimiter", { enumerable: true, get: function () { return rate_limiter_1.TokenBucketLimiter; } });
+Object.defineProperty(exports, "SlidingWindowLimiter", { enumerable: true, get: function () { return rate_limiter_1.SlidingWindowLimiter; } });
+// Metrics
+var metrics_collector_1 = require("./metrics/metrics-collector");
+Object.defineProperty(exports, "MetricsCollector", { enumerable: true, get: function () { return metrics_collector_1.MetricsCollector; } });
+Object.defineProperty(exports, "MetricsRegistry", { enumerable: true, get: function () { return metrics_collector_1.MetricsRegistry; } });
+// Decorators (re-exported with decorator-friendly names)
+var decorators_1 = require("./decorators");
+Object.defineProperty(exports, "WithCircuitBreaker", { enumerable: true, get: function () { return decorators_1.CircuitBreaker; } });
+Object.defineProperty(exports, "WithRetry", { enumerable: true, get: function () { return decorators_1.Retry; } });
+Object.defineProperty(exports, "WithTimeout", { enumerable: true, get: function () { return decorators_1.Timeout; } });
+Object.defineProperty(exports, "WithBulkhead", { enumerable: true, get: function () { return decorators_1.Bulkhead; } });
+Object.defineProperty(exports, "Fallback", { enumerable: true, get: function () { return decorators_1.Fallback; } });
+Object.defineProperty(exports, "WithRateLimit", { enumerable: true, get: function () { return decorators_1.RateLimit; } });

package/dist/metrics/metrics-collector.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Metrics Collector
+ * Tracks success/failure/latency per target. Used internally by circuit breakers
+ * and exposed to the gateway for canary deployment decisions.
+ */
+import { MetricsSnapshot } from '../types';
+export declare class MetricsCollector {
+    private entries;
+    private windowMs;
+    constructor(windowMs?: number);
+    /**
+     * Record a successful call
+     */
+    recordSuccess(duration: number): void;
+    /**
+     * Record a failed call
+     */
+    recordFailure(duration: number, error?: string): void;
+    /**
+     * Get a snapshot of current metrics within the sliding window
+     */
+    getSnapshot(): MetricsSnapshot;
+    /**
+     * Get the current failure rate as a percentage (0-100)
+     */
+    getFailureRate(): number;
+    /**
+     * Get the number of entries in the current window
+     */
+    getCallCount(): number;
+    /**
+     * Get failure count in the current window
+     */
+    getFailureCount(): number;
+    /**
+     * Get success count in the current window
+     */
+    getSuccessCount(): number;
+    /**
+     * Reset all metrics
+     */
+    reset(): void;
+    /**
+     * Set the window duration
+     */
+    setWindow(windowMs: number): void;
+    /**
+     * Evict entries outside the sliding window
+     */
+    private evict;
+    /**
+     * Calculate percentile from sorted array
+     */
+    private percentile;
+}
+/**
+ * Global registry of metrics collectors, keyed by name
+ */
+export declare class MetricsRegistry {
+    private static collectors;
+    static getOrCreate(name: string, windowMs?: number): MetricsCollector;
+    static get(name: string): MetricsCollector | undefined;
+    static getAll(): Map<string, MetricsCollector>;
+    static remove(name: string): boolean;
+    static clear(): void;
+    static getSnapshot(name: string): MetricsSnapshot | undefined;
+    static getAllSnapshots(): Record<string, MetricsSnapshot>;
+}
+//# sourceMappingURL=metrics-collector.d.ts.map

package/dist/metrics/metrics-collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics-collector.d.ts","sourceRoot":"","sources":["../../src/metrics/metrics-collector.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAgB,eAAe,EAAE,MAAM,UAAU,CAAC;AAEzD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,QAAQ,CAAS;gBAEb,QAAQ,GAAE,MAAe;IAIrC;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IASrC;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAUrD;;OAEG;IACH,WAAW,IAAI,eAAe;IAuC9B;;OAEG;IACH,cAAc,IAAI,MAAM;IAOxB;;OAEG;IACH,YAAY,IAAI,MAAM;IAKtB;;OAEG;IACH,eAAe,IAAI,MAAM;IAKzB;;OAEG;IACH,eAAe,IAAI,MAAM;IAKzB;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAKjC;;OAEG;IACH,OAAO,CAAC,KAAK;IAYb;;OAEG;IACH,OAAO,CAAC,UAAU;CAKnB;AAED;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAC,UAAU,CAAuC;IAEhE,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,gBAAgB;IASrE,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAItD,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAI9C,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIpC,MAAM,CAAC,KAAK,IAAI,IAAI;IAIpB,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAI7D,MAAM,CAAC,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC;CAO1D"}

package/dist/metrics/metrics-collector.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * Metrics Collector
+ * Tracks success/failure/latency per target. Used internally by circuit breakers
+ * and exposed to the gateway for canary deployment decisions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsRegistry = exports.MetricsCollector = void 0;
+class MetricsCollector {
+    constructor(windowMs = 60000) {
+        this.entries = [];
+        this.windowMs = windowMs;
+    }
+    /**
+     * Record a successful call
+     */
+    recordSuccess(duration) {
+        this.entries.push({
+            timestamp: Date.now(),
+            duration,
+            success: true,
+        });
+        this.evict();
+    }
+    /**
+     * Record a failed call
+     */
+    recordFailure(duration, error) {
+        this.entries.push({
+            timestamp: Date.now(),
+            duration,
+            success: false,
+            error,
+        });
+        this.evict();
+    }
+    /**
+     * Get a snapshot of current metrics within the sliding window
+     */
+    getSnapshot() {
+        this.evict();
+        const entries = this.entries;
+        const total = entries.length;
+        if (total === 0) {
+            return {
+                totalCalls: 0,
+                successCalls: 0,
+                failureCalls: 0,
+                failureRate: 0,
+                averageResponseTime: 0,
+                p50ResponseTime: 0,
+                p95ResponseTime: 0,
+                p99ResponseTime: 0,
+                minResponseTime: 0,
+                maxResponseTime: 0,
+            };
+        }
+        const successes = entries.filter((e) => e.success).length;
+        const failures = total - successes;
+        const durations = entries.map((e) => e.duration).sort((a, b) => a - b);
+        return {
+            totalCalls: total,
+            successCalls: successes,
+            failureCalls: failures,
+            failureRate: total > 0 ? (failures / total) * 100 : 0,
+            averageResponseTime: durations.reduce((a, b) => a + b, 0) / total,
+            p50ResponseTime: this.percentile(durations, 50),
+            p95ResponseTime: this.percentile(durations, 95),
+            p99ResponseTime: this.percentile(durations, 99),
+            minResponseTime: durations[0],
+            maxResponseTime: durations[durations.length - 1],
+            lastCallTime: entries[entries.length - 1]?.timestamp,
+        };
+    }
+    /**
+     * Get the current failure rate as a percentage (0-100)
+     */
+    getFailureRate() {
+        this.evict();
+        if (this.entries.length === 0)
+            return 0;
+        const failures = this.entries.filter((e) => !e.success).length;
+        return (failures / this.entries.length) * 100;
+    }
+    /**
+     * Get the number of entries in the current window
+     */
+    getCallCount() {
+        this.evict();
+        return this.entries.length;
+    }
+    /**
+     * Get failure count in the current window
+     */
+    getFailureCount() {
+        this.evict();
+        return this.entries.filter((e) => !e.success).length;
+    }
+    /**
+     * Get success count in the current window
+     */
+    getSuccessCount() {
+        this.evict();
+        return this.entries.filter((e) => e.success).length;
+    }
+    /**
+     * Reset all metrics
+     */
+    reset() {
+        this.entries = [];
+    }
+    /**
+     * Set the window duration
+     */
+    setWindow(windowMs) {
+        this.windowMs = windowMs;
+        this.evict();
+    }
+    /**
+     * Evict entries outside the sliding window
+     */
+    evict() {
+        const cutoff = Date.now() - this.windowMs;
+        // Find first entry within window using binary-ish scan
+        let i = 0;
+        while (i < this.entries.length && this.entries[i].timestamp < cutoff) {
+            i++;
+        }
+        if (i > 0) {
+            this.entries = this.entries.slice(i);
+        }
+    }
+    /**
+     * Calculate percentile from sorted array
+     */
+    percentile(sorted, p) {
+        if (sorted.length === 0)
+            return 0;
+        const index = Math.ceil((p / 100) * sorted.length) - 1;
+        return sorted[Math.max(0, index)];
+    }
+}
+exports.MetricsCollector = MetricsCollector;
+/**
+ * Global registry of metrics collectors, keyed by name
+ */
+class MetricsRegistry {
+    static getOrCreate(name, windowMs) {
+        let collector = this.collectors.get(name);
+        if (!collector) {
+            collector = new MetricsCollector(windowMs);
+            this.collectors.set(name, collector);
+        }
+        return collector;
+    }
+    static get(name) {
+        return this.collectors.get(name);
+    }
+    static getAll() {
+        return new Map(this.collectors);
+    }
+    static remove(name) {
+        return this.collectors.delete(name);
+    }
+    static clear() {
+        this.collectors.clear();
+    }
+    static getSnapshot(name) {
+        return this.collectors.get(name)?.getSnapshot();
+    }
+    static getAllSnapshots() {
+        const snapshots = {};
+        for (const [name, collector] of this.collectors) {
+            snapshots[name] = collector.getSnapshot();
+        }
+        return snapshots;
+    }
+}
+exports.MetricsRegistry = MetricsRegistry;
+MetricsRegistry.collectors = new Map();

package/dist/rate-limiter/rate-limiter.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Rate Limiter
+ * Token bucket and sliding window implementations for rate limiting.
+ */
+import { RateLimiterConfig, RateLimiterStrategy } from '../types';
+/**
+ * Token Bucket Rate Limiter
+ * Allows bursts up to the bucket capacity and refills at a steady rate.
+ */
+export declare class TokenBucketLimiter {
+    private tokens;
+    private lastRefill;
+    private capacity;
+    private refillRate;
+    constructor(capacity: number, refillRatePerSecond: number);
+    /**
+     * Try to consume a token. Returns true if allowed.
+     */
+    tryAcquire(): boolean;
+    /**
+     * Get time in ms until the next token is available
+     */
+    getRetryAfterMs(): number;
+    private refill;
+}
+/**
+ * Sliding Window Counter Rate Limiter
+ * Tracks request counts in small sub-windows for more accurate rate limiting.
+ */
+export declare class SlidingWindowLimiter {
+    private windows;
+    private max;
+    private windowMs;
+    private subWindowMs;
+    constructor(max: number, windowMs: number);
+    /**
+     * Try to record a request. Returns true if within limit.
+     */
+    tryAcquire(): boolean;
+    /**
+     * Get time in ms until a slot opens up
+     */
+    getRetryAfterMs(): number;
+    private getCurrentCount;
+    private getCurrentSubKey;
+    private evict;
+}
+/**
+ * Unified RateLimiter that wraps the configured strategy
+ */
+export declare class RateLimiter {
+    private limiter;
+    private strategy;
+    constructor(config: RateLimiterConfig);
+    /**
+     * Execute a function within rate limit constraints
+     */
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Try to acquire permission (consumes a token/slot)
+     */
+    tryAcquire(): boolean;
+    /**
+     * Get time in ms until the next request is allowed
+     */
+    getRetryAfterMs(): number;
+    /**
+     * Get the strategy in use
+     */
+    getStrategy(): RateLimiterStrategy;
+}
+//# sourceMappingURL=rate-limiter.d.ts.map