veryfront 0.0.82 → 0.0.84

package/src/proxy/cache/redis-cache.ts

@@ -0,0 +1,203 @@
+/**
+ * Redis Token Cache
+ *
+ * Uses the standard `redis` package for cross-runtime compatibility.
+ * Works in Deno, Node.js, and Bun.
+ */
+
+import { createClient, type RedisClientType } from "redis";
+import type { CacheStats, RedisCacheOptions, TokenCache, TokenCacheEntry } from "./types.js";
+import { withSpan } from "../tracing.js";
+
+const DEFAULT_PREFIX = "vf:token:";
+const DEFAULT_CONNECT_TIMEOUT = 5000;
+const DEFAULT_SCAN_COUNT = 100;
+
+export class RedisCache implements TokenCache {
+  private client: RedisClientType | null = null;
+  private prefix: string;
+  private url: string;
+  private connectTimeout: number;
+  private hits = 0;
+  private misses = 0;
+  private connected = false;
+
+  constructor(options: RedisCacheOptions) {
+    this.url = options.url;
+    this.prefix = options.prefix ?? DEFAULT_PREFIX;
+    this.connectTimeout = options.connectTimeout ?? DEFAULT_CONNECT_TIMEOUT;
+  }
+
+  private key(k: string): string {
+    return `${this.prefix}${k}`;
+  }
+
+  async get(key: string): Promise<TokenCacheEntry | null> {
+    return withSpan("cache.redis.get", async () => {
+      try {
+        await this.ensureConnected();
+        const data = await this.client!.get(this.key(key));
+
+        if (!data) {
+          this.misses++;
+          return null;
+        }
+
+        const entry = JSON.parse(data) as TokenCacheEntry;
+
+        if (Date.now() >= entry.expiresAt) {
+          await this.client!.del(this.key(key));
+          this.misses++;
+          return null;
+        }
+
+        this.hits++;
+        return entry;
+      } catch (error) {
+        console.error("[RedisCache] Get error:", error);
+        this.connected = false;
+        this.misses++;
+        throw error;
+      }
+    }, { "cache.key": key });
+  }
+
+  async set(key: string, entry: TokenCacheEntry): Promise<void> {
+    return withSpan("cache.redis.set", async () => {
+      try {
+        await this.ensureConnected();
+        const ttlMs = entry.expiresAt - Date.now();
+        const ttlSeconds = Math.max(1, Math.floor(ttlMs / 1000));
+        await this.client!.setEx(this.key(key), ttlSeconds, JSON.stringify(entry));
+      } catch (error) {
+        console.error("[RedisCache] Set error:", error);
+        this.connected = false;
+        throw error;
+      }
+    }, { "cache.key": key });
+  }
+
+  async delete(key: string): Promise<void> {
+    return withSpan("cache.redis.delete", async () => {
+      try {
+        await this.ensureConnected();
+        await this.client!.del(this.key(key));
+      } catch (error) {
+        console.error("[RedisCache] Delete error:", error);
+        this.connected = false;
+        throw error;
+      }
+    }, { "cache.key": key });
+  }
+
+  async clear(): Promise<void> {
+    return withSpan("cache.redis.clear", async () => {
+      try {
+        await this.ensureConnected();
+
+        const pattern = `${this.prefix}*`;
+        let cursor = "0";
+        let totalDeleted = 0;
+
+        do {
+          const result = await this.client!.scan(cursor, {
+            MATCH: pattern,
+            COUNT: DEFAULT_SCAN_COUNT,
+          });
+          cursor = String(result.cursor);
+
+          if (result.keys.length > 0) {
+            totalDeleted += await this.client!.del(result.keys);
+          }
+        } while (cursor !== "0");
+
+        if (totalDeleted > 0) {
+          console.log(`[RedisCache] Cleared ${totalDeleted} keys`);
+        }
+
+        this.hits = 0;
+        this.misses = 0;
+      } catch (error) {
+        console.error("[RedisCache] Clear error:", error);
+        this.connected = false;
+        throw error;
+      }
+    });
+  }
+
+  async has(key: string): Promise<boolean> {
+    return withSpan("cache.redis.has", async () => {
+      try {
+        await this.ensureConnected();
+        const exists = await this.client!.exists(this.key(key));
+        return exists === 1;
+      } catch (error) {
+        console.error("[RedisCache] Has error:", error);
+        this.connected = false;
+        throw error;
+      }
+    }, { "cache.key": key });
+  }
+
+  async stats(): Promise<CacheStats> {
+    return withSpan("cache.redis.stats", async () => {
+      let size = 0;
+      try {
+        await this.ensureConnected();
+        size = await this.client!.dbSize();
+      } catch (error) {
+        this.connected = false;
+        console.warn("[RedisCache] Stats error:", error);
+      }
+
+      return { hits: this.hits, misses: this.misses, size, type: "redis" as const };
+    });
+  }
+
+  async close(): Promise<void> {
+    return withSpan("cache.redis.close", async () => {
+      if (this.client) {
+        try {
+          await this.client.quit();
+        } catch {
+          // Ignore close errors
+        }
+        this.client = null;
+      }
+      this.connected = false;
+    });
+  }
+
+  private async ensureConnected(): Promise<void> {
+    return withSpan("cache.redis.connect", async () => {
+      if (this.connected && this.client) {
+        return;
+      }
+
+      // Create client with connection options
+      this.client = createClient({
+        url: this.url,
+        socket: {
+          connectTimeout: this.connectTimeout,
+          reconnectStrategy: (retries) => {
+            // Exponential backoff with max 3 retries
+            if (retries > 3) {
+              return new Error("Max reconnection attempts reached");
+            }
+            return Math.min(retries * 100, 3000);
+          },
+        },
+      });
+
+      // Handle connection errors
+      this.client.on("error", (err) => {
+        console.error("[RedisCache] Client error:", err);
+        this.connected = false;
+      });
+
+      await this.client.connect();
+      this.connected = true;
+      console.log("[RedisCache] Connected");
+    });
+  }
+}

