react-native-iap 10.0.7 → 10.1.1

package/lib/module/iap.js

@@ -1,14 +1,14 @@
 import { Linking, NativeModules, Platform } from 'react-native';
-import { ReceiptValidationStatus } from './types/apple';
 import { enhancedFetch, fillProductsWithAdditionalData, isAmazon, isAndroid } from './internal';
+import { ProductType } from './types';
 import { InstallSourceAndroid, PurchaseStateAndroid } from './types';
 const {
   RNIapIos,
   RNIapModule,
   RNIapAmazonModule
 } = NativeModules;
-const ANDROID_ITEM_TYPE_SUBSCRIPTION = 'subs';
-const ANDROID_ITEM_TYPE_IAP = 'inapp';
+const ANDROID_ITEM_TYPE_SUBSCRIPTION = ProductType.subs;
+const ANDROID_ITEM_TYPE_IAP = ProductType.inapp;
 export const getInstallSourceAndroid = () => {
   return RNIapModule ? InstallSourceAndroid.GOOGLE_PLAY : InstallSourceAndroid.AMAZON;
 };
@@ -43,12 +43,42 @@ export const getNativeModule = () => {
 };
 /**
  * Init module for purchase flow. Required on Android. In ios it will check whether user canMakePayment.
- * @returns {Promise<boolean>}
+ * ## Usage
+
+```tsx
+import React, {useEffect} from 'react';
+import {View} from 'react-native';
+import {initConnection} from 'react-native-iap';
+
+const App = () => {
+  useEffect(() => {
+    void initConnection();
+  }, []);
+
+  return <View />;
+};
+```
  */
 
 export const initConnection = () => getNativeModule().initConnection();
 /**
- * End module for purchase flow.
+ * Disconnects from native SDK
+ * Usage
+ * ```tsx
+import React, {useEffect} from 'react';
+import {View} from 'react-native';
+import {endConnection} from 'react-native-iap';
+
+const App = () => {
+  useEffect(() => {
+    return () => {
+      void endConnection();
+    };
+  }, []);
+
+  return <View />;
+};
+```
  * @returns {Promise<void>}
  */
 
