@teardown/react-native 1.2.38 → 2.0.0

package/README.md

@@ -1,20 +1,88 @@
+# @teardown/react-native
 
+Comprehensive SDK for managing device identity, force updates, logging, and analytics in React Native and Expo applications.
 
+## Features
 
+- 🔐 **Device & User Identity** - Unique device fingerprinting and user session management
+- 🔄 **Force Updates** - Automatic version checking with optional or required update flows
+- 📱 **Device Information** - Comprehensive device, OS, and app information collection
+- 💾 **Storage** - Namespaced persistent storage with platform adapters
+- 📝 **Logging** - Structured logging system with debug modes
+- ⚡ **Performance** - Optimized with caching, throttling, and efficient state management
+- 🎯 **Type Safety** - Full TypeScript support with runtime validation
 
-
-To get started:
+## Installation
 
 ```bash
-yarn add react-native-gesture-handler @teardown/react-native
+bun add @teardown/react-native
 ```
 
-If you're using CocoaPods you need to install pods:
+### Peer Dependencies
 
 ```bash
-cd ios && pod install
+bun add react react-native zod
+bun add expo-application expo-device expo-updates
+bun add react-native-device-info
+```
+
+## Quick Start
+
+```tsx
+import { TeardownCore, TeardownProvider, useTeardown } from '@teardown/react-native';
+
+// Initialize
+const teardown = new TeardownCore({
+  api: {
+    api_key: 'your-api-key',
+    org_id: 'your-org-id',
+    project_id: 'your-project-id',
+    environment_slug: 'production',
+  },
+  storage: { /* ... */ },
+  device: { /* ... */ },
+  identity: { identifyOnLoad: true },
+});
 
-or
+// Wrap your app
+export default function App() {
+  return (
+    <TeardownProvider core={teardown}>
+      <YourApp />
+    </TeardownProvider>
+  );
+}
 
-npx pod-install
+// Use in components
+function YourComponent() {
+  const { core } = useTeardown();
+  
+  const handleLogin = async () => {
+    await core.identity.identify({
+      user_id: 'user-123',
+      email: 'user@example.com',
+    });
+  };
+  
+  return <Button onPress={handleLogin} />;
+}
 ```
+
+## Documentation
+
+Complete documentation is available in the [docs](./docs) folder:
+
+- [Getting Started](./docs/01-getting-started.mdx) - Installation and setup
+- [Core Concepts](./docs/02-core-concepts.mdx) - Architecture overview
+- [Identity & Authentication](./docs/03-identity.mdx) - User session management
+- [Force Updates](./docs/04-force-updates.mdx) - Version management
+- [Device Information](./docs/05-device-info.mdx) - Device data collection
+- [Storage](./docs/06-storage.mdx) - Persistent storage
+- [Logging](./docs/06-logging.mdx) - Structured logging
+- [API Reference](./docs/07-api-reference.mdx) - Complete API docs
+- [Hooks Reference](./docs/08-hooks-reference.mdx) - React hooks
+- [Advanced Usage](./docs/09-advanced.mdx) - Advanced patterns
+
+## License
+
+Proprietary - See LICENSE file for details

package/package.json

