react-native-iap 14.3.2-rc.9 → 14.3.3-rc.1

package/src/helpers/subscription.ts

@@ -33,21 +33,20 @@ export const getActiveSubscriptions = async (
           purchaseToken: purchase.purchaseToken,
           transactionDate: purchase.transactionDate,
           // Platform-specific fields
-          expirationDateIOS: iosPurchase.expirationDateIOS
-            ? new Date(iosPurchase.expirationDateIOS)
-            : undefined,
+          expirationDateIOS: iosPurchase.expirationDateIOS ?? null,
           autoRenewingAndroid:
             androidPurchase.autoRenewingAndroid ??
             androidPurchase.isAutoRenewing, // deprecated - use isAutoRenewing instead
           environmentIOS: iosPurchase.environmentIOS,
           // Convenience fields
           willExpireSoon: false, // Would need to calculate based on expiration date
-          daysUntilExpirationIOS: iosPurchase.expirationDateIOS
-            ? Math.ceil(
-                (iosPurchase.expirationDateIOS - Date.now()) /
-                  (1000 * 60 * 60 * 24),
-              )
-            : undefined,
+          daysUntilExpirationIOS:
+            iosPurchase.expirationDateIOS != null
+              ? Math.ceil(
+                  (iosPurchase.expirationDateIOS - Date.now()) /
+                    (1000 * 60 * 60 * 24),
+                )
+              : undefined,
         };
       });
 

package/src/hooks/useIAP.ts

@@ -16,20 +16,23 @@ import {
   getActiveSubscriptions,
   hasActiveSubscriptions,
   restorePurchases as restorePurchasesTopLevel,
+  getPromotedProductIOS,
+  requestPurchaseOnPromotedProductIOS,
 } from '../';
-import {getPromotedProductIOS, requestPurchaseOnPromotedProductIOS} from '../';
 
 // Types
+import {ProductQueryType, ErrorCode} from '../types';
 import type {
+  ActiveSubscription,
   Product,
   Purchase,
   PurchaseError,
-  PurchaseResult,
-  SubscriptionProduct,
-  RequestPurchaseProps,
-  RequestSubscriptionProps,
-  ActiveSubscription,
+  ProductSubscription,
+  PurchaseParams,
 } from '../types';
