@holoscript/core 6.0.4 → 6.1.2

package/dist/chunk-A6KINLZJ.js

@@ -0,0 +1,236 @@
+// src/resilience/ResiliencePatterns.ts
+var CircuitBreakerState = /* @__PURE__ */ ((CircuitBreakerState2) => {
+  CircuitBreakerState2["CLOSED"] = "CLOSED";
+  CircuitBreakerState2["OPEN"] = "OPEN";
+  CircuitBreakerState2["HALF_OPEN"] = "HALF_OPEN";
+  return CircuitBreakerState2;
+})(CircuitBreakerState || {});
+var CircuitBreaker = class {
+  constructor(config = {}) {
+    this.state = "CLOSED" /* CLOSED */;
+    this.failureCount = 0;
+    this.successCount = 0;
+    this.lastFailureTime = null;
+    this.failures = [];
+    this.config = {
+      failureThreshold: 5,
+      successThreshold: 2,
+      resetTimeoutMs: 6e4,
+      // 1 minute
+      windowMs: 3e4,
+      // 30 seconds
+      isRetryable: (err) => err instanceof Error,
+      ...config
+    };
+  }
+  /**
+   * Execute function with circuit breaker protection
+   */
+  async execute(fn) {
+    if (this.state === "OPEN" /* OPEN */) {
+      if (Date.now() - (this.lastFailureTime || 0) > this.config.resetTimeoutMs) {
+        this.state = "HALF_OPEN" /* HALF_OPEN */;
+        this.successCount = 0;
+      } else {
+        throw new Error(`Circuit breaker is OPEN. Retry after ${this.config.resetTimeoutMs}ms`);
+      }
+    }
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure(error);
+      throw error;
+    }
+  }
+  onSuccess() {
+    this.failureCount = 0;
+    this.failures = this.failures.filter((f) => Date.now() - f.timestamp < this.config.windowMs);
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.successCount++;
+      if (this.successCount >= this.config.successThreshold) {
+        this.state = "CLOSED" /* CLOSED */;
+      }
+    }
+  }
+  onFailure(error) {
+    this.lastFailureTime = Date.now();
+    this.failureCount++;
+    this.failures.push({ timestamp: Date.now(), error });
+    this.failures = this.failures.filter((f) => Date.now() - f.timestamp < this.config.windowMs);
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.state = "OPEN" /* OPEN */;
+    } else if (this.failureCount >= this.config.failureThreshold) {
+      this.state = "OPEN" /* OPEN */;
+      console.error(`Circuit breaker OPEN after ${this.failureCount} failures: ${error.message}`);
+    }
+  }
+  get currentState() {
+    return this.state;
+  }
+  /**
+   * Get current circuit breaker state (accessor method)
+   */
+  getState() {
+    if (this.state === "OPEN" /* OPEN */ && Date.now() - (this.lastFailureTime || 0) > this.config.resetTimeoutMs) {
+      return "HALF_OPEN" /* HALF_OPEN */;
+    }
+    return this.state;
+  }
+  /**
+   * Get circuit breaker metrics
+   */
+  getMetrics() {
+    return {
+      state: this.state,
+      totalFailures: this.failureCount,
+      totalSuccesses: this.successCount,
+      lastFailureTime: this.lastFailureTime,
+      totalRequests: this.failureCount + this.successCount
+    };
+  }
+};
+async function retryWithBackoff(fn, config = {}) {
+  const cfg = {
+    maxAttempts: 3,
+    initialBackoffMs: 100,
+    maxBackoffMs: 1e4,
+    multiplier: 2,
+    jitter: true,
+    isRetryable: (err, attempt) => attempt < cfg.maxAttempts,
+    ...config
+  };
+  let lastError = null;
+  for (let attempt = 1; attempt <= cfg.maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (!cfg.isRetryable(lastError, attempt)) {
+        throw lastError;
+      }
+      if (attempt < cfg.maxAttempts) {
+        const backoff = Math.min(
+          cfg.initialBackoffMs * Math.pow(cfg.multiplier, attempt - 1),
+          cfg.maxBackoffMs
+        );
+        const jitteredBackoff = cfg.jitter ? backoff * (0.5 + Math.random() * 0.5) : backoff;
+        console.warn(
+          `Attempt ${attempt} failed: ${lastError.message}. Retrying in ${Math.round(jitteredBackoff)}ms`
+        );
+        await sleep(jitteredBackoff);
+      }
+    }
+  }
+  throw lastError || new Error("Max retry attempts exceeded");
+}
+var Bulkhead = class {
+  constructor(config = {}) {
+    this.running = 0;
+    this.queue = [];
+    this.config = {
+      maxConcurrent: 10,
+      queueSize: 100,
+      timeoutMs: 3e4,
+      ...config
+    };
+  }
+  /**
+   * Execute function within bulkhead
+   */
+  async execute(fn) {
+    if (this.queue.length >= this.config.queueSize) {
+      throw new Error("Bulkhead queue full - too many pending operations");
+    }
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        const idx = this.queue.findIndex((item) => item.resolve === resolve);
+        if (idx !== -1) {
+          this.queue.splice(idx, 1);
+        }
+        reject(new Error("Bulkhead operation timeout"));
+      }, this.config.timeoutMs);
+      this.queue.push({
+        fn,
+        // @ts-expect-error
+        resolve,
+        reject,
+        timeoutId
+      });
+      this.processQueue();
+    });
+  }
+  processQueue() {
+    while (this.running < this.config.maxConcurrent && this.queue.length > 0) {
+      const item = this.queue.shift();
+      if (!item) break;
+      this.running++;
+      item.fn().then((result) => {
+        clearTimeout(item.timeoutId);
+        item.resolve(result);
+      }).catch((error) => {
+        clearTimeout(item.timeoutId);
+        item.reject(error);
+      }).finally(() => {
+        this.running--;
+        this.processQueue();
+      });
+    }
+  }
+  get stats() {
+    return {
+      running: this.running,
+      queued: this.queue.length
+    };
+  }
+  /**
+   * Get bulkhead state (accessor method)
+   */
+  getState() {
+    return {
+      running: this.running,
+      queued: this.queue.length,
+      maxConcurrent: this.config.maxConcurrent
+    };
+  }
+  /**
+   * Get bulkhead metrics
+   */
+  getMetrics() {
+    return {
+      running: this.running,
+      queued: this.queue.length,
+      utilizationPercent: this.running / this.config.maxConcurrent * 100,
+      queueUtilizationPercent: this.queue.length / this.config.queueSize * 100
+    };
+  }
+};
+async function fallbackChain(strategies) {
+  let lastError = null;
+  for (let i = 0; i < strategies.length; i++) {
+    try {
+      const result = await strategies[i]();
+      return result;
+    } catch (error) {
+      lastError = error;
+      console.warn(`Strategy ${i + 1} failed: ${lastError.message}`);
+    }
+  }
+  throw lastError || new Error("All fallback strategies failed");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withTimeout(promise, timeoutMs) {
+  return Promise.race([
+    promise,
+    new Promise(
+      (_, reject) => setTimeout(() => reject(new Error(`Operation timeout after ${timeoutMs}ms`)), timeoutMs)
+    )
+  ]);
+}
+
+export { Bulkhead, CircuitBreaker, CircuitBreakerState, fallbackChain, retryWithBackoff, withTimeout };
+//# sourceMappingURL=chunk-A6KINLZJ.js.map
+//# sourceMappingURL=chunk-A6KINLZJ.js.map