@@ -1,49 +1,67 @@
 {
-  "name": "@teardown/react-native",
-  "version": "1.2.38",
-  "description": "",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc",
-    "dev": "tsc --watch"
-  },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "README.md",
-    "dist/**/*"
-  ],
-  "dependencies": {
-    "@react-native/dev-middleware": "^0.76.1",
-    "@teardown/cli": "^1.2.20",
-    "@teardown/logger": "1.2.38",
-    "@teardown/util": "1.2.38",
-    "@teardown/websocket": "1.2.38",
-    "async-mutex": "^0.5.0",
-    "chalk": "^5.3.0",
-    "compression": "^1.7.5",
-    "connect": "^3.7.0",
-    "debug": "^4.3.7",
-    "pretty-format": "^29.7.0",
-    "ws": "^8.18.0"
-  },
-  "devDependencies": {
-    "@teardown/config": "1.2.38",
-    "@types/compression": "^1.7.5",
-    "@types/connect": "^3.4.38",
-    "@types/react": "^18.3.12",
-    "@types/react-native": "^0.73.0",
-    "metro-config": "^0.81.0",
-    "react": "^18.3.1",
-    "react-native": "^0.75.4",
-    "react-native-device-info": "^14.0.0",
-    "react-native-gesture-handler": "^2.20.2",
-    "typescript": "^5.6.3"
-  },
-  "peerDependencies": {
-    "react": "^18",
-    "react-native": "^0.75",
-    "react-native-device-info": "^14",
-    "react-native-gesture-handler": "^2"
-  }
+	"name": "@teardown/react-native",
+	"version": "2.0.0",
+	"private": false,
+	"publishConfig": {
+		"access": "public"
+	},
+	"files": [
+		"src/**/*",
+		"docs/**/*"
+	],
+	"main": "./src/exports/index.ts",
+	"module": "./src/exports/index.ts",
+	"types": "./src/exports/index.ts",
+	"exports": {
+		".": {
+			"types": "./src/exports/index.ts",
+			"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"
+		},
+		"./mmkv": {
+			"types": "./src/exports/mmkv.ts",
+			"import": "./src/exports/mmkv.ts",
+			"default": "./src/exports/mmkv.ts"
+		}
+	},
+	"scripts": {
+		"build": "tsc --project ./tsconfig.json",
+		"dev": "bun run build && tsc --watch --project ./tsconfig.json",
+		"typecheck": "tsc --noEmit --project ./tsconfig.json",
+		"lint": "biome lint --write",
+		"fmt": "biome format --write",
+		"test": "bun test",
+		"prepublishOnly": "bun run build",
+		"nuke": "cd ../../ && bun run nuke"
+	},
+	"dependencies": {
+		"@teardown/ingest-api": "0.1.36",
+		"@teardown/schemas": "0.1.36",
+		"@teardown/types": "0.1.36",
+		"eventemitter3": "^5.0.1",
+		"uuid": "^13.0.0"
+	},
+	"devDependencies": {
+		"@elysiajs/eden": "^1.4.5",
+		"@teardown/tsconfig": "1.0.0",
+		"@types/bun": "latest",
+		"@types/react": "*",
+		"@types/uuid": "^11.0.0",
+		"expo-updates": "^29.0.12"
+	},
+	"peerDependencies": {
+		"react": "*",
+		"react-native": "*",
+		"typescript": "*",
+		"expo-application": "^7.0",
+		"expo-device": "^8.0",
+		"expo-notifications": "^0.29",
+		"react-native-mmkv": "^3.0",
+		"zod": "^4"
+	}
 }

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

@@ -0,0 +1,55 @@
+import * 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 };
+
+const TEARDOWN_INGEST_URL = "http://localhost:4880";
+const TEARDOWN_API_KEY_HEADER = "td-api-key";
+const TEARDOWN_ORG_ID_HEADER = "td-org-id";
+const TEARDOWN_PROJECT_ID_HEADER = "td-project-id";
+const TEARDOWN_ENVIRONMENT_SLUG_HEADER = "td-environment-slug";
+
+export type ApiClientOptions = {
+	api_key: string;
+	org_id: string;
+	project_id: string;
+	environment_slug: string;
+	onRequest?: (endpoint: IngestApi.Endpoints, options: IngestApi.RequestOptions) => Promise<IngestApi.RequestOptions>;
+};
+
+export class ApiClient {
+	public client: IngestApi.Client;
+
+	constructor(
+		_logging: LoggingClient,
+		_storage: StorageClient,
+		private readonly options: ApiClientOptions
+	) {
+		this.client = IngestApi.client(TEARDOWN_INGEST_URL, {
+			headers: {
+				[TEARDOWN_API_KEY_HEADER]: `Bearer ${this.options.api_key}`,
+				[TEARDOWN_ORG_ID_HEADER]: this.options.org_id,
+				[TEARDOWN_PROJECT_ID_HEADER]: this.options.project_id,
+				[TEARDOWN_ENVIRONMENT_SLUG_HEADER]: this.options.environment_slug,
+			},
+		});
+	}
+
+	get orgId(): string {
+		return this.options.org_id;
+	}
+
+	get projectId(): string {
+		return this.options.project_id;
+	}
+
+	get apiKey(): string {
+		return this.options.api_key;
+	}
+
+	get environmentSlug(): string {
+		return this.options.environment_slug;
+	}
+}

package/src/clients/api/index.ts

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

package/src/clients/device/device.adpater-interface.ts

