expo-iap 2.7.11 → 2.7.13

package/ios/ExpoIapModule.swift

@@ -48,9 +48,10 @@ func serializeTransaction(_ transaction: Transaction, jwsRepresentationIos: Stri
     }
 
     var purchaseMap: [String: Any?] = [
-        "id": transaction.productID,
+        "id": String(transaction.id),
+        "productId": transaction.productID,
         "ids": [transaction.productID],
-        "transactionId": String(transaction.id),
+        "transactionId": String(transaction.id), // @deprecated - use id instead
         "transactionDate": transaction.purchaseDate.timeIntervalSince1970 * 1000,
         "transactionReceipt": jwsReceipt,
         "platform": "ios",
@@ -240,7 +241,7 @@ public class ExpoIapModule: Module {
             "ERROR_CODES": IapErrorCode.toDictionary()
         ])
 
-        Events(IapEvent.PurchaseUpdated, IapEvent.PurchaseError)
+        Events(IapEvent.PurchaseUpdated, IapEvent.PurchaseError, IapEvent.PromotedProductIOS)
 
         OnStartObserving {
             self.hasListeners = true
@@ -493,6 +494,14 @@ public class ExpoIapModule: Module {
                         options.insert(.appAccountToken(appAccountUUID))
                     }
                     guard let windowScene = await self.currentWindowScene() else {
+                        let errorData = [
+                            "responseCode": IapErrorCode.serviceError,
+                            "debugMessage": "Could not find window scene",
+                            "code": IapErrorCode.serviceError,
+                            "message": "Could not find window scene",
+                            "productId": sku,
+                        ]
+                        self.sendEvent(IapEvent.PurchaseError, errorData)
                         throw Exception(name: "ExpoIapModule", description: "Could not find window scene", code: IapErrorCode.serviceError)
                     }
                     let result: Product.PurchaseResult
@@ -536,19 +545,105 @@ public class ExpoIapModule: Module {
                             return serialized
                         }
                     case .userCancelled:
+                        let errorData = [
+                            "responseCode": IapErrorCode.userCancelled,
+                            "debugMessage": "User cancelled the purchase",
+                            "code": IapErrorCode.userCancelled,
+                            "message": "User cancelled the purchase",
+                            "productId": sku,
+                        ]
+                        self.sendEvent(IapEvent.PurchaseError, errorData)
                         throw Exception(name: "ExpoIapModule", description: "User cancelled the purchase", code: IapErrorCode.userCancelled)
                     case .pending:
+                        let errorData = [
+                            "responseCode": IapErrorCode.deferredPayment,
+                            "debugMessage": "The payment was deferred",
+                            "code": IapErrorCode.deferredPayment,
+                            "message": "The payment was deferred",
+                            "productId": sku,
+                        ]
+                        self.sendEvent(IapEvent.PurchaseError, errorData)
                         throw Exception(name: "ExpoIapModule", description: "The payment was deferred", code: IapErrorCode.deferredPayment)
                     @unknown default:
+                        let errorData = [
+                            "responseCode": IapErrorCode.unknown,
+                            "debugMessage": "Unknown purchase result",
+                            "code": IapErrorCode.unknown,
+                            "message": "Unknown purchase result",
+                            "productId": sku,
+                        ]
+                        self.sendEvent(IapEvent.PurchaseError, errorData)
                         throw Exception(name: "ExpoIapModule", description: "Unknown purchase result", code: IapErrorCode.unknown)
                     }
                 } catch {
                     if error is Exception {
                         throw error
                     }
-                    throw Exception(name: "ExpoIapModule", description: "Purchase failed: \(error.localizedDescription)", code: IapErrorCode.purchaseError)
+                    
+                    // Map StoreKit errors to proper error codes
+                    var errorCode = IapErrorCode.purchaseError
+                    var errorMessage = error.localizedDescription
+                    
+                    // Check for specific StoreKit error types
+                    if let nsError = error as NSError? {
+                        switch nsError.domain {
+                        case "SKErrorDomain":
+                            // Handle SKError codes
+                            switch nsError.code {
+                            case 0: // SKError.unknown
+                                errorCode = IapErrorCode.unknown
+                            case 1: // SKError.clientInvalid
+                                errorCode = IapErrorCode.serviceError
+                            case 2: // SKError.paymentCancelled
+                                errorCode = IapErrorCode.userCancelled
+                                errorMessage = "User cancelled the purchase"
+                            case 3: // SKError.paymentInvalid
+                                errorCode = IapErrorCode.userError
+                            case 4: // SKError.paymentNotAllowed
+                                errorCode = IapErrorCode.userError
+                                errorMessage = "Payment not allowed"
+                            case 5: // SKError.storeProductNotAvailable
+                                errorCode = IapErrorCode.itemUnavailable
+                            case 6: // SKError.cloudServicePermissionDenied
+                                errorCode = IapErrorCode.serviceError
+                            case 7: // SKError.cloudServiceNetworkConnectionFailed
+                                errorCode = IapErrorCode.networkError
+                            case 8: // SKError.cloudServiceRevoked
+                                errorCode = IapErrorCode.serviceError
+                            default:
+                                errorCode = IapErrorCode.purchaseError
+                            }
+                        case "NSURLErrorDomain":
+                            errorCode = IapErrorCode.networkError
+                            errorMessage = "Network error: \(error.localizedDescription)"
+                        default:
+                            errorCode = IapErrorCode.purchaseError
+                        }
+                    } else if error.localizedDescription.lowercased().contains("network") {
+                        errorCode = IapErrorCode.networkError
+                    } else if error.localizedDescription.lowercased().contains("cancelled") {
+                        errorCode = IapErrorCode.userCancelled
+                    }
+                    
+                    let errorData = [
+                        "responseCode": errorCode,
+                        "debugMessage": "Purchase failed: \(error.localizedDescription)",
+                        "code": errorCode,
+                        "message": errorMessage,
+                        "productId": sku,
+                    ]
+                    self.sendEvent(IapEvent.PurchaseError, errorData)
+                    throw Exception(name: "ExpoIapModule", description: errorMessage, code: errorCode)
                 }
             } else {
+                let errorData = [
+                    "responseCode": IapErrorCode.itemUnavailable,
+                    "debugMessage": "Invalid product ID",
+                    "code": IapErrorCode.itemUnavailable,
+                    "message": "Invalid product ID",
+                    "productId": sku,
+                ]
+                self.sendEvent(IapEvent.PurchaseError, errorData)
                 throw Exception(name: "ExpoIapModule", description: "Invalid product ID", code: IapErrorCode.itemUnavailable)
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-iap",
-  "version": "2.7.11",
+  "version": "2.7.13",
   "description": "In App Purchase module in Expo",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/plugin/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/withIAP.ts"],"version":"5.8.3"}
+{"root":["./src/withIAP.ts"],"version":"5.9.2"}

package/src/ExpoIap.types.ts

@@ -28,8 +28,9 @@ export type ProductBase = {
 };
 
 export type PurchaseBase = {
-  id: string;
-  transactionId?: string;
+  id: string; // Transaction identifier - used by finishTransaction
+  productId: string; // Product identifier - which product was purchased
+  transactionId?: string; // @deprecated - use id instead
   transactionDate: number;
   transactionReceipt: string;
 };

package/src/helpers/subscription.ts

@@ -0,0 +1,122 @@
+import {Platform} from 'react-native';
+import {getAvailablePurchases} from '../index';
+
+export interface ActiveSubscription {
+  productId: string;
+  isActive: boolean;
+  expirationDateIOS?: Date;
+  autoRenewingAndroid?: boolean;
+  environmentIOS?: string;
+  willExpireSoon?: boolean;
+  daysUntilExpirationIOS?: number;
+}
+
+/**
+ * Get all active subscriptions with detailed information
+ * @param subscriptionIds - Optional array of subscription product IDs to filter. If not provided, returns all active subscriptions.
+ * @returns Promise<ActiveSubscription[]> array of active subscriptions with details
+ */
+export const getActiveSubscriptions = async (
+  subscriptionIds?: string[],
+): Promise<ActiveSubscription[]> => {
+  try {
+    const purchases = await getAvailablePurchases();
+    const currentTime = Date.now();
+    const activeSubscriptions: ActiveSubscription[] = [];
+
+    // Filter purchases to find active subscriptions
+    const filteredPurchases = purchases.filter((purchase) => {
+      // If specific IDs provided, filter by them
+      if (subscriptionIds && subscriptionIds.length > 0) {
+        if (!subscriptionIds.includes(purchase.id)) {
+          return false;
+        }
+      }
+
+      // Check if this purchase has subscription-specific fields
+      const hasSubscriptionFields =
+        ('expirationDateIos' in purchase && purchase.expirationDateIos) ||
+        'autoRenewingAndroid' in purchase;
+
+      if (!hasSubscriptionFields) {
+        return false;
+      }
+
+      // Check if it's actually active
+      if (Platform.OS === 'ios') {
+        if ('expirationDateIos' in purchase && purchase.expirationDateIos) {
+          return purchase.expirationDateIos > currentTime;
+        }
+        if (
+          'environmentIos' in purchase &&
+          purchase.environmentIos === 'Sandbox'
+        ) {
+          const dayInMs = 24 * 60 * 60 * 1000;
+          if (
+            purchase.transactionDate &&
+            currentTime - purchase.transactionDate < dayInMs
+          ) {
+            return true;
+          }
+        }
+      } else if (Platform.OS === 'android') {
+        // For Android, if it's in the purchases list, it's active
+        return true;
+      }
+
+      return false;
+    });
+
+    // Convert to ActiveSubscription format
+    for (const purchase of filteredPurchases) {
+      const subscription: ActiveSubscription = {
+        productId: purchase.id,
+        isActive: true,
+      };
+
+      // Add platform-specific details
+      if (Platform.OS === 'ios') {
+        if ('expirationDateIos' in purchase && purchase.expirationDateIos) {
+          const expirationDate = new Date(purchase.expirationDateIos);
+          subscription.expirationDateIOS = expirationDate;
+
+          // Calculate days until expiration
+          const daysUntilExpiration = Math.floor(
+            (purchase.expirationDateIos - currentTime) / (1000 * 60 * 60 * 24),
+          );
+          subscription.daysUntilExpirationIOS = daysUntilExpiration;
+          subscription.willExpireSoon = daysUntilExpiration <= 7;
+        }
+
+        if ('environmentIos' in purchase) {
+          subscription.environmentIOS = purchase.environmentIos;
+        }
+      } else if (Platform.OS === 'android') {
+        if ('autoRenewingAndroid' in purchase) {
+          subscription.autoRenewingAndroid = purchase.autoRenewingAndroid;
+          // If auto-renewing is false, subscription will expire soon
+          subscription.willExpireSoon = !purchase.autoRenewingAndroid;
+        }
+      }
+
+      activeSubscriptions.push(subscription);
+    }
+
+    return activeSubscriptions;
+  } catch (error) {
+    console.error('Error getting active subscriptions:', error);
+    return [];
+  }
+};
+
+/**
+ * Check if user has any active subscriptions
+ * @param subscriptionIds - Optional array of subscription product IDs to check. If not provided, checks all subscriptions.
+ * @returns Promise<boolean> true if user has at least one active subscription
+ */
+export const hasActiveSubscriptions = async (
+  subscriptionIds?: string[],
+): Promise<boolean> => {
+  const subscriptions = await getActiveSubscriptions(subscriptionIds);
+  return subscriptions.length > 0;
+};

package/src/index.ts

@@ -36,6 +36,13 @@ export * from './modules/android';
 export * from './modules/ios';
 export type {AppTransactionIOS} from './types/ExpoIapIos.types';
 
+// Export subscription helpers
+export {
+  getActiveSubscriptions,
+  hasActiveSubscriptions,
+  type ActiveSubscription,
+} from './helpers/subscription';
+
 // Get the native constant value
 export const PI = ExpoIapModule.PI;
 
@@ -326,8 +333,9 @@ export const getAvailablePurchases = ({
         ),
       android: async () => {
         const products = await ExpoIapModule.getAvailableItemsByType('inapp');
-        const subscriptions =
-          await ExpoIapModule.getAvailableItemsByType('subs');
+        const subscriptions = await ExpoIapModule.getAvailableItemsByType(
+          'subs',
+        );
         return products.concat(subscriptions);
       },
     }) || (() => Promise.resolve([]))
