expo-iap 1.0.3 → 2.0.0-rc.1

package/package.json

@@ -1,76 +1,47 @@
 {
   "name": "expo-iap",
-  "version": "1.0.3",
-  "packageManager": "yarn@3.1.1",
-  "description": "React Native In App Purchase Module.",
-  "main": "index.js",
-  "types": "index.d.ts",
-  "postinstall": "dooboolab-welcome postinstall",
+  "version": "2.0.0-rc.1",
+  "description": "In App Purchase module in Expo",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
   "scripts": {
-    "build": "tsc && flowgen index.d.ts -o index.js.flow",
-    "flow": "flow",
-    "lint": "eslint src --ext .ts,.tsx",
-    "lint:android": "cd android ",
-    "test": "jest",
-    "test:flow": "flow",
-    "test:typescript": "tsc --noEmit",
-    "tsc:sync": "npx typesync",
-    "tsc": "tsc",
-    "validate": "yarn lint && yarn test:typescript && yarn test:flow && yarn test"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/dooboolab/react-native-iap#expo"
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "eslint --ext .ts,.tsx,.js,.jsx src",
+    "test": "expo-module test",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module",
+    "open:ios": "xed example/ios",
+    "open:android": "open -a \"Android Studio\" example/android",
+    "lint:kotlin": "ktlint --format ./android"
   },
   "keywords": [
-    "expo",
     "react-native",
-    "in app purchase",
-    "in-app-purchase",
-    "billing"
-  ],
-  "author": "dooboolab",
-  "contributors": [
-    {
-      "name": "Andres Aguilar",
-      "url": "https://github.com/andresesfm"
-    }
+    "expo",
+    "expo-iap",
+    "ExpoIap"
   ],
+  "repository": "https://github.com/hyochan",
+  "bugs": {
+    "url": "https://github.com/hyochan/issues"
+  },
+  "author": "hyochan <dooboolab@gmail.com> (https://github.com/hyochan)",
   "license": "MIT",
+  "homepage": "https://github.com/hyochan#readme",
+  "dependencies": {},
+  "devDependencies": {
+    "@types/react": "^18.0.25",
+    "expo-module-scripts": "^3.5.2",
+    "expo-modules-core": "^1.12.19",
+    "eslint": "8.57.0",
+    "eslint-config-expo": "^7.1.2",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3"
+  },
   "peerDependencies": {
     "expo": "*",
     "react": "*",
     "react-native": "*"
-  },
-  "dependencies": {
-    "dooboolab-welcome": "1.3.2"
-  },
-  "devDependencies": {
-    "@babel/core": "7.16.0",
-    "@babel/plugin-proposal-class-properties": "7.16.0",
-    "@babel/plugin-proposal-private-methods": "7.16.0",
-    "@babel/preset-env": "7.16.4",
-    "@babel/preset-react": "7.16.0",
-    "@babel/preset-typescript": "7.16.0",
-    "@dooboo/eslint-config": "1.2.2",
-    "@testing-library/jest-native": "4.0.4",
-    "@testing-library/react-native": "8.0.0",
-    "@types/eslint": "8.2.0",
-    "@types/jest": "27.0.3",
-    "@types/react": "17.0.37",
-    "@types/react-native": "0.66.6",
-    "@typescript-eslint/eslint-plugin": "^5.9.0",
-    "babel-core": "7.0.0-bridge.0",
-    "babel-jest": "27.4.2",
-    "eslint": "8.3.0",
-    "flow-bin": "0.166.1",
-    "flowgen": "1.16.0",
-    "jest": "27.4.3",
-    "metro-react-native-babel-preset": "0.66.2",
-    "monolinter": "1.0.4",
-    "prettier": "2.5.0",
-    "react-native": "0.65.1",
-    "ts-jest": "27.0.7",
-    "typescript": "4.5.2"
   }
 }

package/src/ExpoIap.types.ts

