@umituz/react-native-storage 1.5.0 → 2.3.2

package/src/__tests__/performance.test.ts

@@ -0,0 +1,351 @@
+/**
+ * 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/__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/application/ports/IStorageRepository.ts

@@ -3,8 +3,6 @@
  *
  * Domain-Driven Design: Application port for storage operations
  * Infrastructure layer implements this interface
- *
- * Theme: {{THEME_NAME}} ({{CATEGORY}} category)
  */
 
 import type { StorageResult } from '../../domain/entities/StorageResult';
@@ -59,15 +57,5 @@ export interface IStorageRepository {
    */
   getAllKeys(): Promise<StorageResult<string[]>>;
 
-  /**
-   * Get object from storage (alias for getItem for backward compatibility)
-   * @deprecated Use getItem instead
-   */
-  getObject<T>(key: string, defaultValue: T): Promise<StorageResult<T>>;
 
-  /**
-   * Set object in storage (alias for setItem for backward compatibility)
-   * @deprecated Use setItem instead
-   */
-  setObject<T>(key: string, value: T): Promise<StorageResult<T>>;
 }

package/src/domain/constants/CacheDefaults.ts

@@ -0,0 +1,64 @@
+/**
+ * Cache Default Constants
+ * Domain layer - Default values for caching
+ *
+ * General-purpose constants for any app
+ */
+
+/**
+ * Time constants in milliseconds
+ */
+export const TIME_MS = {
+  SECOND: 1000,
+  MINUTE: 60 * 1000,
+  HOUR: 60 * 60 * 1000,
+  DAY: 24 * 60 * 60 * 1000,
+  WEEK: 7 * 24 * 60 * 60 * 1000,
+} as const;
+
+/**
+ * Default TTL values for different cache types
+ */
+export const DEFAULT_TTL = {
+  /**
+   * Very short cache (1 minute)
+   * Use for: Real-time data, live updates
+   */
+  VERY_SHORT: TIME_MS.MINUTE,
+
+  /**
+   * Short cache (5 minutes)
+   * Use for: Frequently changing data
+   */
+  SHORT: 5 * TIME_MS.MINUTE,
+
+  /**
+   * Medium cache (30 minutes)
+   * Use for: Moderately changing data, user-specific content
+   */
+  MEDIUM: 30 * TIME_MS.MINUTE,
+
+  /**
+   * Long cache (2 hours)
+   * Use for: Slowly changing data, public content
+   */
+  LONG: 2 * TIME_MS.HOUR,
+
+  /**
+   * Very long cache (24 hours)
+   * Use for: Rarely changing data, master data
+   */
+  VERY_LONG: TIME_MS.DAY,
+
+  /**
+   * Permanent cache (7 days)
+   * Use for: Static content, app configuration
+   */
+  PERMANENT: TIME_MS.WEEK,
+} as const;
+
+/**
+ * Cache version for global invalidation
+ * Increment this to invalidate all caches across the app
+ */
+export const CACHE_VERSION = 1;

package/src/domain/entities/CachedValue.ts

@@ -0,0 +1,86 @@
+/**
+ * Cached Value Entity
+ * Domain layer - Represents a cached value with TTL metadata
+ *
+ * General-purpose cache entity for any app that needs persistent caching
+ */
+
+/**
+ * Cached value with time-to-live metadata
+ * Generic type T can be any serializable data
+ */
+export interface CachedValue<T> {
+  /**
+   * The actual cached data
+   */
+  value: T;
+
+  /**
+   * Timestamp when the value was cached (milliseconds)
+   */
+  cachedAt: number;
+
+  /**
+   * Timestamp when the cache expires (milliseconds)
+   */
+  expiresAt: number;
+
+  /**
+   * Optional version for cache invalidation
+   * Increment version to invalidate all caches
+   */
+  version?: number;
+}
+
+/**
+ * Create a new cached value with TTL
+ * @param value - Data to cache
+ * @param ttlMs - Time-to-live in milliseconds
+ * @param version - Optional version number
+ */
+export function createCachedValue<T>(
+  value: T,
+  ttlMs: number,
+  version?: number,
+): CachedValue<T> {
+  const now = Date.now();
+  return {
+    value,
+    cachedAt: now,
+    expiresAt: now + ttlMs,
+    version,
+  };
+}
+
+/**
+ * Check if cached value is expired
+ * @param cached - Cached value to check
+ * @param currentVersion - Optional current version to check against
+ */
+export function isCacheExpired<T>(
+  cached: CachedValue<T>,
+  currentVersion?: number,
+): boolean {
+  const now = Date.now();
+  const timeExpired = now > cached.expiresAt;
+  const versionMismatch = currentVersion !== undefined && cached.version !== currentVersion;
+  return timeExpired || versionMismatch;
+}
+
+/**
+ * Get remaining TTL in milliseconds
+ * Returns 0 if expired
+ */
+export function getRemainingTTL<T>(cached: CachedValue<T>): number {
+  const now = Date.now();
+  const remaining = cached.expiresAt - now;
+  return Math.max(0, remaining);
+}
+
+/**
+ * Get cache age in milliseconds
+ */
+export function getCacheAge<T>(cached: CachedValue<T>): number {
+  const now = Date.now();
+  return now - cached.cachedAt;
+}

package/src/domain/entities/StorageResult.ts

@@ -3,8 +3,6 @@
  *
  * Domain-Driven Design: Entity representing storage operation result
  * Functional programming pattern for error handling (Result type)
- *
- * Theme: {{THEME_NAME}} ({{CATEGORY}} category)
  */
 
 import type { StorageError } from '../errors/StorageError';
@@ -68,5 +66,5 @@ export const map = <T, U>(
   if (isSuccess(result)) {
     return success(fn(result.data));
   }
-  return failure(result.error, result.fallback !== undefined ? fn(result.fallback) : undefined);
+  return failure(result.error);
 };