@teardown/react-native 2.0.1 → 2.0.2

package/src/clients/identity/identity.client.ts

@@ -75,7 +75,8 @@ export const IDENTIFY_STORAGE_KEY = "IDENTIFY_STATE";
 
 export class IdentityClient {
 	private emitter = new EventEmitter<IdentifyStateChangeEvents>();
-	private identifyState: IdentifyState;
+	private identifyState: IdentifyState = { type: "unidentified" };
+	private initialized = false;
 
 	public readonly logger: Logger;
 	public readonly utils: UtilsClient;
@@ -93,22 +94,46 @@ export class IdentityClient {
 		});
 		this.storage = storage.createStorage("identity");
 		this.utils = utils;
-		this.identifyState = this.getIdentifyStateFromStorage();
+		// Don't load from storage here - defer to initialize()
 	}
 
 	async initialize(): Promise<void> {
+		this.logger.debug("Initializing IdentityClient");
+		if (this.initialized) {
+			this.logger.debug("IdentityClient already initialized");
+			return;
+		}
+		this.initialized = true;
+
+		// Load state from storage first (for fallback if identify fails)
+		this.identifyState = this.getIdentifyStateFromStorage();
+		this.logger.debug(`Initialized with state: ${this.identifyState.type}`);
+
+		// Always identify on app boot to refresh version status
 		await this.identify();
 	}
 
 	private getIdentifyStateFromStorage(): IdentifyState {
 		const stored = this.storage.getItem(IDENTIFY_STORAGE_KEY);
+
 		if (stored == null) {
-			// console.log("no stored session state");
+			this.logger.debug("No stored identity state, returning unidentified");
+			return UnidentifiedSessionStateSchema.parse({ type: "unidentified" });
+		}
+
+		const parsed = IdentifyStateSchema.parse(JSON.parse(stored));
+		this.logger.debug(`Parsed identity state from storage: ${parsed.type}`);
+
+		// "identifying" is a transient state - if we restore it, treat as unidentified
+		// This can happen if the app was killed during an identify call
+		if (parsed.type === "identifying") {
+			this.logger.debug("Found stale 'identifying' state in storage, resetting to unidentified");
+			// Clear the stale state from storage immediately
+			this.storage.removeItem(IDENTIFY_STORAGE_KEY);
 			return UnidentifiedSessionStateSchema.parse({ type: "unidentified" });
 		}
 
-		// console.log("stored session state", stored);
-		return IdentifyStateSchema.parse(JSON.parse(stored));
+		return parsed;
 	}
 
 	private saveIdentifyStateToStorage(identifyState: IdentifyState): void {
@@ -116,7 +141,13 @@ export class IdentityClient {
 	}
 
 	private setIdentifyState(newState: IdentifyState): void {
-		this.logger.info(`Identify state: ${this.identifyState.type} -> ${newState.type}`);
+
+		if (this.identifyState.type === newState.type) {
+			this.logger.debug(`Identify state already set: ${this.identifyState.type}`);
+			return;
+		}
+
+		this.logger.debug(`Identify state: ${this.identifyState.type} -> ${newState.type}`);
 		this.identifyState = newState;
 		this.saveIdentifyStateToStorage(newState);
 		this.emitter.emit("IDENTIFY_STATE_CHANGED", newState);
@@ -165,11 +196,14 @@ export class IdentityClient {
 	 * @param fn - The function to try
 	 * @returns An {@link AsyncResult}
 	 */
-	private async tryCatch<T>(fn: () => AsyncResult<T>): AsyncResult<T> {
+	private async tryCatch<T>(fn: () => AsyncResult<T>, onError?: (error: Error) => void): AsyncResult<T> {
 		try {
 			const result = await fn();
 			return result;
 		} catch (error) {
+			if (onError) {
+				onError(error instanceof Error ? error : new Error(String(error)));
+			}
 			return {
 				success: false,
 				error: error instanceof Error ? error.message : "Unknown error",
@@ -178,17 +212,15 @@ export class IdentityClient {
 	}
 
 	async identify(persona?: Persona): AsyncResult<IdentityUser> {
+		this.logger.debug(`Identifying user with persona: ${persona?.name ?? "none"}`);
 		const previousState = this.identifyState;
 		this.setIdentifyState({ type: "identifying" });
 
 		return this.tryCatch(async () => {
+			this.logger.debug("Getting device ID...");
 			const deviceId = await this.device.getDeviceId();
 			const deviceInfo = await this.device.getDeviceInfo();
-			console.log("this.api.apiKey", this.api.apiKey);
-			console.log("this.api.orgId", this.api.orgId);
-			console.log("this.api.projectId", this.api.projectId);
-			console.log("this.api.environmentSlug", this.api.environmentSlug);
-			console.log("this.api.deviceId", deviceId);
+			this.logger.debug("Calling identify API...");
 			const response = await this.api.client("/v1/identify", {
 				method: "POST",
 				headers: {
@@ -200,20 +232,20 @@ export class IdentityClient {
 				},
 				body: {
 					persona,
+					// @ts-expect-error - notifications is not yet implemented
 					device: {
-						...deviceInfo,
-						update: deviceInfo.update
-							? {
-								...deviceInfo.update,
-								created_at: deviceInfo.update.created_at,
-							}
-							: null,
+						timestamp: deviceInfo.timestamp,
+						os: deviceInfo.os,
+						application: deviceInfo.application,
+						hardware: deviceInfo.hardware,
+						update: null,
 					},
 				},
 			});
 
+			this.logger.debug(`Identify API response received`);
 			if (response.error != null) {
-				console.log("identify error", response.error.status, response.error.value);
+				this.logger.warn("Identify API error", response.error.status, response.error.value);
 				this.setIdentifyState(previousState);
 
 				if (response.error.status === 422) {
@@ -250,6 +282,13 @@ export class IdentityClient {
 					},
 				},
 			};
+		}, (error) => {
+			this.logger.error("Error identifying user", error);
+			this.setIdentifyState(previousState);
+			return {
+				success: false,
+				error: error.message,
+			};
 		});
 	}
 }

package/src/clients/storage/adapters/async-storage.adapter.ts

@@ -0,0 +1,81 @@
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { StorageAdapter, type SupportedStorage } from "./storage.adpater-interface";
+
+
+/**
+ * Creates a SupportedStorage adapter backed by AsyncStorage.
+ *
+ * Since SupportedStorage interface is synchronous but AsyncStorage is async,
+ * this adapter uses an in-memory cache for sync access. Writes are persisted
+ * to AsyncStorage asynchronously.
+ *
+ * Call `preload()` after creation to hydrate the cache from AsyncStorage.
+ * Until hydration completes, reads return null for persisted values.
+ */
+
+export class AsyncStorageAdapter extends StorageAdapter {
+	createStorage(storageKey: string): SupportedStorage {
+		let cache: Record<string, string> = {};
+		let hydrated = false;
+
+		const prefixedKey = (key: string): string => `${storageKey}:${key}`;
+
+		return {
+			preload: () => {
+				if (hydrated) return;
+
+				// Fire async hydration - cache will be populated when complete
+				AsyncStorage.getAllKeys()
+					.then((allKeys) => {
+						const relevantKeys = allKeys.filter((k) =>
+							k.startsWith(`${storageKey}:`)
+						);
+						return AsyncStorage.multiGet(relevantKeys);
+					})
+					.then((pairs) => {
+						for (const [fullKey, value] of pairs) {
+							if (value != null) {
+								const key = fullKey.replace(`${storageKey}:`, "");
+								cache[key] = value;
+							}
+						}
+						hydrated = true;
+					})
+					.catch(() => {
+						// Silently fail - cache remains empty
+					});
+			},
+
+			getItem: (key: string): string | null => {
+				return cache[key] ?? null;
+			},
+
+			setItem: (key: string, value: string): void => {
+				cache[key] = value;
+				AsyncStorage.setItem(prefixedKey(key), value).catch(() => {
+					// Silently fail - value remains in cache
+				});
+			},
+
+			removeItem: (key: string): void => {
+				delete cache[key];
+				AsyncStorage.removeItem(prefixedKey(key)).catch(() => {
+					// Silently fail
+				});
+			},
+
+			clear: (): void => {
+				const keysToRemove = Object.keys(cache).map(prefixedKey);
+				cache = {};
+				AsyncStorage.multiRemove(keysToRemove).catch(() => {
+					// Silently fail
+				});
+			},
+
+			keys: (): string[] => {
+				return Object.keys(cache);
+			},
+		};
+	}
+
+}

package/src/clients/storage/{mmkv-adapter.ts → adapters/mmkv.adapter.ts}

@@ -1,14 +1,10 @@
-import type { SupportedStorageFactory } from "./storage.client";
 import * as MMKV from "react-native-mmkv";
+import { StorageAdapter, type SupportedStorage } from "./storage.adpater-interface";
 
-/**
- * Creates a storage factory that uses MMKV for persistence.
- * Each storage key gets its own MMKV instance.
- */
-export const createMMKVStorageFactory = (): SupportedStorageFactory => {
-	return (storageKey: string) => {
-		const storage = MMKV.createMMKV({ id: storageKey });
 
+export class MMKVStorageAdapter extends StorageAdapter {
+	createStorage(storageKey: string): SupportedStorage {
+		const storage = MMKV.createMMKV({ id: storageKey });
 		return {
 			preload: () => {
 				storage.getAllKeys();
@@ -19,5 +15,6 @@ export const createMMKVStorageFactory = (): SupportedStorageFactory => {
 			clear: () => storage.clearAll(),
 			keys: () => storage.getAllKeys(),
 		};
-	};
-};
+	}
+
+}

package/src/clients/storage/adapters/storage.adpater-interface.ts

@@ -0,0 +1,30 @@
+
+/**
+ * A storage interface that is used to store data.
+ */
+export type SupportedStorage = {
+	preload: () => void;
+	getItem: (key: string) => string | null;
+	setItem: (key: string, value: string) => void;
+	removeItem: (key: string) => void;
+	clear: () => void;
+	keys: () => string[];
+};
+
+/**
+ * An interface for a storage adapter.
+ * This interface is used to abstract the storage adapter implementation.
+ */
+export abstract class StorageAdapter {
+
+	/**
+	 * Creates a storage instance for a given storage key.
+	 * @param storageKey - The key to create the storage instance for.
+	 * @returns A storage instance.
+	 * 
+	 * We can have multiple storage instances for different purposes. Hence the storage key is used to create the storage instance.
+	 */
+	abstract createStorage(storageKey: string): SupportedStorage;
+}
+
+

package/src/clients/storage/index.ts

@@ -1 +1,2 @@
-export * from "./storage.client";
+export * from "./adapters/storage.adpater-interface";
+export * from "./storage.client";

package/src/clients/storage/storage.client.ts

@@ -1,19 +1,6 @@
 import type { Logger, LoggingClient } from "../logging";
+import type { StorageAdapter, SupportedStorage } from "./adapters/storage.adpater-interface";
 
-export type SupportedStorage = {
-  preload: () => void;
-  getItem: (key: string) => string | null;
-  setItem: (key: string, value: string) => void;
-  removeItem: (key: string) => void;
-  clear: () => void;
-  keys: () => string[];
-};
-
-export type SupportedStorageFactory = (storageKey: string) => SupportedStorage;
-
-export type StorageClientOptions = {
-  createStorage: SupportedStorageFactory;
-};
 
 export class StorageClient {
 
@@ -21,14 +8,18 @@ export class StorageClient {
 
   private readonly storage: Map<string, SupportedStorage> = new Map();
 
-  constructor(logging: LoggingClient, private readonly factory: SupportedStorageFactory) {
+  constructor(
+    logging: LoggingClient,
+    private readonly orgId: string,
+    private readonly projectId: string,
+    private readonly storageAdapter: StorageAdapter) {
     this.logger = logging.createLogger({
       name: "StorageClient",
     });
   }
 
   private createStorageKey(storageKey: string): string {
-    return `teardown:v1:${storageKey}`;
+    return `teardown:v1:${this.orgId}:${this.projectId}:${storageKey}`;
   }
 
   createStorage(storageKey: string): SupportedStorage {
@@ -48,20 +39,18 @@ export class StorageClient {
     }
 
     this.logger.debug(`Creating new storage for ${fullStorageKey}`);
-    const newStorage = this.factory(fullStorageKey);
+    const newStorage = this.storageAdapter.createStorage(fullStorageKey);
     newStorage.preload();
 
-
     const remappedStorage = {
       ...newStorage,
       clear: () => {
-        this.logger.debug(`Clearing storage for ${fullStorageKey}`);
         this.storage.delete(fullStorageKey);
       },
     }
 
     this.storage.set(fullStorageKey, remappedStorage);
-    this.logger.info(`Storage created for ${fullStorageKey}`);
+    this.logger.debug(`Storage created for ${fullStorageKey}`);
 
     return remappedStorage;
   }

package/src/clients/utils/utils.client.ts

@@ -1,6 +1,6 @@
 import type { Logger, LoggingClient } from "../logging";
+import 'react-native-get-random-values';
 import { v4 as uuidv4 } from "uuid";
-
 export class UtilsClient {
 	private readonly logger: Logger;
 
@@ -15,61 +15,5 @@ export class UtilsClient {
 		const uuid = uuidv4();
 		this.logger.debug(`Random UUID generated: ${uuid}`);
 		return uuid;
-		// this.logger.debug("Generating random UUID");
-		// // Generate a random UUID v4 (xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx)
-		// // Uses only Math.random and string manipulation, no dependencies.
-		// const hex: string[] = [];
-		// for (let i = 0; i < 256; ++i) {
-		// 	hex.push((i < 16 ? "0" : "") + i.toString(16));
-		// }
-
-		// // Seeded random number generator using mulberry32
-		// let seedValue = 0;
-		// if (seed) {
-		// 	// Simple hash function to convert seed string to number
-		// 	for (let i = 0; i < seed.length; i++) {
-		// 		seedValue = ((seedValue << 5) - seedValue + seed.charCodeAt(i)) | 0;
-		// 	}
-		// 	seedValue = Math.abs(seedValue);
-		// }
-
-		// const seededRandom = (): number => {
-		// 	seedValue = (seedValue + 0x6d2b79f5) | 0;
-		// 	let t = Math.imul(seedValue ^ (seedValue >>> 15), 1 | seedValue);
-		// 	t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
-		// 	return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-		// };
-
-		// const getRandomByte = (): number => Math.floor((seed ? seededRandom() : Math.random()) * 256);
-		// const rnds = new Array(16).fill(0).map(getRandomByte);
-
-		// // Per spec:
-		// rnds[6] = (rnds[6]! & 0x0f) | 0x40; // version 4
-		// rnds[8] = (rnds[8]! & 0x3f) | 0x80; // variant 10
-
-		// const uuid =
-		// 	hex[rnds[0]!]! +
-		// 	hex[rnds[1]!]! +
-		// 	hex[rnds[2]!]! +
-		// 	hex[rnds[3]!]! +
-		// 	"-" +
-		// 	hex[rnds[4]!]! +
-		// 	hex[rnds[5]!]! +
-		// 	"-" +
-		// 	hex[rnds[6]!]! +
-		// 	hex[rnds[7]!]! +
-		// 	"-" +
-		// 	hex[rnds[8]!]! +
-		// 	hex[rnds[9]!]! +
-		// 	"-" +
-		// 	hex[rnds[10]!]! +
-		// 	hex[rnds[11]!]! +
-		// 	hex[rnds[12]!]! +
-		// 	hex[rnds[13]!]! +
-		// 	hex[rnds[14]!]! +
-		// 	hex[rnds[15]!]!;
-
-		// this.logger.debug(`Random UUID generated: ${uuid}`);
-		// return uuid;
 	}
 }

package/src/exports/adapters/async-storage.ts

@@ -0,0 +1 @@
+export * from "../../clients/storage/adapters/async-storage.adapter";

package/src/exports/adapters/expo.ts

@@ -0,0 +1 @@
+export * from "../../clients/device/adapters/expo.adapter";

package/src/exports/adapters/mmkv.ts

@@ -0,0 +1 @@
+export * from "../../clients/storage/adapters/mmkv.adapter";

package/src/hooks/use-force-update.ts

@@ -12,7 +12,11 @@ export type UseForceUpdateResult = {
    */
   isUpdateAvailable: boolean;
   /**
-   * Whether the the current version is out of date and is forced to be updated. "force_update" - isUpdateAvailable will also be true if this is true.
+   * Whether an update is recommended for this version, but is not required.
+   */
+  isUpdateRecommended: boolean;
+  /**
+   * Whether the the current version is out of date and is forced to be updated. 
    */
   isUpdateRequired: boolean;
 };
@@ -29,10 +33,15 @@ export const useForceUpdate = (): UseForceUpdateResult => {
     return unsubscribe;
   }, [core.forceUpdate]);
 
+  const isUpdateRequired = versionStatus.type === "update_required";
+  const isUpdateRecommended = versionStatus.type === "update_recommended";
+  const isUpdateAvailable = isUpdateRequired || isUpdateRecommended || (versionStatus.type === "update_available");
+
   return {
     versionStatus,
-    isUpdateRequired: versionStatus.type === "update_required",
-    isUpdateAvailable: versionStatus.type === "update_available" || versionStatus.type === "update_required" || versionStatus.type === "update_recommended",
+    isUpdateRequired,
+    isUpdateRecommended,
+    isUpdateAvailable,
   };
 };
 

package/src/hooks/use-session.ts

@@ -13,10 +13,13 @@ export const useSession = (): UseSessionResult => {
 
   useEffect(() => {
     const unsubscribe = core.identity.onIdentifyStateChange((state) => {
-      if (state.type === "identified") {
-        setSession(state.session);
-      } else {
-        setSession(null);
+      switch (state.type) {
+        case "identified":
+          setSession(state.session);
+          break;
+        case "unidentified":
+          setSession(null);
+          break;
       }
     });
     return unsubscribe;

package/src/teardown.core.ts

@@ -2,8 +2,8 @@ import { ApiClient } from "./clients/api";
 import { DeviceClient, type DeviceClientOptions } from "./clients/device/device.client";
 import { ForceUpdateClient, type ForceUpdateClientOptions } from "./clients/force-update";
 import { IdentityClient } from "./clients/identity";
-import { type LogLevel, LoggingClient, type Logger } from "./clients/logging";
-import { StorageClient, type SupportedStorageFactory } from "./clients/storage";
+import { LoggingClient, type LogLevel, type Logger } from "./clients/logging";
+import { StorageClient, type StorageAdapter } from "./clients/storage";
 import { UtilsClient } from "./clients/utils/utils.client";
 
 export type TeardownCoreOptions = {
@@ -11,7 +11,7 @@ export type TeardownCoreOptions = {
 	project_id: string;
 	api_key: string;
 	// environment_slug: string; // TODO: add this back in
-	storageFactory: SupportedStorageFactory;
+	storageAdapter: StorageAdapter;
 	deviceAdapter: DeviceClientOptions["adapter"];
 	forceUpdate?: ForceUpdateClientOptions;
 };
@@ -30,13 +30,18 @@ export class TeardownCore {
 		this.options = options;
 
 		this.logging = new LoggingClient();
-		// this.setLogLevel("verbose");
+		this.setLogLevel("verbose");
 
 		this.logger = this.logging.createLogger({
 			name: "TeardownCore",
 		});
 		this.utils = new UtilsClient(this.logging);
-		this.storage = new StorageClient(this.logging, this.options.storageFactory);
+		this.storage = new StorageClient(
+			this.logging,
+			this.options.org_id,
+			this.options.project_id,
+			this.options.storageAdapter
+		);
 		this.api = new ApiClient(this.logging, this.storage, {
 			org_id: this.options.org_id,
 			project_id: this.options.project_id,
@@ -57,12 +62,17 @@ export class TeardownCore {
 
 		void this.initialize().catch((error) => {
 			this.logger.error("Error initializing TeardownCore", { error });
+		}).then(() => {
+			this.logger.debug("TeardownCore initialized");
 		});
 
 	}
 
 	async initialize(): Promise<void> {
+		// Initialize identity first (loads from storage, then identifies if needed)
 		await this.identity.initialize();
+		// Then initialize force update (subscribes to identity events)
+		this.forceUpdate.initialize();
 	}
 
 	setLogLevel(level: LogLevel): void {
@@ -70,7 +80,7 @@ export class TeardownCore {
 	}
 
 	shutdown(): void {
-		this.logger.info("Shutting down TeardownCore");
+		this.logger.debug("Shutting down TeardownCore");
 		this.storage.shutdown();
 	}
 }

package/src/exports/expo.ts

@@ -1 +0,0 @@
-export * from "../clients/device/expo-adapter";

package/src/exports/mmkv.ts

@@ -1 +0,0 @@
-export * from "../clients/storage/mmkv-adapter";