@stacksjs/bun-router 0.0.17 → 0.0.19

package/src/cache/sqlite-cache.ts

@@ -1,783 +0,0 @@
-/**
- * SQLite Embedded Caching
- *
- * High-performance embedded caching using Bun's SQLite integration
- */
-
-import { Database } from 'bun:sqlite'
-import { Buffer } from 'node:buffer'
-
-export interface SQLiteCacheConfig {
-  filename?: string
-  memory?: boolean
-  wal?: boolean
-  synchronous?: 'OFF' | 'NORMAL' | 'FULL'
-  journalMode?: 'DELETE' | 'TRUNCATE' | 'PERSIST' | 'MEMORY' | 'WAL' | 'OFF'
-  cacheSize?: number
-  pageSize?: number
-  maxSize?: number
-  defaultTTL?: number
-  cleanupInterval?: number
-  compression?: boolean
-}
-
-export interface CacheEntry {
-  key: string
-  value: string
-  expires: number
-  created: number
-  accessed: number
-  hits: number
-  size: number
-  compressed: boolean
-}
-
-export interface CacheStats {
-  totalEntries: number
-  totalSize: number
-  hitRate: number
-  missRate: number
-  evictions: number
-  compressionRatio: number
-  averageAccessTime: number
-}
-
-/**
- * High-performance SQLite-based cache
- */
-export class SQLiteCache {
-  private db!: Database
-  private config: Required<SQLiteCacheConfig>
-  private stats: CacheStats
-  private cleanupTimer?: ReturnType<typeof setInterval>
-  private preparedStatements!: {
-    get: any
-    set: any
-    delete: any
-    exists: any
-    clear: any
-    cleanup: any
-    stats: any
-    touch: any
-  }
-
-  constructor(config: SQLiteCacheConfig = {}) {
-    this.config = {
-      filename: config.filename || ':memory:',
-      memory: config.memory ?? true,
-      wal: config.wal ?? true,
-      synchronous: config.synchronous || 'NORMAL',
-      journalMode: config.journalMode || 'WAL',
-      cacheSize: config.cacheSize || 10000,
-      pageSize: config.pageSize || 4096,
-      maxSize: config.maxSize || 100 * 1024 * 1024, // 100MB
-      defaultTTL: config.defaultTTL || 3600, // 1 hour
-      cleanupInterval: config.cleanupInterval || 300, // 5 minutes
-      compression: config.compression ?? true,
-      ...config,
-    }
-
-    this.stats = {
-      totalEntries: 0,
-      totalSize: 0,
-      hitRate: 0,
-      missRate: 0,
-      evictions: 0,
-      compressionRatio: 0,
-      averageAccessTime: 0,
-    }
-
-    this.initializeDatabase()
-    this.prepareStatements()
-    this.startCleanupTimer()
-  }
-
-  /**
-   * Get value from cache
-   */
-  get<T = any>(key: string): T | null {
-    const startTime = performance.now()
-
-    try {
-      const result = this.preparedStatements.get.get(key, Date.now()) as CacheEntry | null
-
-      if (!result) {
-        this.updateStats('miss', performance.now() - startTime)
-        return null
-      }
-
-      // Update access statistics
-      this.preparedStatements.touch.run(key, Date.now())
-
-      let value = result.value
-      if (result.compressed && this.config.compression) {
-        value = this.decompress(value)
-      }
-
-      this.updateStats('hit', performance.now() - startTime)
-      return JSON.parse(value)
-    }
-    catch (error) {
-      console.error('Cache get error:', error)
-      this.updateStats('miss', performance.now() - startTime)
-      return null
-    }
-  }
-
-  /**
-   * Set value in cache
-   */
-  set<T = any>(key: string, value: T, ttl?: number): boolean {
-    const startTime = performance.now()
-
-    try {
-      const serialized = JSON.stringify(value)
-      const expires = Date.now() + ((ttl || this.config.defaultTTL) * 1000)
-      const created = Date.now()
-
-      let finalValue = serialized
-      let compressed = false
-      let size = serialized.length
-
-      // Compress if enabled and value is large enough
-      if (this.config.compression && serialized.length > 1024) {
-        const compressedValue = this.compress(serialized)
-        if (compressedValue && compressedValue.length < serialized.length) {
-          finalValue = compressedValue
-          compressed = true
-          size = compressedValue.length
-        }
-      }
-
-      // Check if we need to evict entries
-      this.evictIfNeeded(size)
-
-      this.preparedStatements.set.run(
-        key,
-        finalValue,
-        expires,
-        created,
-        created, // accessed
-        0, // hits
-        size,
-        compressed ? 1 : 0,
-      )
-
-      this.updateCacheStats()
-      this.updateStats('set', performance.now() - startTime)
-      return true
-    }
-    catch (error) {
-      console.error('Cache set error:', error)
-      return false
-    }
-  }
-
-  /**
-   * Delete value from cache
-   */
-  delete(key: string): boolean {
-    try {
-      const result = this.preparedStatements.delete.run(key)
-      this.updateCacheStats()
-      return result.changes > 0
-    }
-    catch (error) {
-      console.error('Cache delete error:', error)
-      return false
-    }
-  }
-
-  /**
-   * Check if key exists in cache
-   */
-  has(key: string): boolean {
-    try {
-      const result = this.preparedStatements.exists.get(key, Date.now())
-      return result !== null
-    }
-    catch (error) {
-      console.error('Cache exists error:', error)
-      return false
-    }
-  }
-
-  /**
-   * Clear all cache entries
-   */
-  clear(): boolean {
-    try {
-      this.preparedStatements.clear.run()
-      this.updateCacheStats()
-      return true
-    }
-    catch (error) {
-      console.error('Cache clear error:', error)
-      return false
-    }
-  }
-
-  /**
-   * Get cache statistics
-   */
-  getStats(): CacheStats {
-    this.updateCacheStats()
-    return { ...this.stats }
-  }
-
-  /**
-   * Get all keys matching pattern
-   */
-  keys(pattern?: string): string[] {
-    try {
-      const query = pattern
-        ? this.db.query('SELECT key FROM cache WHERE key LIKE ? AND expires > ?')
-        : this.db.query('SELECT key FROM cache WHERE expires > ?')
-
-      const params = pattern ? [pattern, Date.now()] : [Date.now()]
-      const results = query.all(...params) as Array<{ key: string }>
-
-      return results.map(row => row.key)
-    }
-    catch (error) {
-      console.error('Cache keys error:', error)
-      return []
-    }
-  }
-
-  /**
-   * Get multiple values at once
-   */
-  mget<T = any>(keys: string[]): Record<string, T | null> {
-    const result: Record<string, T | null> = {}
-
-    for (const key of keys) {
-      result[key] = this.get<T>(key)
-    }
-
-    return result
-  }
-
-  /**
-   * Set multiple values at once
-   */
-  mset<T = any>(entries: Record<string, T>, ttl?: number): boolean {
-    const transaction = this.db.transaction(() => {
-      for (const [key, value] of Object.entries(entries)) {
-        this.set(key, value, ttl)
-      }
-    })
-
-    try {
-      transaction()
-      return true
-    }
-    catch (error) {
-      console.error('Cache mset error:', error)
-      return false
-    }
-  }
-
-  /**
-   * Increment numeric value
-   */
-  increment(key: string, delta: number = 1, ttl?: number): number | null {
-    const current = this.get<number>(key)
-    const newValue = (current || 0) + delta
-
-    if (this.set(key, newValue, ttl)) {
-      return newValue
-    }
-
-    return null
-  }
-
-  /**
-   * Decrement numeric value
-   */
-  decrement(key: string, delta: number = 1, ttl?: number): number | null {
-    return this.increment(key, -delta, ttl)
-  }
-
-  /**
-   * Set value only if key doesn't exist
-   */
-  setnx<T = any>(key: string, value: T, ttl?: number): boolean {
-    if (this.has(key)) {
-      return false
-    }
-    return this.set(key, value, ttl)
-  }
-
-  /**
-   * Get and delete value atomically
-   */
-  getdel<T = any>(key: string): T | null {
-    const value = this.get<T>(key)
-    if (value !== null) {
-      this.delete(key)
-    }
-    return value
-  }
-
-  /**
-   * Update TTL for existing key
-   */
-  expire(key: string, ttl: number): boolean {
-    try {
-      const expires = Date.now() + (ttl * 1000)
-      const result = this.db.query('UPDATE cache SET expires = ? WHERE key = ? AND expires > ?')
-        .run(expires, key, Date.now())
-
-      return result.changes > 0
-    }
-    catch (error) {
-      console.error('Cache expire error:', error)
-      return false
-    }
-  }
-
-  /**
-   * Get TTL for key
-   */
-  ttl(key: string): number {
-    try {
-      const result = this.db.query('SELECT expires FROM cache WHERE key = ? AND expires > ?')
-        .get(key, Date.now()) as { expires: number } | null
-
-      if (!result)
-        return -1
-
-      return Math.floor((result.expires - Date.now()) / 1000)
-    }
-    catch (error) {
-      console.error('Cache TTL error:', error)
-      return -1
-    }
-  }
-
-  /**
-   * Cleanup expired entries
-   */
-  cleanup(): number {
-    try {
-      const result = this.preparedStatements.cleanup.run(Date.now())
-      this.updateCacheStats()
-      return result.changes
-    }
-    catch (error) {
-      console.error('Cache cleanup error:', error)
-      return 0
-    }
-  }
-
-  /**
-   * Close database connection
-   */
-  close(): void {
-    if (this.cleanupTimer) {
-      clearInterval(this.cleanupTimer)
-    }
-    this.db.close()
-  }
-
-  /**
-   * Initialize SQLite database
-   */
-  private initializeDatabase(): void {
-    this.db = new Database(this.config.filename)
-
-    // Configure database
-    this.db.exec(`PRAGMA synchronous = ${this.config.synchronous}`)
-    this.db.exec(`PRAGMA journal_mode = ${this.config.journalMode}`)
-    this.db.exec(`PRAGMA cache_size = ${this.config.cacheSize}`)
-    this.db.exec(`PRAGMA page_size = ${this.config.pageSize}`)
-    this.db.exec('PRAGMA temp_store = MEMORY')
-    this.db.exec('PRAGMA mmap_size = 268435456') // 256MB
-
-    // Create cache table
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS cache (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL,
-        expires INTEGER NOT NULL,
-        created INTEGER NOT NULL,
-        accessed INTEGER NOT NULL,
-        hits INTEGER DEFAULT 0,
-        size INTEGER NOT NULL,
-        compressed INTEGER DEFAULT 0
-      )
-    `)
-
-    // Create indexes
-    this.db.exec('CREATE INDEX IF NOT EXISTS idx_expires ON cache(expires)')
-    this.db.exec('CREATE INDEX IF NOT EXISTS idx_accessed ON cache(accessed)')
-    this.db.exec('CREATE INDEX IF NOT EXISTS idx_size ON cache(size)')
-  }
-
-  /**
-   * Prepare SQL statements
-   */
-  private prepareStatements(): void {
-    this.preparedStatements = {
-      get: this.db.query(`
-        SELECT key, value, expires, created, accessed, hits, size, compressed
-        FROM cache
-        WHERE key = ? AND expires > ?
-      `),
-
-      set: this.db.query(`
-        INSERT OR REPLACE INTO cache
-        (key, value, expires, created, accessed, hits, size, compressed)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-      `),
-
-      delete: this.db.query('DELETE FROM cache WHERE key = ?'),
-
-      exists: this.db.query('SELECT 1 FROM cache WHERE key = ? AND expires > ?'),
-
-      clear: this.db.query('DELETE FROM cache'),
-
-      cleanup: this.db.query('DELETE FROM cache WHERE expires <= ?'),
-
-      stats: this.db.query(`
-        SELECT
-          COUNT(*) as total_entries,
-          SUM(size) as total_size,
-          AVG(hits) as avg_hits,
-          SUM(CASE WHEN compressed = 1 THEN size ELSE 0 END) as compressed_size
-        FROM cache
-        WHERE expires > ?
-      `),
-
-      touch: this.db.query(`
-        UPDATE cache
-        SET accessed = ?, hits = hits + 1
-        WHERE key = ?
-      `),
-    }
-  }
-
-  /**
-   * Start cleanup timer
-   */
-  private startCleanupTimer(): void {
-    this.cleanupTimer = setInterval(() => {
-      const cleaned = this.cleanup()
-      if (cleaned > 0) {
-        console.warn(`SQLite cache cleanup: removed ${cleaned} expired entries`)
-      }
-    }, this.config.cleanupInterval * 1000)
-  }
-
-  /**
-   * Evict entries if cache is too large
-   */
-  private evictIfNeeded(newEntrySize: number): void {
-    const currentStats = this.preparedStatements.stats.get(Date.now()) as {
-      total_entries: number
-      total_size: number
-    } | null
-
-    if (!currentStats)
-      return
-
-    const projectedSize = currentStats.total_size + newEntrySize
-
-    if (projectedSize > this.config.maxSize) {
-      // Evict least recently accessed entries
-      const toEvict = Math.ceil(currentStats.total_entries * 0.1) // Evict 10%
-
-      const evictQuery = this.db.query(`
-        DELETE FROM cache
-        WHERE key IN (
-          SELECT key FROM cache
-          WHERE expires > ?
-          ORDER BY accessed ASC
-          LIMIT ?
-        )
-      `)
-
-      const result = evictQuery.run(Date.now(), toEvict)
-      this.stats.evictions += result.changes
-    }
-  }
-
-  /**
-   * Update cache statistics
-   */
-  private updateCacheStats(): void {
-    try {
-      const result = this.preparedStatements.stats.get(Date.now()) as {
-        total_entries: number
-        total_size: number
-        avg_hits: number
-        compressed_size: number
-      } | null
-
-      if (result) {
-        this.stats.totalEntries = result.total_entries || 0
-        this.stats.totalSize = result.total_size || 0
-        this.stats.compressionRatio = result.total_size > 0
-          ? (result.compressed_size / result.total_size) * 100
-          : 0
-      }
-    }
-    catch (error) {
-      console.error('Error updating cache stats:', error)
-    }
-  }
-
-  /**
-   * Update operation statistics
-   */
-  private updateStats(operation: 'hit' | 'miss' | 'set', responseTime: number): void {
-    if (operation === 'hit') {
-      this.stats.hitRate = (this.stats.hitRate + 1) / 2
-    }
-    else if (operation === 'miss') {
-      this.stats.missRate = (this.stats.missRate + 1) / 2
-    }
-
-    this.stats.averageAccessTime = (this.stats.averageAccessTime + responseTime) / 2
-  }
-
-  /**
-   * Compress string value
-   */
-  private compress(value: string): string | null {
-    try {
-      const compressed = Bun.gzipSync(value)
-      return Buffer.from(compressed).toString('base64')
-    }
-    catch (error) {
-      console.error('Compression error:', error)
-      return null
-    }
-  }
-
-  /**
-   * Decompress string value
-   */
-  private decompress(value: string): string {
-    try {
-      const buffer = Buffer.from(value, 'base64')
-      const decompressed = Bun.gunzipSync(buffer)
-      return new TextDecoder().decode(decompressed)
-    }
-    catch (error) {
-      console.error('Decompression error:', error)
-      return value
-    }
-  }
-}
-
-/**
- * SQLite cache factory
- */
-export class SQLiteCacheFactory {
-  /**
-   * Create in-memory cache
-   */
-  static createMemoryCache(config?: Partial<SQLiteCacheConfig>): SQLiteCache {
-    return new SQLiteCache({
-      filename: ':memory:',
-      memory: true,
-      wal: false,
-      synchronous: 'OFF',
-      ...config,
-    })
-  }
-
-  /**
-   * Create persistent cache
-   */
-  static createPersistentCache(filename: string, config?: Partial<SQLiteCacheConfig>): SQLiteCache {
-    return new SQLiteCache({
-      filename,
-      memory: false,
-      wal: true,
-      synchronous: 'NORMAL',
-      ...config,
-    })
-  }
-
-  /**
-   * Create high-performance cache
-   */
-  static createHighPerformanceCache(config?: Partial<SQLiteCacheConfig>): SQLiteCache {
-    return new SQLiteCache({
-      filename: ':memory:',
-      memory: true,
-      wal: false,
-      synchronous: 'OFF',
-      cacheSize: 50000,
-      pageSize: 8192,
-      maxSize: 500 * 1024 * 1024, // 500MB
-      compression: true,
-      cleanupInterval: 60,
-      ...config,
-    })
-  }
-
-  /**
-   * Create development cache with debugging
-   */
-  static createDevelopmentCache(config?: Partial<SQLiteCacheConfig>): SQLiteCache {
-    return new SQLiteCache({
-      filename: 'dev-cache.db',
-      memory: false,
-      wal: true,
-      synchronous: 'FULL',
-      maxSize: 50 * 1024 * 1024, // 50MB
-      compression: false,
-      cleanupInterval: 30,
-      ...config,
-    })
-  }
-}
-
-/**
- * Cache middleware factory
- */
-export function createSQLiteCacheMiddleware(cache: SQLiteCache, options: {
-  keyGenerator?: (request: Request) => string
-  ttl?: number
-  skipMethods?: string[]
-  skipPaths?: string[]
-  skipHeaders?: string[]
-} = {}) {
-  const {
-    keyGenerator = req => `${req.method}:${new URL(req.url).pathname}`,
-    ttl = 300, // 5 minutes
-    skipMethods = ['POST', 'PUT', 'PATCH', 'DELETE'],
-    skipPaths = [],
-    skipHeaders = ['authorization', 'cookie'],
-  } = options
-
-  return async (request: Request, next: () => Promise<Response>): Promise<Response> => {
-    // Skip caching for certain methods
-    if (skipMethods.includes(request.method)) {
-      return await next()
-    }
-
-    // Skip caching for certain paths
-    const url = new URL(request.url)
-    if (skipPaths.some(path => url.pathname.startsWith(path))) {
-      return await next()
-    }
-
-    // Skip caching if certain headers are present
-    if (skipHeaders.some(header => request.headers.has(header))) {
-      return await next()
-    }
-
-    const cacheKey = keyGenerator(request)
-
-    // Try to get from cache
-    const cached = cache.get<{
-      status: number
-      headers: Record<string, string>
-      body: string
-    }>(cacheKey)
-
-    if (cached) {
-      return new Response(cached.body, {
-        status: cached.status,
-        headers: {
-          ...cached.headers,
-          'X-Cache': 'HIT',
-        },
-      })
-    }
-
-    // Get response and cache it
-    const response = await next()
-
-    // Only cache successful responses
-    if (response.status >= 200 && response.status < 300) {
-      const body = await response.text()
-      const headers = Object.fromEntries(response.headers.entries())
-
-      cache.set(cacheKey, {
-        status: response.status,
-        headers,
-        body,
-      }, ttl)
-
-      return new Response(body, {
-        status: response.status,
-        headers: {
-          ...response.headers,
-          'X-Cache': 'MISS',
-        },
-      })
-    }
-
-    return response
-  }
-}
-
-/**
- * SQLite cache helpers
- */
-export const SQLiteCacheHelpers = {
-  /**
-   * Create session cache
-   */
-  createSessionCache: (cache: SQLiteCache): {
-    get: (sessionId: string) => any
-    set: (sessionId: string, data: any, ttl?: number) => void
-    delete: (sessionId: string) => boolean
-    touch: (sessionId: string, ttl?: number) => boolean
-  } => ({
-    get: (sessionId: string): any => cache.get(`session:${sessionId}`),
-    set: (sessionId: string, data: any, ttl = 3600): void => { cache.set(`session:${sessionId}`, data, ttl) },
-    delete: (sessionId: string): boolean => cache.delete(`session:${sessionId}`),
-    touch: (sessionId: string, ttl = 3600): boolean => cache.expire(`session:${sessionId}`, ttl),
-  }),
-
-  /**
-   * Create rate limiting cache
-   */
-  createRateLimitCache: (cache: SQLiteCache): {
-    increment: (key: string, window?: number) => number
-    get: (key: string) => number
-    reset: (key: string) => boolean
-  } => ({
-    increment: (key: string, window = 60): number => {
-      const current = cache.get<number>(`rate:${key}`) || 0
-      const newValue = current + 1
-      cache.set(`rate:${key}`, newValue, window)
-      return newValue
-    },
-
-    get: (key: string): number => cache.get<number>(`rate:${key}`) || 0,
-
-    reset: (key: string): boolean => cache.delete(`rate:${key}`),
-  }),
-
-  /**
-   * Create query result cache
-   */
-  createQueryCache: (cache: SQLiteCache): {
-    get: (query: string, params: any[]) => any
-    set: (query: string, params: any[], result: any, ttl?: number) => void
-    invalidate: (pattern: string) => void
-  } => ({
-    get: (query: string, params: any[]): any => {
-      const key = `query:${Bun.hash(query + JSON.stringify(params))}`
-      return cache.get(key)
-    },
-
-    set: (query: string, params: any[], result: any, ttl = 300): void => {
-      const key = `query:${Bun.hash(query + JSON.stringify(params))}`
-      cache.set(key, result, ttl)
-    },
-
-    invalidate: (pattern: string): void => {
-      const keys = cache.keys(`query:*${pattern}*`)
-      keys.forEach(key => cache.delete(key))
-    },
-  }),
-}