[Fix] - Store Kit 1 race condition

ios/LatestPromiseKeeper.swift

@@ -0,0 +1,38 @@
+import StoreKit
+
+// Only keeps latest promise, assumes older promises are not needed
+// Avoids racing conditions by storing latestPromise in a thread safe var
+// Cancels previous promises when new ones are added
+// Should not be used when all promises are relevant (e.g. Purchases)
+class LatestPromiseKeeper {
+    private var latestPromise: ThreadSafe<(RCTPromiseResolveBlock, RCTPromiseRejectBlock)?> = ThreadSafe(nil)
+    private var latestRequest: ThreadSafe<SKProductsRequest?> = ThreadSafe(nil)
+
+    func setLatestPromise(request: SKProductsRequest, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        cancelOngoingRequest()
+
+        latestRequest.atomically { $0 = request }
+        latestPromise.atomically { $0 = (resolve, reject) }
+    }
+
+    func cancelOngoingRequest() {
+        latestRequest.atomically { ongoingRequest in
+            ongoingRequest?.cancel()
+            ongoingRequest = nil
+        }
+
+        latestPromise.atomically { $0 = nil }
+    }
+
+    func resolveIfRequestMatches(matchingRequest: SKProductsRequest, items: [[String: Any?]], operation: (RCTPromiseResolveBlock, [[String: Any?]]) -> Void) {
+        latestPromise.atomically { promiseResolvers in
+            guard let (resolve, _) = promiseResolvers else { return }
+
+            latestRequest.atomically { ongoingRequest in
+                guard ongoingRequest === matchingRequest else { return }
+
+                operation(resolve, items)
+            }
+        }
+    }
+}

ios/RNIapIos.swift

@@ -8,18 +8,19 @@ class RNIapIos: RCTEventEmitter, SKRequestDelegate, SKPaymentTransactionObserver
     private var hasListeners = false
     private var pendingTransactionWithAutoFinish = false
     private var receiptBlock: ((Data?, Error?) -> Void)? // Block to handle request the receipt async from delegate
-    private var validProducts: [String: SKProduct]
+    private var validProducts: ThreadSafe<[String: SKProduct]> 
     private var promotedPayment: SKPayment?
     private var promotedProduct: SKProduct?
     private var productsRequest: SKProductsRequest?
+    private let latestPromiseKeeper = LatestPromiseKeeper()
     private var countPendingTransaction: Int = 0
     private var hasTransactionObserver = false
 
     override init() {
         promisesByKey = [String: [RNIapIosPromise]]()
         pendingTransactionWithAutoFinish = false
         myQueue = DispatchQueue(label: "reject")
-        validProducts = [String: SKProduct]()
+        validProducts = ThreadSafe<[String: SKProduct]>([:])
         super.init()
         addTransactionObserver()
     }
@@ -148,7 +149,7 @@ class RNIapIos: RCTEventEmitter, SKRequestDelegate, SKPaymentTransactionObserver
         stopObserving()
         rejectAllPendingPromises()
         receiptBlock = nil
-        validProducts.removeAll()
+        validProducts.atomically { $0.removeAll() }
         promotedPayment = nil
         promotedProduct = nil
         productsRequest = nil
@@ -162,10 +163,13 @@ class RNIapIos: RCTEventEmitter, SKRequestDelegate, SKPaymentTransactionObserver
     ) {
         let productIdentifiers = Set<String>(skus)
         productsRequest = SKProductsRequest(productIdentifiers: productIdentifiers)
+
         if let productsRequest = productsRequest {
             productsRequest.delegate = self
-            let key: String = productsRequest.key
-            addPromise(forKey: key, resolve: resolve, reject: reject)
+
+            // Update latestPromiseKeeper with the new request and promise
+            self.latestPromiseKeeper.setLatestPromise(request: productsRequest, resolve: resolve, reject: reject)
+
             productsRequest.start()
         }
     }
@@ -189,7 +193,7 @@ class RNIapIos: RCTEventEmitter, SKRequestDelegate, SKPaymentTransactionObserver
         reject: @escaping RCTPromiseRejectBlock = { _, _, _ in }
     ) {
         pendingTransactionWithAutoFinish = andDangerouslyFinishTransactionAutomatically
-        if let product = validProducts[sku] {
+        if let product = validProducts.value[sku] { 
             addPromise(forKey: product.productIdentifier, resolve: resolve, reject: reject)
 
             let payment = SKMutablePayment(product: product)
@@ -254,7 +258,7 @@ class RNIapIos: RCTEventEmitter, SKRequestDelegate, SKPaymentTransactionObserver
         reject: @escaping RCTPromiseRejectBlock = { _, _, _ in }
     ) {
         debugMessage("clear valid products")
-        validProducts.removeAll()
+        validProducts.atomically { $0.removeAll() }
         resolve(nil)
     }
 
@@ -348,23 +352,26 @@ class RNIapIos: RCTEventEmitter, SKRequestDelegate, SKPaymentTransactionObserver
 
     // StoreKitDelegate
     func productsRequest(_ request: SKProductsRequest, didReceive response: SKProductsResponse) {
+        // Add received products 
         for prod in response.products {
             add(prod)
         }
 
         var items: [[String: Any?]] = [[:]]
-        for product in validProducts.values {
+        for product in validProducts.value.values {
             items.append(getProductObject(product))
         }
 
-        resolvePromises(forKey: request.key, value: items)
+        self.latestPromiseKeeper.resolveIfRequestMatches(matchingRequest: request, items: items) { (resolve, items) in
+            resolve(items)
+        }
     }
 
     // Add to valid products from Apple server response. Allowing getProducts, getSubscriptions call several times.
     // Doesn't allow duplication. Replace new product.
     func add(_ aProd: SKProduct) {
         debugMessage("Add new object: \(aProd.productIdentifier)")
-        validProducts[aProd.productIdentifier] = aProd
+        validProducts.atomically { $0[aProd.productIdentifier] = aProd }
     }
 
     func request(_ request: SKRequest, didFailWithError error: Error) {

ios/ThreadSafe.swift

@@ -0,0 +1,18 @@
+class ThreadSafe<A> {
+    private var _value: A
+    private let queue = DispatchQueue(label: "ThreadSafe")
+
+    init(_ value: A) {
+        self._value = value
+    }
+
+    var value: A {
+        return queue.sync { _value }
+    }
+
+    func atomically(_ transform: (inout A) -> ()) {
+        queue.sync {
+            transform(&self._value)
+        }
+    }
+}