@teardown/react-native 2.0.24 → 2.0.28

package/src/clients/notifications/adapters/wix-notifications.adapter.ts

@@ -0,0 +1,183 @@
+import { Platform } from "react-native";
+import { type Notification, Notifications, type Registered } from "react-native-notifications";
+import { NotificationPlatformEnum } from "../../device/device.client";
+import {
+	type DataMessage,
+	NotificationAdapter,
+	type PermissionStatus,
+	type PushNotification,
+	type Unsubscribe,
+} from "./notifications.adapter-interface";
+
+/**
+ * Notification adapter for react-native-notifications (Wix) library.
+ * Uses native FCM/APNS tokens for push notifications.
+ *
+ * Note: This library uses event-based token delivery, which is normalized
+ * to a Promise-based API by this adapter.
+ *
+ * @example
+ * ```typescript
+ * import { NotificationsClient } from "@teardown/react-native";
+ * import { WixNotificationsAdapter } from "@teardown/react-native/wix-notifications";
+ *
+ * const notifications = new NotificationsClient(logging, storage, {
+ *   adapter: new WixNotificationsAdapter()
+ * });
+ * ```
+ */
+export class WixNotificationsAdapter extends NotificationAdapter {
+	private tokenPromise: Promise<string> | null = null;
+	private tokenResolver: ((token: string) => void) | null = null;
+	private currentToken: string | null = null;
+	private tokenListeners: Set<(token: string) => void> = new Set();
+
+	constructor() {
+		super();
+		this.setupTokenListener();
+	}
+
+	get platform(): NotificationPlatformEnum {
+		return Platform.OS === "ios" ? NotificationPlatformEnum.APNS : NotificationPlatformEnum.FCM;
+	}
+
+	async getToken(): Promise<string | null> {
+		if (this.currentToken) {
+			return this.currentToken;
+		}
+
+		// Create a promise that will resolve when we receive the token
+		if (!this.tokenPromise) {
+			this.tokenPromise = new Promise<string>((resolve) => {
+				this.tokenResolver = resolve;
+			});
+
+			// Trigger registration to get token
+			Notifications.registerRemoteNotifications();
+		}
+
+		try {
+			// Wait for token with timeout
+			const token = await Promise.race([
+				this.tokenPromise,
+				new Promise<null>((_, reject) => setTimeout(() => reject(new Error("Token timeout")), 10000)),
+			]);
+			return token;
+		} catch {
+			return null;
+		}
+	}
+
+	async requestPermissions(): Promise<PermissionStatus> {
+		return new Promise((resolve) => {
+			// Set up one-time listener for registration result
+			const registeredHandler = () => {
+				resolve({ granted: true, canAskAgain: true });
+			};
+
+			const deniedHandler = () => {
+				resolve({ granted: false, canAskAgain: false });
+			};
+
+			// Subscribe to registration events
+			Notifications.events().registerRemoteNotificationsRegistered(registeredHandler);
+			Notifications.events().registerRemoteNotificationsRegistrationDenied(deniedHandler);
+
+			// Trigger registration
+			Notifications.registerRemoteNotifications();
+
+			// Timeout fallback
+			setTimeout(() => {
+				resolve({ granted: false, canAskAgain: true });
+			}, 10000);
+		});
+	}
+
+	onTokenRefresh(listener: (token: string) => void): Unsubscribe {
+		this.tokenListeners.add(listener);
+
+		// If we already have a token, call listener immediately
+		if (this.currentToken) {
+			listener(this.currentToken);
+		}
+
+		return () => {
+			this.tokenListeners.delete(listener);
+		};
+	}
+
+	onNotificationReceived(listener: (notification: PushNotification) => void): Unsubscribe {
+		const subscription = Notifications.events().registerNotificationReceivedForeground(
+			(
+				notification: Notification,
+				completion: (response: { alert: boolean; sound: boolean; badge: boolean }) => void
+			) => {
+				const payload = notification.payload;
+				listener({
+					title: payload.title,
+					body: payload.body,
+					data: payload,
+				});
+				completion({ alert: true, sound: true, badge: true });
+			}
+		);
+
+		return () => subscription.remove();
+	}
+
+	onNotificationOpened(listener: (notification: PushNotification) => void): Unsubscribe {
+		const subscription = Notifications.events().registerNotificationOpened(
+			(notification: Notification, completion: () => void) => {
+				const payload = notification.payload;
+				listener({
+					title: payload.title,
+					body: payload.body,
+					data: payload,
+				});
+				completion();
+			}
+		);
+
+		return () => subscription.remove();
+	}
+
+	onDataMessage(listener: (message: DataMessage) => void): Unsubscribe {
+		// Wix library handles data-only messages through the same foreground listener
+		// but without title/body in the payload
+		const subscription = Notifications.events().registerNotificationReceivedForeground(
+			(
+				notification: Notification,
+				completion: (response: { alert: boolean; sound: boolean; badge: boolean }) => void
+			) => {
+				const payload = notification.payload;
+				// Data-only message: has payload but no title or body
+				if (payload && !payload.title && !payload.body) {
+					listener({
+						data: payload,
+					});
+				}
+				completion({ alert: false, sound: false, badge: false });
+			}
+		);
+
+		return () => subscription.remove();
+	}
+
+	private setupTokenListener(): void {
+		Notifications.events().registerRemoteNotificationsRegistered((event: Registered) => {
+			this.currentToken = event.deviceToken;
+
+			// Resolve any pending getToken promise
+			if (this.tokenResolver) {
+				this.tokenResolver(event.deviceToken);
+				this.tokenResolver = null;
+				this.tokenPromise = null;
+			}
+
+			// Notify all listeners
+			for (const listener of this.tokenListeners) {
+				listener(event.deviceToken);
+			}
+		});
+	}
+}

