okta-mcp-server/dist/infrastructure/circuit-breaker/types.d.ts

Model Context Protocol (MCP) server for Okta API operations with support for bulk operations and caching

/**
 * Circuit Breaker types and interfaces
 */
import { EventEmitter } from 'events';
/**
 * Circuit breaker states
 */
export declare enum CircuitState {
    CLOSED = "CLOSED",// Normal operation, requests pass through
    OPEN = "OPEN",// Circuit is tripped, requests fail fast
    HALF_OPEN = "HALF_OPEN"
}
/**
 * Circuit breaker configuration options
 */
export interface CircuitBreakerOptions {
    /**
     * Number of failures before opening the circuit
     * @default 5
     */
    failureThreshold: number;
    /**
     * Percentage of failures (0-100) before opening the circuit
     * Used in conjunction with volumeThreshold
     * @default 50
     */
    failurePercentageThreshold?: number;
    /**
     * Minimum number of requests in the rolling window before
     * percentage-based failure is calculated
     * @default 10
     */
    volumeThreshold?: number;
    /**
     * Time in milliseconds before attempting to close the circuit
     * @default 60000 (1 minute)
     */
    resetTimeout: number;
    /**
     * Time window in milliseconds for tracking failures
     * @default 60000 (1 minute)
     */
    rollingWindowSize?: number;
    /**
     * Number of buckets to divide the rolling window into
     * @default 10
     */
    rollingWindowBuckets?: number;
    /**
     * Number of successful requests required in HALF_OPEN state
     * before closing the circuit
     * @default 5
     */
    successThreshold?: number;
    /**
     * Request timeout in milliseconds
     * @default 3000 (3 seconds)
     */
    timeout?: number;
    /**
     * Name for the circuit breaker (for logging/monitoring)
     */
    name?: string;
    /**
     * Whether to emit events for monitoring
     * @default true
     */
    emitEvents?: boolean;
    /**
     * Custom error filter to determine if an error should trip the circuit
     */
    isFailure?: (error: Error) => boolean;
    /**
     * Fallback function to call when circuit is open
     */
    fallback?: <T>(...args: any[]) => Promise<T> | T;
}
/**
 * Circuit breaker statistics
 */
export interface CircuitBreakerStats {
    state: CircuitState;
    failures: number;
    successes: number;
    rejections: number;
    totalRequests: number;
    consecutiveFailures: number;
    consecutiveSuccesses: number;
    lastFailureTime?: number;
    lastSuccessTime?: number;
    nextAttempt?: number;
    failureRate: number;
    rollingCountFailure: number;
    rollingCountSuccess: number;
    rollingCountTimeout: number;
    rollingCountRejected: number;
}
/**
 * Circuit breaker events
 */
export interface CircuitBreakerEvents {
    'state-change': (from: CircuitState, to: CircuitState, stats: CircuitBreakerStats) => void;
    success: (result: any, latency: number) => void;
    failure: (error: Error, latency: number) => void;
    timeout: (latency: number) => void;
    reject: (reason: string) => void;
    fallback: (args: any[]) => void;
    'half-open-success': (result: any) => void;
    'half-open-failure': (error: Error) => void;
    'health-check': (stats: CircuitBreakerStats) => void;
}
/**
 * Circuit breaker event emitter interface
 */
export interface ICircuitBreakerEventEmitter extends EventEmitter {
    on<K extends keyof CircuitBreakerEvents>(event: K, listener: CircuitBreakerEvents[K]): this;
    emit<K extends keyof CircuitBreakerEvents>(event: K, ...args: Parameters<CircuitBreakerEvents[K]>): boolean;
    off<K extends keyof CircuitBreakerEvents>(event: K, listener: CircuitBreakerEvents[K]): this;
    once<K extends keyof CircuitBreakerEvents>(event: K, listener: CircuitBreakerEvents[K]): this;
}
/**
 * Circuit breaker interface
 */
export interface ICircuitBreaker<T = any> {
    /**
     * Execute a function through the circuit breaker
     */
    execute<R>(fn: (...args: T[]) => Promise<R>, ...args: T[]): Promise<R>;
    /**
     * Get current circuit state
     */
    getState(): CircuitState;
    /**
     * Get circuit breaker statistics
     */
    getStats(): CircuitBreakerStats;
    /**
     * Manually open the circuit
     */
    open(): void;
    /**
     * Manually close the circuit
     */
    close(): void;
    /**
     * Reset all statistics
     */
    reset(): void;
    /**
     * Check if circuit is allowing requests
     */
    isOpen(): boolean;
    /**
     * Get the circuit breaker event emitter
     */
    getEventEmitter(): ICircuitBreakerEventEmitter;
    /**
     * Health check for monitoring
     */
    healthCheck(): Promise<CircuitBreakerStats>;
}
/**
 * Rolling window for tracking metrics over time
 */
export interface RollingWindow {
    /**
     * Record a successful request
     */
    recordSuccess(timestamp?: number): void;
    /**
     * Record a failed request
     */
    recordFailure(timestamp?: number): void;
    /**
     * Record a timeout
     */
    recordTimeout(timestamp?: number): void;
    /**
     * Record a rejected request
     */
    recordRejection(timestamp?: number): void;
    /**
     * Get counts for the current window
     */
    getCounts(): WindowCounts;
    /**
     * Reset all metrics
     */
    reset(): void;
}
/**
 * Window counts for metrics
 */
export interface WindowCounts {
    success: number;
    failure: number;
    timeout: number;
    rejected: number;
    total: number;
    errorPercentage: number;
}
/**
 * Circuit breaker factory function type
 */
export type CircuitBreakerFactory = <T = any>(options: CircuitBreakerOptions) => ICircuitBreaker<T>;
/**
 * Circuit breaker middleware for wrapping async functions
 */
export type CircuitBreakerWrapper = <T extends (...args: any[]) => Promise<any>>(fn: T, options?: Partial<CircuitBreakerOptions>) => T;
//# sourceMappingURL=types.d.ts.map