@umituz/react-native-storage 2.5.0 → 2.6.1

package/src/cache/domain/strategies/__tests__/EvictionStrategies.test.ts

@@ -0,0 +1,293 @@
+/**
+ * Eviction Strategies Tests
+ */
+
+import { LRUStrategy } from '../LRUStrategy';
+import { LFUStrategy } from '../LFUStrategy';
+import { FIFOStrategy } from '../FIFOStrategy';
+import { TTLStrategy } from '../TTLStrategy';
+import type { CacheEntry } from '../../types/Cache';
+
+describe('Eviction Strategies', () => {
+  const createMockEntries = (): Map<string, CacheEntry<string>> => {
+    const entries = new Map<string, CacheEntry<string>>();
+    const now = Date.now();
+    
+    entries.set('key1', {
+      value: 'value1',
+      timestamp: now - 1000,
+      ttl: 5000,
+      accessCount: 5,
+      lastAccess: now - 500,
+    });
+    
+    entries.set('key2', {
+      value: 'value2',
+      timestamp: now - 2000,
+      ttl: 5000,
+      accessCount: 3,
+      lastAccess: now - 100,
+    });
+    
+    entries.set('key3', {
+      value: 'value3',
+      timestamp: now - 3000,
+      ttl: 5000,
+      accessCount: 10,
+      lastAccess: now - 1500,
+    });
+    
+    return entries;
+  };
+
+  describe('LRUStrategy', () => {
+    let strategy: LRUStrategy<string>;
+
+    beforeEach(() => {
+      strategy = new LRUStrategy<string>();
+    });
+
+    test('should evict least recently used key', () => {
+      const entries = createMockEntries();
+      const keyToEvict = strategy.findKeyToEvict(entries);
+      
+      // key3 has the oldest lastAccess time
+      expect(keyToEvict).toBe('key3');
+    });
+
+    test('should return undefined for empty entries', () => {
+      const entries = new Map<string, CacheEntry<string>>();
+      const keyToEvict = strategy.findKeyToEvict(entries);
+      
+      expect(keyToEvict).toBeUndefined();
+    });
+
+    test('should handle single entry', () => {
+      const entries = new Map<string, CacheEntry<string>>();
+      entries.set('key1', {
+        value: 'value1',
+        timestamp: Date.now(),
+        ttl: 5000,
+        accessCount: 1,
+        lastAccess: Date.now(),
+      });
+      
+      const keyToEvict = strategy.findKeyToEvict(entries);
+      expect(keyToEvict).toBe('key1');
+    });
+  });
+
+  describe('LFUStrategy', () => {
+    let strategy: LFUStrategy<string>;
+
+    beforeEach(() => {
+      strategy = new LFUStrategy<string>();
+    });
+
+    test('should evict least frequently used key', () => {
+      const entries = createMockEntries();
+      const keyToEvict = strategy.findKeyToEvict(entries);
+      
+      // key2 has the lowest access count (3)
+      expect(keyToEvict).toBe('key2');
+    });
+
+    test('should return undefined for empty entries', () => {
+      const entries = new Map<string, CacheEntry<string>>();
+      const keyToEvict = strategy.findKeyToEvict(entries);
+      
+      expect(keyToEvict).toBeUndefined();
+    });
+
+    test('should handle ties by choosing first encountered', () => {
+      const entries = new Map<string, CacheEntry<string>>();
+      const now = Date.now();
+      
+      entries.set('key1', {
+        value: 'value1',
+        timestamp: now,
+        ttl: 5000,
+        accessCount: 2,
+        lastAccess: now,
+      });
+      
+      entries.set('key2', {
+        value: 'value2',
+        timestamp: now,
+        ttl: 5000,
+        accessCount: 2,
+        lastAccess: now,
+      });
+      
+      const keyToEvict = strategy.findKeyToEvict(entries);
+      // Should return the first key with lowest count
+      expect(keyToEvict).toBe('key1');
+    });
+  });
+
+  describe('FIFOStrategy', () => {
+    let strategy: FIFOStrategy<string>;
+
+    beforeEach(() => {
+      strategy = new FIFOStrategy<string>();
+    });
+
+    test('should evict first inserted key', () => {
+      const entries = createMockEntries();
+      const keyToEvict = strategy.findKeyToEvict(entries);
+      
+      // Map preserves insertion order, so first key should be evicted
+      expect(keyToEvict).toBe('key1');
+    });
+
+    test('should return undefined for empty entries', () => {
+      const entries = new Map<string, CacheEntry<string>>();
+      const keyToEvict = strategy.findKeyToEvict(entries);
+      
+      expect(keyToEvict).toBeUndefined();
+    });
+
+    test('should handle single entry', () => {
+      const entries = new Map<string, CacheEntry<string>>();
+      entries.set('onlyKey', {
+        value: 'value',
+        timestamp: Date.now(),
+        ttl: 5000,
+        accessCount: 1,
+        lastAccess: Date.now(),
+      });
+      
+      const keyToEvict = strategy.findKeyToEvict(entries);
+      expect(keyToEvict).toBe('onlyKey');
+    });
+  });
+
+  describe('TTLStrategy', () => {
+    let strategy: TTLStrategy<string>;
+
+    beforeEach(() => {
+      strategy = new TTLStrategy<string>();
+    });
+
+    test('should evict key with nearest expiry', () => {
+      const now = Date.now();
+      const entries = new Map<string, CacheEntry<string>>();
+      
+      entries.set('key1', {
+        value: 'value1',
+        timestamp: now - 1000,
+        ttl: 2000, // Expires at now + 1000
+        accessCount: 1,
+        lastAccess: now,
+      });
+      
+      entries.set('key2', {
+        value: 'value2',
+        timestamp: now - 500,
+        ttl: 1000, // Expires at now + 500
+        accessCount: 1,
+        lastAccess: now,
+      });
+      
+      entries.set('key3', {
+        value: 'value3',
+        timestamp: now - 2000,
+        ttl: 3000, // Expires at now + 1000
+        accessCount: 1,
+        lastAccess: now,
+      });
+      
+      const keyToEvict = strategy.findKeyToEvict(entries);
+      
+      // key2 expires soonest (now + 500)
+      expect(keyToEvict).toBe('key2');
+    });
+
+    test('should return undefined for empty entries', () => {
+      const entries = new Map<string, CacheEntry<string>>();
+      const keyToEvict = strategy.findKeyToEvict(entries);
+      
+      expect(keyToEvict).toBeUndefined();
+    });
+
+    test('should handle already expired entries', () => {
+      const now = Date.now();
+      const entries = new Map<string, CacheEntry<string>>();
+      
+      entries.set('key1', {
+        value: 'value1',
+        timestamp: now - 2000,
+        ttl: 1000, // Already expired
+        accessCount: 1,
+        lastAccess: now,
+      });
+      
+      entries.set('key2', {
+        value: 'value2',
+        timestamp: now - 1000,
+        ttl: 2000, // Expires at now + 1000
+        accessCount: 1,
+        lastAccess: now,
+      });
+      
+      const keyToEvict = strategy.findKeyToEvict(entries);
+      
+      // key1 is already expired, should be evicted first
+      expect(keyToEvict).toBe('key1');
+    });
+
+    test('should handle ties by choosing first encountered', () => {
+      const now = Date.now();
+      const entries = new Map<string, CacheEntry<string>>();
+      
+      entries.set('key1', {
+        value: 'value1',
+        timestamp: now - 1000,
+        ttl: 2000, // Both expire at now + 1000
+        accessCount: 1,
+        lastAccess: now,
+      });
+      
+      entries.set('key2', {
+        value: 'value2',
+        timestamp: now - 1000,
+        ttl: 2000, // Both expire at now + 1000
+        accessCount: 1,
+        lastAccess: now,
+      });
+      
+      const keyToEvict = strategy.findKeyToEvict(entries);
+      
+      // Should return the first key with nearest expiry
+      expect(keyToEvict).toBe('key1');
+    });
+  });
+
+  describe('Strategy Integration', () => {
+    test('all strategies should handle different data types', () => {
+      const numberStrategy = new LRUStrategy<number>();
+      const objectStrategy = new LRUStrategy<{ id: string }>();
+      
+      const numberEntries = new Map<string, CacheEntry<number>>();
+      numberEntries.set('num1', {
+        value: 42,
+        timestamp: Date.now(),
+        ttl: 5000,
+        accessCount: 1,
+        lastAccess: Date.now(),
+      });
+      
+      const objectEntries = new Map<string, CacheEntry<{ id: string }>>();
+      objectEntries.set('obj1', {
+        value: { id: 'test' },
+        timestamp: Date.now(),
+        ttl: 5000,
+        accessCount: 1,
+        lastAccess: Date.now(),
+      });
+      
+      expect(numberStrategy.findKeyToEvict(numberEntries)).toBe('num1');
+      expect(objectStrategy.findKeyToEvict(objectEntries)).toBe('obj1');
+    });
+  });
+});

