@teardown/react-native 2.0.17 → 2.0.19

package/package.json

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

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

@@ -107,35 +107,46 @@ export class IdentityClient {
 		}
 		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}`);
+		try {
+			// Load state from storage first (for fallback if identify fails)
+			this.identifyState = this.getIdentifyStateFromStorage();
+			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.debugError("Error initializing IdentityClient", { error });
+			this.identifyState = { type: "unidentified" };
+		}
 
 		// Always identify on app boot to refresh version status
 		await this.identify();
 	}
 
 	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 {
@@ -144,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);
@@ -213,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" });
 
@@ -244,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);
+	}
 }