@@ -555,10 +563,10 @@ export const finishTransaction = ({
   return (
     Platform.select({
       ios: async () => {
-        const transactionId = purchase.transactionId;
+        const transactionId = purchase.id;
         if (!transactionId) {
           return Promise.reject(
-            new Error('transactionId required to finish iOS transaction'),
+            new Error('purchase.id required to finish iOS transaction'),
           );
         }
         await ExpoIapModule.finishTransaction(transactionId);

package/src/useIap.ts

@@ -16,6 +16,9 @@ import {
   requestPurchase as requestPurchaseInternal,
   requestProducts,
   validateReceipt as validateReceiptInternal,
+  getActiveSubscriptions,
+  hasActiveSubscriptions,
+  type ActiveSubscription,
 } from './';
 import {
   syncIOS,
@@ -47,6 +50,7 @@ type UseIap = {
   currentPurchase?: ProductPurchase;
   currentPurchaseError?: PurchaseError;
   promotedProductIOS?: Product;
+  activeSubscriptions: ActiveSubscription[];
   clearCurrentPurchase: () => void;
   clearCurrentPurchaseError: () => void;
   finishTransaction: ({
@@ -88,6 +92,10 @@ type UseIap = {
   restorePurchases: () => Promise<void>; // 구매 복원 함수 추가
   getPromotedProductIOS: () => Promise<any | null>;
   buyPromotedProductIOS: () => Promise<void>;
+  getActiveSubscriptions: (
+    subscriptionIds?: string[],
+  ) => Promise<ActiveSubscription[]>;
+  hasActiveSubscriptions: (subscriptionIds?: string[]) => Promise<boolean>;
 };
 
 export interface UseIAPOptions {
@@ -116,6 +124,9 @@ export function useIAP(options?: UseIAPOptions): UseIap {
   const [currentPurchaseError, setCurrentPurchaseError] =
     useState<PurchaseError>();
   const [promotedProductIdIOS] = useState<string>();
+  const [activeSubscriptions, setActiveSubscriptions] = useState<
+    ActiveSubscription[]
+  >([]);
 
   const optionsRef = useRef<UseIAPOptions | undefined>(options);
 
@@ -241,6 +252,33 @@ export function useIAP(options?: UseIAPOptions): UseIap {
     }
   }, []);
 
+  const getActiveSubscriptionsInternal = useCallback(
+    async (subscriptionIds?: string[]): Promise<ActiveSubscription[]> => {
+      try {
+        const result = await getActiveSubscriptions(subscriptionIds);
+        setActiveSubscriptions(result);
+        return result;
+      } catch (error) {
+        console.error('Error getting active subscriptions:', error);
+        setActiveSubscriptions([]);
+        return [];
+      }
+    },
+    [],
+  );
+
+  const hasActiveSubscriptionsInternal = useCallback(
+    async (subscriptionIds?: string[]): Promise<boolean> => {
+      try {
+        return await hasActiveSubscriptions(subscriptionIds);
+      } catch (error) {
+        console.error('Error checking active subscriptions:', error);
+        return false;
+      }
+    },
+    [],
+  );
+
   const getPurchaseHistoriesInternal = useCallback(async (): Promise<void> => {
     setPurchaseHistories(await getPurchaseHistories());
   }, []);
@@ -408,6 +446,7 @@ export function useIAP(options?: UseIAPOptions): UseIap {
     currentPurchase,
     currentPurchaseError,
     promotedProductIOS,
+    activeSubscriptions,
     clearCurrentPurchase,
     clearCurrentPurchaseError,
     getAvailablePurchases: getAvailablePurchasesInternal,
@@ -420,5 +459,7 @@ export function useIAP(options?: UseIAPOptions): UseIap {
     getSubscriptions: getSubscriptionsInternal,
     getPromotedProductIOS,
     buyPromotedProductIOS,
+    getActiveSubscriptions: getActiveSubscriptionsInternal,
+    hasActiveSubscriptions: hasActiveSubscriptionsInternal,
   };
 }