@umituz/react-native-design-system 2.9.20 → 2.9.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-design-system",
-  "version": "2.9.20",
+  "version": "2.9.22",
   "description": "Universal design system for React Native apps - Consolidated package with atoms, molecules, organisms, theme, typography, responsive, safe area, exception, infinite scroll, UUID, image, timezone, offline, onboarding, and loading utilities",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/device/domain/types/AnonymousUserTypes.ts

@@ -0,0 +1,47 @@
+/**
+ * Anonymous User Types
+ *
+ * Type definitions for device-based anonymous user identification.
+ * Device ID is persistent across app reinstalls but device-specific.
+ *
+ * @domain device
+ * @layer domain/types
+ */
+
+/**
+ * Anonymous user data with persistent device-based identification
+ */
+export interface AnonymousUser {
+  /** Persistent device-based user ID (stable across sessions and reinstalls) */
+  userId: string;
+  /** User-friendly device name (e.g., "iPhone13-A8F2") */
+  deviceName: string;
+  /** Display name for the anonymous user */
+  displayName: string;
+  /** Always true for anonymous users */
+  isAnonymous: boolean;
+}
+
+/**
+ * Options for anonymous user hook
+ */
+export interface UseAnonymousUserOptions {
+  /** Custom display name for anonymous user */
+  anonymousDisplayName?: string;
+  /** Fallback user ID if device ID generation fails */
+  fallbackUserId?: string;
+}
+
+/**
+ * Return type for useAnonymousUser hook
+ */
+export interface UseAnonymousUserResult {
+  /** Anonymous user data with persistent device-based ID */
+  anonymousUser: AnonymousUser | null;
+  /** Loading state */
+  isLoading: boolean;
+  /** Error message if ID generation failed */
+  error: string | null;
+  /** Refresh function to reload user data */
+  refresh: () => Promise<void>;
+}

package/src/device/index.ts

@@ -108,7 +108,8 @@ export {
 export type {
     AnonymousUser,
     UseAnonymousUserOptions,
-} from './presentation/hooks/useAnonymousUser';
+    UseAnonymousUserResult,
+} from './domain/types/AnonymousUserTypes';
 
 export { useDeviceFeatures } from './presentation/hooks/useDeviceFeatures';
 

package/src/device/infrastructure/repositories/SecureDeviceIdRepository.ts

@@ -1,12 +1,28 @@
+/**
+ * Secure Device ID Repository
+ *
+ * Uses iOS Keychain with AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY for:
+ * - Persistence across app reinstalls
+ * - Device-specific (no backup migration)
+ * - Accessible after first unlock (background tasks)
+ *
+ * @domain device
+ * @layer infrastructure/repositories
+ */
+
 import * as SecureStore from 'expo-secure-store';
 
 const DEVICE_ID_KEY = '@device/persistent_id';
 const MIGRATION_FLAG_KEY = '@device/migration_completed';
 
