@umituz/react-native-storage 1.5.0 → 2.3.2

package/src/infrastructure/repositories/__tests__/AsyncStorageRepository.test.ts

@@ -0,0 +1,169 @@
+/**
+ * AsyncStorageRepository Tests
+ *
+ * Unit tests for AsyncStorageRepository
+ */
+
+import { AsyncStorageRepository } from '../AsyncStorageRepository';
+import { AsyncStorage } from '../../__tests__/mocks/asyncStorage.mock';
+
+describe('AsyncStorageRepository', () => {
+  let repository: AsyncStorageRepository;
+
+  beforeEach(() => {
+    repository = new AsyncStorageRepository();
+    (AsyncStorage as any).__clear();
+  });
+
+  describe('Composition', () => {
+    it('should use composition pattern', () => {
+      expect(repository).toBeInstanceOf(AsyncStorageRepository);
+      
+      // Test that all methods are available
+      expect(typeof repository.getItem).toBe('function');
+      expect(typeof repository.setItem).toBe('function');
+      expect(typeof repository.getString).toBe('function');
+      expect(typeof repository.setString).toBe('function');
+      expect(typeof repository.removeItem).toBe('function');
+      expect(typeof repository.hasItem).toBe('function');
+      expect(typeof repository.clearAll).toBe('function');
+      expect(typeof repository.getMultiple).toBe('function');
+      expect(typeof repository.getAllKeys).toBe('function');
+    });
+  });
+
+  describe('Delegation', () => {
+    it('should delegate getItem to BaseStorageOperations', async () => {
+      const key = 'test-key';
+      const defaultValue = 'default';
+      const expectedValue = 'test-value';
+
+      await AsyncStorage.setItem(key, JSON.stringify(expectedValue));
+
+      const result = await repository.getItem(key, defaultValue);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBe(expectedValue);
+    });
+
+    it('should delegate setItem to BaseStorageOperations', async () => {
+      const key = 'test-key';
+      const value = 'test-value';
+
+      const result = await repository.setItem(key, value);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBe(value);
+    });
+
+    it('should delegate getString to StringStorageOperations', async () => {
+      const key = 'test-key';
+      const defaultValue = 'default';
+      const expectedValue = 'test-string';
+
+      await AsyncStorage.setItem(key, expectedValue);
+
+      const result = await repository.getString(key, defaultValue);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBe(expectedValue);
+    });
+
+    it('should delegate setString to StringStorageOperations', async () => {
+      const key = 'test-key';
+      const value = 'test-string';
+
+      const result = await repository.setString(key, value);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBe(value);
+    });
+
+    it('should delegate removeItem to BaseStorageOperations', async () => {
+      const key = 'test-key';
+
+      await AsyncStorage.setItem(key, 'test-value');
+
+      const result = await repository.removeItem(key);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should delegate hasItem to BaseStorageOperations', async () => {
+      const key = 'test-key';
+
+      await AsyncStorage.setItem(key, 'test-value');
+
+      const exists = await repository.hasItem(key);
+
+      expect(exists).toBe(true);
+    });
+
+    it('should delegate clearAll to BaseStorageOperations', async () => {
+      await AsyncStorage.setItem('key1', 'value1');
+      await AsyncStorage.setItem('key2', 'value2');
+
+      const result = await repository.clearAll();
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should delegate getMultiple to BatchStorageOperations', async () => {
+      const keys = ['key1', 'key2'];
+      
+      await AsyncStorage.setItem('key1', 'value1');
+      await AsyncStorage.setItem('key2', 'value2');
+
+      const result = await repository.getMultiple(keys);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual({
+        key1: 'value1',
+        key2: 'value2'
+      });
+    });
+
+    it('should delegate getAllKeys to BatchStorageOperations', async () => {
+      await AsyncStorage.setItem('key1', 'value1');
+      await AsyncStorage.setItem('key2', 'value2');
+
+      const result = await repository.getAllKeys();
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(expect.arrayContaining(['key1', 'key2']));
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle errors from delegated operations', async () => {
+      const key = 'test-key';
+      
+      // Mock error in AsyncStorage
+      (AsyncStorage.getItem as jest.Mock).mockRejectedValue(new Error('Storage error'));
+
+      const result = await repository.getItem(key, 'default');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+
+  describe('Type Safety', () => {
+    it('should maintain type safety for generic methods', async () => {
+      interface TestData {
+        id: number;
+        name: string;
+      }
+
+      const key = 'typed-key';
+      const data: TestData = { id: 1, name: 'test' };
+
+      const setResult = await repository.setItem<TestData>(key, data);
+      const getResult = await repository.getItem<TestData>(key, { id: 0, name: '' });
+
+      expect(setResult.success).toBe(true);
+      expect(getResult.success).toBe(true);
+      expect(getResult.data).toEqual(data);
+    });
+  });
+});

package/src/infrastructure/repositories/__tests__/BaseStorageOperations.test.ts

@@ -0,0 +1,200 @@
+/**
+ * BaseStorageOperations Tests
+ *
+ * Unit tests for BaseStorageOperations
+ */
+
+import { BaseStorageOperations } from '../BaseStorageOperations';
+import { AsyncStorage } from '../../__tests__/mocks/asyncStorage.mock';
+import { StorageReadError, StorageWriteError, StorageDeleteError } from '../../../domain/errors/StorageError';
+
+describe('BaseStorageOperations', () => {
+  let baseOps: BaseStorageOperations;
+
+  beforeEach(() => {
+    baseOps = new BaseStorageOperations();
+    (AsyncStorage as any).__clear();
+  });
+
+  describe('getItem', () => {
+    it('should get item successfully', async () => {
+      const key = 'test-key';
+      const value = { test: 'value' };
+      const defaultValue = { default: true };
+
+      // Setup
+      await AsyncStorage.setItem(key, JSON.stringify(value));
+
+      // Test
+      const result = await baseOps.getItem(key, defaultValue);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(value);
+    });
+
+    it('should return default value for missing key', async () => {
+      const key = 'missing-key';
+      const defaultValue = { default: true };
+
+      const result = await baseOps.getItem(key, defaultValue);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBe(defaultValue);
+    });
+
+    it('should handle deserialization error', async () => {
+      const key = 'invalid-json-key';
+      const defaultValue = { default: true };
+
+      // Setup invalid JSON
+      await AsyncStorage.setItem(key, 'invalid-json');
+
+      const result = await baseOps.getItem(key, defaultValue);
+
+      expect(result.success).toBe(false);
+      expect(result.data).toBe(defaultValue);
+      expect(result.error).toBeInstanceOf(StorageReadError);
+    });
+
+    it('should handle storage read error', async () => {
+      const key = 'test-key';
+      const defaultValue = { default: true };
+
+      // Mock storage error
+      (AsyncStorage.getItem as jest.Mock).mockRejectedValue(new Error('Storage error'));
+
+      const result = await baseOps.getItem(key, defaultValue);
+
+      expect(result.success).toBe(false);
+      expect(result.data).toBe(defaultValue);
+      expect(result.error).toBeInstanceOf(StorageReadError);
+    });
+  });
+
+  describe('setItem', () => {
+    it('should set item successfully', async () => {
+      const key = 'test-key';
+      const value = { test: 'value' };
+
+      const result = await baseOps.setItem(key, value);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(value);
+
+      // Verify storage
+      const stored = await AsyncStorage.getItem(key);
+      expect(JSON.parse(stored!)).toEqual(value);
+    });
+
+    it('should handle serialization error', async () => {
+      const key = 'test-key';
+      const value = { circular: {} };
+      value.circular = value; // Create circular reference
+
+      const result = await baseOps.setItem(key, value);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeInstanceOf(StorageWriteError);
+    });
+
+    it('should handle storage write error', async () => {
+      const key = 'test-key';
+      const value = { test: 'value' };
+
+      // Mock storage error
+      (AsyncStorage.setItem as jest.Mock).mockRejectedValue(new Error('Storage error'));
+
+      const result = await baseOps.setItem(key, value);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeInstanceOf(StorageWriteError);
+    });
+  });
+
+  describe('removeItem', () => {
+    it('should remove item successfully', async () => {
+      const key = 'test-key';
+
+      // Setup
+      await AsyncStorage.setItem(key, 'test-value');
+
+      const result = await baseOps.removeItem(key);
+
+      expect(result.success).toBe(true);
+
+      // Verify removal
+      const stored = await AsyncStorage.getItem(key);
+      expect(stored).toBeNull();
+    });
+
+    it('should handle storage delete error', async () => {
+      const key = 'test-key';
+
+      // Mock storage error
+      (AsyncStorage.removeItem as jest.Mock).mockRejectedValue(new Error('Storage error'));
+
+      const result = await baseOps.removeItem(key);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeInstanceOf(StorageDeleteError);
+    });
+  });
+
+  describe('hasItem', () => {
+    it('should return true for existing item', async () => {
+      const key = 'test-key';
+
+      // Setup
+      await AsyncStorage.setItem(key, 'test-value');
+
+      const exists = await baseOps.hasItem(key);
+
+      expect(exists).toBe(true);
+    });
+
+    it('should return false for missing item', async () => {
+      const key = 'missing-key';
+
+      const exists = await baseOps.hasItem(key);
+
+      expect(exists).toBe(false);
+    });
+
+    it('should return false on storage error', async () => {
+      const key = 'test-key';
+
+      // Mock storage error
+      (AsyncStorage.getItem as jest.Mock).mockRejectedValue(new Error('Storage error'));
+
+      const exists = await baseOps.hasItem(key);
+
+      expect(exists).toBe(false);
+    });
+  });
+
+  describe('clearAll', () => {
+    it('should clear all storage successfully', async () => {
+      // Setup
+      await AsyncStorage.setItem('key1', 'value1');
+      await AsyncStorage.setItem('key2', 'value2');
+
+      const result = await baseOps.clearAll();
+
+      expect(result.success).toBe(true);
+
+      // Verify clear
+      const keys = await AsyncStorage.getAllKeys();
+      expect(keys).toHaveLength(0);
+    });
+
+    it('should handle storage clear error', async () => {
+      // Mock storage error
+      (AsyncStorage.clear as jest.Mock).mockRejectedValue(new Error('Storage error'));
+
+      const result = await baseOps.clearAll();
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeInstanceOf(StorageDeleteError);
+    });
+  });
+});

package/src/presentation/hooks/CacheStorageOperations.ts

@@ -0,0 +1,95 @@
+/**
+ * Cache Storage Operations
+ *
+ * Handles cache storage operations following Single Responsibility Principle
+ */
+
+import { storageRepository } from '../../infrastructure/repositories/AsyncStorageRepository';
+import type { CachedValue } from '../../domain/entities/CachedValue';
+import { createCachedValue } from '../../domain/entities/CachedValue';
+import { devWarn } from '../../domain/utils/devUtils';
+
+export interface CacheStorageOptions {
+  ttl?: number;
+  version?: number;
+  enabled?: boolean;
+}
+
+/**
+ * Handles cache storage operations with proper error handling and memory management
+ */
+export class CacheStorageOperations {
+  private static instance: CacheStorageOperations | null = null;
+
+  /**
+   * Singleton pattern to prevent memory leaks
+   */
+  static getInstance(): CacheStorageOperations {
+    if (!CacheStorageOperations.instance) {
+      CacheStorageOperations.instance = new CacheStorageOperations();
+    }
+    return CacheStorageOperations.instance;
+  }
+
+  /**
+   * Reset singleton instance (useful for testing)
+   */
+  static resetInstance(): void {
+    CacheStorageOperations.instance = null;
+  }
+
+  /**
+   * Load cached data from storage
+   */
+  async loadFromStorage<T>(
+    key: string,
+    version?: number
+  ): Promise<CachedValue<T> | null> {
+    try {
+      const result = await storageRepository.getString(key, '');
+
+      if (result.success && result.data) {
+        const cached = JSON.parse(result.data) as CachedValue<T>;
+        return cached;
+      }
+
+      return null;
+    } catch (error) {
+      devWarn(`CacheStorageOperations: Failed to load cache for key "${key}"`, error);
+      return null;
+    }
+  }
+
+  /**
+   * Save data to cache storage
+   */
+  async saveToStorage<T>(
+    key: string,
+    value: T,
+    options: CacheStorageOptions = {}
+  ): Promise<void> {
+    const { ttl, version, enabled = true } = options;
+
+    if (!enabled) return;
+
+    try {
+      const cached = createCachedValue(value, ttl || 0, version);
+      await storageRepository.setString(key, JSON.stringify(cached));
+    } catch (error) {
+      devWarn(`CacheStorageOperations: Failed to save cache for key "${key}"`, error);
+    }
+  }
+
+  /**
+   * Clear cached data from storage
+   */
+  async clearFromStorage(key: string, enabled = true): Promise<void> {
+    if (!enabled) return;
+
+    try {
+      await storageRepository.removeItem(key);
+    } catch (error) {
+      devWarn(`CacheStorageOperations: Failed to clear cache for key "${key}"`, error);
+    }
+  }
+}