@teardown/react-native 1.2.39 → 2.0.1

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

@@ -0,0 +1,454 @@
+import { describe, expect, mock, test } from "bun:test";
+
+// Mock react-native before any imports that use it
+mock.module("react-native", () => ({
+	AppState: {
+		addEventListener: () => ({ remove: () => {} }),
+	},
+}));
+
+// Import after mock
+const { IdentityClient } = await import("./identity.client");
+const { IdentifyVersionStatusEnum } = await import("../force-update");
+type IdentifyState = import("./identity.client").IdentifyState;
+
+function createMockLoggingClient() {
+	return {
+		createLogger: () => ({
+			info: () => {},
+			warn: () => {},
+			error: () => {},
+			debug: () => {},
+		}),
+	};
+}
+
+function createMockStorageClient() {
+	const storage = new Map<string, string>();
+	return {
+		createStorage: () => ({
+			getItem: (key: string) => storage.get(key) ?? null,
+			setItem: (key: string, value: string) => storage.set(key, value),
+			removeItem: (key: string) => storage.delete(key),
+		}),
+		getStorage: () => storage,
+	};
+}
+
+function createMockUtilsClient() {
+	return {
+		generateRandomUUID: async () => "mock-uuid",
+	};
+}
+
+function createMockDeviceClient() {
+	return {
+		getDeviceId: async () => "mock-device-id",
+		getDeviceInfo: async () => ({
+			application: { name: "TestApp", version: "1.0.0", build: "100", bundle_id: "com.test" },
+			hardware: { brand: "Apple", model: "iPhone", device_type: "PHONE" },
+			os: { name: "iOS", version: "17.0" },
+			notifications: { push_token: null, platform: null },
+			update: null,
+		}),
+	};
+}
+
+function createMockApiClient(options: {
+	success?: boolean;
+	versionStatus?: IdentifyVersionStatusEnum;
+	errorStatus?: number;
+	errorMessage?: string;
+} = {}) {
+	const { success = true, versionStatus = IdentifyVersionStatusEnum.UP_TO_DATE, errorStatus, errorMessage } = options;
+
+	return {
+		apiKey: "test-api-key",
+		orgId: "test-org-id",
+		projectId: "test-project-id",
+		client: async () => {
+			if (!success) {
+				return {
+					error: {
+						status: errorStatus ?? 500,
+						value: { message: errorMessage ?? "API Error", error: { message: errorMessage ?? "API Error" } },
+					},
+					data: null,
+				};
+			}
+			return {
+				error: null,
+				data: {
+					data: {
+						session_id: "session-123",
+						device_id: "device-123",
+						persona_id: "persona-123",
+						token: "token-123",
+						version_info: { status: versionStatus },
+					},
+				},
+			};
+		},
+	};
+}
+
+describe("IdentityClient", () => {
+	describe("initial state", () => {
+		test("starts with unidentified state when no stored state", () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockApi = createMockApiClient();
+			const mockDevice = createMockDeviceClient();
+
+			const client = new IdentityClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				mockApi as never,
+				mockDevice as never
+			);
+
+			expect(client.getIdentifyState().type).toBe("unidentified");
+		});
+
+		test("restores state from storage", () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockApi = createMockApiClient();
+			const mockDevice = createMockDeviceClient();
+
+			// Pre-populate storage with identified state
+			const storedState = {
+				type: "identified",
+				session: { session_id: "s1", device_id: "d1", persona_id: "p1", token: "t1" },
+				version_info: { status: IdentifyVersionStatusEnum.UP_TO_DATE, update: null },
+			};
+			mockStorage.getStorage().set("IDENTIFY_STATE", JSON.stringify(storedState));
+
+			const client = new IdentityClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				mockApi as never,
+				mockDevice as never
+			);
+
+			const state = client.getIdentifyState();
+			expect(state.type).toBe("identified");
+			if (state.type === "identified") {
+				expect(state.session.session_id).toBe("s1");
+			}
+		});
+	});
+
+	describe("identify", () => {
+		test("transitions to identifying then identified on success", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockApi = createMockApiClient({ success: true });
+			const mockDevice = createMockDeviceClient();
+
+			const client = new IdentityClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				mockApi as never,
+				mockDevice as never
+			);
+
+			const stateChanges: IdentifyState[] = [];
+			client.onIdentifyStateChange((state) => stateChanges.push(state));
+
+			const result = await client.identify();
+
+			expect(result.success).toBe(true);
+			expect(stateChanges).toHaveLength(2);
+			expect(stateChanges[0].type).toBe("identifying");
+			expect(stateChanges[1].type).toBe("identified");
+		});
+
+		test("returns user data on successful identify", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockApi = createMockApiClient({ versionStatus: IdentifyVersionStatusEnum.UPDATE_AVAILABLE });
+			const mockDevice = createMockDeviceClient();
+
+			const client = new IdentityClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				mockApi as never,
+				mockDevice as never
+			);
+
+			const result = await client.identify();
+
+			expect(result.success).toBe(true);
+			if (result.success) {
+				expect(result.data.session_id).toBe("session-123");
+				expect(result.data.device_id).toBe("device-123");
+				expect(result.data.version_info.status).toBe(IdentifyVersionStatusEnum.UPDATE_AVAILABLE);
+			}
+		});
+
+		test("reverts to previous state on API error", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockApi = createMockApiClient({ success: false, errorStatus: 500, errorMessage: "Server error" });
+			const mockDevice = createMockDeviceClient();
+
+			const client = new IdentityClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				mockApi as never,
+				mockDevice as never
+			);
+
+			const result = await client.identify();
+
+			expect(result.success).toBe(false);
+			// Should revert to unidentified (the previous state)
+			expect(client.getIdentifyState().type).toBe("unidentified");
+		});
+
+		test("handles 422 validation error", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockApi = createMockApiClient({ success: false, errorStatus: 422, errorMessage: "Validation failed" });
+			const mockDevice = createMockDeviceClient();
+
+			const client = new IdentityClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				mockApi as never,
+				mockDevice as never
+			);
+
+			const result = await client.identify();
+
+			expect(result.success).toBe(false);
+			if (!result.success) {
+				expect(result.error).toBe("Validation failed");
+			}
+		});
+
+		test("persists identified state to storage", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockApi = createMockApiClient({ success: true });
+			const mockDevice = createMockDeviceClient();
+
+			const client = new IdentityClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				mockApi as never,
+				mockDevice as never
+			);
+
+			await client.identify();
+
+			const stored = mockStorage.getStorage().get("IDENTIFY_STATE");
+			expect(stored).toBeDefined();
+			const parsed = JSON.parse(stored!);
+			expect(parsed.type).toBe("identified");
+			expect(parsed.session.session_id).toBe("session-123");
+		});
+	});
+
+	describe("onIdentifyStateChange", () => {
+		test("emits state changes to listeners", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockApi = createMockApiClient();
+			const mockDevice = createMockDeviceClient();
+
+			const client = new IdentityClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				mockApi as never,
+				mockDevice as never
+			);
+
+			const states: IdentifyState[] = [];
+			client.onIdentifyStateChange((state) => states.push(state));
+
+			await client.identify();
+
+			expect(states.length).toBeGreaterThan(0);
+		});
+
+		test("returns unsubscribe function", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockApi = createMockApiClient();
+			const mockDevice = createMockDeviceClient();
+
+			const client = new IdentityClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				mockApi as never,
+				mockDevice as never
+			);
+
+			const states: IdentifyState[] = [];
+			const unsubscribe = client.onIdentifyStateChange((state) => states.push(state));
+
+			unsubscribe();
+
+			await client.identify();
+
+			// Should not receive any state changes after unsubscribing
+			expect(states).toHaveLength(0);
+		});
+	});
+
+	describe("refresh", () => {
+		test("returns error when not identified", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockApi = createMockApiClient();
+			const mockDevice = createMockDeviceClient();
+
+			const client = new IdentityClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				mockApi as never,
+				mockDevice as never
+			);
+
+			const result = await client.refresh();
+
+			expect(result.success).toBe(false);
+			if (!result.success) {
+				expect(result.error).toBe("Not identified");
+			}
+		});
+
+		test("re-identifies when already identified", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockApi = createMockApiClient();
+			const mockDevice = createMockDeviceClient();
+
+			const client = new IdentityClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				mockApi as never,
+				mockDevice as never
+			);
+
+			// First identify
+			await client.identify();
+			expect(client.getIdentifyState().type).toBe("identified");
+
+			// Then refresh
+			const result = await client.refresh();
+			expect(result.success).toBe(true);
+		});
+	});
+
+	describe("reset", () => {
+		test("resets state to unidentified", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockApi = createMockApiClient();
+			const mockDevice = createMockDeviceClient();
+
+			const client = new IdentityClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				mockApi as never,
+				mockDevice as never
+			);
+
+			// First identify
+			await client.identify();
+			expect(client.getIdentifyState().type).toBe("identified");
+
+			// Then reset
+			client.reset();
+
+			expect(client.getIdentifyState().type).toBe("unidentified");
+			// Storage contains unidentified state after reset (setIdentifyState saves it)
+			const stored = mockStorage.getStorage().get("IDENTIFY_STATE");
+			expect(stored).toBeDefined();
+			if (stored) {
+				expect(JSON.parse(stored).type).toBe("unidentified");
+			}
+		});
+
+		test("emits unidentified state on reset", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockApi = createMockApiClient();
+			const mockDevice = createMockDeviceClient();
+
+			const client = new IdentityClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				mockApi as never,
+				mockDevice as never
+			);
+
+			await client.identify();
+
+			const states: IdentifyState[] = [];
+			client.onIdentifyStateChange((state) => states.push(state));
+
+			client.reset();
+
+			expect(states).toHaveLength(1);
+			expect(states[0].type).toBe("unidentified");
+		});
+	});
+
+	describe("shutdown", () => {
+		test("removes all listeners", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockApi = createMockApiClient();
+			const mockDevice = createMockDeviceClient();
+
+			const client = new IdentityClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				mockApi as never,
+				mockDevice as never
+			);
+
+			const states: IdentifyState[] = [];
+			client.onIdentifyStateChange((state) => states.push(state));
+
+			client.shutdown();
+
+			await client.identify();
+
+			// Should not receive any state changes after shutdown
+			expect(states).toHaveLength(0);
+		});
+	});
+});

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