+const KEYCHAIN_OPTIONS: SecureStore.SecureStoreOptions = {
+  keychainAccessible: SecureStore.AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY,
+};
+
 export class SecureDeviceIdRepository {
   async get(): Promise<string | null> {
     try {
-      return await SecureStore.getItemAsync(DEVICE_ID_KEY);
+      return await SecureStore.getItemAsync(DEVICE_ID_KEY, KEYCHAIN_OPTIONS);
     } catch {
       return null;
     }
@@ -14,15 +30,15 @@ export class SecureDeviceIdRepository {
 
   async set(deviceId: string): Promise<void> {
     try {
-      await SecureStore.setItemAsync(DEVICE_ID_KEY, deviceId);
+      await SecureStore.setItemAsync(DEVICE_ID_KEY, deviceId, KEYCHAIN_OPTIONS);
     } catch {
-      // Silent fail per CLAUDE.md rules
+      // Silent fail
     }
   }
 
   async hasMigrated(): Promise<boolean> {
     try {
-      const flag = await SecureStore.getItemAsync(MIGRATION_FLAG_KEY);
+      const flag = await SecureStore.getItemAsync(MIGRATION_FLAG_KEY, KEYCHAIN_OPTIONS);
       return flag === 'true';
     } catch {
       return false;
@@ -31,7 +47,15 @@ export class SecureDeviceIdRepository {
 
   async setMigrated(): Promise<void> {
     try {
-      await SecureStore.setItemAsync(MIGRATION_FLAG_KEY, 'true');
+      await SecureStore.setItemAsync(MIGRATION_FLAG_KEY, 'true', KEYCHAIN_OPTIONS);
+    } catch {
+      // Silent fail
+    }
+  }
+
+  async remove(): Promise<void> {
+    try {
+      await SecureStore.deleteItemAsync(DEVICE_ID_KEY, KEYCHAIN_OPTIONS);
     } catch {
       // Silent fail
     }

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

@@ -12,6 +12,7 @@ import { Dimensions } from 'react-native';
 import * as Localization from 'expo-localization';
 import { DeviceInfoService } from './DeviceInfoService';
 import { ApplicationInfoService } from './ApplicationInfoService';
+import { DeviceIdService } from './DeviceIdService';
 import { PersistentDeviceIdService } from './PersistentDeviceIdService';
 
 /**
@@ -21,7 +22,12 @@ import { PersistentDeviceIdService } from './PersistentDeviceIdService';
  */
 export interface DeviceExtras {
   [key: string]: string | number | boolean | undefined;
+  /** The stable ID stored in Keychain/SecureStore */
   deviceId?: string;
+  /** Alias for deviceId for clarity in Firestore */
+  persistentDeviceId?: string;
+  /** The raw native platform ID (IDFV on iOS, Android ID on Android) */
+  nativeDeviceId?: string;
   platform?: string;
   deviceModel?: string;
   deviceBrand?: string;
@@ -77,10 +83,11 @@ function getDeviceLocale(): string | undefined {
  */
 export async function collectDeviceExtras(): Promise<DeviceExtras> {
   try {
-    const [deviceInfo, appInfo, deviceId] = await Promise.all([
+    const [deviceInfo, appInfo, deviceId, nativeDeviceId] = await Promise.all([
       DeviceInfoService.getDeviceInfo(),
       ApplicationInfoService.getApplicationInfo(),
       PersistentDeviceIdService.getDeviceId(),
+      DeviceIdService.getDeviceId(),
     ]);
 
     const locale = getDeviceLocale();
@@ -88,6 +95,8 @@ export async function collectDeviceExtras(): Promise<DeviceExtras> {
 
     return {
       deviceId,
+      persistentDeviceId: deviceId, // Explicitly named for Firestore clarity
+      nativeDeviceId: nativeDeviceId || undefined,
       platform: deviceInfo.platform,
       deviceModel: deviceInfo.modelName || undefined,
       deviceBrand: deviceInfo.brand || undefined,

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

@@ -1,32 +1,27 @@
+import { generateUUID } from '../../../uuid';
+import { SecureDeviceIdRepository } from '../repositories/SecureDeviceIdRepository';
+import { LegacyDeviceIdRepository } from '../repositories/LegacyDeviceIdRepository';
+import { DeviceIdService } from './DeviceIdService';
+
+let cachedDeviceId: string | null = null;
+let initializationPromise: Promise<string> | null = null;
+
 /**
  * Persistent Device ID Service
  *
  * Provides a stable device identifier that survives app reinstalls.
- * Priority: SecureStore (survives reinstall) > Native ID > Generated UUID
+ * Priority: SecureStore (true keychain persistence) > Migration > Native ID > Generated UUID
  *
  * @domain device
  * @layer infrastructure/services
  */
-
-import { SecureDeviceIdRepository } from '../repositories/SecureDeviceIdRepository';
-import { LegacyDeviceIdRepository } from '../repositories/LegacyDeviceIdRepository';
-import { DeviceIdService } from './DeviceIdService';
-
-let cachedDeviceId: string | null = null;
-let initializationPromise: Promise<string> | null = null;
-
-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);
-  });
-}
-
 export class PersistentDeviceIdService {
   private static secureRepo = new SecureDeviceIdRepository();
   private static legacyRepo = new LegacyDeviceIdRepository();
 
+  /**
+   * Get device ID with caching and concurrent request handling
+   */
   static async getDeviceId(): Promise<string> {
     if (cachedDeviceId) {
       return cachedDeviceId;
@@ -40,34 +35,60 @@ export class PersistentDeviceIdService {
     return initializationPromise;
   }
 
+  /**
+   * Logic to establish a persistent ID
+   */
   private static async initializeDeviceId(): Promise<string> {
     try {
+      // 1. Try secure repository (Keychain)
       const secureId = await this.secureRepo.get();
 
       if (secureId) {
+        if (__DEV__) {
+          console.log('[PersistentDeviceIdService] Found secure device ID:', secureId);
+        }
         cachedDeviceId = secureId;
         return secureId;
       }
 
+      // 2. Try migration from legacy storage
       const migrated = await this.migrateFromLegacy();
       if (migrated) {
+        if (__DEV__) {
+          console.log('[PersistentDeviceIdService] Migrated ID from legacy storage:', migrated);
+        }
         cachedDeviceId = migrated;
         return migrated;
       }
 
+      // 3. Create brand new ID
       const newId = await this.createNewDeviceId();
-      await this.secureRepo.set(newId);
-      await this.legacyRepo.set(newId);
-      cachedDeviceId = newId;
+      
+      // Save to both for safety during transition
+      await Promise.all([
+        this.secureRepo.set(newId),
+        this.legacyRepo.set(newId),
+      ]);
+
+      if (__DEV__) {
+        console.log('[PersistentDeviceIdService] Created new persistent ID:', newId);
+      }
 
+      cachedDeviceId = newId;
       return newId;
-    } catch {
-      const fallbackId = generateUUID();
+    } catch (error) {
+      if (__DEV__) {
+        console.error('[PersistentDeviceIdService] Initialization failed, using fallback:', error);
+      }
+      const fallbackId = `fallback_${generateUUID()}`;
       cachedDeviceId = fallbackId;
       return fallbackId;
     }
   }
 
+  /**
+   * Handles migration while ensuring it only happens once
+   */
   private static async migrateFromLegacy(): Promise<string | null> {
     try {
       const hasMigrated = await this.secureRepo.hasMigrated();
@@ -81,6 +102,7 @@ export class PersistentDeviceIdService {
         return null;
       }
 
+      // Upgrade legacy to secure storage
       await this.secureRepo.set(legacyId);
       await this.secureRepo.setMigrated();
 
@@ -90,6 +112,9 @@ export class PersistentDeviceIdService {
     }
   }
 
+  /**
+   * Generates a new ID based on platform info if possible
+   */
   private static async createNewDeviceId(): Promise<string> {
     const nativeId = await DeviceIdService.getDeviceId();
 
@@ -97,9 +122,12 @@ export class PersistentDeviceIdService {
       return `device_${nativeId}`;
     }
 
-    return `generated_${generateUUID()}`;
+    return `gen_${generateUUID()}`;
   }
 
+  /**
+   * Check if an ID exists without initializing
+   */
   static async hasStoredId(): Promise<boolean> {
     try {
       const secureId = await this.secureRepo.get();
@@ -109,16 +137,28 @@ export class PersistentDeviceIdService {
     }
   }
 
+  /**
+   * Fully clear all stored identifiers
+   */
   static async clearStoredId(): Promise<void> {
     try {
-      await this.legacyRepo.remove();
+      await Promise.all([
+        this.secureRepo.remove(),
+        this.legacyRepo.remove(),
+      ]);
       cachedDeviceId = null;
       initializationPromise = null;
+      if (__DEV__) {
+        console.log('[PersistentDeviceIdService] All device identifiers cleared');
+      }
     } catch {
       // Silent fail
     }
   }
 
+  /**
+   * Get current cached ID synchronously
+   */
   static getCachedId(): string | null {
     return cachedDeviceId;
   }

package/src/device/presentation/hooks/useAnonymousUser.ts

@@ -2,8 +2,10 @@
  * Anonymous User Hook
  *
  * Provides persistent device-based user ID for anonymous users.
- * The ID is stable across app restarts and sessions.
- * Compatible with subscription services and Firebase Anonymous Auth.
+ * Uses iOS Keychain with AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY for:
+ * - Stable ID across app restarts and reinstalls
+ * - Device-specific (no backup migration)
+ * - Compatible with Firebase Anonymous Auth
  *
  * @domain device
  * @layer presentation/hooks
@@ -12,37 +14,18 @@
 import { useState, useEffect, useCallback } from 'react';
 import { PersistentDeviceIdService } from '../../infrastructure/services/PersistentDeviceIdService';
 import { DeviceService } from '../../infrastructure/services/DeviceService';
-
-/**
- * Anonymous user data
- */
-export interface AnonymousUser {
-  /** Persistent device-based user ID (stable across sessions) */
-  userId: string;
-  /** User-friendly device name (e.g., "iPhone13-A8F2") */
-  deviceName: string;
-  /** Display name for the anonymous user */
-  displayName: string;
-  /** Always true for anonymous users */
-  isAnonymous: boolean;
-}
-
-/**
- * useAnonymousUser hook options
- */
-export interface UseAnonymousUserOptions {
-  /** Custom display name for anonymous user */
-  anonymousDisplayName?: string;
-  /** Fallback user ID if device ID generation fails */
-  fallbackUserId?: string;
-}
+import type {
+  AnonymousUser,
+  UseAnonymousUserOptions,
+  UseAnonymousUserResult,
+} from '../../domain/types/AnonymousUserTypes';
 
 /**
  * useAnonymousUser hook for persistent device-based user identification
  *
  * USAGE:
  * ```typescript
- * import { useAnonymousUser } from '@umituz/react-native-device';
+ * import { useAnonymousUser } from '@umituz/react-native-design-system';
  *
  * const { anonymousUser, isLoading } = useAnonymousUser();
  *
@@ -57,7 +40,9 @@ export interface UseAnonymousUserOptions {
  * />
  * ```
  */
-export const useAnonymousUser = (options?: UseAnonymousUserOptions) => {
+export const useAnonymousUser = (
+  options?: UseAnonymousUserOptions
+): UseAnonymousUserResult => {
   const [anonymousUser, setAnonymousUser] = useState<AnonymousUser | null>(null);
   const [isLoading, setIsLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
@@ -105,13 +90,9 @@ export const useAnonymousUser = (options?: UseAnonymousUserOptions) => {
   }, [loadAnonymousUser]);
 
   return {
-    /** Anonymous user data with persistent device-based ID */
     anonymousUser,
-    /** Loading state */
     isLoading,
-    /** Error message if ID generation failed */
     error,
-    /** Refresh function to reload user data */
     refresh,
   };
 };