@@ -0,0 +1,57 @@
+import type {
+	ApplicationInfo,
+	DeviceInfo,
+	HardwareInfo,
+	NotificationsInfo,
+	OSInfo
+} from "@teardown/schemas";
+
+/**
+ * An interface for a device adapter.
+ * This interface is used to abstract the device adapter implementation.
+ * Everything is optional and should be implemented by the adapter.
+ *
+ * The aim of this interface is to provide a consistent way to get information about the device.
+ * With an opt-in approach to get the information your want to use and track.
+ *
+ */
+export abstract class DeviceInfoAdapter {
+	// -- Application Information --
+	/**
+	 * The information about the application running.
+	 */
+	abstract get applicationInfo(): ApplicationInfo;
+	// -- Updates Information --
+	/**
+	 * The information about the update running.
+	 */
+	// abstract get updateInfo(): UpdateInfo | null;
+	// -- Hardware Information --
+	/**
+	 * The information about the hardware of the device.
+	 */
+	abstract get hardwareInfo(): HardwareInfo;
+	// -- OS Information --
+	/**
+	 * The information about the operating system of the device.
+	 */
+	abstract get osInfo(): OSInfo;
+
+	/**
+	 * The information about the notifications of the device.
+	 */
+	abstract get notificationsInfo(): NotificationsInfo;
+
+	/**
+	 * The information about the device.
+	 */
+	public getDeviceInfo(): Promise<DeviceInfo> {
+		return Promise.resolve({
+			application: this.applicationInfo,
+			hardware: this.hardwareInfo,
+			os: this.osInfo,
+			notifications: this.notificationsInfo,
+			update: null,
+		});
+	}
+}

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

@@ -0,0 +1,195 @@
+import type { DeviceInfo } from "@teardown/schemas";
+import { describe, expect, test } from "bun:test";
+import type { DeviceInfoAdapter } from "./device.adpater-interface";
+import { DeviceClient } from "./device.client";
+
+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() {
+	let uuidCounter = 0;
+	return {
+		generateRandomUUID: async () => `mock-uuid-${++uuidCounter}`,
+		getUuidCounter: () => uuidCounter,
+	};
+}
+
+function createMockDeviceAdapter(): DeviceInfoAdapter {
+	const mockDeviceInfo: DeviceInfo = {
+		application: {
+			name: "TestApp",
+			version: "1.0.0",
+			build: "100",
+			bundle_id: "com.test.app",
+		},
+		hardware: {
+			brand: "Apple",
+			model: "iPhone 15",
+			device_type: "PHONE",
+		},
+		os: {
+			name: "iOS",
+			version: "17.0",
+		},
+		notifications: {
+			push_token: null,
+			platform: null,
+		},
+		update: null,
+	};
+
+	return {
+		applicationInfo: mockDeviceInfo.application,
+		hardwareInfo: mockDeviceInfo.hardware,
+		osInfo: mockDeviceInfo.os,
+		notificationsInfo: mockDeviceInfo.notifications,
+		getDeviceInfo: async () => mockDeviceInfo,
+	} as DeviceInfoAdapter;
+}
+
+describe("DeviceClient", () => {
+	describe("getDeviceId", () => {
+		test("generates new UUID when no device ID stored", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockAdapter = createMockDeviceAdapter();
+
+			const client = new DeviceClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				{ adapter: mockAdapter }
+			);
+
+			const deviceId = await client.getDeviceId();
+
+			expect(deviceId).toBe("mock-uuid-1");
+			expect(mockUtils.getUuidCounter()).toBe(1);
+		});
+
+		test("returns stored device ID when available", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockAdapter = createMockDeviceAdapter();
+
+			// Pre-populate storage with a device ID
+			mockStorage.getStorage().set("deviceId", "existing-device-id");
+
+			const client = new DeviceClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				{ adapter: mockAdapter }
+			);
+
+			const deviceId = await client.getDeviceId();
+
+			expect(deviceId).toBe("existing-device-id");
+			// Should not have generated a new UUID
+			expect(mockUtils.getUuidCounter()).toBe(0);
+		});
+
+		test("returns consistent device ID on multiple calls", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockAdapter = createMockDeviceAdapter();
+
+			mockStorage.getStorage().set("deviceId", "consistent-id");
+
+			const client = new DeviceClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				{ adapter: mockAdapter }
+			);
+
+			const id1 = await client.getDeviceId();
+			const id2 = await client.getDeviceId();
+			const id3 = await client.getDeviceId();
+
+			expect(id1).toBe("consistent-id");
+			expect(id2).toBe("consistent-id");
+			expect(id3).toBe("consistent-id");
+		});
+	});
+
+	describe("getDeviceInfo", () => {
+		test("returns device info from adapter", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+			const mockAdapter = createMockDeviceAdapter();
+
+			const client = new DeviceClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				{ adapter: mockAdapter }
+			);
+
+			const deviceInfo = await client.getDeviceInfo();
+
+			expect(deviceInfo.application.name).toBe("TestApp");
+			expect(deviceInfo.application.version).toBe("1.0.0");
+			expect(deviceInfo.hardware.brand).toBe("Apple");
+			expect(deviceInfo.hardware.model).toBe("iPhone 15");
+			expect(deviceInfo.os.name).toBe("iOS");
+			expect(deviceInfo.os.version).toBe("17.0");
+		});
+
+		test("delegates to adapter getDeviceInfo", async () => {
+			const mockLogging = createMockLoggingClient();
+			const mockStorage = createMockStorageClient();
+			const mockUtils = createMockUtilsClient();
+
+			let getDeviceInfoCalled = false;
+			const customAdapter = {
+				getDeviceInfo: async () => {
+					getDeviceInfoCalled = true;
+					return {
+						application: { name: "Custom", version: "2.0.0", build: "200", bundle_id: "com.custom" },
+						hardware: { brand: "Custom", model: "Device", device_type: "TABLET" },
+						os: { name: "CustomOS", version: "1.0" },
+						notifications: { push_token: null, platform: null },
+						update: null,
+					};
+				},
+			} as DeviceInfoAdapter;
+
+			const client = new DeviceClient(
+				mockLogging as never,
+				mockUtils as never,
+				mockStorage as never,
+				{ adapter: customAdapter }
+			);
+
+			const deviceInfo = await client.getDeviceInfo();
+
+			expect(getDeviceInfoCalled).toBe(true);
+			expect(deviceInfo.application.name).toBe("Custom");
+		});
+	});
+});

