react-native-iap 10.1.0 → 10.1.1

package/src/iap.ts

@@ -14,12 +14,12 @@ import {
   Product,
   ProductPurchase,
   ProductType,
-  ProrationModesAndroid,
   Purchase,
   PurchaseResult,
+  RequestPurchase,
+  RequestSubscription,
   Sku,
   Subscription,
-  SubscriptionOffer,
   SubscriptionPurchase,
 } from './types';
 import {InstallSourceAndroid, PurchaseStateAndroid} from './types';
@@ -81,13 +81,43 @@ 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 = (): Promise<boolean> =>
   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>}
  */
 export const endConnection = (): Promise<boolean> =>
@@ -103,8 +133,47 @@ export const flushFailedPurchasesCachedAsPendingAndroid =
 
 /**
  * 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 = ({
   skus,
@@ -134,8 +203,24 @@ export const getProducts = ({
 
 /**
  * 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 = ({
   skus,
@@ -165,7 +250,26 @@ export const getSubscriptions = ({
 
 /**
  * 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 = (): Promise<
   (ProductPurchase | SubscriptionPurchase)[]
@@ -195,7 +299,81 @@ export const getPurchaseHistory = (): Promise<
 
 /**
  * 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 = (): Promise<
   (ProductPurchase | SubscriptionPurchase)[]
@@ -225,14 +403,70 @@ export const getAvailablePurchases = (): Promise<
 
 /**
  * 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 = ({
@@ -243,16 +477,7 @@ export const requestPurchase = ({
   obfuscatedProfileIdAndroid,
   skus,
   isOfferPersonalized,
-}: {
-  sku?: Sku;
-  andDangerouslyFinishTransactionAutomaticallyIOS?: boolean;
-  applicationUsername?: string;
-  obfuscatedAccountIdAndroid?: string;
-  obfuscatedProfileIdAndroid?: string;
-  /** For Google Play Billing Library 5 https://developer.android.com/google/play/billing/integrate#personalized-price */
-  skus?: Sku[];
-  isOfferPersonalized?: boolean;
-}): Promise<ProductPurchase | void> =>
+}: RequestPurchase): Promise<ProductPurchase | void> =>
   (
     Platform.select({
       ios: async () => {
@@ -302,15 +527,80 @@ export const requestPurchase = ({
 
 /**
  * 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 = ({
   sku,
@@ -322,19 +612,7 @@ export const requestSubscription = ({
   obfuscatedAccountIdAndroid,
   obfuscatedProfileIdAndroid,
   isOfferPersonalized = undefined,
-}: {
-  sku?: Sku;
-  andDangerouslyFinishTransactionAutomaticallyIOS?: boolean;
-  applicationUsername?: string;
-  purchaseTokenAndroid?: string;
-  prorationModeAndroid?: ProrationModesAndroid;
-  /** For Google Play Billing Library 5 */
-  subscriptionOffers?: SubscriptionOffer[];
-  obfuscatedAccountIdAndroid?: string;
-  obfuscatedProfileIdAndroid?: string;
-  /** For Google Play Billing Library 5 https://developer.android.com/google/play/billing/integrate#personalized-price */
-  isOfferPersonalized?: boolean;
-}): Promise<SubscriptionPurchase | null | void> =>
+}: RequestSubscription): Promise<SubscriptionPurchase | null | void> =>
   (
     Platform.select({
       ios: async () => {
@@ -405,10 +683,22 @@ export const requestPurchaseWithQuantityIOS = ({
  *   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 = ({
   purchase,
@@ -603,7 +893,10 @@ export const validateReceiptIos = async ({
     ? 'https://sandbox.itunes.apple.com/verifyReceipt'
     : 'https://buy.itunes.apple.com/verifyReceipt';
 
-  return await enhancedFetch<ReceiptValidationResponse>(url);
+  return await enhancedFetch<ReceiptValidationResponse>(url, {
+    method: 'POST',
+    body: receiptBody,
+  });
 };
 
 /**

package/src/index.ts

@@ -4,3 +4,4 @@ export * from './eventEmitter';
 export * from './hooks/useIAP';
 export * from './hooks/withIAPContext';
 export * from './purchaseError';
+export * from './modules';

package/src/types/index.ts

@@ -4,6 +4,8 @@ import type {
   IosModuleProps,
 } from '../modules';
 
+import type * as Apple from './apple';
+
 export type Sku = string;
 
 export enum ProrationModesAndroid {
@@ -45,7 +47,7 @@ export enum ProductType {
 
 export interface ProductCommon {
   type: 'subs' | 'sub' | 'inapp' | 'iap';
-  productId: string;
+  productId: string; //iOS
   productIds?: string[];
   title: string;
   description: string;
@@ -109,15 +111,19 @@ export interface Discount {
   subscriptionPeriod: string;
 }
 
-export interface Product extends ProductCommon {
+export interface ProductAndroid extends ProductCommon {
   type: 'inapp' | 'iap';
-  // Android V5
   oneTimePurchaseOfferDetails?: {
     priceCurrencyCode: string;
     formattedPrice: string;
     priceAmountMicros: string;
   };
 }
+export interface ProductIOS extends ProductCommon {
+  type: 'inapp' | 'iap';
+}
+
+export type Product = ProductAndroid & ProductIOS;
 
 // Android V5
 export interface SubscriptionAndroid extends ProductCommon {
@@ -145,7 +151,6 @@ export interface SubscriptionAndroid extends ProductCommon {
 
 export interface SubscriptionIOS extends ProductCommon {
   type: 'subs';
-
   discounts?: Discount[];
   introductoryPrice?: string;
   introductoryPriceAsAmountIOS?: string;
@@ -167,6 +172,28 @@ export interface SubscriptionIOS extends ProductCommon {
 }
 
 export type Subscription = SubscriptionAndroid & SubscriptionIOS;
+export interface RequestPurchaseBaseAndroid {
+  obfuscatedAccountIdAndroid?: string;
+  obfuscatedProfileIdAndroid?: string;
+  isOfferPersonalized?: boolean; // For AndroidBilling V5 https://developer.android.com/google/play/billing/integrate#personalized-price
+}
+
+export interface RequestPurchaseAndroid extends RequestPurchaseBaseAndroid {
+  skus?: Sku[];
+}
+
+export interface RequestPurchaseIOS {
+  sku?: Sku;
+  andDangerouslyFinishTransactionAutomaticallyIOS?: boolean;
+  /**
+   * UUID representing user account
+   */
+  applicationUsername?: string;
+  quantity?: number;
+  withOffer?: Apple.PaymentDiscount;
+}
+
+export type RequestPurchase = RequestPurchaseAndroid & RequestPurchaseIOS;
 
 /**
  * In order to purchase a new subscription, every sku must have a selected offerToken
@@ -177,6 +204,17 @@ export interface SubscriptionOffer {
   offerToken: string;
 }
 
+export interface RequestSubscriptionAndroid extends RequestPurchaseBaseAndroid {
+  purchaseTokenAndroid?: string;
+  prorationModeAndroid?: ProrationModesAndroid;
+  subscriptionOffers?: SubscriptionOffer[]; // For AndroidBilling V5
+}
+
+export type RequestSubscriptionIOS = RequestPurchaseIOS;
+
+export type RequestSubscription = RequestSubscriptionAndroid &
+  RequestSubscriptionIOS;
+
 declare module 'react-native' {
   interface NativeModulesStatic {
     RNIapIos: IosModuleProps;