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

package/src/storage/__tests__/performance.test.tsx

@@ -0,0 +1,352 @@
+/* eslint-disable */
+/**
+ * Performance Tests
+ *
+ * Performance and memory leak tests
+ */
+
+import { renderHook, act } from '@testing-library/react-hooks';
+import { useStorage, useStorageState, usePersistentCache } from '../../index';
+import { AsyncStorage } from '../mocks/asyncStorage.mock';
+import { mockPerformance, trackMemoryUsage } from '../setup';
+
+describe('Performance Tests', () => {
+  beforeEach(() => {
+    (AsyncStorage as any).__clear();
+    jest.clearAllMocks();
+    mockPerformance();
+  });
+
+  describe('Memory Leak Prevention', () => {
+    it('should not leak memory with multiple hook instances', () => {
+      const memoryTracker = trackMemoryUsage();
+      
+      // Create many hook instances
+      const hooks = Array.from({ length: 100 }, (_, i) => 
+        renderHook(() => useStorage())
+      );
+
+      // Add listeners
+      hooks.forEach(hook => {
+        hook.current.getItem(`key-${i}`, 'default');
+      });
+
+      const listenerCount = memoryTracker.getListenerCount();
+      expect(listenerCount).toBeLessThan(50); // Should be much less than 100
+
+      // Cleanup
+      hooks.forEach(hook => hook.unmount());
+      memoryTracker.cleanup();
+    });
+
+    it('should cleanup on unmount', () => {
+      const memoryTracker = trackMemoryUsage();
+      
+      const { result, unmount } = renderHook(() => useStorageState('test', 'default'));
+
+      // Add some async operations
+      const promise = result.current[1]('test-value');
+      
+      // Unmount before promise resolves
+      unmount();
+
+      const listenerCount = memoryTracker.getListenerCount();
+      expect(listenerCount).toBe(0);
+
+      memoryTracker.cleanup();
+      return promise;
+    });
+
+    it('should not create multiple CacheStorageOperations instances', () => {
+      const { result: hook1 } = renderHook(() => 
+        usePersistentCache('key1')
+      );
+
+      const { result: hook2 } = renderHook(() => 
+        usePersistentCache('key2')
+      );
+
+      const { result: hook3 } = renderHook(() => 
+        usePersistentCache('key3')
+      );
+
+      // All should use the same instance (singleton pattern)
+      expect(hook1.current.setData).toBe(hook2.current.setData);
+      expect(hook2.current.setData).toBe(hook3.current.setData);
+    });
+  });
+
+  describe('Performance Benchmarks', () => {
+    it('should handle large datasets efficiently', async () => {
+      const { result: storageHook } = renderHook(() => useStorage());
+
+      // Create large dataset (10,000 items)
+      const largeData = Array.from({ length: 10000 }, (_, i) => ({
+        id: i,
+        name: `Item ${i}`,
+        description: `Description for item ${i}`,
+        metadata: {
+          created: Date.now(),
+          tags: [`tag${i % 10}`, `category${i % 5}`],
+        },
+      }));
+
+      const startTime = performance.now();
+
+      // Set large data
+      const setSuccess = await storageHook.current.setItem('large-data', largeData);
+      expect(setSuccess).toBe(true);
+
+      // Get large data
+      const retrievedData = await storageHook.current.getItem('large-data', []);
+      expect(retrievedData).toEqual(largeData);
+
+      const endTime = performance.now();
+      const duration = endTime - startTime;
+
+      // Should complete within reasonable time (less than 1 second)
+      expect(duration).toBeLessThan(1000);
+    });
+
+    it('should handle rapid operations efficiently', async () => {
+      const { result: storageHook } = renderHook(() => useStorage());
+
+      const iterations = 1000;
+      const startTime = performance.now();
+
+      // Rapid set/get operations
+      for (let i = 0; i < iterations; i++) {
+        const key = `rapid-key-${i}`;
+        const value = `rapid-value-${i}`;
+
+        await storageHook.current.setItem(key, value);
+        const retrieved = await storageHook.current.getItem(key, '');
+        expect(retrieved).toBe(value);
+      }
+
+      const endTime = performance.now();
+      const duration = endTime - startTime;
+      const avgTime = duration / iterations;
+
+      // Average operation should be fast (less than 1ms per operation)
+      expect(avgTime).toBeLessThan(1);
+    });
+
+    it('should handle concurrent operations efficiently', async () => {
+      const { result: storageHook } = renderHook(() => useStorage());
+
+      const concurrentOperations = 100;
+      const operations = Array.from({ length: concurrentOperations }, (_, i) => 
+        storageHook.current.setItem(`concurrent-key-${i}`, `concurrent-value-${i}`)
+      );
+
+      const startTime = performance.now();
+
+      // Execute all operations concurrently
+      const results = await Promise.all(operations);
+
+      const endTime = performance.now();
+      const duration = endTime - startTime;
+
+      // All operations should succeed
+      expect(results.every(success => success)).toBe(true);
+
+      // Concurrent operations should be faster than sequential
+      expect(duration).toBeLessThan(concurrentOperations * 10); // Less than 10ms per operation
+    });
+  });
+
+  describe('Cache Performance', () => {
+    it('should handle cache operations efficiently', async () => {
+      const { result: cacheHook } = renderHook(() => 
+        usePersistentCache('performance-cache')
+      );
+
+      const cacheOperations = 1000;
+      const startTime = performance.now();
+
+      // Rapid cache operations
+      for (let i = 0; i < cacheOperations; i++) {
+        const data = { id: i, value: `cache-value-${i}` };
+        
+        await cacheHook.current.setData(data);
+        expect(cacheHook.current.data).toEqual(data);
+      }
+
+      const endTime = performance.now();
+      const duration = endTime - startTime;
+      const avgTime = duration / cacheOperations;
+
+      // Cache operations should be very fast
+      expect(avgTime).toBeLessThan(0.1); // Less than 0.1ms per operation
+    });
+
+    it('should handle TTL checks efficiently', async () => {
+      const { result: cacheHook } = renderHook(() => 
+        usePersistentCache('ttl-cache', { ttl: 60000 })
+      );
+
+      const data = { test: 'value' };
+      await cacheHook.current.setData(data);
+
+      const startTime = performance.now();
+
+      // Check TTL many times (should be cached)
+      for (let i = 0; i < 10000; i++) {
+        // Access isExpired property
+        const isExpired = cacheHook.current.isExpired;
+        expect(isExpired).toBe(false);
+      }
+
+      const endTime = performance.now();
+      const duration = endTime - startTime;
+
+      // TTL checks should be extremely fast
+      expect(duration).toBeLessThan(10); // Less than 10ms for 10,000 checks
+    });
+  });
+
+  describe('State Performance', () => {
+    it('should handle state updates efficiently', async () => {
+      const { result: stateHook, waitForNextUpdate } = renderHook(() => 
+        useStorageState('performance-state', 'initial')
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      const stateUpdates = 1000;
+      const startTime = performance.now();
+
+      // Rapid state updates
+      for (let i = 0; i < stateUpdates; i++) {
+        await act(async () => {
+          await stateHook.current[1](`update-${i}`);
+        });
+        expect(stateHook.current[0]).toBe(`update-${i}`);
+      }
+
+      const endTime = performance.now();
+      const duration = endTime - startTime;
+      const avgTime = duration / stateUpdates;
+
+      // State updates should be fast
+      expect(avgTime).toBeLessThan(1); // Less than 1ms per update
+    });
+
+    it('should not re-render unnecessarily', async () => {
+      let renderCount = 0;
+      
+      const TestComponent = () => {
+        renderCount++;
+        const [state] = useStorageState('render-test', 'default');
+        return null; // Don't render anything
+      };
+
+      const { rerender } = renderHook(() => <TestComponent />);
+
+      const initialRenders = renderCount;
+
+      // Rerender with same props
+      rerender(<TestComponent />);
+
+      // Should not cause additional renders
+      expect(renderCount).toBe(initialRenders);
+    });
+  });
+
+  describe('Memory Usage', () => {
+    it('should maintain stable memory usage', async () => {
+      const { result: storageHook } = renderHook(() => useStorage());
+
+      const initialMemory = (performance as any).memory?.usedJSHeapSize || 0;
+
+      // Create and destroy many objects
+      for (let i = 0; i < 1000; i++) {
+        const largeObject = {
+          id: i,
+          data: new Array(1000).fill(`data-${i}`),
+          nested: {
+            level1: { level2: { level3: new Array(100).fill(`nested-${i}`) } },
+          },
+        };
+
+        await storageHook.current.setItem(`temp-${i}`, largeObject);
+        await storageHook.current.removeItem(`temp-${i}`);
+      }
+
+      // Force garbage collection if available
+      if (global.gc) {
+        global.gc();
+      }
+
+      const finalMemory = (performance as any).memory?.usedJSHeapSize || 0;
+      const memoryIncrease = finalMemory - initialMemory;
+
+      // Memory increase should be minimal
+      expect(memoryIncrease).toBeLessThan(1024 * 1024); // Less than 1MB increase
+    });
+
+    it('should cleanup event listeners', () => {
+      const memoryTracker = trackMemoryUsage();
+      
+      // Create and destroy many hooks
+      for (let i = 0; i < 100; i++) {
+        const { unmount } = renderHook(() => useStorageState(`cleanup-${i}`, 'default'));
+        unmount();
+      }
+
+      const listenerCount = memoryTracker.getListenerCount();
+      expect(listenerCount).toBe(0);
+
+      memoryTracker.cleanup();
+    });
+  });
+
+  describe('Scalability Tests', () => {
+    it('should handle many keys efficiently', async () => {
+      const { result: storageHook } = renderHook(() => useStorage());
+
+      const keyCount = 10000;
+      const startTime = performance.now();
+
+      // Create many keys
+      for (let i = 0; i < keyCount; i++) {
+        await storageHook.current.setItem(`scale-key-${i}`, `scale-value-${i}`);
+      }
+
+      const endTime = performance.now();
+      const duration = endTime - startTime;
+
+      // Should handle many keys efficiently
+      expect(duration).toBeLessThan(keyCount * 0.1); // Less than 0.1ms per key
+
+      // Verify all keys exist
+      for (let i = 0; i < keyCount; i++) {
+        const exists = await storageHook.current.hasItem(`scale-key-${i}`);
+        expect(exists).toBe(true);
+      }
+    });
+
+    it('should handle large values efficiently', async () => {
+      const { result: storageHook } = renderHook(() => useStorage());
+
+      // Create very large value (1MB string)
+      const largeValue = 'x'.repeat(1024 * 1024);
+      const startTime = performance.now();
+
+      const setSuccess = await storageHook.current.setItem('large-value', largeValue);
+      expect(setSuccess).toBe(true);
+
+      const retrievedValue = await storageHook.current.getString('large-value', '');
+      expect(retrievedValue).toBe(largeValue);
+
+      const endTime = performance.now();
+      const duration = endTime - startTime;
+
+      // Large values should be handled efficiently
+      expect(duration).toBeLessThan(100); // Less than 100ms for 1MB
+    });
+  });
+});

package/src/storage/__tests__/setup.ts

@@ -0,0 +1,63 @@
+/**
+ * Test Setup
+ *
+ * Global test configuration and mocks
+ */
+
+import 'jest-environment-jsdom';
+
+// Mock __DEV__ global
+Object.defineProperty(globalThis, '__DEV__', {
+  value: true,
+  writable: true,
+});
+
+// Mock AsyncStorage
+jest.mock('@react-native-async-storage/async-storage', () => ({
+  default: {
+    getItem: jest.fn(),
+    setItem: jest.fn(),
+    removeItem: jest.fn(),
+    clear: jest.fn(),
+    getAllKeys: jest.fn(),
+    multiGet: jest.fn(),
+  },
+}));
+
+// Mock console for __DEV__ checks
+const originalConsole = { ...console };
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+afterEach(() => {
+  // Restore console after each test
+  Object.assign(console, originalConsole);
+});
+
+// Performance test utilities
+export const mockPerformance = () => {
+  const mockPerformance = {
+    now: jest.fn(() => Date.now()),
+    mark: jest.fn(),
+    measure: jest.fn(),
+  };
+  
+  globalThis.performance = mockPerformance as any;
+  return mockPerformance;
+};
+
+// Memory leak test utilities
+export const trackMemoryUsage = () => {
+  const listeners = new Set<() => void>();
+  
+  return {
+    addListener: (listener: () => void) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    getListenerCount: () => listeners.size,
+    cleanup: () => listeners.clear(),
+  };
+};

package/src/storage/application/README.md

@@ -0,0 +1,158 @@
+# Application Layer
+
+Ports and interfaces for dependency inversion between domain and infrastructure layers.
+
+## Overview
+
+Application layer containing interfaces (ports) for storage operations. Located at `src/application/`.
+
+## Directory Structure
+
+- `ports/` - Repository interfaces defining storage contracts
+
+## Strategies
+
+### Dependency Inversion
+- Use IStorageRepository interface for storage operations
+- Define contracts in application layer
+- Implement interfaces in infrastructure layer
+- Enable dependency injection for testing
+
+### Port Definition
+- Use IStorageRepository as primary storage interface
+- Define all storage operations as methods
+- Support Result pattern for error handling
+- Enable generic type parameters for type safety
+
+### Use Case Pattern
+- Create use cases for complex business logic
+- Inject IStorageRepository through constructor
+- Encapsulate business rules in use case methods
+- Enable testing with mock implementations
+
+### Interface Segregation
+- Define cohesive interfaces for specific purposes
+- Support granular method dependencies
+- Enable single responsibility principle
+- Facilitate testing with focused mocks
+
+## Restrictions
+
+### Interface Definition
+- DO NOT define implementation details in interfaces
+- DO NOT create interfaces without clear purpose
+- DO NOT mix different concerns in single interface
+- DO NOT include framework-specific types
+
+### Dependency Injection
+- DO NOT create concrete instances in use cases
+- DO NOT use hardcoded dependencies
+- DO NOT skip constructor injection
+- DO NOT create circular dependencies
+
+### Use Case Implementation
+- DO NOT implement business logic in components
+- DO NOT mix storage operations with UI logic
+- DO NOT create use cases without clear purpose
+- DO NOT bypass error handling in use cases
+
+### Testing
+- DO NOT test with real storage implementations
+- DO NOT create complex mock implementations
+- DO NOT share state between tests
+- DO NOT forget to reset mocks between tests
+
+## Rules
+
+### IStorageRepository Interface
+- MUST define getItem<T>(key, defaultValue): Promise<StorageResult<T>>
+- MUST define setItem<T>(key, value): Promise<StorageResult<void>>
+- MUST define getString(key, defaultValue): Promise<StorageResult<string>>
+- MUST define setString(key, value): Promise<StorageResult<void>>
+- MUST define removeItem(key): Promise<StorageResult<void>>
+- MUST define hasItem(key): Promise<boolean>
+- MUST define clearAll(): Promise<StorageResult<void>>
+
+### Interface Design
+- MUST use generic type parameters for value operations
+- MUST return Result type for all mutable operations
+- MUST support type inference from parameters
+- MUST be framework-agnostic
+- MUST define contracts only (no implementation)
+
+### Method Signatures
+- MUST accept key parameter for all operations
+- MUST accept defaultValue parameter for get operations
+- MUST accept value parameter for set operations
+- MUST return Promise for all async operations
+- MUST include StorageResult for typed results
+
+### Use Case Implementation
+- MUST accept IStorageRepository in constructor
+- MUST define single responsibility per use case
+- MUST handle Result pattern in all operations
+- MUST return domain types from use case methods
+- MUST not expose storage implementation details
+
+### Constructor Injection
+- MUST inject dependencies through constructor
+- MUST store dependencies as private fields
+- MUST use interface types for dependencies
+- MUST enable dependency injection for testing
+- MUST not create instances inside use cases
+
+### Error Handling
+- MUST check result.success before accessing data
+- MUST handle result.error appropriately
+- MUST propagate errors to callers when needed
+- MUST not throw exceptions from use cases
+- MUST preserve error context
+
+### Testing Requirements
+- MUST enable mocking of IStorageRepository
+- MUST support test double implementations
+- MUST isolate tests from real storage
+- MUST clear state between test runs
+- MUST not depend on external services
+
+### Mock Implementation
+- MUST implement full IStorageRepository interface
+- MUST return appropriate Result types
+- MUST simulate storage behavior accurately
+- MUST support async operations with Promise
+- MUST be simple and predictable
+
+### Custom Repository Implementation
+- MUST implement IStorageRepository interface
+- MUST use Result pattern for all methods
+- MUST handle errors appropriately
+- MUST support generic type parameters
+- MUST be compatible with existing code
+
+### Layer Separation
+- MUST not depend on infrastructure implementations
+- MUST not depend on presentation components
+- MUST define contracts for domain use
+- MUST enable layer independence
+- MUST support testing at each layer
+
+### Export Rules
+- MUST export IStorageRepository interface
+- MUST export all port interfaces
+- MUST not export implementations
+- MUST provide TypeScript types
+- MUST document interface contracts
+
+### Architecture Compliance
+- MUST follow dependency inversion principle
+- MUST depend on abstractions not concretions
+- MUST enable independent layer evolution
+- MUST support multiple implementations
+- MUST maintain clear separation of concerns
+
+### Documentation
+- MUST document all interface methods
+- MUST specify method contracts clearly
+- MUST provide usage guidance
+- MUST explain Result pattern usage
+- MUST not include implementation examples

package/src/storage/application/ports/IStorageRepository.ts

@@ -0,0 +1,61 @@
+/**
+ * Storage Repository Interface (Port)
+ *
+ * Domain-Driven Design: Application port for storage operations
+ * Infrastructure layer implements this interface
+ */
+
+import type { StorageResult } from '../../domain/entities/StorageResult';
+
+/**
+ * Storage Repository Interface
+ * Defines contract for storage operations
+ */
+export interface IStorageRepository {
+  /**
+   * Get item from storage with JSON parsing
+   */
+  getItem<T>(key: string, defaultValue: T): Promise<StorageResult<T>>;
+
+  /**
+   * Set item in storage with JSON serialization
+   */
+  setItem<T>(key: string, value: T): Promise<StorageResult<T>>;
+
+  /**
+   * Get string value (no JSON parsing)
+   */
+  getString(key: string, defaultValue: string): Promise<StorageResult<string>>;
+
+  /**
+   * Set string value (no JSON serialization)
+   */
+  setString(key: string, value: string): Promise<StorageResult<string>>;
+
+  /**
+   * Remove item from storage
+   */
+  removeItem(key: string): Promise<StorageResult<void>>;
+
+  /**
+   * Check if key exists in storage
+   */
+  hasItem(key: string): Promise<boolean>;
+
+  /**
+   * Clear all storage data
+   */
+  clearAll(): Promise<StorageResult<void>>;
+
+  /**
+   * Get multiple items at once
+   */
+  getMultiple(keys: string[]): Promise<StorageResult<Record<string, string | null>>>;
+
+  /**
+   * Get all keys from storage
+   */
+  getAllKeys(): Promise<StorageResult<string[]>>;
+
+
+}