@umituz/react-native-design-system 2.3.1 → 2.3.3

package/src/device/infrastructure/services/PersistentDeviceIdService.ts

@@ -0,0 +1,132 @@
+/**
+ * Persistent Device ID Service
+ *
+ * Provides a stable, persistent device identifier that survives app restarts.
+ * Uses native device ID when available, falls back to generated UUID.
+ * Stores the ID in AsyncStorage for persistence.
+ *
+ * @domain device
+ * @layer infrastructure/services
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { DeviceIdService } from './DeviceIdService';
+
+const STORAGE_KEY = '@device/persistent_id';
+
+/** Cached ID to avoid repeated AsyncStorage reads */
+let cachedDeviceId: string | null = null;
+
+/** Promise to prevent race conditions during initialization */
+let initializationPromise: Promise<string> | null = null;
+
+/**
+ * Generate a UUID v4 without external dependencies
+ */
+function generateUUID(): string {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+
+/**
+ * Service for managing persistent device identifiers
+ */
+export class PersistentDeviceIdService {
+  /**
+   * Get or create a persistent device ID
+   *
+   * This method:
+   * 1. Returns cached ID if available (fastest)
+   * 2. Checks AsyncStorage for previously stored ID
+   * 3. If not found, gets native device ID or generates UUID
+   * 4. Stores and caches the result for future calls
+   *
+   * Thread-safe: Multiple concurrent calls return the same promise
+   */
+  static async getDeviceId(): Promise<string> {
+    if (cachedDeviceId) {
+      return cachedDeviceId;
+    }
+
+    if (initializationPromise) {
+      return initializationPromise;
+    }
+
+    initializationPromise = this.initializeDeviceId();
+    return initializationPromise;
+  }
+
+  /**
+   * Initialize and persist device ID
+   */
+  private static async initializeDeviceId(): Promise<string> {
+    try {
+      const storedId = await AsyncStorage.getItem(STORAGE_KEY);
+
+      if (storedId) {
+        cachedDeviceId = storedId;
+        return storedId;
+      }
+
+      const newId = await this.createNewDeviceId();
+      await AsyncStorage.setItem(STORAGE_KEY, newId);
+      cachedDeviceId = newId;
+
+      return newId;
+    } catch {
+      const fallbackId = generateUUID();
+      cachedDeviceId = fallbackId;
+      return fallbackId;
+    }
+  }
+
+  /**
+   * Create a new device ID from native source or generate one
+   */
+  private static async createNewDeviceId(): Promise<string> {
+    const nativeId = await DeviceIdService.getDeviceId();
+
+    if (nativeId) {
+      return `device_${nativeId}`;
+    }
+
+    return `generated_${generateUUID()}`;
+  }
+
+  /**
+   * Check if device ID exists in storage
+   */
+  static async hasStoredId(): Promise<boolean> {
+    try {
+      const storedId = await AsyncStorage.getItem(STORAGE_KEY);
+      return storedId !== null;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Clear stored device ID (use with caution)
+   * This will generate a new ID on next getDeviceId() call
+   */
+  static async clearStoredId(): Promise<void> {
+    try {
+      await AsyncStorage.removeItem(STORAGE_KEY);
+      cachedDeviceId = null;
+      initializationPromise = null;
+    } catch {
+      // Silent fail - non-critical operation
+    }
+  }
+
+  /**
+   * Get the cached device ID without async operation
+   * Returns null if not yet initialized
+   */
+  static getCachedId(): string | null {
+    return cachedDeviceId;
+  }
+}

package/src/device/infrastructure/services/UserFriendlyIdService.ts

@@ -0,0 +1,68 @@
+/**
+ * User Friendly ID Service
+ *
+ * Single Responsibility: Generate user-friendly device identifiers
+ * Follows SOLID principles - only handles ID generation logic
+ */
+
+import { Platform } from 'react-native';
+import type { DeviceInfo } from '../../domain/entities/Device';
+import { DeviceInfoService } from './DeviceInfoService';
+import { DeviceIdService } from './DeviceIdService';
+import {
+  cleanModelName,
+  extractIdPart,
+  generateRandomId,
+  getPlatformPrefix,
+} from '../utils/stringUtils';
+
+/**
+ * Service for generating user-friendly device IDs
+ */
+export class UserFriendlyIdService {
+  /**
+   * Get user friendly device ID (e.g. "iPhone13-A8F2")
+   *
+   * Useful for displaying a readable user identifier in profiles.
+   * Combines cleaned model name with short device hash.
+   *
+   * SAFE: This method has multiple fallback layers to prevent native module crashes.
+   * If native modules are not ready, it will return a safe fallback ID.
+   */
+  static async getUserFriendlyId(): Promise<string> {
+    // Web platform - no native modules needed
+    if (Platform.OS === 'web') {
+      return `WebUser-${generateRandomId()}`;
+    }
+
+    try {
+      // Try to get device info and ID
+      const deviceInfo: DeviceInfo = await DeviceInfoService.getDeviceInfo();
+      const deviceId: string | null = await DeviceIdService.getDeviceId();
+
+      // If we got device info, use it
+      if (deviceInfo && (deviceInfo.modelName || deviceInfo.deviceName)) {
+        const model = deviceInfo.modelName || deviceInfo.deviceName || 'Device';
+        const cleanModel = cleanModelName(model);
+        const idPart = extractIdPart(deviceId, 6);
+
+        return `${cleanModel}-${idPart}`;
+      }
+
+      // Fallback: Use platform + random ID
+      return this.generateFallbackId();
+    } catch {
+      // Final fallback: Generate safe random ID
+      return this.generateFallbackId();
+    }
+  }
+
+  /**
+   * Generate fallback ID when native modules are not available
+   */
+  private static generateFallbackId(): string {
+    const platformPrefix = getPlatformPrefix(Platform.OS);
+    return `${platformPrefix}-${generateRandomId()}`;
+  }
+}
+

package/src/device/infrastructure/utils/__tests__/nativeModuleUtils.test.ts

@@ -0,0 +1,158 @@
+/**
+ * Native Module Utils Tests
+ */
+
+import { withTimeout, safeAccess, withTimeoutAll } from '../nativeModuleUtils';
+
+describe('Native Module Utils', () => {
+  describe('withTimeout', () => {
+    beforeEach(() => {
+      jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    it('should resolve with operation result when successful', async () => {
+      const operation = jest.fn().mockResolvedValue('success');
+      const promise = withTimeout(operation, 1000);
+
+      jest.advanceTimersByTime(0);
+      await expect(promise).resolves.toBe('success');
+      expect(operation).toHaveBeenCalledTimes(1);
+    });
+
+    it('should return null when operation times out', async () => {
+      const operation = jest.fn().mockImplementation(() => new Promise(() => {}));
+      const promise = withTimeout(operation, 1000);
+
+      jest.advanceTimersByTime(1000);
+      await expect(promise).resolves.toBeNull();
+    });
+
+    it('should return null when operation throws', async () => {
+      const operation = jest.fn().mockRejectedValue(new Error('Test error'));
+      const promise = withTimeout(operation, 1000);
+
+      jest.advanceTimersByTime(0);
+      await expect(promise).resolves.toBeNull();
+    });
+
+    it('should use default timeout when not specified', async () => {
+      const operation = jest.fn().mockImplementation(() => new Promise(() => {}));
+      const promise = withTimeout(operation);
+
+      jest.advanceTimersByTime(1000);
+      await expect(promise).resolves.toBeNull();
+    });
+  });
+
+  describe('safeAccess', () => {
+    it('should return value when accessor succeeds', () => {
+      const accessor = () => 'test value';
+      const result = safeAccess(accessor, 'fallback');
+      expect(result).toBe('test value');
+    });
+
+    it('should return fallback when accessor throws', () => {
+      const accessor = () => {
+        throw new Error('Test error');
+      };
+      const result = safeAccess(accessor, 'fallback');
+      expect(result).toBe('fallback');
+    });
+
+    it('should return fallback when accessor returns null/undefined', () => {
+      const accessor1 = () => null;
+      const accessor2 = () => undefined;
+      
+      expect(safeAccess(accessor1, 'fallback')).toBe('fallback');
+      expect(safeAccess(accessor2, 'fallback')).toBe('fallback');
+    });
+
+    it('should return value when accessor returns falsy but not null/undefined', () => {
+      const accessor1 = () => '';
+      const accessor2 = () => 0;
+      const accessor3 = () => false;
+      
+      expect(safeAccess(accessor1, 'fallback')).toBe('');
+      expect(safeAccess(accessor2, 'fallback')).toBe(0);
+      expect(safeAccess(accessor3, 'fallback')).toBe(false);
+    });
+  });
+
+  describe('withTimeoutAll', () => {
+    beforeEach(() => {
+      jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    it('should resolve all operations when successful', async () => {
+      const operations = [
+        jest.fn().mockResolvedValue('result1'),
+        jest.fn().mockResolvedValue('result2'),
+        jest.fn().mockResolvedValue('result3'),
+      ];
+      const promise = withTimeoutAll(operations, 1000);
+
+      jest.advanceTimersByTime(0);
+      const results = await promise;
+      
+      expect(results).toEqual(['result1', 'result2', 'result3']);
+      operations.forEach(op => expect(op).toHaveBeenCalledTimes(1));
+    });
+
+    it('should handle individual operation failures', async () => {
+      const operations = [
+        jest.fn().mockResolvedValue('result1'),
+        jest.fn().mockRejectedValue(new Error('Test error')),
+        jest.fn().mockResolvedValue('result3'),
+      ];
+      const promise = withTimeoutAll(operations, 1000);
+
+      jest.advanceTimersByTime(0);
+      const results = await promise;
+      
+      expect(results).toEqual(['result1', null, 'result3']);
+    });
+
+    it('should return null for all operations when timeout occurs', async () => {
+      const operations = [
+        jest.fn().mockImplementation(() => new Promise(() => {})),
+        jest.fn().mockResolvedValue('result2'),
+      ];
+      const promise = withTimeoutAll(operations, 1000);
+
+      jest.advanceTimersByTime(1000);
+      const results = await promise;
+      
+      expect(results).toEqual([null, null]);
+    });
+
+    it('should use default timeout when not specified', async () => {
+      const operations = [
+        jest.fn().mockImplementation(() => new Promise(() => {})),
+      ];
+      const promise = withTimeoutAll(operations);
+
+      jest.advanceTimersByTime(2000);
+      const results = await promise;
+      
+      expect(results).toEqual([null]);
+    });
+
+    it('should handle empty operations array', async () => {
+      const operations: Array<() => Promise<string>> = [];
+      const promise = withTimeoutAll(operations, 1000);
+
+      jest.advanceTimersByTime(0);
+      const results = await promise;
+      
+      expect(results).toEqual([]);
+    });
+  });
+});

package/src/device/infrastructure/utils/__tests__/stringUtils.test.ts

@@ -0,0 +1,120 @@
+/**
+ * String Utils Tests
+ */
+
+import { cleanModelName, extractIdPart, generateRandomId, getPlatformPrefix } from '../stringUtils';
+
+describe('String Utils', () => {
+  describe('cleanModelName', () => {
+    it('should remove special characters from model name', () => {
+      const result = cleanModelName('iPhone 14 Pro Max');
+      expect(result).toBe('iPhone14ProMax');
+    });
+
+    it('should handle null/undefined input', () => {
+      expect(cleanModelName(null)).toBe('Device');
+      expect(cleanModelName(undefined)).toBe('Device');
+    });
+
+    it('should handle empty string', () => {
+      const result = cleanModelName('');
+      expect(result).toBe('Device');
+    });
+
+    it('should handle model with only special characters', () => {
+      const result = cleanModelName('!@#$%^&*()');
+      expect(result).toBe('Device');
+    });
+
+    it('should preserve alphanumeric characters', () => {
+      const result = cleanModelName('SM-G998B');
+      expect(result).toBe('SMG998B');
+    });
+  });
+
+  describe('extractIdPart', () => {
+    it('should extract last N characters from device ID', () => {
+      const deviceId = '12345678-1234-1234-1234-123456789012';
+      const result = extractIdPart(deviceId, 6);
+      expect(result).toBe('789012');
+    });
+
+    it('should use default length of 6 when not specified', () => {
+      const deviceId = '12345678-1234-1234-1234-123456789012';
+      const result = extractIdPart(deviceId);
+      expect(result).toBe('789012');
+    });
+
+    it('should handle null device ID by generating random ID', () => {
+      const result = extractIdPart(null, 6);
+      expect(result).toMatch(/^[A-Z0-9]{6}$/);
+    });
+
+    it('should handle empty device ID by generating random ID', () => {
+      const result = extractIdPart('', 6);
+      expect(result).toMatch(/^[A-Z0-9]{6}$/);
+    });
+
+    it('should handle device ID shorter than requested length', () => {
+      const deviceId = 'ABC';
+      const result = extractIdPart(deviceId, 6);
+      expect(result).toBe('ABC');
+    });
+
+    it('should convert to uppercase', () => {
+      const deviceId = 'abcdef';
+      const result = extractIdPart(deviceId, 3);
+      expect(result).toBe('DEF');
+    });
+  });
+
+  describe('generateRandomId', () => {
+    it('should generate random ID with default length', () => {
+      const result = generateRandomId();
+      expect(result).toMatch(/^[A-Z0-9]{6}$/);
+    });
+
+    it('should generate random ID with specified length', () => {
+      const result = generateRandomId(10);
+      expect(result).toMatch(/^[A-Z0-9]{10}$/);
+    });
+
+    it('should generate different IDs on multiple calls', () => {
+      const id1 = generateRandomId(6);
+      const id2 = generateRandomId(6);
+      expect(id1).not.toBe(id2);
+    });
+
+    it('should handle length of 1', () => {
+      const result = generateRandomId(1);
+      expect(result).toMatch(/^[A-Z0-9]{1}$/);
+    });
+  });
+
+  describe('getPlatformPrefix', () => {
+    it('should return iOS for ios platform', () => {
+      const result = getPlatformPrefix('ios');
+      expect(result).toBe('iOS');
+    });
+
+    it('should return Android for android platform', () => {
+      const result = getPlatformPrefix('android');
+      expect(result).toBe('Android');
+    });
+
+    it('should return Device for unknown platform', () => {
+      const result = getPlatformPrefix('windows');
+      expect(result).toBe('Device');
+    });
+
+    it('should return Device for empty string', () => {
+      const result = getPlatformPrefix('');
+      expect(result).toBe('Device');
+    });
+
+    it('should be case sensitive', () => {
+      expect(getPlatformPrefix('IOS')).toBe('Device');
+      expect(getPlatformPrefix('ANDROID')).toBe('Device');
+    });
+  });
+});

package/src/device/infrastructure/utils/nativeModuleUtils.ts

@@ -0,0 +1,69 @@
+/**
+ * Native Module Utilities
+ *
+ * Safe wrappers for native module access with timeout and error handling
+ * Prevents crashes when native modules are not ready
+ */
+
+/**
+ * Execute a native module call with timeout
+ * @param operation - Async operation to execute
+ * @param timeoutMs - Timeout in milliseconds (default: 1000)
+ * @returns Result of operation or null if timeout/error
+ */
+export async function withTimeout<T>(
+  operation: () => Promise<T>,
+  timeoutMs: number = 1000,
+): Promise<T | null> {
+  try {
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      setTimeout(() => reject(new Error('Operation timeout')), timeoutMs);
+    });
+
+    return await Promise.race([operation(), timeoutPromise]);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Safely access a native module property
+ * @param accessor - Function that accesses the property
+ * @param fallback - Fallback value if access fails
+ * @returns Property value or fallback
+ */
+export function safeAccess<T>(accessor: () => T, fallback: T): T {
+  try {
+    const value = accessor();
+    return value ?? fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+/**
+ * Execute multiple native module operations with timeout
+ * @param operations - Array of async operations
+ * @param timeoutMs - Timeout in milliseconds (default: 2000)
+ * @returns Array of results (null for failed operations)
+ */
+export async function withTimeoutAll<T>(
+  operations: Array<() => Promise<T>>,
+  timeoutMs: number = 2000,
+): Promise<Array<T | null>> {
+  try {
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      setTimeout(() => reject(new Error('Operations timeout')), timeoutMs);
+    });
+
+    const results = await Promise.race([
+      Promise.all(operations.map((op) => op().catch(() => null))),
+      timeoutPromise,
+    ]).catch(() => operations.map(() => null));
+
+    return results as Array<T | null>;
+  } catch {
+    return operations.map(() => null);
+  }
+}
+

package/src/device/infrastructure/utils/stringUtils.ts

@@ -0,0 +1,59 @@
+/**
+ * String Utilities
+ *
+ * Pure utility functions for string manipulation
+ * No dependencies, no side effects
+ */
+
+/**
+ * Clean model name by removing special characters
+ * @param model - Device model name
+ * @returns Cleaned model name with only alphanumeric characters
+ */
+export function cleanModelName(model: string | null | undefined): string {
+  if (!model) {
+    return 'Device';
+  }
+  const cleaned = model.replace(/[^a-zA-Z0-9]/g, '');
+  return cleaned || 'Device';
+}
+
+/**
+ * Extract ID part from device ID
+ * @param deviceId - Full device ID
+ * @param length - Length of ID part to extract (default: 6)
+ * @returns Last N characters of device ID in uppercase
+ */
+export function extractIdPart(deviceId: string | null, length: number = 6): string {
+  if (!deviceId) {
+    return generateRandomId(length);
+  }
+  const start = Math.max(0, deviceId.length - length);
+  return deviceId.substring(start).toUpperCase();
+}
+
+/**
+ * Generate random alphanumeric ID
+ * @param length - Length of ID to generate (default: 6)
+ * @returns Random ID in uppercase
+ */
+export function generateRandomId(length: number = 6): string {
+  return Math.random().toString(36).substring(2, 2 + length).toUpperCase();
+}
+
+/**
+ * Get platform prefix for device ID
+ * @param platform - Platform OS
+ * @returns Platform prefix string
+ */
+export function getPlatformPrefix(platform: string): string {
+  switch (platform) {
+    case 'ios':
+      return 'iOS';
+    case 'android':
+      return 'Android';
+    default:
+      return 'Device';
+  }
+}
+