@teardown/react-native 2.0.0 → 2.0.2

package/src/clients/device/{expo-adapter.ts → adapters/basic.adapter.ts}

@@ -6,11 +6,10 @@ import type {
 } from "@teardown/schemas";
 import * as Application from "expo-application";
 import * as Device from "expo-device";
-import * as Notifications from "expo-notifications";
 import { Platform } from "react-native";
 
 import { DeviceInfoAdapter } from "./device.adpater-interface";
-import { DevicePlatformEnum, NotificationPlatformEnum } from "./device.client";
+import { DevicePlatformEnum, NotificationPlatformEnum } from "../device.client";
 
 /**
  * Maps expo-device DeviceType to a string representation
@@ -50,13 +49,6 @@ function mapPlatform(platform: typeof Platform.OS): DevicePlatformEnum {
   }
 }
 
-/**
- * Determines the notification platform based on the device platform
- */
-function getNotificationPlatform(): NotificationPlatformEnum {
-  return NotificationPlatformEnum.EXPO;
-}
-
 export class ExpoDeviceAdapter extends DeviceInfoAdapter {
   get applicationInfo(): ApplicationInfo {
     return {
@@ -85,44 +77,14 @@ export class ExpoDeviceAdapter extends DeviceInfoAdapter {
   }
 
   get notificationsInfo(): NotificationsInfo {
-    // Note: This returns a synchronous snapshot.
-    // For accurate permission status, use getNotificationsInfoAsync()
     return {
       push: {
         enabled: false,
         granted: false,
         token: null,
-        platform: getNotificationPlatform(),
+        platform: NotificationPlatformEnum.EXPO,
       },
     };
   }
 
-  /**
-   * Async method to get accurate notification permissions and token.
-   * Use this when you need real-time notification status.
-   */
-  async getNotificationsInfoAsync(): Promise<NotificationsInfo> {
-    const { status: existingStatus } =
-      await Notifications.getPermissionsAsync();
-    const granted = existingStatus === "granted";
-
-    let token: string | null = null;
-    if (granted) {
-      try {
-        const tokenData = await Notifications.getExpoPushTokenAsync();
-        token = tokenData.data;
-      } catch {
-        // Token retrieval failed, keep as null
-      }
-    }
-
-    return {
-      push: {
-        enabled: granted,
-        granted,
-        token,
-        platform: getNotificationPlatform(),
-      },
-    };
-  }
 }

package/src/clients/device/{device.adpater-interface.ts → adapters/device.adpater-interface.ts}

@@ -50,7 +50,7 @@ export abstract class DeviceInfoAdapter {
 			application: this.applicationInfo,
 			hardware: this.hardwareInfo,
 			os: this.osInfo,
-			notifications: this.notificationsInfo,
+			notifications: null,
 			update: null,
 		});
 	}

package/src/clients/device/adapters/expo.adapter.ts

@@ -0,0 +1,90 @@
+import type {
+  ApplicationInfo,
+  HardwareInfo,
+  NotificationsInfo,
+  OSInfo,
+} from "@teardown/schemas";
+import * as Application from "expo-application";
+import * as Device from "expo-device";
+import { Platform } from "react-native";
+
+import { DeviceInfoAdapter } from "./device.adpater-interface";
+import { DevicePlatformEnum, NotificationPlatformEnum } from "../device.client";
+
+/**
+ * Maps expo-device DeviceType to a string representation
+ */
+function mapDeviceType(deviceType: Device.DeviceType | null): string {
+  switch (deviceType) {
+    case Device.DeviceType.PHONE:
+      return "phone";
+    case Device.DeviceType.TABLET:
+      return "tablet";
+    case Device.DeviceType.DESKTOP:
+      return "desktop";
+    case Device.DeviceType.TV:
+      return "tv";
+    default:
+      return "unknown";
+  }
+}
+
+/**
+ * Maps React Native Platform.OS to DevicePlatformEnum
+ */
+function mapPlatform(platform: typeof Platform.OS): DevicePlatformEnum {
+  switch (platform) {
+    case "ios":
+      return DevicePlatformEnum.IOS;
+    case "android":
+      return DevicePlatformEnum.ANDROID;
+    case "web":
+      return DevicePlatformEnum.WEB;
+    case "macos":
+      return DevicePlatformEnum.MACOS;
+    case "windows":
+      return DevicePlatformEnum.WINDOWS;
+    default:
+      return DevicePlatformEnum.UNKNOWN;
+  }
+}
+
+export class ExpoDeviceAdapter extends DeviceInfoAdapter {
+  get applicationInfo(): ApplicationInfo {
+    return {
+      version: Application.nativeApplicationVersion ?? "0.0.0",
+      build_number: Number.parseInt(
+        Application.nativeBuildVersion ?? "0",
+        10
+      ),
+    };
+  }
+
+  get hardwareInfo(): HardwareInfo {
+    return {
+      device_name: Device.deviceName ?? "Unknown Device",
+      device_brand: Device.brand ?? "Unknown Brand",
+      device_type: mapDeviceType(Device.deviceType),
+    };
+  }
+
+  get osInfo(): OSInfo {
+    return {
+      platform: mapPlatform(Platform.OS),
+      name: Device.osName ?? Platform.OS,
+      version: Device.osVersion ?? "0.0.0",
+    };
+  }
+
+  get notificationsInfo(): NotificationsInfo {
+    return {
+      push: {
+        enabled: false,
+        granted: false,
+        token: null,
+        platform: NotificationPlatformEnum.EXPO,
+      },
+    };
+  }
+
+}

