@umituz/react-native-design-system 2.8.7 → 2.8.8

package/src/storage/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/storage/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/storage/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/storage/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/storage/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/storage/cache/domain/strategies/README.md

@@ -0,0 +1,117 @@
+# Cache Eviction Strategies
+
+Algorithms for determining which cache entries to evict when cache is full.
+
+## Overview
+
+Eviction strategies determine which cache entries to remove when the cache reaches its maximum size. Located at `src/cache/domain/strategies/`.
+
+## Strategies
+
+### Strategy Selection
+- Use LRU (Least Recently Used) for most use cases - best general performance
+- Use LFU (Least Frequently Used) for popularity-based caching - keeps frequently accessed items
+- Use FIFO (First In First Out) for simple queue-based caching - lowest overhead
+- Use TTL (Time To Live) for time-sensitive data - required for expiration
+
+### Performance Considerations
+- LRU provides O(1) eviction time with proper data structures
+- LFU provides O(n) eviction time but better for read-heavy workloads
+- FIFO provides O(1) eviction time with minimal overhead
+- TTL requires periodic cleanup but essential for freshness
+
+### Access Pattern Analysis
+- Consider data access patterns when choosing strategy
+- Use LRU for temporal locality (recently accessed likely to be accessed again)
+- Use LFU for frequency-based patterns (popular items should stay)
+- Use FIFO for sequential access patterns
+- Use TTL when data freshness is critical
+
+### Implementation Strategy
+- Implement EvictionStrategy interface for custom strategies
+- Track necessary metadata (access count, last access, timestamp)
+- Provide findKeyToEvict method for selection
+- Update metadata on cache operations
+
+## Restrictions
+
+### Strategy Usage
+- DO NOT use LFU for write-heavy workloads (expensive)
+- DO NOT use FIFO when access patterns matter
+- DO NOT use TTL when data staleness is acceptable
+- DO NOT change strategies after cache creation
+
+### Performance
+- DO NOT implement O(n²) eviction algorithms
+- DO NOT scan entire cache for eviction on every operation
+- DO NOT track unnecessary metadata for chosen strategy
+- DO NOT use complex algorithms for simple use cases
+
+### Custom Strategies
+- DO NOT implement custom strategies without thorough testing
+- DO NOT ignore edge cases (empty cache, single entry)
+- DO NOT create strategies without clear performance benefits
+- DO NOT mix multiple eviction strategies in same cache
+
+## Rules
+
+### EvictionStrategy Interface
+- MUST implement findKeyToEvict(store: Map): string | undefined
+- MUST return undefined when store is empty
+- MUST return single key for eviction
+- MUST handle all cache states correctly
+
+### LRU Strategy
+- MUST track lastAccess timestamp for each entry
+- MUST update lastAccess on every get operation
+- MUST select entry with oldest lastAccess time
+- MUST provide O(1) or O(log n) time complexity
+
+### LFU Strategy
+- MUST track accessCount for each entry
+- MUST increment accessCount on every get operation
+- MUST select entry with lowest accessCount
+- MUST handle ties consistently (use LRU as tiebreaker)
+
+### FIFO Strategy
+- MUST track insertion order for each entry
+- MUST select oldest entry (first inserted)
+- MUST NOT consider access patterns
+- MUST provide O(1) time complexity
+
+### TTL Strategy
+- MUST check timestamp + ttl against current time
+- MUST select expired entries first
+- MUST fall back to secondary strategy if no expired entries
+- MUST handle zero TTL entries (immediate eviction)
+
+### Metadata Updates
+- MUST update eviction metadata on every cache operation
+- MUST update metadata on cache set operations
+- MUST update metadata on cache get operations
+- MUST reset metadata appropriately on cache updates
+
+### Edge Cases
+- MUST handle empty cache (return undefined)
+- MUST handle single entry cache
+- MUST handle all entries with same metadata
+- MUST handle concurrent access safely
+
+### Strategy Selection
+- MUST use LRU as default strategy
+- MUST allow strategy override in configuration
+- MUST validate strategy choice
+- MUST document strategy behavior
+
+### Testing Requirements
+- MUST test eviction with full cache
+- MUST test eviction with empty cache
+- MUST test metadata tracking accuracy
+- MUST test edge cases
+- MUST measure time complexity
+
+### Performance Rules
+- MUST not exceed O(n) for eviction selection
+- MUST not allocate memory during eviction
+- MUST not use blocking operations
+- MUST minimize CPU overhead

package/src/storage/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;
+  }
+}