package/src/clients/notifications/index.ts

@@ -0,0 +1,2 @@
+export * from "./adapters/notifications.adapter-interface";
+export * from "./notifications.client";

package/src/clients/notifications/notifications.client.ts

@@ -1,10 +1,221 @@
-// import { ApiClient } from "../api/api.client";
+import EventEmitter from "eventemitter3";
+import type { NotificationPlatformEnum } from "../device/device.client";
+import type { Logger, LoggingClient } from "../logging";
+import type { StorageClient, SupportedStorage } from "../storage";
+import type {
+	DataMessage,
+	NotificationAdapter,
+	PermissionStatus,
+	PushNotification,
+	Unsubscribe,
+} from "./adapters/notifications.adapter-interface";
 
+interface NotificationEvents {
+	TOKEN_CHANGED: (token: string) => void;
+	NOTIFICATION_RECEIVED: (notification: PushNotification) => void;
+	NOTIFICATION_OPENED: (notification: PushNotification) => void;
+	DATA_MESSAGE: (message: DataMessage) => void;
+}
 
+export interface NotificationsClientOptions {
+	/** The notification adapter to use (expo, firebase, wix) */
+	adapter: NotificationAdapter;
+}
 
+/**
+ * Client for managing push notifications across different providers.
+ *
+ * Uses an adapter pattern to support multiple notification libraries:
+ * - expo-notifications (Expo projects)
+ * - @react-native-firebase/messaging (Firebase FCM)
+ * - react-native-notifications (Wix)
+ *
+ * @example
+ * ```typescript
+ * import { NotificationsClient } from "@teardown/react-native";
+ * import { ExpoNotificationsAdapter } from "@teardown/react-native/expo-notifications";
+ *
+ * const notifications = new NotificationsClient(logging, storage, {
+ *   adapter: new ExpoNotificationsAdapter()
+ * });
+ *
+ * await notifications.requestPermissions();
+ * const token = await notifications.getToken();
+ * ```
+ */
 export class NotificationsClient {
-  // constructor(private readonly api: ApiClient) { }
+	private logger: Logger;
+	private storage: SupportedStorage;
+	private emitter = new EventEmitter<NotificationEvents>();
+	private token: string | null = null;
+	private initialized = false;
+	private adapterUnsubscribers: Unsubscribe[] = [];
 
+	constructor(
+		logging: LoggingClient,
+		storage: StorageClient,
+		private readonly options: NotificationsClientOptions
+	) {
+		this.logger = logging.createLogger({
+			name: "NotificationsClient",
+		});
+		this.storage = storage.createStorage("notifications");
+	}
 
+	/**
+	 * Initialize the notifications client.
+	 * Sets up event listeners for token refresh and incoming notifications.
+	 * Call this after constructing the client.
+	 */
+	async initialize(): Promise<void> {
+		if (this.initialized) {
+			this.logger.warn("NotificationsClient already initialized");
+			return;
+		}
 
-}
+		this.logger.debug("Initializing NotificationsClient");
+
+		// Load cached token
+		const cachedToken = this.storage.getItem("token");
+		if (cachedToken) {
+			this.token = cachedToken;
+			this.logger.debug("Loaded cached token");
+		}
+
+		// Subscribe to adapter events
+		const tokenRefreshUnsub = this.options.adapter.onTokenRefresh((newToken) => {
+			this.handleTokenChange(newToken);
+		});
+		this.adapterUnsubscribers.push(tokenRefreshUnsub);
+
+		const notificationReceivedUnsub = this.options.adapter.onNotificationReceived((notification) => {
+			this.logger.debug("Notification received in foreground", notification);
+			this.emitter.emit("NOTIFICATION_RECEIVED", notification);
+		});
+		this.adapterUnsubscribers.push(notificationReceivedUnsub);
+
+		const notificationOpenedUnsub = this.options.adapter.onNotificationOpened((notification) => {
+			this.logger.debug("Notification opened by user", notification);
+			this.emitter.emit("NOTIFICATION_OPENED", notification);
+		});
+		this.adapterUnsubscribers.push(notificationOpenedUnsub);
+
+		const dataMessageUnsub = this.options.adapter.onDataMessage((message) => {
+			this.logger.debug("Data-only message received", message);
+			this.emitter.emit("DATA_MESSAGE", message);
+		});
+		this.adapterUnsubscribers.push(dataMessageUnsub);
+
+		this.initialized = true;
+		this.logger.debug("NotificationsClient initialized");
+	}
+
+	/**
+	 * Request push notification permissions from the user.
+	 */
+	async requestPermissions(): Promise<PermissionStatus> {
+		this.logger.debug("Requesting notification permissions");
+		const status = await this.options.adapter.requestPermissions();
+		this.logger.debug("Permission status", status);
+		return status;
+	}
+
+	/**
+	 * Get the current push notification token.
+	 * Returns cached token if available, otherwise fetches from adapter.
+	 */
+	async getToken(): Promise<string | null> {
+		// Return cached token if we have one
+		if (this.token) {
+			return this.token;
+		}
+
+		this.logger.debug("Fetching token from adapter");
+		const token = await this.options.adapter.getToken();
+
+		if (token) {
+			this.handleTokenChange(token);
+		}
+
+		return token;
+	}
+
+	/**
+	 * Get the notification platform type (EXPO, FCM, APNS).
+	 */
+	get platform(): NotificationPlatformEnum {
+		return this.options.adapter.platform;
+	}
+
+	/**
+	 * Subscribe to token change events.
+	 *
+	 * @param listener - Callback invoked when token changes
+	 * @returns Unsubscribe function
+	 */
+	onTokenChange(listener: (token: string) => void): Unsubscribe {
+		this.emitter.addListener("TOKEN_CHANGED", listener);
+		return () => this.emitter.removeListener("TOKEN_CHANGED", listener);
+	}
+
+	/**
+	 * Subscribe to foreground notification events.
+	 *
+	 * @param listener - Callback invoked when notification received in foreground
+	 * @returns Unsubscribe function
+	 */
+	onNotificationReceived(listener: (notification: PushNotification) => void): Unsubscribe {
+		this.emitter.addListener("NOTIFICATION_RECEIVED", listener);
+		return () => this.emitter.removeListener("NOTIFICATION_RECEIVED", listener);
+	}
+
+	/**
+	 * Subscribe to notification opened events.
+	 *
+	 * @param listener - Callback invoked when user taps a notification
+	 * @returns Unsubscribe function
+	 */
+	onNotificationOpened(listener: (notification: PushNotification) => void): Unsubscribe {
+		this.emitter.addListener("NOTIFICATION_OPENED", listener);
+		return () => this.emitter.removeListener("NOTIFICATION_OPENED", listener);
+	}
+
+	/**
+	 * Subscribe to data-only message events (silent/background push).
+	 * These are messages without notification display, used for background data sync.
+	 *
+	 * @param listener - Callback invoked when data message received
+	 * @returns Unsubscribe function
+	 */
+	onDataMessage(listener: (message: DataMessage) => void): Unsubscribe {
+		this.emitter.addListener("DATA_MESSAGE", listener);
+		return () => this.emitter.removeListener("DATA_MESSAGE", listener);
+	}
+
+	/**
+	 * Clean up event listeners and resources.
+	 */
+	destroy(): void {
+		this.logger.debug("Destroying NotificationsClient");
+
+		// Unsubscribe from adapter events
+		for (const unsub of this.adapterUnsubscribers) {
+			unsub();
+		}
+		this.adapterUnsubscribers = [];
+
+		// Remove all listeners
+		this.emitter.removeAllListeners();
+
+		this.initialized = false;
+	}
+
+	private handleTokenChange(newToken: string): void {
+		if (this.token !== newToken) {
+			this.logger.debug("Token changed");
+			this.token = newToken;
+			this.storage.setItem("token", newToken);
+			this.emitter.emit("TOKEN_CHANGED", newToken);
+		}
+	}
+}

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

