@idealyst/payments 1.2.108 → 1.2.110

package/src/payments.native.ts

@@ -1,301 +1,391 @@
 // ============================================================================
-// Native Payment Implementation
-// Wraps @stripe/stripe-react-native Platform Pay API for Apple Pay & Google Pay
+// Native IAP Implementation
+// Wraps react-native-iap v14.x for StoreKit 2 (iOS) and Google Play Billing (Android)
+//
+// v14 API changes from earlier versions:
+// - getProducts/getSubscriptions → fetchProducts({ skus, type })
+// - requestPurchase/requestSubscription → requestPurchase({ request, type })
+// - Product fields: id (not productId), displayPrice (not localizedPrice)
+// - Purchase fields: productId, id (transaction ID)
 // ============================================================================
 
 import { Platform } from 'react-native';
 import type {
-  PaymentConfig,
-  PaymentProviderStatus,
-  PaymentMethodAvailability,
-  PaymentMethodType,
-  PaymentSheetRequest,
-  PaymentResult,
+  IAPConfig,
+  IAPProviderStatus,
+  IAPProduct,
+  IAPSubscription,
+  IAPPurchase,
+  ProductPlatform,
+  SubscriptionPeriod,
+  SubscriptionPeriodUnit,
+  SubscriptionDiscount,
+  DiscountPaymentMode,
 } from './types';
 import { INITIAL_PROVIDER_STATUS } from './constants';
-import { createPaymentError, normalizeError } from './errors';
+import { createIAPError, normalizeError } from './errors';
 
-// Graceful optional import — @stripe/stripe-react-native may not be installed
+// Graceful optional import — react-native-iap may not be installed
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-let Stripe: any = null;
+let RNIap: any = null;
 try {
-  Stripe = require('@stripe/stripe-react-native');
+  RNIap = require('react-native-iap');
 } catch {
   // Will degrade gracefully when methods are called
 }
 
 // Module-level state
-let _status: PaymentProviderStatus = { ...INITIAL_PROVIDER_STATUS };
-let _config: PaymentConfig | null = null;
+let _status: IAPProviderStatus = { ...INITIAL_PROVIDER_STATUS };
+let _config: IAPConfig = {};
 
 /**
- * Get the current payment provider status.
+ * Get the current IAP provider status.
  */