package/src/proxy/cache/resilient-cache.ts

@@ -0,0 +1,205 @@
+/**
+ * Resilient Token Cache
+ *
+ * Wraps a primary cache (Redis) with a fallback cache (Memory).
+ * Automatically falls back to memory cache when Redis operations fail.
+ * Provides graceful degradation instead of hard failures.
+ */
+
+import type { CacheStats, TokenCache, TokenCacheEntry } from "./types.js";
+import { proxyLogger } from "../logger.js";
+import { withSpan } from "../tracing.js";
+
+const CIRCUIT_OPEN_DURATION_MS = 30_000; // 30 seconds
+const FAILURE_THRESHOLD = 3; // failures before circuit opens
+
+const logger = proxyLogger.child({ module: "cache" });
+
+export class ResilientCache implements TokenCache {
+  private primary: TokenCache;
+  private fallback: TokenCache;
+  private usingFallback = false;
+  private failureCount = 0;
+  private circuitOpenedAt: number | null = null;
+
+  constructor(primary: TokenCache, fallback: TokenCache) {
+    this.primary = primary;
+    this.fallback = fallback;
+  }
+
+  /**
+   * Check if we should try primary again after circuit was opened.
+   */
+  private shouldTryPrimary(): boolean {
+    if (!this.usingFallback) return true;
+
+    // If circuit was opened, check if enough time has passed
+    if (this.circuitOpenedAt) {
+      const elapsed = Date.now() - this.circuitOpenedAt;
+      if (elapsed >= CIRCUIT_OPEN_DURATION_MS) {
+        logger.info("[ResilientCache] Circuit half-open, trying primary again");
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Record a successful primary operation - reset failure state.
+   */
+  private recordSuccess(): void {
+    if (this.usingFallback) {
+      logger.info("[ResilientCache] Primary recovered, switching back from fallback");
+      this.usingFallback = false;
+      this.failureCount = 0;
+      this.circuitOpenedAt = null;
+    }
+  }
+
+  /**
+   * Record a primary failure - may trigger fallback.
+   */
+  private recordFailure(error: unknown): void {
+    this.failureCount++;
+    logger.warn(
+      `[ResilientCache] Primary cache error (${this.failureCount}/${FAILURE_THRESHOLD}):`,
+      { error: error instanceof Error ? error.message : error },
+    );
+
+    if (this.failureCount >= FAILURE_THRESHOLD && !this.usingFallback) {
+      logger.warn("[ResilientCache] Opening circuit, switching to fallback cache");
+      this.usingFallback = true;
+      this.circuitOpenedAt = Date.now();
+    }
+  }
+
+  async get(key: string): Promise<TokenCacheEntry | null> {
+    return withSpan("cache.resilient.get", async () => {
+      // Try primary if circuit allows
+      if (this.shouldTryPrimary()) {
+        try {
+          const result = await this.primary.get(key);
+          this.recordSuccess();
+          return result;
+        } catch (error) {
+          this.recordFailure(error);
+          // Don't return here - try fallback
+        }
+      }
+
+      // Use fallback
+      return this.fallback.get(key);
+    }, { "cache.key": key, "cache.usingFallback": this.usingFallback });
+  }
+
+  async set(key: string, entry: TokenCacheEntry): Promise<void> {
+    return withSpan("cache.resilient.set", async () => {
+      // Always try to set in fallback (local cache)
+      await this.fallback.set(key, entry);
+
+      // Try primary if circuit allows
+      if (this.shouldTryPrimary()) {
+        try {
+          await this.primary.set(key, entry);
+          this.recordSuccess();
+        } catch (error) {
+          this.recordFailure(error);
+          // Fallback already set above, no need to retry
+        }
+      }
+    }, { "cache.key": key, "cache.usingFallback": this.usingFallback });
+  }
+
+  async delete(key: string): Promise<void> {
+    return withSpan("cache.resilient.delete", async () => {
+      // Delete from both
+      await this.fallback.delete(key);
+
+      if (this.shouldTryPrimary()) {
+        try {
+          await this.primary.delete(key);
+          this.recordSuccess();
+        } catch (error) {
+          this.recordFailure(error);
+        }
+      }
+    }, { "cache.key": key });
+  }
+
+  async clear(): Promise<void> {
+    return withSpan("cache.resilient.clear", async () => {
+      await this.fallback.clear();
+
+      if (this.shouldTryPrimary()) {
+        try {
+          await this.primary.clear();
+          this.recordSuccess();
+        } catch (error) {
+          this.recordFailure(error);
+        }
+      }
+    });
+  }
+
+  async has(key: string): Promise<boolean> {
+    return withSpan("cache.resilient.has", async () => {
+      if (this.shouldTryPrimary()) {
+        try {
+          const result = await this.primary.has(key);
+          this.recordSuccess();
+          return result;
+        } catch (error) {
+          this.recordFailure(error);
+        }
+      }
+
+      return this.fallback.has(key);
+    }, { "cache.key": key });
+  }
+
+  async stats(): Promise<CacheStats> {
+    return withSpan("cache.resilient.stats", async () => {
+      const fallbackStats = await this.fallback.stats();
+
+      if (this.shouldTryPrimary()) {
+        try {
+          const primaryStats = await this.primary.stats();
+          this.recordSuccess();
+          return {
+            ...primaryStats,
+            type: this.usingFallback ? "memory" as const : "redis" as const,
+          };
+        } catch (error) {
+          this.recordFailure(error);
+        }
+      }
+
+      return {
+        ...fallbackStats,
+        type: "memory" as const,
+      };
+    }, { "cache.usingFallback": this.usingFallback });
+  }
+
+  async close(): Promise<void> {
+    return withSpan("cache.resilient.close", async () => {
+      await Promise.all([this.primary.close(), this.fallback.close()]);
+    });
+  }
+
+  /**
+   * Get current resilience status for debugging/health checks.
+   */
+  getStatus(): {
+    usingFallback: boolean;
+    failureCount: number;
+    circuitOpenedAt: number | null;
+  } {
+    return {
+      usingFallback: this.usingFallback,
+      failureCount: this.failureCount,
+      circuitOpenedAt: this.circuitOpenedAt,
+    };
+  }
+}

package/src/proxy/cache/types.ts

@@ -0,0 +1,72 @@
+/**
+ * Token Cache Interface
+ *
+ * Abstraction for storing OAuth tokens with TTL support.
+ * Implementations: MemoryCache, RedisCache
+ */
+
+export interface TokenCacheEntry {
+  token: string;
+  expiresAt: number; // Unix timestamp in ms
+  scope: "preview" | "production";
+  projectSlug?: string;
+}
+
+export interface TokenCache {
+  /**
+   * Get a cached token entry.
+   */
+  get(key: string): Promise<TokenCacheEntry | null>;
+
+  /**
+   * Set a token entry with automatic TTL based on expiresAt.
+   */
+  set(key: string, entry: TokenCacheEntry): Promise<void>;
+
+  /**
+   * Delete a specific token entry.
+   */
+  delete(key: string): Promise<void>;
+
+  /**
+   * Clear all cached tokens.
+   */
+  clear(): Promise<void>;
+
+  /**
+   * Check if a key exists in cache.
+   */
+  has(key: string): Promise<boolean>;
+
+  /**
+   * Get cache statistics.
+   */
+  stats(): Promise<CacheStats>;
+
+  /**
+   * Close any connections (for Redis).
+   */
+  close(): Promise<void>;
+}
+
+export interface CacheStats {
+  hits: number;
+  misses: number;
+  size: number;
+  type: "memory" | "redis";
+}
+
+export interface MemoryCacheOptions {
+  maxSize?: number; // Maximum number of entries
+  cleanupInterval?: number; // Interval in ms to cleanup expired entries
+}
+
+export interface RedisCacheOptions {
+  url: string;
+  prefix?: string;
+  connectTimeout?: number;
+}
+
+export type CacheOptions =
+  | { type: "memory"; options?: MemoryCacheOptions }
+  | { type: "redis"; options: RedisCacheOptions };