# API Caching > **Skill Purpose:** API response caching strategies, cache management, and performance optimization patterns --- ## Core Skill Pattern **Objective:** Establish comprehensive API caching patterns with intelligent cache management, invalidation strategies, and performance optimization. **Universal Pattern:** 1. Define caching strategies and algorithms 2. Create cache key generation and management 3. Set up cache invalidation and refresh procedures 4. Establish cache monitoring and optimization 5. Create cache warming and preloading procedures **Key Decisions (Project-Specific):** - Caching strategy and algorithm selection - Cache storage mechanism and configuration - Cache key generation and naming conventions - Invalidation strategy and trigger conditions - Monitoring and optimization requirements --- ## Project-Specific Implementation Notes **Customize per project:** - Caching strategy based on API characteristics and usage patterns - Storage mechanism based on performance and scalability requirements - Key generation based on data uniqueness and cache hit requirements - Invalidation depth based on data volatility and consistency needs - Monitoring frequency based on performance criticality --- ## Example Implementation (API Caching Pattern) > **Note:** This is an example pattern for API caching. Adapt caching strategies and storage based on your specific API requirements and infrastructure. ### Prerequisites (Example) - API endpoints identified and categorized - Caching requirements documented - Cache storage selected (Redis, memory, CDN) - Cache invalidation triggers defined --- ## Example: API Caching Implementation > **Framework-Specific Example:** This demonstrates caching patterns using Redis with intelligent invalidation. Adapt for your caching storage and requirements. ### 1. Caching Strategies ```typescript // Caching strategies and algorithms interface CacheStrategy { name: string; get(key: string): Promise; set(key: string, value: any, ttl?: number): Promise; delete(key: string): Promise; clear(pattern?: string): Promise; exists(key: string): Promise; } interface CacheEntry { value: any; timestamp: number; ttl: number; metadata?: CacheMetadata; } interface CacheMetadata { version: number; tags: string[]; dependencies: string[]; size: number; hitCount: number; lastAccessed: number; } // Time-based expiration strategy class TimeBasedCache implements CacheStrategy { name = 'time_based'; constructor(private storage: CacheStorage) {} async get(key: string): Promise { const entry = await this.storage.get(key); if (!entry) { return null; } // Check if expired if (Date.now() - entry.timestamp > entry.ttl) { await this.storage.delete(key); return null; } // Update access metadata if (entry.metadata) { entry.metadata.hitCount++; entry.metadata.lastAccessed = Date.now(); await this.storage.set(key, entry); } return entry; } async set(key: string, value: any, ttl: number = 300000): Promise { // Default 5 minutes const entry: CacheEntry = { value, timestamp: Date.now(), ttl, metadata: { version: 1, tags: [], dependencies: [], size: this.calculateSize(value), hitCount: 0, lastAccessed: Date.now() } }; await this.storage.set(key, entry); } async delete(key: string): Promise { await this.storage.delete(key); } async clear(pattern?: string): Promise { if (pattern) { const keys = await this.storage.getKeys(pattern); for (const key of keys) { await this.storage.delete(key); } } else { await this.storage.clear(); } } async exists(key: string): Promise { return await this.storage.exists(key); } private calculateSize(value: any): number { return JSON.stringify(value).length; } } // Write-through cache strategy class WriteThroughCache implements CacheStrategy { name = 'write_through'; constructor( private storage: CacheStorage, private dataProvider: DataProvider ) {} async get(key: string): Promise { // Try cache first const cached = await this.storage.get(key); if (cached) { return cached; } // Cache miss - fetch from data provider try { const data = await this.dataProvider.get(key); if (data !== null) { // Cache the data await this.set(key, data); return { value: data, timestamp: Date.now(), ttl: 300000, metadata: { version: 1, tags: [], dependencies: [], size: this.calculateSize(data), hitCount: 0, lastAccessed: Date.now() } }; } } catch (error) { console.error(`Error fetching data for key ${key}:`, error); } return null; } async set(key: string, value: any, ttl?: number): Promise { // Update cache const entry: CacheEntry = { value, timestamp: Date.now(), ttl: ttl || 300000, metadata: { version: 1, tags: [], dependencies: [], size: this.calculateSize(value), hitCount: 0, lastAccessed: Date.now() } }; await this.storage.set(key, entry); // Update data provider try { await this.dataProvider.set(key, value); } catch (error) { console.error(`Error updating data provider for key ${key}:`, error); } } async delete(key: string): Promise { await this.storage.delete(key); await this.dataProvider.delete(key); } async clear(pattern?: string): Promise { if (pattern) { const keys = await this.storage.getKeys(pattern); for (const key of keys) { await this.delete(key); } } else { await this.storage.clear(); await this.dataProvider.clear(); } } async exists(key: string): Promise { return await this.storage.exists(key); } private calculateSize(value: any): number { return JSON.stringify(value).length; } } // Cache-aside strategy class CacheAsideCache implements CacheStrategy { name = 'cache_aside'; constructor(private storage: CacheStorage) {} async get(key: string): Promise { return await this.storage.get(key); } async set(key: string, value: any, ttl?: number): Promise { const entry: CacheEntry = { value, timestamp: Date.now(), ttl: ttl || 300000, metadata: { version: 1, tags: [], dependencies: [], size: this.calculateSize(value), hitCount: 0, lastAccessed: Date.now() } }; await this.storage.set(key, entry); } async delete(key: string): Promise { await this.storage.delete(key); } async clear(pattern?: string): Promise { if (pattern) { const keys = await this.storage.getKeys(pattern); for (const key of keys) { await this.storage.delete(key); } } else { await this.storage.clear(); } } async exists(key: string): Promise { return await this.storage.exists(key); } private calculateSize(value: any): number { return JSON.stringify(value).length; } } ``` ### 2. Cache Key Generation ```typescript // Cache key generation and management interface CacheKeyGenerator { generateKey(context: CacheContext): string; parseKey(key: string): CacheContext | null; validateKey(key: string): boolean; } interface CacheContext { prefix: string; resource: string; identifier?: string; parameters?: Record; version?: string; tags?: string[]; } class StandardCacheKeyGenerator implements CacheKeyGenerator { generateKey(context: CacheContext): string { const parts = [ context.prefix, context.resource, context.identifier || '', this.serializeParameters(context.parameters), context.version || 'v1' ].filter(part => part !== ''); return parts.join(':'); } parseKey(key: string): CacheContext | null { const parts = key.split(':'); if (parts.length < 2) { return null; } return { prefix: parts[0], resource: parts[1], identifier: parts[2] || undefined, parameters: parts[3] ? this.deserializeParameters(parts[3]) : undefined, version: parts[4] || 'v1' }; } validateKey(key: string): boolean { return /^[a-zA-Z0-9:_-]+$/.test(key); } private serializeParameters(parameters?: Record): string { if (!parameters) { return ''; } const sorted = Object.keys(parameters) .sort() .reduce((obj, key) => { obj[key] = parameters[key]; return obj; }, {} as Record); return Buffer.from(JSON.stringify(sorted)).toString('base64').replace(/=/g, ''); } private deserializeParameters(serialized: string): Record { try { const padded = serialized + '='.repeat((4 - serialized.length % 4) % 4); const json = Buffer.from(padded, 'base64').toString(); return JSON.parse(json); } catch { return {}; } } } // Specialized key generators class UserCacheKeyGenerator implements CacheKeyGenerator { generateKey(context: CacheContext): string { // User-specific key generation const userId = context.identifier || 'anonymous'; const resource = context.resource || 'profile'; return `user:${userId}:${resource}:${context.version || 'v1'}`; } parseKey(key: string): CacheContext | null { const parts = key.split(':'); if (parts.length < 3 || parts[0] !== 'user') { return null; } return { prefix: parts[0], resource: parts[2], identifier: parts[1], version: parts[3] || 'v1' }; } validateKey(key: string): boolean { return /^user:[a-zA-Z0-9_-]+:[a-zA-Z0-9_-]+(:v\d+)?$/.test(key); } } class APICacheKeyGenerator implements CacheKeyGenerator { generateKey(context: CacheContext): string { // API-specific key generation const method = context.parameters?.method || 'GET'; const endpoint = context.resource; const params = this.serializeQueryParams(context.parameters?.query); return `api:${method}:${endpoint}:${params}:${context.version || 'v1'}`; } parseKey(key: string): CacheContext | null { const parts = key.split(':'); if (parts.length < 4 || parts[0] !== 'api') { return null; } return { prefix: parts[0], resource: parts[2], parameters: { method: parts[1], query: this.deserializeQueryParams(parts[3]) }, version: parts[4] || 'v1' }; } validateKey(key: string): boolean { return /^api:(GET|POST|PUT|DELETE|PATCH):[a-zA-Z0-9_/-]+:[a-zA-Z0-9_-]+(:v\d+)?$/.test(key); } private serializeQueryParams(query?: Record): string { if (!query) { return ''; } const sorted = Object.keys(query) .sort() .reduce((obj, key) => { obj[key] = query[key]; return obj; }, {} as Record); return Buffer.from(JSON.stringify(sorted)).toString('base64').replace(/=/g, ''); } private deserializeQueryParams(serialized: string): Record { try { const padded = serialized + '='.repeat((4 - serialized.length % 4) % 4); const json = Buffer.from(padded, 'base64').toString(); return JSON.parse(json); } catch { return {}; } } } ``` ### 3. Cache Invalidation ```typescript // Cache invalidation strategies interface CacheInvalidator { invalidate(key: string): Promise; invalidateByTag(tag: string): Promise; invalidateByPattern(pattern: string): Promise; invalidateDependencies(key: string): Promise; } class TagBasedInvalidator implements CacheInvalidator { constructor(private storage: CacheStorage) {} async invalidate(key: string): Promise { await this.storage.delete(key); } async invalidateByTag(tag: string): Promise { // Get all keys with this tag const keys = await this.storage.getKeysByTag(tag); // Delete all keys for (const key of keys) { await this.storage.delete(key); } } async invalidateByPattern(pattern: string): Promise { const keys = await this.storage.getKeys(pattern); for (const key of keys) { await this.storage.delete(key); } } async invalidateDependencies(key: string): Promise { const entry = await this.storage.get(key); if (entry?.metadata?.dependencies) { for (const dependency of entry.metadata.dependencies) { await this.invalidate(dependency); } } } } class TimeBasedInvalidator implements CacheInvalidator { constructor(private storage: CacheStorage) {} async invalidate(key: string): Promise { await this.storage.delete(key); } async invalidateByTag(tag: string): Promise { // Time-based invalidation doesn't support tags console.warn('Time-based invalidator does not support tag-based invalidation'); } async invalidateByPattern(pattern: string): Promise { const keys = await this.storage.getKeys(pattern); for (const key of keys) { await this.storage.delete(key); } } async invalidateDependencies(key: string): Promise { // Time-based invalidation handles dependencies through TTL console.log('Dependencies will be invalidated through TTL expiration'); } } class EventBasedInvalidator implements CacheInvalidator { private eventListeners = new Map>(); constructor(private storage: CacheStorage) { this.setupEventListeners(); } async invalidate(key: string): Promise { await this.storage.delete(key); this.emitEvent('cache:invalidated', { key }); } async invalidateByTag(tag: string): Promise { const keys = await this.storage.getKeysByTag(tag); for (const key of keys) { await this.invalidate(key); } this.emitEvent('cache:tag_invalidated', { tag, keys }); } async invalidateByPattern(pattern: string): Promise { const keys = await this.storage.getKeys(pattern); for (const key of keys) { await this.invalidate(key); } this.emitEvent('cache:pattern_invalidated', { pattern, keys }); } async invalidateDependencies(key: string): Promise { const entry = await this.storage.get(key); if (entry?.metadata?.dependencies) { for (const dependency of entry.metadata.dependencies) { await this.invalidate(dependency); } } this.emitEvent('cache:dependencies_invalidated', { key, dependencies: entry?.metadata?.dependencies }); } on(event: string, listener: Function): void { if (!this.eventListeners.has(event)) { this.eventListeners.set(event, new Set()); } this.eventListeners.get(event)!.add(listener); } off(event: string, listener: Function): void { const listeners = this.eventListeners.get(event); if (listeners) { listeners.delete(listener); } } private emitEvent(event: string, data: any): void { const listeners = this.eventListeners.get(event); if (listeners) { listeners.forEach(listener => { try { listener(data); } catch (error) { console.error(`Error in cache event listener for ${event}:`, error); } }); } } private setupEventListeners(): void { // Listen for data change events this.on('data:changed', async (data: { resource: string, id: string }) => { const key = `resource:${data.resource}:${data.id}`; await this.invalidate(key); }); // Listen for user update events this.on('user:updated', async (data: { userId: string }) => { const pattern = `user:${data.userId}:*`; await this.invalidateByPattern(pattern); }); } } ``` ### 4. Cache Middleware ```typescript // Cache middleware for API endpoints interface CacheMiddlewareOptions { strategy: CacheStrategy; keyGenerator: CacheKeyGenerator; ttl?: number; condition?: (req: any) => boolean; invalidateOn?: string[]; tags?: string[]; } class CacheMiddleware { constructor(private options: CacheMiddlewareOptions) {} middleware() { return async (req: any, res: any, next: any) => { try { // Check if request should be cached if (!this.shouldCache(req)) { return next(); } // Generate cache key const context: CacheContext = { prefix: 'api', resource: req.route?.path || req.path, identifier: this.getIdentifier(req), parameters: { method: req.method, query: req.query, params: req.params } }; const key = this.options.keyGenerator.generateKey(context); // Try to get from cache const cached = await this.options.strategy.get(key); if (cached) { // Cache hit this.setCacheHeaders(res, cached, 'HIT'); return res.json(cached.value); } // Cache miss - continue to next middleware const originalJson = res.json; // Override res.json to cache the response res.json = function(data: any) { // Cache the response if (res.statusCode === 200) { this.options.strategy.set(key, data, this.options.ttl).catch(error => { console.error('Error caching response:', error); }); } // Send response return originalJson.call(this, data); }.bind(this); next(); } catch (error) { console.error('Cache middleware error:', error); next(); } }; private shouldCache(req: any): boolean { // Check condition function if (this.options.condition && !this.options.condition(req)) { return false; } // Only cache GET requests by default if (req.method !== 'GET') { return false; } // Don't cache if there are query parameters that indicate dynamic content const dynamicParams = ['_', 'ts', 'nonce', 'cache_bust']; const hasDynamicParams = Object.keys(req.query || {}).some(param => dynamicParams.some(dynamic => param.includes(dynamic)) ); if (hasDynamicParams) { return false; } return true; } private getIdentifier(req: any): string { // Use user ID if available if (req.user?.id) { return req.user.id; } // Use API key if available if (req.headers['x-api-key']) { return req.headers['x-api-key']; } // Use IP address as fallback return req.ip || req.connection.remoteAddress || 'anonymous'; } private setCacheHeaders(res: any, cached: CacheEntry, status: string): void { res.set('X-Cache-Status', status); res.set('X-Cache-Timestamp', new Date(cached.timestamp).toISOString()); if (cached.metadata) { res.set('X-Cache-Hits', cached.metadata.hitCount.toString()); res.set('X-Cache-Size', cached.metadata.size.toString()); } // Calculate remaining TTL const remainingTTL = cached.ttl - (Date.now() - cached.timestamp); if (remainingTTL > 0) { res.set('X-Cache-Remaining-TTL', Math.ceil(remainingTTL / 1000).toString()); } } } // Cache warming service class CacheWarmer { constructor( private strategy: CacheStrategy, private keyGenerator: CacheKeyGenerator ) {} async warmCache(endpoints: WarmupEndpoint[]): Promise { console.log(`🔥 Warming up cache for ${endpoints.length} endpoints`); const results: WarmupEndpointResult[] = []; const startTime = Date.now(); for (const endpoint of endpoints) { try { const result = await this.warmEndpoint(endpoint); results.push(result); } catch (error) { results.push({ endpoint: endpoint.path, success: false, error: error instanceof Error ? error.message : 'Unknown error' }); } } return { totalEndpoints: endpoints.length, successCount: results.filter(r => r.success).length, failureCount: results.filter(r => !r.success).length, duration: Date.now() - startTime, results }; } private async warmEndpoint(endpoint: WarmupEndpoint): Promise { console.log(`🔥 Warming endpoint: ${endpoint.path}`); const startTime = Date.now(); // Generate cache key const context: CacheContext = { prefix: 'api', resource: endpoint.path, identifier: endpoint.identifier, parameters: endpoint.parameters }; const key = this.keyGenerator.generateKey(context); // Fetch data (this would typically make an actual API call) const data = await this.fetchData(endpoint); // Cache the data await this.strategy.set(key, data, endpoint.ttl); return { endpoint: endpoint.path, success: true, duration: Date.now() - startTime, dataSize: JSON.stringify(data).length }; } private async fetchData(endpoint: WarmupEndpoint): Promise { // Implementation for fetching data to warm cache // This would typically make an HTTP request to the API endpoint return { message: 'Warmed up data', timestamp: Date.now() }; } } interface WarmupEndpoint { path: string; identifier?: string; parameters?: Record; ttl?: number; } interface WarmupResult { totalEndpoints: number; successCount: number; failureCount: number; duration: number; results: WarmupEndpointResult[]; } interface WarmupEndpointResult { endpoint: string; success: boolean; duration?: number; dataSize?: number; error?: string; } ``` ### 5. Cache Monitoring ```typescript // Cache monitoring and analytics interface CacheMetrics { totalRequests: number; cacheHits: number; cacheMisses: number; hitRate: number; averageResponseTime: number; cacheSize: number; evictionCount: number; topKeys: CacheKeyStats[]; } interface CacheKeyStats { key: string; hits: number; misses: number; size: number; lastAccessed: number; ttl: number; } class CacheMonitor { private metrics: CacheMetrics = { totalRequests: 0, cacheHits: 0, cacheMisses: 0, hitRate: 0, averageResponseTime: 0, cacheSize: 0, evictionCount: 0, topKeys: [] }; private keyStats = new Map(); private responseTimes: number[] = []; recordRequest(hit: boolean, key: string, responseTime: number, size?: number): void { this.metrics.totalRequests++; if (hit) { this.metrics.cacheHits++; } else { this.metrics.cacheMisses++; } // Update key stats const existing = this.keyStats.get(key) || { key, hits: 0, misses: 0, size: 0, lastAccessed: Date.now(), ttl: 0 }; if (hit) { existing.hits++; } else { existing.misses++; } if (size !== undefined) { existing.size = size; } existing.lastAccessed = Date.now(); this.keyStats.set(key, existing); // Update response times this.responseTimes.push(responseTime); if (this.responseTimes.length > 1000) { this.responseTimes.shift(); } // Calculate metrics this.calculateMetrics(); } recordEviction(key: string): void { this.metrics.evictionCount++; this.keyStats.delete(key); this.calculateMetrics(); } private calculateMetrics(): void { // Calculate hit rate this.metrics.hitRate = this.metrics.totalRequests > 0 ? this.metrics.cacheHits / this.metrics.totalRequests : 0; // Calculate average response time if (this.responseTimes.length > 0) { this.metrics.averageResponseTime = this.responseTimes.reduce((sum, time) => sum + time, 0) / this.responseTimes.length; } // Calculate cache size this.metrics.cacheSize = Array.from(this.keyStats.values()).reduce((sum, stats) => sum + stats.size, 0); // Get top keys this.metrics.topKeys = Array.from(this.keyStats.values()) .sort((a, b) => (b.hits + b.misses) - (a.hits + a.misses)) .slice(0, 10); } getMetrics(): CacheMetrics { return { ...this.metrics }; } getKeyStats(key: string): CacheKeyStats | null { return this.keyStats.get(key) || null; } getTopKeys(limit: number = 10): CacheKeyStats[] { return Array.from(this.keyStats.values()) .sort((a, b) => (b.hits + b.misses) - (a.hits + a.misses)) .slice(0, limit); } getAlerts(): CacheAlert[] { const alerts: CacheAlert[] = []; // Low hit rate alert if (this.metrics.hitRate < 0.5 && this.metrics.totalRequests > 100) { alerts.push({ type: 'low_hit_rate', severity: 'warning', message: `Low cache hit rate: ${(this.metrics.hitRate * 100).toFixed(2)}%`, value: this.metrics.hitRate, threshold: 0.5 }); } // High eviction rate alert const evictionRate = this.metrics.evictionCount / this.metrics.totalRequests; if (evictionRate > 0.1) { alerts.push({ type: 'high_eviction_rate', severity: 'warning', message: `High eviction rate: ${(evictionRate * 100).toFixed(2)}%`, value: evictionRate, threshold: 0.1 }); } // Large cache size alert if (this.metrics.cacheSize > 1000000000) { // 1GB alerts.push({ type: 'large_cache_size', severity: 'info', message: `Large cache size: ${(this.metrics.cacheSize / 1024 / 1024).toFixed(2)}MB`, value: this.metrics.cacheSize, threshold: 1000000000 }); } return alerts; } reset(): void { this.metrics = { totalRequests: 0, cacheHits: 0, cacheMisses: 0, hitRate: 0, averageResponseTime: 0, cacheSize: 0, evictionCount: 0, topKeys: [] }; this.keyStats.clear(); this.responseTimes = []; } } interface CacheAlert { type: string; severity: 'info' | 'warning' | 'error'; message: string; value: number; threshold: number; } ``` --- ## Integration Patterns ### API Department Integration - Response caching for frequently accessed endpoints - API performance optimization - User-specific caching ### Data Department Integration - Database query result caching - Schema and type caching - Data consistency management ### Monitoring Integration - Cache performance metrics - Hit rate monitoring - Cache optimization recommendations --- ## Stop Conditions **STOP caching operations and escalate if:** - Cache storage failures - High cache miss rates - Data consistency issues - Performance degradation - Cache corruption detected **PAUSE operations if:** - Cache configuration changes - Storage system maintenance - High invalidation rates - Memory pressure --- ## Best Practices **Caching Strategy:** - Multiple strategies for different use cases - Appropriate TTL values - Intelligent invalidation - Graceful degradation **Key Management:** - Consistent key generation - Clear naming conventions - Proper parameter handling - Version management **Performance Optimization:** - Cache warming procedures - Memory usage monitoring - Eviction policy tuning - Hit rate optimization

API Caching

Install this skill

Comments