package/src/clients/device/device.client.ts

@@ -0,0 +1,69 @@
+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";
+
+// TODO: sort out why importing these enuims from schemas is not working - @teardown/schemas
+export enum NotificationPlatformEnum {
+	APNS = "APNS", // Apple Push Notification Service
+	FCM = "FCM", // Firebase Cloud Messaging
+	EXPO = "EXPO", // Expo Push Notifications
+}
+
+// TODO: sort out why importing these enuims from schemas is not working - @teardown/schemas
+export enum DevicePlatformEnum {
+	IOS = "IOS",
+	ANDROID = "ANDROID",
+	WEB = "WEB",
+	WINDOWS = "WINDOWS",
+	MACOS = "MACOS",
+	LINUX = "LINUX",
+	PHONE = "PHONE",
+	TABLET = "TABLET",
+	DESKTOP = "DESKTOP",
+	CONSOLE = "CONSOLE",
+	TV = "TV",
+	WEARABLE = "WEARABLE",
+	GAME_CONSOLE = "GAME_CONSOLE",
+	VR = "VR",
+	UNKNOWN = "UNKNOWN",
+	OTHER = "OTHER",
+}
+
+export type DeviceClientOptions = {
+	adapter: DeviceInfoAdapter;
+};
+export class DeviceClient {
+	private logger: Logger;
+	private storage: SupportedStorage;
+
+	constructor(
+		logging: LoggingClient,
+		private readonly utils: UtilsClient,
+		storage: StorageClient,
+		private readonly options: DeviceClientOptions
+	) {
+		this.logger = logging.createLogger({
+			name: "DeviceClient",
+		});
+		this.storage = storage.createStorage("device");
+	}
+
+	async getDeviceId(): Promise<string> {
+
+		this.logger.debug("Getting device ID");
+		const deviceId = this.storage.getItem("deviceId");
+		if (deviceId) {
+			return deviceId;
+		}
+
+		const newDeviceId = await this.utils.generateRandomUUID();
+
+		return newDeviceId;
+	}
+
+	async getDeviceInfo(): Promise<DeviceInfo> {
+		return this.options.adapter.getDeviceInfo();
+	}
+}