@stacksjs/bun-router 0.0.4 → 0.0.6

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

@@ -0,0 +1,209 @@
+/**
+ * SQLite Embedded Caching
+ *
+ * High-performance embedded caching using Bun's SQLite integration
+ */
+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 declare class SQLiteCache {
+    private db;
+    private config;
+    private stats;
+    private cleanupTimer?;
+    private preparedStatements;
+    constructor(config?: SQLiteCacheConfig);
+    /**
+     * Get value from cache
+     */
+    get<T = any>(key: string): T | null;
+    /**
+     * Set value in cache
+     */
+    set<T = any>(key: string, value: T, ttl?: number): boolean;
+    /**
+     * Delete value from cache
+     */
+    delete(key: string): boolean;
+    /**
+     * Check if key exists in cache
+     */
+    has(key: string): boolean;
+    /**
+     * Clear all cache entries
+     */
+    clear(): boolean;
+    /**
+     * Get cache statistics
+     */
+    getStats(): CacheStats;
+    /**
+     * Get all keys matching pattern
+     */
+    keys(pattern?: string): string[];
+    /**
+     * Get multiple values at once
+     */
+    mget<T = any>(keys: string[]): Record<string, T | null>;
+    /**
+     * Set multiple values at once
+     */
+    mset<T = any>(entries: Record<string, T>, ttl?: number): boolean;
+    /**
+     * Increment numeric value
+     */
+    increment(key: string, delta?: number, ttl?: number): number | null;
+    /**
+     * Decrement numeric value
+     */
+    decrement(key: string, delta?: number, ttl?: number): number | null;
+    /**
+     * Set value only if key doesn't exist
+     */
+    setnx<T = any>(key: string, value: T, ttl?: number): boolean;
+    /**
+     * Get and delete value atomically
+     */
+    getdel<T = any>(key: string): T | null;
+    /**
+     * Update TTL for existing key
+     */
+    expire(key: string, ttl: number): boolean;
+    /**
+     * Get TTL for key
+     */
+    ttl(key: string): number;
+    /**
+     * Cleanup expired entries
+     */
+    cleanup(): number;
+    /**
+     * Close database connection
+     */
+    close(): void;
+    /**
+     * Initialize SQLite database
+     */
+    private initializeDatabase;
+    /**
+     * Prepare SQL statements
+     */
+    private prepareStatements;
+    /**
+     * Start cleanup timer
+     */
+    private startCleanupTimer;
+    /**
+     * Evict entries if cache is too large
+     */
+    private evictIfNeeded;
+    /**
+     * Update cache statistics
+     */
+    private updateCacheStats;
+    /**
+     * Update operation statistics
+     */
+    private updateStats;
+    /**
+     * Compress string value
+     */
+    private compress;
+    /**
+     * Decompress string value
+     */
+    private decompress;
+}
+/**
+ * SQLite cache factory
+ */
+export declare class SQLiteCacheFactory {
+    /**
+     * Create in-memory cache
+     */
+    static createMemoryCache(config?: Partial<SQLiteCacheConfig>): SQLiteCache;
+    /**
+     * Create persistent cache
+     */
+    static createPersistentCache(filename: string, config?: Partial<SQLiteCacheConfig>): SQLiteCache;
+    /**
+     * Create high-performance cache
+     */
+    static createHighPerformanceCache(config?: Partial<SQLiteCacheConfig>): SQLiteCache;
+    /**
+     * Create development cache with debugging
+     */
+    static createDevelopmentCache(config?: Partial<SQLiteCacheConfig>): SQLiteCache;
+}
+/**
+ * Cache middleware factory
+ */
+export declare function createSQLiteCacheMiddleware(cache: SQLiteCache, options?: {
+    keyGenerator?: (request: Request) => string;
+    ttl?: number;
+    skipMethods?: string[];
+    skipPaths?: string[];
+    skipHeaders?: string[];
+}): (request: Request, next: () => Promise<Response>) => Promise<Response>;
+/**
+ * SQLite cache helpers
+ */
+export declare 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;
+    };
+    /**
+     * Create rate limiting cache
+     */
+    createRateLimitCache: (cache: SQLiteCache) => {
+        increment: (key: string, window?: number) => number;
+        get: (key: string) => number;
+        reset: (key: string) => boolean;
+    };
+    /**
+     * 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;
+    };
+};

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

@@ -0,0 +1,132 @@
+import type { LRUCacheOptions } from './lru-cache';
+/**
+ * Response streaming cache for large responses
+ * Optimized for handling large payloads with memory-efficient streaming
+ */
+export interface StreamingCacheOptions extends Omit<LRUCacheOptions, 'maxSize'> {
+    maxSize: number;
+    maxResponseSize: number;
+    chunkSize: number;
+    compressionEnabled: boolean;
+    compressionThreshold: number;
+}
+export interface CachedResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: Uint8Array | null;
+    compressed: boolean;
+    originalSize: number;
+    timestamp: number;
+    etag?: string;
+}
+export 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 options;
+    private cache;
+    private stats;
+    constructor(options: StreamingCacheOptions);
+    /**
+     * Cache a response with streaming support
+     */
+    cacheResponse(key: string, response: Response, options?: {
+        ttl?: number;
+        forceCache?: boolean;
+        generateETag?: boolean;
+    }): Promise<void>;
+    /**
+     * Get cached response as a streaming response
+     */
+    getStreamingResponse(key: string): Promise<Response | null>;
+    /**
+     * Check if response should be cached based on headers and size
+     */
+    shouldCache(response: Response): boolean;
+    /**
+     * Warm cache with common routes
+     */
+    warmCache(routes: Array<{
+        key: string;
+        url: string;
+        method?: string;
+        headers?: Record<string, string>;
+    }>): Promise<number>;
+    /**
+     * Create conditional response based on ETag
+     */
+    createConditionalResponse(key: string, ifNoneMatch?: string): Response | null;
+    /**
+     * Get cache statistics
+     */
+    getStats(): StreamingCacheStats & {
+        lruStats: any;
+    };
+    /**
+     * Clear cache and reset statistics
+     */
+    clear(): void;
+    /**
+     * Prune expired entries
+     */
+    prune(): number;
+    /**
+     * Create streaming response for large payloads
+     */
+    private createStreamingResponse;
+    /**
+     * Extract headers from response (excluding hop-by-hop headers)
+     */
+    private extractHeaders;
+    /**
+     * Compress data using gzip
+     */
+    private compressData;
+    /**
+     * Decompress data using gzip
+     */
+    private decompressData;
+    /**
+     * Generate ETag for response body
+     */
+    private generateETag;
+    /**
+     * Update statistics when caching a response
+     */
+    private updateStatsOnCache;
+    /**
+     * Update statistics when evicting a response
+     */
+    private updateStatsOnEviction;
+}
+/**
+ * Factory functions for creating streaming caches with common configurations
+ */
+export declare const createStreamingCache: {
+    /**
+     * Create cache optimized for API responses
+     */
+    api: (maxSize?: number) => StreamingCache;
+    /**
+     * Create cache optimized for static assets
+     */
+    assets: (maxSize?: number) => StreamingCache;
+    /**
+     * Create cache optimized for HTML pages
+     */
+    pages: (maxSize?: number) => StreamingCache;
+    /**
+     * Create custom configured streaming cache
+     */
+    custom: (options: StreamingCacheOptions) => StreamingCache;
+};