@umituz/react-native-storage 2.0.0 → 2.3.3

package/src/infrastructure/repositories/AsyncStorageRepository.ts

@@ -2,178 +2,97 @@
  * AsyncStorage Repository
  *
  * Domain-Driven Design: Infrastructure implementation of IStorageRepository
- * Adapts React Native AsyncStorage to domain interface
+ * Adapts React Native AsyncStorage to domain interface using composition
  */
 
-import AsyncStorage from '@react-native-async-storage/async-storage';
 import type { IStorageRepository } from '../../application/ports/IStorageRepository';
 import type { StorageResult } from '../../domain/entities/StorageResult';
-import { success, failure } from '../../domain/entities/StorageResult';
-import {
-  StorageReadError,
-  StorageWriteError,
-  StorageDeleteError,
-  StorageSerializationError,
-  StorageDeserializationError,
-} from '../../domain/errors/StorageError';
+import { BaseStorageOperations } from './BaseStorageOperations';
+import { StringStorageOperations } from './StringStorageOperations';
+import { BatchStorageOperations } from './BatchStorageOperations';
 
 /**
  * AsyncStorage Repository Implementation
+ * Uses composition to follow Single Responsibility Principle
  */
 export class AsyncStorageRepository implements IStorageRepository {
+  private baseOps: BaseStorageOperations;
+  private stringOps: StringStorageOperations;
+  private batchOps: BatchStorageOperations;
+
+  constructor() {
+    this.baseOps = new BaseStorageOperations();
+    this.stringOps = new StringStorageOperations();
+    this.batchOps = new BatchStorageOperations();
+  }
+
   /**
    * Get item from AsyncStorage with type safety
    */
   async getItem<T>(key: string, defaultValue: T): Promise<StorageResult<T>> {
-    try {
-      const value = await AsyncStorage.getItem(key);
-
-      if (value === null) {
-        // Missing keys on first app launch are NORMAL, not errors
-        return success(defaultValue);
-      }
-
-      try {
-        const parsed = JSON.parse(value) as T;
-        return success(parsed);
-      } catch (parseError) {
-        return failure(new StorageDeserializationError(key, parseError), defaultValue);
-      }
-    } catch (error) {
-      return failure(new StorageReadError(key, error), defaultValue);
-    }
+    return this.baseOps.getItem(key, defaultValue);
   }
 
   /**
    * Set item in AsyncStorage with automatic JSON serialization
    */
   async setItem<T>(key: string, value: T): Promise<StorageResult<T>> {
-    try {
-      let serialized: string;
-      try {
-        serialized = JSON.stringify(value);
-      } catch (serializeError) {
-        return failure(new StorageSerializationError(key, serializeError));
-      }
-
-      await AsyncStorage.setItem(key, serialized);
-      return success(value);
-    } catch (error) {
-      return failure(new StorageWriteError(key, error));
-    }
+    return this.baseOps.setItem(key, value);
   }
 
   /**
    * Get string value (no JSON parsing)
    */
   async getString(key: string, defaultValue: string): Promise<StorageResult<string>> {
-    try {
-      const value = await AsyncStorage.getItem(key);
-
-      if (value === null) {
-        // Missing keys on first app launch are NORMAL, not errors
-        return success(defaultValue);
-      }
-
-      return success(value);
-    } catch (error) {
-      return failure(new StorageReadError(key, error), defaultValue);
-    }
+    return this.stringOps.getString(key, defaultValue);
   }
 
   /**
    * Set string value (no JSON serialization)
    */
   async setString(key: string, value: string): Promise<StorageResult<string>> {
-    try {
-      await AsyncStorage.setItem(key, value);
-      return success(value);
-    } catch (error) {
-      return failure(new StorageWriteError(key, error));
-    }
+    return this.stringOps.setString(key, value);
   }
 
   /**
    * Remove item from AsyncStorage
    */
   async removeItem(key: string): Promise<StorageResult<void>> {
-    try {
-      await AsyncStorage.removeItem(key);
-      return success(undefined);
-    } catch (error) {
-      return failure(new StorageDeleteError(key, error));
-    }
+    return this.baseOps.removeItem(key);
   }
 
   /**
    * Check if key exists in storage
    */
   async hasItem(key: string): Promise<boolean> {
-    try {
-      const value = await AsyncStorage.getItem(key);
-      return value !== null;
-    } catch {
-      return false;
-    }
+    return this.baseOps.hasItem(key);
   }
 
   /**
-   * Clear all AsyncStorage data (use with caution!)
+   * Clear all AsyncStorage data
    */
   async clearAll(): Promise<StorageResult<void>> {
-    try {
-      await AsyncStorage.clear();
-      return success(undefined);
-    } catch (error) {
-      return failure(new StorageDeleteError('ALL_KEYS', error));
-    }
+    return this.baseOps.clearAll();
   }
 
   /**
-   * Get multiple items at once (more efficient than multiple getItem calls)
+   * Get multiple items at once
    */
   async getMultiple(
     keys: string[]
   ): Promise<StorageResult<Record<string, string | null>>> {
-    try {
-      const pairs = await AsyncStorage.multiGet(keys);
-      const result = Object.fromEntries(pairs);
-      return success(result);
-    } catch (error) {
-      return failure(new StorageReadError('MULTIPLE_KEYS', error));
-    }
+    return this.batchOps.getMultiple(keys);
   }
 
   /**
    * Get all keys from storage
    */
   async getAllKeys(): Promise<StorageResult<string[]>> {
-    try {
-      const keys = await AsyncStorage.getAllKeys();
-      return success([...keys]);
-    } catch (error) {
-      return failure(new StorageReadError('ALL_KEYS', error));
-    }
-  }
-
-  /**
-   * Get object from storage (alias for getItem for backward compatibility)
-   * @deprecated Use getItem instead
-   */
-  async getObject<T>(key: string, defaultValue: T): Promise<StorageResult<T>> {
-    return this.getItem(key, defaultValue);
-  }
-
-  /**
-   * Set object in storage (alias for setItem for backward compatibility)
-   * @deprecated Use setItem instead
-   */
-  async setObject<T>(key: string, value: T): Promise<StorageResult<T>> {
-    return this.setItem(key, value);
+    return this.batchOps.getAllKeys();
   }
 }
 
 /**
  * Singleton instance
  */
