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

package/android/src/testAmazon/java/ml/nami/expo/iap/ExpoNamiIapModuleAmazonFlavorTest.kt

@@ -0,0 +1,71 @@
+package ml.nami.expo.iap
+
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.Test
+
+/**
+ * Amazon-flavor smoke tests for [ExpoNamiIapModule] backend resolution.
+ *
+ * Under the `amazon` product flavor, `PlayBillingBackend` is absent from
+ * the classpath while `AmazonIapBackend` is present. The
+ * [ExpoNamiIapModule.buildBackend] method tries Google first, catches
+ * [ClassNotFoundException], and falls back to Amazon. These tests verify
+ * that fall-through path.
+ */
+class ExpoNamiIapModuleAmazonFlavorTest {
+    /**
+     * Google's [PlayBillingBackend] must NOT be on the classpath in the
+     * `amazon` flavor — confirming the first `Class.forName` in
+     * [buildBackend] will throw.
+     */
+    @Test
+    fun `PlayBillingBackend is absent from the amazon flavor classpath`() {
+        try {
+            Class.forName("ml.nami.expo.iap.google.PlayBillingBackend")
+            fail("PlayBillingBackend should NOT be on the amazon-flavor classpath")
+        } catch (_: ClassNotFoundException) {
+            // Expected — Google class is not compiled into the amazon flavor
+        }
+    }
+
+    /**
+     * Amazon's [AmazonIapBackend] must be discoverable on the classpath
+     * and instantiable via its no-arg constructor — the same path
+     * [buildBackend] takes after the Google fallback.
+     */
+    @Test
+    fun `AmazonIapBackend is on the amazon flavor classpath`() {
+        val cls = Class.forName("ml.nami.expo.iap.amazon.AmazonIapBackend")
+        assertNotNull("AmazonIapBackend class should be on the classpath", cls)
+
+        val instance = cls.getDeclaredConstructor().newInstance()
+        assertTrue(
+            "Resolved backend should be an IapBackend",
+            instance is IapBackend,
+        )
+    }
+
+    /**
+     * Replicate the full [buildBackend] resolution logic: try Google
+     * first (fails with [ClassNotFoundException]), fall back to Amazon
+     * (succeeds), and verify the result is an [IapBackend].
+     */
+    @Test
+    fun `buildBackend resolution falls through to AmazonIapBackend`() {
+        val cls =
+            try {
+                Class.forName("ml.nami.expo.iap.google.PlayBillingBackend")
+            } catch (_: ClassNotFoundException) {
+                Class.forName("ml.nami.expo.iap.amazon.AmazonIapBackend")
+            }
+
+        val backend = cls.getDeclaredConstructor().newInstance() as IapBackend
+        assertNotNull("Backend instance should be non-null", backend)
+        assertTrue(
+            "Backend should be AmazonIapBackend",
+            backend::class.java.simpleName == "AmazonIapBackend",
+        )
+    }
+}

package/dist/index.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+var expoModulesCore = require('expo-modules-core');
+
+const NativeModule = expoModulesCore.requireNativeModule('ExpoNamiIapModule');
+const emitter = new expoModulesCore.EventEmitter(NativeModule);
+
+function configure(options) {
+    NativeModule.configure(options);
+}
+function initConnection() {
+    return NativeModule.initConnection();
+}
+function endConnection() {
+    return NativeModule.endConnection();
+}
+function getProducts(skuIds) {
+    return NativeModule.getProducts(skuIds);
+}
+function checkEligibility(skuIds) {
+    return NativeModule.checkEligibility(skuIds);
+}
+function purchase(options) {
+    return NativeModule.purchase(options);
+}
+function restorePurchases() {
+    return NativeModule.restorePurchases();
+}
+function finishTransaction(transactionId) {
+    return NativeModule.finishTransaction(transactionId);
+}
+/**
+ * Subscribe to real-time transaction updates from the native layer.
+ * Returns a subscription object with a `remove()` method to unsubscribe.
+ */
+function addTransactionListener(cb) {
+    return emitter.addListener('onTransactionUpdate', cb);
+}
+/**
+ * Subscribe to error events from the native layer.
+ * Returns a subscription object with a `remove()` method to unsubscribe.
+ */
+function addErrorListener(cb) {
+    return emitter.addListener('onError', cb);
+}
+
+exports.addErrorListener = addErrorListener;
+exports.addTransactionListener = addTransactionListener;
+exports.checkEligibility = checkEligibility;
+exports.configure = configure;
+exports.endConnection = endConnection;
+exports.finishTransaction = finishTransaction;
+exports.getProducts = getProducts;
+exports.initConnection = initConnection;
+exports.purchase = purchase;
+exports.restorePurchases = restorePurchases;

