@umituz/react-native-storage 2.6.0 → 2.6.1

package/src/cache/domain/ErrorHandler.ts

@@ -0,0 +1,42 @@
+/**
+ * Error Handler for Cache Operations
+ */
+
+export class CacheError extends Error {
+  constructor(message: string, public readonly code: string) {
+    super(message);
+    this.name = 'CacheError';
+  }
+}
+
+export class ErrorHandler {
+  static handle(error: unknown, context: string): never {
+    if (error instanceof CacheError) {
+      throw error;
+    }
+    
+    if (error instanceof Error) {
+      throw new CacheError(`${context}: ${error.message}`, 'CACHE_ERROR');
+    }
+    
+    throw new CacheError(`${context}: Unknown error`, 'UNKNOWN_ERROR');
+  }
+
+  static async withTimeout<T>(
+    promise: Promise<T>,
+    timeoutMs: number,
+    context: string
+  ): Promise<T> {
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      setTimeout(() => {
+        reject(new CacheError(`${context}: Operation timed out after ${timeoutMs}ms`, 'TIMEOUT'));
+      }, timeoutMs);
+    });
+
+    try {
+      return await Promise.race([promise, timeoutPromise]);
+    } catch (error) {
+      this.handle(error, context);
+    }
+  }
+}

package/src/cache/domain/PatternMatcher.ts

@@ -0,0 +1,30 @@
+/**
+ * Pattern Matcher for Cache Keys
+ */
+
+const regexCache = new Map<string, RegExp>();
+
+export class PatternMatcher {
+  static convertPatternToRegex(pattern: string): RegExp {
+    if (regexCache.has(pattern)) {
+      return regexCache.get(pattern)!;
+    }
+
+    const escapedPattern = pattern
+      .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+      .replace(/\*/g, '.*');
+    const regex = new RegExp(`^${escapedPattern}$`);
+    
+    regexCache.set(pattern, regex);
+    return regex;
+  }
+
+  static matchesPattern(key: string, pattern: string): boolean {
+    const regex = this.convertPatternToRegex(pattern);
+    return regex.test(key);
+  }
+
+  static clearCache(): void {
+    regexCache.clear();
+  }
+}

package/src/cache/domain/__tests__/Cache.test.ts