@@ -0,0 +1,125 @@
+import {
+  ProductAndroid,
+  RequestPurchaseAndroidProps,
+  RequestSubscriptionAndroidProps,
+  SubscriptionProductAndroid,
+} from './types/ExpoIapAndroid.types';
+import {
+  ProductIos,
+  RequestPurchaseIosProps,
+  RequestSubscriptionIosProps,
+  SubscriptionProductIos,
+} from './types/ExpoIapIos.types';
+export type ChangeEventPayload = {
+  value: string;
+};
+
+export type Product = ProductAndroid | ProductIos;
+export enum ProductType {
+  InAppPurchase = 'inapp',
+  Subscription = 'subs',
+}
+
+export type SubscriptionProduct =
+  | SubscriptionProductAndroid
+  | SubscriptionProductIos;
+
+export type RequestPurchaseProps =
+  | RequestPurchaseIosProps
+  | RequestPurchaseAndroidProps;
+
+enum PurchaseStateAndroid {
+  UNSPECIFIED_STATE = 0,
+  PURCHASED = 1,
+  PENDING = 2,
+}
+
+export type ProductPurchase = {
+  productId: string;
+  transactionId?: string;
+  transactionDate: number;
+  transactionReceipt: string;
+  purchaseToken?: string;
+  //iOS
+  quantityIOS?: number;
+  originalTransactionDateIOS?: number;
+  originalTransactionIdentifierIOS?: string;
+  verificationResultIOS?: string;
+  appAccountToken?: string;
+  //Android
+  productIds?: string[];
+  dataAndroid?: string;
+  signatureAndroid?: string;
+  autoRenewingAndroid?: boolean;
+  purchaseStateAndroid?: PurchaseStateAndroid;
+  isAcknowledgedAndroid?: boolean;
+  packageNameAndroid?: string;
+  developerPayloadAndroid?: string;
+  obfuscatedAccountIdAndroid?: string;
+  obfuscatedProfileIdAndroid?: string;
+};
+
+export type RequestSubscriptionProps =
+  | RequestSubscriptionAndroidProps
+  | RequestSubscriptionIosProps;
+
+enum TransactionReason {
+  PURCHASE = 'PURCHASE',
+  RENEWAL = 'RENEWAL',
+}
+
+export type SubscriptionPurchase = {
+  autoRenewingAndroid?: boolean;
+  originalTransactionDateIOS?: number;
+  originalTransactionIdentifierIOS?: string;
+  verificationResultIOS?: string;
+  transactionReasonIOS?: TransactionReason | string;
+} & ProductPurchase;
+
+export type Purchase = ProductPurchase | SubscriptionPurchase;
+
+export type PurchaseResult = {
+  responseCode?: number;
+  debugMessage?: string;
+  code?: string;
+  message?: string;
+  purchaseToken?: string;
+};
+
+export enum ErrorCode {
+  E_UNKNOWN = 'E_UNKNOWN',
+  E_USER_CANCELLED = 'E_USER_CANCELLED',
+  E_USER_ERROR = 'E_USER_ERROR',
+  E_ITEM_UNAVAILABLE = 'E_ITEM_UNAVAILABLE',
+  E_REMOTE_ERROR = 'E_REMOTE_ERROR',
+  E_NETWORK_ERROR = 'E_NETWORK_ERROR',
+  E_SERVICE_ERROR = 'E_SERVICE_ERROR',
+  E_RECEIPT_FAILED = 'E_RECEIPT_FAILED',
+  E_RECEIPT_FINISHED_FAILED = 'E_RECEIPT_FINISHED_FAILED',
+  E_NOT_PREPARED = 'E_NOT_PREPARED',
+  E_NOT_ENDED = 'E_NOT_ENDED',
+  E_ALREADY_OWNED = 'E_ALREADY_OWNED',
+  E_DEVELOPER_ERROR = 'E_DEVELOPER_ERROR',
+  E_BILLING_RESPONSE_JSON_PARSE_ERROR = 'E_BILLING_RESPONSE_JSON_PARSE_ERROR',
+  E_DEFERRED_PAYMENT = 'E_DEFERRED_PAYMENT',
+  E_INTERRUPTED = 'E_INTERRUPTED',
+  E_IAP_NOT_AVAILABLE = 'E_IAP_NOT_AVAILABLE',
+}
+
+export class PurchaseError implements Error {
+  constructor(
+    public name: string,
+    public message: string,
+    public responseCode?: number,
+    public debugMessage?: string,
+    public code?: ErrorCode,
+    public productId?: string,
+  ) {
+    this.name = '[react-native-iap]: PurchaseError';
+    this.message = message;
+    this.responseCode = responseCode;
+    this.debugMessage = debugMessage;
+    this.code = code;
+    this.productId = productId;
+  }
+}