@@ -61,8 +91,47 @@ export const endConnection = () => getNativeModule().endConnection();
 export const flushFailedPurchasesCachedAsPendingAndroid = () => getAndroidModule().flushFailedPurchasesCachedAsPending();
 /**
  * Get a list of products (consumable and non-consumable items, but not subscriptions)
- * @param {string[]} skus The item skus
- * @returns {Promise<Product[]>}
+ ## Usage
+
+```ts
+import React, {useState} from 'react';
+import {Platform} from 'react-native';
+import {getProducts, Product} from 'react-native-iap';
+
+const skus = Platform.select({
+  ios: ['com.example.consumableIos'],
+  android: ['com.example.consumableAndroid'],
+});
+
+const App = () => {
+  const [products, setProducts] = useState<Product[]>([]);
+
+  const handleProducts = async () => {
+    const items = await getProducts({skus});
+
+    setProducts(items);
+  };
+
+  useEffect(() => {
+    void handleProducts();
+  }, []);
+
+  return (
+    <>
+      {products.map((product) => (
+        <Text key={product.productId}>{product.productId}</Text>
+      ))}
+    </>
+  );
+};
+```
+
+Just a few things to keep in mind:
+
+- You can get your products in `componentDidMount`, `useEffect` or another appropriate area of your app.
+- Since a user may start your app with a bad or no internet connection, preparing/getting the items more than once may be a good idea.
+- If the user has no IAPs available when the app starts first, you may want to check again when the user enters your IAP store.
+
  */
 
 export const getProducts = _ref => {
@@ -78,12 +147,28 @@ export const getProducts = _ref => {
       const products = await getAndroidModule().getItemsByType(ANDROID_ITEM_TYPE_IAP, skus);
       return fillProductsWithAdditionalData(products);
     }
-  }) || Promise.resolve)();
+  }) || (() => Promise.reject(new Error('Unsupported Platform'))))();
 };
 /**
  * Get a list of subscriptions
- * @param {string[]} skus The item skus
- * @returns {Promise<Subscription[]>}
+ * ## Usage
+
+```tsx
+import React, {useCallback} from 'react';
+import {View} from 'react-native';
+import {getSubscriptions} from 'react-native-iap';
+
+const App = () => {
+  const subscriptions = useCallback(
+    async () =>
+      await getSubscriptions(['com.example.product1', 'com.example.product2']),
+    [],
+  );
+
+  return <View />;
+};
+```
+
  */
 
 export const getSubscriptions = _ref2 => {
@@ -99,11 +184,30 @@ export const getSubscriptions = _ref2 => {
       const subscriptions = await getAndroidModule().getItemsByType(ANDROID_ITEM_TYPE_SUBSCRIPTION, skus);
       return fillProductsWithAdditionalData(subscriptions);
     }
-  }) || Promise.resolve)();
+  }) || (() => Promise.reject(new Error('Unsupported Platform'))))();
 };
 /**
  * Gets an inventory of purchases made by the user regardless of consumption status
- * @returns {Promise<(ProductPurchase | SubscriptionPurchase)[]>}
+ * ## Usage
+
+```tsx
+import React, {useCallback} from 'react';
+import {View} from 'react-native';
+import {getPurchaseHistory} from 'react-native-iap';
+
+const App = () => {
+  const history = useCallback(
+    async () =>
+      await getPurchaseHistory([
+        'com.example.product1',
+        'com.example.product2',
+      ]),
+    [],
+  );
+
+  return <View />;
+};
+```
  */
 
 export const getPurchaseHistory = () => (Platform.select({
@@ -115,14 +219,88 @@ export const getPurchaseHistory = () => (Platform.select({
       return await RNIapAmazonModule.getAvailableItems();
     }
 
-    const products = await getAndroidModule().getPurchaseHistoryByType(ANDROID_ITEM_TYPE_IAP);
-    const subscriptions = await getAndroidModule().getPurchaseHistoryByType(ANDROID_ITEM_TYPE_SUBSCRIPTION);
+    const products = await RNIapModule.getPurchaseHistoryByType(ANDROID_ITEM_TYPE_IAP);
+    const subscriptions = await RNIapModule.getPurchaseHistoryByType(ANDROID_ITEM_TYPE_SUBSCRIPTION);
     return products.concat(subscriptions);
   }
-}) || Promise.resolve)();
+}) || (() => Promise.resolve([])))();
 /**
  * Get all purchases made by the user (either non-consumable, or haven't been consumed yet)
- * @returns {Promise<(ProductPurchase | SubscriptionPurchase)[]>}
+ * ## Usage
+
+```tsx
+import React, {useCallback} from 'react';
+import {View} from 'react-native';
+import {getAvailablePurchases} from 'react-native-iap';
+
+const App = () => {
+  const availablePurchases = useCallback(
+    async () => await getAvailablePurchases(),
+    [],
+  );
+
+  return <View />;
+};
+```
+
+## Restoring purchases
+
+You can use `getAvailablePurchases()` to do what's commonly understood as "restoring" purchases.
+
+:::note
+For debugging you may want to consume all items, you have then to iterate over the purchases returned by `getAvailablePurchases()`.
+:::
+
+:::warning
+Beware that if you consume an item without having recorded the purchase in your database the user may have paid for something without getting it delivered and you will have no way to recover the receipt to validate and restore their purchase.
+:::
+
+```tsx
+import React from 'react';
+import {Button} from 'react-native';
+import {getAvailablePurchases,finishTransaction} from 'react-native-iap';
+
+const App = () => {
+  handleRestore = async () => {
+    try {
+      const purchases = await getAvailablePurchases();
+      const newState = {premium: false, ads: true};
+      let titles = [];
+
+      await Promise.all(purchases.map(async purchase => {
+        switch (purchase.productId) {
+          case 'com.example.premium':
+            newState.premium = true;
+            titles.push('Premium Version');
+            break;
+
+          case 'com.example.no_ads':
+            newState.ads = false;
+            titles.push('No Ads');
+            break;
+
+          case 'com.example.coins100':
+            await finishTransaction(purchase.purchaseToken);
+            CoinStore.addCoins(100);
+        }
+      })
+
+      Alert.alert(
+        'Restore Successful',
+        `You successfully restored the following purchases: ${titles.join(', ')}`,
+      );
+    } catch (error) {
+      console.warn(error);
+      Alert.alert(error.message);
+    }
+  };
+
+  return (
+    <Button title="Restore purchases" onPress={handleRestore} />
+  )
+};
+```
+ * 
  */
 
 export const getAvailablePurchases = () => (Platform.select({
@@ -134,21 +312,77 @@ export const getAvailablePurchases = () => (Platform.select({
       return await RNIapAmazonModule.getAvailableItems();
     }
 
-    const products = await getAndroidModule().getAvailableItemsByType(ANDROID_ITEM_TYPE_IAP);
-    const subscriptions = await getAndroidModule().getAvailableItemsByType(ANDROID_ITEM_TYPE_SUBSCRIPTION);
+    const products = await RNIapModule.getAvailableItemsByType(ANDROID_ITEM_TYPE_IAP);
+    const subscriptions = await RNIapModule.getAvailableItemsByType(ANDROID_ITEM_TYPE_SUBSCRIPTION);
     return products.concat(subscriptions);
   }
-}) || Promise.resolve)();
+}) || (() => Promise.resolve([])))();
 /**
  * Request a purchase for product. This will be received in `PurchaseUpdatedListener`.
- * @param {string} sku The product's sku/ID
- * @param {string} [applicationUsername] The purchaser's user ID
- * @param {boolean} [andDangerouslyFinishTransactionAutomaticallyIOS] You should set this to false and call finishTransaction manually when you have delivered the purchased goods to the user. It defaults to true to provide backwards compatibility. Will default to false in version 4.0.0.
- * @param {string} [obfuscatedAccountIdAndroid] Specifies an optional obfuscated string that is uniquely associated with the user's account in your app.
- * @param {string} [obfuscatedProfileIdAndroid] Specifies an optional obfuscated string that is uniquely associated with the user's profile in your app.
- * @param {string[]} [skus] Product Ids to purchase. Note that this is only for Android. iOS only uses a single SKU. If not provided, it'll default to using [sku] for backward-compatibility
- * @param {boolean} [isOfferPersonalized] Defaults to false, Only for Android V5
- * @returns {Promise<ProductPurchase>}
+ * Request a purchase for a product (consumables or non-consumables).
+
+The response will be received through the `PurchaseUpdatedListener`.
+
+:::note
+`andDangerouslyFinishTransactionAutomatically` defaults to false. We recommend
+always keeping at false, and verifying the transaction receipts on the server-side.
+:::
+
+## Signature
+
+```ts
+requestPurchase(
+ The product's sku/ID 
+  sku,
+
+  
+   * You should set this to false and call finishTransaction manually when you have delivered the purchased goods to the user.
+   * @default false
+   
+  andDangerouslyFinishTransactionAutomaticallyIOS = false,
+
+  /** Specifies an optional obfuscated string that is uniquely associated with the user's account in your app. 
+  obfuscatedAccountIdAndroid,
+
+  Specifies an optional obfuscated string that is uniquely associated with the user's profile in your app. 
+  obfuscatedProfileIdAndroid,
+
+   The purchaser's user ID 
+  applicationUsername,
+): Promise<ProductPurchase>;
+```
+
+## Usage
+
+```tsx
+import React, {useCallback} from 'react';
+import {Button} from 'react-native';
+import {requestPurchase, Product, Sku, getProducts} from 'react-native-iap';
+
+const App = () => {
+  const products = useCallback(
+    async () => getProducts(['com.example.product']),
+    [],
+  );
+
+  const handlePurchase = async (sku: Sku) => {
+    await requestPurchase({sku});
+  };
+
+  return (
+    <>
+      {products.map((product) => (
+        <Button
+          key={product.productId}
+          title="Buy product"
+          onPress={() => handlePurchase(product.productId)}
+        />
+      ))}
+    </>
+  );
+};
+```
+
  */
 
 export const requestPurchase = _ref3 => {
@@ -163,6 +397,10 @@ export const requestPurchase = _ref3 => {
   } = _ref3;
   return (Platform.select({
     ios: async () => {
+      if (!sku) {
+        return Promise.reject(new Error('sku is required for iOS purchase'));
+      }
+
       if (andDangerouslyFinishTransactionAutomaticallyIOS) {
         console.warn('You are dangerously allowing react-native-iap to finish your transaction automatically. You should set andDangerouslyFinishTransactionAutomatically to false when calling requestPurchase and call finishTransaction manually when you have delivered the purchased goods to the user. It defaults to true to provide backwards compatibility. Will default to false in version 4.0.0.');
       }
@@ -171,24 +409,97 @@ export const requestPurchase = _ref3 => {
     },
     android: async () => {
       if (isAmazon) {
+        if (!sku) {
+          return Promise.reject(new Error('sku is required for Amazon purchase'));
+        }
+
         return RNIapAmazonModule.buyItemByType(sku);
       } else {
-        return getAndroidModule().buyItemByType(ANDROID_ITEM_TYPE_IAP, skus !== null && skus !== void 0 && skus.length ? skus : [sku], null, -1, obfuscatedAccountIdAndroid, obfuscatedProfileIdAndroid, [], isOfferPersonalized ?? false);
+        if (!(sku !== null && sku !== void 0 && sku.length) && !sku) {
+          return Promise.reject(new Error('skus is required for Android purchase'));
+        }
+
+        return getAndroidModule().buyItemByType(ANDROID_ITEM_TYPE_IAP, skus !== null && skus !== void 0 && skus.length ? skus : [sku], undefined, -1, obfuscatedAccountIdAndroid, obfuscatedProfileIdAndroid, [], isOfferPersonalized ?? false);
       }
     }
   }) || Promise.resolve)();
 };
 /**
  * Request a purchase for product. This will be received in `PurchaseUpdatedListener`.
- * @param {string} [sku] The product's sku/ID
- * @param {string} [applicationUsername] The purchaser's user ID
- * @param {boolean} [andDangerouslyFinishTransactionAutomaticallyIOS] You should set this to false and call finishTransaction manually when you have delivered the purchased goods to the user. It defaults to true to provide backwards compatibility. Will default to false in version 4.0.0.
- * @param {string} [purchaseTokenAndroid] purchaseToken that the user is upgrading or downgrading from (Android).
- * @param {ProrationModesAndroid} [prorationModeAndroid] UNKNOWN_SUBSCRIPTION_UPGRADE_DOWNGRADE_POLICY, IMMEDIATE_WITH_TIME_PRORATION, IMMEDIATE_AND_CHARGE_PRORATED_PRICE, IMMEDIATE_WITHOUT_PRORATION, DEFERRED
- * @param {string} [obfuscatedAccountIdAndroid] Specifies an optional obfuscated string that is uniquely associated with the user's account in your app.
- * @param {string} [obfuscatedProfileIdAndroid] Specifies an optional obfuscated string that is uniquely associated with the user's profile in your app.
- * @param {SubscriptionOffers[]} [subscriptionOffers] Array of SubscriptionOffers. Every sku must be paired with a corresponding offerToken
- * @returns {Promise<SubscriptionPurchase | null>} Promise resolves to null when using proratioModesAndroid=DEFERRED, and to a SubscriptionPurchase otherwise
+ * Request a purchase for a subscription.
+
+The response will be received through the `PurchaseUpdatedListener`.
+
+:::note
+`andDangerouslyFinishTransactionAutomatically` defaults to false. We recommend
+always keeping at false, and verifying the transaction receipts on the server-side.
+:::
+
+## Signature
+
+```ts
+requestSubscription(
+  The product's sku/ID 
+  sku,
+
+
+   * You should set this to false and call finishTransaction manually when you have delivered the purchased goods to the user.
+   * @default false
+
+  andDangerouslyFinishTransactionAutomaticallyIOS = false,
+
+   purchaseToken that the user is upgrading or downgrading from (Android). 
+  purchaseTokenAndroid,
+
+  UNKNOWN_SUBSCRIPTION_UPGRADE_DOWNGRADE_POLICY, IMMEDIATE_WITH_TIME_PRORATION, IMMEDIATE_AND_CHARGE_PRORATED_PRICE, IMMEDIATE_WITHOUT_PRORATION, DEFERRED 
+  prorationModeAndroid = -1,
+
+  /** Specifies an optional obfuscated string that is uniquely associated with the user's account in your app. 
+  obfuscatedAccountIdAndroid,
+
+  Specifies an optional obfuscated string that is uniquely associated with the user's profile in your app. 
+  obfuscatedProfileIdAndroid,
+
+  The purchaser's user ID 
+  applicationUsername,
+): Promise<SubscriptionPurchase>
+```
+
+## Usage
+
+```tsx
+import React, {useCallback} from 'react';
+import {Button} from 'react-native';
+import {
+  requestSubscription,
+  Product,
+  Sku,
+  getSubscriptions,
+} from 'react-native-iap';
+
+const App = () => {
+  const subscriptions = useCallback(
+    async () => getSubscriptions(['com.example.subscription']),
+    [],
+  );
+
+  const handlePurchase = async (sku: Sku) => {
+    await requestSubscription({sku});
+  };
+
+  return (
+    <>
+      {subscriptions.map((subscription) => (
+        <Button
+          key={subscription.productId}
+          title="Buy subscription"
+          onPress={() => handlePurchase(subscription.productId)}
+        />
+      ))}
+    </>
+  );
+};
+```
  */
 
 export const requestSubscription = _ref4 => {
@@ -205,6 +516,10 @@ export const requestSubscription = _ref4 => {
   } = _ref4;
   return (Platform.select({
     ios: async () => {
+      if (!sku) {
+        return Promise.reject(new Error('sku is required for iOS subscription'));
+      }
+
       if (andDangerouslyFinishTransactionAutomaticallyIOS) {
         console.warn('You are dangerously allowing react-native-iap to finish your transaction automatically. You should set andDangerouslyFinishTransactionAutomatically to false when calling requestPurchase and call finishTransaction manually when you have delivered the purchased goods to the user. It defaults to true to provide backwards compatibility. Will default to false in version 4.0.0.');
       }
@@ -213,6 +528,10 @@ export const requestSubscription = _ref4 => {
     },
     android: async () => {
       if (isAmazon) {
+        if (!sku) {
+          return Promise.reject(new Error('sku is required for Amazon purchase'));
+        }
+
         return RNIapAmazonModule.buyItemByType(sku);
       } else {
         if (!(subscriptionOffers !== null && subscriptionOffers !== void 0 && subscriptionOffers.length)) {
@@ -222,7 +541,7 @@ export const requestSubscription = _ref4 => {
         return RNIapModule.buyItemByType(ANDROID_ITEM_TYPE_SUBSCRIPTION, subscriptionOffers === null || subscriptionOffers === void 0 ? void 0 : subscriptionOffers.map(so => so.sku), purchaseTokenAndroid, prorationModeAndroid, obfuscatedAccountIdAndroid, obfuscatedProfileIdAndroid, subscriptionOffers === null || subscriptionOffers === void 0 ? void 0 : subscriptionOffers.map(so => so.offerToken), isOfferPersonalized ?? false);
       }
     }
-  }) || Promise.resolve)();
+  }) || (() => Promise.resolve(null)))();
 };
 /**
  * Request a purchase for product. This will be received in `PurchaseUpdatedListener`.
@@ -244,10 +563,22 @@ export const requestPurchaseWithQuantityIOS = _ref5 => {
  *   Call this after you have persisted the purchased state to your server or local data in your app.
  *   `react-native-iap` will continue to deliver the purchase updated events with the successful purchase until you finish the transaction. **Even after the app has relaunched.**
  *   Android: it will consume purchase for consumables and acknowledge purchase for non-consumables.
- * @param {object} purchase The purchase that you would like to finish.
- * @param {boolean} isConsumable Checks if purchase is consumable. Has effect on `android`.
- * @param {string} developerPayloadAndroid Android developerPayload.
- * @returns {Promise<string | void> }
+ *   
+```tsx
+import React from 'react';
+import {Button} from 'react-native';
+import {finishTransaction} from 'react-native-iap';
+
+const App = () => {
+  const handlePurchase = async () => {
+    // ... handle the purchase request
+
+    const result = finishTransaction(purchase);
+  };
+
+  return <Button title="Buy product" onPress={handlePurchase} />;
+};
+``` 
  */
 
 export const finishTransaction = _ref6 => {
@@ -258,22 +589,28 @@ export const finishTransaction = _ref6 => {
   } = _ref6;
   return (Platform.select({
     ios: async () => {
-      return getIosModule().finishTransaction(purchase.transactionId);
+      const transactionId = purchase.transactionId;
+
+      if (!transactionId) {
+        return Promise.reject(new Error('transactionId required to finish iOS transaction'));
+      }
+
+      return getIosModule().finishTransaction(transactionId);
     },
     android: async () => {
-      if (purchase) {
+      if (purchase !== null && purchase !== void 0 && purchase.purchaseToken) {
         if (isConsumable) {
           return getAndroidModule().consumeProduct(purchase.purchaseToken, developerPayloadAndroid);
         } else if (purchase.userIdAmazon || !purchase.isAcknowledgedAndroid && purchase.purchaseStateAndroid === PurchaseStateAndroid.PURCHASED) {
           return getAndroidModule().acknowledgePurchase(purchase.purchaseToken, developerPayloadAndroid);
         } else {
-          throw new Error('purchase is not suitable to be purchased');
+          return Promise.reject(new Error('purchase is not suitable to be purchased'));
         }
-      } else {
-        throw new Error('purchase is not assigned');
       }
+
+      return Promise.reject(new Error('purchase is not suitable to be purchased'));
     }
-  }) || Promise.resolve)();
+  }) || (() => Promise.reject(new Error('Unsupported Platform'))))();
 };
 /**
  * Clear Transaction (iOS only)
@@ -331,6 +668,7 @@ export const getPromotedProductIOS = () => getIosModule().promotedProduct();
  */
 
 export const buyPromotedProductIOS = () => getIosModule().buyPromotedProduct();
+const TEST_RECEIPT = 21007;
 
 const requestAgnosticReceiptValidationIos = async receiptBody => {
   const response = await enhancedFetch('https://buy.itunes.apple.com/verifyReceipt', {
@@ -339,7 +677,7 @@ const requestAgnosticReceiptValidationIos = async receiptBody => {
   }); // Best practice is to check for test receipt and check sandbox instead
   // https://developer.apple.com/documentation/appstorereceipts/verifyreceipt
 
-  if (response && response.status === ReceiptValidationStatus.TEST_RECEIPT) {
+  if (response && response.status === TEST_RECEIPT) {
     const testResponse = await enhancedFetch('https://sandbox.itunes.apple.com/verifyReceipt', {
       method: 'POST',
       body: receiptBody
@@ -392,7 +730,10 @@ export const validateReceiptIos = async _ref10 => {
   }
 
   const url = isTest ? 'https://sandbox.itunes.apple.com/verifyReceipt' : 'https://buy.itunes.apple.com/verifyReceipt';
-  return await enhancedFetch(url);
+  return await enhancedFetch(url, {
+    method: 'POST',
+    body: receiptBody
+  });
 };
 /**
  * Validate receipt for Android. NOTE: This method is here for debugging purposes only. Including