@@ -0,0 +1,255 @@
+import type { AsyncResult } from "@teardown/types";
+import { EventEmitter } from "eventemitter3";
+import { z } from "zod";
+import type { ApiClient } from "../api";
+import type { DeviceClient } from "../device/device.client";
+import { IdentifyVersionStatusEnum } from "../force-update";
+import type { Logger, LoggingClient } from "../logging";
+import type { StorageClient, SupportedStorage } from "../storage";
+import type { UtilsClient } from "../utils";
+
+export type Persona = {
+	name?: string | undefined;
+	user_id?: string | undefined;
+	email?: string | undefined;
+};
+
+export type IdentityUser = {
+	session_id: string;
+	device_id: string;
+	persona_id: string;
+	token: string;
+	version_info: {
+		status: IdentifyVersionStatusEnum;
+		update: null
+	}
+}
+
+export const UnidentifiedSessionStateSchema = z.object({
+	type: z.literal("unidentified"),
+});
+export const IdentifyingSessionStateSchema = z.object({
+	type: z.literal("identifying"),
+});
+
+
+export const UpdateVersionStatusBodySchema = z.object({
+	version: z.string(),
+});
+
+export const SessionSchema = z.object({
+	session_id: z.string(),
+	device_id: z.string(),
+	persona_id: z.string(),
+	token: z.string(),
+});
+export type Session = z.infer<typeof SessionSchema>;
+
+export const VersionStatusResponseSchema = z.object({
+	status: z.enum(["UPDATE_AVAILABLE", "UPDATE_REQUIRED", "UP_TO_DATE"]),
+	latest_version: z.string().optional(),
+});
+
+export const IdentifiedSessionStateSchema = z.object({
+	type: z.literal("identified"),
+	session: SessionSchema,
+	version_info: z.object({
+		status: z.enum(IdentifyVersionStatusEnum),
+		update: z.null(),
+	}),
+});
+
+export const IdentifyStateSchema = z.discriminatedUnion("type", [UnidentifiedSessionStateSchema, IdentifyingSessionStateSchema, IdentifiedSessionStateSchema]);
+export type IdentifyState = z.infer<typeof IdentifyStateSchema>;
+
+export type UnidentifiedSessionState = z.infer<typeof UnidentifiedSessionStateSchema>;
+export type IdentifyingSessionState = z.infer<typeof IdentifyingSessionStateSchema>;
+export type IdentifiedSessionState = z.infer<typeof IdentifiedSessionStateSchema>;
+
+export type IdentifyStateChangeEvents = {
+	IDENTIFY_STATE_CHANGED: (state: IdentifyState) => void;
+};
+
+
+export const IDENTIFY_STORAGE_KEY = "IDENTIFY_STATE";
+
+export class IdentityClient {
+	private emitter = new EventEmitter<IdentifyStateChangeEvents>();
+	private identifyState: IdentifyState;
+
+	public readonly logger: Logger;
+	public readonly utils: UtilsClient;
+	public readonly storage: SupportedStorage;
+
+	constructor(
+		logging: LoggingClient,
+		utils: UtilsClient,
+		storage: StorageClient,
+		private readonly api: ApiClient,
+		private readonly device: DeviceClient
+	) {
+		this.logger = logging.createLogger({
+			name: "IdentityClient",
+		});
+		this.storage = storage.createStorage("identity");
+		this.utils = utils;
+		this.identifyState = this.getIdentifyStateFromStorage();
+	}
+
+	async initialize(): Promise<void> {
+		await this.identify();
+	}
+
+	private getIdentifyStateFromStorage(): IdentifyState {
+		const stored = this.storage.getItem(IDENTIFY_STORAGE_KEY);
+		if (stored == null) {
+			// console.log("no stored session state");
+			return UnidentifiedSessionStateSchema.parse({ type: "unidentified" });
+		}
+
+		// console.log("stored session state", stored);
+		return IdentifyStateSchema.parse(JSON.parse(stored));
+	}
+
+	private saveIdentifyStateToStorage(identifyState: IdentifyState): void {
+		this.storage.setItem(IDENTIFY_STORAGE_KEY, JSON.stringify(identifyState));
+	}
+
+	private setIdentifyState(newState: IdentifyState): void {
+		this.logger.info(`Identify state: ${this.identifyState.type} -> ${newState.type}`);
+		this.identifyState = newState;
+		this.saveIdentifyStateToStorage(newState);
+		this.emitter.emit("IDENTIFY_STATE_CHANGED", newState);
+	}
+
+	public onIdentifyStateChange(listener: (state: IdentifyState) => void) {
+		this.emitter.addListener("IDENTIFY_STATE_CHANGED", listener);
+		return () => {
+			this.emitter.removeListener("IDENTIFY_STATE_CHANGED", listener);
+		};
+	}
+
+	public getIdentifyState(): IdentifyState {
+		return this.identifyState;
+	}
+
+	public getSessionState(): Session | null {
+		if (this.identifyState.type !== "identified") {
+			return null;
+		}
+		return this.identifyState.session;
+	}
+
+	public shutdown() {
+		this.emitter.removeAllListeners("IDENTIFY_STATE_CHANGED");
+	}
+
+	public reset() {
+		this.storage.removeItem(IDENTIFY_STORAGE_KEY);
+		this.setIdentifyState({ type: "unidentified" });
+	}
+
+	/**
+	 * Re-identify the current persona to refresh session data.
+	 * Only works if already identified.
+	 */
+	async refresh(): AsyncResult<IdentityUser> {
+		if (this.identifyState.type !== "identified") {
+			return { success: false, error: "Not identified" };
+		}
+		return this.identify();
+	}
+
+	/**
+	 * Catches all errors and returns an AsyncResult
+	 * @param fn - The function to try
+	 * @returns An {@link AsyncResult}
+	 */
+	private async tryCatch<T>(fn: () => AsyncResult<T>): AsyncResult<T> {
+		try {
+			const result = await fn();
+			return result;
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Unknown error",
+			};
+		}
+	}
+
+	async identify(persona?: Persona): AsyncResult<IdentityUser> {
+		const previousState = this.identifyState;
+		this.setIdentifyState({ type: "identifying" });
+
+		return this.tryCatch(async () => {
+			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);
+			const response = await this.api.client("/v1/identify", {
+				method: "POST",
+				headers: {
+					"td-api-key": this.api.apiKey,
+					"td-org-id": this.api.orgId,
+					"td-project-id": this.api.projectId,
+					"td-environment-slug": "production",
+					"td-device-id": deviceId,
+				},
+				body: {
+					persona,
+					device: {
+						...deviceInfo,
+						update: deviceInfo.update
+							? {
+								...deviceInfo.update,
+								created_at: deviceInfo.update.created_at,
+							}
+							: null,
+					},
+				},
+			});
+
+			if (response.error != null) {
+				console.log("identify error", response.error.status, response.error.value);
+				this.setIdentifyState(previousState);
+
+				if (response.error.status === 422) {
+					this.logger.warn("422 Error identifying user", response.error.value);
+					return {
+						success: false,
+						error: response.error.value.message ?? "Unknown error",
+					};
+				}
+
+				const value = response.error.value;
+				return {
+					success: false,
+					error: value?.error?.message ?? "Unknown error",
+				};
+			}
+
+			this.setIdentifyState({
+				type: "identified",
+				session: response.data.data,
+				version_info: {
+					status: response.data.data.version_info.status,
+					update: null,
+				},
+			});
+
+			return {
+				success: true,
+				data: {
+					...response.data.data,
+					version_info: {
+						status: response.data.data.version_info.status,
+						update: null,
+					},
+				},
+			};
+		});
+	}
+}

package/src/clients/identity/index.ts

@@ -0,0 +1 @@
+export * from "./identity.client";

package/src/clients/logging/index.ts

@@ -0,0 +1 @@
+export * from "./logging.client";