@@ -1,7 +1,6 @@
 import AsyncStorage from "@react-native-async-storage/async-storage";
 import { StorageAdapter, type SupportedStorage } from "./storage.adpater-interface";
 
-
 /**
  * Creates a SupportedStorage adapter backed by AsyncStorage.
  *
@@ -26,9 +25,7 @@ export class AsyncStorageAdapter extends StorageAdapter {
 
 				try {
 					const allKeys = await AsyncStorage.getAllKeys();
-					const relevantKeys = allKeys.filter((k) =>
-						k.startsWith(`${storageKey}:`)
-					);
+					const relevantKeys = allKeys.filter((k) => k.startsWith(`${storageKey}:`));
 					const pairs = await AsyncStorage.multiGet(relevantKeys);
 
 					for (const [fullKey, value] of pairs) {
@@ -75,5 +72,4 @@ export class AsyncStorageAdapter extends StorageAdapter {
 			},
 		};
 	}
-
-}
+}

package/src/clients/storage/adapters/storage-adapters.test.ts

@@ -29,9 +29,7 @@ function createMockAsyncStorage() {
 	const store = new Map<string, string>();
 	return {
 		getAllKeys: mock(async () => Array.from(store.keys())),
-		multiGet: mock(async (keys: string[]) =>
-			keys.map((k) => [k, store.get(k) ?? null] as [string, string | null])
-		),
+		multiGet: mock(async (keys: string[]) => keys.map((k) => [k, store.get(k) ?? null] as [string, string | null])),
 		setItem: mock(async (key: string, value: string) => {
 			store.set(key, value);
 		}),
@@ -528,10 +526,7 @@ describe("Edge Cases", () => {
 		test("handles special characters in keys (properly prefixed)", async () => {
 			storage.setItem("key:with/special-chars", "value");
 			await new Promise((resolve) => setTimeout(resolve, 10));
-			expect(mockAsyncStorage.setItem).toHaveBeenCalledWith(
-				"edge-test:key:with/special-chars",
-				"value"
-			);
+			expect(mockAsyncStorage.setItem).toHaveBeenCalledWith("edge-test:key:with/special-chars", "value");
 		});
 
 		test("handles keys that look like prefixed keys", async () => {

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

@@ -1,4 +1,3 @@
-
 /**
  * A storage interface that is used to store data.
  */
