@stacksjs/bun-router 0.0.2

package/dist/cache/route-cache-warmer.d.ts

@@ -0,0 +1,125 @@
+import type { LRUCache } from './lru-cache';
+import type { StreamingCache } from './streaming-cache';
+/**
+ * Factory functions for creating route cache warmers
+ */
+export declare const createRouteCacheWarmer: {
+  /**
+   * Create warmer for development environment
+   */
+  development: (routeCache: LRUCache<any>, streamingCache?: StreamingCache) => any;
+  /**
+   * Create warmer for production environment
+   */
+  production: (routeCache: LRUCache<any>, streamingCache?: StreamingCache) => any;
+  /**
+   * Create warmer with custom configuration
+   */
+  custom: ( config: WarmupConfig, routeCache: LRUCache<any>, streamingCache?: StreamingCache, ) => any
+};
+/**
+ * Route cache warming system for pre-populating caches with common routes
+ */
+export declare interface WarmupRoute {
+  path: string
+  method: string
+  priority: number
+  frequency: number
+  params?: Record<string, string>
+  query?: Record<string, string>
+  headers?: Record<string, string>
+  warmupData?: any
+}
+export declare interface AnalyticsRoute {
+  path: string
+  method: string
+  frequency: number
+}
+export declare interface RecentRoute {
+  path: string
+  method: string
+  timestamp: number
+}
+export declare interface PrecomputeRoute {
+  path: string
+  method: string
+  computeFunction: () => Promise<any>
+  cacheKey?: string
+  ttl?: number
+}
+export declare interface UserSegment {
+  segment: string
+  commonRoutes: string[]
+  priority: number
+}
+export declare interface TimeRange {
+  start: number
+  end: number
+}
+export declare interface TimeBasedPattern {
+  timeRange: TimeRange
+  routes: string[]
+  priority: number
+}
+export declare interface GeographicPattern {
+  region: string
+  routes: string[]
+  priority: number
+}
+export declare interface IntelligentWarmupPatterns {
+  userSegments?: UserSegment[]
+  timeBasedPatterns?: TimeBasedPattern[]
+  geographicPatterns?: GeographicPattern[]
+}
+export declare interface WarmupConfig {
+  enabled: boolean
+  maxConcurrency: number
+  warmupTimeout: number
+  retryAttempts: number
+  retryDelay: number
+  scheduleInterval?: number
+  priorityThreshold: number
+}
+export declare interface WarmupStats {
+  totalRoutes: number
+  successfulWarmups: number
+  failedWarmups: number
+  averageWarmupTime: number
+  lastWarmupTime: number
+  cacheHitRateImprovement: number
+}
+/**
+ * Route cache warmer for pre-populating caches with frequently accessed routes
+ */
+export declare class RouteCacheWarmer {
+  private routes: WarmupRoute[];
+  private routeCache: LRUCache<any>;
+  private streamingCache?: StreamingCache;
+  private stats: WarmupStats;
+  private warmupTimer?: Timer;
+  private config: WarmupConfig;
+  constructor(config: WarmupConfig, routeCache: LRUCache<any>, streamingCache?: StreamingCache);
+  registerRoutes(routes: WarmupRoute[]): void;
+  registerRoute(route: WarmupRoute): void;
+  warmCache(options?: {
+    routes?: string[] // Specific routes to warm (by path)
+    maxRoutes?: number // Maximum number of routes to warm
+    skipLowPriority?: boolean
+  }): Promise<WarmupStats>;
+  warmFromAnalytics(analytics: {
+    topRoutes: AnalyticsRoute[]
+    recentRoutes: RecentRoute[]
+  }): Promise<void>;
+  precomputeRoutes(routes: PrecomputeRoute[]): Promise<number>;
+  intelligentWarmup(patterns: IntelligentWarmupPatterns): Promise<void>;
+  getStats(): WarmupStats;
+  resetStats(): void;
+  stop(): void;
+  private warmRoutesWithConcurrency(routes: WarmupRoute[]): Promise<{
+    successful: number
+    failed: number
+  }>;
+  private warmSingleRoute(route: WarmupRoute): Promise<void>;
+  private buildRouteUrl(route: WarmupRoute): string;
+  private schedulePeriodicWarmup(): void;
+}

package/dist/cache/sqlite-cache.d.ts

