@revealui/core 0.2.1 → 0.5.0

package/dist/error-handling/circuit-breaker.js

@@ -1,542 +0,0 @@
-/**
- * Circuit Breaker Pattern
- *
- * Prevents cascading failures by stopping requests to failing services
- */
-import { logger } from '../observability/logger.js';
-const DEFAULT_CONFIG = {
-    failureThreshold: 5,
-    successThreshold: 2,
-    timeout: 60000,
-    resetTimeout: 30000,
-    volumeThreshold: 10,
-    errorFilter: () => true,
-    onStateChange: () => { },
-    onTrip: () => { },
-    onReset: () => { },
-};
-/**
- * Circuit Breaker implementation
- */
-export class CircuitBreaker {
-    state = 'closed';
-    failures = 0;
-    successes = 0;
-    consecutiveFailures = 0;
-    consecutiveSuccesses = 0;
-    totalCalls = 0;
-    totalFailures = 0;
-    totalSuccesses = 0;
-    lastFailureTime;
-    lastSuccessTime;
-    stateChangedAt = Date.now();
-    resetTimer;
-    config;
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    /**
-     * Execute function with circuit breaker
-     */
-    async execute(fn) {
-        // Check if circuit is open
-        if (this.state === 'open') {
-            // Check if reset timeout has passed
-            if (Date.now() - this.stateChangedAt >= this.config.resetTimeout) {
-                this.transitionTo('half-open');
-            }
-            else {
-                throw new CircuitBreakerOpenError('Circuit breaker is open');
-            }
-        }
-        this.totalCalls++;
-        try {
-            const result = await fn();
-            this.onSuccess();
-            return result;
-        }
-        catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            this.onFailure(err);
-            throw error;
-        }
-    }
-    /**
-     * Handle successful execution
-     */
-    onSuccess() {
-        this.successes++;
-        this.consecutiveSuccesses++;
-        this.totalSuccesses++;
-        this.consecutiveFailures = 0;
-        this.lastSuccessTime = Date.now();
-        if (this.state === 'half-open') {
-            // Check if we can close the circuit
-            if (this.consecutiveSuccesses >= this.config.successThreshold) {
-                this.transitionTo('closed');
-            }
-        }
-        // Reset failure count in closed state
-        if (this.state === 'closed') {
-            this.failures = 0;
-        }
-    }
-    /**
-     * Handle failed execution
-     */
-    onFailure(error) {
-        // Check if error should count
-        if (!this.config.errorFilter(error)) {
-            return;
-        }
-        this.failures++;
-        this.consecutiveFailures++;
-        this.totalFailures++;
-        this.consecutiveSuccesses = 0;
-        this.lastFailureTime = Date.now();
-        if (this.state === 'half-open') {
-            // Immediately open circuit on failure in half-open state
-            this.transitionTo('open');
-        }
-        else if (this.state === 'closed') {
-            // Check if we should open the circuit
-            if (this.consecutiveFailures >= this.config.failureThreshold &&
-                this.totalCalls >= this.config.volumeThreshold) {
-                this.transitionTo('open');
-            }
-        }
-    }
-    /**
-     * Transition to new state
-     */
-    transitionTo(newState) {
-        if (this.state === newState)
-            return;
-        const oldState = this.state;
-        this.state = newState;
-        this.stateChangedAt = Date.now();
-        // Reset counters
-        if (newState === 'half-open' || newState === 'closed') {
-            this.consecutiveFailures = 0;
-            this.consecutiveSuccesses = 0;
-        }
-        // Clear reset timer
-        if (this.resetTimer) {
-            clearTimeout(this.resetTimer);
-            this.resetTimer = undefined;
-        }
-        // Set reset timer for open state
-        if (newState === 'open') {
-            this.resetTimer = setTimeout(() => {
-                this.transitionTo('half-open');
-            }, this.config.resetTimeout);
-            this.config.onTrip();
-        }
-        // Circuit reset
-        if (newState === 'closed' && oldState === 'half-open') {
-            this.failures = 0;
-            this.config.onReset();
-        }
-        this.config.onStateChange(newState);
-        logger.info(`Circuit breaker state changed: ${oldState} -> ${newState}`, this.getStats());
-    }
-    /**
-     * Get current state
-     */
-    getState() {
-        return this.state;
-    }
-    /**
-     * Get statistics
-     */
-    getStats() {
-        return {
-            state: this.state,
-            failures: this.failures,
-            successes: this.successes,
-            consecutiveFailures: this.consecutiveFailures,
-            consecutiveSuccesses: this.consecutiveSuccesses,
-            totalCalls: this.totalCalls,
-            totalFailures: this.totalFailures,
-            totalSuccesses: this.totalSuccesses,
-            lastFailureTime: this.lastFailureTime,
-            lastSuccessTime: this.lastSuccessTime,
-            stateChangedAt: this.stateChangedAt,
-        };
-    }
-    /**
-     * Manually open circuit
-     */
-    trip() {
-        this.transitionTo('open');
-    }
-    /**
-     * Manually close circuit
-     */
-    reset() {
-        this.failures = 0;
-        this.successes = 0;
-        this.consecutiveFailures = 0;
-        this.consecutiveSuccesses = 0;
-        this.transitionTo('closed');
-    }
-    /**
-     * Force state to half-open
-     */
-    halfOpen() {
-        this.transitionTo('half-open');
-    }
-    /**
-     * Check if circuit is open
-     */
-    isOpen() {
-        return this.state === 'open';
-    }
-    /**
-     * Check if circuit is closed
-     */
-    isClosed() {
-        return this.state === 'closed';
-    }
-    /**
-     * Check if circuit is half-open
-     */
-    isHalfOpen() {
-        return this.state === 'half-open';
-    }
-    /**
-     * Get failure rate
-     */
-    getFailureRate() {
-        if (this.totalCalls === 0)
-            return 0;
-        return this.totalFailures / this.totalCalls;
-    }
-    /**
-     * Get success rate
-     */
-    getSuccessRate() {
-        if (this.totalCalls === 0)
-            return 0;
-        return this.totalSuccesses / this.totalCalls;
-    }
-    /**
-     * Cleanup
-     */
-    destroy() {
-        if (this.resetTimer) {
-            clearTimeout(this.resetTimer);
-        }
-    }
-}
-/**
- * Circuit breaker open error
- */
-export class CircuitBreakerOpenError extends Error {
-    constructor(message = 'Circuit breaker is open') {
-        super(message);
-        this.name = 'CircuitBreakerOpenError';
-    }
-}
-/**
- * Circuit breaker registry
- */
-export class CircuitBreakerRegistry {
-    breakers = new Map();
-    /**
-     * Get or create circuit breaker
-     */
-    get(name, config) {
-        let breaker = this.breakers.get(name);
-        if (!breaker) {
-            breaker = new CircuitBreaker(config);
-            this.breakers.set(name, breaker);
-        }
-        return breaker;
-    }
-    /**
-     * Check if breaker exists
-     */
-    has(name) {
-        return this.breakers.has(name);
-    }
-    /**
-     * Remove circuit breaker
-     */
-    remove(name) {
-        const breaker = this.breakers.get(name);
-        if (breaker) {
-            breaker.destroy();
-            return this.breakers.delete(name);
-        }
-        return false;
-    }
-    /**
-     * Get all breakers
-     */
-    getAll() {
-        return new Map(this.breakers);
-    }
-    /**
-     * Get all statistics
-     */
-    getAllStats() {
-        const stats = {};
-        for (const [name, breaker] of this.breakers) {
-            stats[name] = breaker.getStats();
-        }
-        return stats;
-    }
-    /**
-     * Reset all breakers
-     */
-    resetAll() {
-        for (const breaker of this.breakers.values()) {
-            breaker.reset();
-        }
-    }
-    /**
-     * Clear all breakers
-     */
-    clear() {
-        for (const breaker of this.breakers.values()) {
-            breaker.destroy();
-        }
-        this.breakers.clear();
-    }
-}
-/**
- * Global circuit breaker registry
- */
-export const circuitBreakerRegistry = new CircuitBreakerRegistry();
-/**
- * Create circuit breaker decorator
- */
-export function CircuitBreak(nameOrConfig = {}) {
-    return (target, propertyKey, descriptor) => {
-        const originalMethod = descriptor.value;
-        const name = typeof nameOrConfig === 'string'
-            ? nameOrConfig
-            : `${target.constructor.name}.${propertyKey}`;
-        const config = typeof nameOrConfig === 'object' ? nameOrConfig : undefined;
-        descriptor.value = async function (...args) {
-            const breaker = circuitBreakerRegistry.get(name, config);
-            return breaker.execute(() => originalMethod.apply(this, args));
-        };
-        return descriptor;
-    };
-}
-/**
- * Execute with circuit breaker
- */
-export async function withCircuitBreaker(name, fn, config) {
-    const breaker = circuitBreakerRegistry.get(name, config);
-    return breaker.execute(fn);
-}
-/**
- * Create circuit breaker middleware
- */
-export function createCircuitBreakerMiddleware(name, config) {
-    const breaker = circuitBreakerRegistry.get(name, config);
-    return async (_request, next) => {
-        return breaker.execute(next);
-    };
-}
-/**
- * Circuit breaker for fetch
- */
-export async function fetchWithCircuitBreaker(name, url, init, config) {
-    const breaker = circuitBreakerRegistry.get(name, config);
-    return breaker.execute(async () => {
-        const response = await fetch(url, init);
-        // Treat 5xx errors as failures
-        if (response.status >= 500) {
-            const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
-            error.statusCode = response.status;
-            throw error;
-        }
-        return response;
-    });
-}
-/**
- * Adaptive circuit breaker with dynamic thresholds
- */
-export class AdaptiveCircuitBreaker extends CircuitBreaker {
-    errorRateWindow = [];
-    windowSize = 100;
-    adaptiveThreshold;
-    constructor(config = {}) {
-        super(config);
-        this.adaptiveThreshold = config.failureThreshold || 5;
-    }
-    /**
-     * Execute with adaptive thresholds
-     */
-    async execute(fn) {
-        try {
-            const result = await super.execute(fn);
-            this.recordSuccess();
-            return result;
-        }
-        catch (error) {
-            this.recordFailure();
-            throw error;
-        }
-    }
-    /**
-     * Record success in window
-     */
-    recordSuccess() {
-        this.errorRateWindow.push(0);
-        this.trimWindow();
-        this.adjustThreshold();
-    }
-    /**
-     * Record failure in window
-     */
-    recordFailure() {
-        this.errorRateWindow.push(1);
-        this.trimWindow();
-        this.adjustThreshold();
-    }
-    /**
-     * Trim window to size
-     */
-    trimWindow() {
-        if (this.errorRateWindow.length > this.windowSize) {
-            this.errorRateWindow.shift();
-        }
-    }
-    /**
-     * Adjust threshold based on error rate
-     */
-    adjustThreshold() {
-        const errorRate = this.getWindowErrorRate();
-        // Increase threshold if error rate is low
-        if (errorRate < 0.1) {
-            this.adaptiveThreshold = Math.min(this.adaptiveThreshold + 1, 20);
-        }
-        // Decrease threshold if error rate is high
-        else if (errorRate > 0.5) {
-            this.adaptiveThreshold = Math.max(this.adaptiveThreshold - 1, 2);
-        }
-    }
-    /**
-     * Get error rate in window
-     */
-    getWindowErrorRate() {
-        if (this.errorRateWindow.length === 0)
-            return 0;
-        const errors = this.errorRateWindow.reduce((sum, val) => sum + val, 0);
-        return errors / this.errorRateWindow.length;
-    }
-    /**
-     * Get adaptive threshold
-     */
-    getAdaptiveThreshold() {
-        return this.adaptiveThreshold;
-    }
-}
-/**
- * Bulkhead pattern - limit concurrent executions
- */
-export class Bulkhead {
-    activeRequests = 0;
-    queue = [];
-    maxConcurrent;
-    maxQueue;
-    constructor(maxConcurrent = 10, maxQueue = 100) {
-        this.maxConcurrent = maxConcurrent;
-        this.maxQueue = maxQueue;
-    }
-    /**
-     * Execute with bulkhead
-     */
-    async execute(fn) {
-        // Check if at capacity
-        if (this.activeRequests >= this.maxConcurrent) {
-            // Check queue capacity
-            if (this.queue.length >= this.maxQueue) {
-                throw new Error('Bulkhead queue is full');
-            }
-            // Wait for slot
-            await new Promise((resolve) => {
-                this.queue.push(resolve);
-            });
-        }
-        this.activeRequests++;
-        try {
-            return await fn();
-        }
-        finally {
-            this.activeRequests--;
-            // Process queue
-            const next = this.queue.shift();
-            if (next) {
-                next();
-            }
-        }
-    }
-    /**
-     * Get active requests
-     */
-    getActiveRequests() {
-        return this.activeRequests;
-    }
-    /**
-     * Get queue size
-     */
-    getQueueSize() {
-        return this.queue.length;
-    }
-    /**
-     * Get statistics
-     */
-    getStats() {
-        return {
-            activeRequests: this.activeRequests,
-            queueSize: this.queue.length,
-            maxConcurrent: this.maxConcurrent,
-            maxQueue: this.maxQueue,
-        };
-    }
-}
-/**
- * Combined resilience wrapper
- */
-export class ResilientOperation {
-    fn;
-    circuitBreaker;
-    bulkhead;
-    constructor(fn, circuitBreaker, bulkhead) {
-        this.fn = fn;
-        this.circuitBreaker = circuitBreaker;
-        this.bulkhead = bulkhead;
-    }
-    /**
-     * Execute with all resilience patterns
-     */
-    async execute() {
-        const executeFn = async () => {
-            if (this.bulkhead) {
-                return this.bulkhead.execute(this.fn);
-            }
-            return this.fn();
-        };
-        if (this.circuitBreaker) {
-            return this.circuitBreaker.execute(executeFn);
-        }
-        return executeFn();
-    }
-}
-/**
- * Create resilient function
- */
-export function createResilientFunction(fn, options = {}) {
-    const breaker = options.circuitBreaker ? new CircuitBreaker(options.circuitBreaker) : undefined;
-    const bulkhead = options.bulkhead
-        ? new Bulkhead(options.bulkhead.maxConcurrent, options.bulkhead.maxQueue)
-        : undefined;
-    const operation = new ResilientOperation(fn, breaker, bulkhead);
-    return () => operation.execute();
-}