@umituz/react-native-storage 1.5.0 → 2.3.2

package/src/domain/entities/__tests__/CachedValue.test.ts

@@ -0,0 +1,149 @@
+/**
+ * CachedValue Entity Tests
+ *
+ * Unit tests for CachedValue entity
+ */
+
+import { 
+  createCachedValue, 
+  isCacheExpired, 
+  getRemainingTTL, 
+  getCacheAge 
+} from '../../domain/entities/CachedValue';
+
+describe('CachedValue Entity', () => {
+  const mockNow = 1000000;
+
+  beforeEach(() => {
+    jest.spyOn(Date, 'now').mockReturnValue(mockNow);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('createCachedValue', () => {
+    it('should create cached value with default values', () => {
+      const data = { test: 'value' };
+      const cached = createCachedValue(data);
+
+      expect(cached.value).toBe(data);
+      expect(cached.timestamp).toBe(mockNow);
+      expect(cached.ttl).toBeDefined();
+      expect(cached.version).toBeUndefined();
+    });
+
+    it('should create cached value with custom TTL', () => {
+      const data = { test: 'value' };
+      const ttl = 60000; // 1 minute
+      const cached = createCachedValue(data, ttl);
+
+      expect(cached.value).toBe(data);
+      expect(cached.timestamp).toBe(mockNow);
+      expect(cached.ttl).toBe(ttl);
+    });
+
+    it('should create cached value with version', () => {
+      const data = { test: 'value' };
+      const version = 2;
+      const cached = createCachedValue(data, undefined, version);
+
+      expect(cached.value).toBe(data);
+      expect(cached.timestamp).toBe(mockNow);
+      expect(cached.version).toBe(version);
+    });
+  });
+
+  describe('isCacheExpired', () => {
+    it('should return false for fresh cache', () => {
+      const data = { test: 'value' };
+      const ttl = 60000; // 1 minute
+      const cached = createCachedValue(data, ttl);
+
+      expect(isCacheExpired(cached)).toBe(false);
+    });
+
+    it('should return true for expired cache', () => {
+      const data = { test: 'value' };
+      const ttl = 1000; // 1 second
+      const cached = createCachedValue(data, ttl, mockNow - 2000); // Created 2 seconds ago
+
+      expect(isCacheExpired(cached)).toBe(true);
+    });
+
+    it('should handle version mismatch', () => {
+      const data = { test: 'value' };
+      const cached = createCachedValue(data, 60000, 1);
+      const currentVersion = 2;
+
+      expect(isCacheExpired(cached, currentVersion)).toBe(true);
+    });
+
+    it('should return false when version matches', () => {
+      const data = { test: 'value' };
+      const cached = createCachedValue(data, 60000, 1);
+      const currentVersion = 1;
+
+      expect(isCacheExpired(cached, currentVersion)).toBe(false);
+    });
+  });
+
+  describe('getRemainingTTL', () => {
+    it('should return remaining TTL for fresh cache', () => {
+      const data = { test: 'value' };
+      const ttl = 60000; // 1 minute
+      const cached = createCachedValue(data, ttl, mockNow - 30000); // Created 30 seconds ago
+
+      const remaining = getRemainingTTL(cached);
+      expect(remaining).toBe(30000); // 30 seconds remaining
+    });
+
+    it('should return 0 for expired cache', () => {
+      const data = { test: 'value' };
+      const ttl = 1000; // 1 second
+      const cached = createCachedValue(data, ttl, mockNow - 2000); // Created 2 seconds ago
+
+      const remaining = getRemainingTTL(cached);
+      expect(remaining).toBe(0);
+    });
+
+    it('should handle missing TTL', () => {
+      const data = { test: 'value' };
+      const cached = createCachedValue(data);
+
+      const remaining = getRemainingTTL(cached);
+      expect(remaining).toBeGreaterThan(0);
+    });
+  });
+
+  describe('getCacheAge', () => {
+    it('should return correct age', () => {
+      const data = { test: 'value' };
+      const age = 30000; // 30 seconds
+      const cached = createCachedValue(data, undefined, undefined, mockNow - age);
+
+      const cacheAge = getCacheAge(cached);
+      expect(cacheAge).toBe(age);
+    });
+
+    it('should return 0 for new cache', () => {
+      const data = { test: 'value' };
+      const cached = createCachedValue(data);
+
+      const cacheAge = getCacheAge(cached);
+      expect(cacheAge).toBe(0);
+    });
+  });
+
+  describe('Immutability', () => {
+    it('should create immutable cached value', () => {
+      const data = { test: 'value' };
+      const cached = createCachedValue(data);
+
+      // Attempt to modify
+      (cached as any).value = { modified: true };
+
+      expect(cached.value).toEqual(data);
+    });
+  });
+});

package/src/domain/entities/__tests__/StorageResult.test.ts

@@ -0,0 +1,122 @@
+/**
+ * StorageResult Entity Tests
+ *
+ * Unit tests for StorageResult entity
+ */
+
+import { success, failure, unwrap, map, isSuccess, isFailure } from '../../domain/entities/StorageResult';
+import { StorageError } from '../../domain/errors/StorageError';
+
+describe('StorageResult Entity', () => {
+  describe('success', () => {
+    it('should create a successful result', () => {
+      const data = { test: 'value' };
+      const result = success(data);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBe(data);
+      expect(result.error).toBeUndefined();
+    });
+  });
+
+  describe('failure', () => {
+    it('should create a failure result', () => {
+      const error = new StorageError('test-key', new Error('Test error'));
+      const defaultValue = 'default';
+      const result = failure(error, defaultValue);
+
+      expect(result.success).toBe(false);
+      expect(result.data).toBe(defaultValue);
+      expect(result.error).toBe(error);
+    });
+  });
+
+  describe('unwrap', () => {
+    it('should return data for successful result', () => {
+      const data = { test: 'value' };
+      const result = success(data);
+      const defaultValue = 'default';
+
+      const unwrapped = unwrap(result, defaultValue);
+
+      expect(unwrapped).toBe(data);
+    });
+
+    it('should return default value for failure result', () => {
+      const error = new StorageError('test-key', new Error('Test error'));
+      const defaultValue = 'default';
+      const result = failure(error, defaultValue);
+
+      const unwrapped = unwrap(result, defaultValue);
+
+      expect(unwrapped).toBe(defaultValue);
+    });
+  });
+
+  describe('map', () => {
+    it('should map successful result', () => {
+      const data = { count: 1 };
+      const result = success(data);
+      const mapper = (value: typeof data) => ({ ...value, count: value.count + 1 });
+
+      const mapped = map(result, mapper);
+
+      expect(mapped.success).toBe(true);
+      expect(mapped.data).toEqual({ count: 2 });
+    });
+
+    it('should not map failure result', () => {
+      const error = new StorageError('test-key', new Error('Test error'));
+      const defaultValue = { count: 0 };
+      const result = failure(error, defaultValue);
+      const mapper = jest.fn();
+
+      const mapped = map(result, mapper);
+
+      expect(mapped.success).toBe(false);
+      expect(mapper).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('isSuccess', () => {
+    it('should return true for successful result', () => {
+      const result = success('test');
+      expect(isSuccess(result)).toBe(true);
+    });
+
+    it('should return false for failure result', () => {
+      const error = new StorageError('test-key', new Error('Test error'));
+      const result = failure(error);
+      expect(isSuccess(result)).toBe(false);
+    });
+  });
+
+  describe('isFailure', () => {
+    it('should return false for successful result', () => {
+      const result = success('test');
+      expect(isFailure(result)).toBe(false);
+    });
+
+    it('should return true for failure result', () => {
+      const error = new StorageError('test-key', new Error('Test error'));
+      const result = failure(error);
+      expect(isFailure(result)).toBe(true);
+    });
+  });
+
+  describe('Type Safety', () => {
+    it('should maintain type information', () => {
+      interface TestData {
+        id: number;
+        name: string;
+      }
+
+      const data: TestData = { id: 1, name: 'test' };
+      const result = success<TestData>(data);
+
+      // TypeScript should infer the type correctly
+      const typedData: TestData = result.data;
+      expect(typedData).toEqual(data);
+    });
+  });
+});

package/src/domain/errors/StorageError.ts

@@ -3,8 +3,6 @@
  *
  * Domain-Driven Design: Domain errors for storage operations
  * Typed errors for better error handling and debugging
- *
- * Theme: {{THEME_NAME}} ({{CATEGORY}} category)
  */
 
 /**

package/src/domain/errors/__tests__/StorageError.test.ts

@@ -0,0 +1,127 @@
+/**
+ * StorageError Tests
+ *
+ * Unit tests for StorageError classes
+ */
+
+import {
+  StorageError,
+  StorageReadError,
+  StorageWriteError,
+  StorageDeleteError,
+  StorageSerializationError,
+  StorageDeserializationError,
+} from '../../domain/errors/StorageError';
+
+describe('StorageError Classes', () => {
+  describe('StorageError', () => {
+    it('should create base storage error', () => {
+      const key = 'test-key';
+      const cause = new Error('Original error');
+      const error = new StorageError(key, cause);
+
+      expect(error.key).toBe(key);
+      expect(error.cause).toBe(cause);
+      expect(error.name).toBe('StorageError');
+      expect(error.message).toContain(key);
+    });
+
+    it('should serialize error details', () => {
+      const key = 'test-key';
+      const cause = new Error('Original error');
+      const error = new StorageError(key, cause);
+
+      const serialized = JSON.stringify(error);
+      const parsed = JSON.parse(serialized);
+
+      expect(parsed.key).toBe(key);
+      expect(parsed.message).toContain(key);
+    });
+  });
+
+  describe('StorageReadError', () => {
+    it('should create read error', () => {
+      const key = 'test-key';
+      const cause = new Error('Read failed');
+      const error = new StorageReadError(key, cause);
+
+      expect(error.key).toBe(key);
+      expect(error.cause).toBe(cause);
+      expect(error.name).toBe('StorageReadError');
+      expect(error.message).toContain('read');
+    });
+  });
+
+  describe('StorageWriteError', () => {
+    it('should create write error', () => {
+      const key = 'test-key';
+      const cause = new Error('Write failed');
+      const error = new StorageWriteError(key, cause);
+
+      expect(error.key).toBe(key);
+      expect(error.cause).toBe(cause);
+      expect(error.name).toBe('StorageWriteError');
+      expect(error.message).toContain('write');
+    });
+  });
+
+  describe('StorageDeleteError', () => {
+    it('should create delete error', () => {
+      const key = 'test-key';
+      const cause = new Error('Delete failed');
+      const error = new StorageDeleteError(key, cause);
+
+      expect(error.key).toBe(key);
+      expect(error.cause).toBe(cause);
+      expect(error.name).toBe('StorageDeleteError');
+      expect(error.message).toContain('delete');
+    });
+  });
+
+  describe('StorageSerializationError', () => {
+    it('should create serialization error', () => {
+      const key = 'test-key';
+      const cause = new Error('Serialization failed');
+      const error = new StorageSerializationError(key, cause);
+
+      expect(error.key).toBe(key);
+      expect(error.cause).toBe(cause);
+      expect(error.name).toBe('StorageSerializationError');
+      expect(error.message).toContain('serialize');
+    });
+  });
+
+  describe('StorageDeserializationError', () => {
+    it('should create deserialization error', () => {
+      const key = 'test-key';
+      const cause = new Error('Deserialization failed');
+      const error = new StorageDeserializationError(key, cause);
+
+      expect(error.key).toBe(key);
+      expect(error.cause).toBe(cause);
+      expect(error.name).toBe('StorageDeserializationError');
+      expect(error.message).toContain('deserialize');
+    });
+  });
+
+  describe('Error Inheritance', () => {
+    it('should maintain error chain', () => {
+      const key = 'test-key';
+      const cause = new Error('Original error');
+      const error = new StorageReadError(key, cause);
+
+      expect(error instanceof Error).toBe(true);
+      expect(error instanceof StorageError).toBe(true);
+      expect(error instanceof StorageReadError).toBe(true);
+    });
+
+    it('should preserve stack trace', () => {
+      const key = 'test-key';
+      const cause = new Error('Original error');
+      const error = new StorageReadError(key, cause);
+
+      expect(error.stack).toBeDefined();
+      expect(error.stack).toContain('StorageReadError');
+    });
+  });
+});

package/src/domain/factories/StoreFactory.ts

@@ -0,0 +1,33 @@
+/**
+ * Store Factory
+ * Create Zustand stores with AsyncStorage persistence
+ */
+
+import { create } from 'zustand';
+import { persist, createJSONStorage } from 'zustand/middleware';
+import type { StoreConfig } from '../types/Store';
+import { storageService } from '../../infrastructure/adapters/StorageService';
+
+export function createStore<T extends object>(config: StoreConfig<T>) {
+  if (!config.persist) {
+    return create<T>(() => config.initialState);
+  }
+
+  return create<T>()(
+    persist(
+      () => config.initialState,
+      {
+        name: config.name,
+        storage: createJSONStorage(() => storageService),
+        version: config.version || 1,
+        partialize: config.partialize,
+        onRehydrateStorage: () => (state) => {
+          if (state && config.onRehydrate) {
+            config.onRehydrate(state);
+          }
+        },
+        migrate: config.migrate as any,
+      }
+    )
+  );
+}

package/src/domain/types/Store.ts

@@ -0,0 +1,18 @@
+/**
+ * Store Types
+ */
+
+export interface StoreConfig<T> {
+  name: string;
+  initialState: T;
+  persist?: boolean;
+  version?: number;
+  partialize?: (state: T) => Partial<T>;
+  onRehydrate?: (state: T) => void;
+  migrate?: (persistedState: unknown, version: number) => T;
+}
+
+export interface PersistedState<T> {
+  state: T;
+  version: number;
+}

package/src/domain/utils/CacheKeyGenerator.ts

@@ -0,0 +1,66 @@
+/**
+ * Cache Key Generator
+ * Domain layer - Utility for generating consistent cache keys
+ *
+ * General-purpose key generation for any app
+ */
+
+/**
+ * Generate a cache key from prefix and identifier
+ * @param prefix - Cache key prefix (e.g., 'posts', 'products', 'user')
+ * @param id - Unique identifier
+ * @returns Formatted cache key
+ *
+ * @example
+ * generateCacheKey('posts', '123') // 'cache:posts:123'
+ * generateCacheKey('user', 'profile') // 'cache:user:profile'
+ */
+export function generateCacheKey(prefix: string, id: string | number): string {
+  return `cache:${prefix}:${id}`;
+}
+
+/**
+ * Generate a cache key for a list/collection
+ * @param prefix - Cache key prefix
+ * @param params - Optional query parameters
+ *
+ * @example
+ * generateListCacheKey('posts') // 'cache:posts:list'
+ * generateListCacheKey('posts', { page: 1 }) // 'cache:posts:list:page=1'
+ */
+export function generateListCacheKey(
+  prefix: string,
+  params?: Record<string, string | number>,
+): string {
+  const base = `cache:${prefix}:list`;
+  if (!params) return base;
+
+  const paramString = Object.entries(params)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([key, value]) => `${key}=${value}`)
+    .join(':');
+
+  return `${base}:${paramString}`;
+}
+
+/**
+ * Parse a cache key to extract prefix and id
+ * @param key - Cache key to parse
+ * @returns Object with prefix and id, or null if invalid
+ */
+export function parseCacheKey(key: string): { prefix: string; id: string } | null {
+  const parts = key.split(':');
+  if (parts.length < 3 || parts[0] !== 'cache') return null;
+
+  return {
+    prefix: parts[1],
+    id: parts.slice(2).join(':'),
+  };
+}
+
+/**
+ * Check if a key is a cache key
+ */
+export function isCacheKey(key: string): boolean {
+  return key.startsWith('cache:');
+}

package/src/domain/utils/__tests__/devUtils.test.ts

@@ -0,0 +1,97 @@
+/**
+ * Development Utilities Tests
+ */
+
+import { isDev, devWarn, devError, devLog } from '../devUtils';
+
+// Mock console methods
+const mockConsoleWarn = jest.fn();
+const mockConsoleError = jest.fn();
+const mockConsoleLog = jest.fn();
+
+describe('Development Utilities', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    // Mock console methods
+    console.warn = mockConsoleWarn;
+    console.error = mockConsoleError;
+    console.log = mockConsoleLog;
+  });
+
+  describe('isDev', () => {
+    it('should return true when __DEV__ is true', () => {
+      (globalThis as any).__DEV__ = true;
+      expect(isDev()).toBe(true);
+    });
+
+    it('should return false when __DEV__ is false', () => {
+      (globalThis as any).__DEV__ = false;
+      expect(isDev()).toBe(false);
+    });
+
+    it('should return false when __DEV__ is undefined', () => {
+      delete (globalThis as any).__DEV__;
+      expect(isDev()).toBe(false);
+    });
+  });
+
+  describe('devWarn', () => {
+    it('should log warning when in development mode', () => {
+      (globalThis as any).__DEV__ = true;
+      
+      devWarn('Test warning', { data: 'test' });
+      
+      expect(mockConsoleWarn).toHaveBeenCalledWith('Test warning', { data: 'test' });
+    });
+
+    it('should not log warning when not in development mode', () => {
+      (globalThis as any).__DEV__ = false;
+      
+      devWarn('Test warning', { data: 'test' });
+      
+      expect(mockConsoleWarn).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('devError', () => {
+    it('should log error when in development mode', () => {
+      (globalThis as any).__DEV__ = true;
+      
+      devError('Test error', new Error('test'));
+      
+      expect(mockConsoleError).toHaveBeenCalledWith('Test error', new Error('test'));
+    });
+
+    it('should not log error when not in development mode', () => {
+      (globalThis as any).__DEV__ = false;
+      
+      devError('Test error', new Error('test'));
+      
+      expect(mockConsoleError).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('devLog', () => {
+    it('should log info when in development mode', () => {
+      (globalThis as any).__DEV__ = true;
+      
+      devLog('Test log', { info: 'test' });
+      
+      expect(mockConsoleLog).toHaveBeenCalledWith('Test log', { info: 'test' });
+    });
+
+    it('should not log info when not in development mode', () => {
+      (globalThis as any).__DEV__ = false;
+      
+      devLog('Test log', { info: 'test' });
+      
+      expect(mockConsoleLog).not.toHaveBeenCalled();
+    });
+  });
+
+  afterEach(() => {
+    // Clean up __DEV__ after each test
+    delete (globalThis as any).__DEV__;
+  });
+});

package/src/domain/utils/devUtils.ts

@@ -0,0 +1,37 @@
+/**
+ * Development utilities
+ */
+
+/**
+ * Check if running in development mode
+ */
+export const isDev = (): boolean => {
+  return (globalThis as any).__DEV__ === true;
+};
+
+/**
+ * Log warning in development mode only
+ */
+export const devWarn = (message: string, ...args: any[]): void => {
+  if (isDev()) {
+    console.warn(message, ...args);
+  }
+};
+
+/**
+ * Log error in development mode only
+ */
+export const devError = (message: string, ...args: any[]): void => {
+  if (isDev()) {
+    console.error(message, ...args);
+  }
+};
+
+/**
+ * Log info in development mode only
+ */
+export const devLog = (message: string, ...args: any[]): void => {
+  if (isDev()) {
+    console.log(message, ...args);
+  }
+};