@ordojs/core/dist/database/cache-manager.d.ts

Core compiler and runtime for OrdoJS framework

/**
 * @fileoverview OrdoJS Cache Manager - Comprehensive caching and real-time data management
 */
/**
 * Cache configuration
 */
export interface CacheConfig {
    /** Cache type */
    type: 'memory' | 'redis' | 'file' | 'hybrid';
    /** Redis configuration */
    redis?: RedisConfig;
    /** File cache configuration */
    file?: FileCacheConfig;
    /** Default TTL in seconds */
    defaultTTL: number;
    /** Maximum cache size */
    maxSize: number;
    /** Whether to enable compression */
    enableCompression: boolean;
    /** Whether to enable encryption */
    enableEncryption: boolean;
    /** Encryption key */
    encryptionKey?: string;
    /** Whether to enable real-time sync */
    enableRealtimeSync: boolean;
    /** Real-time sync interval in milliseconds */
    syncInterval: number;
    /** Whether to enable cache warming */
    enableCacheWarming: boolean;
    /** Cache warming strategies */
    warmingStrategies: WarmingStrategy[];
    /** Whether to enable cache analytics */
    enableAnalytics: boolean;
    /** Analytics retention period in days */
    analyticsRetention: number;
}
/**
 * Redis configuration
 */
export interface RedisConfig {
    /** Redis host */
    host: string;
    /** Redis port */
    port: number;
    /** Redis password */
    password?: string;
    /** Redis database */
    database: number;
    /** Connection timeout */
    timeout: number;
    /** Retry strategy */
    retryStrategy: 'exponential' | 'linear' | 'fixed';
    /** Max retry attempts */
    maxRetries: number;
}
/**
 * File cache configuration
 */
export interface FileCacheConfig {
    /** Cache directory */
    directory: string;
    /** File extension */
    extension: string;
    /** Whether to enable subdirectories */
    enableSubdirectories: boolean;
    /** Maximum file size in bytes */
    maxFileSize: number;
    /** Cleanup interval in milliseconds */
    cleanupInterval: number;
}
/**
 * Warming strategy
 */
export interface WarmingStrategy {
    /** Strategy name */
    name: string;
    /** Strategy type */
    type: 'preload' | 'background' | 'on-demand';
    /** Cache keys pattern */
    pattern: string;
    /** Data source */
    dataSource: string;
    /** Schedule (cron expression) */
    schedule?: string;
    /** Priority */
    priority: number;
}
/**
 * Cache entry
 */
export interface CacheEntry<T = any> {
    /** Cache key */
    key: string;
    /** Cached data */
    data: T;
    /** Expiration time */
    expiresAt: Date;
    /** Created time */
    createdAt: Date;
    /** Last accessed time */
    lastAccessed: Date;
    /** Access count */
    accessCount: number;
    /** Size in bytes */
    size: number;
    /** Tags */
    tags: string[];
    /** Metadata */
    metadata: Record<string, any>;
}
/**
 * Cache result
 */
export interface CacheResult<T = any> {
    /** Cache hit */
    hit: boolean;
    /** Cached data */
    data?: T;
    /** Cache key */
    key: string;
    /** TTL remaining */
    ttl?: number;
    /** Cache metadata */
    metadata?: CacheMetadata;
    /** Error message */
    error?: string;
}
/**
 * Cache metadata
 */
export interface CacheMetadata {
    /** Cache type */
    type: string;
    /** Cache size */
    size: number;
    /** Hit rate */
    hitRate: number;
    /** Miss rate */
    missRate: number;
    /** Average access time */
    averageAccessTime: number;
    /** Last cleanup */
    lastCleanup: Date;
    /** Memory usage */
    memoryUsage: number;
}
/**
 * Cache analytics
 */
export interface CacheAnalytics {
    /** Total requests */
    totalRequests: number;
    /** Cache hits */
    hits: number;
    /** Cache misses */
    misses: number;
    /** Hit rate percentage */
    hitRate: number;
    /** Average response time */
    averageResponseTime: number;
    /** Memory usage */
    memoryUsage: number;
    /** Disk usage */
    diskUsage: number;
    /** Top accessed keys */
    topKeys: Array<{
        key: string;
        count: number;
    }>;
    /** Performance metrics */
    performance: PerformanceMetrics;
}
/**
 * Performance metrics
 */
export interface PerformanceMetrics {
    /** Read operations per second */
    readsPerSecond: number;
    /** Write operations per second */
    writesPerSecond: number;
    /** Delete operations per second */
    deletesPerSecond: number;
    /** Average read time */
    averageReadTime: number;
    /** Average write time */
    averageWriteTime: number;
    /** Average delete time */
    averageDeleteTime: number;
}
/**
 * Real-time sync event
 */
