@umituz/react-native-storage 2.6.0 → 2.6.2

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

@@ -0,0 +1,303 @@
+/**
+ * ErrorHandler Tests
+ */
+
+import { ErrorHandler, CacheError } from '../ErrorHandler';
+
+describe('ErrorHandler', () => {
+  describe('CacheError', () => {
+    test('should create CacheError with message and code', () => {
+      const error = new CacheError('Test message', 'TEST_CODE');
+      
+      expect(error).toBeInstanceOf(Error);
+      expect(error).toBeInstanceOf(CacheError);
+      expect(error.message).toBe('Test message');
+      expect(error.code).toBe('TEST_CODE');
+      expect(error.name).toBe('CacheError');
+    });
+
+    test('should have stack trace', () => {
+      const error = new CacheError('Test message', 'TEST_CODE');
+      
+      expect(error.stack).toBeDefined();
+      expect(typeof error.stack).toBe('string');
+    });
+
+    test('should be serializable', () => {
+      const error = new CacheError('Test message', 'TEST_CODE');
+      const serialized = JSON.stringify(error);
+      const parsed = JSON.parse(serialized);
+      
+      expect(parsed.message).toBe('Test message');
+      expect(parsed.code).toBe('TEST_CODE');
+      expect(parsed.name).toBe('CacheError');
+    });
+  });
+
+  describe('handle', () => {
+    test('should throw CacheError as-is', () => {
+      const originalError = new CacheError('Original error', 'ORIGINAL');
+      
+      expect(() => {
+        ErrorHandler.handle(originalError, 'test context');
+      }).toThrow('Original error');
+    });
+
+    test('should wrap regular Error in CacheError', () => {
+      const originalError = new Error('Regular error');
+      
+      expect(() => {
+        ErrorHandler.handle(originalError, 'test context');
+      }).toThrow(CacheError);
+    });
+
+    test('should include context in wrapped error message', () => {
+      const originalError = new Error('Regular error');
+      
+      try {
+        ErrorHandler.handle(originalError, 'test context');
+      } catch (error) {
+        expect((error as CacheError).message).toBe('test context: Regular error');
+        expect((error as CacheError).code).toBe('CACHE_ERROR');
+      }
+    });
+
+    test('should handle unknown error type', () => {
+      const unknownError = 'string error';
+      
+      try {
+        ErrorHandler.handle(unknownError, 'test context');
+      } catch (error) {
+        expect((error as CacheError).message).toBe('test context: Unknown error');
+        expect((error as CacheError).code).toBe('UNKNOWN_ERROR');
+      }
+    });
+
+    test('should handle null error', () => {
+      try {
+        ErrorHandler.handle(null, 'test context');
+      } catch (error) {
+        expect((error as CacheError).message).toBe('test context: Unknown error');
+        expect((error as CacheError).code).toBe('UNKNOWN_ERROR');
+      }
+    });
+
+    test('should handle undefined error', () => {
+      try {
+        ErrorHandler.handle(undefined, 'test context');
+      } catch (error) {
+        expect((error as CacheError).message).toBe('test context: Unknown error');
+        expect((error as CacheError).code).toBe('UNKNOWN_ERROR');
+      }
+    });
+
+    test('should preserve original error properties when possible', () => {
+      const originalError = new Error('Original error');
+      (originalError as any).customProperty = 'custom value';
+      
+      try {
+        ErrorHandler.handle(originalError, 'test context');
+      } catch (error) {
+        const cacheError = error as CacheError;
+        expect(cacheError.message).toBe('test context: Original error');
+        expect(cacheError.code).toBe('CACHE_ERROR');
+        // Note: original properties are not copied to maintain clean error structure
+      }
+    });
+  });
+
+  describe('withTimeout', () => {
+    beforeEach(() => {
+      jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    test('should resolve promise before timeout', async () => {
+      const promise = Promise.resolve('success');
+      const result = await ErrorHandler.withTimeout(promise, 1000, 'test context');
+      
+      expect(result).toBe('success');
+    });
+
+    test('should timeout when promise takes too long', async () => {
+      const promise = new Promise(resolve => setTimeout(() => resolve('late'), 2000));
+      
+      await expect(
+        ErrorHandler.withTimeout(promise, 1000, 'test context')
+      ).rejects.toThrow(CacheError);
+    });
+
+    test('should include timeout in error message', async () => {
+      const promise = new Promise(resolve => setTimeout(() => resolve('late'), 2000));
+      
+      try {
+        await ErrorHandler.withTimeout(promise, 1000, 'test context');
+      } catch (error) {
+        expect((error as CacheError).message).toBe('test context: Operation timed out after 1000ms');
+        expect((error as CacheError).code).toBe('TIMEOUT');
+      }
+    });
+
+    test('should handle promise rejection before timeout', async () => {
+      const promise = Promise.reject(new Error('Promise rejected'));
+      
+      await expect(
+        ErrorHandler.withTimeout(promise, 1000, 'test context')
+      ).rejects.toThrow(CacheError);
+    });
+
+    test('should include context in promise rejection error', async () => {
+      const promise = Promise.reject(new Error('Promise rejected'));
+      
+      try {
+        await ErrorHandler.withTimeout(promise, 1000, 'test context');
+      } catch (error) {
+        expect((error as CacheError).message).toBe('test context: Promise rejected');
+        expect((error as CacheError).code).toBe('CACHE_ERROR');
+      }
+    });
+
+    test('should handle zero timeout', async () => {
+      const promise = new Promise(resolve => setTimeout(() => resolve('success'), 100));
+      
+      await expect(
+        ErrorHandler.withTimeout(promise, 0, 'test context')
+      ).rejects.toThrow(CacheError);
+    });
+
+    test('should handle negative timeout', async () => {
+      const promise = Promise.resolve('success');
+      
+      // Negative timeout should trigger immediate timeout
+      await expect(
+        ErrorHandler.withTimeout(promise, -1000, 'test context')
+      ).rejects.toThrow(CacheError);
+    });
+
+    test('should cleanup timeout when promise resolves', async () => {
+      const clearTimeoutSpy = jest.spyOn(global, 'clearTimeout');
+      const promise = Promise.resolve('success');
+      
+      await ErrorHandler.withTimeout(promise, 1000, 'test context');
+      
+      // Should clear timeout after promise resolves
+      expect(clearTimeoutSpy).toHaveBeenCalled();
+      
+      clearTimeoutSpy.mockRestore();
+    });
+
+    test('should handle multiple concurrent timeouts', async () => {
+      const promise1 = Promise.resolve('success1');
+      const promise2 = Promise.resolve('success2');
+      const promise3 = new Promise(resolve => setTimeout(() => resolve('success3'), 2000));
+      
+      const results = await Promise.allSettled([
+        ErrorHandler.withTimeout(promise1, 1000, 'context1'),
+        ErrorHandler.withTimeout(promise2, 1000, 'context2'),
+        ErrorHandler.withTimeout(promise3, 1000, 'context3'),
+      ]);
+      
+      expect(results[0].status).toBe('fulfilled');
+      expect(results[1].status).toBe('fulfilled');
+      expect(results[2].status).toBe('rejected');
+    });
+  });
+
+  describe('Integration with Cache Operations', () => {
+    test('should handle cache operation errors', () => {
+      const mockOperation = () => {
+        throw new Error('Cache operation failed');
+      };
+      
+      expect(() => {
+        ErrorHandler.handle(mockOperation(), 'cache.set');
+      }).toThrow('cache.set: Cache operation failed');
+    });
+
+    test('should handle async cache operation errors', async () => {
+      const mockAsyncOperation = async () => {
+        throw new Error('Async cache operation failed');
+      };
+      
+      await expect(
+        ErrorHandler.withTimeout(mockAsyncOperation(), 1000, 'cache.get')
+      ).rejects.toThrow('cache.get: Async cache operation failed');
+    });
+
+    test('should handle network timeout scenarios', async () => {
+      const mockNetworkCall = new Promise(resolve => 
+        setTimeout(() => resolve({ data: 'response' }), 5000)
+      );
+      
+      await expect(
+        ErrorHandler.withTimeout(mockNetworkCall, 1000, 'api.fetch')
+      ).rejects.toThrow('api.fetch: Operation timed out after 1000ms');
+    });
+  });
+
+  describe('Error Code Constants', () => {
+    test('should use consistent error codes', () => {
+      const scenarios = [
+        { error: new Error('test'), expectedCode: 'CACHE_ERROR' },
+        { error: 'string', expectedCode: 'UNKNOWN_ERROR' },
+        { error: null, expectedCode: 'UNKNOWN_ERROR' },
+        { error: undefined, expectedCode: 'UNKNOWN_ERROR' },
+      ];
+
+      scenarios.forEach(({ error, expectedCode }) => {
+        try {
+          ErrorHandler.handle(error, 'test');
+        } catch (caught) {
+          expect((caught as CacheError).code).toBe(expectedCode);
+        }
+      });
+    });
+
+    test('should use TIMEOUT code for timeout errors', async () => {
+      const promise = new Promise(resolve => setTimeout(() => resolve('late'), 2000));
+      
+      try {
+        await ErrorHandler.withTimeout(promise, 1000, 'test');
+      } catch (error) {
+        expect((error as CacheError).code).toBe('TIMEOUT');
+      }
+    });
+  });
+
+  describe('Edge Cases', () => {
+    test('should handle empty context string', () => {
+      const error = new Error('test error');
+      
+      try {
+        ErrorHandler.handle(error, '');
+      } catch (caught) {
+        expect((caught as CacheError).message).toBe(': test error');
+      }
+    });
+
+    test('should handle very long context string', () => {
+      const longContext = 'context'.repeat(1000);
+      const error = new Error('test error');
+      
+      try {
+        ErrorHandler.handle(error, longContext);
+      } catch (caught) {
+        expect((caught as CacheError).message).toBe(`${longContext}: test error`);
+      }
+    });
+
+    test('should handle special characters in context', () => {
+      const context = 'context-with-special-chars-!@#$%^&*()';
+      const error = new Error('test error');
+      
+      try {
+        ErrorHandler.handle(error, context);
+      } catch (caught) {
+        expect((caught as CacheError).message).toBe(`${context}: test error`);
+      }
+    });
+  });
+});

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

@@ -0,0 +1,261 @@
+/**
+ * PatternMatcher Tests
+ */
+
+import { PatternMatcher } from '../PatternMatcher';
+
+describe('PatternMatcher', () => {
+  beforeEach(() => {
+    PatternMatcher.clearCache();
+  });
+
+  describe('convertPatternToRegex', () => {
+    test('should handle simple patterns', () => {
+      const regex = PatternMatcher.convertPatternToRegex('user:*');
+      expect(regex.test('user:1')).toBe(true);
+      expect(regex.test('user:123')).toBe(true);
+      expect(regex.test('user:abc')).toBe(true);
+      expect(regex.test('admin:1')).toBe(false);
+    });
+
+    test('should handle multiple wildcards', () => {
+      const regex = PatternMatcher.convertPatternToRegex('*:*:*');
+      expect(regex.test('user:1:profile')).toBe(true);
+      expect(regex.test('post:2:comments')).toBe(true);
+      expect(regex.test('user:1')).toBe(false);
+      expect(regex.test('user')).toBe(false);
+    });
+
+    test('should handle exact matches', () => {
+      const regex = PatternMatcher.convertPatternToRegex('exact-key');
+      expect(regex.test('exact-key')).toBe(true);
+      expect(regex.test('exact-key-123')).toBe(false);
+      expect(regex.test('exact')).toBe(false);
+    });
+
+    test('should handle patterns with special characters', () => {
+      const regex = PatternMatcher.convertPatternToRegex('user.*profile');
+      expect(regex.test('user.123.profile')).toBe(true);
+      expect(regex.test('user.abc.profile')).toBe(true);
+      expect(regex.test('user.profile')).toBe(false);
+    });
+
+    test('should escape regex special characters', () => {
+      const regex = PatternMatcher.convertPatternToRegex('user.+?^${}()|[]\\');
+      expect(regex.test('user.+?^${}()|[]\\')).toBe(true);
+      expect(regex.test('user-something')).toBe(false);
+    });
+
+    test('should handle empty pattern', () => {
+      const regex = PatternMatcher.convertPatternToRegex('');
+      expect(regex.test('')).toBe(true);
+      expect(regex.test('anything')).toBe(false);
+    });
+
+    test('should handle pattern with only wildcards', () => {
+      const regex = PatternMatcher.convertPatternToRegex('*');
+      expect(regex.test('anything')).toBe(true);
+      expect(regex.test('')).toBe(true);
+    });
+
+    test('should handle complex patterns', () => {
+      const regex = PatternMatcher.convertPatternToRegex('cache:*:data:*');
+      expect(regex.test('cache:user:data:123')).toBe(true);
+      expect(regex.test('cache:post:data:456')).toBe(true);
+      expect(regex.test('cache:user:meta:123')).toBe(false);
+      expect(regex.test('user:data:123')).toBe(false);
+    });
+
+    test('should handle patterns with dots and dashes', () => {
+      const regex = PatternMatcher.convertPatternToRegex('module.*-service.*');
+      expect(regex.test('module.auth-service.v1')).toBe(true);
+      expect(regex.test('module.user-service.v2')).toBe(true);
+      expect(regex.test('module.auth')).toBe(false);
+    });
+  });
+
+  describe('matchesPattern', () => {
+    test('should return true for matching patterns', () => {
+      expect(PatternMatcher.matchesPattern('user:1', 'user:*')).toBe(true);
+      expect(PatternMatcher.matchesPattern('post:123:comments', '*:*:*')).toBe(true);
+      expect(PatternMatcher.matchesPattern('exact', 'exact')).toBe(true);
+    });
+
+    test('should return false for non-matching patterns', () => {
+      expect(PatternMatcher.matchesPattern('admin:1', 'user:*')).toBe(false);
+      expect(PatternMatcher.matchesPattern('user:1', '*:*:*')).toBe(false);
+      expect(PatternMatcher.matchesPattern('exact', 'different')).toBe(false);
+    });
+
+    test('should handle case-sensitive matching', () => {
+      expect(PatternMatcher.matchesPattern('User:1', 'user:*')).toBe(false);
+      expect(PatternMatcher.matchesPattern('user:1', 'User:*')).toBe(false);
+      expect(PatternMatcher.matchesPattern('USER:1', 'USER:*')).toBe(true);
+    });
+
+    test('should handle empty strings', () => {
+      expect(PatternMatcher.matchesPattern('', '')).toBe(true);
+      expect(PatternMatcher.matchesPattern('', '*')).toBe(true);
+      expect(PatternMatcher.matchesPattern('test', '')).toBe(false);
+    });
+  });
+
+  describe('Regex Caching', () => {
+    test('should cache converted regex patterns', () => {
+      const pattern = 'user:*';
+      
+      const regex1 = PatternMatcher.convertPatternToRegex(pattern);
+      const regex2 = PatternMatcher.convertPatternToRegex(pattern);
+      
+      expect(regex1).toBe(regex2); // Same reference
+    });
+
+    test('should create different regex for different patterns', () => {
+      const regex1 = PatternMatcher.convertPatternToRegex('user:*');
+      const regex2 = PatternMatcher.convertPatternToRegex('post:*');
+      
+      expect(regex1).not.toBe(regex2); // Different references
+      expect(regex1.test('user:1')).toBe(true);
+      expect(regex1.test('post:1')).toBe(false);
+      expect(regex2.test('post:1')).toBe(true);
+      expect(regex2.test('user:1')).toBe(false);
+    });
+
+    test('should clear cache', () => {
+      const pattern = 'user:*';
+      
+      const regex1 = PatternMatcher.convertPatternToRegex(pattern);
+      PatternMatcher.clearCache();
+      const regex2 = PatternMatcher.convertPatternToRegex(pattern);
+      
+      expect(regex1).not.toBe(regex2); // Different references after clear
+    });
+
+    test('should maintain cache performance', () => {
+      const pattern = 'very:complex:pattern:*:with:many:parts:*';
+      
+      // First call - should create new regex
+      const start1 = performance.now();
+      const regex1 = PatternMatcher.convertPatternToRegex(pattern);
+      const end1 = performance.now();
+      
+      // Second call - should use cached regex
+      const start2 = performance.now();
+      const regex2 = PatternMatcher.convertPatternToRegex(pattern);
+      const end2 = performance.now();
+      
+      expect(regex1).toBe(regex2);
+      // Second call should be faster (though this might not always be true in tests)
+      expect(end2 - start2).toBeLessThanOrEqual(end1 - start1);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    test('should handle very long patterns', () => {
+      const longPattern = 'a'.repeat(1000) + '*';
+      const longKey = 'a'.repeat(1000) + 'suffix';
+      
+      expect(PatternMatcher.matchesPattern(longKey, longPattern)).toBe(true);
+      expect(PatternMatcher.matchesPattern('a'.repeat(999), longPattern)).toBe(false);
+    });
+
+    test('should handle patterns with only special characters', () => {
+      const regex = PatternMatcher.convertPatternToRegex('.+?^${}()|[]\\');
+      expect(regex.test('.+?^${}()|[]\\')).toBe(true);
+    });
+
+    test('should handle Unicode characters', () => {
+      expect(PatternMatcher.matchesPattern('üser:1', 'üser:*')).toBe(true);
+      expect(PatternMatcher.matchesPattern('用户:1', '用户:*')).toBe(true);
+      expect(PatternMatcher.matchesPattern('🚀:launch', '🚀:*')).toBe(true);
+    });
+
+    test('should handle null and undefined inputs gracefully', () => {
+      expect(() => {
+        PatternMatcher.convertPatternToRegex(null as any);
+      }).toThrow();
+      
+      expect(() => {
+        PatternMatcher.convertPatternToRegex(undefined as any);
+      }).toThrow();
+    });
+
+    test('should handle non-string inputs', () => {
+      expect(() => {
+        PatternMatcher.convertPatternToRegex(123 as any);
+      }).toThrow();
+      
+      expect(() => {
+        PatternMatcher.convertPatternToRegex({} as any);
+      }).toThrow();
+    });
+  });
+
+  describe('Performance Considerations', () => {
+    test('should handle large number of pattern matches efficiently', () => {
+      const pattern = 'cache:*:data:*';
+      const keys = Array.from({ length: 1000 }, (_, i) => `cache:${i}:data:${i * 2}`);
+      
+      const start = performance.now();
+      
+      keys.forEach(key => {
+        PatternMatcher.matchesPattern(key, pattern);
+      });
+      
+      const end = performance.now();
+      
+      // Should complete within reasonable time (adjust threshold as needed)
+      expect(end - start).toBeLessThan(100); // 100ms
+    });
+
+    test('should reuse cached regex for many matches', () => {
+      const pattern = 'user:*';
+      const keys = Array.from({ length: 1000 }, (_, i) => `user:${i}`);
+      
+      // Pre-cache the regex
+      PatternMatcher.convertPatternToRegex(pattern);
+      
+      const start = performance.now();
+      
+      keys.forEach(key => {
+        PatternMatcher.matchesPattern(key, pattern);
+      });
+      
+      const end = performance.now();
+      
+      // Should be faster with cached regex
+      expect(end - start).toBeLessThan(50); // 50ms
+    });
+  });
+
+  describe('Real-world Scenarios', () => {
+    test('should handle common cache key patterns', () => {
+      const scenarios = [
+        { key: 'user:123:profile', pattern: 'user:*:profile', expected: true },
+        { key: 'user:123:settings', pattern: 'user:*:profile', expected: false },
+        { key: 'post:456:comments:789', pattern: 'post:*:comments:*', expected: true },
+        { key: 'post:456:likes', pattern: 'post:*:comments:*', expected: false },
+        { key: 'session:abc123', pattern: 'session:*', expected: true },
+        { key: 'cache:api:user:123', pattern: 'cache:api:*', expected: true },
+        { key: 'cache:db:user:123', pattern: 'cache:api:*', expected: false },
+      ];
+
+      scenarios.forEach(({ key, pattern, expected }) => {
+        expect(PatternMatcher.matchesPattern(key, pattern)).toBe(expected);
+      });
+    });
+
+    test('should handle API endpoint patterns', () => {
+      const apiPatterns = [
+        { endpoint: '/api/v1/users/123', pattern: '/api/v1/users/*', expected: true },
+        { endpoint: '/api/v1/posts/456/comments', pattern: '/api/v1/posts/*/comments', expected: true },
+        { endpoint: '/api/v2/users/123', pattern: '/api/v1/users/*', expected: false },
+        { endpoint: '/api/v1/users', pattern: '/api/v1/users/*', expected: false },
+      ];
+
+      apiPatterns.forEach(({ endpoint, pattern, expected }) => {
+        expect(PatternMatcher.matchesPattern(endpoint, pattern)).toBe(expected);
+      });
+    });
+  });
+});

package/src/cache/domain/strategies/EvictionStrategy.ts

@@ -0,0 +1,9 @@
+/**
+ * Eviction Strategy Interface
+ */
+
+import type { CacheEntry } from '../types/Cache';
+
+export interface EvictionStrategy<T> {
+  findKeyToEvict(entries: Map<string, CacheEntry<T>>): string | undefined;
+}

package/src/cache/domain/strategies/FIFOStrategy.ts

@@ -0,0 +1,12 @@
+/**
+ * FIFO (First In First Out) Eviction Strategy
+ */
+
+import type { EvictionStrategy } from './EvictionStrategy';
+import type { CacheEntry } from '../types/Cache';
+
+export class FIFOStrategy<T> implements EvictionStrategy<T> {
+  findKeyToEvict(entries: Map<string, CacheEntry<T>>): string | undefined {
+    return entries.keys().next().value;
+  }
+}

package/src/cache/domain/strategies/LFUStrategy.ts

@@ -0,0 +1,22 @@
+/**
+ * LFU (Least Frequently Used) Eviction Strategy
+ */
+
+import type { EvictionStrategy } from './EvictionStrategy';
+import type { CacheEntry } from '../types/Cache';
+
+export class LFUStrategy<T> implements EvictionStrategy<T> {
+  findKeyToEvict(entries: Map<string, CacheEntry<T>>): string | undefined {
+    let least: string | undefined;
+    let leastCount = Infinity;
+
+    for (const [key, entry] of entries.entries()) {
+      if (entry.accessCount < leastCount) {
+        leastCount = entry.accessCount;
+        least = key;
+      }
+    }
+
+    return least;
+  }
+}

package/src/cache/domain/strategies/LRUStrategy.ts

@@ -0,0 +1,22 @@
+/**
+ * LRU (Least Recently Used) Eviction Strategy
+ */
+
+import type { EvictionStrategy } from './EvictionStrategy';
+import type { CacheEntry } from '../types/Cache';
+
+export class LRUStrategy<T> implements EvictionStrategy<T> {
+  findKeyToEvict(entries: Map<string, CacheEntry<T>>): string | undefined {
+    let oldest: string | undefined;
+    let oldestTime = Infinity;
+
+    for (const [key, entry] of entries.entries()) {
+      if (entry.lastAccess < oldestTime) {
+        oldestTime = entry.lastAccess;
+        oldest = key;
+      }
+    }
+
+    return oldest;
+  }
+}

package/src/cache/domain/strategies/TTLStrategy.ts

@@ -0,0 +1,23 @@
+/**
+ * TTL (Time To Live) Eviction Strategy
+ */
+
+import type { EvictionStrategy } from './EvictionStrategy';
+import type { CacheEntry } from '../types/Cache';
+
+export class TTLStrategy<T> implements EvictionStrategy<T> {
+  findKeyToEvict(entries: Map<string, CacheEntry<T>>): string | undefined {
+    let nearest: string | undefined;
+    let nearestExpiry = Infinity;
+
+    for (const [key, entry] of entries.entries()) {
+      const expiry = entry.timestamp + entry.ttl;
+      if (expiry < nearestExpiry) {
+        nearestExpiry = expiry;
+        nearest = key;
+      }
+    }
+
+    return nearest;
+  }
+}