package/src/clients/device/device.client.test.ts

@@ -1,6 +1,6 @@
 import type { DeviceInfo } from "@teardown/schemas";
 import { describe, expect, test } from "bun:test";
-import type { DeviceInfoAdapter } from "./device.adpater-interface";
+import type { DeviceInfoAdapter } from "./adapters/device.adpater-interface";
 import { DeviceClient } from "./device.client";
 
 function createMockLoggingClient() {
@@ -51,10 +51,6 @@ function createMockDeviceAdapter(): DeviceInfoAdapter {
 			name: "iOS",
 			version: "17.0",
 		},
-		notifications: {
-			push_token: null,
-			platform: null,
-		},
 		update: null,
 	};
 
@@ -62,7 +58,6 @@ function createMockDeviceAdapter(): DeviceInfoAdapter {
 		applicationInfo: mockDeviceInfo.application,
 		hardwareInfo: mockDeviceInfo.hardware,
 		osInfo: mockDeviceInfo.os,
-		notificationsInfo: mockDeviceInfo.notifications,
 		getDeviceInfo: async () => mockDeviceInfo,
 	} as DeviceInfoAdapter;
 }

package/src/clients/device/device.client.ts

@@ -2,7 +2,7 @@ import type { DeviceInfo } from "@teardown/schemas";
 import type { Logger, LoggingClient } from "../logging/";
 import type { StorageClient, SupportedStorage } from "../storage";
 import type { UtilsClient } from "../utils/utils.client";
-import type { DeviceInfoAdapter } from "./device.adpater-interface";
+import type { DeviceInfoAdapter } from "./adapters/device.adpater-interface";
 
 // TODO: sort out why importing these enuims from schemas is not working - @teardown/schemas
 export enum NotificationPlatformEnum {
@@ -54,11 +54,13 @@ export class DeviceClient {
 
 		this.logger.debug("Getting device ID");
 		const deviceId = this.storage.getItem("deviceId");
+		this.logger.debug(`Device ID found in storage: ${deviceId}`);
 		if (deviceId) {
 			return deviceId;
 		}
 
 		const newDeviceId = await this.utils.generateRandomUUID();
+		await this.storage.setItem("deviceId", newDeviceId);
 
 		return newDeviceId;
 	}
@@ -66,4 +68,6 @@ export class DeviceClient {
 	async getDeviceInfo(): Promise<DeviceInfo> {
 		return this.options.adapter.getDeviceInfo();
 	}
+
+
 }

package/src/clients/device/index.ts

@@ -1,4 +1,4 @@
 // export * from "./adapters/device-info.adapter";
 // export * from "./adapters/expo-device.adapter";
-export * from "./device.adpater-interface";
+export * from "./adapters/device.adpater-interface";
 export * from "./device.client";

package/src/clients/force-update/force-update.client.test.ts

@@ -1,5 +1,6 @@
 import { describe, test, expect, beforeEach, mock } from "bun:test";
 import { EventEmitter } from "eventemitter3";
+import { ForceUpdateClient, IdentifyVersionStatusEnum, VERSION_STATUS_STORAGE_KEY } from "./force-update.client";
 
 // Must mock react-native BEFORE any imports that use it
 const mockAppStateListeners: ((state: string) => void)[] = [];
@@ -12,16 +13,15 @@ mock.module("react-native", () => ({
 	},
 }));
 
