@chipmobilesdk/rn-payment 0.4.1 → 0.6.0

package/src/engine/connection.ts

@@ -0,0 +1,194 @@
+/**
+ * The billing connection: connecting, watching it, and reconnecting with bounded
+ * backoff (FR-018 – FR-024, PAY-10).
+ *
+ * A reconnect is always a full teardown-then-connect cycle. The upstream
+ * binding's own `reconnect()` has reported success without rebuilding anything
+ * (openiap#408), so no shortcut is trusted here.
+ */
+import type { ProviderPurchase } from '../adapter/port';
+import type { Unsubscribe } from '../config/types';
+import { backoffDelayMs } from '../core/retry';
+import { withTimeout } from '../core/mutex';
+import { PaymentError } from '../diagnostics/errors';
+import type { EngineState } from './state';
+
+export type InitOutcome = { ok: true } | { ok: false; error: PaymentError };
+
+export interface Connection {
+	/** Connects and attaches the watchers; status follows the outcome. */
+	connect(): Promise<InitOutcome>;
+	/**
+	 * A fresh reconnect budget and one immediate attempt, when an earlier budget
+	 * ran out: a foreground return is when the network the app lost is usually
+	 * back.
+	 */
+	recover(): Promise<void>;
+	dispose(): void;
+}
+
+export function createConnection(
+	state: EngineState,
+	onPurchase: (purchase: ProviderPurchase) => void,
+): Connection {
+	const { provider, resolved } = state;
+	let connectionSub: Unsubscribe | undefined;
+	let purchaseSub: Unsubscribe | undefined;
+	let reconnectTimer: ReturnType<typeof setTimeout> | undefined;
+	let reconnectAttempts = 0;
+	/**
+	 * Set once a connection succeeded. Recovery after an exhausted budget is only
+	 * meaningful from there; a first connection that failed is the app's to retry
+	 * through `initialize`.
+	 */
+	let everConnected = false;
+
+	function scheduleReconnect(): void {
+		if (state.disposed) {
+			return;
+		}
+		if (reconnectAttempts >= resolved.retry.reconnect.maxAttempts) {
+			// Out of budget for now, not for good: a retryable failure rather than a
+			// `connecting` that promised a reconnect nobody was going to make.
+			state.setStatus({ kind: 'failed', retryable: true, reconnectAttempts });
+			return;
+		}
+		const attempt = reconnectAttempts + 1;
+		reconnectTimer = setTimeout(
+			() => {
+				reconnectTimer = undefined;
+				if (state.disposed) {
+					return;
+				}
+				reconnectAttempts = attempt;
+				state.setStatus({ kind: 'connecting', reconnectAttempts });
+				reconnectOnce().catch(() => undefined);
+			},
+			backoffDelayMs(attempt, resolved.retry.reconnect),
+		);
+	}
+
+	async function reconnectOnce(): Promise<void> {
+		try {
+			await provider.disconnect();
+		} catch {
+			// Already down; nothing to tear down.
+		}
+		const outcome = await provider.connect();
+		if (state.disposed) {
+			return;
+		}
+		if (outcome.ok) {
+			reconnectAttempts = 0;
+			state.setStatus({ kind: 'ready', reconnectAttempts: 0 });
+		} else {
+			scheduleReconnect();
+		}
+	}
+
+	/** Replaced, never stacked: a second subscription would hear everything twice. */
+	function watch(): void {
+		connectionSub?.();
+		connectionSub = provider.observeConnection((connected, reason) => {
+			if (state.disposed) {
+				return;
+			}
+			state.emit({ type: 'connection_changed', connected, reason, attempt: reconnectAttempts });
+			if (!connected && state.status.kind === 'ready') {
+				state.setStatus({ kind: 'connecting' });
+				scheduleReconnect();
+			}
+		});
+		// Session-long: a pending purchase settling between sessions arrives here
+		// (FR-039), not only while a purchase is open.
+		purchaseSub?.();
+		purchaseSub = provider.observePurchases(purchase => {
+			if (!state.disposed) {
+				onPurchase(purchase);
+			}
+		});
+	}
+
+	return {
+		async connect() {
+			const outcome = await withTimeout(
+				provider.connect(),
+				resolved.timeouts.connectMs,
+				() =>
+					new PaymentError({
+						code: 'PAYMENT_TIMEOUT',
+						message: 'Connecting to the billing service timed out',
+						operation: 'initialize',
+						retryable: true,
+					}),
+			).catch((error: PaymentError) => ({
+				ok: false as const,
+				reason: 'store_error' as const,
+				retryable: error.retryable,
+			}));
+
+			if (!outcome.ok) {
+				if (outcome.reason === 'store_error') {
+					state.setStatus({ kind: 'failed', retryable: outcome.retryable });
+					return {
+						ok: false,
+						error: new PaymentError({
+							code: 'PAYMENT_STORE_ERROR',
+							message: 'Could not connect to the billing service',
+							operation: 'initialize',
+							retryable: outcome.retryable,
+						}),
+					};
+				}
+				// No billing service, an outdated one, or an unsupported platform: each
+				// distinguishable, and none of them may break the host app (FR-021, FR-023).
+				state.setStatus({
+					kind: 'unavailable',
+					unavailableReason: outcome.reason,
+					retryable: outcome.retryable,
+				});
+				return {
+					ok: false,
+					error: new PaymentError({
+						code:
+							outcome.reason === 'platform_unsupported'
+								? 'PAYMENT_UNSUPPORTED_PLATFORM'
+								: 'PAYMENT_UNAVAILABLE',
+						message: `Billing unavailable: ${outcome.reason}`,
+						operation: 'initialize',
+						retryable: outcome.retryable,
+					}),
+				};
+			}
+
+			watch();
+			everConnected = true;
+			state.setStatus({ kind: 'ready', reconnectAttempts: 0 });
+			return { ok: true };
+		},
+
+		async recover() {
+			if (
+				everConnected &&
+				!state.disposed &&
+				state.status.kind === 'failed' &&
+				reconnectTimer === undefined
+			) {
+				reconnectAttempts = 0;
+				state.setStatus({ kind: 'connecting', reconnectAttempts: 0 });
+				await reconnectOnce().catch(() => undefined);
+			}
+		},
+
+		dispose() {
+			connectionSub?.();
+			connectionSub = undefined;
+			purchaseSub?.();
+			purchaseSub = undefined;
+			if (reconnectTimer !== undefined) {
+				clearTimeout(reconnectTimer);
+				reconnectTimer = undefined;
+			}
+		},
+	};
+}