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

package/src/storage/cache/infrastructure/__tests__/TTLCache.test.ts

@@ -0,0 +1,303 @@
+/**
+ * TTLCache Tests
+ */
+
+import { TTLCache } from '../TTLCache';
+import type { CacheConfig } from '../domain/types/Cache';
+
+describe('TTLCache', () => {
+  let cache: TTLCache<string>;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    cache = new TTLCache<string>({ 
+      maxSize: 5, 
+      defaultTTL: 1000,
+      cleanupIntervalMs: 500 
+    });
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    cache.destroy();
+  });
+
+  describe('Basic Functionality', () => {
+    test('should inherit from Cache', () => {
+      expect(cache).toHaveProperty('set');
+      expect(cache).toHaveProperty('get');
+      expect(cache).toHaveProperty('has');
+      expect(cache).toHaveProperty('delete');
+      expect(cache).toHaveProperty('clear');
+    });
+
+    test('should set and get values', () => {
+      cache.set('key1', 'value1');
+      expect(cache.get('key1')).toBe('value1');
+    });
+
+    test('should use default TTL', () => {
+      cache.set('key1', 'value1');
+      expect(cache.get('key1')).toBe('value1');
+
+      jest.advanceTimersByTime(1001);
+      expect(cache.get('key1')).toBeUndefined();
+    });
+
+    test('should use custom TTL', () => {
+      cache.set('key1', 'value1', 2000);
+      expect(cache.get('key1')).toBe('value1');
+
+      jest.advanceTimersByTime(1001);
+      expect(cache.get('key1')).toBe('value1'); // Should still exist
+
+      jest.advanceTimersByTime(1000);
+      expect(cache.get('key1')).toBeUndefined(); // Should be expired
+    });
+  });
+
+  describe('Automatic Cleanup', () => {
+    test('should start cleanup interval on creation', () => {
+      const setIntervalSpy = jest.spyOn(global, 'setInterval');
+      new TTLCache<string>({ cleanupIntervalMs: 1000 });
+      
+      expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 1000);
+      setIntervalSpy.mockRestore();
+    });
+
+    test('should cleanup expired entries automatically', () => {
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+      
+      cache.set('key1', 'value1', 500);
+      cache.set('key2', 'value2', 1500);
+      
+      // Fast forward to trigger first cleanup
+      jest.advanceTimersByTime(500);
+      
+      // key1 should be cleaned up, key2 should remain
+      expect(cache.get('key1')).toBeUndefined();
+      expect(cache.get('key2')).toBe('value2');
+      
+      expect(consoleSpy).toHaveBeenCalledWith('TTLCache: Cleaned up 1 expired entries');
+      
+      consoleSpy.mockRestore();
+    });
+
+    test('should not log when no entries are cleaned up', () => {
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+      
+      cache.set('key1', 'value1', 2000);
+      
+      // Fast forward, but no entries should be expired yet
+      jest.advanceTimersByTime(500);
+      
+      expect(consoleSpy).not.toHaveBeenCalled();
+      
+      consoleSpy.mockRestore();
+    });
+
+    test('should handle multiple cleanup cycles', () => {
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+      
+      cache.set('key1', 'value1', 300);
+      cache.set('key2', 'value2', 800);
+      cache.set('key3', 'value3', 1300);
+      
+      // First cleanup - key1 expires
+      jest.advanceTimersByTime(500);
+      expect(cache.get('key1')).toBeUndefined();
+      expect(cache.get('key2')).toBe('value2');
+      expect(cache.get('key3')).toBe('value3');
+      
+      // Second cleanup - key2 expires
+      jest.advanceTimersByTime(500);
+      expect(cache.get('key2')).toBeUndefined();
+      expect(cache.get('key3')).toBe('value3');
+      
+      // Third cleanup - key3 expires
+      jest.advanceTimersByTime(500);
+      expect(cache.get('key3')).toBeUndefined();
+      
+      expect(consoleSpy).toHaveBeenCalledTimes(3);
+      
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('Destroy Method', () => {
+    test('should clear cleanup interval on destroy', () => {
+      const clearIntervalSpy = jest.spyOn(global, 'clearInterval');
+      
+      cache.destroy();
+      
+      expect(clearIntervalSpy).toHaveBeenCalled();
+      clearIntervalSpy.mockRestore();
+    });
+
+    test('should clear all data on destroy', () => {
+      cache.set('key1', 'value1');
+      cache.set('key2', 'value2');
+      
+      expect(cache.getStats().size).toBe(2);
+      
+      cache.destroy();
+      
+      expect(cache.getStats().size).toBe(0);
+    });
+
+    test('should handle multiple destroy calls', () => {
+      const clearIntervalSpy = jest.spyOn(global, 'clearInterval');
+      
+      cache.destroy();
+      cache.destroy();
+      cache.destroy();
+      
+      // Should only call clearInterval once
+      expect(clearIntervalSpy).toHaveBeenCalledTimes(1);
+      
+      clearIntervalSpy.mockRestore();
+    });
+
+    test('should not cleanup after destroy', () => {
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+      
+      cache.set('key1', 'value1', 300);
+      
+      cache.destroy();
+      
+      // Advance time - should not trigger cleanup
+      jest.advanceTimersByTime(1000);
+      
+      expect(consoleSpy).not.toHaveBeenCalled();
+      
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('Destroyed State Handling', () => {
+    beforeEach(() => {
+      cache.destroy();
+    });
+
+    test('should warn on set after destroy', () => {
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+      
+      cache.set('key1', 'value1');
+      
+      expect(consoleSpy).toHaveBeenCalledWith('TTLCache: Attempted to set value on destroyed cache');
+      expect(cache.get('key1')).toBeUndefined();
+      
+      consoleSpy.mockRestore();
+    });
+
+    test('should warn on get after destroy', () => {
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+      
+      const result = cache.get('key1');
+      
+      expect(consoleSpy).toHaveBeenCalledWith('TTLCache: Attempted to get value from destroyed cache');
+      expect(result).toBeUndefined();
+      
+      consoleSpy.mockRestore();
+    });
+
+    test('should return false for has after destroy', () => {
+      expect(cache.has('key1')).toBe(false);
+    });
+
+    test('should return false for delete after destroy', () => {
+      expect(cache.delete('key1')).toBe(false);
+    });
+
+    test('should not throw on clear after destroy', () => {
+      expect(() => cache.clear()).not.toThrow();
+    });
+  });
+
+  describe('Configuration', () => {
+    test('should use custom cleanup interval', () => {
+      const setIntervalSpy = jest.spyOn(global, 'setInterval');
+      
+      new TTLCache<string>({ cleanupIntervalMs: 2000 });
+      
+      expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 2000);
+      setIntervalSpy.mockRestore();
+    });
+
+    test('should use default cleanup interval when not specified', () => {
+      const setIntervalSpy = jest.spyOn(global, 'setInterval');
+      
+      new TTLCache<string>();
+      
+      expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 60000);
+      setIntervalSpy.mockRestore();
+    });
+
+    test('should pass configuration to parent Cache', () => {
+      const config: CacheConfig = {
+        maxSize: 10,
+        defaultTTL: 5000,
+      };
+      
+      const customCache = new TTLCache<string>(config);
+      
+      customCache.set('key1', 'value1');
+      expect(customCache.get('key1')).toBe('value1');
+      
+      // Should use custom default TTL
+      jest.advanceTimersByTime(5001);
+      expect(customCache.get('key1')).toBeUndefined();
+      
+      customCache.destroy();
+    });
+  });
+
+  describe('Memory Management', () => {
+    test('should not memory leak with many entries', () => {
+      const entryCount = 1000;
+      
+      // Create many entries with short TTL
+      for (let i = 0; i < entryCount; i++) {
+        cache.set(`key${i}`, `value${i}`, 100);
+      }
+      
+      expect(cache.getStats().size).toBe(entryCount);
+      
+      // Let all entries expire and cleanup
+      jest.advanceTimersByTime(500);
+      
+      expect(cache.getStats().size).toBe(0);
+    });
+
+    test('should handle rapid create/destroy cycles', () => {
+      for (let i = 0; i < 10; i++) {
+        const tempCache = new TTLCache<string>({ cleanupIntervalMs: 100 });
+        tempCache.set('key', 'value');
+        tempCache.destroy();
+      }
+      
+      // Should not throw or cause issues
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    test('should handle zero cleanup interval', () => {
+      expect(() => {
+        new TTLCache<string>({ cleanupIntervalMs: 0 });
+      }).not.toThrow();
+    });
+
+    test('should handle negative cleanup interval', () => {
+      expect(() => {
+        new TTLCache<string>({ cleanupIntervalMs: -100 });
+      }).not.toThrow();
+    });
+
+    test('should handle very large cleanup interval', () => {
+      expect(() => {
+        new TTLCache<string>({ cleanupIntervalMs: Number.MAX_SAFE_INTEGER });
+      }).not.toThrow();
+    });
+  });
+});

package/src/storage/cache/presentation/README.md

@@ -0,0 +1,123 @@
+# Cache Presentation
+
+React hooks and UI integration for cache system.
+
+## Overview
+
+Presentation layer provides React hooks and components for integrating cache functionality with React applications. Located at `src/cache/presentation/`.
+
+## Strategies
+
+### Hook Design
+- Create hooks for common caching patterns
+- Provide simple, composable APIs
+- Support React Suspense where applicable
+- Handle loading and error states
+
+### React Integration
+- Follow React rules of hooks
+- Support dependency arrays correctly
+- Clean up on component unmount
+- Avoid unnecessary re-renders
+
+### State Management
+- Expose cache state reactively
+- Provide update mechanisms
+- Support invalidation and refresh
+- Handle stale data appropriately
+
+### Performance
+- Use memoization to prevent redundant operations
+- Implement efficient re-render strategies
+- Debounce rapid cache operations
+- Minimize hook overhead
+
+## Restrictions
+
+### Hook Usage
+- DO NOT call hooks outside React components
+- DO NOT call hooks conditionally
+- DO NOT call hooks in loops
+- DO NOT create new cache instances on every render
+
+### State Management
+- DO NOT cause infinite re-render loops
+- DO NOT mutate state directly
+- DO NOT ignore loading states
+- DO NOT swallow errors silently
+
+### Performance
+- DO NOT recreate functions on every render
+- DO NOT subscribe to entire cache when slice needed
+- DO NOT perform expensive operations in render
+- DO NOT cache large computed values in hook state
+
+### Cleanup
+- DO NOT leak subscriptions
+- DO NOT forget cleanup on unmount
+- DO NOT create memory leaks
+- DO NOT leave timers running
+
+## Rules
+
+### Hook Implementation
+- MUST follow React rules of hooks
+- MUST use `use` prefix for hook names
+- MUST provide TypeScript types
+- MUST handle errors gracefully
+
+### useCache Hook
+- MUST accept cache name parameter
+- MUST return cache interface methods
+- MUST provide consistent API across renders
+- MUST handle non-existent cache gracefully
+
+### useCachedValue Hook
+- MUST accept key and fetcher function
+- MUST accept optional TTL parameter
+- MUST return value, setter, and invalidate function
+- MUST handle loading state
+- MUST handle error state
+
+### State Updates
+- MUST trigger re-renders on cache changes
+- MUST use React state for reactive values
+- MUST memoize callbacks to prevent re-renders
+- MUST update state atomically
+
+### Cleanup Behavior
+- MUST clean up subscriptions on unmount
+- MUST cancel pending operations
+- MUST clear timers
+- MUST not leak memory
+
+### Error Handling
+- MUST expose error state to caller
+- MUST allow error recovery
+- MUST log errors in development
+- MUST provide error boundaries for usage
+
+### TypeScript Types
+- MUST provide generic type parameters
+- MUST infer types from cache
+- MUST enforce type safety
+- MUST document complex types
+
+### Performance Rules
+- MUST use useCallback for stable function references
+- MUST use useMemo for expensive computations
+- MUST provide stable references across renders
+- MUST minimize re-render frequency
+
+### Testing Requirements
+- MUST test with @testing-library/react-hooks
+- MUST test cleanup behavior
+- MUST test error scenarios
+- MUST test type safety
+- MUST test re-render behavior
+
+### Export Rules
+- MUST export hooks from index file
+- MUST provide consistent naming
+- MUST document hook contracts
+- MUST maintain backward compatibility