-export const storageRepository = new AsyncStorageRepository();
+export const storageRepository = new AsyncStorageRepository();

package/src/infrastructure/repositories/BaseStorageOperations.ts

@@ -0,0 +1,101 @@
+/**
+ * Base Storage Operations
+ *
+ * Core storage operations following Single Responsibility Principle
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type { IStorageRepository } from '../../application/ports/IStorageRepository';
+import type { StorageResult } from '../../domain/entities/StorageResult';
+import { success, failure } from '../../domain/entities/StorageResult';
+import {
+  StorageReadError,
+  StorageWriteError,
+  StorageDeleteError,
+  StorageSerializationError,
+  StorageDeserializationError,
+} from '../../domain/errors/StorageError';
+import { devWarn } from '../../domain/utils/devUtils';
+
+/**
+ * Base storage operations implementation
+ */
+export class BaseStorageOperations {
+  /**
+   * Get item from AsyncStorage with type safety
+   */
+  async getItem<T>(key: string, defaultValue: T): Promise<StorageResult<T>> {
+    try {
+      const value = await AsyncStorage.getItem(key);
+
+      if (value === null) {
+        return success(defaultValue);
+      }
+
+      try {
+        const parsed = JSON.parse(value) as T;
+        return success(parsed);
+      } catch (parseError) {
+        return failure(new StorageDeserializationError(key, parseError), defaultValue);
+      }
+    } catch (error) {
+      return failure(new StorageReadError(key, error), defaultValue);
+    }
+  }
+
+  /**
+   * Set item in AsyncStorage with automatic JSON serialization
+   */
+  async setItem<T>(key: string, value: T): Promise<StorageResult<T>> {
+    try {
+      let serialized: string;
+      try {
+        serialized = JSON.stringify(value);
+      } catch (serializeError) {
+        return failure(new StorageSerializationError(key, serializeError));
+      }
+
+      await AsyncStorage.setItem(key, serialized);
+      return success(value);
+    } catch (error) {
+      return failure(new StorageWriteError(key, error));
+    }
+  }
+
+  /**
+   * Remove item from AsyncStorage
+   */
+  async removeItem(key: string): Promise<StorageResult<void>> {
+    try {
+      await AsyncStorage.removeItem(key);
+      return success(undefined);
+    } catch (error) {
+      return failure(new StorageDeleteError(key, error));
+    }
+  }
+
+  /**
+   * Check if key exists in storage
+   */
+  async hasItem(key: string): Promise<boolean> {
+    try {
+      const value = await AsyncStorage.getItem(key);
+      return value !== null;
+    } catch (error) {
+      devWarn(`BaseStorageOperations: Failed to check if key "${key}" exists`, error);
+      return false;
+    }
+  }
+
+  /**
+   * Clear all AsyncStorage data
+   */
+  async clearAll(): Promise<StorageResult<void>> {
+    try {
+      await AsyncStorage.clear();
+      return success(undefined);
+    } catch (error) {
+      return failure(new StorageDeleteError('ALL_KEYS', error));
+    }
+  }
+}