export interface RealtimeSyncEvent {
    /** Event type */
    type: 'set' | 'delete' | 'clear' | 'expire';
    /** Cache key */
    key: string;
    /** Event data */
    data?: any;
    /** Timestamp */
    timestamp: Date;
    /** Source node */
    sourceNode: string;
}
/**
 * Comprehensive cache manager for OrdoJS applications
 */
export declare class CacheManager {
    private config;
    private memoryCache;
    private redisClient;
    private fileCache;
    private analytics;
    private syncEvents;
    private warmingJobs;
    private cleanupInterval;
    private syncInterval;
    constructor(config?: Partial<CacheConfig>);
    /**
     * Set cache entry
     */
    set<T = any>(key: string, data: T, ttl?: number, tags?: string[], metadata?: Record<string, any>): Promise<CacheResult<T>>;
    /**
     * Get cache entry
     */
    get<T = any>(key: string): Promise<CacheResult<T>>;
    /**
     * Delete cache entry
     */
    delete(key: string): Promise<CacheResult>;
    /**
     * Clear all cache entries
     */
    clear(): Promise<CacheResult>;
    /**
     * Get cache entries by tag
     */
    getByTag<T = any>(tag: string): Promise<CacheResult<T[]>[]>;
    /**
     * Delete cache entries by tag
     */
    deleteByTag(tag: string): Promise<CacheResult>;
    /**
     * Get cache statistics
     */
    getStatistics(): CacheAnalytics;
    /**
     * Warm cache
     */
    warmCache(): Promise<void>;
    /**
     * Add warming strategy
     */
    addWarmingStrategy(strategy: WarmingStrategy): void;
    /**
     * Remove warming strategy
     */
    removeWarmingStrategy(name: string): void;
    /**
     * Get cache metadata
     */
    getMetadata(): CacheMetadata;
    /**
     * Cleanup expired entries
     */
    cleanup(): Promise<void>;
    /**
     * Initialize cache
     */
    private initializeCache;
    /**
     * Initialize Redis cache
     */
    private initializeRedisCache;
    /**
     * Initialize file cache
     */
    private initializeFileCache;
    /**
     * Initialize hybrid cache
     */
    private initializeHybridCache;
    /**
     * Set memory cache entry
     */
    private setMemoryCache;
    /**
     * Get memory cache entry
     */
    private getMemoryCache;
    /**
     * Set Redis cache entry
     */
    private setRedisCache;
    /**
     * Get Redis cache entry
     */
    private getRedisCache;
    /**
     * Delete Redis cache entry
     */
    private deleteRedisCache;
    /**
     * Clear Redis cache
     */
    private clearRedisCache;
    /**
     * Set file cache entry
     */
    private setFileCache;
    /**
     * Get file cache entry
     */
    private getFileCache;
    /**
     * Delete file cache entry
     */
    private deleteFileCache;
    /**
     * Clear file cache
     */
    private clearFileCache;
    /**
     * Set hybrid cache entry
     */
    private setHybridCache;
    /**
     * Get hybrid cache entry
     */
    private getHybridCache;
    /**
     * Delete hybrid cache entry
     */
    private deleteHybridCache;
    /**
     * Clear hybrid cache
     */
    private clearHybridCache;
    /**
     * Get Redis cache by tag
     */
    private getRedisCacheByTag;
    /**
     * Get file cache by tag
     */
    private getFileCacheByTag;
    /**
     * Get hybrid cache by tag
     */
    private getHybridCacheByTag;
    /**
     * Serialize cache entry
     */
    private serializeEntry;
    /**
     * Deserialize cache entry
     */
    private deserializeEntry;
    /**
     * Calculate data size
     */
    private calculateSize;
    /**
     * Calculate total cache size
     */
    private calculateTotalSize;
    /**
     * Enforce memory limit
     */
    private enforceMemoryLimit;
    /**
     * Get memory usage
     */
    private getMemoryUsage;
    /**
     * Update analytics
     */
    private updateAnalytics;
    /**
     * Update top keys
     */
    private updateTopKeys;
    /**
     * Trigger sync event
     */
    private triggerSyncEvent;
    /**
     * Sync cache
     */
    private syncCache;
    /**
     * Execute warming strategy
     */
    private executeWarmingStrategy;
    /**
     * Get cache filename
     */
    private getCacheFilename;
    /**
     * Hash string
     */
    private hashString;
    /**
     * Cleanup analytics
     */
    private cleanupAnalytics;
    /**
     * Cleanup Redis cache
     */
    private cleanupRedisCache;
    /**
     * Cleanup file cache
     */
    private cleanupFileCache;
    /**
     * Cleanup hybrid cache
     */
    private cleanupHybridCache;
}
//# sourceMappingURL=cache-manager.d.ts.map