@stacksjs/bun-router 0.0.13 → 0.0.14

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

@@ -1,161 +0,0 @@
-import type { LRUCache } from './lru-cache';
-import type { StreamingCache } from './streaming-cache';
-/**
- * Route cache warming system for pre-populating caches with common routes
- */
-export 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 interface AnalyticsRoute {
-    path: string;
-    method: string;
-    frequency: number;
-}
-export interface RecentRoute {
-    path: string;
-    method: string;
-    timestamp: number;
-}
-export interface PrecomputeRoute {
-    path: string;
-    method: string;
-    computeFunction: () => Promise<any>;
-    cacheKey?: string;
-    ttl?: number;
-}
-export interface UserSegment {
-    segment: string;
-    commonRoutes: string[];
-    priority: number;
-}
-export interface TimeRange {
-    start: number;
-    end: number;
-}
-export interface TimeBasedPattern {
-    timeRange: TimeRange;
-    routes: string[];
-    priority: number;
-}
-export interface GeographicPattern {
-    region: string;
-    routes: string[];
-    priority: number;
-}
-export interface IntelligentWarmupPatterns {
-    userSegments?: UserSegment[];
-    timeBasedPatterns?: TimeBasedPattern[];
-    geographicPatterns?: GeographicPattern[];
-}
-export interface WarmupConfig {
-    enabled: boolean;
-    maxConcurrency: number;
-    warmupTimeout: number;
-    retryAttempts: number;
-    retryDelay: number;
-    scheduleInterval?: number;
-    priorityThreshold: number;
-}
-export 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 config;
-    private routes;
-    private routeCache;
-    private streamingCache?;
-    private stats;
-    private warmupTimer?;
-    constructor(config: WarmupConfig, routeCache: LRUCache<any>, streamingCache?: StreamingCache);
-    /**
-     * Register routes for cache warming
-     */
-    registerRoutes(routes: WarmupRoute[]): void;
-    /**
-     * Register a single route for cache warming
-     */
-    registerRoute(route: WarmupRoute): void;
-    /**
-     * Warm cache with registered routes
-     */
-    warmCache(options?: {
-        routes?: string[];
-        maxRoutes?: number;
-        skipLowPriority?: boolean;
-    }): Promise<WarmupStats>;
-    /**
-     * Warm specific route patterns based on analytics
-     */
-    warmFromAnalytics(analytics: {
-        topRoutes: AnalyticsRoute[];
-        recentRoutes: RecentRoute[];
-    }): Promise<void>;
-    /**
-     * Pre-compute and cache expensive route operations
-     */
-    precomputeRoutes(routes: PrecomputeRoute[]): Promise<number>;
-    /**
-     * Warm cache based on route patterns and user behavior
-     */
-    intelligentWarmup(patterns: IntelligentWarmupPatterns): Promise<void>;
-    /**
-     * Get cache warming statistics
-     */
-    getStats(): WarmupStats;
-    /**
-     * Clear warmup statistics
-     */
-    resetStats(): void;
-    /**
-     * Stop periodic warmup
-     */
-    stop(): void;
-    /**
-     * Warm routes with concurrency control
-     */
-    private warmRoutesWithConcurrency;
-    /**
-     * Warm a single route
-     */
-    private warmSingleRoute;
-    /**
-     * Build URL for route warming
-     */
-    private buildRouteUrl;
-    /**
-     * Schedule periodic cache warmup
-     */
-    private schedulePeriodicWarmup;
-}
-/**
- * Factory functions for creating route cache warmers
- */
-export declare const createRouteCacheWarmer: {
-    /**
-     * Create warmer for development environment
-     */
-    development: (routeCache: LRUCache<any>, streamingCache?: StreamingCache) => RouteCacheWarmer;
-    /**
-     * Create warmer for production environment
-     */
-    production: (routeCache: LRUCache<any>, streamingCache?: StreamingCache) => RouteCacheWarmer;
-    /**
-     * Create warmer with custom configuration
-     */
-    custom: (config: WarmupConfig, routeCache: LRUCache<any>, streamingCache?: StreamingCache) => RouteCacheWarmer;
-};

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

@@ -1,209 +0,0 @@
-/**
- * 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

@@ -1,132 +0,0 @@
-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;
-};