@umituz/react-native-design-system 2.3.0 → 2.3.2

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

@@ -0,0 +1,95 @@
+/**
+ * Device Info Service
+ *
+ * Single Responsibility: Get device information from native modules
+ * Follows SOLID principles - only handles device info retrieval
+ */
+
+import * as Device from 'expo-device';
+import { Platform } from 'react-native';
+import * as Localization from 'expo-localization';
+import type { DeviceInfo } from '../../domain/entities/Device';
+import { safeAccess, withTimeout } from '../utils/nativeModuleUtils';
+
+/**
+ * Service for retrieving device information
+ */
+export class DeviceInfoService {
+  /**
+   * Get device information
+   * SAFE: Returns minimal info if native modules are not ready
+   */
+  static async getDeviceInfo(): Promise<DeviceInfo> {
+    try {
+      const totalMemory = await withTimeout(
+        () => Device.getMaxMemoryAsync(),
+        1000,
+      );
+
+      const brand = safeAccess(() => Device.brand, null);
+      const manufacturer = safeAccess(() => Device.manufacturer, null);
+      const modelName = safeAccess(() => Device.modelName, null);
+      const modelId = safeAccess(() => Device.modelId, null);
+      const deviceName = safeAccess(() => Device.deviceName, null);
+      const deviceYearClass = safeAccess(() => Device.deviceYearClass, null);
+      const deviceType = safeAccess(() => Device.deviceType, null);
+      const isDevice = safeAccess(() => Device.isDevice, false);
+      const osName = safeAccess(() => Device.osName, null);
+      const osVersion = safeAccess(() => Device.osVersion, null);
+      const osBuildId = safeAccess(() => Device.osBuildId, null);
+      const platformApiLevel = safeAccess(() => Device.platformApiLevel, null);
+
+      // Localization
+      const calendars = Localization.getCalendars();
+      const locales = Localization.getLocales();
+      const timezone = calendars?.[0]?.timeZone ?? null;
+      const region = locales?.[0]?.regionCode ?? null;
+
+      return {
+        brand,
+        manufacturer,
+        modelName,
+        modelId,
+        deviceName,
+        deviceYearClass,
+        deviceType,
+        isDevice,
+        osName,
+        osVersion,
+        osBuildId,
+        platformApiLevel,
+        totalMemory,
+        platform: Platform.OS as 'ios' | 'android' | 'web',
+        timezone,
+        region,
+      };
+    } catch {
+      return this.getMinimalDeviceInfo();
+    }
+  }
+
+  /**
+   * Get minimal device info (fallback)
+   */
+  private static getMinimalDeviceInfo(): DeviceInfo {
+    return {
+      brand: null,
+      manufacturer: null,
+      modelName: null,
+      modelId: null,
+      deviceName: null,
+      deviceYearClass: null,
+      deviceType: null,
+      isDevice: false,
+      osName: null,
+      osVersion: null,
+      osBuildId: null,
+      platformApiLevel: null,
+      totalMemory: null,
+      platform: Platform.OS as 'ios' | 'android' | 'web',
+      timezone: null,
+      region: null,
+    };
+  }
+}
+

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

@@ -0,0 +1,104 @@
+/**
+ * Device Service - Facade/Orchestrator
+ *
+ * Main entry point for device operations.
+ * Delegates to specialized services following Single Responsibility Principle.
+ *
+ * @domain device
+ * @layer infrastructure/services
+ */
+
+import type { DeviceInfo, ApplicationInfo, SystemInfo } from '../../domain/entities/Device';
+import { DeviceInfoService } from './DeviceInfoService';
+import { ApplicationInfoService } from './ApplicationInfoService';
+import { DeviceIdService } from './DeviceIdService';
+import { DeviceCapabilityService } from './DeviceCapabilityService';
+import { UserFriendlyIdService } from './UserFriendlyIdService';
+
+/**
+ * Device Service - Facade for all device operations
+ *
+ * This is a facade that delegates to specialized services.
+ * Each service has a single responsibility (SOLID principles).
+ */
+export class DeviceService {
+  /**
+   * Get device information
+   * Delegates to DeviceInfoService
+   */
+  static async getDeviceInfo(): Promise<DeviceInfo> {
+    return DeviceInfoService.getDeviceInfo();
+  }
+
+  /**
+   * Get application information
+   * Delegates to ApplicationInfoService
+   */
+  static async getApplicationInfo(): Promise<ApplicationInfo> {
+    return ApplicationInfoService.getApplicationInfo();
+  }
+
+  /**
+   * Get complete system information (device + app)
+   * @param options - Optional configuration
+   * @param options.userId - Optional user ID to include in system info
+   */
+  static async getSystemInfo(options?: { userId?: string }): Promise<SystemInfo> {
+    const [device, application] = await Promise.all([
+      DeviceInfoService.getDeviceInfo(),
+      ApplicationInfoService.getApplicationInfo(),
+    ]);
+
+    return {
+      device,
+      application,
+      timestamp: Date.now(),
+      ...(options?.userId && { userId: options.userId }),
+    };
+  }
+
+  /**
+   * Get device unique identifier (platform-specific)
+   * Delegates to DeviceIdService
+   */
+  static async getDeviceId(): Promise<string | null> {
+    return DeviceIdService.getDeviceId();
+  }
+
+  /**
+   * Get offline user ID with fallback
+   * Delegates to DeviceIdService
+   */
+  static async getOfflineUserId(fallbackId: string = 'offline_user'): Promise<string | null> {
+    return DeviceIdService.getOfflineUserId(fallbackId);
+  }
+
+  /**
+   * Check if device supports specific features
+   * Delegates to DeviceCapabilityService
+   */
+  static async getDeviceCapabilities(): Promise<{
+    isDevice: boolean;
+    isTablet: boolean;
+    hasNotch: boolean;
+    totalMemoryGB: number | null;
+  }> {
+    return DeviceCapabilityService.getDeviceCapabilities();
+  }
+
+  /**
+   * Check if device has notch/dynamic island
+   * Delegates to DeviceCapabilityService
+   */
+  static async hasNotch(): Promise<boolean> {
+    return DeviceCapabilityService.hasNotch();
+  }
+
+  /**
+   * Get user friendly device ID
+   * Delegates to UserFriendlyIdService
+   */
+  static async getUserFriendlyId(): Promise<string> {
+    return UserFriendlyIdService.getUserFriendlyId();
+  }
+}

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