@@ -0,0 +1,292 @@
+/**
+ * Cache Class Tests
+ */
+
+import { Cache } from '../Cache';
+import type { CacheConfig } from '../types/Cache';
+
+describe('Cache', () => {
+  let cache: Cache<string>;
+
+  beforeEach(() => {
+    cache = new Cache<string>({ maxSize: 3, defaultTTL: 1000 });
+  });
+
+  describe('Basic Operations', () => {
+    test('should set and get values', () => {
+      cache.set('key1', 'value1');
+      expect(cache.get('key1')).toBe('value1');
+    });
+
+    test('should return undefined for non-existent keys', () => {
+      expect(cache.get('nonexistent')).toBeUndefined();
+    });
+
+    test('should check if key exists', () => {
+      cache.set('key1', 'value1');
+      expect(cache.has('key1')).toBe(true);
+      expect(cache.has('nonexistent')).toBe(false);
+    });
+
+    test('should delete keys', () => {
+      cache.set('key1', 'value1');
+      expect(cache.delete('key1')).toBe(true);
+      expect(cache.has('key1')).toBe(false);
+      expect(cache.delete('nonexistent')).toBe(false);
+    });
+
+    test('should clear all keys', () => {
+      cache.set('key1', 'value1');
+      cache.set('key2', 'value2');
+      cache.clear();
+      expect(cache.has('key1')).toBe(false);
+      expect(cache.has('key2')).toBe(false);
+      expect(cache.getStats().size).toBe(0);
+    });
+
+    test('should return all keys', () => {
+      cache.set('key1', 'value1');
+      cache.set('key2', 'value2');
+      const keys = cache.keys();
+      expect(keys).toContain('key1');
+      expect(keys).toContain('key2');
+      expect(keys).toHaveLength(2);
+    });
+  });
+
+  describe('TTL (Time To Live)', () => {
+    beforeEach(() => {
+      jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    test('should expire entries after TTL', () => {
+      cache.set('key1', 'value1', 1000);
+      expect(cache.get('key1')).toBe('value1');
+
+      jest.advanceTimersByTime(1001);
+      expect(cache.get('key1')).toBeUndefined();
+    });
+
+    test('should use default TTL when not specified', () => {
+      cache.set('key1', 'value1');
+      expect(cache.get('key1')).toBe('value1');
+
+      jest.advanceTimersByTime(1001);
+      expect(cache.get('key1')).toBeUndefined();
+    });
+
+    test('should call onExpire callback when entry expires', () => {
+      const onExpire = jest.fn();
+      const cacheWithCallback = new Cache<string>({ 
+        defaultTTL: 1000, 
+        onExpire 
+      });
+
+      cacheWithCallback.set('key1', 'value1');
+      jest.advanceTimersByTime(1001);
+      cacheWithCallback.get('key1'); // Trigger expiration check
+
+      expect(onExpire).toHaveBeenCalledWith('key1', expect.objectContaining({
+        value: 'value1',
+        timestamp: expect.any(Number),
+        ttl: 1000,
+        accessCount: 0,
+        lastAccess: expect.any(Number)
+      }));
+    });
+  });
+
+  describe('Eviction', () => {
+    test('should evict LRU when cache is full', () => {
+      const onEvict = jest.fn();
+      const cacheWithCallback = new Cache<string>({ 
+        maxSize: 2, 
+        onEvict 
+      });
+
+      cacheWithCallback.set('key1', 'value1');
+      cacheWithCallback.set('key2', 'value2');
+      
+      // Access key1 to make it recently used
+      cacheWithCallback.get('key1');
+      
+      // Add third item, should evict key2 (least recently used)
+      cacheWithCallback.set('key3', 'value3');
+      
+      expect(cacheWithCallback.has('key1')).toBe(true);
+      expect(cacheWithCallback.has('key2')).toBe(false);
+      expect(cacheWithCallback.has('key3')).toBe(true);
+      expect(onEvict).toHaveBeenCalledWith('key2', expect.any(Object));
+    });
+
+    test('should not evict when updating existing key', () => {
+      cache.set('key1', 'value1');
+      cache.set('key2', 'value2');
+      cache.set('key3', 'value3');
+      
+      // Update existing key, should not cause eviction
+      cache.set('key1', 'value1-updated');
+      
+      expect(cache.has('key1')).toBe(true);
+      expect(cache.has('key2')).toBe(true);
+      expect(cache.has('key3')).toBe(true);
+      expect(cache.get('key1')).toBe('value1-updated');
+    });
+  });
+
+  describe('Pattern Invalidation', () => {
+    test('should invalidate keys matching pattern', () => {
+      cache.set('user:1', 'user1');
+      cache.set('user:2', 'user2');
+      cache.set('post:1', 'post1');
+      cache.set('admin', 'admin');
+
+      const invalidatedCount = cache.invalidatePattern('user:*');
+      
+      expect(invalidatedCount).toBe(2);
+      expect(cache.has('user:1')).toBe(false);
+      expect(cache.has('user:2')).toBe(false);
+      expect(cache.has('post:1')).toBe(true);
+      expect(cache.has('admin')).toBe(true);
+    });
+
+    test('should handle complex patterns', () => {
+      cache.set('user:1:profile', 'profile1');
+      cache.set('user:2:profile', 'profile2');
+      cache.set('user:1:settings', 'settings1');
+      cache.set('post:1', 'post1');
+
+      const invalidatedCount = cache.invalidatePattern('user:*:profile');
+      
+      expect(invalidatedCount).toBe(2);
+      expect(cache.has('user:1:profile')).toBe(false);
+      expect(cache.has('user:2:profile')).toBe(false);
+      expect(cache.has('user:1:settings')).toBe(true);
+      expect(cache.has('post:1')).toBe(true);
+    });
+
+    test('should return 0 for non-matching patterns', () => {
+      cache.set('user:1', 'user1');
+      cache.set('post:1', 'post1');
+
+      const invalidatedCount = cache.invalidatePattern('admin:*');
+      
+      expect(invalidatedCount).toBe(0);
+      expect(cache.has('user:1')).toBe(true);
+      expect(cache.has('post:1')).toBe(true);
+    });
+  });
+
+  describe('Statistics', () => {
+    test('should track cache statistics correctly', () => {
+      // Initial stats
+      let stats = cache.getStats();
+      expect(stats.size).toBe(0);
+      expect(stats.hits).toBe(0);
+      expect(stats.misses).toBe(0);
+      expect(stats.evictions).toBe(0);
+      expect(stats.expirations).toBe(0);
+
+      // Set some values
+      cache.set('key1', 'value1');
+      cache.set('key2', 'value2');
+      
+      stats = cache.getStats();
+      expect(stats.size).toBe(2);
+
+      // Hit
+      cache.get('key1');
+      stats = cache.getStats();
+      expect(stats.hits).toBe(1);
+      expect(stats.misses).toBe(0);
+
+      // Miss
+      cache.get('nonexistent');
+      stats = cache.getStats();
+      expect(stats.hits).toBe(1);
+      expect(stats.misses).toBe(1);
+
+      // Delete
+      cache.delete('key1');
+      stats = cache.getStats();
+      expect(stats.size).toBe(1);
+
+      // Clear
+      cache.clear();
+      stats = cache.getStats();
+      expect(stats.size).toBe(0);
+      expect(stats.hits).toBe(0);
+      expect(stats.misses).toBe(0);
+    });
+
+    test('should return immutable stats object', () => {
+      cache.set('key1', 'value1');
+      const stats1 = cache.getStats();
+      const stats2 = cache.getStats();
+      
+      expect(stats1).toEqual(stats2);
+      expect(stats1).not.toBe(stats2); // Different references
+    });
+  });
+
+  describe('Access Count and Last Access', () => {
+    test('should track access count and last access time', () => {
+      const startTime = Date.now();
+      
+      cache.set('key1', 'value1');
+      
+      // First access
+      cache.get('key1');
+      let stats = cache.getStats();
+      
+      // Second access
+      jest.advanceTimersByTime(100);
+      cache.get('key1');
+      
+      // Verify access tracking (internal implementation detail)
+      expect(cache.get('key1')).toBe('value1');
+    });
+  });
+
+  describe('Configuration', () => {
+    test('should use custom configuration', () => {
+      const customConfig: CacheConfig = {
+        maxSize: 10,
+        defaultTTL: 5000,
+        onEvict: jest.fn(),
+        onExpire: jest.fn(),
+      };
+
+      const customCache = new Cache<string>(customConfig);
+      
+      customCache.set('key1', 'value1');
+      expect(customCache.get('key1')).toBe('value1');
+      
+      // Should not expire before custom TTL
+      jest.advanceTimersByTime(4000);
+      expect(customCache.get('key1')).toBe('value1');
+      
+      // Should expire after custom TTL
+      jest.advanceTimersByTime(1001);
+      expect(customCache.get('key1')).toBeUndefined();
+    });
+
+    test('should use default configuration when not provided', () => {
+      const defaultCache = new Cache<string>();
+      
+      defaultCache.set('key1', 'value1');
+      expect(defaultCache.get('key1')).toBe('value1');
+      
+      // Should use default TTL (5 minutes)
+      jest.advanceTimersByTime(5 * 60 * 1000 - 1);
+      expect(defaultCache.get('key1')).toBe('value1');
+      
+      jest.advanceTimersByTime(2);
+      expect(defaultCache.get('key1')).toBeUndefined();
+    });
+  });
+});

package/src/cache/domain/__tests__/CacheManager.test.ts

@@ -0,0 +1,276 @@
+/**
+ * CacheManager Tests
+ */
+
+import { CacheManager, cacheManager } from '../CacheManager';
+import type { CacheConfig } from '../types/Cache';
+
+describe('CacheManager', () => {
+  let manager: CacheManager;
+
+  beforeEach(() => {
+    // Reset singleton for testing
+    (CacheManager as any).instance = null;
+    manager = CacheManager.getInstance();
+  });
+
+  afterEach(() => {
+    manager.clearAll();
+    (CacheManager as any).instance = null;
+  });
+
+  describe('Singleton Pattern', () => {
+    test('should return the same instance', () => {
+      const instance1 = CacheManager.getInstance();
+      const instance2 = CacheManager.getInstance();
+      
+      expect(instance1).toBe(instance2);
+    });
+
+    test('should create only one instance', () => {
+      const instance1 = CacheManager.getInstance();
+      const instance2 = new (CacheManager as any)();
+      
+      expect(instance1).not.toBe(instance2);
+      expect(instance1).toBe(CacheManager.getInstance());
+    });
+  });
+
+  describe('Cache Management', () => {
+    test('should create and retrieve cache instances', () => {
+      const cache1 = manager.getCache<string>('cache1');
+      const cache2 = manager.getCache<number>('cache2');
+      
+      expect(cache1).toBeDefined();
+      expect(cache2).toBeDefined();
+      expect(cache1).not.toBe(cache2);
+    });
+
+    test('should return same cache instance for same name', () => {
+      const cache1 = manager.getCache<string>('cache1');
+      const cache2 = manager.getCache<string>('cache1');
+      
+      expect(cache1).toBe(cache2);
+    });
+
+    test('should create caches with different types', () => {
+      const stringCache = manager.getCache<string>('strings');
+      const numberCache = manager.getCache<number>('numbers');
+      const objectCache = manager.getCache<{ id: string }>('objects');
+      
+      stringCache.set('key', 'value');
+      numberCache.set('key', 42);
+      objectCache.set('key', { id: 'test' });
+      
+      expect(stringCache.get('key')).toBe('value');
+      expect(numberCache.get('key')).toBe(42);
+      expect(objectCache.get('key')).toEqual({ id: 'test' });
+    });
+
+    test('should apply configuration to cache', () => {
+      const config: CacheConfig = {
+        maxSize: 50,
+        defaultTTL: 10000,
+      };
+      
+      const cache = manager.getCache<string>('configured-cache', config);
+      
+      cache.set('key', 'value');
+      expect(cache.get('key')).toBe('value');
+      
+      // Test configuration is applied (basic check)
+      const stats = cache.getStats();
+      expect(stats.size).toBe(1);
+    });
+  });
+
+  describe('Cache Deletion', () => {
+    test('should delete specific cache', () => {
+      manager.getCache<string>('cache1');
+      manager.getCache<string>('cache2');
+      
+      expect(manager.getCacheNames()).toContain('cache1');
+      expect(manager.getCacheNames()).toContain('cache2');
+      
+      const deleted = manager.deleteCache('cache1');
+      
+      expect(deleted).toBe(true);
+      expect(manager.getCacheNames()).not.toContain('cache1');
+      expect(manager.getCacheNames()).toContain('cache2');
+    });
+
+    test('should return false when deleting non-existent cache', () => {
+      const deleted = manager.deleteCache('nonexistent');
+      
+      expect(deleted).toBe(false);
+    });
+
+    test('should clear cache before deletion', () => {
+      const cache = manager.getCache<string>('cache1');
+      cache.set('key1', 'value1');
+      cache.set('key2', 'value2');
+      
+      expect(cache.getStats().size).toBe(2);
+      
+      manager.deleteCache('cache1');
+      
+      // Get new instance to verify old one was cleared
+      const newCache = manager.getCache<string>('cache1');
+      expect(newCache.getStats().size).toBe(0);
+    });
+  });
+
+  describe('Clear All', () => {
+    test('should clear all caches', () => {
+      const cache1 = manager.getCache<string>('cache1');
+      const cache2 = manager.getCache<string>('cache2');
+      const cache3 = manager.getCache<string>('cache3');
+      
+      cache1.set('key1', 'value1');
+      cache2.set('key2', 'value2');
+      cache3.set('key3', 'value3');
+      
+      expect(cache1.getStats().size).toBe(1);
+      expect(cache2.getStats().size).toBe(1);
+      expect(cache3.getStats().size).toBe(1);
+      expect(manager.getCacheNames()).toHaveLength(3);
+      
+      manager.clearAll();
+      
+      expect(cache1.getStats().size).toBe(0);
+      expect(cache2.getStats().size).toBe(0);
+      expect(cache3.getStats().size).toBe(0);
+      expect(manager.getCacheNames()).toHaveLength(0);
+    });
+
+    test('should handle clear all when no caches exist', () => {
+      expect(() => manager.clearAll()).not.toThrow();
+      expect(manager.getCacheNames()).toHaveLength(0);
+    });
+  });
+
+  describe('Cache Names', () => {
+    test('should return list of cache names', () => {
+      expect(manager.getCacheNames()).toHaveLength(0);
+      
+      manager.getCache<string>('cache1');
+      manager.getCache<string>('cache2');
+      manager.getCache<string>('cache3');
+      
+      const names = manager.getCacheNames();
+      expect(names).toHaveLength(3);
+      expect(names).toContain('cache1');
+      expect(names).toContain('cache2');
+      expect(names).toContain('cache3');
+    });
+
+    test('should not duplicate cache names', () => {
+      manager.getCache<string>('cache1');
+      manager.getCache<string>('cache1'); // Same name
+      manager.getCache<string>('cache2');
+      
+      const names = manager.getCacheNames();
+      expect(names).toHaveLength(2);
+      expect(names.filter(name => name === 'cache1')).toHaveLength(1);
+    });
+  });
+
+  describe('Memory Management', () => {
+    test('should handle large number of caches', () => {
+      const cacheCount = 100;
+      
+      for (let i = 0; i < cacheCount; i++) {
+        const cache = manager.getCache<string>(`cache${i}`);
+        cache.set(`key${i}`, `value${i}`);
+      }
+      
+      expect(manager.getCacheNames()).toHaveLength(cacheCount);
+      
+      // Verify all caches have their data
+      for (let i = 0; i < cacheCount; i++) {
+        const cache = manager.getCache<string>(`cache${i}`);
+        expect(cache.get(`key${i}`)).toBe(`value${i}`);
+      }
+    });
+
+    test('should handle cache deletion in large scale', () => {
+      const cacheCount = 50;
+      
+      // Create caches
+      for (let i = 0; i < cacheCount; i++) {
+        manager.getCache<string>(`cache${i}`);
+      }
+      
+      expect(manager.getCacheNames()).toHaveLength(cacheCount);
+      
+      // Delete every other cache
+      for (let i = 0; i < cacheCount; i += 2) {
+        manager.deleteCache(`cache${i}`);
+      }
+      
+      expect(manager.getCacheNames()).toHaveLength(Math.floor(cacheCount / 2));
+      
+      // Verify remaining caches still work
+      for (let i = 1; i < cacheCount; i += 2) {
+        const cache = manager.getCache<string>(`cache${i}`);
+        cache.set('test', 'value');
+        expect(cache.get('test')).toBe('value');
+      }
+    });
+  });
+
+  describe('Edge Cases', () => {
+    test('should handle empty string cache name', () => {
+      const cache = manager.getCache<string>('');
+      expect(cache).toBeDefined();
+      expect(manager.getCacheNames()).toContain('');
+    });
+
+    test('should handle special characters in cache names', () => {
+      const specialNames = ['cache-with-dash', 'cache_with_underscore', 'cache.with.dots', 'cache with spaces'];
+      
+      specialNames.forEach(name => {
+        const cache = manager.getCache<string>(name);
+        expect(cache).toBeDefined();
+        expect(manager.getCacheNames()).toContain(name);
+      });
+    });
+
+    test('should handle very long cache names', () => {
+      const longName = 'a'.repeat(1000);
+      const cache = manager.getCache<string>(longName);
+      
+      expect(cache).toBeDefined();
+      expect(manager.getCacheNames()).toContain(longName);
+    });
+  });
+});
+
+describe('cacheManager export', () => {
+  beforeEach(() => {
+    (CacheManager as any).instance = null;
+  });
+
+  afterEach(() => {
+    cacheManager.clearAll();
+    (CacheManager as any).instance = null;
+  });
+
+  test('should export singleton instance', () => {
+    expect(cacheManager).toBeDefined();
+    expect(cacheManager).toBeInstanceOf(CacheManager);
+  });
+
+  test('should be the same instance as CacheManager.getInstance()', () => {
+    const instance = CacheManager.getInstance();
+    expect(cacheManager).toBe(instance);
+  });
+
+  test('should work with exported instance', () => {
+    const cache = cacheManager.getCache<string>('test-cache');
+    cache.set('key', 'value');
+    
+    expect(cache.get('key')).toBe('value');
+    expect(cacheManager.getCacheNames()).toContain('test-cache');
+  });
+});