package/dist/index.d.ts

@@ -0,0 +1,62 @@
+import { NamiProductDetails } from '@namiml/sdk-core';
+
+interface ExpoNamiIapProduct extends NamiProductDetails {
+    platform_raw?: unknown;
+}
+interface ExpoNamiIapTransaction {
+    skuId: string;
+    transactionId: string;
+    originalTransactionId?: string;
+    receipt?: string;
+    purchaseToken?: string;
+    purchaseTime?: number;
+    isAcknowledged?: boolean;
+}
+type ExpoNamiIapErrorCode = 'user_cancelled' | 'network' | 'item_unavailable' | 'already_owned' | 'not_allowed' | 'unknown';
+interface ExpoNamiIapError {
+    code: ExpoNamiIapErrorCode;
+    message: string;
+    nativeCode?: string;
+}
+interface EligibilityResult {
+    skuId: string;
+    introEligible: boolean;
+    promoEligible: boolean;
+}
+interface ConfigureOptions {
+    amazon?: {
+        autoRegisterListener?: boolean;
+    };
+}
+interface PurchaseOptions {
+    skuId: string;
+    offerId?: string;
+    offerSignature?: string;
+    appAccountToken?: string;
+}
+
+declare function configure(options: ConfigureOptions): void;
+declare function initConnection(): Promise<void>;
+declare function endConnection(): Promise<void>;
+declare function getProducts(skuIds: string[]): Promise<ExpoNamiIapProduct[]>;
+declare function checkEligibility(skuIds: string[]): Promise<EligibilityResult[]>;
+declare function purchase(options: PurchaseOptions): Promise<ExpoNamiIapTransaction>;
+declare function restorePurchases(): Promise<ExpoNamiIapTransaction[]>;
+declare function finishTransaction(transactionId: string): Promise<void>;
+/**
+ * Subscribe to real-time transaction updates from the native layer.
+ * Returns a subscription object with a `remove()` method to unsubscribe.
+ */
+declare function addTransactionListener(cb: (tx: ExpoNamiIapTransaction) => void): {
+    remove: () => void;
+};
+/**
+ * Subscribe to error events from the native layer.
+ * Returns a subscription object with a `remove()` method to unsubscribe.
+ */
+declare function addErrorListener(cb: (err: ExpoNamiIapError) => void): {
+    remove: () => void;
+};
+
+export { addErrorListener, addTransactionListener, checkEligibility, configure, endConnection, finishTransaction, getProducts, initConnection, purchase, restorePurchases };
+export type { ConfigureOptions, EligibilityResult, ExpoNamiIapError, ExpoNamiIapErrorCode, ExpoNamiIapProduct, ExpoNamiIapTransaction, PurchaseOptions };

package/dist/index.mjs