package/src/infrastructure/repositories/BatchStorageOperations.ts

@@ -0,0 +1,42 @@
+/**
+ * Batch Storage Operations
+ *
+ * Batch operations following Single Responsibility Principle
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type { StorageResult } from '../../domain/entities/StorageResult';
+import { success, failure } from '../../domain/entities/StorageResult';
+import { StorageReadError } from '../../domain/errors/StorageError';
+
+/**
+ * Batch storage operations for efficiency
+ */
+export class BatchStorageOperations {
+  /**
+   * Get multiple items at once
+   */
+  async getMultiple(
+    keys: string[]
+  ): Promise<StorageResult<Record<string, string | null>>> {
+    try {
+      const pairs = await AsyncStorage.multiGet(keys);
+      const result = Object.fromEntries(pairs);
+      return success(result);
+    } catch (error) {
+      return failure(new StorageReadError('MULTIPLE_KEYS', error));
+    }
+  }
+
+  /**
+   * Get all keys from storage
+   */
+  async getAllKeys(): Promise<StorageResult<string[]>> {
+    try {
+      const keys = await AsyncStorage.getAllKeys();
+      return success([...keys]);
+    } catch (error) {
+      return failure(new StorageReadError('ALL_KEYS', error));
+    }
+  }
+}

package/src/infrastructure/repositories/StringStorageOperations.ts

@@ -0,0 +1,44 @@
+/**
+ * String Storage Operations
+ *
+ * Specialized string operations following Single Responsibility Principle
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type { StorageResult } from '../../domain/entities/StorageResult';
+import { success, failure } from '../../domain/entities/StorageResult';
+import { StorageReadError, StorageWriteError } from '../../domain/errors/StorageError';
+
+/**
+ * String-specific storage operations
+ */
+export class StringStorageOperations {
+  /**
+   * Get string value (no JSON parsing)
+   */
+  async getString(key: string, defaultValue: string): Promise<StorageResult<string>> {
+    try {
+      const value = await AsyncStorage.getItem(key);
+
+      if (value === null) {
+        return success(defaultValue);
+      }
+
+      return success(value);
+    } catch (error) {
+      return failure(new StorageReadError(key, error), defaultValue);
+    }
+  }
+
+  /**
+   * Set string value (no JSON serialization)
+   */
+  async setString(key: string, value: string): Promise<StorageResult<string>> {
+    try {
+      await AsyncStorage.setItem(key, value);
+      return success(value);
+    } catch (error) {
+      return failure(new StorageWriteError(key, error));
+    }
+  }
+}

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);
+    });
+  });
+});