package/src/ExpoIapModule.ts

@@ -0,0 +1,5 @@
+import {requireNativeModule} from 'expo-modules-core';
+
+// It loads the native module object from the JSI or falls back to
+// the bridge module (from NativeModulesProxy) if the remote debugger is on.
+export default requireNativeModule('ExpoIap');

package/src/index.ts

@@ -0,0 +1,397 @@
+// Import the native module. On web, it will be resolved to ExpoIap.web.ts
+// and on native platforms to ExpoIap.ts
+import {NativeModulesProxy, EventEmitter} from 'expo-modules-core';
+import {Platform} from 'react-native';
+
+import {
+  Product,
+  ProductPurchase,
+  ProductType,
+  Purchase,
+  PurchaseError,
+  PurchaseResult,
+  RequestSubscriptionProps,
+  SubscriptionProduct,
+  SubscriptionPurchase,
+} from './ExpoIap.types';
+import ExpoIapModule from './ExpoIapModule';
+import {RequestPurchaseAndroidProps, RequestSubscriptionAndroidProps} from './types/ExpoIapAndroid.types';
+import {
+  PaymentDiscount,
+  ProductIos,
+  RequestPurchaseIosProps,
+  RequestSubscriptionIosProps,
+  SubscriptionProductIos,
+  TransactionSk2,
+} from './types/ExpoIapIos.types';
+import {isProductIos} from './modules/ios';
+
+export * from './modules/android';
+export * from './modules/ios';
+
+// Get the native constant value.
+export const PI = ExpoIapModule.PI;
+
+export enum IapEvent {
+  PurchaseUpdated = 'purchase-updated',
+  PurchaseError = 'purchase-error',
+  TransactionIapUpdated = 'iap-transaction-updated',
+}
+
+export async function setValueAsync(value: string) {
+  return await ExpoIapModule.setValueAsync(value);
+}
+
+export const emitter = new EventEmitter(
+  ExpoIapModule ?? NativeModulesProxy.ExpoIap,
+);
+
+export const purchaseUpdatedListener = (
+  listener: (event: Purchase) => void,
+) => {
+  const emitterSubscription = emitter.addListener(
+    IapEvent.PurchaseUpdated,
+    listener,
+  );
+  return emitterSubscription;
+};
+
+export const purchaseErrorListener = (
+  listener: (error: PurchaseError) => void,
+) => {
+  return emitter.addListener<PurchaseError>(IapEvent.PurchaseError, listener);
+};
+
+export function initConnection() {
+  return ExpoIapModule.initConnection();
+}
+
+export const getProducts = async (skus: string[]): Promise<Product[]> => {
+  if (!skus?.length) {
+    return Promise.reject(new Error('"skus" is required'));
+  }
+
+  return Platform.select({
+    ios: async () => {
+      const items = (await ExpoIapModule.getItems(skus)) as ProductIos[];
+      return items.filter((item: ProductIos) => isProductIos(item));
+    },
+    android: async () => {
+      const products = await ExpoIapModule.getItemsByType(
+        ProductType.InAppPurchase,
+        skus,
+      );
+
+      return products;
+    },
+    default: () => Promise.reject(new Error('Unsupported Platform')),
+  })();
+};
+
+export const getSubscriptions = async (
+  skus: string[],
+): Promise<SubscriptionProduct[]> => {
+  if (!skus?.length) {
+    return Promise.reject(new Error('"skus" is required'));
+  }
+
+  return Platform.select({
+    ios: async (): Promise<SubscriptionProductIos[]> => {
+      const items: SubscriptionProductIos[] = (
+        (await ExpoIapModule.getItems(skus)) as SubscriptionProductIos[]
+      ).filter((item: SubscriptionProductIos) => skus.includes(item.id));
+
+      return items;
+    },
+    android: async () => {
+      return ExpoIapModule.getItemsByType('subs', skus);
+    },
+    default: () => Promise.reject(new Error('Unsupported Platform')),
+  })();
+};
+
+export async function endConnection(): Promise<boolean> {
+  return ExpoIapModule.endConnection();
+}
+
+export const getPurchaseHistory = ({
+  alsoPublishToEventListener = false,
+  automaticallyFinishRestoredTransactions = true,
+  onlyIncludeActiveItems = false,
+}: {
+  alsoPublishToEventListener?: boolean;
+  automaticallyFinishRestoredTransactions?: boolean;
+  onlyIncludeActiveItems?: boolean;
+} = {}): Promise<ProductPurchase[]> =>
+  (
+    Platform.select({
+      ios: async () => {
+        return ExpoIapModule.getAvailableItems(
+          alsoPublishToEventListener,
+          onlyIncludeActiveItems,
+        );
+      },
+      android: async () => {
+        const products = await ExpoIapModule.getPurchaseHistoryByType(
+          ProductType.InAppPurchase,
+        );
+
+        const subscriptions = await ExpoIapModule.getPurchaseHistoryByType(
+          ProductType.Subscription,
+        );
+
+        return products.concat(subscriptions);
+      },
+    }) || (() => Promise.resolve([]))
+  )();
+
+export const getAvailablePurchases = ({
+  alsoPublishToEventListener = false,
+  automaticallyFinishRestoredTransactions = false,
+  onlyIncludeActiveItems = true,
+}: {
+  alsoPublishToEventListener?: boolean;
+  automaticallyFinishRestoredTransactions?: boolean;
+  onlyIncludeActiveItems?: boolean;
+} = {}): Promise<ProductPurchase[]> =>
+  (
+    Platform.select({
+      ios: () =>
+        ExpoIapModule.getAvailableItems(
+          alsoPublishToEventListener,
+          onlyIncludeActiveItems,
+        ),
+      android: async () => {
+        const products = await ExpoIapModule.getAvailableItemsByType(
+          ProductType.InAppPurchase,
+        );
+
+        const subscriptions = await ExpoIapModule.getAvailableItemsByType(
+          ProductType.Subscription,
+        );
+
+        return products.concat(subscriptions);
+      },
+    }) || (() => Promise.resolve([]))
+  )();
+
+const offerToRecordIos = (
+  offer: PaymentDiscount | undefined,
+): Record<keyof PaymentDiscount, string> | undefined => {
+  if (!offer) {
+    return undefined;
+  }
+  return {
+    identifier: offer.identifier,
+    keyIdentifier: offer.keyIdentifier,
+    nonce: offer.nonce,
+    signature: offer.signature,
+    timestamp: offer.timestamp.toString(),
+  };
+};
+
+const iosTransactionToPurchaseMap = ({
+  id,
+  originalPurchaseDate,
+  productID,
+  purchaseDate,
+  purchasedQuantity,
+  originalID,
+  verificationResult,
+  appAccountToken,
+  jsonRepresentation,
+}: TransactionSk2): Purchase => {
+  let transactionReasonIOS;
+
+  try {
+    if (jsonRepresentation) {
+      const transactionData = JSON.parse(jsonRepresentation);
+      transactionReasonIOS = transactionData.transactionReason;
+    }
+  } catch (e) {
+    console.log('SK2 Error parsing jsonRepresentation', e);
+  }
+  const purchase: Purchase = {
+    productId: productID,
+    transactionId: String(id),
+    transactionDate: purchaseDate, //??
+    transactionReceipt: '', // Not available
+    purchaseToken: '', //Not available
+    quantityIOS: purchasedQuantity,
+    originalTransactionDateIOS: originalPurchaseDate,
+    originalTransactionIdentifierIOS: originalID,
+    verificationResultIOS: verificationResult ?? '',
+    appAccountToken: appAccountToken ?? '',
+    transactionReasonIOS: transactionReasonIOS ?? '',
+  };
+  return purchase;
+};
+
+export const requestPurchase = (
+  request: RequestPurchaseIosProps | RequestPurchaseAndroidProps,
+): Promise<ProductPurchase | ProductPurchase[] | void> =>
+  (
+    Platform.select({
+      ios: async () => {
+        if (!('sku' in request)) {
+          throw new Error('sku is required for iOS purchase');
+        }
+
+        const {
+          sku,
+          andDangerouslyFinishTransactionAutomaticallyIOS = false,
+          appAccountToken,
+          quantity,
+          withOffer,
+        } = request;
+
+        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.',
+          );
+        }
+
+        const offer = offerToRecordIos(withOffer);
+
+        const result = await ExpoIapModule.buyProduct(
+          sku,
+          andDangerouslyFinishTransactionAutomaticallyIOS,
+          appAccountToken,
+          quantity ?? -1,
+          offer,
+        );
+
+        const purchase = iosTransactionToPurchaseMap(result);
+        return Promise.resolve(purchase);
+      },
+      android: async () => {
+        if (!('skus' in request) || !request.skus.length) {
+          throw new Error('skus is required for Android purchase');
+        }
+
+        const {
+          skus,
+          obfuscatedAccountIdAndroid,
+          obfuscatedProfileIdAndroid,
+          isOfferPersonalized,
+        } = request;
+
+        return ExpoIapModule.buyItemByType({
+          type: ProductType.InAppPurchase,
+          skuArr: skus,
+          purchaseToken: undefined,
+          replacementMode: -1,
+          obfuscatedAccountId: obfuscatedAccountIdAndroid,
+          obfuscatedProfileId: obfuscatedProfileIdAndroid,
+          offerTokenArr: [],
+          isOfferPersonalized: isOfferPersonalized ?? false,
+        });
+      },
+    }) || Promise.resolve
+  )();
+
+export const requestSubscription = (
+  request: RequestSubscriptionProps,
+): Promise<SubscriptionPurchase | SubscriptionPurchase[] | null | void> =>
+  (
+    Platform.select({
+      ios: async () => {
+        if (!('sku' in request)) {
+          throw new Error('sku is required for iOS subscriptions');
+        }
+
+        const {
+          sku,
+          andDangerouslyFinishTransactionAutomaticallyIOS = false,
+          appAccountToken,
+          quantity,
+          withOffer,
+        } = request as RequestSubscriptionIosProps;
+
+        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.',
+          );
+        }
+
+        const offer = offerToRecordIos(withOffer);
+
+        const purchase = iosTransactionToPurchaseMap(
+          await ExpoIapModule.buyProduct(
+            sku,
+            andDangerouslyFinishTransactionAutomaticallyIOS,
+            appAccountToken,
+            quantity ?? -1,
+            offer,
+          ),
+        );
+        return Promise.resolve(purchase);
+      },
+      android: async () => {
+        console.log('requestSubscription', request);
+        const {
+          skus,
+          isOfferPersonalized,
+          obfuscatedAccountIdAndroid,
+          obfuscatedProfileIdAndroid,
+          subscriptionOffers,
+          replacementModeAndroid,
+          purchaseTokenAndroid,
+        } = request as RequestSubscriptionAndroidProps;
+
+        return ExpoIapModule.buyItemByType({
+          type: ProductType.Subscription,
+          skuArr: skus.map((so) => so),
+          purchaseToken: purchaseTokenAndroid,
+          replacementMode: replacementModeAndroid,
+          obfuscatedAccountId: obfuscatedAccountIdAndroid,
+          obfuscatedProfileId: obfuscatedProfileIdAndroid,
+          offerTokenArr: subscriptionOffers.map((so) => so.offerToken),
+          isOfferPersonalized: isOfferPersonalized ?? false,
+        });
+      },
+    }) || (() => Promise.resolve(null))
+  )();
+
+export const finishTransaction = ({
+  purchase,
+  isConsumable,
+  developerPayloadAndroid,
+}: {
+  purchase: Purchase;
+  isConsumable?: boolean;
+  developerPayloadAndroid?: string;
+}): Promise<PurchaseResult | boolean> => {
+  return (
+    Platform.select({
+      ios: async () => {
+        const transactionId = purchase.transactionId;
+
+        if (!transactionId) {
+          return Promise.reject(
+            new Error('transactionId required to finish iOS transaction'),
+          );
+        }
+        await ExpoIapModule.finishTransaction(transactionId);
+        return Promise.resolve(true);
+      },
+      android: async () => {
+        if (purchase?.purchaseToken) {
+          if (!isConsumable) {
+            return Promise.reject(
+              new Error('purchase is not suitable to be purchased'),
+            );
+          }
+
+          return ExpoIapModule.consumeProduct(
+            purchase.purchaseToken,
+            developerPayloadAndroid,
+          );
+        }
+        return Promise.reject(
+          new Error('purchase is not suitable to be purchased'),
+        );
+      },
+    }) || (() => Promise.reject(new Error('Unsupported Platform')))
+  )();
+};