@withwiz/toolkit 0.1.0

package/dist/chunk-HV3DGSSH.js

@@ -0,0 +1,447 @@
+import {
+  InMemoryCacheManager
+} from "./chunk-Z4D4CMDA.js";
+import {
+  isRedisGloballyDisabled,
+  notifyRedisError
+} from "./chunk-6LTZCXNC.js";
+import {
+  getCacheFallbackConfig
+} from "./chunk-I47QEDTX.js";
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+import {
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/cache/hybrid-cache-manager.ts
+function getDefaultHybridConfig() {
+  const fallbackConfig = getCacheFallbackConfig();
+  return {
+    backend: "hybrid",
+    fallbackOnRedisError: fallbackConfig.fallbackOnRedisError,
+    writeToMemory: fallbackConfig.writeToMemory,
+    redisErrorThreshold: fallbackConfig.redisErrorThresholdLocal,
+    redisReconnectInterval: fallbackConfig.redisReconnectInterval
+  };
+}
+var HybridCacheManager = class _HybridCacheManager {
+  constructor(prefix, config) {
+    // Redis 상태 추적
+    this.redisErrorCount = 0;
+    this.lastRedisError = null;
+    this.lastRedisErrorMessage = null;
+    this.isRedisTemporarilyDisabled = false;
+    this.redisReconnectTimer = null;
+    // 메트릭
+    this.redisFallbackCount = 0;
+    this.prefix = prefix;
+    this.config = __spreadValues(__spreadValues({}, getDefaultHybridConfig()), config);
+    this.redisManager = config.redisManager;
+    this.memoryCache = InMemoryCacheManager.getInstance(prefix, config.inmemoryConfig);
+    logger.info(`[HybridCacheManager] Initialized: prefix=${prefix}, backend=${this.config.backend}, redis=${this.redisManager ? "Y" : "N"}`);
+  }
+  // ============================================================================
+  // Public Methods
+  // ============================================================================
+  /**
+   * 캐시에서 값 조회
+   */
+  async get(key) {
+    const effectiveBackend = this.getEffectiveBackend();
+    if (effectiveBackend === "memory") {
+      return this.memoryCache.get(key);
+    }
+    if (this.redisManager && !this.isRedisTemporarilyDisabled) {
+      try {
+        const result = await this.redisManager.get(key);
+        if (result !== null) {
+          this.resetRedisErrorState();
+          return result;
+        }
+      } catch (error) {
+        this.handleRedisError(error, "get");
+        if (effectiveBackend === "hybrid" && this.config.fallbackOnRedisError) {
+          this.redisFallbackCount++;
+          return this.memoryCache.get(key);
+        }
+      }
+    }
+    if (effectiveBackend === "hybrid") {
+      return this.memoryCache.get(key);
+    }
+    return null;
+  }
+  /**
+   * 캐시에 값 저장
+   */
+  async set(key, value, ttl) {
+    const effectiveBackend = this.getEffectiveBackend();
+    if (effectiveBackend === "memory") {
+      await this.memoryCache.set(key, value, ttl);
+      return;
+    }
+    if (effectiveBackend === "redis") {
+      if (this.redisManager && !this.isRedisTemporarilyDisabled) {
+        try {
+          await this.redisManager.set(key, value, ttl);
+          this.resetRedisErrorState();
+        } catch (error) {
+          this.handleRedisError(error, "set");
+        }
+      }
+      return;
+    }
+    const promises = [];
+    if (this.redisManager && !this.isRedisTemporarilyDisabled) {
+      promises.push(
+        this.redisManager.set(key, value, ttl).then(() => this.resetRedisErrorState()).catch((error) => {
+          this.handleRedisError(error, "set");
+        })
+      );
+    }
+    if (this.config.writeToMemory || this.isRedisTemporarilyDisabled) {
+      promises.push(this.memoryCache.set(key, value, ttl));
+    }
+    await Promise.allSettled(promises);
+  }
+  /**
+   * 캐시에서 항목 삭제
+   */
+  async delete(key) {
+    const effectiveBackend = this.getEffectiveBackend();
+    const promises = [];
+    if (effectiveBackend !== "memory" && this.redisManager && !this.isRedisTemporarilyDisabled) {
+      promises.push(
+        this.redisManager.delete(key).catch((error) => {
+          this.handleRedisError(error, "delete");
+        })
+      );
+    }
+    if (effectiveBackend !== "redis") {
+      promises.push(this.memoryCache.delete(key));
+    }
+    await Promise.allSettled(promises);
+  }
+  /**
+   * 패턴 매칭으로 캐시 삭제
+   */
+  async deletePattern(pattern) {
+    const effectiveBackend = this.getEffectiveBackend();
+    const promises = [];
+    if (effectiveBackend !== "memory" && this.redisManager && !this.isRedisTemporarilyDisabled) {
+      promises.push(
+        this.redisManager.deletePattern(pattern).catch((error) => {
+          this.handleRedisError(error, "deletePattern");
+        })
+      );
+    }
+    if (effectiveBackend !== "redis") {
+      promises.push(this.memoryCache.deletePattern(pattern));
+    }
+    await Promise.allSettled(promises);
+  }
+  /**
+   * 키 존재 여부 확인
+   */
+  async exists(key) {
+    const effectiveBackend = this.getEffectiveBackend();
+    if (effectiveBackend === "memory") {
+      return this.memoryCache.exists(key);
+    }
+    if (this.redisManager && !this.isRedisTemporarilyDisabled) {
+      try {
+        const exists = await this.redisManager.exists(key);
+        if (exists) {
+          this.resetRedisErrorState();
+          return true;
+        }
+      } catch (error) {
+        this.handleRedisError(error, "exists");
+      }
+    }
+    if (effectiveBackend === "hybrid") {
+      return this.memoryCache.exists(key);
+    }
+    return false;
+  }
+  /**
+   * 값 증가
+   */
+  async increment(key, value = 1) {
+    const effectiveBackend = this.getEffectiveBackend();
+    if (effectiveBackend === "memory") {
+      return this.memoryCache.increment(key, value);
+    }
+    if (this.redisManager && !this.isRedisTemporarilyDisabled) {
+      try {
+        const result = await this.redisManager.increment(key, value);
+        this.resetRedisErrorState();
+        return result;
+      } catch (error) {
+        this.handleRedisError(error, "increment");
+      }
+    }
+    if (effectiveBackend === "hybrid" && this.config.fallbackOnRedisError) {
+      return this.memoryCache.increment(key, value);
+    }
+    return 0;
+  }
+  /**
+   * TTL 설정
+   */
+  async expire(key, ttl) {
+    const effectiveBackend = this.getEffectiveBackend();
+    const promises = [];
+    if (effectiveBackend !== "memory" && this.redisManager && !this.isRedisTemporarilyDisabled) {
+      promises.push(
+        this.redisManager.expire(key, ttl).catch((error) => {
+          this.handleRedisError(error, "expire");
+        })
+      );
+    }
+    if (effectiveBackend !== "redis") {
+      promises.push(this.memoryCache.expire(key, ttl));
+    }
+    await Promise.allSettled(promises);
+  }
+  // ============================================================================
+  // Metrics & Status
+  // ============================================================================
+  /**
+   * 하이브리드 캐시 메트릭 조회
+   */
+  getMetrics() {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const memoryMetrics = this.memoryCache.getMetrics();
+    let redisMetrics = null;
+    if (this.redisManager) {
+      const raw = this.redisManager.getMetrics();
+      redisMetrics = {
+        hits: (_a = raw.hits) != null ? _a : 0,
+        misses: (_b = raw.misses) != null ? _b : 0,
+        errors: (_c = raw.errors) != null ? _c : 0,
+        totalRequests: (_d = raw.totalRequests) != null ? _d : 0,
+        hitRate: (_e = raw.hitRate) != null ? _e : 0,
+        averageResponseTime: (_f = raw.averageResponseTime) != null ? _f : 0
+      };
+    }
+    const totalHits = ((_g = redisMetrics == null ? void 0 : redisMetrics.hits) != null ? _g : 0) + memoryMetrics.hits;
+    const totalMisses = ((_h = redisMetrics == null ? void 0 : redisMetrics.misses) != null ? _h : 0) + memoryMetrics.misses;
+    const totalRequests = totalHits + totalMisses;
+    return {
+      redis: redisMetrics,
+      memory: memoryMetrics,
+      combined: {
+        totalHits,
+        totalMisses,
+        redisFallbacks: this.redisFallbackCount,
+        hitRate: totalRequests > 0 ? Math.round(totalHits / totalRequests * 1e4) / 100 : 0
+      }
+    };
+  }
+  /**
+   * 연결 상태 조회
+   */
+  getConnectionStatus() {
+    const isGloballyDisabled = isRedisGloballyDisabled();
+    return {
+      redisConnected: !!this.redisManager && !this.isRedisTemporarilyDisabled && !isGloballyDisabled,
+      memoryActive: true,
+      currentBackend: this.getEffectiveBackend(),
+      redisErrorCount: this.redisErrorCount,
+      lastRedisError: this.lastRedisError,
+      lastRedisErrorMessage: this.lastRedisErrorMessage,
+      redisGloballyDisabled: isGloballyDisabled
+    };
+  }
+  /**
+   * 연결 체크
+   */
+  async checkConnection() {
+    const effectiveBackend = this.getEffectiveBackend();
+    if (effectiveBackend === "memory") {
+      return true;
+    }
+    if (this.redisManager) {
+      try {
+        const connected = await this.redisManager.checkConnection();
+        if (connected) {
+          this.resetRedisErrorState();
+          return true;
+        }
+      } catch (e) {
+      }
+    }
+    return effectiveBackend === "hybrid";
+  }
+  /**
+   * 설정 조회
+   */
+  getConfig() {
+    return {
+      prefix: this.prefix,
+      backend: this.config.backend,
+      effectiveBackend: this.getEffectiveBackend(),
+      fallbackOnRedisError: this.config.fallbackOnRedisError,
+      writeToMemory: this.config.writeToMemory,
+      redisAvailable: !!this.redisManager,
+      isRedisTemporarilyDisabled: this.isRedisTemporarilyDisabled,
+      memoryConfig: this.memoryCache.getConfig()
+    };
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  /**
+   * 실제 사용할 백엔드 결정
+   * - 전역 Redis 비활성화 상태도 확인
+   */
+  getEffectiveBackend() {
+    if (this.config.backend === "memory") {
+      return "memory";
+    }
+    const isRedisDisabled = isRedisGloballyDisabled() || this.isRedisTemporarilyDisabled;
+    if (!this.redisManager || isRedisDisabled) {
+      if (this.config.backend === "hybrid") {
+        return "memory";
+      }
+      return "redis";
+    }
+    return this.config.backend;
+  }
+  /**
+   * Redis 에러 처리
+   * - 전역 Redis 상태도 함께 업데이트
+   */
+  handleRedisError(error, operation) {
+    this.redisErrorCount++;
+    this.lastRedisError = /* @__PURE__ */ new Date();
+    this.lastRedisErrorMessage = error.message;
+    notifyRedisError(error, `HybridCacheManager.${operation}:${this.prefix}`);
+    logger.warn("[HybridCacheManager] Redis error", {
+      prefix: this.prefix,
+      operation,
+      error: error.message,
+      errorCount: this.redisErrorCount,
+      threshold: this.config.redisErrorThreshold,
+      globallyDisabled: isRedisGloballyDisabled()
+    });
+    if (this.redisErrorCount >= this.config.redisErrorThreshold) {
+      this.disableRedisTemporarily();
+    }
+  }
+  /**
+   * Redis 일시 비활성화
+   */
+  disableRedisTemporarily() {
+    if (this.isRedisTemporarilyDisabled) {
+      return;
+    }
+    this.isRedisTemporarilyDisabled = true;
+    logger.warn("[HybridCacheManager] Redis temporarily disabled", {
+      prefix: this.prefix,
+      errorCount: this.redisErrorCount,
+      reconnectIn: this.config.redisReconnectInterval
+    });
+    this.redisReconnectTimer = setTimeout(() => {
+      this.tryReconnectRedis();
+    }, this.config.redisReconnectInterval);
+  }
+  /**
+   * Redis 재연결 시도
+   */
+  async tryReconnectRedis() {
+    if (!this.redisManager) {
+      return;
+    }
+    logger.info("[HybridCacheManager] Redis reconnection attempt", { prefix: this.prefix });
+    try {
+      const connected = await this.redisManager.checkConnection();
+      if (connected) {
+        this.resetRedisErrorState();
+        logger.info("[HybridCacheManager] Redis reconnection successful", { prefix: this.prefix });
+      } else {
+        this.redisReconnectTimer = setTimeout(() => {
+          this.tryReconnectRedis();
+        }, this.config.redisReconnectInterval);
+      }
+    } catch (e) {
+      this.redisReconnectTimer = setTimeout(() => {
+        this.tryReconnectRedis();
+      }, this.config.redisReconnectInterval);
+    }
+  }
+  /**
+   * Redis 에러 상태 초기화 (로컬 상태만)
+   * - 전역 상태는 cache-redis.ts에서 관리 (Redis 성공 시 자동 리셋)
+   */
+  resetRedisErrorState() {
+    if (this.redisErrorCount > 0 || this.isRedisTemporarilyDisabled) {
+      logger.debug("[HybridCacheManager] Redis local error state reset", {
+        prefix: this.prefix,
+        previousErrorCount: this.redisErrorCount
+      });
+    }
+    this.redisErrorCount = 0;
+    this.isRedisTemporarilyDisabled = false;
+    if (this.redisReconnectTimer) {
+      clearTimeout(this.redisReconnectTimer);
+      this.redisReconnectTimer = null;
+    }
+  }
+  /**
+   * 리소스 정리
+   */
+  destroy() {
+    if (this.redisReconnectTimer) {
+      clearTimeout(this.redisReconnectTimer);
+      this.redisReconnectTimer = null;
+    }
+    logger.info("[HybridCacheManager] Instance destroyed", { prefix: this.prefix });
+  }
+  // ============================================================================
+  // Static Factory (globalThis 사용으로 프로세스 레벨 싱글톤 보장)
+  // ============================================================================
+  /**
+   * 전역 인스턴스 맵 가져오기 (HMR 안전)
+   */
+  static getGlobalInstances() {
+    if (!globalThis.__hybridCacheInstances) {
+      globalThis.__hybridCacheInstances = /* @__PURE__ */ new Map();
+    }
+    return globalThis.__hybridCacheInstances;
+  }
+  /**
+   * 싱글톤 인스턴스 가져오기
+   */
+  static getInstance(prefix, config) {
+    const instances = _HybridCacheManager.getGlobalInstances();
+    if (!instances.has(prefix)) {
+      instances.set(prefix, new _HybridCacheManager(prefix, config));
+    }
+    return instances.get(prefix);
+  }
+  /**
+   * 모든 인스턴스 종료
+   */
+  static destroyAll() {
+    const instances = _HybridCacheManager.getGlobalInstances();
+    for (const instance of instances.values()) {
+      instance.destroy();
+    }
+    instances.clear();
+    InMemoryCacheManager.destroyAll();
+  }
+  /**
+   * 인스턴스 초기화 (테스트용)
+   */
+  static clearInstances() {
+    _HybridCacheManager.getGlobalInstances().clear();
+  }
+};
+
+export {
+  HybridCacheManager
+};

package/dist/chunk-I47QEDTX.js

@@ -0,0 +1,193 @@
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+import {
+  CACHE_DURATION_DEFAULTS,
+  CACHE_FALLBACK_DEFAULTS,
+  CACHE_HEALTH_DEFAULTS,
+  CACHE_TTL_DEFAULTS,
+  INMEMORY_CACHE_DEFAULTS
+} from "./chunk-IQQKKUAV.js";
+
+// src/cache/cache-env.ts
+function _isRedisCacheEnabled() {
+  return process.env.CACHE_REDIS_ENABLED !== "false";
+}
+function _isInmemoryCacheEnabled() {
+  return process.env.CACHE_INMEMORY_ENABLED !== "false";
+}
+function _isRedisConfigured() {
+  return !!(process.env.UPSTASH_REDIS_REST_URL && process.env.UPSTASH_REDIS_REST_TOKEN);
+}
+function _isRedisAvailable() {
+  return _isRedisCacheEnabled() && _isRedisConfigured();
+}
+var _injectedConfig = null;
+function getDefaultConfig() {
+  const nodeEnv = process.env.NODE_ENV || "development";
+  const cacheEnabled = process.env.CACHE_ENABLED !== "false";
+  const redisUrl = process.env.UPSTASH_REDIS_REST_URL;
+  const redisToken = process.env.UPSTASH_REDIS_REST_TOKEN;
+  const redisEnabled = _isRedisCacheEnabled();
+  const inmemoryEnabled = _isInmemoryCacheEnabled();
+  const redisAvailable = _isRedisAvailable();
+  const defaultCategoryConfig = (enabled, duration) => ({
+    ENABLED: enabled,
+    DURATION: duration
+  });
+  return {
+    env: {
+      NODE_ENV: nodeEnv,
+      UPSTASH_REDIS_REST_URL: redisUrl,
+      UPSTASH_REDIS_REST_TOKEN: redisToken,
+      CACHE_ENABLED: cacheEnabled
+    },
+    ENV: {
+      REDIS: {
+        URL: redisUrl,
+        TOKEN: redisToken,
+        IS_AVAILABLE: redisAvailable,
+        ENABLED: redisEnabled
+      },
+      CACHE: {
+        ENABLED: cacheEnabled,
+        REDIS: {
+          ENABLED: redisEnabled
+        },
+        INMEMORY: {
+          ENABLED: inmemoryEnabled,
+          MAX_SIZE: parseInt(process.env.CACHE_INMEMORY_MAX_SIZE || String(INMEMORY_CACHE_DEFAULTS.MAX_SIZE), 10),
+          MAX_MB: parseInt(process.env.CACHE_INMEMORY_MAX_MB || String(INMEMORY_CACHE_DEFAULTS.MAX_MB), 10),
+          EVICTION: process.env.CACHE_INMEMORY_EVICTION || INMEMORY_CACHE_DEFAULTS.EVICTION,
+          CLEANUP_INTERVAL: parseInt(process.env.CACHE_INMEMORY_CLEANUP_INTERVAL || String(INMEMORY_CACHE_DEFAULTS.CLEANUP_INTERVAL), 10)
+        },
+        TTL: {
+          DEFAULT: parseInt(process.env.CACHE_TTL_DEFAULT || String(CACHE_TTL_DEFAULTS.DEFAULT), 10),
+          SHORT: parseInt(process.env.CACHE_TTL_SHORT || String(CACHE_TTL_DEFAULTS.SHORT), 10),
+          LONG: parseInt(process.env.CACHE_TTL_LONG || String(CACHE_TTL_DEFAULTS.LONG), 10),
+          GEOIP: parseInt(process.env.CACHE_TTL_GEOIP || String(CACHE_TTL_DEFAULTS.GEOIP), 10),
+          SETTINGS: parseInt(process.env.CACHE_TTL_SETTINGS || String(CACHE_TTL_DEFAULTS.SETTINGS), 10),
+          ANALYTICS: parseInt(process.env.CACHE_TTL_ANALYTICS || String(CACHE_TTL_DEFAULTS.ANALYTICS), 10),
+          USER: parseInt(process.env.CACHE_TTL_USER || String(CACHE_TTL_DEFAULTS.USER), 10),
+          LINK: parseInt(process.env.CACHE_TTL_LINK || String(CACHE_TTL_DEFAULTS.LINK), 10),
+          ALIAS: parseInt(process.env.CACHE_TTL_ALIAS || String(CACHE_TTL_DEFAULTS.ALIAS), 10),
+          COMMUNITY: parseInt(process.env.CACHE_TTL_COMMUNITY || String(CACHE_TTL_DEFAULTS.COMMUNITY), 10),
+          RESERVED_WORDS: parseInt(process.env.CACHE_TTL_RESERVED_WORDS || String(CACHE_TTL_DEFAULTS.RESERVED_WORDS), 10)
+        },
+        ANALYTICS: defaultCategoryConfig(process.env.CACHE_ANALYTICS_ENABLED !== "false", parseInt(process.env.CACHE_ANALYTICS_DURATION || String(CACHE_DURATION_DEFAULTS.ANALYTICS), 10)),
+        USER: defaultCategoryConfig(process.env.CACHE_USER_ENABLED !== "false", parseInt(process.env.CACHE_USER_DURATION || String(CACHE_DURATION_DEFAULTS.USER), 10)),
+        GEOIP: defaultCategoryConfig(process.env.CACHE_GEOIP_ENABLED !== "false", parseInt(process.env.CACHE_GEOIP_DURATION || String(CACHE_DURATION_DEFAULTS.GEOIP), 10)),
+        SETTINGS: defaultCategoryConfig(process.env.CACHE_SETTINGS_ENABLED !== "false", parseInt(process.env.CACHE_SETTINGS_DURATION || String(CACHE_DURATION_DEFAULTS.SETTINGS), 10)),
+        RESERVED_WORDS: defaultCategoryConfig(process.env.CACHE_RESERVED_WORDS_ENABLED !== "false", parseInt(process.env.CACHE_RESERVED_WORDS_DURATION || String(CACHE_DURATION_DEFAULTS.RESERVED_WORDS), 10)),
+        ALIAS: defaultCategoryConfig(process.env.CACHE_ALIAS_ENABLED !== "false", parseInt(process.env.CACHE_ALIAS_DURATION || String(CACHE_DURATION_DEFAULTS.ALIAS), 10)),
+        COMMUNITY: defaultCategoryConfig(process.env.CACHE_COMMUNITY_ENABLED !== "false", parseInt(process.env.CACHE_COMMUNITY_DURATION || String(CACHE_DURATION_DEFAULTS.COMMUNITY), 10)),
+        LINK: defaultCategoryConfig(process.env.CACHE_LINK_ENABLED !== "false", parseInt(process.env.CACHE_LINK_DURATION || process.env.CACHE_TTL_LINK || String(CACHE_DURATION_DEFAULTS.LINK), 10)),
+        // RATE_LIMIT: ENABLED 제거됨 - Rate Limiting은 RATE_LIMIT_ENABLED로 제어, CACHE_ENABLED로 Redis 사용 여부 결정
+        RATE_LIMIT: defaultCategoryConfig(true, parseInt(process.env.CACHE_RATE_LIMIT_DURATION || String(CACHE_DURATION_DEFAULTS.RATE_LIMIT), 10)),
+        URL_TOKEN: defaultCategoryConfig(process.env.CACHE_URL_TOKEN_ENABLED !== "false", parseInt(process.env.CACHE_URL_TOKEN_DURATION || String(CACHE_DURATION_DEFAULTS.URL_TOKEN), 10)),
+        API_KEY: defaultCategoryConfig(process.env.CACHE_API_KEY_ENABLED !== "false", parseInt(process.env.CACHE_API_KEY_DURATION || String(CACHE_DURATION_DEFAULTS.API_KEY), 10)),
+        API_CONFIG: defaultCategoryConfig(process.env.CACHE_API_CONFIG_ENABLED !== "false", parseInt(process.env.CACHE_API_CONFIG_DURATION || String(CACHE_DURATION_DEFAULTS.API_CONFIG), 10))
+      }
+    },
+    isCacheEnabled: () => cacheEnabled,
+    isRedisAvailable: () => redisAvailable
+  };
+}
+function getConfig() {
+  if (_injectedConfig) {
+    return _injectedConfig;
+  }
+  return getDefaultConfig();
+}
+var getEnv = () => getConfig().env;
+var getENV = () => getConfig().ENV;
+function initializeCache(config) {
+  if (global.__cacheInitialized) {
+    return;
+  }
+  _injectedConfig = config;
+  global.__cacheInitialized = true;
+  if (process.env.NODE_ENV === "production" && process.env.NEXT_BUILD_TIME !== "true") {
+    logger.info("[Cache] Environment configuration injection complete", {
+      cacheEnabled: config.isCacheEnabled(),
+      redisAvailable: config.isRedisAvailable()
+    });
+  }
+}
+var isCacheEnabled = () => getConfig().isCacheEnabled();
+function validateRedisEnvironment() {
+  const errors = [];
+  const env = getEnv();
+  if (!env.UPSTASH_REDIS_REST_URL) {
+    errors.push("UPSTASH_REDIS_REST_URL is not configured.");
+  } else if (env.UPSTASH_REDIS_REST_URL.trim() === "") {
+    errors.push("UPSTASH_REDIS_REST_URL is an empty string.");
+  }
+  if (!env.UPSTASH_REDIS_REST_TOKEN) {
+    errors.push("UPSTASH_REDIS_REST_TOKEN is not configured.");
+  } else if (env.UPSTASH_REDIS_REST_TOKEN.trim() === "") {
+    errors.push("UPSTASH_REDIS_REST_TOKEN is an empty string.");
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+function getCacheFallbackConfig() {
+  return {
+    redisErrorThresholdGlobal: parseInt(
+      process.env.CACHE_REDIS_ERROR_THRESHOLD_GLOBAL || String(CACHE_FALLBACK_DEFAULTS.REDIS_ERROR_THRESHOLD_GLOBAL),
+      10
+    ),
+    redisErrorThresholdLocal: parseInt(
+      process.env.CACHE_REDIS_ERROR_THRESHOLD_LOCAL || String(CACHE_FALLBACK_DEFAULTS.REDIS_ERROR_THRESHOLD_LOCAL),
+      10
+    ),
+    redisReconnectInterval: parseInt(
+      process.env.CACHE_REDIS_RECONNECT_INTERVAL || String(CACHE_FALLBACK_DEFAULTS.REDIS_RECONNECT_INTERVAL),
+      10
+    ),
+    fallbackOnRedisError: process.env.CACHE_FALLBACK_ON_REDIS_ERROR !== "false",
+    writeToMemory: process.env.CACHE_WRITE_TO_MEMORY !== "false"
+  };
+}
+function getCacheHealthConfig() {
+  return {
+    errorRateThreshold: parseInt(
+      process.env.CACHE_HEALTH_ERROR_RATE_THRESHOLD || String(CACHE_HEALTH_DEFAULTS.ERROR_RATE_THRESHOLD),
+      10
+    ),
+    hitRateThreshold: parseInt(
+      process.env.CACHE_HEALTH_HIT_RATE_THRESHOLD || String(CACHE_HEALTH_DEFAULTS.HIT_RATE_THRESHOLD),
+      10
+    ),
+    reportHitRateThreshold: parseInt(
+      process.env.CACHE_REPORT_HIT_RATE_THRESHOLD || String(CACHE_HEALTH_DEFAULTS.REPORT_HIT_RATE_THRESHOLD),
+      10
+    ),
+    reportResponseTimeThreshold: parseInt(
+      process.env.CACHE_REPORT_RESPONSE_TIME_THRESHOLD || String(CACHE_HEALTH_DEFAULTS.REPORT_RESPONSE_TIME_THRESHOLD),
+      10
+    ),
+    reportInvalidationThreshold: parseInt(
+      process.env.CACHE_REPORT_INVALIDATION_THRESHOLD || String(CACHE_HEALTH_DEFAULTS.REPORT_INVALIDATION_THRESHOLD),
+      10
+    ),
+    reportMinRequests: parseInt(
+      process.env.CACHE_REPORT_MIN_REQUESTS || String(CACHE_HEALTH_DEFAULTS.REPORT_MIN_REQUESTS),
+      10
+    )
+  };
+}
+
+export {
+  getDefaultConfig,
+  getConfig,
+  getEnv,
+  getENV,
+  initializeCache,
+  isCacheEnabled,
+  validateRedisEnvironment,
+  getCacheFallbackConfig,
+  getCacheHealthConfig
+};