@stackmemoryai/stackmemory 0.2.8 → 0.3.0

package/dist/core/errors/recovery.js

@@ -0,0 +1,258 @@
+import { logger } from "../monitoring/logger.js";
+import {
+  isRetryableError,
+  getErrorMessage
+} from "./index.js";
+var CircuitState = /* @__PURE__ */ ((CircuitState2) => {
+  CircuitState2["CLOSED"] = "closed";
+  CircuitState2["OPEN"] = "open";
+  CircuitState2["HALF_OPEN"] = "half_open";
+  return CircuitState2;
+})(CircuitState || {});
+function calculateBackoff(attempt, initialDelay, maxDelay, factor) {
+  const exponentialDelay = Math.min(
+    initialDelay * Math.pow(factor, attempt - 1),
+    maxDelay
+  );
+  const jitter = exponentialDelay * Math.random() * 0.25;
+  return Math.floor(exponentialDelay + jitter);
+}
+async function retry(fn, options = {}) {
+  const {
+    maxAttempts = 3,
+    initialDelay = 1e3,
+    maxDelay = 3e4,
+    backoffFactor = 2,
+    timeout,
+    onRetry
+  } = options;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      if (timeout) {
+        return await Promise.race([
+          fn(),
+          new Promise(
+            (_, reject) => setTimeout(
+              () => reject(new Error(`Operation timed out after ${timeout}ms`)),
+              timeout
+            )
+          )
+        ]);
+      }
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (!isRetryableError(error) || attempt === maxAttempts) {
+        throw error;
+      }
+      const delay = calculateBackoff(attempt, initialDelay, maxDelay, backoffFactor);
+      logger.warn(`Retry attempt ${attempt}/${maxAttempts} after ${delay}ms`, {
+        error: getErrorMessage(error),
+        attempt,
+        delay
+      });
+      if (onRetry) {
+        onRetry(attempt, error);
+      }
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw lastError;
+}
+class CircuitBreaker {
+  constructor(name, options = {}) {
+    this.name = name;
+    this.options = {
+      failureThreshold: options.failureThreshold ?? 5,
+      resetTimeout: options.resetTimeout ?? 6e4,
+      halfOpenRequests: options.halfOpenRequests ?? 3
+    };
+  }
+  state = "closed" /* CLOSED */;
+  failures = 0;
+  successCount = 0;
+  lastFailTime;
+  options;
+  async execute(fn) {
+    if (this.state === "open" /* OPEN */) {
+      const timeSinceLastFailure = this.lastFailTime ? Date.now() - this.lastFailTime.getTime() : 0;
+      if (timeSinceLastFailure >= this.options.resetTimeout) {
+        this.state = "half_open" /* HALF_OPEN */;
+        this.successCount = 0;
+        logger.info(`Circuit breaker ${this.name} entering half-open state`);
+      } else {
+        throw new Error(
+          `Circuit breaker ${this.name} is OPEN. Retry after ${this.options.resetTimeout - timeSinceLastFailure}ms`
+        );
+      }
+    }
+    try {
+      const result = await fn();
+      if (this.state === "half_open" /* HALF_OPEN */) {
+        this.successCount++;
+        if (this.successCount >= this.options.halfOpenRequests) {
+          this.state = "closed" /* CLOSED */;
+          this.failures = 0;
+          logger.info(`Circuit breaker ${this.name} is now CLOSED`);
+        }
+      } else {
+        this.failures = 0;
+      }
+      return result;
+    } catch (error) {
+      this.handleFailure(error);
+      throw error;
+    }
+  }
+  handleFailure(error) {
+    this.failures++;
+    this.lastFailTime = /* @__PURE__ */ new Date();
+    if (this.state === "half_open" /* HALF_OPEN */) {
+      this.state = "open" /* OPEN */;
+      logger.error(
+        `Circuit breaker ${this.name} reopened due to failure in half-open state`
+      );
+    } else if (this.state === "closed" /* CLOSED */ && this.failures >= this.options.failureThreshold) {
+      this.state = "open" /* OPEN */;
+      logger.error(
+        `Circuit breaker ${this.name} opened after ${this.failures} failures`
+      );
+    }
+  }
+  getState() {
+    return this.state;
+  }
+  reset() {
+    this.state = "closed" /* CLOSED */;
+    this.failures = 0;
+    this.successCount = 0;
+    this.lastFailTime = void 0;
+    logger.info(`Circuit breaker ${this.name} manually reset`);
+  }
+}
+async function withFallback(primary, fallbacks, context) {
+  const errors = [];
+  try {
+    return await primary();
+  } catch (error) {
+    errors.push(error);
+    logger.warn("Primary operation failed, trying fallbacks", {
+      error: getErrorMessage(error),
+      context
+    });
+  }
+  for (let i = 0; i < fallbacks.length; i++) {
+    try {
+      const result = await fallbacks[i]();
+      logger.info(`Fallback ${i + 1} succeeded`, { context });
+      return result;
+    } catch (error) {
+      errors.push(error);
+      if (i < fallbacks.length - 1) {
+        logger.warn(`Fallback ${i + 1} failed, trying next`, {
+          error: getErrorMessage(error),
+          context
+        });
+      }
+    }
+  }
+  throw new Error(
+    `All attempts failed. Errors: ${errors.map(getErrorMessage).join(", ")}`
+  );
+}
+class Bulkhead {
+  constructor(name, maxConcurrent) {
+    this.name = name;
+    this.maxConcurrent = maxConcurrent;
+  }
+  running = 0;
+  queue = [];
+  async execute(fn) {
+    if (this.running >= this.maxConcurrent) {
+      await new Promise((resolve) => {
+        this.queue.push(resolve);
+      });
+    }
+    this.running++;
+    try {
+      return await fn();
+    } finally {
+      this.running--;
+      const next = this.queue.shift();
+      if (next) {
+        next();
+      }
+    }
+  }
+  getStats() {
+    return {
+      running: this.running,
+      queued: this.queue.length,
+      maxConcurrent: this.maxConcurrent
+    };
+  }
+}
+async function withTimeout(fn, timeoutMs, timeoutMessage) {
+  return Promise.race([
+    fn(),
+    new Promise(
+      (_, reject) => setTimeout(
+        () => reject(
+          new Error(timeoutMessage ?? `Operation timed out after ${timeoutMs}ms`)
+        ),
+        timeoutMs
+      )
+    )
+  ]);
+}
+async function gracefulDegrade(fn, defaultValue, logContext) {
+  try {
+    return await fn();
+  } catch (error) {
+    logger.warn("Operation failed, using default value", {
+      error: getErrorMessage(error),
+      ...logContext
+    });
+    return defaultValue;
+  }
+}
+function createResilientOperation(name, options = {}) {
+  const circuitBreaker = options.circuitBreaker ? new CircuitBreaker(name, options.circuitBreaker) : null;
+  const bulkhead = options.bulkhead ? new Bulkhead(name, options.bulkhead) : null;
+  return async (fn) => {
+    let currentFn = fn;
+    if (bulkhead) {
+      const wrapped = currentFn;
+      currentFn = () => bulkhead.execute(wrapped);
+    }
+    if (options.timeout) {
+      const wrapped = currentFn;
+      currentFn = () => withTimeout(wrapped, options.timeout);
+    }
+    if (options.retry) {
+      const wrapped = currentFn;
+      currentFn = () => retry(wrapped, options.retry);
+    }
+    if (circuitBreaker) {
+      const wrapped = currentFn;
+      currentFn = () => circuitBreaker.execute(wrapped);
+    }
+    if (options.fallback) {
+      return withFallback(currentFn, [options.fallback]);
+    }
+    return currentFn();
+  };
+}
+export {
+  Bulkhead,
+  CircuitBreaker,
+  CircuitState,
+  calculateBackoff,
+  createResilientOperation,
+  gracefulDegrade,
+  retry,
+  withFallback,
+  withTimeout
+};
+//# sourceMappingURL=recovery.js.map

