@namiml/expo-nami-iap 3.4.0-dev.202605060437

package/ios/Tests/Resources/Products.storekit

@@ -0,0 +1,210 @@
+{
+  "appPolicies" : {
+    "eula" : "",
+    "policies" : [
+      {
+        "locale" : "en_US",
+        "policyText" : "",
+        "policyURL" : ""
+      }
+    ]
+  },
+  "identifier" : "A1B2C3D4",
+  "nonRenewingSubscriptions" : [
+
+  ],
+  "products" : [
+    {
+      "displayPrice" : "1.99",
+      "familyShareable" : false,
+      "internalID" : "100000001",
+      "localizations" : [
+        {
+          "description" : "A test consumable product",
+          "displayName" : "Test Consumable",
+          "locale" : "en_US"
+        }
+      ],
+      "productID" : "com.nami.test.consumable",
+      "referenceName" : "Test Consumable",
+      "type" : "Consumable"
+    },
+    {
+      "displayPrice" : "49.99",
+      "familyShareable" : false,
+      "internalID" : "100000002",
+      "localizations" : [
+        {
+          "description" : "A lifetime non-consumable purchase",
+          "displayName" : "Lifetime Access",
+          "locale" : "en_US"
+        }
+      ],
+      "productID" : "com.nami.test.lifetime",
+      "referenceName" : "Lifetime Access",
+      "type" : "NonConsumable"
+    }
+  ],
+  "settings" : {
+    "_failTransactionsEnabled" : false,
+    "_locale" : "en_US",
+    "_storefront" : "USA",
+    "_storeKitErrors" : [
+      {
+        "current" : null,
+        "enabled" : false,
+        "name" : "Load Products"
+      },
+      {
+        "current" : null,
+        "enabled" : false,
+        "name" : "Purchase"
+      },
+      {
+        "current" : null,
+        "enabled" : false,
+        "name" : "Verification"
+      },
+      {
+        "current" : null,
+        "enabled" : false,
+        "name" : "App Store Sync"
+      },
+      {
+        "current" : null,
+        "enabled" : false,
+        "name" : "Subscription Status"
+      },
+      {
+        "current" : null,
+        "enabled" : false,
+        "name" : "App Transaction"
+      },
+      {
+        "current" : null,
+        "enabled" : false,
+        "name" : "Manage Subscriptions Sheet"
+      },
+      {
+        "current" : null,
+        "enabled" : false,
+        "name" : "Refund Request Sheet"
+      },
+      {
+        "current" : null,
+        "enabled" : false,
+        "name" : "Offer Code Redeem Sheet"
+      }
+    ]
+  },
+  "subscriptionGroups" : [
+    {
+      "id" : "90000001",
+      "localizations" : [
+
+      ],
+      "name" : "test_subscriptions",
+      "subscriptions" : [
+        {
+          "adHocOffers" : [
+
+          ],
+          "codeOffers" : [
+
+          ],
+          "displayPrice" : "9.99",
+          "familyShareable" : false,
+          "groupNumber" : 1,
+          "internalID" : "200000001",
+          "introductoryOffer" : null,
+          "localizations" : [
+            {
+              "description" : "Weekly auto-renewable subscription",
+              "displayName" : "Weekly Plan",
+              "locale" : "en_US"
+            }
+          ],
+          "productID" : "com.nami.test.weekly",
+          "recurringSubscriptionPeriod" : "P1W",
+          "referenceName" : "Weekly Plan",
+          "subscriptionGroupID" : "90000001",
+          "type" : "RecurringSubscription",
+          "winbackOffers" : [
+
+          ]
+        },
+        {
+          "adHocOffers" : [
+
+          ],
+          "codeOffers" : [
+
+          ],
+          "displayPrice" : "12.99",
+          "familyShareable" : false,
+          "groupNumber" : 2,
+          "internalID" : "200000002",
+          "introductoryOffer" : {
+            "internalID" : "300000001",
+            "numberOfPeriods" : 1,
+            "paymentMode" : "free",
+            "subscriptionPeriod" : "P1W"
+          },
+          "localizations" : [
+            {
+              "description" : "Monthly subscription with free trial",
+              "displayName" : "Monthly with Trial",
+              "locale" : "en_US"
+            }
+          ],
+          "productID" : "com.nami.test.monthly.trial",
+          "recurringSubscriptionPeriod" : "P1M",
+          "referenceName" : "Monthly with Trial",
+          "subscriptionGroupID" : "90000001",
+          "type" : "RecurringSubscription",
+          "winbackOffers" : [
+
+          ]
+        },
+        {
+          "adHocOffers" : [
+
+          ],
+          "codeOffers" : [
+
+          ],
+          "displayPrice" : "14.99",
+          "familyShareable" : false,
+          "groupNumber" : 3,
+          "internalID" : "200000003",
+          "introductoryOffer" : {
+            "displayPrice" : "0.99",
+            "internalID" : "300000002",
+            "numberOfPeriods" : 1,
+            "paymentMode" : "payAsYouGo",
+            "subscriptionPeriod" : "P1W"
+          },
+          "localizations" : [
+            {
+              "description" : "Monthly subscription with intro price",
+              "displayName" : "Monthly with Intro",
+              "locale" : "en_US"
+            }
+          ],
+          "productID" : "com.nami.test.monthly.intro",
+          "recurringSubscriptionPeriod" : "P1M",
+          "referenceName" : "Monthly with Intro",
+          "subscriptionGroupID" : "90000001",
+          "type" : "RecurringSubscription",
+          "winbackOffers" : [
+
+          ]
+        }
+      ]
+    }
+  ],
+  "version" : {
+    "major" : 4,
+    "minor" : 0
+  }
+}