@@ -0,0 +1,45 @@
+import { requireNativeModule, EventEmitter } from 'expo-modules-core';
+
+const NativeModule = requireNativeModule('ExpoNamiIapModule');
+const emitter = new EventEmitter(NativeModule);
+
+function configure(options) {
+    NativeModule.configure(options);
+}
+function initConnection() {
+    return NativeModule.initConnection();
+}
+function endConnection() {
+    return NativeModule.endConnection();
+}
+function getProducts(skuIds) {
+    return NativeModule.getProducts(skuIds);
+}
+function checkEligibility(skuIds) {
+    return NativeModule.checkEligibility(skuIds);
+}
+function purchase(options) {
+    return NativeModule.purchase(options);
+}
+function restorePurchases() {
+    return NativeModule.restorePurchases();
+}
+function finishTransaction(transactionId) {
+    return NativeModule.finishTransaction(transactionId);
+}
+/**
+ * Subscribe to real-time transaction updates from the native layer.
+ * Returns a subscription object with a `remove()` method to unsubscribe.
+ */
+function addTransactionListener(cb) {
+    return emitter.addListener('onTransactionUpdate', cb);
+}
+/**
+ * Subscribe to error events from the native layer.
+ * Returns a subscription object with a `remove()` method to unsubscribe.
+ */
+function addErrorListener(cb) {
+    return emitter.addListener('onError', cb);
+}
+
+export { addErrorListener, addTransactionListener, checkEligibility, configure, endConnection, finishTransaction, getProducts, initConnection, purchase, restorePurchases };

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["ios", "android"],
+  "ios": {
+    "modules": ["ExpoNamiIapModule"]
+  },
+  "android": {
+    "modules": ["ml.nami.expo.iap.ExpoNamiIapModule"]
+  }
+}

package/ios/Errors.swift