package/dist/core/errors/recovery.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/errors/recovery.ts"],
+  "sourcesContent": ["/**\n * Error recovery utilities for StackMemory\n * Provides retry logic, circuit breakers, and fallback mechanisms\n */\n\nimport { logger } from '../monitoring/logger.js';\nimport {\n  StackMemoryError,\n  isRetryableError,\n  getErrorMessage,\n  ErrorContext,\n} from './index.js';\n\nexport interface RetryOptions {\n  maxAttempts?: number;\n  initialDelay?: number;\n  maxDelay?: number;\n  backoffFactor?: number;\n  timeout?: number;\n  onRetry?: (attempt: number, error: unknown) => void;\n}\n\nexport interface CircuitBreakerOptions {\n  failureThreshold?: number;\n  resetTimeout?: number;\n  halfOpenRequests?: number;\n}\n\nexport enum CircuitState {\n  CLOSED = 'closed',\n  OPEN = 'open',\n  HALF_OPEN = 'half_open',\n}\n\n/**\n * Exponential backoff with jitter\n */\nexport function calculateBackoff(\n  attempt: number,\n  initialDelay: number,\n  maxDelay: number,\n  factor: number\n): number {\n  const exponentialDelay = Math.min(\n    initialDelay * Math.pow(factor, attempt - 1),\n    maxDelay\n  );\n  // Add jitter (0-25% of delay)\n  const jitter = exponentialDelay * Math.random() * 0.25;\n  return Math.floor(exponentialDelay + jitter);\n}\n\n/**\n * Retry with exponential backoff\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  options: RetryOptions = {}\n): Promise<T> {\n  const {\n    maxAttempts = 3,\n    initialDelay = 1000,\n    maxDelay = 30000,\n    backoffFactor = 2,\n    timeout,\n    onRetry,\n  } = options;\n\n  let lastError: unknown;\n\n  for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n    try {\n      // Add timeout if specified\n      if (timeout) {\n        return await Promise.race([\n          fn(),\n          new Promise<T>((_, reject) =>\n            setTimeout(\n              () => reject(new Error(`Operation timed out after ${timeout}ms`)),\n              timeout\n            )\n          ),\n        ]);\n      }\n      return await fn();\n    } catch (error) {\n      lastError = error;\n\n      // Don't retry if not retryable or last attempt\n      if (!isRetryableError(error) || attempt === maxAttempts) {\n        throw error;\n      }\n\n      const delay = calculateBackoff(attempt, initialDelay, maxDelay, backoffFactor);\n\n      logger.warn(`Retry attempt ${attempt}/${maxAttempts} after ${delay}ms`, {\n        error: getErrorMessage(error),\n        attempt,\n        delay,\n      });\n\n      if (onRetry) {\n        onRetry(attempt, error);\n      }\n\n      await new Promise((resolve) => setTimeout(resolve, delay));\n    }\n  }\n\n  throw lastError;\n}\n\n/**\n * Circuit breaker implementation\n */\nexport class CircuitBreaker<T> {\n  private state: CircuitState = CircuitState.CLOSED;\n  private failures = 0;\n  private successCount = 0;\n  private lastFailTime?: Date;\n  private readonly options: Required<CircuitBreakerOptions>;\n\n  constructor(\n    private readonly name: string,\n    options: CircuitBreakerOptions = {}\n  ) {\n    this.options = {\n      failureThreshold: options.failureThreshold ?? 5,\n      resetTimeout: options.resetTimeout ?? 60000,\n      halfOpenRequests: options.halfOpenRequests ?? 3,\n    };\n  }\n\n  async execute<R = T>(fn: () => Promise<R>): Promise<R> {\n    // Check if circuit should transition from OPEN to HALF_OPEN\n    if (this.state === CircuitState.OPEN) {\n      const timeSinceLastFailure = this.lastFailTime\n        ? Date.now() - this.lastFailTime.getTime()\n        : 0;\n\n      if (timeSinceLastFailure >= this.options.resetTimeout) {\n        this.state = CircuitState.HALF_OPEN;\n        this.successCount = 0;\n        logger.info(`Circuit breaker ${this.name} entering half-open state`);\n      } else {\n        throw new Error(\n          `Circuit breaker ${this.name} is OPEN. Retry after ${\n            this.options.resetTimeout - timeSinceLastFailure\n          }ms`\n        );\n      }\n    }\n\n    try {\n      const result = await fn();\n\n      // Handle success\n      if (this.state === CircuitState.HALF_OPEN) {\n        this.successCount++;\n        if (this.successCount >= this.options.halfOpenRequests) {\n          this.state = CircuitState.CLOSED;\n          this.failures = 0;\n          logger.info(`Circuit breaker ${this.name} is now CLOSED`);\n        }\n      } else {\n        this.failures = 0;\n      }\n\n      return result;\n    } catch (error) {\n      this.handleFailure(error);\n      throw error;\n    }\n  }\n\n  private handleFailure(error: unknown): void {\n    this.failures++;\n    this.lastFailTime = new Date();\n\n    if (this.state === CircuitState.HALF_OPEN) {\n      this.state = CircuitState.OPEN;\n      logger.error(\n        `Circuit breaker ${this.name} reopened due to failure in half-open state`\n      );\n    } else if (\n      this.state === CircuitState.CLOSED &&\n      this.failures >= this.options.failureThreshold\n    ) {\n      this.state = CircuitState.OPEN;\n      logger.error(\n        `Circuit breaker ${this.name} opened after ${this.failures} failures`\n      );\n    }\n  }\n\n  getState(): CircuitState {\n    return this.state;\n  }\n\n  reset(): void {\n    this.state = CircuitState.CLOSED;\n    this.failures = 0;\n    this.successCount = 0;\n    this.lastFailTime = undefined;\n    logger.info(`Circuit breaker ${this.name} manually reset`);\n  }\n}\n\n/**\n * Fallback with multiple strategies\n */\nexport async function withFallback<T>(\n  primary: () => Promise<T>,\n  fallbacks: Array<() => Promise<T>>,\n  context?: ErrorContext\n): Promise<T> {\n  const errors: unknown[] = [];\n\n  // Try primary\n  try {\n    return await primary();\n  } catch (error) {\n    errors.push(error);\n    logger.warn('Primary operation failed, trying fallbacks', {\n      error: getErrorMessage(error),\n      context,\n    });\n  }\n\n  // Try fallbacks in order\n  for (let i = 0; i < fallbacks.length; i++) {\n    try {\n      const result = await fallbacks[i]();\n      logger.info(`Fallback ${i + 1} succeeded`, { context });\n      return result;\n    } catch (error) {\n      errors.push(error);\n      if (i < fallbacks.length - 1) {\n        logger.warn(`Fallback ${i + 1} failed, trying next`, {\n          error: getErrorMessage(error),\n          context,\n        });\n      }\n    }\n  }\n\n  // All attempts failed\n  throw new Error(\n    `All attempts failed. Errors: ${errors.map(getErrorMessage).join(', ')}`\n  );\n}\n\n/**\n * Bulkhead pattern - limit concurrent operations\n */\nexport class Bulkhead {\n  private running = 0;\n  private queue: Array<() => void> = [];\n\n  constructor(\n    private readonly name: string,\n    private readonly maxConcurrent: number\n  ) {}\n\n  async execute<T>(fn: () => Promise<T>): Promise<T> {\n    if (this.running >= this.maxConcurrent) {\n      await new Promise<void>((resolve) => {\n        this.queue.push(resolve);\n      });\n    }\n\n    this.running++;\n\n    try {\n      return await fn();\n    } finally {\n      this.running--;\n      const next = this.queue.shift();\n      if (next) {\n        next();\n      }\n    }\n  }\n\n  getStats() {\n    return {\n      running: this.running,\n      queued: this.queue.length,\n      maxConcurrent: this.maxConcurrent,\n    };\n  }\n}\n\n/**\n * Timeout wrapper with proper cleanup\n */\nexport async function withTimeout<T>(\n  fn: () => Promise<T>,\n  timeoutMs: number,\n  timeoutMessage?: string\n): Promise<T> {\n  return Promise.race([\n    fn(),\n    new Promise<T>((_, reject) =>\n      setTimeout(\n        () =>\n          reject(\n            new Error(timeoutMessage ?? `Operation timed out after ${timeoutMs}ms`)\n          ),\n        timeoutMs\n      )\n    ),\n  ]);\n}\n\n/**\n * Graceful degradation helper\n */\nexport async function gracefulDegrade<T, F>(\n  fn: () => Promise<T>,\n  defaultValue: F,\n  logContext?: ErrorContext\n): Promise<T | F> {\n  try {\n    return await fn();\n  } catch (error) {\n    logger.warn('Operation failed, using default value', {\n      error: getErrorMessage(error),\n      ...logContext,\n    });\n    return defaultValue;\n  }\n}\n\n/**\n * Create a resilient operation with multiple recovery strategies\n */\nexport function createResilientOperation<T>(\n  name: string,\n  options: {\n    retry?: RetryOptions;\n    circuitBreaker?: CircuitBreakerOptions;\n    bulkhead?: number;\n    timeout?: number;\n    fallback?: () => Promise<T>;\n  } = {}\n) {\n  const circuitBreaker = options.circuitBreaker\n    ? new CircuitBreaker<T>(name, options.circuitBreaker)\n    : null;\n  const bulkhead = options.bulkhead\n    ? new Bulkhead(name, options.bulkhead)\n    : null;\n\n  return async (fn: () => Promise<T>): Promise<T> => {\n    let currentFn = fn;\n\n    // Wrap with bulkhead if configured\n    if (bulkhead) {\n      const wrapped = currentFn;\n      currentFn = () => bulkhead.execute(wrapped);\n    }\n\n    // Wrap with timeout if configured\n    if (options.timeout) {\n      const wrapped = currentFn;\n      currentFn = () => withTimeout(wrapped, options.timeout!);\n    }\n\n    // Wrap with retry if configured\n    if (options.retry) {\n      const wrapped = currentFn;\n      currentFn = () => retry(wrapped, options.retry!);\n    }\n\n    // Wrap with circuit breaker if configured\n    if (circuitBreaker) {\n      const wrapped = currentFn;\n      currentFn = () => circuitBreaker.execute(wrapped);\n    }\n\n    // Execute with fallback if configured\n    if (options.fallback) {\n      return withFallback(currentFn, [options.fallback]);\n    }\n\n    return currentFn();\n  };\n}"],
+  "mappings": "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",
+  "names": ["CircuitState"]
+}