@teardown/react-native 2.0.1 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@teardown/react-native",
-	"version": "2.0.1",
+	"version": "2.0.2",
 	"private": false,
 	"publishConfig": {
 		"access": "public"
@@ -18,15 +18,20 @@
 			"import": "./src/exports/index.ts",
 			"default": "./src/exports/index.ts"
 		},
-		"./expo": {
-			"types": "./src/exports/expo.ts",
-			"import": "./src/exports/expo.ts",
-			"default": "./src/exports/expo.ts"
+		"./adapters/expo": {
+			"types": "./src/exports/adapters/expo.ts",
+			"import": "./src/exports/adapters/expo.ts",
+			"default": "./src/exports/adapters/expo.ts"
 		},
-		"./mmkv": {
-			"types": "./src/exports/mmkv.ts",
-			"import": "./src/exports/mmkv.ts",
-			"default": "./src/exports/mmkv.ts"
+		"./adapters/mmkv": {
+			"types": "./src/exports/adapters/mmkv.ts",
+			"import": "./src/exports/adapters/mmkv.ts",
+			"default": "./src/exports/adapters/mmkv.ts"
+		},
+		"./adapters/async-storage": {
+			"types": "./src/exports/adapters/async-storage.ts",
+			"import": "./src/exports/adapters/async-storage.ts",
+			"default": "./src/exports/adapters/async-storage.ts"
 		}
 	},
 	"scripts": {
@@ -40,11 +45,13 @@
 		"nuke": "cd ../../ && bun run nuke"
 	},
 	"dependencies": {
-		"@teardown/ingest-api": "0.1.36",
-		"@teardown/schemas": "0.1.36",
-		"@teardown/types": "0.1.36",
+		"@teardown/ingest-api": "0.1.41",
+		"@teardown/schemas": "0.1.41",
+		"@teardown/types": "0.1.41",
 		"eventemitter3": "^5.0.1",
-		"uuid": "^13.0.0"
+		"react-native-get-random-values": "^2.0.0",
+		"uuid": "^13.0.0",
+		"zod": "^4.1.13"
 	},
 	"devDependencies": {
 		"@elysiajs/eden": "^1.4.5",
@@ -55,13 +62,34 @@
 		"expo-updates": "^29.0.12"
 	},
 	"peerDependencies": {
+		"@react-native-async-storage/async-storage": "^1.21.0 || ^2.0.0",
 		"react": "*",
 		"react-native": "*",
 		"typescript": "*",
-		"expo-application": "^7.0",
-		"expo-device": "^8.0",
-		"expo-notifications": "^0.29",
-		"react-native-mmkv": "^3.0",
-		"zod": "^4"
+		"expo-application": "*",
+		"expo-device": "*",
+		"expo-notifications": "*",
+		"expo-secure-store": "*",
+		"react-native-mmkv": "*"
+	},
+	"peerDependenciesMeta": {
+		"@react-native-async-storage/async-storage": {
+			"optional": true
+		},
+		"react-native-mmkv": {
+			"optional": true
+		},
+		"expo-application": {
+			"optional": true
+		},
+		"expo-device": {
+			"optional": true
+		},
+		"expo-notifications": {
+			"optional": true
+		},
+		"expo-secure-store": {
+			"optional": true
+		}
 	}
 }

package/src/clients/api/api.client.ts

@@ -1,9 +1,9 @@
-import * as Eden from "@elysiajs/eden";
+import type * as Eden from "@elysiajs/eden";
 import * as IngestApi from "@teardown/ingest-api";
 import type { LoggingClient } from "../logging";
 import type { StorageClient } from "../storage";
 
-export { Eden, IngestApi };
+export type { Eden, IngestApi };
 
 const TEARDOWN_INGEST_URL = "https://ingest.teardown.dev";
 const TEARDOWN_API_KEY_HEADER = "td-api-key";

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

@@ -9,7 +9,7 @@ import * as Device from "expo-device";
 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

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() {

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,6 +1,6 @@
 import { describe, test, expect, beforeEach, mock } from "bun:test";
 import { EventEmitter } from "eventemitter3";
-import { ForceUpdateClient, IdentifyVersionStatusEnum } from "./force-update.client";
+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)[] = [];
@@ -17,10 +17,11 @@ 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 } },
 	};
@@ -31,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,
@@ -67,6 +74,7 @@ function createMockStorageClient() {
 			setItem: (key: string, value: string) => storage.set(key, value),
 			removeItem: (key: string) => storage.delete(key),
 		}),
+		getStorage: () => storage,
 	};
 }
 
@@ -75,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();
@@ -87,6 +172,7 @@ describe("ForceUpdateClient", () => {
 				mockIdentity as never,
 				{ throttleMs: 0, checkCooldownMs: 0 }
 			);
+			client.initialize();
 
 			const statusChanges: VersionStatus[] = [];
 			client.onVersionStatusChange((status) => statusChanges.push(status));
@@ -123,6 +209,7 @@ describe("ForceUpdateClient", () => {
 				mockIdentity as never,
 				{ throttleMs: 0, checkCooldownMs: 0 }
 			);
+			client.initialize();
 
 			const statusChanges: VersionStatus[] = [];
 			client.onVersionStatusChange((status) => statusChanges.push(status));
@@ -156,6 +243,7 @@ describe("ForceUpdateClient", () => {
 				mockStorage as never,
 				mockIdentity as never
 			);
+			client.initialize();
 
 			const statusChanges: VersionStatus[] = [];
 			client.onVersionStatusChange((status) => statusChanges.push(status));
@@ -183,6 +271,7 @@ describe("ForceUpdateClient", () => {
 				mockStorage as never,
 				mockIdentity as never
 			);
+			client.initialize();
 
 			expect(mockAppStateListeners).toHaveLength(1);
 
@@ -193,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();
@@ -204,6 +347,7 @@ describe("ForceUpdateClient", () => {
 				mockIdentity as never,
 				{ throttleMs: 1000, checkCooldownMs: 0 }
 			);
+			client.initialize();
 
 			const foregroundHandler = mockAppStateListeners[0];
 
@@ -237,6 +381,7 @@ describe("ForceUpdateClient", () => {
 				mockIdentity as never,
 				{ throttleMs: 0, checkCooldownMs: 5000 }
 			);
+			client.initialize();
 
 			const foregroundHandler = mockAppStateListeners[0];
 
@@ -260,6 +405,92 @@ 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"],
@@ -277,6 +508,7 @@ describe("ForceUpdateClient", () => {
 				mockStorage as never,
 				mockIdentity as never
 			);
+			client.initialize();
 
 			const statusChanges: VersionStatus[] = [];
 			client.onVersionStatusChange((status) => statusChanges.push(status));