@@ -0,0 +1,178 @@
+//
+//  Errors.swift
+//  ExpoNamiIap
+//
+//  Copyright (c) 2024 Nami ML Inc. All rights reserved.
+//
+
+import StoreKit
+
+// MARK: - ExpoNamiIapError
+
+/// Typed error enum mirroring the Android `ExpoNamiIapException` sealed class.
+/// Each case carries an optional `nativeCode` for debugging and a `message`.
+@available(iOS 15.0, tvOS 15.0, *)
+enum ExpoNamiIapError: Error {
+    case userCancelled(nativeCode: String? = nil)
+    case network(message: String, nativeCode: String? = nil)
+    case itemUnavailable(message: String, nativeCode: String? = nil)
+    case alreadyOwned(nativeCode: String? = nil)
+    case notAllowed(message: String, nativeCode: String? = nil)
+    case unknown(message: String, nativeCode: String? = nil)
+
+    /// The normalized error code sent to JavaScript.
+    var code: String {
+        switch self {
+        case .userCancelled: return "user_cancelled"
+        case .network: return "network"
+        case .itemUnavailable: return "item_unavailable"
+        case .alreadyOwned: return "already_owned"
+        case .notAllowed: return "not_allowed"
+        case .unknown: return "unknown"
+        }
+    }
+
+    /// Human-readable message.
+    var message: String {
+        switch self {
+        case .userCancelled: return "User cancelled"
+        case .network(let message, _): return message
+        case .itemUnavailable(let message, _): return message
+        case .alreadyOwned: return "Already owned"
+        case .notAllowed(let message, _): return message
+        case .unknown(let message, _): return message
+        }
+    }
+
+    /// Raw platform error code for debugging (nil when not available).
+    var nativeCode: String? {
+        switch self {
+        case .userCancelled(let nc): return nc
+        case .network(_, let nc): return nc
+        case .itemUnavailable(_, let nc): return nc
+        case .alreadyOwned(let nc): return nc
+        case .notAllowed(_, let nc): return nc
+        case .unknown(_, let nc): return nc
+        }
+    }
+
+    /// Convert to a dictionary matching the `ExpoNamiIapError` TypeScript shape:
+    /// `{ code: string, message: string, nativeCode?: string }`.
+    func toDict() -> [String: Any] {
+        var dict: [String: Any] = [
+            "code": code,
+            "message": message,
+        ]
+        if let nativeCode {
+            dict["nativeCode"] = nativeCode
+        }
+        return dict
+    }
+}
+
+// MARK: - Errors (namespace)
+
+/// Static helpers that translate StoreKit errors and `Product.PurchaseResult` into
+/// `ExpoNamiIapError` values.
+@available(iOS 15.0, tvOS 15.0, *)
+enum Errors {
+
+    // MARK: - From generic Error
+
+    /// Map any `Error` to `ExpoNamiIapError`.
+    ///
+    /// - If the error is already an `ExpoNamiIapError`, it passes through unchanged.
+    /// - `StoreKitError` cases are pattern-matched to the normalized codes.
+    /// - Anything else falls through to `.unknown`.
+    static func toExpoNamiIapError(_ error: Error) -> ExpoNamiIapError {
+        // Pass-through if already our type.
+        if let iapError = error as? ExpoNamiIapError {
+            return iapError
+        }
+
+        // StoreKit 2 errors.
+        if let skError = error as? StoreKitError {
+            return fromStoreKitError(skError)
+        }
+
+        // Fallback — any unknown Error.
+        return .unknown(
+            message: error.localizedDescription,
+            nativeCode: String(describing: error)
+        )
+    }
+
+    // MARK: - From Product.PurchaseResult
+
+    /// Translate a `Product.PurchaseResult` into an error, or `nil` if the result is `.success`.
+    ///
+    /// - `.userCancelled` → `ExpoNamiIapError.userCancelled`
+    /// - `.pending` → `ExpoNamiIapError.unknown` (transaction pending approval)
+    /// - `.success` → `nil`
+    /// - `@unknown default` → `ExpoNamiIapError.unknown`
+    static func fromPurchaseResult(_ result: Product.PurchaseResult) -> ExpoNamiIapError? {
+        switch result {
+        case .success:
+            return nil
+        case .userCancelled:
+            return .userCancelled()
+        case .pending:
+            return .unknown(message: "Transaction pending approval")
+        @unknown default:
+            return .unknown(message: "Unrecognized purchase result")
+        }
+    }
+
+    // MARK: - item_unavailable helper
+
+    /// Convenience factory for the `item_unavailable` case, used by `StoreKit2Helper.getProducts`
+    /// when a product fetch returns empty results.
+    static func itemUnavailable(_ message: String) -> ExpoNamiIapError {
+        .itemUnavailable(message: message)
+    }
+
+    // MARK: - Private
+
+    private static func fromStoreKitError(_ error: StoreKitError) -> ExpoNamiIapError {
+        switch error {
+        case .userCancelled:
+            return .userCancelled(nativeCode: "StoreKitError.userCancelled")
+
+        case .networkError(let urlError):
+            return .network(
+                message: urlError.localizedDescription,
+                nativeCode: "StoreKitError.networkError(\(urlError.code.rawValue))"
+            )
+
+        case .notAvailableInStorefront:
+            return .notAllowed(
+                message: "Not available in storefront",
+                nativeCode: "StoreKitError.notAvailableInStorefront"
+            )
+
+        case .notEntitled:
+            return .notAllowed(
+                message: "Not entitled",
+                nativeCode: "StoreKitError.notEntitled"
+            )
+
+        case .systemError(let underlying):
+            return .unknown(
+                message: underlying.localizedDescription,
+                nativeCode: "StoreKitError.systemError(\(String(describing: underlying)))"
+            )
+
+        case .unknown:
+            return .unknown(
+                message: "Unknown StoreKit error",
+                nativeCode: "StoreKitError.unknown"
+            )
+
+        @unknown default:
+            return .unknown(
+                message: "Unrecognized StoreKit error",
+                nativeCode: String(describing: error)
+            )
+        }
+    }
+}

package/ios/ExpoNamiIap.podspec

