@umituz/react-native-design-system 2.8.7 → 2.8.8

package/src/storage/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/storage/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/storage/domain/errors/README.md

@@ -0,0 +1,126 @@
+# Storage Errors
+
+Error classes and error handling strategies for storage operations.
+
+## Overview
+
+Hierarchical error classes for storage operations with context preservation. Located at `src/domain/errors/`.
+
+## Strategies
+
+### Error Hierarchy
+- Use StorageError as base class for all storage errors
+- Create specific error types for different operations
+- Preserve error context (key, operation, cause)
+- Enable error type checking with instanceof
+
+### Error Categories
+- StorageReadError for read failures
+- StorageWriteError for write failures
+- StorageDeleteError for delete failures
+- StorageSerializationError for serialization failures
+- StorageDeserializationError for parsing failures
+
+### Error Handling Strategy
+- Use Result pattern instead of throwing exceptions
+- Preserve original error as cause property
+- Include error codes for programmatic handling
+- Log errors with full context
+
+### Error Recovery
+- Implement retry logic for transient failures
+- Provide fallback values for graceful degradation
+- Clear corrupted data when appropriate
+- Alert monitoring systems for critical errors
+
+## Restrictions
+
+### Error Creation
+- DO NOT throw generic Error class
+- DO NOT lose error context when wrapping
+- DO NOT create error types without clear purpose
+- DO NOT use strings for error codes
+
+### Error Handling
+- DO NOT catch and ignore errors silently
+- DO NOT suppress error logging in production
+- DO NOT retry indefinitely on persistent failures
+- DO NOT expose sensitive data in error messages
+
+### Error Types
+- DO NOT mix different error categories
+- DO NOT create circular error hierarchies
+- DO NOT omit error code from custom errors
+- DO NOT cause infinite error loops
+
+## Rules
+
+### Error Base Class
+- MUST extend Error class
+- MUST include code property (string)
+- MUST preserve stack trace
+- MUST accept cause parameter for wrapping
+- MUST include message parameter
+
+### Specific Error Types
+- MUST extend StorageError base class
+- MUST include key property for storage errors
+- MUST include cause property when wrapping
+- MUST use specific error codes
+- MUST set appropriate error name
+
+### Error Codes
+- MUST use format: CATEGORY_ERROR (e.g., STORAGE_READ_ERROR)
+- MUST be unique across error types
+- MUST be descriptive and searchable
+- MUST follow naming convention
+- MUST be documented
+
+### Error Context
+- MUST include storage key in storage errors
+- MUST include original operation type
+- MUST attach cause error when wrapping
+- MUST preserve stack trace
+- MUST include timestamp for debugging
+
+### Error Handling Patterns
+- MUST use try-catch for all storage operations
+- MUST check error types with instanceof
+- MUST log errors with full context
+- MUST provide error recovery where possible
+- MUST not expose sensitive data
+
+### Custom Error Creation
+- MUST extend StorageError for custom errors
+- MUST provide unique error code
+- MUST include all required context
+- MUST document error purpose
+- MUST follow naming conventions
+
+### Error Logging
+- MUST log error code and message
+- MUST log error context (key, operation)
+- MUST log cause error if present
+- MUST log stack trace in development
+- MUST not log sensitive data
+
+### Error Testing
+- MUST test error creation
+- MUST test error type checking
+- MUST test error context preservation
+- MUST test error logging
+- MUST test error recovery logic
+
+### Type Safety
+- MUST use instanceof for type checking
+- MUST use type guards where appropriate
+- MUST enforce error codes as literal types
+- MUST provide TypeScript types
+- MUST not use `any` for error types
+
+### Error Recovery
+- MUST implement retry limits
+- MUST provide fallback strategies
+- MUST clear corrupted data when detected
+- MUST alert on critical failures
+- MUST document recovery behavior

package/src/storage/domain/errors/StorageError.ts

@@ -0,0 +1,81 @@
+/**
+ * Storage Error Types
+ *
+ * Domain-Driven Design: Domain errors for storage operations
+ * Typed errors for better error handling and debugging
+ */
+
+/**
+ * Base Storage Error
+ */
+export class StorageError extends Error {
+  constructor(message: string, public readonly key?: string) {
+    super(message);
+    this.name = 'StorageError';
+  }
+}
+
+/**
+ * Storage Read Error
+ */
+export class StorageReadError extends StorageError {
+  public readonly cause?: unknown;
+
+  constructor(key: string, cause?: unknown) {
+    super(`Failed to read from storage: ${key}`, key);
+    this.name = 'StorageReadError';
+    this.cause = cause;
+  }
+}
+
+/**
+ * Storage Write Error
+ */
+export class StorageWriteError extends StorageError {
+  public readonly cause?: unknown;
+
+  constructor(key: string, cause?: unknown) {
+    super(`Failed to write to storage: ${key}`, key);
+    this.name = 'StorageWriteError';
+    this.cause = cause;
+  }
+}
+
+/**
+ * Storage Delete Error
+ */
+export class StorageDeleteError extends StorageError {
+  public readonly cause?: unknown;
+
+  constructor(key: string, cause?: unknown) {
+    super(`Failed to delete from storage: ${key}`, key);
+    this.name = 'StorageDeleteError';
+    this.cause = cause;
+  }
+}
+
+/**
+ * Storage Serialization Error
+ */
+export class StorageSerializationError extends StorageError {
+  public readonly cause?: unknown;
+
+  constructor(key: string, cause?: unknown) {
+    super(`Failed to serialize data for key: ${key}`, key);
+    this.name = 'StorageSerializationError';
+    this.cause = cause;
+  }
+}
+
+/**
+ * Storage Deserialization Error
+ */
+export class StorageDeserializationError extends StorageError {
+  public readonly cause?: unknown;
+
+  constructor(key: string, cause?: unknown) {
+    super(`Failed to deserialize data for key: ${key}`, key);
+    this.name = 'StorageDeserializationError';
+    this.cause = cause;
+  }
+}

package/src/storage/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');
+    });
+  });
+});