@umituz/react-native-storage 2.0.0 → 2.3.2

package/src/presentation/hooks/__tests__/useStorage.test.ts

@@ -0,0 +1,246 @@
+/**
+ * useStorage Hook Tests
+ *
+ * Unit tests for useStorage hook
+ */
+
+import { renderHook, act } from '@testing-library/react-hooks';
+import { useStorage } from '../useStorage';
+import { AsyncStorage } from '../../__tests__/mocks/asyncStorage.mock';
+
+describe('useStorage Hook', () => {
+  beforeEach(() => {
+    (AsyncStorage as any).__clear();
+    jest.clearAllMocks();
+  });
+
+  describe('getItem', () => {
+    it('should get item from storage', async () => {
+      const key = 'test-key';
+      const defaultValue = 'default';
+      const expectedValue = 'test-value';
+
+      await AsyncStorage.setItem(key, JSON.stringify(expectedValue));
+
+      const { result } = renderHook(() => useStorage());
+
+      const value = await result.current.getItem(key, defaultValue);
+
+      expect(value).toBe(expectedValue);
+    });
+
+    it('should return default value for missing key', async () => {
+      const key = 'missing-key';
+      const defaultValue = 'default';
+
+      const { result } = renderHook(() => useStorage());
+
+      const value = await result.current.getItem(key, defaultValue);
+
+      expect(value).toBe(defaultValue);
+    });
+
+    it('should handle StorageKey enum', async () => {
+      const key = '@ui_preferences';
+      const defaultValue = 'default';
+      const expectedValue = 'test-value';
+
+      await AsyncStorage.setItem(key, JSON.stringify(expectedValue));
+
+      const { result } = renderHook(() => useStorage());
+
+      const value = await result.current.getItem(key as any, defaultValue);
+
+      expect(value).toBe(expectedValue);
+    });
+  });
+
+  describe('setItem', () => {
+    it('should set item to storage', async () => {
+      const key = 'test-key';
+      const value = 'test-value';
+
+      const { result } = renderHook(() => useStorage());
+
+      const success = await result.current.setItem(key, value);
+
+      expect(success).toBe(true);
+
+      // Verify storage
+      const stored = await AsyncStorage.getItem(key);
+      expect(JSON.parse(stored!)).toBe(value);
+    });
+
+    it('should return false on failure', async () => {
+      const key = 'test-key';
+      const value = { circular: {} };
+      value.circular = value; // Create circular reference
+
+      const { result } = renderHook(() => useStorage());
+
+      const success = await result.current.setItem(key, value);
+
+      expect(success).toBe(false);
+    });
+  });
+
+  describe('getString', () => {
+    it('should get string from storage', async () => {
+      const key = 'test-key';
+      const defaultValue = 'default';
+      const expectedValue = 'test-string';
+
+      await AsyncStorage.setItem(key, expectedValue);
+
+      const { result } = renderHook(() => useStorage());
+
+      const value = await result.current.getString(key, defaultValue);
+
+      expect(value).toBe(expectedValue);
+    });
+  });
+
+  describe('setString', () => {
+    it('should set string to storage', async () => {
+      const key = 'test-key';
+      const value = 'test-string';
+
+      const { result } = renderHook(() => useStorage());
+
+      const success = await result.current.setString(key, value);
+
+      expect(success).toBe(true);
+
+      // Verify storage
+      const stored = await AsyncStorage.getItem(key);
+      expect(stored).toBe(value);
+    });
+  });
+
+  describe('removeItem', () => {
+    it('should remove item from storage', async () => {
+      const key = 'test-key';
+
+      // Setup
+      await AsyncStorage.setItem(key, 'test-value');
+
+      const { result } = renderHook(() => useStorage());
+
+      const success = await result.current.removeItem(key);
+
+      expect(success).toBe(true);
+
+      // Verify removal
+      const stored = await AsyncStorage.getItem(key);
+      expect(stored).toBeNull();
+    });
+  });
+
+  describe('hasItem', () => {
+    it('should return true for existing item', async () => {
+      const key = 'test-key';
+
+      await AsyncStorage.setItem(key, 'test-value');
+
+      const { result } = renderHook(() => useStorage());
+
+      const exists = await result.current.hasItem(key);
+
+      expect(exists).toBe(true);
+    });
+
+    it('should return false for missing item', async () => {
+      const key = 'missing-key';
+
+      const { result } = renderHook(() => useStorage());
+
+      const exists = await result.current.hasItem(key);
+
+      expect(exists).toBe(false);
+    });
+  });
+
+  describe('clearAll', () => {
+    it('should clear all storage', async () => {
+      // Setup
+      await AsyncStorage.setItem('key1', 'value1');
+      await AsyncStorage.setItem('key2', 'value2');
+
+      const { result } = renderHook(() => useStorage());
+
+      const success = await result.current.clearAll();
+
+      expect(success).toBe(true);
+
+      // Verify clear
+      const keys = await AsyncStorage.getAllKeys();
+      expect(keys).toHaveLength(0);
+    });
+  });
+
+  describe('getItemWithResult', () => {
+    it('should return full result object', async () => {
+      const key = 'test-key';
+      const defaultValue = 'default';
+      const expectedValue = 'test-value';
+
+      await AsyncStorage.setItem(key, JSON.stringify(expectedValue));
+
+      const { result } = renderHook(() => useStorage());
+
+      const storageResult = await result.current.getItemWithResult(key, defaultValue);
+
+      expect(storageResult.success).toBe(true);
+      expect(storageResult.data).toBe(expectedValue);
+      expect(storageResult.error).toBeUndefined();
+    });
+  });
+
+  describe('Performance', () => {
+    it('should memoize return object', () => {
+      const { result, rerender } = renderHook(() => useStorage());
+
+      const firstCall = result.current;
+      rerender();
+      const secondCall = result.current;
+
+      // Should be the same reference (memoized)
+      expect(firstCall).toBe(secondCall);
+    });
+
+    it('should not recreate functions on re-render', () => {
+      const { result, rerender } = renderHook(() => useStorage());
+
+      const firstFunctions = {
+        getItem: result.current.getItem,
+        setItem: result.current.setItem,
+        getString: result.current.getString,
+        setString: result.current.setString,
+        removeItem: result.current.removeItem,
+        hasItem: result.current.hasItem,
+        clearAll: result.current.clearAll,
+        getItemWithResult: result.current.getItemWithResult,
+      };
+
+      rerender();
+
+      const secondFunctions = {
+        getItem: result.current.getItem,
+        setItem: result.current.setItem,
+        getString: result.current.getString,
+        setString: result.current.setString,
+        removeItem: result.current.removeItem,
+        hasItem: result.current.hasItem,
+        clearAll: result.current.clearAll,
+        getItemWithResult: result.current.getItemWithResult,
+      };
+
+      // All functions should be the same reference
+      Object.keys(firstFunctions).forEach(key => {
+        expect(firstFunctions[key as keyof typeof firstFunctions]).toBe(
+          secondFunctions[key as keyof typeof secondFunctions]
+        );
+      });
+    });
+  });
+});