package/src/cache/domain/types/Cache.ts

@@ -0,0 +1,28 @@
+/**
+ * Cache Types
+ */
+
+export interface CacheEntry<T> {
+  value: T;
+  timestamp: number;
+  ttl: number;
+  accessCount: number;
+  lastAccess: number;
+}
+
+export interface CacheConfig {
+  maxSize?: number;
+  defaultTTL?: number;
+  onEvict?: (key: string, entry: CacheEntry<unknown>) => void;
+  onExpire?: (key: string, entry: CacheEntry<unknown>) => void;
+}
+
+export interface CacheStats {
+  size: number;
+  hits: number;
+  misses: number;
+  evictions: number;
+  expirations: number;
+}
+
+export type EvictionStrategy = 'lru' | 'lfu' | 'fifo' | 'ttl';

package/src/cache/index.ts

@@ -0,0 +1,28 @@
+/**
+ * @umituz/react-native-cache
+ * In-memory caching utilities for React Native
+ */
+
+export { Cache } from './domain/Cache';
+export { CacheManager, cacheManager } from './domain/CacheManager';
+export { CacheStatsTracker } from './domain/CacheStatsTracker';
+export { PatternMatcher } from './domain/PatternMatcher';
+export { ErrorHandler, CacheError } from './domain/ErrorHandler';
+export { TTLCache } from './infrastructure/TTLCache';
+
+export type {
+  CacheEntry,
+  CacheConfig,
+  CacheStats,
+  EvictionStrategy,
+} from './domain/types/Cache';
+
+export type { EvictionStrategy as IEvictionStrategy } from './domain/strategies/EvictionStrategy';
+
+export { LRUStrategy } from './domain/strategies/LRUStrategy';
+export { LFUStrategy } from './domain/strategies/LFUStrategy';
+export { FIFOStrategy } from './domain/strategies/FIFOStrategy';
+export { TTLStrategy as TTLEvictionStrategy } from './domain/strategies/TTLStrategy';
+
+export { useCache } from './presentation/useCache';
+export { useCachedValue } from './presentation/useCachedValue';

