@teardown/react-native 2.0.18 → 2.0.22

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@teardown/react-native",
-	"version": "2.0.18",
+	"version": "2.0.22",
 	"private": false,
 	"publishConfig": {
 		"access": "public"

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

@@ -39,7 +39,7 @@ export const UpdateVersionStatusBodySchema = z.object({
 export const SessionSchema = z.object({
 	session_id: z.string(),
 	device_id: z.string(),
-	user_id: z.string(),
+	user_id: z.string().or(z.object({ persona_id: z.string() }).transform((val) => val.persona_id)),
 	token: z.string(),
 });
 export type Session = z.infer<typeof SessionSchema>;
@@ -113,7 +113,7 @@ export class IdentityClient {
 			this.logger.debug(`Initialized with state: ${this.identifyState.type}`);
 		} catch (error) {
 			// Silently fail on errors - we'll re-identify on app boot if needed
-			this.logger.debug("Error initializing IdentityClient", { error });
+			this.logger.debugError("Error initializing IdentityClient", { error });
 			this.identifyState = { type: "unidentified" };
 		}
 
@@ -122,26 +122,31 @@ export class IdentityClient {
 	}
 
 	private getIdentifyStateFromStorage(): IdentifyState {
-		const stored = this.storage.getItem(IDENTIFY_STORAGE_KEY);
+		try {
+			const stored = this.storage.getItem(IDENTIFY_STORAGE_KEY);
 
-		if (stored == null) {
-			this.logger.debug("No stored identity state, returning unidentified");
-			return UnidentifiedSessionStateSchema.parse({ type: "unidentified" });
-		}
+			if (stored == null) {
+				this.logger.debugInfo("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}`);
+			const parsed = IdentifyStateSchema.parse(JSON.parse(stored));
+			this.logger.debugInfo(`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" });
-		}
+			// "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.debugInfo("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" });
+			}
 
-		return parsed;
+			return parsed;
+		} catch (error) {
+			this.logger.debugError("Error getting identify state from storage", { error });
+			return { type: "unidentified" };
+		}
 	}
 
 	private saveIdentifyStateToStorage(identifyState: IdentifyState): void {
@@ -150,11 +155,11 @@ export class IdentityClient {
 
 	private setIdentifyState(newState: IdentifyState): void {
 		if (this.identifyState.type === newState.type) {
-			this.logger.debug(`Identify state already set: ${this.identifyState.type}`);
+			this.logger.debugInfo(`Identify state already set: ${this.identifyState.type}`);
 			return;
 		}
 
-		this.logger.debug(`Identify state: ${this.identifyState.type} -> ${newState.type}`);
+		this.logger.debugInfo(`Identify state: ${this.identifyState.type} -> ${newState.type}`);
 		this.identifyState = newState;
 		this.saveIdentifyStateToStorage(newState);
 		this.emitter.emit("IDENTIFY_STATE_CHANGED", newState);
@@ -219,7 +224,7 @@ export class IdentityClient {
 	}
 
 	async identify(user?: Persona): AsyncResult<IdentityUser> {
-		this.logger.debug(`Identifying user with persona: ${user?.name ?? "none"}`);
+		this.logger.debugInfo(`Identifying user with persona: ${user?.name ?? "none"}`);
 		const previousState = this.identifyState;
 		this.setIdentifyState({ type: "identifying" });
 
@@ -250,7 +255,7 @@ export class IdentityClient {
 					},
 				});
 
-				this.logger.debug(`Identify API response received`);
+				this.logger.debugInfo(`Identify API response received`);
 				if (response.error != null) {
 					this.logger.warn("Identify API error", response.error.status, response.error.value);
 					this.setIdentifyState(previousState);

package/src/clients/logging/logging.client.ts

@@ -54,12 +54,16 @@ export class Logger {
 	private boundConsole = {
 		log: console.log.bind(console),
 		error: console.error.bind(console),
-		debug: console.debug.bind(console),
 		warn: console.warn.bind(console),
 		trace: console.trace.bind(console),
+		debug: console.debug.bind(console),
+		debugError: console.debug.bind(console, "Error: "),
+		debugWarn: console.debug.bind(console, "Warning: "),
+		debugInfo: console.debug.bind(console, "Info: "),
+		debugVerbose: console.debug.bind(console, "Verbose: "),
 	};
 
-	constructor(private readonly options: LoggerOptions) { }
+	constructor(private readonly options: LoggerOptions) {}
 
 	get prefix() {
 		return `[Teardown:${this.options.name}]`;
@@ -75,11 +79,6 @@ export class Logger {
 		this.boundConsole.error(`${this.prefix} ${message}`, ...args);
 	}
 
-	debug(message: string, ...args: unknown[]) {
-		if (!this.options.loggingClient.shouldLog("verbose")) return;
-		this.boundConsole.debug(`${this.prefix} ${message}`, ...args);
-	}
-
 	warn(message: string, ...args: unknown[]) {
 		if (!this.options.loggingClient.shouldLog("warn")) return;
 		this.boundConsole.warn(`${this.prefix} ${message}`, ...args);
@@ -89,4 +88,29 @@ export class Logger {
 		if (!this.options.loggingClient.shouldLog("verbose")) return;
 		this.boundConsole.trace(`${this.prefix} ${message}`, ...args);
 	}
+
+	debug(message: string, ...args: unknown[]) {
+		if (!this.options.loggingClient.shouldLog("verbose")) return;
+		this.boundConsole.debug(`${this.prefix} ${message}`, ...args);
+	}
+
+	debugError(message: string, ...args: unknown[]) {
+		if (!this.options.loggingClient.shouldLog("verbose")) return;
+		this.boundConsole.debugError(`${this.prefix} ${message}`, ...args);
+	}
+
+	debugWarn(message: string, ...args: unknown[]) {
+		if (!this.options.loggingClient.shouldLog("verbose")) return;
+		this.boundConsole.debugWarn(`${this.prefix} ${message}`, ...args);
+	}
+
+	debugInfo(message: string, ...args: unknown[]) {
+		if (!this.options.loggingClient.shouldLog("verbose")) return;
+		this.boundConsole.debugInfo(`${this.prefix} ${message}`, ...args);
+	}
+
+	debugVerbose(message: string, ...args: unknown[]) {
+		if (!this.options.loggingClient.shouldLog("verbose")) return;
+		this.boundConsole.debugVerbose(`${this.prefix} ${message}`, ...args);
+	}
 }

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

@@ -1,80 +1,72 @@
 import type { Logger, LoggingClient } from "../logging";
 import type { StorageAdapter, SupportedStorage } from "./adapters/storage.adpater-interface";
 
-
 export class StorageClient {
-
-  private readonly logger: Logger;
-
-  private readonly storage: Map<string, SupportedStorage> = new Map();
-
-  private readonly preloadPromises: Promise<void>[] = [];
-
-  private _isReady = false;
-
-  get isReady(): boolean {
-    return this._isReady;
-  }
-
-  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:${this.orgId}:${this.projectId}:${storageKey}`;
-  }
-
-  createStorage(storageKey: string): SupportedStorage {
-    const fullStorageKey = this.createStorageKey(storageKey);
-
-    this.logger.debug(`Creating storage for ${fullStorageKey}`);
-    if (this.storage.has(fullStorageKey)) {
-      this.logger.debug(`Storage already exists for ${fullStorageKey}`);
-      const existingStorage = this.storage.get(fullStorageKey);
-
-      if (existingStorage != null) {
-        this.logger.debug(`Returning existing storage for ${fullStorageKey}`);
-        return existingStorage;
-      }
-
-      this.logger.error(`Existing storage was found for ${fullStorageKey}, but it was null`);
-    }
-
-    this.logger.debug(`Creating new storage for ${fullStorageKey}`);
-    const newStorage = this.storageAdapter.createStorage(fullStorageKey);
-    const preloadResult = newStorage.preload();
-    if (preloadResult instanceof Promise) {
-      this.preloadPromises.push(preloadResult);
-    }
-
-    const remappedStorage = {
-      ...newStorage,
-      clear: () => {
-        this.storage.delete(fullStorageKey);
-      },
-    }
-
-    this.storage.set(fullStorageKey, remappedStorage);
-    this.logger.debug(`Storage created for ${fullStorageKey}`);
-
-    return remappedStorage;
-  }
-
-  async whenReady(): Promise<void> {
-    await Promise.all(this.preloadPromises);
-    this._isReady = true;
-  }
-
-  shutdown(): void {
-    this.storage.forEach((storage) => {
-      storage.clear();
-    });
-    this.storage.clear();
-  }
-}
+	private readonly logger: Logger;
+
+	private readonly storage: Map<string, SupportedStorage> = new Map();
+
+	private readonly preloadPromises: Promise<void>[] = [];
+
+	private _isReady = false;
+
+	get isReady(): boolean {
+		return this._isReady;
+	}
+
+	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:${this.orgId}:${this.projectId}:${storageKey}`;
+	}
+
+	createStorage(storageKey: string): SupportedStorage {
+		const fullStorageKey = this.createStorageKey(storageKey);
+
+		this.logger.debug(`Creating storage for ${fullStorageKey}`);
+		if (this.storage.has(fullStorageKey)) {
+			this.logger.debug(`Storage already exists for ${fullStorageKey}`);
+			const existingStorage = this.storage.get(fullStorageKey);
+
+			if (existingStorage != null) {
+				this.logger.debug(`Returning existing storage for ${fullStorageKey}`);
+				return existingStorage;
+			}
+
+			this.logger.error(`Existing storage was found for ${fullStorageKey}, but it was null`);
+		}
+
+		this.logger.debug(`Creating new storage for ${fullStorageKey}`);
+		const newStorage = this.storageAdapter.createStorage(fullStorageKey);
+		const preloadResult = newStorage.preload();
+		if (preloadResult instanceof Promise) {
+			this.preloadPromises.push(preloadResult);
+		}
+
+		const remappedStorage = {
+			...newStorage,
+			clear: () => {
+				this.storage.delete(fullStorageKey);
+			},
+		};
+
+		this.storage.set(fullStorageKey, remappedStorage);
+		this.logger.debug(`Storage created for ${fullStorageKey}`);
+
+		return remappedStorage;
+	}
+
+	async whenReady(): Promise<void> {
+		await Promise.all(this.preloadPromises);
+		this._isReady = true;
+	}
+}

package/src/teardown.core.ts

@@ -85,6 +85,5 @@ export class TeardownCore {
 
 	shutdown(): void {
 		this.logger.debug("Shutting down TeardownCore");
-		this.storage.shutdown();
 	}
 }