package/src/presentation/hooks/__tests__/useStorageState.test.ts

@@ -0,0 +1,292 @@
+/**
+ * useStorageState Hook Tests
+ *
+ * Unit tests for useStorageState hook
+ */
+
+import { renderHook, act } from '@testing-library/react-hooks';
+import { useStorageState } from '../useStorageState';
+import { AsyncStorage } from '../../__tests__/mocks/asyncStorage.mock';
+
+describe('useStorageState Hook', () => {
+  beforeEach(() => {
+    (AsyncStorage as any).__clear();
+    jest.clearAllMocks();
+  });
+
+  describe('Initial Load', () => {
+    it('should load initial value from storage', async () => {
+      const key = 'test-key';
+      const defaultValue = 'default';
+      const storedValue = 'stored-value';
+
+      await AsyncStorage.setItem(key, JSON.stringify(storedValue));
+
+      const { result, waitForNextUpdate } = renderHook(() => 
+        useStorageState(key, defaultValue)
+      );
+
+      // Initial state
+      expect(result.current[0]).toBe(defaultValue);
+      expect(result.current[2]).toBe(true); // isLoading
+
+      // Wait for load
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      expect(result.current[0]).toBe(storedValue);
+      expect(result.current[2]).toBe(false); // isLoading
+    });
+
+    it('should use default value for missing key', async () => {
+      const key = 'missing-key';
+      const defaultValue = 'default';
+
+      const { result, waitForNextUpdate } = renderHook(() => 
+        useStorageState(key, defaultValue)
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      expect(result.current[0]).toBe(defaultValue);
+      expect(result.current[2]).toBe(false);
+    });
+
+    it('should handle StorageKey enum', async () => {
+      const key = '@ui_preferences';
+      const defaultValue = 'default';
+      const storedValue = 'stored-value';
+
+      await AsyncStorage.setItem(key, JSON.stringify(storedValue));
+
+      const { result, waitForNextUpdate } = renderHook(() => 
+        useStorageState(key as any, defaultValue)
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      expect(result.current[0]).toBe(storedValue);
+    });
+  });
+
+  describe('Update State', () => {
+    it('should update state and persist to storage', async () => {
+      const key = 'test-key';
+      const defaultValue = 'default';
+      const newValue = 'new-value';
+
+      const { result, waitForNextUpdate } = renderHook(() => 
+        useStorageState(key, defaultValue)
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      // Update state
+      await act(async () => {
+        await result.current[1](newValue);
+      });
+
+      expect(result.current[0]).toBe(newValue);
+
+      // Verify storage
+      const stored = await AsyncStorage.getItem(key);
+      expect(JSON.parse(stored!)).toBe(newValue);
+    });
+
+    it('should handle update during loading', async () => {
+      const key = 'test-key';
+      const defaultValue = 'default';
+      const newValue = 'new-value';
+
+      // Mock slow storage
+      let resolveStorage: (value: string) => void;
+      (AsyncStorage.getItem as jest.Mock).mockImplementation(() => 
+        new Promise(resolve => {
+          resolveStorage = resolve;
+        })
+      );
+
+      const { result } = renderHook(() => 
+        useStorageState(key, defaultValue)
+      );
+
+      // Update while loading
+      await act(async () => {
+        await result.current[1](newValue);
+      });
+
+      expect(result.current[0]).toBe(newValue);
+    });
+  });
+
+  describe('Memory Leak Prevention', () => {
+    it('should cleanup on unmount', async () => {
+      const key = 'test-key';
+      const defaultValue = 'default';
+
+      // Mock slow storage
+      let resolveStorage: (value: string) => void;
+      (AsyncStorage.getItem as jest.Mock).mockImplementation(() => 
+        new Promise(resolve => {
+          resolveStorage = resolve;
+        })
+      );
+
+      const { result, unmount } = renderHook(() => 
+        useStorageState(key, defaultValue)
+      );
+
+      // Unmount before load completes
+      unmount();
+
+      // Resolve storage after unmount
+      await act(async () => {
+        resolveStorage!('stored-value');
+      });
+
+      // State should not be updated after unmount
+      expect(result.current[0]).toBe(defaultValue);
+    });
+
+    it('should handle unmount during update', async () => {
+      const key = 'test-key';
+      const defaultValue = 'default';
+      const newValue = 'new-value';
+
+      // Mock slow storage
+      let resolveStorage: () => void;
+      (AsyncStorage.setItem as jest.Mock).mockImplementation(() => 
+        new Promise(resolve => {
+          resolveStorage = resolve;
+        })
+      );
+
+      const { result, unmount } = renderHook(() => 
+        useStorageState(key, defaultValue)
+      );
+
+      // Start update
+      const updatePromise = act(async () => {
+        await result.current[1](newValue);
+      });
+
+      // Unmount before update completes
+      unmount();
+
+      // Complete update
+      await act(async () => {
+        resolveStorage!();
+      });
+
+      await updatePromise;
+    });
+  });
+
+  describe('Performance', () => {
+    it('should not re-run effect when defaultValue changes', async () => {
+      const key = 'test-key';
+      const defaultValue1 = 'default1';
+      const defaultValue2 = 'default2';
+
+      await AsyncStorage.setItem(key, JSON.stringify('stored-value'));
+
+      const { result, rerender, waitForNextUpdate } = renderHook(
+        ({ defaultValue }) => useStorageState(key, defaultValue),
+        { initialProps: { defaultValue: defaultValue1 } }
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      const getItemCalls = (AsyncStorage.getItem as jest.Mock).mock.calls.length;
+
+      // Rerender with different default value
+      rerender({ defaultValue: defaultValue2 });
+
+      // Should not trigger another storage read
+      expect((AsyncStorage.getItem as jest.Mock).mock.calls.length).toBe(getItemCalls);
+    });
+
+    it('should re-run effect when key changes', async () => {
+      const key1 = 'key1';
+      const key2 = 'key2';
+      const defaultValue = 'default';
+
+      await AsyncStorage.setItem(key1, JSON.stringify('value1'));
+      await AsyncStorage.setItem(key2, JSON.stringify('value2'));
+
+      const { result, rerender, waitForNextUpdate } = renderHook(
+        ({ key }) => useStorageState(key, defaultValue),
+        { initialProps: { key: key1 } }
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      expect(result.current[0]).toBe('value1');
+
+      // Change key
+      rerender({ key: key2 });
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      expect(result.current[0]).toBe('value2');
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle storage read error', async () => {
+      const key = 'test-key';
+      const defaultValue = 'default';
+
+      // Mock storage error
+      (AsyncStorage.getItem as jest.Mock).mockRejectedValue(new Error('Storage error'));
+
+      const { result, waitForNextUpdate } = renderHook(() => 
+        useStorageState(key, defaultValue)
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      expect(result.current[0]).toBe(defaultValue);
+      expect(result.current[2]).toBe(false); // isLoading should be false
+    });
+
+    it('should handle storage write error', async () => {
+      const key = 'test-key';
+      const defaultValue = 'default';
+      const newValue = 'new-value';
+
+      // Mock storage error
+      (AsyncStorage.setItem as jest.Mock).mockRejectedValue(new Error('Storage error'));
+
+      const { result, waitForNextUpdate } = renderHook(() => 
+        useStorageState(key, defaultValue)
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      // State should still update even if storage fails
+      await act(async () => {
+        await result.current[1](newValue);
+      });
+
+      expect(result.current[0]).toBe(newValue);
+    });
+  });
+});

package/src/presentation/hooks/useCacheState.ts

@@ -0,0 +1,55 @@
+/**
+ * Cache State Manager
+ *
+ * Manages cache state following Single Responsibility Principle
+ */
+
+import { useState, useCallback, useMemo } from 'react';
+import type { CachedValue } from '../../domain/entities/CachedValue';
+import { createCachedValue, isCacheExpired } from '../../domain/entities/CachedValue';
+
+export interface CacheState<T> {
+  data: T | null;
+  isLoading: boolean;
+  isExpired: boolean;
+}
+
+export interface CacheActions<T> {
+  setData: (value: T) => void;
+  clearData: () => void;
+  setLoading: (loading: boolean) => void;
+  setExpired: (expired: boolean) => void;
+}
+
+/**
+ * Hook for managing cache state
+ */
+export function useCacheState<T>(): [CacheState<T>, CacheActions<T>] {
+  const [data, setDataState] = useState<T | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [isExpired, setIsExpired] = useState(false);
+
+  const setData = useCallback((value: T) => {
+    setDataState(value);
+    setIsExpired(false);
+  }, []);
+
+  const clearData = useCallback(() => {
+    setDataState(null);
+    setIsExpired(true);
+  }, []);
+
+  const setLoading = useCallback((loading: boolean) => {
+    setIsLoading(loading);
+  }, []);
+
+  const setExpired = useCallback((expired: boolean) => {
+    setIsExpired(expired);
+  }, []);
+
+  // Memoize state and actions objects for performance
+  const state: CacheState<T> = useMemo(() => ({ data, isLoading, isExpired }), [data, isLoading, isExpired]);
+  const actions: CacheActions<T> = useMemo(() => ({ setData, clearData, setLoading, setExpired }), [setData, clearData, setLoading, setExpired]);
+
+  return [state, actions];
+}

package/src/presentation/hooks/usePersistentCache.ts

@@ -5,10 +5,10 @@
  * General-purpose cache hook for any app
  */
 
-import { useState, useEffect, useCallback } from 'react';
-import { storageRepository } from '../../infrastructure/repositories/AsyncStorageRepository';
-import type { CachedValue } from '../../domain/entities/CachedValue';
-import { createCachedValue, isCacheExpired } from '../../domain/entities/CachedValue';
+import { useEffect, useCallback, useMemo } from 'react';
+import { useCacheState } from './useCacheState';
+import { CacheStorageOperations } from './CacheStorageOperations';
+import { isCacheExpired } from '../../domain/entities/CachedValue';
 import { DEFAULT_TTL } from '../../domain/constants/CacheDefaults';
 
 /**
@@ -91,71 +91,62 @@ export function usePersistentCache<T>(
   options: PersistentCacheOptions = {},
 ): PersistentCacheResult<T> {
   const { ttl = DEFAULT_TTL.MEDIUM, version, enabled = true } = options;
-
-  const [data, setDataState] = useState<T | null>(null);
-  const [isLoading, setIsLoading] = useState(true);
-  const [isExpired, setIsExpired] = useState(false);
+  const [state, actions] = useCacheState<T>();
+  
+  // Use singleton pattern to prevent memory leaks
+  const cacheOps = useMemo(() => CacheStorageOperations.getInstance(), []);
 
   const loadFromStorage = useCallback(async () => {
     if (!enabled) {
-      setIsLoading(false);
+      actions.setLoading(false);
       return;
     }
 
+    actions.setLoading(true);
+
     try {
-      const result = await storageRepository.getString(key, '');
+      const cached = await cacheOps.loadFromStorage<T>(key, version);
 
-      if (result.success && result.data) {
-        const cached = JSON.parse(result.data) as CachedValue<T>;
+      if (cached) {
         const expired = isCacheExpired(cached, version);
-
-        setDataState(cached.value);
-        setIsExpired(expired);
+        actions.setData(cached.value);
+        actions.setExpired(expired);
       } else {
-        setDataState(null);
-        setIsExpired(true);
+        actions.clearData();
       }
     } catch {
-      setDataState(null);
-      setIsExpired(true);
+      actions.clearData();
     } finally {
-      setIsLoading(false);
+      actions.setLoading(false);
     }
-  }, [key, version, enabled]);
+  }, [key, version, enabled, actions, cacheOps]);
 
   const setData = useCallback(
     async (value: T) => {
-      if (!enabled) return;
-
-      const cached = createCachedValue(value, ttl, version);
-      await storageRepository.setString(key, JSON.stringify(cached));
-      setDataState(value);
-      setIsExpired(false);
+      await cacheOps.saveToStorage(key, value, { ttl, version, enabled });
+      actions.setData(value);
     },
-    [key, ttl, version, enabled],
+    [key, ttl, version, enabled, actions, cacheOps],
   );
 
   const clearData = useCallback(async () => {
-    if (!enabled) return;
-
-    await storageRepository.removeItem(key);
-    setDataState(null);
-    setIsExpired(true);
-  }, [key, enabled]);
+    await cacheOps.clearFromStorage(key, enabled);
+    actions.clearData();
+  }, [key, enabled, actions, cacheOps]);
 
   const refresh = useCallback(async () => {
-    setIsLoading(true);
     await loadFromStorage();
   }, [loadFromStorage]);
 
+  // Prevent infinite loops by only running when key or enabled changes
   useEffect(() => {
     loadFromStorage();
-  }, [loadFromStorage]);
+  }, [key, enabled]);
 
   return {
-    data,
-    isLoading,
-    isExpired,
+    data: state.data,
+    isLoading: state.isLoading,
+    isExpired: state.isExpired,
     setData,
     clearData,
     refresh,