@chipmobilesdk/rn-payment 0.4.1 → 0.5.0

package/src/react/PaymentProvider.tsx

@@ -15,6 +15,7 @@ import React, {
 	type PropsWithChildren,
 } from 'react';
 import { createEngine, type EngineDeps, type PaymentEngine } from '../engine/engine';
+import { syncOnForeground as watchForeground } from '../engine/foreground';
 import type { PaymentConfig } from '../config/types';
 
 const PaymentContext = createContext<PaymentEngine | null>(null);
@@ -32,12 +33,19 @@ export interface PaymentProviderProps {
 	deps: EngineDeps;
 	/** Skip automatic initialization when the app wants to control the moment. */
 	autoInitialize?: boolean;
+	/**
+	 * Call `handleForeground()` each time the app returns from the background, through
+	 * rn-core's shared lifecycle port. Off by default: what counts as a foreground
+	 * return is the app's decision (FR-059).
+	 */
+	syncOnForeground?: boolean;
 }
 
 export function PaymentProvider({
 	config,
 	deps,
 	autoInitialize = true,
+	syncOnForeground = false,
 	children,
 }: PropsWithChildren<PaymentProviderProps>): React.ReactElement {
 	// Built once per config identity. Rebuilding on every render would reconnect
@@ -55,6 +63,11 @@ export function PaymentProvider({
 		return () => engine.cleanup();
 	}, [engine, autoInitialize]);
 
+	useEffect(
+		() => (syncOnForeground ? watchForeground(engine) : undefined),
+		[engine, syncOnForeground],
+	);
+
 	return <PaymentContext.Provider value={engine}>{children}</PaymentContext.Provider>;
 }
 

package/src/react/hooks.ts

@@ -8,6 +8,7 @@
  * returns a loading placeholder for an entitlement it already knows (PERF-001).
  */
 