package/src/cache/infrastructure/TTLCache.ts

@@ -0,0 +1,103 @@
+/**
+ * TTL Cache
+ * Time-to-live cache with automatic cleanup
+ */
+
+import { Cache } from '../domain/Cache';
+import type { CacheConfig } from '../domain/types/Cache';
+
+export class TTLCache<T = unknown> extends Cache<T> {
+  private cleanupInterval: ReturnType<typeof setInterval> | null = null;
+  private isDestroyed = false;
+  private readonly cleanupIntervalMs: number;
+
+  constructor(config: CacheConfig & { cleanupIntervalMs?: number } = {}) {
+    super(config);
+
+    this.cleanupIntervalMs = config.cleanupIntervalMs || 60000;
+    this.startCleanup();
+  }
+
+  private startCleanup(): void {
+    if (this.isDestroyed) return;
+
+    this.cleanupInterval = setInterval(() => {
+      if (!this.isDestroyed) {
+        this.cleanup();
+      }
+    }, this.cleanupIntervalMs);
+  }
+
+  private cleanup(): void {
+    if (this.isDestroyed) return;
+
+    const keys = this.keys();
+    let cleanedCount = 0;
+    const now = Date.now();
+
+    for (const key of keys) {
+      const entry = (this as any).store.get(key);
+      if (entry && (now - entry.timestamp) > entry.ttl) {
+        (this as any).store.delete(key);
+        cleanedCount++;
+      }
+    }
+
+    if (cleanedCount > 0) {
+      (this as any).statsTracker.updateSize((this as any).store.size);
+      (this as any).statsTracker.recordExpiration();
+
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.log(`TTLCache: Cleaned up ${cleanedCount} expired entries`);
+      }
+    }
+  }
+
+  destroy(): void {
+    if (this.isDestroyed) return;
+
+    this.isDestroyed = true;
+
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+
+    this.clear();
+  }
+
+  override set(key: string, value: T, ttl?: number): void {
+    if (this.isDestroyed) {
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.warn('TTLCache: Attempted to set value on destroyed cache');
+      }
+      return;
+    }
+    super.set(key, value, ttl);
+  }
+
+  override get(key: string): T | undefined {
+    if (this.isDestroyed) {
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.warn('TTLCache: Attempted to get value from destroyed cache');
+      }
+      return undefined;
+    }
+    return super.get(key);
+  }
+
+  override has(key: string): boolean {
+    if (this.isDestroyed) return false;
+    return super.has(key);
+  }
+
+  override delete(key: string): boolean {
+    if (this.isDestroyed) return false;
+    return super.delete(key);
+  }
+
+  override clear(): void {
+    if (this.isDestroyed) return;
+    super.clear();
+  }
+}