package/ios/Tests/StoreKit2HelperTests.swift

@@ -0,0 +1,360 @@
+//
+//  StoreKit2HelperTests.swift
+//  ExpoNamiIap
+//
+//  Copyright (c) 2024 Nami ML Inc. All rights reserved.
+//
+
+import XCTest
+import StoreKit
+@testable import ExpoNamiIap
+
+@available(iOS 15.0, tvOS 15.0, *)
+final class StoreKit2HelperTests: XCTestCase {
+
+    private var session: SKTestSession!
+    private var helper: StoreKit2Helper!
+
+    override func setUp() async throws {
+        try await super.setUp()
+        session = try SKTestSession(configurationFileNamed: "Products")
+        session.disableDialogs = true
+        session.clearTransactions()
+        helper = StoreKit2Helper()
+    }
+
+    override func tearDown() async throws {
+        session = nil
+        helper = nil
+        try await super.tearDown()
+    }
+
+    // MARK: - getProducts
+
+    func testGetProductsReturnsMappedProductsInInputOrder() async throws {
+        let skuIds = ["com.nami.test.lifetime", "com.nami.test.consumable"]
+        let products = try await helper.getProducts(skuIds)
+
+        XCTAssertEqual(products.count, 2, "Should return two mapped products")
+
+        // Verify order matches input — lifetime first, consumable second
+        let firstId = try XCTUnwrap(products[0]["product_ref_id"] as? String)
+        let secondId = try XCTUnwrap(products[1]["product_ref_id"] as? String)
+        XCTAssertEqual(firstId, "com.nami.test.lifetime")
+        XCTAssertEqual(secondId, "com.nami.test.consumable")
+    }
+
+    func testGetProductsThrowsItemUnavailableForUnknownSku() async throws {
+        do {
+            _ = try await helper.getProducts(["com.nami.test.nonexistent"])
+            XCTFail("Expected itemUnavailable error")
+        } catch let error as ExpoNamiIapError {
+            XCTAssertEqual(error.code, "item_unavailable")
+        } catch {
+            XCTFail("Unexpected error type: \(error)")
+        }
+    }
+
+    func testGetProductsCachesProducts() async throws {
+        // First call populates cache
+        let skuIds = ["com.nami.test.consumable"]
+        _ = try await helper.getProducts(skuIds)
+
+        // Second call should still work (from cache or fresh — behavior is transparent)
+        let products = try await helper.getProducts(skuIds)
+        XCTAssertEqual(products.count, 1)
+        XCTAssertEqual(products[0]["product_ref_id"] as? String, "com.nami.test.consumable")
+    }
+
+    func testGetProductsPreservesOrderWithMixedTypes() async throws {
+        let skuIds = [
+            "com.nami.test.weekly",
+            "com.nami.test.consumable",
+            "com.nami.test.monthly.trial",
+        ]
+        let products = try await helper.getProducts(skuIds)
+
+        XCTAssertEqual(products.count, 3)
+        XCTAssertEqual(products[0]["product_ref_id"] as? String, "com.nami.test.weekly")
+        XCTAssertEqual(products[1]["product_ref_id"] as? String, "com.nami.test.consumable")
+        XCTAssertEqual(products[2]["product_ref_id"] as? String, "com.nami.test.monthly.trial")
+    }
+
+    // MARK: - checkEligibility
+
+    func testCheckEligibilityReturnsEligibleWhenNoPriorPurchase() async throws {
+        let results = try await helper.checkEligibility(["com.nami.test.monthly.trial"])
+
+        XCTAssertEqual(results.count, 1)
+
+        let entry = results[0]
+        XCTAssertEqual(entry["skuId"] as? String, "com.nami.test.monthly.trial")
+        XCTAssertEqual(entry["introEligible"] as? Bool, true)
+        XCTAssertEqual(entry["promoEligible"] as? Bool, true)
+    }
+
+    func testCheckEligibilityReturnsNotEligibleAfterPurchase() async throws {
+        // Simulate a purchase of the monthly trial product
+        try session.buyProduct(productIdentifier: "com.nami.test.monthly.trial")
+
+        let results = try await helper.checkEligibility(["com.nami.test.monthly.trial"])
+
+        XCTAssertEqual(results.count, 1)
+
+        let entry = results[0]
+        XCTAssertEqual(entry["skuId"] as? String, "com.nami.test.monthly.trial")
+        // After a purchase in the same subscription group, intro offer should no longer be eligible
+        XCTAssertEqual(entry["introEligible"] as? Bool, false)
+        // After a purchase in the same subscription group, promo should not be eligible
+        XCTAssertEqual(entry["promoEligible"] as? Bool, false)
+    }
+
+    func testCheckEligibilityNonSubscriptionReturnsFalse() async throws {
+        let results = try await helper.checkEligibility(["com.nami.test.consumable"])
+
+        XCTAssertEqual(results.count, 1)
+
+        let entry = results[0]
+        XCTAssertEqual(entry["skuId"] as? String, "com.nami.test.consumable")
+        XCTAssertEqual(entry["introEligible"] as? Bool, false)
+        XCTAssertEqual(entry["promoEligible"] as? Bool, false)
+    }
+
+    func testCheckEligibilityThrowsForUnknownSku() async throws {
+        do {
+            _ = try await helper.checkEligibility(["com.nami.test.nonexistent"])
+            XCTFail("Expected itemUnavailable error")
+        } catch let error as ExpoNamiIapError {
+            XCTAssertEqual(error.code, "item_unavailable")
+        } catch {
+            XCTFail("Unexpected error type: \(error)")
+        }
+    }
+
+    func testCheckEligibilityMultipleSkus() async throws {
+        let results = try await helper.checkEligibility([
+            "com.nami.test.monthly.trial",
+            "com.nami.test.monthly.intro",
+        ])
+
+        XCTAssertEqual(results.count, 2)
+        XCTAssertEqual(results[0]["skuId"] as? String, "com.nami.test.monthly.trial")
+        XCTAssertEqual(results[1]["skuId"] as? String, "com.nami.test.monthly.intro")
+    }
+
+    // MARK: - purchase
+
+    func testPurchaseReturnsTransactionDict() async throws {
+        let result = try await helper.purchase(
+            skuId: "com.nami.test.consumable",
+            offerId: nil,
+            offerSignature: nil,
+            appAccountToken: nil
+        )
+
+        let skuId = try XCTUnwrap(result["skuId"] as? String)
+        XCTAssertEqual(skuId, "com.nami.test.consumable")
+
+        let transactionId = try XCTUnwrap(result["transactionId"] as? String)
+        XCTAssertFalse(transactionId.isEmpty, "transactionId should be non-empty")
+
+        let originalTransactionId = try XCTUnwrap(result["originalTransactionId"] as? String)
+        XCTAssertFalse(originalTransactionId.isEmpty, "originalTransactionId should be non-empty")
+
+        let receipt = try XCTUnwrap(result["receipt"] as? String)
+        XCTAssertFalse(receipt.isEmpty, "receipt (JWS) should be non-empty")
+
+        let purchaseTime = try XCTUnwrap(result["purchaseTime"] as? Int)
+        XCTAssertGreaterThan(purchaseTime, 0, "purchaseTime should be a positive epoch millis")
+    }
+
+    func testPurchaseWithAppAccountToken() async throws {
+        let tokenUUID = "550e8400-e29b-41d4-a716-446655440000"
+        let result = try await helper.purchase(
+            skuId: "com.nami.test.consumable",
+            offerId: nil,
+            offerSignature: nil,
+            appAccountToken: tokenUUID
+        )
+
+        // Verify the purchase succeeded — the appAccountToken is embedded in
+        // the transaction but not surfaced in our dictionary. We verify success
+        // and that the token did not cause a failure.
+        let skuId = try XCTUnwrap(result["skuId"] as? String)
+        XCTAssertEqual(skuId, "com.nami.test.consumable")
+
+        let transactionId = try XCTUnwrap(result["transactionId"] as? String)
+        XCTAssertFalse(transactionId.isEmpty)
+    }
+
+    func testPurchaseWithInvalidOfferSignatureIgnoresPromo() async throws {
+        // When an invalid (non-Base64 / malformed) offerSignature is provided,
+        // PromotionalOfferSigner.option returns nil and the purchase proceeds
+        // without a promotional offer applied.
+        let result = try await helper.purchase(
+            skuId: "com.nami.test.consumable",
+            offerId: "some-offer",
+            offerSignature: "not-valid-base64!!!",
+            appAccountToken: nil
+        )
+
+        let skuId = try XCTUnwrap(result["skuId"] as? String)
+        XCTAssertEqual(skuId, "com.nami.test.consumable")
+    }
+
+    func testPurchaseUserCancelledThrowsError() async throws {
+        // Enable transaction failures to simulate a cancellation scenario.
+        // When failTransactionsEnabled is true, StoreKit testing returns
+        // an error instead of completing the purchase.
+        session.failTransactionsEnabled = true
+
+        do {
+            _ = try await helper.purchase(
+                skuId: "com.nami.test.consumable",
+                offerId: nil,
+                offerSignature: nil,
+                appAccountToken: nil
+            )
+            XCTFail("Expected an error when transactions are set to fail")
+        } catch {
+            // The transaction failed — this verifies our error handling paths
+            // are exercised. The exact error type depends on StoreKit testing
+            // internals (may be .unknown wrapping a StoreKitError).
+            XCTAssertTrue(error is ExpoNamiIapError || error is StoreKitError,
+                          "Error should be ExpoNamiIapError or StoreKitError, got \(type(of: error))")
+        }
+    }
+
+    // MARK: - finishTransaction
+
+    func testFinishTransactionRemovesFromUnfinished() async throws {
+        // Purchase a product — the transaction is held unfinished
+        let result = try await helper.purchase(
+            skuId: "com.nami.test.lifetime",
+            offerId: nil,
+            offerSignature: nil,
+            appAccountToken: nil
+        )
+
+        let transactionId = try XCTUnwrap(result["transactionId"] as? String)
+
+        // Verify the transaction appears in Transaction.unfinished
+        var foundBefore = false
+        for await verificationResult in Transaction.unfinished {
+            if case .verified(let txn) = verificationResult, String(txn.id) == transactionId {
+                foundBefore = true
+                break
+            }
+        }
+        XCTAssertTrue(foundBefore, "Transaction should be in unfinished before finishing")
+
+        // Finish the transaction
+        try await helper.finishTransaction(transactionId: transactionId)
+
+        // Verify the transaction no longer appears in Transaction.unfinished
+        var foundAfter = false
+        for await verificationResult in Transaction.unfinished {
+            if case .verified(let txn) = verificationResult, String(txn.id) == transactionId {
+                foundAfter = true
+                break
+            }
+        }
+        XCTAssertFalse(foundAfter, "Transaction should not be in unfinished after finishing")
+    }
+
+    func testFinishTransactionNoOpForUnknownId() async throws {
+        // Finishing a transaction that was never purchased should be a no-op
+        try await helper.finishTransaction(transactionId: "999999999")
+        // No error thrown — success
+    }
+
+    // MARK: - restorePurchases
+
+    func testRestorePurchasesReturnsActiveEntitlements() async throws {
+        // Simulate a purchase so there is an active entitlement
+        try session.buyProduct(productIdentifier: "com.nami.test.lifetime")
+
+        let restored = try await helper.restorePurchases()
+
+        XCTAssertGreaterThanOrEqual(restored.count, 1,
+                                    "Should return at least the lifetime entitlement")
+
+        // Find the lifetime transaction in the results
+        let lifetime = restored.first { ($0["skuId"] as? String) == "com.nami.test.lifetime" }
+        let entry = try XCTUnwrap(lifetime, "Restored results should contain the lifetime product")
+
+        let transactionId = try XCTUnwrap(entry["transactionId"] as? String)
+        XCTAssertFalse(transactionId.isEmpty, "transactionId should be non-empty")
+
+        let receipt = try XCTUnwrap(entry["receipt"] as? String)
+        XCTAssertFalse(receipt.isEmpty, "receipt (JWS) should be non-empty")
+
+        let purchaseTime = try XCTUnwrap(entry["purchaseTime"] as? Int)
+        XCTAssertGreaterThan(purchaseTime, 0, "purchaseTime should be a positive epoch millis")
+    }
+
+    func testRestorePurchasesEmptyWhenNoEntitlements() async throws {
+        // Fresh session with no purchases — should return an empty array
+        let restored = try await helper.restorePurchases()
+        XCTAssertTrue(restored.isEmpty, "Should return empty array when there are no entitlements")
+    }
+
+    // MARK: - TransactionObserver (initConnection / endConnection)
+
+    func testInitConnectionFiresCallbackOnPurchase() async throws {
+        let expectation = XCTestExpectation(description: "onUpdate callback fires with transaction dict")
+
+        var receivedDict: [String: Any]?
+        await helper.initConnection { dict in
+            receivedDict = dict
+            expectation.fulfill()
+        }
+
+        // Trigger a purchase via SKTestSession — this produces a Transaction.updates event
+        try session.buyProduct(productIdentifier: "com.nami.test.consumable")
+
+        await fulfillment(of: [expectation], timeout: 5.0)
+
+        let dict = try XCTUnwrap(receivedDict, "Callback should have received a transaction dict")
+        let skuId = try XCTUnwrap(dict["skuId"] as? String)
+        XCTAssertEqual(skuId, "com.nami.test.consumable")
+
+        let transactionId = try XCTUnwrap(dict["transactionId"] as? String)
+        XCTAssertFalse(transactionId.isEmpty, "transactionId should be non-empty")
+
+        let receipt = try XCTUnwrap(dict["receipt"] as? String)
+        XCTAssertFalse(receipt.isEmpty, "receipt (JWS) should be non-empty")
+
+        // Clean up
+        await helper.endConnection()
+    }
+
+    func testEndConnectionStopsCallbackFiring() async throws {
+        let firstExpectation = XCTestExpectation(description: "First purchase fires callback")
+        let secondExpectation = XCTestExpectation(description: "Second purchase should NOT fire callback")
+        secondExpectation.isInverted = true
+
+        var callCount = 0
+        await helper.initConnection { _ in
+            callCount += 1
+            if callCount == 1 {
+                firstExpectation.fulfill()
+            } else {
+                secondExpectation.fulfill()
+            }
+        }
+
+        // First purchase — should fire callback
+        try session.buyProduct(productIdentifier: "com.nami.test.consumable")
+        await fulfillment(of: [firstExpectation], timeout: 5.0)
+
+        // Stop the observer
+        await helper.endConnection()
+
+        // Second purchase — should NOT fire callback (inverted expectation)
+        try session.buyProduct(productIdentifier: "com.nami.test.lifetime")
+        await fulfillment(of: [secondExpectation], timeout: 2.0)
+
+        XCTAssertEqual(callCount, 1, "Callback should have fired exactly once (before endConnection)")
+    }
+}