+import { useExternalStore } from '@chipmobilesdk/rn-core/react';
 import { useCallback, useEffect, useState } from 'react';
 import { usePaymentEngine } from './PaymentProvider';
 import type {
@@ -33,34 +34,19 @@ import type { RestoreOutcome, SyncOutcome } from '../engine/engine';
  */
 export function useEntitlement(key: EntitlementKey): EntitlementState {
 	const engine = usePaymentEngine();
-	const [state, setState] = useState<EntitlementState>(() => engine.getEntitlement(key));
-
-	useEffect(() => {
-		// Re-read on subscribe: the entitlement may have changed between the initial
-		// render and this effect.
-		setState(engine.getEntitlement(key));
-		return engine.subscribeEntitlements(map => {
-			const next = map[key];
-			if (next) {
-				setState(next);
-			}
-		});
-	}, [engine, key]);
-
-	return state;
+	// The engine keeps an unchanged entitlement's object across recomputes, so this
+	// selection only changes, and the component only re-renders, when it changes.
+	const select = useCallback(
+		(map: EntitlementMap) => map[key] ?? engine.getEntitlement(key),
+		[engine, key],
+	);
+	return useExternalStore(engine.subscribeEntitlements, engine.getAllEntitlements, select);
 }
 
 /** Every entitlement at once, for a screen that shows overall plan state. */
 export function useEntitlements(): EntitlementMap {
 	const engine = usePaymentEngine();
-	const [map, setMap] = useState<EntitlementMap>(() => engine.getAllEntitlements());
-
-	useEffect(() => {
-		setMap(engine.getAllEntitlements());
-		return engine.subscribeEntitlements(setMap);
-	}, [engine]);
-
-	return map;
+	return useExternalStore(engine.subscribeEntitlements, engine.getAllEntitlements);
 }
 
 function narrowPending(
@@ -99,14 +85,7 @@ export function usePendingPurchases(productKeys?: readonly string[]): PendingPur
 /** Package status, so an app can tell "cannot sell here" from "not paid" (FR-022). */
 export function usePaymentStatus(): PaymentStatus {
 	const engine = usePaymentEngine();
-	const [status, setStatus] = useState<PaymentStatus>(() => engine.getStatus());
-
-	useEffect(() => {
-		setStatus(engine.getStatus());
-		return engine.subscribeStatus(setStatus);
-	}, [engine]);
-
-	return status;
+	return useExternalStore(engine.subscribeStatus, engine.getStatus);
 }
 
 export interface UsePurchaseResult {

package/src/testing/conformance.ts

@@ -0,0 +1,169 @@
+/**
+ * What any `ProviderPort` must do (IOS-12, PAY-13).
+ *
+ * The same checks run against the fake store and against the Play adapter over a
+ * simulated binding (or the real one, from a demo screen on a device), so a test
+ * that drives the fake proves something about the device path. Each check builds
+ * its own port over the same small store, through a harness.
+ */
+import {
+	ensure,
+	runChecks,
+	type Check,
+	type ConformanceReport,
+} from '@chipmobilesdk/rn-core/testing';
+
+import type { ProviderPort } from '../adapter/port';
+import type { ProductType } from '../config/types';
+
+export interface StoreProductSpec {
+	readonly storeProductId: string;
+	readonly productType: ProductType;
+	/** As the store formats it; the port must pass it through untouched. */
+	readonly formattedPrice: string;
+}
+
+export interface OwnedPurchaseSpec {
+	readonly storeProductId: string;
+	readonly token: string;
+	readonly state: 'purchased' | 'pending';
+}
+
+export interface StoreScenario {
+	readonly products: readonly StoreProductSpec[];
+	readonly owned: readonly OwnedPurchaseSpec[];
+}
+
+export interface ProviderSubject {
+	readonly port: ProviderPort;
+	/** How the next purchase flow the user starts ends. */
+	nextPurchaseEnds(outcome: 'bought' | 'cancelled'): void;
+	/** The billing service goes away underneath the app. */
+	dropService(): void;
+}
+
+export interface ProviderHarness {
+	create(scenario: StoreScenario): ProviderSubject;
+}
+
+/** The store every check runs against. */
+export const CONFORMANCE_STORE: StoreScenario = {
+	products: [
+		{
+			storeProductId: 'conformance.remove_ads',
+			productType: 'one_time_permanent',
+			formattedPrice: '€1.99',
+		},
+		{
+			storeProductId: 'conformance.coins',
+			productType: 'one_time_consumable',
+			formattedPrice: '€0.99',
+		},
+	],
+	owned: [
+		{ storeProductId: 'conformance.remove_ads', token: 'token-owned', state: 'purchased' },
+		{ storeProductId: 'conformance.coins', token: 'token-pending', state: 'pending' },
+	],
+};
+
+export const providerPortChecks: readonly Check<ProviderHarness>[] = [
+	{
+		name: 'connects, and disconnects safely before a connect and twice',
+		async run(harness) {
+			const { port } = harness.create(CONFORMANCE_STORE);
+			await port.disconnect();
+			const outcome = await port.connect();
+			ensure(outcome.ok, `connect failed: ${JSON.stringify(outcome)}`);
+			await port.disconnect();
+			await port.disconnect();
+		},
+	},
+	{
+		name: 'reports a dropped service to observers, and nothing after unsubscribing',
+		async run(harness) {
+			const subject = harness.create(CONFORMANCE_STORE);
+			const seen: boolean[] = [];
+			const stop = subject.port.observeConnection(connected => seen.push(connected));
+			await subject.port.connect();
+			ensure(seen.at(-1) === true, `after connect observers saw ${JSON.stringify(seen)}`);
+			subject.dropService();
+			ensure(seen.at(-1) === false, `after the drop observers saw ${JSON.stringify(seen)}`);
+			stop();
+			const before = seen.length;
+			await subject.port.connect();
+			ensure(seen.length === before, 'notified after unsubscribing');
+		},
+	},
+	{
+		name: 'returns the requested products with the store-formatted price',
+		async run(harness) {
+			const { port } = harness.create(CONFORMANCE_STORE);
+			await port.connect();
+			const products = await port.queryProducts(['conformance.remove_ads'], 'one_time_permanent');
+			ensure(products.length === 1, `expected one product, got ${products.length}`);
+			const [product] = products;
+			ensure(product?.storeProductId === 'conformance.remove_ads', 'wrong product returned');
+			ensure(product.productType === 'one_time_permanent', `product type ${product.productType}`);
+			ensure(product.formattedPrice === '€1.99', `price ${product.formattedPrice}`);
+		},
+	},
+	{
+		name: 'flags a pending purchase rather than filtering it out',
+		async run(harness) {
+			const { port } = harness.create(CONFORMANCE_STORE);
+			await port.connect();
+			const owned = await port.queryOwned();
+			const pending = owned.find(purchase => purchase.token === 'token-pending');
+			const bought = owned.find(purchase => purchase.token === 'token-owned');
+			ensure(pending?.state === 'pending', `pending purchase reported as ${pending?.state}`);
+			ensure(bought?.state === 'purchased', `bought purchase reported as ${bought?.state}`);
+		},
+	},
+	{
+		name: 'reports a bought purchase for the product that was requested',
+		async run(harness) {
+			const subject = harness.create(CONFORMANCE_STORE);
+			await subject.port.connect();
+			subject.nextPurchaseEnds('bought');
+			const outcome = await subject.port.launchPurchase({
+				storeProductId: 'conformance.coins',
+				productType: 'one_time_consumable',
+			});
+			ensure(outcome.ok, `purchase failed: ${JSON.stringify(outcome)}`);
+			ensure(
+				outcome.purchase.storeProductId === 'conformance.coins',
+				'purchase for another product',
+			);
+			ensure(outcome.purchase.token !== '', 'purchase has no token to finalize');
+		},
+	},
+	{
+		name: 'reports a cancelled flow as user_cancelled',
+		async run(harness) {
+			const subject = harness.create(CONFORMANCE_STORE);
+			await subject.port.connect();
+			subject.nextPurchaseEnds('cancelled');
+			const outcome = await subject.port.launchPurchase({
+				storeProductId: 'conformance.remove_ads',
+				productType: 'one_time_permanent',
+			});
+			ensure(!outcome.ok, 'a cancelled flow reported a purchase');
+			ensure(outcome.reason === 'user_cancelled', `reason ${outcome.reason}`);
+		},
+	},
+	{
+		name: 'acknowledges and consumes safely twice',
+		async run(harness) {
+			const { port } = harness.create(CONFORMANCE_STORE);
+			await port.connect();
+			await port.acknowledge('token-owned');
+			await port.acknowledge('token-owned');
+			await port.consume('token-pending');
+			await port.consume('token-pending');
+		},
+	},
+];
+
+export function runProviderPortConformance(harness: ProviderHarness): Promise<ConformanceReport> {
+	return runChecks(() => harness, providerPortChecks);
+}

package/src/testing/fakeStore.ts

@@ -11,6 +11,8 @@
  * testable at all (NFR-007, SC-008).
  */
 
+import { createListenerSet } from '@chipmobilesdk/rn-core';
+
 import type {
 	ProviderCapabilities,
 	ProviderConnectOutcome,
@@ -154,8 +156,10 @@ export function createFakeStore(options: FakeStoreOptions = {}): FakeStore {
 	const acknowledgedTokens: ProviderToken[] = [];
 	const consumedTokens: ProviderToken[] = [];
 	const managementOpenedFor: (StoreProductId | undefined)[] = [];
-	const connectionListeners = new Set<(connected: boolean, reason?: string) => void>();
-	const purchaseListeners = new Set<(purchase: ProviderPurchase) => void>();
+	// The same listener sets as the real adapter, so a throwing observer behaves
+	// identically here and on a device (PAY-17).
+	const connectionListeners = createListenerSet<[boolean, string | undefined]>();
+	const purchaseListeners = createListenerSet<[ProviderPurchase]>();
 
 	let connectCalls = 0;
 	let launchCalls = 0;
@@ -164,9 +168,7 @@ export function createFakeStore(options: FakeStoreOptions = {}): FakeStore {
 
 	const notifyConnection = (next: boolean, reason?: string): void => {
 		connected = next;
-		for (const listener of [...connectionListeners]) {
-			listener(next, reason);
-		}
+		connectionListeners.notify(next, reason);
 	};
 
 	return {
@@ -187,15 +189,7 @@ export function createFakeStore(options: FakeStoreOptions = {}): FakeStore {
 		},
 
 		observeConnection(listener): Unsubscribe {
-			connectionListeners.add(listener);
-			let removed = false;
-			return () => {
-				if (removed) {
-					return;
-				}
-				removed = true;
-				connectionListeners.delete(listener);
-			};
+			return connectionListeners.add(listener);
 		},
 
 		async queryProducts(
@@ -235,23 +229,13 @@ export function createFakeStore(options: FakeStoreOptions = {}): FakeStore {
 			if (androidBinding) {
 				// The binding's update listener fires for every observer, the session-long
 				// one included, before the launch settles.
-				for (const listener of [...purchaseListeners]) {
-					listener(purchase);
-				}
+				purchaseListeners.notify(purchase);
 			}
 			return { ok: true, purchase };
 		},
 
 		observePurchases(listener): Unsubscribe {
-			purchaseListeners.add(listener);
-			let removed = false;
-			return () => {
-				if (removed) {
-					return;
-				}
-				removed = true;
-				purchaseListeners.delete(listener);
-			};
+			return purchaseListeners.add(listener);
 		},
 
 		async acknowledge(token: ProviderToken): Promise<void> {
@@ -306,9 +290,7 @@ export function createFakeStore(options: FakeStoreOptions = {}): FakeStore {
 		},
 		pushPurchaseUpdate(purchase) {
 			owned = [...owned.filter(p => p.transactionId !== purchase.transactionId), purchase];
-			for (const listener of [...purchaseListeners]) {
-				listener(purchase);
-			}
+			purchaseListeners.notify(purchase);
 		},
 		revoke(transactionId) {
 			owned = owned.filter(p => p.transactionId !== transactionId);

package/src/testing/index.ts

@@ -8,3 +8,12 @@
 export { createFakeStore, makePurchase } from './fakeStore';
 export type { FakeStore, FakeStoreOptions } from './fakeStore';
 export { createMemorySnapshotStore } from '../persistence/mmkv-store';
+
+export { CONFORMANCE_STORE, providerPortChecks, runProviderPortConformance } from './conformance';
+export type {
+	OwnedPurchaseSpec,
+	ProviderHarness,
+	ProviderSubject,
+	StoreProductSpec,
+	StoreScenario,
+} from './conformance';