@@ -0,0 +1,114 @@
+import { Database } from 'bun:sqlite';
+/**
+ * Cache middleware factory
+ */
+export declare function createSQLiteCacheMiddleware(cache: SQLiteCache, options?: {
+  keyGenerator?: (request: Request) => string
+  ttl?: number
+  skipMethods?: string[]
+  skipPaths?: string[]
+  skipHeaders?: string[]
+}): void;
+/**
+ * SQLite cache helpers
+ */
+export declare const SQLiteCacheHelpers: {
+  /**
+   * Create session cache
+   */
+  createSessionCache: (cache: SQLiteCache) => unknown;
+  /**
+   * Create rate limiting cache
+   */
+  createRateLimitCache: (cache: SQLiteCache) => unknown;
+  /**
+   * Create query result cache
+   */
+  createQueryCache: (cache: SQLiteCache) => unknown
+};
+export declare 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 declare interface CacheEntry {
+  key: string
+  value: string
+  expires: number
+  created: number
+  accessed: number
+  hits: number
+  size: number
+  compressed: boolean
+}
+export declare interface CacheStats {
+  totalEntries: number
+  totalSize: number
+  hitRate: number
+  missRate: number
+  evictions: number
+  compressionRatio: number
+  averageAccessTime: number
+}
+/**
+ * High-performance SQLite-based cache
+ */
+export declare class SQLiteCache {
+  private db: Database;
+  private config: Required<SQLiteCacheConfig>;
+  private stats: CacheStats;
+  private cleanupTimer?: Timer;
+  private preparedStatements: {
+    get: any
+    set: any
+    delete: any
+    exists: any
+    clear: any
+    cleanup: any
+    stats: any
+    touch: any
+  };
+  constructor(config?: SQLiteCacheConfig);
+  get<T = any>(key: string): T | null;
+  set<T = any>(key: string, value: T, ttl?: number): boolean;
+  delete(key: string): boolean;
+  has(key: string): boolean;
+  clear(): boolean;
+  getStats(): CacheStats;
+  keys(pattern?: string): string[];
+  mget<T = any>(keys: string[]): Record<string, T | null>;
+  mset<T = any>(entries: Record<string, T>, ttl?: number): boolean;
+  increment(key: string, delta?: number, ttl?: number): number | null;
+  decrement(key: string, delta?: number, ttl?: number): number | null;
+  setnx<T = any>(key: string, value: T, ttl?: number): boolean;
+  getdel<T = any>(key: string): T | null;
+  expire(key: string, ttl: number): boolean;
+  ttl(key: string): number;
+  cleanup(): number;
+  close(): void;
+  private initializeDatabase(): void;
+  private prepareStatements(): void;
+  private startCleanupTimer(): void;
+  private evictIfNeeded(newEntrySize: number): void;
+  private updateCacheStats(): void;
+  private updateStats(operation: 'hit' | 'miss' | 'set', responseTime: number): void;
+  private compress(value: string): string | null;
+  private decompress(value: string): string;
+}
+/**
+ * SQLite cache factory
+ */
+export declare class SQLiteCacheFactory {
+  static createMemoryCache(config?: Partial<SQLiteCacheConfig>): SQLiteCache;
+  static createPersistentCache(filename: string, config?: Partial<SQLiteCacheConfig>): SQLiteCache;
+  static createHighPerformanceCache(config?: Partial<SQLiteCacheConfig>): SQLiteCache;
+  static createDevelopmentCache(config?: Partial<SQLiteCacheConfig>): SQLiteCache;
+}

package/dist/cache/streaming-cache.d.ts

@@ -0,0 +1,86 @@
+import { LRUCache } from './lru-cache';
+import type { LRUCacheOptions } from './lru-cache';
+/**
+ * Factory functions for creating streaming caches with common configurations
+ */
+export declare const createStreamingCache: {
+  /**
+   * Create cache optimized for API responses
+   */
+  api: (maxSize: number?) => any;
+  /**
+   * Create cache optimized for static assets
+   */
+  assets: (maxSize: number?) => any;
+  /**
+   * Create cache optimized for HTML pages
+   */
+  pages: (maxSize: number?) => any;
+  /**
+   * Create custom configured streaming cache
+   */
+  custom: (options: StreamingCacheOptions) => any
+};
+/**
+ * Response streaming cache for large responses
+ * Optimized for handling large payloads with memory-efficient streaming
+ */
+export declare interface StreamingCacheOptions extends Omit<LRUCacheOptions, 'maxSize'> {
+  maxSize: number
+  maxResponseSize: number
+  chunkSize: number
+  compressionEnabled: boolean
+  compressionThreshold: number
+}
+export declare interface CachedResponse {
+  status: number
+  statusText: string
+  headers: Record<string, string>
+  body: Uint8Array | null
+  compressed: boolean
+  originalSize: number
+  timestamp: number
+  etag?: string
+}
+export declare interface StreamingCacheStats {
+  totalResponses: number
+  totalSize: number
+  compressionRatio: number
+  averageResponseSize: number
+  largestResponse: number
+  streamingHits: number
+  streamingMisses: number
+}
+/**
+ * High-performance streaming cache for large HTTP responses
+ */
+export declare class StreamingCache {
+  private cache: LRUCache<CachedResponse>;
+  private stats: StreamingCacheStats;
+  private options: StreamingCacheOptions;
+  constructor(options: StreamingCacheOptions);
+  cacheResponse(key: string, response: Response, options?: {
+      ttl?: number
+      forceCache?: boolean
+      generateETag?: boolean
+    }): Promise<void>;
+  getStreamingResponse(key: string): Promise<Response | null>;
+  shouldCache(response: Response): boolean;
+  warmCache(routes: Array<{
+    key: string
+    url: string
+    method?: string
+    headers?: Record<string, string>
+  }>): Promise<number>;
+  createConditionalResponse(key: string, ifNoneMatch?: string): Response | null;
+  getStats(): StreamingCacheStats & { lruStats: any };
+  clear(): void;
+  prune(): number;
+  private createStreamingResponse(body: Uint8Array, cachedResponse: CachedResponse, headers: Headers): Response;
+  private extractHeaders(response: Response): Record<string, string>;
+  private compressData(data: Uint8Array): Promise<Uint8Array>;
+  private decompressData(data: Uint8Array): Promise<Uint8Array>;
+  private generateETag(data: Uint8Array): Promise<string>;
+  private updateStatsOnCache(originalSize: number, compressedSize: number): void;
+  private updateStatsOnEviction(cachedResponse: CachedResponse): void;
+}