@@ -0,0 +1,14 @@
+Pod::Spec.new do |s|
+  s.name           = 'ExpoNamiIap'
+  s.version        = '3.4.0'
+  s.summary        = 'Nami Expo IAP module — StoreKit 2'
+  s.description    = 'Native IAP primitives for Nami Expo SDK'
+  s.author         = 'Nami ML Inc.'
+  s.homepage       = 'https://www.nami.ml'
+  s.platforms      = { :ios => '15.0', :tvos => '15.0' }
+  s.source         = { git: '' }
+  s.static_framework = true
+  s.swift_version    = '5.9'
+  s.dependency 'ExpoModulesCore'
+  s.source_files = "**/*.{h,m,swift}"
+end

package/ios/ExpoNamiIapModule.swift

@@ -0,0 +1,81 @@
+import ExpoModulesCore
+import StoreKit
+
+public class ExpoNamiIapModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("ExpoNamiIapModule")
+
+    Events("onTransactionUpdate", "onError")
+
+    OnCreate {
+      if #available(iOS 15.0, tvOS 15.0, *) {
+        Task { [weak self] in
+          await StoreKit2Helper.shared.initConnection { dict in
+            self?.sendEvent("onTransactionUpdate", dict)
+          }
+        }
+      }
+    }
+
+    OnDestroy {
+      if #available(iOS 15.0, tvOS 15.0, *) {
+        Task {
+          await StoreKit2Helper.shared.endConnection()
+        }
+      }
+    }
+
+    Function("configure") { (_: [String: Any]) -> Void in
+      // No-op on iOS. This function exists for the Android Amazon IAP mode
+      // toggle. iOS StoreKit 2 requires no runtime configuration.
+    }
+
+    AsyncFunction("initConnection") {
+      if #available(iOS 15.0, tvOS 15.0, *) {
+        await StoreKit2Helper.shared.initConnection { [weak self] dict in
+          self?.sendEvent("onTransactionUpdate", dict)
+        }
+      }
+    }
+
+    AsyncFunction("endConnection") {
+      if #available(iOS 15.0, tvOS 15.0, *) {
+        await StoreKit2Helper.shared.endConnection()
+      }
+    }
+
+    AsyncFunction("getProducts") { (skuIds: [String]) -> [[String: Any]] in
+      guard #available(iOS 15.0, tvOS 15.0, *) else { return [] }
+      return try await StoreKit2Helper.shared.getProducts(skuIds)
+    }
+
+    AsyncFunction("checkEligibility") { (skuIds: [String]) -> [[String: Any]] in
+      guard #available(iOS 15.0, tvOS 15.0, *) else { return [] }
+      return try await StoreKit2Helper.shared.checkEligibility(skuIds)
+    }
+
+    AsyncFunction("purchase") { (options: [String: Any]) -> [String: Any] in
+      guard #available(iOS 15.0, tvOS 15.0, *) else { return [:] }
+      let skuId = options["skuId"] as? String ?? ""
+      let offerId = options["offerId"] as? String
+      let offerSignature = options["offerSignature"] as? String
+      let appAccountToken = options["appAccountToken"] as? String
+      return try await StoreKit2Helper.shared.purchase(
+        skuId: skuId,
+        offerId: offerId,
+        offerSignature: offerSignature,
+        appAccountToken: appAccountToken
+      )
+    }
+
+    AsyncFunction("restorePurchases") { () -> [[String: Any]] in
+      guard #available(iOS 15.0, tvOS 15.0, *) else { return [] }
+      return try await StoreKit2Helper.shared.restorePurchases()
+    }
+
+    AsyncFunction("finishTransaction") { (transactionId: String) -> Void in
+      guard #available(iOS 15.0, tvOS 15.0, *) else { return }
+      try await StoreKit2Helper.shared.finishTransaction(transactionId: transactionId)
+    }
+  }
+}

package/ios/ProductMapper.swift