+import type {FinishTransactionParams} from '../';
+import type {NitroPurchaseResult} from '../specs/RnIap.nitro';
+import {normalizeErrorCodeFromNative} from '../utils/errorMapping';
 
 // Types for event subscriptions
 interface EventSubscription {
@@ -41,7 +44,7 @@ type UseIap = {
   products: Product[];
   promotedProductsIOS: Purchase[];
   promotedProductIdIOS?: string;
-  subscriptions: SubscriptionProduct[];
+  subscriptions: ProductSubscription[];
   availablePurchases: Purchase[];
   currentPurchase?: Purchase;
   currentPurchaseError?: PurchaseError;
@@ -52,14 +55,11 @@ type UseIap = {
   finishTransaction: ({
     purchase,
     isConsumable,
-  }: {
-    purchase: Purchase;
-    isConsumable?: boolean;
-  }) => Promise<PurchaseResult | boolean>;
+  }: FinishTransactionParams) => Promise<NitroPurchaseResult | boolean>;
   getAvailablePurchases: (skus?: string[]) => Promise<void>;
   fetchProducts: (params: {
     skus: string[];
-    type?: 'inapp' | 'subs';
+    type?: ProductQueryType | null;
   }) => Promise<void>;
   /**
    * @deprecated Use fetchProducts({ skus, type: 'inapp' }) instead. This method will be removed in version 3.0.0.
@@ -71,10 +71,7 @@ type UseIap = {
    * Note: This method internally uses fetchProducts, so no deprecation warning is shown.
    */
   getSubscriptions: (skus: string[]) => Promise<void>;
-  requestPurchase: (params: {
-    request: RequestPurchaseProps | RequestSubscriptionProps;
-    type?: 'inapp' | 'subs';
-  }) => Promise<any>;
+  requestPurchase: (params: PurchaseParams) => Promise<any>;
   validateReceipt: (
     sku: string,
     androidOptions?: {
@@ -109,7 +106,7 @@ export function useIAP(options?: UseIapOptions): UseIap {
   const [connected, setConnected] = useState<boolean>(false);
   const [products, setProducts] = useState<Product[]>([]);
   const [promotedProductsIOS] = useState<Purchase[]>([]);
-  const [subscriptions, setSubscriptions] = useState<SubscriptionProduct[]>([]);
+  const [subscriptions, setSubscriptions] = useState<ProductSubscription[]>([]);
   const [availablePurchases, setAvailablePurchases] = useState<Purchase[]>([]);
   const [currentPurchase, setCurrentPurchase] = useState<Purchase>();
   const [promotedProductIOS, setPromotedProductIOS] = useState<Product>();
@@ -159,7 +156,7 @@ export function useIAP(options?: UseIapOptions): UseIap {
     promotedProductIOS?: EventSubscription;
   }>({});
 
-  const subscriptionsRefState = useRef<SubscriptionProduct[]>([]);
+  const subscriptionsRefState = useRef<ProductSubscription[]>([]);
 
   useEffect(() => {
     subscriptionsRefState.current = subscriptions;
@@ -176,7 +173,10 @@ export function useIAP(options?: UseIapOptions): UseIap {
   const getProductsInternal = useCallback(
     async (skus: string[]): Promise<void> => {
       try {
-        const result = await fetchProducts({skus, type: 'inapp'});
+        const result = await fetchProducts({
+          skus,
+          type: ProductQueryType.InApp,
+        });
         setProducts((prevProducts: Product[]) =>
           mergeWithDuplicateCheck(
             prevProducts,
@@ -194,12 +194,15 @@ export function useIAP(options?: UseIapOptions): UseIap {
   const getSubscriptionsInternal = useCallback(
     async (skus: string[]): Promise<void> => {
       try {
-        const result = await fetchProducts({skus, type: 'subs'});
-        setSubscriptions((prevSubscriptions: SubscriptionProduct[]) =>
+        const result = await fetchProducts({
+          skus,
+          type: ProductQueryType.Subs,
+        });
+        setSubscriptions((prevSubscriptions: ProductSubscription[]) =>
           mergeWithDuplicateCheck(
             prevSubscriptions,
-            result as SubscriptionProduct[],
-            (subscription: SubscriptionProduct) => subscription.id,
+            result as ProductSubscription[],
+            (subscription: ProductSubscription) => subscription.id,
           ),
         );
       } catch (error) {
@@ -212,7 +215,7 @@ export function useIAP(options?: UseIapOptions): UseIap {
   const fetchProductsInternal = useCallback(
     async (params: {
       skus: string[];
-      type?: 'inapp' | 'subs';
+      type?: ProductQueryType | null;
     }): Promise<void> => {
       if (!connectedRef.current) {
         console.warn(
@@ -222,12 +225,12 @@ export function useIAP(options?: UseIapOptions): UseIap {
       }
       try {
         const result = await fetchProducts(params);
-        if (params.type === 'subs') {
-          setSubscriptions((prevSubscriptions: SubscriptionProduct[]) =>
+        if (params.type === ProductQueryType.Subs) {
+          setSubscriptions((prevSubscriptions: ProductSubscription[]) =>
             mergeWithDuplicateCheck(
               prevSubscriptions,
-              result as SubscriptionProduct[],
-              (subscription: SubscriptionProduct) => subscription.id,
+              result as ProductSubscription[],
+              (subscription: ProductSubscription) => subscription.id,
             ),
           );
         } else {
@@ -296,7 +299,7 @@ export function useIAP(options?: UseIapOptions): UseIap {
     }: {
       purchase: Purchase;
       isConsumable?: boolean;
-    }): Promise<PurchaseResult | boolean> => {
+    }): Promise<NitroPurchaseResult | boolean> => {
       try {
         return await finishTransactionInternal({
           purchase,
@@ -322,7 +325,7 @@ export function useIAP(options?: UseIapOptions): UseIap {
   );
 
   const requestPurchaseWithReset = useCallback(
-    async (requestObj: {request: any; type?: 'inapp' | 'subs'}) => {
+    async (requestObj: PurchaseParams) => {
       clearCurrentPurchase();
       clearCurrentPurchaseError();
 
@@ -371,23 +374,25 @@ export function useIAP(options?: UseIapOptions): UseIap {
       },
     );
 
-    subscriptionsRef.current.purchaseError = purchaseErrorListener(
-      (error: PurchaseError) => {
-        // Ignore init error until connected
-        if (
-          error &&
-          (error as any).code === 'E_INIT_CONNECTION' &&
-          !connectedRef.current
-        ) {
-          return;
-        }
-        setCurrentPurchase(undefined);
-        setCurrentPurchaseError(error);
-        if (optionsRef.current?.onPurchaseError) {
-          optionsRef.current.onPurchaseError(error);
-        }
-      },
-    );
+    subscriptionsRef.current.purchaseError = purchaseErrorListener((error) => {
+      const mappedError: PurchaseError = {
+        code: normalizeErrorCodeFromNative(error.code),
+        message: error.message,
+        productId: undefined,
+      };
+      // Ignore init error until connected
+      if (
+        mappedError.code === ErrorCode.InitConnection &&
+        !connectedRef.current
+      ) {
+        return;
+      }
+      setCurrentPurchase(undefined);
+      setCurrentPurchaseError(mappedError);
+      if (optionsRef.current?.onPurchaseError) {
+        optionsRef.current.onPurchaseError(mappedError);
+      }
+    });
 
     if (Platform.OS === 'ios') {
       subscriptionsRef.current.promotedProductsIOS = promotedProductListenerIOS(

package/src/index.ts

@@ -1,8 +1,8 @@
 // External dependencies
 import {Platform} from 'react-native';
-// Side-effect import ensures Nitro installs its dispatcher before IAP is used
+// Side-effect import ensures Nitro installs its dispatcher before IAP is used (no-op in tests)
 import 'react-native-nitro-modules';
-import {NitroModules, isRuntimeAlive} from 'react-native-nitro-modules';
+import {NitroModules} from 'react-native-nitro-modules';
 
 // Internal modules
 import type {
@@ -12,22 +12,24 @@ import type {
   NitroReceiptValidationResultIOS,
   NitroReceiptValidationResultAndroid,
 } from './specs/RnIap.nitro';
+import {ProductQueryType} from './types';
 import type {
   Product,
+  ProductRequest,
   Purchase,
   PurchaseAndroid,
-  RequestPurchaseProps,
-  RequestSubscriptionProps,
-  RequestSubscriptionAndroidProps,
   PurchaseOptions,
-  FinishTransactionParams,
-  ReceiptValidationResultIOS,
+  PurchaseParams,
+  PurchaseError,
   ReceiptValidationResultAndroid,
-  RequestPurchaseIosProps,
+  ReceiptValidationResultIOS,
   RequestPurchaseAndroidProps,
+  RequestPurchaseIosProps,
+  RequestPurchasePropsByPlatforms,
+  RequestSubscriptionAndroidProps,
+  RequestSubscriptionPropsByPlatforms,
   SubscriptionStatusIOS,
 } from './types';
-import type {ProductRequest} from './types';
 import {
   convertNitroProductToProduct,
   convertNitroPurchaseToPurchase,
@@ -36,6 +38,7 @@ import {
   convertNitroSubscriptionStatusToSubscriptionStatusIOS,
 } from './utils/type-bridge';
 import {parseErrorStringToJsonObj} from './utils/error';
+import {normalizeErrorCodeFromNative} from './utils/errorMapping';
 
 // Export all types
 export type {
@@ -47,11 +50,46 @@ export type {
 export * from './types';
 export * from './utils/error';
 
-// Types for event listeners
+// Internal constants/helpers for bridging legacy Nitro expectations
+const NITRO_PRODUCT_TYPE_INAPP = 'inapp';
+const NITRO_PRODUCT_TYPE_SUBS = 'subs';
+
+function toNitroProductType(
+  type?: ProductQueryType | null,
+): typeof NITRO_PRODUCT_TYPE_INAPP | typeof NITRO_PRODUCT_TYPE_SUBS {
+  return type === ProductQueryType.Subs
+    ? NITRO_PRODUCT_TYPE_SUBS
+    : NITRO_PRODUCT_TYPE_INAPP;
+}
+
+function isSubscriptionQuery(type?: ProductQueryType | null): boolean {
+  return type === ProductQueryType.Subs;
+}
+
+function normalizeProductQueryType(
+  type?: ProductQueryType | string | null,
+): ProductQueryType {
+  if (type === ProductQueryType.All || type === 'all') {
+    return ProductQueryType.All;
+  }
+  if (type === ProductQueryType.Subs || type === 'subs') {
+    return ProductQueryType.Subs;
+  }
+  if (type === ProductQueryType.InApp || type === 'inapp') {
+    return ProductQueryType.InApp;
+  }
+  return ProductQueryType.InApp;
+}
+
 export interface EventSubscription {
   remove(): void;
 }
 
+export type FinishTransactionParams = {
+  purchase: Purchase;
+  isConsumable?: boolean;
+};
+
 // ActiveSubscription and PurchaseError types are already exported via 'export * from ./types'
 
 // Export hooks
@@ -85,15 +123,23 @@ const IAP = {
   get instance(): RnIap {
     if (iapRef) return iapRef;
 
-    // Guard against accessing Nitro before it's installed into the JS runtime
-    const hasNitroDispatcher = isRuntimeAlive();
-    if (!hasNitroDispatcher) {
-      throw new Error(
-        'Nitro runtime not installed yet. Ensure react-native-nitro-modules is initialized before calling IAP.',
-      );
+    // Attempt to create the HybridObject and map common Nitro/JSI readiness errors
+    try {
+      iapRef = NitroModules.createHybridObject<RnIap>('RnIap');
+    } catch (e) {
+      const msg = String((e as any)?.message ?? e ?? '');
+      if (
+        msg.includes('Nitro') ||
+        msg.includes('JSI') ||
+        msg.includes('dispatcher') ||
+        msg.includes('HybridObject')
+      ) {
+        throw new Error(
+          'Nitro runtime not installed yet. Ensure react-native-nitro-modules is initialized before calling IAP.',
+        );
+      }
+      throw e;
     }
-
-    iapRef = NitroModules.createHybridObject<RnIap>('RnIap');
     return iapRef;
   },
 };
@@ -142,17 +188,19 @@ export const endConnection = async (): Promise<boolean> => {
  */
 export const fetchProducts = async ({
   skus,
-  type = 'inapp',
+  type = ProductQueryType.InApp,
 }: ProductRequest): Promise<Product[]> => {
   try {
     if (!skus || skus.length === 0) {
       throw new Error('No SKUs provided');
     }
 
-    if (type === 'all') {
+    const normalizedType = normalizeProductQueryType(type);
+
+    if (normalizedType === ProductQueryType.All) {
       const [inappNitro, subsNitro] = await Promise.all([
-        IAP.instance.fetchProducts(skus, 'inapp'),
-        IAP.instance.fetchProducts(skus, 'subs'),
+        IAP.instance.fetchProducts(skus, NITRO_PRODUCT_TYPE_INAPP),
+        IAP.instance.fetchProducts(skus, NITRO_PRODUCT_TYPE_SUBS),
       ]);
       const allNitro = [...inappNitro, ...subsNitro];
       const validAll = allNitro.filter(validateNitroProduct);
@@ -164,7 +212,10 @@ export const fetchProducts = async ({
       return validAll.map(convertNitroProductToProduct);
     }
 
-    const nitroProducts = await IAP.instance.fetchProducts(skus, type);
+    const nitroProducts = await IAP.instance.fetchProducts(
+      skus,
+      toNitroProductType(normalizedType),
+    );
 
     // Validate and convert NitroProducts to TypeScript Products
     const validProducts = nitroProducts.filter(validateNitroProduct);
@@ -217,17 +268,53 @@ export const fetchProducts = async ({
  * ⚠️ Important: This is an event-based operation, not promise-based.
  * Listen for events through purchaseUpdatedListener or purchaseErrorListener.
  * @param params - Purchase request configuration
- * @param params.request - Platform-specific purchase parameters
- * @param params.type - Type of purchase: 'inapp' for products (default) or 'subs' for subscriptions
+ * @param params.requestPurchase - Platform-specific purchase parameters (in-app)
+ * @param params.requestSubscription - Platform-specific subscription parameters (subs)
+ * @param params.type - Type of purchase (defaults to in-app)
  */
-export const requestPurchase = async ({
-  request,
-  type = 'inapp',
-}: {
-  request: RequestPurchaseProps | RequestSubscriptionProps;
-  type?: 'inapp' | 'subs';
-}): Promise<void> => {
+export const requestPurchase = async (
+  params: PurchaseParams,
+): Promise<void> => {
   try {
+    const {requestPurchase: purchaseRequest, requestSubscription} = params;
+    const normalizedPurchaseRequest = purchaseRequest ?? undefined;
+    const normalizedSubscriptionRequest = requestSubscription ?? undefined;
+
+    const effectiveType = normalizeProductQueryType(params.type);
+    const isSubs = isSubscriptionQuery(effectiveType);
+    let request:
+      | RequestPurchasePropsByPlatforms
+      | RequestSubscriptionPropsByPlatforms
+      | undefined;
+
+    if (isSubs) {
+      if (
+        __DEV__ &&
+        normalizedPurchaseRequest &&
+        !normalizedSubscriptionRequest
+      ) {
+        console.warn(
+          '[react-native-iap] `requestPurchase` was provided for a subscription request. Did you mean to use `requestSubscription`?',
+        );
+      }
+      request = normalizedSubscriptionRequest ?? normalizedPurchaseRequest;
+    } else {
+      if (
+        __DEV__ &&
+        normalizedSubscriptionRequest &&
+        !normalizedPurchaseRequest
+      ) {
+        console.warn(
+          '[react-native-iap] `requestSubscription` was provided for an in-app purchase request. Did you mean to use `requestPurchase`?',
+        );
+      }
+      request = normalizedPurchaseRequest ?? normalizedSubscriptionRequest;
+    }
+
+    if (!request) {
+      throw new Error('Missing purchase request configuration');
+    }
+
     // Validate platform-specific requests
     if (Platform.OS === 'ios') {
       const iosRequest = request.ios;
@@ -253,8 +340,7 @@ export const requestPurchase = async ({
     if (Platform.OS === 'ios' && request.ios) {
       const iosReq = request.ios as RequestPurchaseIosProps;
       const autoFinishSubs =
-        type === 'subs' &&
-        iosReq.andDangerouslyFinishTransactionAutomatically == null;
+        isSubs && iosReq.andDangerouslyFinishTransactionAutomatically == null;
       unifiedRequest.ios = {
         ...iosReq,
         // Align with native SwiftUI flow: auto-finish subscriptions by default
@@ -265,7 +351,7 @@ export const requestPurchase = async ({
     }
 
     if (Platform.OS === 'android' && request.android) {
-      if (type === 'subs') {
+      if (isSubs) {
         const subsRequest = request.android as RequestSubscriptionAndroidProps;
         unifiedRequest.android = {
           ...subsRequest,
@@ -612,13 +698,20 @@ export const purchaseUpdatedListener = (
  * ```
  */
 export const purchaseErrorListener = (
-  listener: (error: NitroPurchaseResult) => void,
+  listener: (error: PurchaseError) => void,
 ): EventSubscription => {
-  // Store the listener for removal
-  listenerMap.set(listener, listener);
+  const wrapped = (error: NitroPurchaseResult) => {
+    listener({
+      code: normalizeErrorCodeFromNative(error.code),
+      message: error.message,
+      productId: undefined,
+    });
+  };
+
+  listenerMap.set(listener, wrapped);
   let attached = false;
   try {
-    IAP.instance.addPurchaseErrorListener(listener as any);
+    IAP.instance.addPurchaseErrorListener(wrapped as any);
     attached = true;
   } catch (e) {
     const msg = String(e ?? '');
@@ -633,12 +726,15 @@ export const purchaseErrorListener = (
 
   return {
     remove: () => {
-      if (attached) {
-        try {
-          IAP.instance.removePurchaseErrorListener(listener as any);
-        } catch {}
+      const stored = listenerMap.get(listener);
+      if (stored) {
+        if (attached) {
+          try {
+            IAP.instance.removePurchaseErrorListener(stored as any);
+          } catch {}
+        }
+        listenerMap.delete(listener);
       }
-      listenerMap.delete(listener);
     },
   };
 };
@@ -1232,7 +1328,7 @@ export {
 export {
   convertNitroProductToProduct,
   convertNitroPurchaseToPurchase,
-  convertProductToSubscriptionProduct,
+  convertProductToProductSubscription,
   validateNitroProduct,
   validateNitroPurchase,
   checkTypeSynchronization,

package/src/specs/RnIap.nitro.ts

@@ -9,7 +9,7 @@ import type {HybridObject} from 'react-native-nitro-modules';
 /**
  * Android-specific receipt validation options
  */
-export interface NitroAndroidReceiptValidationOptions {
+export interface NitroReceiptValidationAndroidOptions {
   packageName: string;
   productToken: string;
   accessToken: string;
@@ -21,7 +21,7 @@ export interface NitroAndroidReceiptValidationOptions {
  */
 export interface NitroReceiptValidationParams {
   sku: string;
-  androidOptions?: NitroAndroidReceiptValidationOptions;
+  androidOptions?: NitroReceiptValidationAndroidOptions;
 }
 
 // Purchase request parameters