rampkit-expo-dev 0.0.66 → 0.0.68

package/build/RampKitNative.d.ts

@@ -18,6 +18,8 @@ interface RampKitNativeModule {
     getNotificationPermissions(): Promise<NotificationPermissionResult>;
     startTransactionObserver(appId: string): Promise<void>;
     stopTransactionObserver(): Promise<void>;
+    trackPurchaseCompleted(productId: string, transactionId?: string, originalTransactionId?: string): Promise<void>;
+    trackPurchaseFromProduct(productId: string): Promise<void>;
 }
 export interface NativeDeviceInfo {
     appUserId: string;
@@ -162,4 +164,21 @@ export declare const TransactionObserver: {
      * Stop listening for purchase transactions
      */
     stop(): Promise<void>;
+    /**
+     * Manually track a purchase completion
+     * Use this when Superwall/RevenueCat reports a purchase but the automatic
+     * observer doesn't catch it (they finish transactions before we see them)
+     *
+     * @param productId - The product ID (e.g., "com.app.yearly")
+     * @param transactionId - Optional transaction ID if available
+     * @param originalTransactionId - Optional original transaction ID (for renewals)
+     */
+    trackPurchase(productId: string, transactionId?: string, originalTransactionId?: string): Promise<void>;
+    /**
+     * Track a purchase by looking up the product's latest transaction
+     * Use this when you only have the productId (common with Superwall)
+     *
+     * @param productId - The product ID to look up and track
+     */
+    trackPurchaseByProductId(productId: string): Promise<void>;
 };

package/build/RampKitNative.js

@@ -62,6 +62,8 @@ function createFallbackModule() {
         },
         async startTransactionObserver(_appId) { },
         async stopTransactionObserver() { },
+        async trackPurchaseCompleted(_productId, _transactionId, _originalTransactionId) { },
+        async trackPurchaseFromProduct(_productId) { },
     };
 }
 function generateFallbackUserId() {
@@ -285,4 +287,39 @@ exports.TransactionObserver = {
             console.warn("[RampKit] Failed to stop transaction observer:", e);
         }
     },
+    /**
+     * Manually track a purchase completion
+     * Use this when Superwall/RevenueCat reports a purchase but the automatic
+     * observer doesn't catch it (they finish transactions before we see them)
+     *
+     * @param productId - The product ID (e.g., "com.app.yearly")
+     * @param transactionId - Optional transaction ID if available
+     * @param originalTransactionId - Optional original transaction ID (for renewals)
+     */
+    async trackPurchase(productId, transactionId, originalTransactionId) {
+        try {
+            console.log("[RampKit] Manually tracking purchase:", productId);
+            await RampKitNativeModule.trackPurchaseCompleted(productId, transactionId, originalTransactionId);
+            console.log("[RampKit] Purchase tracked successfully:", productId);
+        }
+        catch (e) {
+            console.warn("[RampKit] Failed to track purchase:", e);
+        }
+    },
+    /**
+     * Track a purchase by looking up the product's latest transaction
+     * Use this when you only have the productId (common with Superwall)
+     *
+     * @param productId - The product ID to look up and track
+     */
+    async trackPurchaseByProductId(productId) {
+        try {
+            console.log("[RampKit] Looking up and tracking purchase for:", productId);
+            await RampKitNativeModule.trackPurchaseFromProduct(productId);
+            console.log("[RampKit] Purchase lookup and tracking complete:", productId);
+        }
+        catch (e) {
+            console.warn("[RampKit] Failed to track purchase by product:", e);
+        }
+    },
 };

package/ios/RampKitModule.swift