-export function getPaymentStatus(): PaymentProviderStatus {
+export function getIAPStatus(): IAPProviderStatus {
   return { ..._status };
 }
 
 /**
- * Initialize the Stripe SDK for platform payments.
+ * Initialize the IAP connection to the native store.
  */
-export async function initializePayments(
-  config: PaymentConfig,
-): Promise<void> {
-  if (!Stripe) {
+export async function initializeIAP(config?: IAPConfig): Promise<void> {
+  if (!RNIap) {
     _status = {
-      ..._status,
       state: 'error',
-      error: createPaymentError(
+      isStoreAvailable: false,
+      error: createIAPError(
         'not_available',
-        '@stripe/stripe-react-native is not installed. Run: yarn add @stripe/stripe-react-native',
+        'react-native-iap is not installed. Run: yarn add react-native-iap',
       ),
     };
     return;
   }
 
   _status = { ..._status, state: 'initializing' };
-  _config = config;
+  _config = config ?? {};
 
   try {
-    await Stripe.initStripe({
-      publishableKey: config.publishableKey,
-      merchantIdentifier: config.merchantIdentifier,
-      urlScheme: config.urlScheme,
-    });
-
-    const availability = await checkPaymentAvailability();
+    await RNIap.initConnection();
 
     _status = {
       state: 'ready',
-      availablePaymentMethods: availability,
-      isPaymentAvailable: availability.some((m) => m.isAvailable),
+      isStoreAvailable: true,
     };
   } catch (error) {
     _status = {
-      ..._status,
       state: 'error',
+      isStoreAvailable: false,
       error: normalizeError(error),
     };
   }
 }
 
 /**
- * Check which payment methods (Apple Pay, Google Pay, card) are available.
+ * Fetch products (one-time purchases) from the store by SKU.
  */
-export async function checkPaymentAvailability(): Promise<
-  PaymentMethodAvailability[]
-> {
-  if (!Stripe) {
-    return [
-      {
-        type: 'apple_pay',
-        isAvailable: false,
-        unavailableReason: 'Stripe SDK not installed',
-      },
-      {
-        type: 'google_pay',
-        isAvailable: false,
-        unavailableReason: 'Stripe SDK not installed',
-      },
-      { type: 'card', isAvailable: false, unavailableReason: 'Stripe SDK not installed' },
-    ];
+export async function getProducts(skus: string[]): Promise<IAPProduct[]> {
+  assertReady();
+
+  try {
+    const products = await RNIap!.fetchProducts({ skus, type: 'in-app' });
+    return products.map((p: unknown) => mapProduct(p, 'iap'));
+  } catch (error) {
+    throw normalizeError(error);
   }
+}
 
-  const results: PaymentMethodAvailability[] = [];
-  const isIOS = Platform.OS === 'ios';
+/**
+ * Fetch subscriptions from the store by SKU.
+ */
+export async function getSubscriptions(
+  skus: string[],
+): Promise<IAPSubscription[]> {
+  assertReady();
 
   try {
-    const isSupported = await Stripe.isPlatformPaySupported({
-      googlePay: {
-        testEnv: _config?.testEnvironment ?? false,
-      },
-    });
+    const products = await RNIap!.fetchProducts({ skus, type: 'subs' });
+    return products.map(mapSubscription);
+  } catch (error) {
+    throw normalizeError(error);
+  }
+}
 
-    results.push({
-      type: 'apple_pay',
-      isAvailable: isIOS && isSupported,
-      unavailableReason: !isIOS
-        ? 'Apple Pay is only available on iOS'
-        : !isSupported
-          ? 'Apple Pay is not configured on this device'
-          : undefined,
-    });
+/**
+ * Purchase a one-time product.
+ */
+export async function purchaseProduct(sku: string): Promise<IAPPurchase> {
+  assertReady();
 
-    results.push({
-      type: 'google_pay',
-      isAvailable: !isIOS && isSupported,
-      unavailableReason: isIOS
-        ? 'Google Pay is only available on Android'
-        : !isSupported
-          ? 'Google Pay is not configured on this device'
-          : undefined,
-    });
-  } catch (error) {
-    results.push(
-      {
-        type: 'apple_pay',
-        isAvailable: false,
-        unavailableReason: String(error),
-      },
-      {
-        type: 'google_pay',
-        isAvailable: false,
-        unavailableReason: String(error),
+  try {
+    const purchase = await RNIap!.requestPurchase({
+      request: {
+        apple: { sku },
+        google: { skus: [sku] },
       },
-    );
-  }
+      type: 'in-app',
+    });
 
-  // Card payments are always conceptually available via Stripe
-  results.push({ type: 'card', isAvailable: true });
+    const mapped = mapPurchase(purchase);
 
-  _status = {
-    ..._status,
-    availablePaymentMethods: results,
-    isPaymentAvailable: results.some((m) => m.isAvailable),
-  };
+    if (_config.autoFinishTransactions) {
+      await RNIap!.finishTransaction({ purchase, isConsumable: false });
+    }
 
-  return results;
+    return mapped;
+  } catch (error) {
+    throw normalizeError(error);
+  }
 }
 
 /**
- * Present the platform payment sheet and confirm a PaymentIntent.
- * Requires `request.clientSecret` from a server-created PaymentIntent.
+ * Purchase a subscription.
+ * On Android, an `offerToken` from the subscription's offer details may be required.
  */
-export async function confirmPayment(
-  request: PaymentSheetRequest,
-): Promise<PaymentResult> {
+export async function purchaseSubscription(
+  sku: string,
+  offerToken?: string,
+): Promise<IAPPurchase> {
   assertReady();
 
-  if (!request.clientSecret) {
-    throw createPaymentError(
-      'invalid_request',
-      'clientSecret is required for confirmPayment. Create a PaymentIntent on your server first.',
-    );
-  }
-
   try {
-    const { error, paymentIntent } =
-      await Stripe!.confirmPlatformPayPayment(request.clientSecret, {
-        googlePay: buildGooglePayConfig(request),
-        applePay: buildApplePayConfig(request),
-      });
-
-    if (error) {
-      throw error;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const googleRequest: any = { skus: [sku] };
+    if (offerToken) {
+      googleRequest.offerToken = offerToken;
     }
 
-    return {
-      paymentMethodType: detectPlatformPayType(),
-      paymentIntentId: paymentIntent?.id,
-      status: paymentIntent?.status,
-    };
+    const purchase = await RNIap!.requestPurchase({
+      request: {
+        apple: { sku },
+        google: googleRequest,
+      },
+      type: 'subs',
+    });
+
+    const mapped = mapPurchase(purchase);
+
+    if (_config.autoFinishTransactions) {
+      await RNIap!.finishTransaction({ purchase, isConsumable: false });
+    }
+
+    return mapped;
   } catch (error) {
     throw normalizeError(error);
   }
 }
 
 /**
- * Present the platform payment sheet and create a payment method
- * without confirming. Returns a payment method ID for server-side use.
+ * Finish a transaction. Call this after server-side receipt validation.
+ *
+ * @param purchase The purchase to finish.
+ * @param isConsumable Whether the product is consumable (can be purchased again).
  */
-export async function createPaymentMethod(
-  request: PaymentSheetRequest,
-): Promise<PaymentResult> {
+export async function finishTransaction(
+  purchase: IAPPurchase,
+  isConsumable?: boolean,
+): Promise<void> {
   assertReady();
 
   try {
-    const { error, paymentMethod } =
-      await Stripe!.createPlatformPayPaymentMethod({
-        googlePay: {
-          ...buildGooglePayConfig(request),
-          amount: request.amount.amount,
-        },
-        applePay: buildApplePayConfig(request),
-      });
-
-    if (error) {
-      throw error;
-    }
+    // finishTransaction expects the raw purchase object; we reconstruct the
+    // minimal shape that react-native-iap needs (id + productId + purchaseToken)
+    await RNIap!.finishTransaction({
+      purchase: {
+        id: purchase.transactionId,
+        productId: purchase.sku,
+        purchaseToken: purchase.purchaseToken,
+      },
+      isConsumable: isConsumable ?? false,
+    });
+  } catch (error) {
+    throw normalizeError(error);
+  }
+}
 
-    return {
-      paymentMethodType: detectPlatformPayType(),
-      paymentMethodId: paymentMethod?.id,
-    };
+/**
+ * Restore previous purchases (e.g., after reinstall or on a new device).
+ */
+export async function restorePurchases(): Promise<IAPPurchase[]> {
+  assertReady();
+
+  try {
+    const purchases = await RNIap!.getAvailablePurchases();
+    return purchases.map((p: unknown) => mapPurchase(p, 'restored'));
   } catch (error) {
     throw normalizeError(error);
   }
 }
 
+/**
+ * End the IAP connection. Call on cleanup (e.g., app unmount).
+ */
+export async function endConnection(): Promise<void> {
+  if (!RNIap) return;
+
+  try {
+    await RNIap.endConnection();
+    _status = { ...INITIAL_PROVIDER_STATUS };
+  } catch {
+    // Ignore errors during cleanup
+  }
+}
+
 // ============================================================================
 // Internal Helpers
 // ============================================================================
 
 function assertReady(): void {
-  if (!Stripe) {
-    throw createPaymentError(
+  if (!RNIap) {
+    throw createIAPError(
       'not_available',
-      '@stripe/stripe-react-native is not installed',
+      'react-native-iap is not installed',
     );
   }
   if (_status.state !== 'ready') {
-    throw createPaymentError(
+    throw createIAPError(
       'not_initialized',
-      'Payment provider not initialized. Call initializePayments() first.',
+      'IAP connection not initialized. Call initializeIAP() first.',
     );
   }
 }
 
-function detectPlatformPayType(): PaymentMethodType {
-  return Platform.OS === 'ios' ? 'apple_pay' : 'google_pay';
+function getPlatform(): ProductPlatform {
+  return Platform.OS === 'ios' ? 'ios' : 'android';
 }
 
-function buildGooglePayConfig(request: PaymentSheetRequest) {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function mapProduct(raw: any, type: 'iap' | 'sub' = 'iap'): IAPProduct {
   return {
-    testEnv: _config?.testEnvironment ?? false,
-    merchantName: _config!.merchantName,
-    merchantCountryCode: _config!.merchantCountryCode,
-    currencyCode: request.amount.currencyCode,
-    billingAddressConfig: request.billingAddress
-      ? {
-          isRequired: request.billingAddress.isRequired ?? false,
-          isPhoneNumberRequired:
-            request.billingAddress.isPhoneNumberRequired ?? false,
-          format:
-            request.billingAddress.format === 'FULL'
-              ? Stripe!.PlatformPay.BillingAddressFormat.Full
-              : Stripe!.PlatformPay.BillingAddressFormat.Min,
-        }
+    sku: raw.id ?? raw.productId ?? '',
+    title: raw.title ?? raw.displayName ?? '',
+    description: raw.description ?? '',
+    price: typeof raw.price === 'number' ? raw.price : parseFloat(raw.price ?? '0'),
+    priceFormatted: raw.displayPrice ?? raw.localizedPrice ?? String(raw.price ?? ''),
+    currency: raw.currency ?? '',
+    type,
+    platform: getPlatform(),
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function mapSubscription(raw: any): IAPSubscription {
+  const base = mapProduct(raw, 'sub');
+
+  return {
+    ...base,
+    subscriptionPeriod: parseSubscriptionPeriod(raw),
+    introductoryPrice: raw.introductoryPrice
+      ? mapDiscount(raw.introductoryPrice, 'introductory')
       : undefined,
+    discounts: raw.discounts?.map((d: unknown) =>
+      mapDiscount(d, 'promotional'),
+    ),
   };
 }
 
-function buildApplePayConfig(request: PaymentSheetRequest) {
-  const cartItems: Array<{
-    label: string;
-    amount: string;
-    paymentType: number;
-  }> = [];
-
-  if (request.lineItems) {
-    for (const item of request.lineItems) {
-      cartItems.push({
-        label: item.label,
-        amount: (item.amount / 100).toFixed(2),
-        paymentType: Stripe!.PlatformPay.PaymentType.Immediate,
-      });
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseSubscriptionPeriod(raw: any): SubscriptionPeriod {
+  // iOS: subscriptionPeriodUnitIOS / subscriptionPeriodNumberIOS
+  if (raw.subscriptionPeriodUnitIOS) {
+    return {
+      unit: mapPeriodUnit(raw.subscriptionPeriodUnitIOS),
+      numberOfUnits: parseInt(raw.subscriptionPeriodNumberIOS ?? '1', 10),
+    };
+  }
+
+  // Android: subscriptionOfferDetailsAndroid may contain period info
+  if (raw.subscriptionOfferDetailsAndroid?.length) {
+    const offer = raw.subscriptionOfferDetailsAndroid[0];
+    const pricingPhases = offer?.pricingPhases?.pricingPhaseList;
+    if (pricingPhases?.length) {
+      const billingPeriod = pricingPhases[0]?.billingPeriod;
+      if (billingPeriod) {
+        return parseISO8601Period(billingPeriod);
+      }
     }
   }
 
-  // Total line item (required by Apple Pay)
-  cartItems.push({
-    label: _config?.merchantName ?? 'Total',
-    amount: (request.amount.amount / 100).toFixed(2),
-    paymentType: Stripe!.PlatformPay.PaymentType.Immediate,
-  });
+  // Fallback: subscriptionPeriodAndroid (older format)
+  if (raw.subscriptionPeriodAndroid) {
+    return parseISO8601Period(raw.subscriptionPeriodAndroid);
+  }
+
+  return { unit: 'month', numberOfUnits: 1 };
+}
+
+function mapPeriodUnit(unit: string): SubscriptionPeriodUnit {
+  switch (unit.toUpperCase()) {
+    case 'DAY':
+      return 'day';
+    case 'WEEK':
+      return 'week';
+    case 'MONTH':
+      return 'month';
+    case 'YEAR':
+      return 'year';
+    default:
+      return 'month';
+  }
+}
+
+function parseISO8601Period(period: string): SubscriptionPeriod {
+  // Simple ISO 8601 duration parser for P{n}{unit} (e.g., P1M, P3M, P1Y, P7D)
+  const match = period.match(/P(\d+)([DWMY])/i);
+  if (!match) return { unit: 'month', numberOfUnits: 1 };
+
+  const num = parseInt(match[1], 10);
+  switch (match[2].toUpperCase()) {
+    case 'D':
+      return { unit: 'day', numberOfUnits: num };
+    case 'W':
+      return { unit: 'week', numberOfUnits: num };
+    case 'M':
+      return { unit: 'month', numberOfUnits: num };
+    case 'Y':
+      return { unit: 'year', numberOfUnits: num };
+    default:
+      return { unit: 'month', numberOfUnits: num };
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function mapDiscount(raw: any, type: 'introductory' | 'promotional'): SubscriptionDiscount {
+  const paymentModeMap: Record<string, DiscountPaymentMode> = {
+    FREETRIAL: 'freeTrial',
+    FREE_TRIAL: 'freeTrial',
+    PAYASYOUGO: 'payAsYouGo',
+    PAY_AS_YOU_GO: 'payAsYouGo',
+    PAYUPFRONT: 'payUpFront',
+    PAY_UP_FRONT: 'payUpFront',
+  };
+
+  return {
+    identifier: raw.identifier,
+    price: parseFloat(raw.price ?? '0'),
+    priceFormatted: raw.displayPrice ?? raw.localizedPrice ?? raw.price ?? '',
+    period: raw.subscriptionPeriod
+      ? parseISO8601Period(raw.subscriptionPeriod)
+      : { unit: 'month', numberOfUnits: 1 },
+    paymentMode:
+      paymentModeMap[(raw.paymentMode ?? '').toUpperCase()] ?? 'freeTrial',
+    type,
+  };
+}
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function mapPurchase(raw: any, stateOverride?: IAPPurchase['purchaseState']): IAPPurchase {
+  // v14: transaction ID is in `id`, product is in `productId`
   return {
-    cartItems,
-    merchantCountryCode: _config!.merchantCountryCode,
-    currencyCode: request.amount.currencyCode,
+    sku: raw.productId ?? raw.id ?? '',
+    transactionId: raw.id ?? raw.transactionId ?? '',
+    transactionDate: raw.transactionDate
+      ? (typeof raw.transactionDate === 'number'
+          ? raw.transactionDate
+          : parseInt(raw.transactionDate, 10))
+      : Date.now(),
+    transactionReceipt: raw.transactionReceipt ?? raw.dataAndroid ?? '',
+    purchaseToken: raw.purchaseToken,
+    isAcknowledged: raw.isAcknowledgedAndroid,
+    purchaseState: stateOverride ?? 'purchased',
   };
 }