@@ -16,15 +15,12 @@ export type SupportedStorage = {
  * 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/utils/index.ts

@@ -1 +1 @@
-export * from "./utils.client";
+export * from "./utils.client";

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

@@ -1,5 +1,5 @@
 import type { Logger, LoggingClient } from "../logging";
-import 'react-native-get-random-values';
+import "react-native-get-random-values";
 import { v4 as uuidv4 } from "uuid";
 export class UtilsClient {
 	private readonly logger: Logger;

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

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

package/src/exports/adapters/expo.ts

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

package/src/exports/expo.ts

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

package/src/exports/firebase.ts

@@ -0,0 +1 @@
+export * from "../clients/notifications/adapters/firebase-messaging.adapter";

package/src/exports/index.ts

@@ -1,16 +1,13 @@
-export * from "../teardown.core";
-
-
-// Providers
-export * from "../providers/teardown.provider";
-
 // Clients
 export * from "../clients/api";
+export * from "../clients/device/device.client";
 export * from "../clients/logging";
-export * from "../clients/utils";
+export * from "../clients/notifications";
 export * from "../clients/storage";
-export * from "../clients/device/device.client";
-
+export * from "../clients/utils";
 // Hooks
 export * from "../hooks/use-force-update";
 export * from "../hooks/use-session";
+// Providers
+export * from "../providers/teardown.provider";
+export * from "../teardown.core";

package/src/exports/wix.ts

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

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

@@ -3,45 +3,42 @@ import type { VersionStatus } from "../clients/force-update";
 import { useTeardown } from "../contexts/teardown.context";
 
 export interface UseForceUpdateResult {
-  /**
-   * The current version status.
-   */
-  versionStatus: VersionStatus;
-  /**
-   * Whether an update is available for this version, but is not required.
-   */
-  isUpdateAvailable: boolean;
-  /**
-   * 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;
+	/**
+	 * The current version status.
+	 */
+	versionStatus: VersionStatus;
+	/**
+	 * Whether an update is available for this version, but is not required.
+	 */
+	isUpdateAvailable: boolean;
+	/**
+	 * 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;
 }
 
 export const useForceUpdate = (): UseForceUpdateResult => {
-  const { core } = useTeardown();
+	const { core } = useTeardown();
 
-  const [versionStatus, setVersionStatus] = useState<VersionStatus>(
-    core.forceUpdate.getVersionStatus()
-  );
+	const [versionStatus, setVersionStatus] = useState<VersionStatus>(core.forceUpdate.getVersionStatus());
 
-  useEffect(() => {
-    const unsubscribe = core.forceUpdate.onVersionStatusChange(setVersionStatus);
-    return unsubscribe;
-  }, [core.forceUpdate]);
+	useEffect(() => {
+		const unsubscribe = core.forceUpdate.onVersionStatusChange(setVersionStatus);
+		return unsubscribe;
+	}, [core.forceUpdate]);
 
-  const isUpdateRequired = versionStatus.type === "update_required";
-  const isUpdateRecommended = versionStatus.type === "update_recommended";
-  const isUpdateAvailable = isUpdateRequired || isUpdateRecommended || (versionStatus.type === "update_available");
+	const isUpdateRequired = versionStatus.type === "update_required";
+	const isUpdateRecommended = versionStatus.type === "update_recommended";
+	const isUpdateAvailable = isUpdateRequired || isUpdateRecommended || versionStatus.type === "update_available";
 
-  return {
-    versionStatus,
-    isUpdateRequired,
-    isUpdateRecommended,
-    isUpdateAvailable,
-  };
+	return {
+		versionStatus,
+		isUpdateRequired,
+		isUpdateRecommended,
+		isUpdateAvailable,
+	};
 };
-

package/src/index.ts

@@ -0,0 +1 @@
+export {};

package/src/teardown.core.ts

@@ -75,8 +75,6 @@ export class TeardownCore {
 		this.logger.debug("Initializing force update");
 		this.forceUpdate.initialize();
 		this.logger.debug("Force update initialized");
-
-		this.logger.debug("TeardownCore initialized");
 	}
 
 	setLogLevel(level: LogLevel): void {