-// Import after mock
-const { ForceUpdateClient, IdentifyVersionStatusEnum } = await import("./force-update.client");
 type IdentifyState = import("../identity").IdentifyState;
 type IdentifyStateChangeEvents = import("../identity").IdentifyStateChangeEvents;
 type VersionStatus = import("./force-update.client").VersionStatus;
 
-function createMockIdentityClient() {
+function createMockIdentityClient(initialState?: IdentifyState) {
 	const emitter = new EventEmitter<IdentifyStateChangeEvents>();
 	let identifyCallCount = 0;
-	let nextIdentifyResult: { success: boolean; data?: { version_info: { status: IdentifyVersionStatusEnum } } } = {
+	let currentState: IdentifyState = initialState ?? { type: "unidentified" };
+	let nextIdentifyResult: { success: boolean; data?: { version_info: { status: IdentifyVersionStatusEnum } } } | null = {
 		success: true,
 		data: { version_info: { status: IdentifyVersionStatusEnum.UP_TO_DATE } },
 	};
@@ -32,14 +32,20 @@ function createMockIdentityClient() {
 			emitter.addListener("IDENTIFY_STATE_CHANGED", listener);
 			return () => emitter.removeListener("IDENTIFY_STATE_CHANGED", listener);
 		},
+		getIdentifyState: () => currentState,
 		identify: async () => {
 			identifyCallCount++;
-			emitter.emit("IDENTIFY_STATE_CHANGED", { type: "identifying" });
-			emitter.emit("IDENTIFY_STATE_CHANGED", {
+			if (nextIdentifyResult === null) {
+				return null;
+			}
+			currentState = { type: "identifying" };
+			emitter.emit("IDENTIFY_STATE_CHANGED", currentState);
+			currentState = {
 				type: "identified",
 				session: { session_id: "s1", device_id: "d1", persona_id: "p1", token: "t1" },
 				version_info: { status: nextIdentifyResult.data?.version_info.status ?? IdentifyVersionStatusEnum.UP_TO_DATE, update: null },
-			});
+			};
+			emitter.emit("IDENTIFY_STATE_CHANGED", currentState);
 			return nextIdentifyResult;
 		},
 		getIdentifyCallCount: () => identifyCallCount,
@@ -52,10 +58,10 @@ function createMockIdentityClient() {
 function createMockLoggingClient() {
 	return {
 		createLogger: () => ({
-			info: () => {},
-			warn: () => {},
-			error: () => {},
-			debug: () => {},
+			info: () => { },
+			warn: () => { },
+			error: () => { },
+			debug: () => { },
 		}),
 	};
 }
@@ -68,6 +74,7 @@ function createMockStorageClient() {
 			setItem: (key: string, value: string) => storage.set(key, value),
 			removeItem: (key: string) => storage.delete(key),
 		}),
+		getStorage: () => storage,
 	};
 }
 
@@ -76,6 +83,83 @@ describe("ForceUpdateClient", () => {
 		mockAppStateListeners.length = 0;
 	});
 
+	describe("initialization from current identity state", () => {
+		test("initializes version status when identity is already identified", () => {
+			const mockIdentity = createMockIdentityClient({
+				type: "identified",
+				session: { session_id: "s1", device_id: "d1", persona_id: "p1", token: "t1" },
+				version_info: { status: IdentifyVersionStatusEnum.UPDATE_REQUIRED, update: null },
+			});
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+
+			const client = new ForceUpdateClient(
+				mockLogging as never,
+				mockStorage as never,
+				mockIdentity as never
+			);
+			client.initialize();
+
+			// Should immediately have update_required status from initialization
+			expect(client.getVersionStatus().type).toBe("update_required");
+
+			client.shutdown();
+		});
+
+		test("stays in initializing when identity is unidentified", () => {
+			const mockIdentity = createMockIdentityClient({ type: "unidentified" });
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+
+			const client = new ForceUpdateClient(
+				mockLogging as never,
+				mockStorage as never,
+				mockIdentity as never
+			);
+			client.initialize();
+
+			// Should stay in initializing since not yet identified
+			expect(client.getVersionStatus().type).toBe("initializing");
+
+			client.shutdown();
+		});
+
+		test("emits status change during initialization when already identified", () => {
+			const mockIdentity = createMockIdentityClient({
+				type: "identified",
+				session: { session_id: "s1", device_id: "d1", persona_id: "p1", token: "t1" },
+				version_info: { status: IdentifyVersionStatusEnum.UP_TO_DATE, update: null },
+			});
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+
+			const statusChanges: VersionStatus[] = [];
+
+			const client = new ForceUpdateClient(
+				mockLogging as never,
+				mockStorage as never,
+				mockIdentity as never
+			);
+			client.initialize();
+
+			// Subscribe after construction to verify initial status was set
+			client.onVersionStatusChange((status) => statusChanges.push(status));
+
+			// Trigger another identify to verify no duplicate
+			mockIdentity.emitter.emit("IDENTIFY_STATE_CHANGED", {
+				type: "identified",
+				session: { session_id: "s1", device_id: "d1", persona_id: "p1", token: "t1" },
+				version_info: { status: IdentifyVersionStatusEnum.UP_TO_DATE, update: null },
+			});
+
+			// Should only have one change from the second emit (initial was before subscription)
+			expect(statusChanges).toHaveLength(1);
+			expect(client.getVersionStatus().type).toBe("up_to_date");
+
+			client.shutdown();
+		});
+	});
+
 	describe("updateFromVersionStatus single emission", () => {
 		test("emits VERSION_STATUS_CHANGED exactly once per identify cycle", async () => {
 			const mockIdentity = createMockIdentityClient();
@@ -88,6 +172,7 @@ describe("ForceUpdateClient", () => {
 				mockIdentity as never,
 				{ throttleMs: 0, checkCooldownMs: 0 }
 			);
+			client.initialize();
 
 			const statusChanges: VersionStatus[] = [];
 			client.onVersionStatusChange((status) => statusChanges.push(status));
@@ -124,6 +209,7 @@ describe("ForceUpdateClient", () => {
 				mockIdentity as never,
 				{ throttleMs: 0, checkCooldownMs: 0 }
 			);
+			client.initialize();
 
 			const statusChanges: VersionStatus[] = [];
 			client.onVersionStatusChange((status) => statusChanges.push(status));
@@ -157,6 +243,7 @@ describe("ForceUpdateClient", () => {
 				mockStorage as never,
 				mockIdentity as never
 			);
+			client.initialize();
 
 			const statusChanges: VersionStatus[] = [];
 			client.onVersionStatusChange((status) => statusChanges.push(status));
@@ -184,6 +271,7 @@ describe("ForceUpdateClient", () => {
 				mockStorage as never,
 				mockIdentity as never
 			);
+			client.initialize();
 
 			expect(mockAppStateListeners).toHaveLength(1);
 
@@ -194,6 +282,60 @@ describe("ForceUpdateClient", () => {
 	});
 
 	describe("throttle and cooldown", () => {
+		test("skips version check when identify returns null", async () => {
+			const mockIdentity = createMockIdentityClient();
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+
+			mockIdentity.setNextIdentifyResult(null);
+
+			const client = new ForceUpdateClient(
+				mockLogging as never,
+				mockStorage as never,
+				mockIdentity as never,
+				{ throttleMs: 0, checkCooldownMs: 0 }
+			);
+			client.initialize();
+
+			const statusChanges: VersionStatus[] = [];
+			client.onVersionStatusChange((status) => statusChanges.push(status));
+
+			const foregroundHandler = mockAppStateListeners[0];
+			await foregroundHandler("active");
+			await new Promise((r) => setTimeout(r, 10));
+
+			// Should have called identify but no status changes (null result)
+			expect(mockIdentity.getIdentifyCallCount()).toBe(1);
+			expect(statusChanges).toHaveLength(0);
+
+			client.shutdown();
+		});
+
+		test("checkCooldownMs -1 disables version checking entirely", async () => {
+			const mockIdentity = createMockIdentityClient();
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+
+			const client = new ForceUpdateClient(
+				mockLogging as never,
+				mockStorage as never,
+				mockIdentity as never,
+				{ throttleMs: 0, checkCooldownMs: -1 }
+			);
+			client.initialize();
+
+			const foregroundHandler = mockAppStateListeners[0];
+
+			// Trigger foreground
+			await foregroundHandler("active");
+			await new Promise((r) => setTimeout(r, 10));
+
+			// Should not have called identify at all
+			expect(mockIdentity.getIdentifyCallCount()).toBe(0);
+
+			client.shutdown();
+		});
+
 		test("throttle prevents rapid foreground checks", async () => {
 			const mockIdentity = createMockIdentityClient();
 			const mockLogging = createMockLoggingClient();
@@ -205,6 +347,7 @@ describe("ForceUpdateClient", () => {
 				mockIdentity as never,
 				{ throttleMs: 1000, checkCooldownMs: 0 }
 			);
+			client.initialize();
 
 			const foregroundHandler = mockAppStateListeners[0];
 
@@ -238,6 +381,7 @@ describe("ForceUpdateClient", () => {
 				mockIdentity as never,
 				{ throttleMs: 0, checkCooldownMs: 5000 }
 			);
+			client.initialize();
 
 			const foregroundHandler = mockAppStateListeners[0];
 
@@ -261,13 +405,99 @@ describe("ForceUpdateClient", () => {
 		});
 	});
 
+	describe("stale storage state reset", () => {
+		test("resets stale 'checking' state from storage to initializing", () => {
+			const mockIdentity = createMockIdentityClient({ type: "unidentified" });
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+
+			// Pre-populate storage with stale "checking" state
+			mockStorage.getStorage().set(VERSION_STATUS_STORAGE_KEY, JSON.stringify({ type: "checking" }));
+
+			const client = new ForceUpdateClient(
+				mockLogging as never,
+				mockStorage as never,
+				mockIdentity as never
+			);
+			client.initialize();
+
+			// Should reset to initializing, not stay in checking
+			expect(client.getVersionStatus().type).toBe("initializing");
+
+			client.shutdown();
+		});
+
+		test("resets stale 'initializing' state from storage to initializing", () => {
+			const mockIdentity = createMockIdentityClient({ type: "unidentified" });
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+
+			// Pre-populate storage with stale "initializing" state
+			mockStorage.getStorage().set(VERSION_STATUS_STORAGE_KEY, JSON.stringify({ type: "initializing" }));
+
+			const client = new ForceUpdateClient(
+				mockLogging as never,
+				mockStorage as never,
+				mockIdentity as never
+			);
+			client.initialize();
+
+			// Should reset to initializing (which it already is, but storage should be cleared)
+			expect(client.getVersionStatus().type).toBe("initializing");
+
+			client.shutdown();
+		});
+
+		test("preserves valid 'up_to_date' state from storage", () => {
+			const mockIdentity = createMockIdentityClient({ type: "unidentified" });
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+
+			// Pre-populate storage with valid state
+			mockStorage.getStorage().set(VERSION_STATUS_STORAGE_KEY, JSON.stringify({ type: "up_to_date" }));
+
+			const client = new ForceUpdateClient(
+				mockLogging as never,
+				mockStorage as never,
+				mockIdentity as never
+			);
+			client.initialize();
+
+			// Should keep up_to_date from storage
+			expect(client.getVersionStatus().type).toBe("up_to_date");
+
+			client.shutdown();
+		});
+
+		test("preserves valid 'update_required' state from storage", () => {
+			const mockIdentity = createMockIdentityClient({ type: "unidentified" });
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+
+			// Pre-populate storage with valid state
+			mockStorage.getStorage().set(VERSION_STATUS_STORAGE_KEY, JSON.stringify({ type: "update_required" }));
+
+			const client = new ForceUpdateClient(
+				mockLogging as never,
+				mockStorage as never,
+				mockIdentity as never
+			);
+			client.initialize();
+
+			// Should keep update_required from storage
+			expect(client.getVersionStatus().type).toBe("update_required");
+
+			client.shutdown();
+		});
+	});
+
 	describe("version status mapping", () => {
 		test.each([
 			[IdentifyVersionStatusEnum.UP_TO_DATE, "up_to_date"],
 			[IdentifyVersionStatusEnum.UPDATE_AVAILABLE, "update_available"],
 			[IdentifyVersionStatusEnum.UPDATE_REQUIRED, "update_required"],
-			[IdentifyVersionStatusEnum.UPDATE_RECOMMENDED, "up_to_date"], // Falls through to default
-			[IdentifyVersionStatusEnum.DISABLED, "up_to_date"], // Falls through to default
+			[IdentifyVersionStatusEnum.UPDATE_RECOMMENDED, "update_recommended"],
+			[IdentifyVersionStatusEnum.DISABLED, "disabled"],
 		])("maps %s to %s", (apiStatus, expectedType) => {
 			const mockIdentity = createMockIdentityClient();
 			const mockLogging = createMockLoggingClient();
@@ -278,6 +508,7 @@ describe("ForceUpdateClient", () => {
 				mockStorage as never,
 				mockIdentity as never
 			);
+			client.initialize();
 
 			const statusChanges: VersionStatus[] = [];
 			client.onVersionStatusChange((status) => statusChanges.push(status));