package/ios/TransactionObserver.swift

@@ -0,0 +1,54 @@
+//
+//  TransactionObserver.swift
+//  ExpoNamiIap
+//
+//  Copyright (c) 2024 Nami ML Inc. All rights reserved.
+//
+
+import StoreKit
+
+/// Actor that listens for `Transaction.updates` and forwards verified
+/// transactions to a registered callback as bridgeable dictionaries.
+///
+/// Used by `StoreKit2Helper.initConnection(onUpdate:)` /
+/// `StoreKit2Helper.endConnection()` to provide the JavaScript layer
+/// with real-time transaction events.
+@available(iOS 15.0, tvOS 15.0, *)
+actor TransactionObserver {
+
+    private var task: Task<Void, Never>?
+    private var onUpdate: (@Sendable ([String: Any]) -> Void)?
+
+    /// Begin observing `Transaction.updates`.
+    ///
+    /// Idempotent — calling `start` while already observing cancels the
+    /// previous listener and creates a new one.
+    ///
+    /// - Parameter onUpdate: Closure invoked for each verified transaction,
+    ///   receiving a dictionary matching the `ExpoNamiIapTransaction` shape.
+    func start(onUpdate: @escaping @Sendable ([String: Any]) -> Void) {
+        self.onUpdate = onUpdate
+        task?.cancel()
+        task = Task.detached { [weak self] in
+            for await result in Transaction.updates {
+                if Task.isCancelled { break }
+                if case .verified(let txn) = result {
+                    await self?.notify(txn, jws: result.jwsRepresentation)
+                }
+            }
+        }
+    }
+
+    /// Stop observing `Transaction.updates` and discard the callback.
+    func stop() {
+        task?.cancel()
+        task = nil
+        onUpdate = nil
+    }
+
+    // MARK: - Private
+
+    private func notify(_ txn: Transaction, jws: String?) {
+        onUpdate?(StoreKit2Helper.txnToDict(txn, jwsRepresentation: jws))
+    }
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@namiml/expo-nami-iap",
+  "version": "3.4.0-dev.202605060437",
+  "description": "Nami Expo native IAP module — StoreKit 2, Google Play Billing, Amazon IAP, and Kepler",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "react-native": "./src/index.ts",
+  "source": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "ios",
+    "android",
+    "expo-module.config.json"
+  ],
+  "scripts": {
+    "build": "rollup -c rollup.config.mjs",
+    "build:prod": "NODE_ENV=production rollup -c rollup.config.mjs",
+    "test": "jest --coverage",
+    "lint": "eslint src/",
+    "clean": "rm -rf dist",
+    "dev": "rollup -c rollup.config.mjs -w",
+    "prepublishOnly": "yarn clean && yarn build:prod"
+  },
+  "peerDependencies": {
+    "@namiml/sdk-core": "3.4.0-dev.202605060437",
+    "expo": "*",
+    "react": ">=18.0.0",
+    "react-native": ">=0.72.0"
+  },
+  "peerDependenciesMeta": {
+    "@amazon-devices/keplerscript-appstore-iap-lib": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@namiml/sdk-core": "3.4.0-dev.202605060437",
+    "@rollup/plugin-commonjs": "^28.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/jest": "^29.5.14",
+    "@types/react": "^18.3.12",
+    "eslint": "^10.2.0",
+    "jest": "^29.7.0",
+    "react": "^18.3.1",
+    "react-native": "^0.75.0",
+    "rollup": "^4.18.0",
+    "rollup-plugin-dts": "^6.1.0",
+    "ts-jest": "^29.2.0",
+    "typescript": "^5.4.5",
+    "typescript-eslint": "^8.58.0"
+  },
+  "packageManager": "yarn@4.4.0"
+}