@@ -0,0 +1,130 @@
+//
+//  ProductMapper.swift
+//  ExpoNamiIap
+//
+//  Copyright (c) 2024 Nami ML Inc. All rights reserved.
+//
+
+import StoreKit
+
+/// Maps a StoreKit `Product` into a dictionary matching the `ExpoNamiIapProduct` TypeScript type.
+///
+/// The output dictionary conforms to the `NamiProductDetails` shape defined in
+/// `sdk/core/src/types/externals/product.ts` and extended by `ExpoNamiIapProduct` in
+/// `sdk/expo/modules/expo-nami-iap/src/types.ts`.
+@available(iOS 15.0, tvOS 15.0, *)
+struct ProductMapper {
+
+    /// Convert a StoreKit `Product` to a dictionary suitable for bridging to TypeScript.
+    ///
+    /// Keys emitted:
+    /// - `product_ref_id` (String)
+    /// - `name` (String)
+    /// - `description` (String)
+    /// - `product_type` ("one_time_purchase" | "subscription")
+    /// - `offers` ([[String: Any]])
+    /// - `subscription_period` ([String: Any]) — only present for subscriptions
+    static func toDict(_ product: Product) async -> [String: Any] {
+        var result: [String: Any] = [
+            "product_ref_id": product.id,
+            "name": product.displayName,
+            "description": product.description,
+            "product_type": mapProductType(product),
+            "offers": await buildOffers(product),
+        ]
+
+        if let sub = product.subscription {
+            result["subscription_period"] = periodDict(sub.subscriptionPeriod)
+        }
+
+        return result
+    }
+
+    // MARK: - Product Type
+
+    private static func mapProductType(_ product: Product) -> String {
+        switch product.type {
+        case .consumable, .nonConsumable:
+            return "one_time_purchase"
+        case .autoRenewable, .nonRenewable:
+            return "subscription"
+        default:
+            return "unknown"
+        }
+    }
+
+    // MARK: - Offers
+
+    private static func buildOffers(_ product: Product) async -> [[String: Any]] {
+        let currency = currencyCode(for: product)
+
+        // Default offer (base price)
+        var offers: [[String: Any]] = [[
+            "offer_type": "default",
+            "price": NSDecimalNumber(decimal: product.price).doubleValue,
+            "currency": currency,
+        ]]
+
+        // Intro offer (if any)
+        if let sub = product.subscription, let intro = sub.introductoryOffer {
+            offers.append(introOfferDict(intro, currency: currency))
+        }
+
+        // Promotional offers
+        if let sub = product.subscription {
+            for promo in sub.promotionalOffers {
+                offers.append(promoOfferDict(promo, currency: currency))
+            }
+        }
+
+        return offers
+    }
+
+    // MARK: - Period
+
+    static func periodDict(_ period: Product.SubscriptionPeriod) -> [String: Any] {
+        let type: String = switch period.unit {
+        case .day: "day"
+        case .week: "week"
+        case .month: "month"
+        case .year: "year"
+        @unknown default: "unknown"
+        }
+        return ["type": type, "count": period.value]
+    }
+
+    // MARK: - Intro Offer
+
+    private static func introOfferDict(
+        _ offer: Product.SubscriptionOffer,
+        currency: String
+    ) -> [String: Any] {
+        [
+            "offer_type": offer.paymentMode == .freeTrial ? "free_trial" : "intro",
+            "price": NSDecimalNumber(decimal: offer.price).doubleValue,
+            "currency": currency,
+            "promo_period": periodDict(offer.period),
+        ]
+    }
+
+    // MARK: - Promo Offer
+
+    private static func promoOfferDict(
+        _ offer: Product.SubscriptionOffer,
+        currency: String
+    ) -> [String: Any] {
+        [
+            "offer_type": "promo",
+            "offer_ref_id": offer.id ?? NSNull(),
+            "price": NSDecimalNumber(decimal: offer.price).doubleValue,
+            "currency": currency,
+            "promo_period": periodDict(offer.period),
+        ]
+    }
+
+    // MARK: - Currency
+
+    private static func currencyCode(for product: Product) -> String {
+        product.priceFormatStyle.locale.currency?.identifier ?? "USD"
+    }
+}