@@ -9,14 +9,27 @@ public class RampKitModule: Module {
   private let installDateKey = "rk_install_date"
   private let launchCountKey = "rk_launch_count"
   private let lastLaunchKey = "rk_last_launch"
-  
+  private let trackedTransactionsKey = "rk_tracked_transactions"
+
   // Transaction observer task
   private var transactionObserverTask: Task<Void, Never>?
   private var appId: String?
   private var userId: String?
-  
+  private var isConfigured = false
+
+  // Set of already-tracked originalTransactionIds to prevent duplicates
+  private var trackedTransactionIds: Set<String> = []
+
   public func definition() -> ModuleDefinition {
     Name("RampKit")
+
+    // OnCreate runs when JS first requires the module - may be too late for some transactions
+    OnCreate {
+      print("[RampKit] ⚡ OnCreate called - module being initialized")
+      self.loadTrackedTransactions()
+      self.userId = self.getOrCreateUserId()
+      print("[RampKit] ⚡ OnCreate complete, userId: \(self.userId ?? "nil")")
+    }
     
     // ============================================================================
     // Device Info
@@ -89,14 +102,30 @@ public class RampKitModule: Module {
     // ============================================================================
     // Transaction Observer (StoreKit 2)
     // ============================================================================
-    
+
     AsyncFunction("startTransactionObserver") { (appId: String) in
       self.startTransactionObserver(appId: appId)
     }
-    
+
     AsyncFunction("stopTransactionObserver") { () in
       self.stopTransactionObserver()
     }
+
+    // ============================================================================
+    // Manual Purchase Tracking (Fallback for Superwall/RevenueCat)
+    // ============================================================================
+
+    AsyncFunction("trackPurchaseCompleted") { (productId: String, transactionId: String?, originalTransactionId: String?) in
+      await self.trackPurchaseCompletedManually(
+        productId: productId,
+        transactionId: transactionId,
+        originalTransactionId: originalTransactionId
+      )
+    }
+
+    AsyncFunction("trackPurchaseFromProduct") { (productId: String) in
+      await self.trackPurchaseFromProductId(productId: productId)
+    }
   }
   
   // MARK: - Device Info Collection
@@ -224,8 +253,23 @@ public class RampKitModule: Module {
     SecItemAdd(addQuery as CFDictionary, nil)
   }
   
+  // MARK: - Tracked Transactions (Deduplication)
+
+  private func loadTrackedTransactions() {
+    if let stored = UserDefaults.standard.array(forKey: trackedTransactionsKey) as? [String] {
+      trackedTransactionIds = Set(stored)
+      print("[RampKit] 📚 Loaded \(trackedTransactionIds.count) tracked transaction IDs")
+    }
+  }
+
+  private func saveTrackedTransactions() {
+    let array = Array(trackedTransactionIds)
+    UserDefaults.standard.set(array, forKey: trackedTransactionsKey)
+    print("[RampKit] 💾 Saved \(trackedTransactionIds.count) tracked transaction IDs")
+  }
+
   // MARK: - Launch Tracking
-  
+
   private func getLaunchTrackingData() -> [String: Any?] {
     let defaults = UserDefaults.standard
     let now = ISO8601DateFormatter().string(from: Date())
@@ -386,78 +430,137 @@ public class RampKitModule: Module {
   }
   
   // MARK: - StoreKit 2 Transaction Observer
-  
+
+  /// Called from JavaScript - sets appId and IMMEDIATELY checks for purchases we may have missed
   private func startTransactionObserver(appId: String) {
     self.appId = appId
     self.userId = getOrCreateUserId()
-    
-    // Cancel existing observer if any
-    transactionObserverTask?.cancel()
-    
-    // Start listening for transactions (iOS 15+)
+    self.isConfigured = true
+
+    print("[RampKit] ✅ Transaction observer configured with appId: \(appId)")
+    print("[RampKit] 📊 Already tracked \(trackedTransactionIds.count) transactions")
+
     if #available(iOS 15.0, *) {
-      transactionObserverTask = Task {
-        await self.listenForTransactions()
+      // CRITICAL: Check current entitlements for any purchases we missed
+      // This is the KEY mechanism for catching Superwall/RevenueCat purchases
+      Task {
+        await self.checkAndTrackCurrentEntitlements()
       }
-      
-      // Also check for any unfinished transactions
+
+      // Also start listening for future transactions
       Task {
-        await self.handleUnfinishedTransactions()
+        await self.startTransactionUpdatesListener()
       }
     }
-    
-    print("[RampKit] Transaction observer started")
   }
-  
-  private func stopTransactionObserver() {
-    transactionObserverTask?.cancel()
-    transactionObserverTask = nil
-    print("[RampKit] Transaction observer stopped")
-  }
-  
+
+  /// Check all current entitlements and track any we haven't seen before
+  /// This catches purchases made by Superwall/RevenueCat before our observer started
   @available(iOS 15.0, *)
-  private func listenForTransactions() async {
-    // Listen for transaction updates
-    for await result in Transaction.updates {
-      do {
-        let transaction = try self.checkVerified(result)
-        await self.handleTransaction(transaction)
-        await transaction.finish()
-      } catch {
-        print("[RampKit] Transaction verification failed: \(error)")
+  private func checkAndTrackCurrentEntitlements() async {
+    print("[RampKit] 🔍 Checking current entitlements for missed purchases...")
+
+    var foundCount = 0
+    var trackedCount = 0
+    var newCount = 0
+
+    for await result in Transaction.currentEntitlements {
+      foundCount += 1
+
+      guard case .verified(let transaction) = result else {
+        print("[RampKit] ⚠️ Unverified entitlement skipped")
+        continue
       }
+
+      let originalId = String(transaction.originalID)
+      print("[RampKit] 📦 Found entitlement: \(transaction.productID), originalID: \(originalId)")
+
+      // Check if we've already tracked this transaction
+      if trackedTransactionIds.contains(originalId) {
+        trackedCount += 1
+        print("[RampKit] ✓ Already tracked: \(transaction.productID)")
+        continue
+      }
+
+      // NEW transaction we haven't seen!
+      newCount += 1
+      print("[RampKit] 🆕 NEW purchase detected: \(transaction.productID)")
+
+      // Track it
+      await self.handleTransaction(transaction)
+
+      // Mark as tracked
+      trackedTransactionIds.insert(originalId)
+      saveTrackedTransactions()
     }
+
+    print("[RampKit] 🔍 Entitlement check complete:")
+    print("[RampKit]    - Total found: \(foundCount)")
+    print("[RampKit]    - Already tracked: \(trackedCount)")
+    print("[RampKit]    - NEW (sent events): \(newCount)")
   }
-  
+
+  /// Start listening for Transaction.updates (for future purchases)
   @available(iOS 15.0, *)
-  private func handleUnfinishedTransactions() async {
-    // Handle any transactions that weren't finished
-    for await result in Transaction.unfinished {
-      do {
-        let transaction = try self.checkVerified(result)
+  private func startTransactionUpdatesListener() async {
+    guard transactionObserverTask == nil else {
+      print("[RampKit] Transaction updates listener already running")
+      return
+    }
+
+    print("[RampKit] 👂 Starting Transaction.updates listener...")
+
+    transactionObserverTask = Task {
+      for await result in Transaction.updates {
+        print("[RampKit] 🎉 Transaction.updates received!")
+
+        guard case .verified(let transaction) = result else {
+          print("[RampKit] ⚠️ Unverified transaction update")
+          continue
+        }
+
+        let originalId = String(transaction.originalID)
+
+        // Skip if already tracked
+        if self.trackedTransactionIds.contains(originalId) {
+          print("[RampKit] ✓ Transaction.updates: Already tracked \(transaction.productID)")
+          await transaction.finish()
+          continue
+        }
+
+        print("[RampKit] 🆕 Transaction.updates: NEW purchase \(transaction.productID)")
+
+        // Track it
         await self.handleTransaction(transaction)
+
+        // Mark as tracked
+        self.trackedTransactionIds.insert(originalId)
+        self.saveTrackedTransactions()
+
+        // Finish the transaction
         await transaction.finish()
-      } catch {
-        print("[RampKit] Unfinished transaction verification failed: \(error)")
       }
     }
   }
-  
-  @available(iOS 15.0, *)
-  private func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
-    switch result {
-    case .unverified(_, let error):
-      throw error
-    case .verified(let safe):
-      return safe
-    @unknown default:
-      fatalError("Unknown VerificationResult case")
-    }
+
+  private func stopTransactionObserver() {
+    transactionObserverTask?.cancel()
+    transactionObserverTask = nil
+    isConfigured = false
+    print("[RampKit] Transaction observer stopped")
   }
-  
+
   @available(iOS 15.0, *)
   private func handleTransaction(_ transaction: Transaction) async {
-    guard let appId = self.appId, let userId = self.userId else { return }
+    print("[RampKit] 🔄 handleTransaction called for: \(transaction.productID)")
+    print("[RampKit]    - id: \(transaction.id)")
+    print("[RampKit]    - originalID: \(transaction.originalID)")
+    print("[RampKit]    - purchaseDate: \(transaction.purchaseDate)")
+
+    guard let appId = self.appId, let userId = self.userId else {
+      print("[RampKit] ❌ handleTransaction failed: appId=\(self.appId ?? "nil"), userId=\(self.userId ?? "nil")")
+      return
+    }
 
     let formatter = ISO8601DateFormatter()
     formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
@@ -474,6 +577,8 @@ public class RampKitModule: Module {
       return
     }
 
+    print("[RampKit] ✅ Transaction is a new purchase, will send event")
+
     // All new purchases (including trials) are tracked as purchase_completed
     // The isTrial and offerType properties indicate trial status
     let eventName = "purchase_completed"
@@ -636,7 +741,104 @@ public class RampKitModule: Module {
       print("[RampKit] Failed to send purchase event: \(error)")
     }
   }
-  
+
+  // MARK: - Manual Purchase Tracking (Fallback for Superwall/RevenueCat)
+
+  /// Track a purchase manually when you have the transaction IDs
+  /// Use this when Superwall or RevenueCat provides the transaction info
+  @available(iOS 15.0, *)
+  private func trackPurchaseCompletedManually(
+    productId: String,
+    transactionId: String?,
+    originalTransactionId: String?
+  ) async {
+    print("[RampKit] 📲 Manual purchase tracking called for: \(productId)")
+
+    guard let appId = self.appId, let userId = self.userId else {
+      print("[RampKit] ❌ Manual tracking failed: SDK not initialized (appId or userId missing)")
+      return
+    }
+
+    let formatter = ISO8601DateFormatter()
+    formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+
+    var properties: [String: Any] = [
+      "productId": productId,
+      "purchaseDate": formatter.string(from: Date()),
+      "source": "manual" // Mark as manually tracked
+    ]
+
+    // Add transaction IDs if available
+    if let transactionId = transactionId {
+      properties["transactionId"] = transactionId
+    }
+    if let originalTransactionId = originalTransactionId {
+      properties["originalTransactionId"] = originalTransactionId
+    } else if let transactionId = transactionId {
+      // Use transactionId as originalTransactionId if not provided (first purchase)
+      properties["originalTransactionId"] = transactionId
+    }
+
+    // Try to get product info from StoreKit
+    if let product = await getProduct(for: productId) {
+      properties["amount"] = product.price
+      properties["currency"] = product.priceFormatStyle.currencyCode
+      properties["priceFormatted"] = product.displayPrice
+      properties["productType"] = mapProductType(product.type)
+
+      if let subscription = product.subscription {
+        properties["subscriptionPeriod"] = formatSubscriptionPeriod(subscription.subscriptionPeriod)
+        properties["subscriptionGroupId"] = subscription.subscriptionGroupID
+      }
+    }
+
+    // Get storefront
+    if let storefront = await Storefront.current {
+      properties["storefront"] = storefront.countryCode
+    }
+
+    print("[RampKit] 📤 Sending manual purchase_completed event...")
+    await sendPurchaseEvent(
+      appId: appId,
+      userId: userId,
+      eventName: "purchase_completed",
+      properties: properties
+    )
+  }
+
+  /// Track a purchase by looking up the latest transaction for a product
+  /// Use this when you only know the productId (Superwall doesn't always provide transaction IDs)
+  @available(iOS 15.0, *)
+  private func trackPurchaseFromProductId(productId: String) async {
+    print("[RampKit] 🔍 Looking up transaction for product: \(productId)")
+
+    // Try to find the latest transaction for this product
+    var latestTransaction: Transaction?
+
+    for await result in Transaction.currentEntitlements {
+      if case .verified(let transaction) = result {
+        if transaction.productID == productId {
+          if latestTransaction == nil || transaction.purchaseDate > latestTransaction!.purchaseDate {
+            latestTransaction = transaction
+          }
+        }
+      }
+    }
+
+    if let transaction = latestTransaction {
+      print("[RampKit] ✅ Found transaction for product: \(productId)")
+      await handleTransaction(transaction)
+    } else {
+      print("[RampKit] ⚠️ No transaction found for product, tracking manually: \(productId)")
+      // Fall back to manual tracking without transaction IDs
+      await trackPurchaseCompletedManually(
+        productId: productId,
+        transactionId: nil,
+        originalTransactionId: nil
+      )
+    }
+  }
+
   // MARK: - Device Helpers
   
   private func getDeviceModelIdentifier() -> String {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rampkit-expo-dev",
-  "version": "0.0.66",
+  "version": "0.0.68",
   "description": "The Expo SDK for RampKit. Build, test, and personalize app onboardings with instant updates.",
   "main": "build/index.js",
   "types": "build/index.d.ts",