capacitor-plugin-cdv-purchase 13.17.2 → 13.19.1

package/ios/Sources/PurchasePlugin/PurchasePlugin.swift

@@ -5,6 +5,11 @@ import StoreKit
 @available(iOS 15.0, *)
 private class SK2State {
     var products: [String: Product] = [:]
+    /// Transactions emitted to JS and not yet finished. Access must be
+    /// serialized on the main thread (same as processedTransactionIds below):
+    /// the detached Transaction.updates observer, emitTransactionUpdate(),
+    /// finish(), and clearExpiredUnfinishedTransactions() all read or
+    /// mutate it from concurrent async contexts.
     var unfinishedTransactions: [String: Transaction] = [:]
     var transactionObserverTask: Task<Void, Never>?
     /// Transaction IDs already emitted to JS. Prevents duplicate delivery when
@@ -46,20 +51,21 @@ public class PurchasePlugin: CAPPlugin, CAPBridgedPlugin {
 
     // MARK: - Lifecycle
 
-    override public func load() {
-        if #available(iOS 15.0, *) {
-            startTransactionObserver()
-        }
-    }
-
     deinit {
         if #available(iOS 15.0, *) {
             sk2.transactionObserverTask?.cancel()
         }
     }
 
+    /// Start listening to Transaction.updates. Called at the end of init(),
+    /// NOT at plugin load: Transaction.updates delivers unfinished
+    /// transactions as soon as iteration begins, and before JS called init()
+    /// no listener is attached — the events would be lost while their ids
+    /// still land in processedTransactionIds, hiding unfinished purchases
+    /// for the rest of the session.
     @available(iOS 15.0, *)
     private func startTransactionObserver() {
+        guard sk2.transactionObserverTask == nil else { return }
         sk2.transactionObserverTask = Task.detached { [weak self] in
             for await result in Transaction.updates {
                 guard let self = self else { return }
@@ -73,22 +79,18 @@ public class PurchasePlugin: CAPPlugin, CAPBridgedPlugin {
         let jwsRepresentation = result.jwsRepresentation
         switch result {
         case .verified(let transaction):
-            // Serialize access to processedTransactionIds on the main thread
-            // since this method runs from a detached Task while init()/purchase()
-            // also mutate the set.
-            let shouldEmit: Bool = await MainActor.run {
-                if sk2.processedTransactionIds.contains(transaction.id) {
-                    debugLog("Transaction.updates: skipping duplicate id=\(transaction.id)")
-                    return false
-                }
-                sk2.processedTransactionIds.insert(transaction.id)
-                return true
+            guard await markEmittedToJs(transaction.id) else {
+                debugLog("Transaction.updates: skipping duplicate id=\(transaction.id)")
+                return
             }
-            guard shouldEmit else { return }
             await emitTransactionUpdate(transaction, state: "PaymentTransactionStatePurchased",
                                         jwsRepresentation: jwsRepresentation)
         case .unverified(let transaction, _):
-            // Emit as Purchased — let JS layer handle verification
+            // Emit as Purchased — let JS layer handle verification.
+            // Deliberately NOT deduped via markEmittedToJs: marking an
+            // unverified id would suppress the transaction for the rest of
+            // the session even if a later delivery verifies. A double-emit of
+            // the same JWS is harmless — JS re-validates it.
             await emitTransactionUpdate(transaction, state: "PaymentTransactionStatePurchased",
                                         jwsRepresentation: jwsRepresentation)
         }
@@ -104,29 +106,55 @@ public class PurchasePlugin: CAPPlugin, CAPBridgedPlugin {
         debugEnabled = call.getBool("debug", false)
         debugLog("init")
 
-        // Load current entitlements and emit to JS so existing subscriptions
-        // are visible immediately on app launch (without requiring a manual restore).
+        // Load current entitlements and unfinished transactions, and emit them
+        // to JS so existing purchases are visible immediately on app launch
+        // (without requiring a manual restore).
         Task {
-            for await result in Transaction.currentEntitlements {
+            let (entitlements, unfinishedIds) = await self.entitlementsWithUnfinishedIds()
+            for result in entitlements {
                 switch result {
                 case .verified(let transaction):
                     if transaction.isUpgraded {
                         debugLog("init: skipping upgraded entitlement id=\(transaction.id) product=\(transaction.productID)")
                         continue
                     }
-                    if self.sk2.processedTransactionIds.contains(transaction.id) {
-                        debugLog("init: skipping already-processed entitlement id=\(transaction.id)")
+                    guard await self.markEmittedToJs(transaction.id) else {
+                        debugLog("init: skipping already-emitted entitlement id=\(transaction.id)")
                         continue
                     }
-                    self.sk2.processedTransactionIds.insert(transaction.id)
-                    self.sk2.unfinishedTransactions[String(transaction.id)] = transaction
                     await self.emitTransactionUpdate(transaction,
                         state: "PaymentTransactionStateRestored",
-                        jwsRepresentation: result.jwsRepresentation)
+                        jwsRepresentation: result.jwsRepresentation,
+                        isFinished: !unfinishedIds.contains(transaction.id))
                 case .unverified(let transaction, let error):
                     debugLog("init: unverified entitlement id=\(transaction.id) product=\(transaction.productID) error=\(error)")
                 }
             }
+            // Emit every transaction the app hasn't finished yet. This is the
+            // only reliable source for unfinished consumables: they never
+            // appear in currentEntitlements, so without this pass an
+            // unfinished consumable would hang in limbo for the session.
+            for await result in Transaction.unfinished {
+                switch result {
+                case .verified(let transaction):
+                    if transaction.isUpgraded {
+                        debugLog("init: skipping upgraded unfinished transaction id=\(transaction.id) product=\(transaction.productID)")
+                        continue
+                    }
+                    guard await self.markEmittedToJs(transaction.id) else { continue }
+                    debugLog("init: emitting unfinished transaction id=\(transaction.id) product=\(transaction.productID)")
+                    await self.emitTransactionUpdate(transaction,
+                        state: "PaymentTransactionStateRestored",
+                        jwsRepresentation: result.jwsRepresentation,
+                        isFinished: false)
+                case .unverified(let transaction, let error):
+                    debugLog("init: unverified unfinished transaction id=\(transaction.id) product=\(transaction.productID) error=\(error)")
+                }
+            }
+            // Only now start observing Transaction.updates — see the comment
+            // on startTransactionObserver() for why starting earlier loses
+            // unfinished transactions.
+            self.startTransactionObserver()
             call.resolve()
         }
     }
@@ -206,12 +234,13 @@ public class PurchasePlugin: CAPPlugin, CAPBridgedPlugin {
                     let jwsRepresentation = verification.jwsRepresentation
                     switch verification {
                     case .verified(let transaction):
-                        sk2.processedTransactionIds.insert(transaction.id)
+                        _ = await markEmittedToJs(transaction.id)
                         await emitTransactionUpdate(transaction,
                                                     state: "PaymentTransactionStatePurchased",
                                                     jwsRepresentation: jwsRepresentation)
                     case .unverified(let transaction, _):
-                        // Emit as Purchased — let JS handle verification
+                        // Emit as Purchased — let JS handle verification.
+                        // Deliberately not deduped — see handleTransactionUpdate.
                         await emitTransactionUpdate(transaction,
                                                     state: "PaymentTransactionStatePurchased",
                                                     jwsRepresentation: jwsRepresentation)
@@ -254,9 +283,17 @@ public class PurchasePlugin: CAPPlugin, CAPBridgedPlugin {
         debugLog("finish: \(transactionId)")
 
         Task {
-            if let transaction = sk2.unfinishedTransactions[transactionId] {
+            // Atomically claim the transaction on the main thread: read and
+            // removal must be one step, or two concurrent finish() calls for
+            // the same id could both proceed. Serialized because the detached
+            // Transaction.updates observer also mutates the dictionary.
+            let transaction: Transaction? = await MainActor.run {
+                guard let t = sk2.unfinishedTransactions[transactionId] else { return nil }
+                _ = sk2.unfinishedTransactions.removeValue(forKey: transactionId)
+                return t
+            }
+            if let transaction = transaction {
                 await transaction.finish()
-                sk2.unfinishedTransactions.removeValue(forKey: transactionId)
                 // Note: do NOT remove from processedTransactionIds here.
                 // Once a transaction ID has been emitted to JS, it must stay in the set
                 // for the lifetime of the session to prevent Transaction.updates from
@@ -289,17 +326,21 @@ public class PurchasePlugin: CAPPlugin, CAPBridgedPlugin {
         Task {
             do {
                 try await AppStore.sync()
-                for await result in Transaction.currentEntitlements {
+                let (entitlements, unfinishedIds) = await entitlementsWithUnfinishedIds()
+                for result in entitlements {
                     switch result {
                     case .verified(let transaction):
                         if transaction.isUpgraded {
                             debugLog("restore: skipping upgraded entitlement id=\(transaction.id) product=\(transaction.productID)")
                             continue
                         }
-                        sk2.processedTransactionIds.insert(transaction.id)
+                        // Restore deliberately re-emits transactions already
+                        // delivered this session — mark, but ignore the result.
+                        _ = await markEmittedToJs(transaction.id)
                         await emitTransactionUpdate(transaction,
                                                     state: "PaymentTransactionStateRestored",
-                                                    jwsRepresentation: result.jwsRepresentation)
+                                                    jwsRepresentation: result.jwsRepresentation,
+                                                    isFinished: !unfinishedIds.contains(transaction.id))
                     case .unverified(let transaction, let error):
                         debugLog("restore: unverified entitlement id=\(transaction.id) product=\(transaction.productID) error=\(error)")
                     }
@@ -407,19 +448,63 @@ public class PurchasePlugin: CAPPlugin, CAPBridgedPlugin {
             if let expirationDate = transaction.expirationDate, expirationDate < Date() {
                 debugLog("clearExpired: finishing expired transaction id=\(transaction.id) product=\(transaction.productID) expired=\(expirationDate)")
                 await transaction.finish()
-                sk2.unfinishedTransactions.removeValue(forKey: String(transaction.id))
+                await MainActor.run {
+                    _ = sk2.unfinishedTransactions.removeValue(forKey: String(transaction.id))
+                }
                 // Note: do NOT remove from processedTransactionIds.
                 // The set must grow monotonically to prevent re-delivery via Transaction.updates.
             }
         }
     }
 
+    /// Current entitlements, plus the ids of every transaction the app has
+    /// not finished yet. Used to tell finished entitlements apart from
+    /// unfinished ones: finished non-consumables and non-renewing
+    /// subscriptions stay in Transaction.currentEntitlements and are
+    /// re-emitted at every launch.
+    ///
+    /// The unfinished snapshot is taken AFTER listing entitlements, so an
+    /// entitlement is never wrongly reported as finished: anything listed
+    /// that is still unfinished is in the snapshot. The only possible error
+    /// is the safe one (finished in between, reported as unfinished).
+    @available(iOS 15.0, *)
+    private func entitlementsWithUnfinishedIds() async -> ([VerificationResult<Transaction>], Set<UInt64>) {
+        var entitlements: [VerificationResult<Transaction>] = []
+        for await result in Transaction.currentEntitlements {
+            entitlements.append(result)
+        }
+        var ids = Set<UInt64>()
+        for await result in Transaction.unfinished {
+            ids.insert(result.unsafePayloadValue.id)
+        }
+        return (entitlements, ids)
+    }
+
+    /// Atomically check-and-mark a transaction id as emitted to the JS layer.
+    /// Returns false when it was already emitted this session. "Emitted" is
+    /// unrelated to Apple's finished state — it only prevents duplicate
+    /// delivery of the same transaction within one app session. Serialized on
+    /// the main thread because the Transaction.updates observer runs in a
+    /// detached Task while init()/restore()/purchase() run in their own Tasks.
+    @available(iOS 15.0, *)
+    private func markEmittedToJs(_ id: UInt64) async -> Bool {
+        return await MainActor.run {
+            if sk2.processedTransactionIds.contains(id) { return false }
+            sk2.processedTransactionIds.insert(id)
+            return true
+        }
+    }
+
     @available(iOS 15.0, *)
     private func emitTransactionUpdate(_ transaction: Transaction, state: String,
                                        errorCode: Int? = nil, errorText: String? = nil,
-                                       jwsRepresentation: String? = nil) async {
+                                       jwsRepresentation: String? = nil,
+                                       isFinished: Bool? = nil) async {
         let transactionId = String(transaction.id)
-        sk2.unfinishedTransactions[transactionId] = transaction
+        // Serialized on the main thread — see SK2State.unfinishedTransactions.
+        await MainActor.run {
+            sk2.unfinishedTransactions[transactionId] = transaction
+        }
 
         var data: [String: Any] = [
             "state": state,
@@ -443,6 +528,11 @@ public class PurchasePlugin: CAPPlugin, CAPBridgedPlugin {
         if let jws = jwsRepresentation {
             data["jwsRepresentation"] = jws
         }
+        // Whether the app already called finish() on this transaction. Only
+        // set when known (Restored emissions), so JS can skip re-delivery.
+        if let isFinished = isFinished {
+            data["isFinished"] = isFinished
+        }
 
         notifyListeners("transactionUpdated", data: data)
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-plugin-cdv-purchase",
-  "version": "13.17.2",
+  "version": "13.19.1",
   "description": "In-App Purchases for Capacitor — iOS (StoreKit 2) and Android (Google Play Billing)",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -38,6 +38,7 @@
     "dist/",
     "types/",
     "www/",
+    "src/ts/platforms/iaptic-js/iaptic-js-types.d.ts",
     "android/",
     "!android/build",
     "ios/",

package/src/ts/platforms/iaptic-js/iaptic-js-types.d.ts

@@ -0,0 +1,326 @@
+declare namespace ModuleIapticJS {
+    /**
+     * Type of product that can be purchased
+     */
+    export type ProductType = 'subscription' | 'consumable' | 'non consumable' | 'paid subscription';
+
+    /**
+     * Represents a pricing phase for an offer
+     */
+    export interface PricingPhase {
+        /** Price in micros (1/1,000,000 of the currency unit). For example, $1.99 = 1990000 micros */
+        priceMicros: number;
+        /** ISO 4217 currency code (e.g., 'USD', 'EUR', 'JPY') */
+        currency: string;
+        /**
+         * ISO 8601 duration string representing the billing period
+         * Examples: 'P1M' = 1 month, 'P1Y' = 1 year, 'P7D' = 7 days
+         */
+        billingPeriod: string;
+        /**
+         * Defines how the subscription recurs
+         */
+        recurrenceMode: 'INFINITE_RECURRING' | 'NON_RECURRING' | 'FINITE_RECURRING';
+        /**
+         * Defines when payment is collected
+         */
+        paymentMode: 'PayAsYouGo' | 'PayUpFront';
+    }
+
+    /**
+     * Represents a purchase offer for a product
+     */
+    export interface Offer {
+        /** Unique identifier for the offer in the format 'platform:id' */
+        id: string;
+        /** Payment platform identifier (e.g., 'stripe', 'google', 'apple') */
+        platform: string;
+        /** Type of the offer */
+        offerType: 'Subscription' | 'Default';
+        /** Array of pricing phases that make up this offer's payment schedule */
+        pricingPhases: PricingPhase[];
+    }
+
+    /**
+     * Represents a product that can be purchased
+     */
+    export interface Product {
+        /** Type of the product (subscription, consumable, etc.) */
+        type: ProductType;
+        /** Unique identifier for the product */
+        id: string;
+        /** Display name of the product shown to customers */
+        title: string;
+        /** Optional detailed description of the product */
+        description?: string;
+        /** Available purchase offers for this product */
+        offers: Offer[];
+        /**
+         * Optional additional data associated with the product
+         */
+        metadata?: Record<string, any>;
+        /** Optional platform identifier (e.g., 'stripe') */
+        platform?: string;
+    }
+
+    /**
+     * Represents a purchased product
+     */
+    export interface Purchase {
+        /** Unique identifier for the purchase */
+        purchaseId: string;
+        /** Unique identifier for the transaction */
+        transactionId: string;
+        /** Unique identifier for the product */
+        productId: string;
+        /** Platform identifier (e.g., 'stripe') */
+        platform: 'stripe';
+        /** Date of the purchase */
+        purchaseDate: string;
+        /** Date of the last renewal */
+        lastRenewalDate: string;
+        /** Date of the expiration */
+        expirationDate: string;
+        /** Intent of the renewal */
+        renewalIntent: 'Renew' | 'Cancel';
+        /** Whether the purchase is a trial period */
+        isTrialPeriod: boolean;
+        /** Price in micros (1/1,000,000 of the currency unit) */
+        amountMicros: number;
+        /** Currency code (e.g., 'USD', 'EUR') */
+        currency: string;
+    }
+
+    /**
+     * Represents an order for a product
+     */
+    export interface Order {
+        /** Unique identifier for the offer */
+        offerId: string;
+        /** Username in the application */
+        applicationUsername: string;
+        /** URL to redirect to on success */
+        successUrl: string;
+        /** URL to redirect to on cancel */
+        cancelUrl: string;
+        /** Optional access token for the user */
+        accessToken?: string;
+    }
+
+    /** Plan change request */
+    export interface PlanChange {
+        /** Unique identifier for the purchase to replace (optional) */
+        purchaseId: string;
+        /** New offer to subscribe to */
+        offerId: string;
+        /** Optional access token for the user */
+        accessToken?: string;
+    }
+
+    /**
+     * Configuration options for creating an Iaptic adapter
+     */
+    export interface Config {
+        /** Adapter type (currently only 'stripe' is supported) */
+        type: 'stripe';
+        /** Stripe publishable key */
+        stripePublicKey: string;
+        /** Your application name as configured on iaptic.com */
+        appName: string;
+        /** Your Iaptic public API key */
+        apiKey: string;
+        /** Optional custom Iaptic URL for private deployments */
+        customIapticUrl?: string;
+    }
+
+    /**
+     * Response from Iaptic's /stripe/products API
+     */
+    export interface GetProductsResponse {
+        /** Whether the request was successful */
+        ok: boolean;
+        /** Array of available products */
+        products: Product[];
+    }
+
+    /**
+     * Response from Iaptic's /stripe/checkout API
+     */
+    export interface PostCheckoutSessionResponse {
+        /** Whether the request was successful */
+        ok: boolean;
+        /** Stripe Checkout URL where the customer will be redirected */
+        url: string;
+        /** Access token for the customer */
+        accessToken: string;
+    }
+
+    /**
+     * Response from Iaptic's /stripe/purchases API
+     */
+    export interface GetPurchasesResponse {
+        /** Whether the request was successful */
+        ok: boolean;
+        /** Array of customer's purchases */
+        purchases: Purchase[];
+        /** Optional new access token */
+        newAccessToken?: string;
+    }
+
+    /**
+     * Response from Iaptic's /stripe/change-plan API
+     */
+    export interface ChangePlanResponse {
+        /** Whether the request was successful */
+        ok: boolean;
+        /** Updated purchase details */
+        purchase: Purchase;
+        /** Optional new access token */
+        newAccessToken?: string;
+    }
+
+    /**
+     * Represents a scheduled refresh for a subscription
+     */
+    export interface ScheduledRefresh {
+        /** Unique identifier for the scheduled refresh */
+        id: string;
+        /** Unique identifier for the subscription */
+        subscriptionId: string;
+        /** Date and time of the scheduled refresh */
+        scheduledAt: number;
+        /** Whether the refresh has been completed */
+        completed: boolean;
+        /** Whether the refresh is currently in progress */
+        inProgress: boolean;
+        /** Reason for the scheduled refresh */
+        reason: string;
+    }
+
+    /**
+     * RefreshScheduler class for managing subscription refreshes
+     */
+    export class RefreshScheduler {
+        schedules: ScheduledRefresh[];
+        constructor(iapticStripe: IapticStripe);
+        scheduleRefresh(subscriptionId: string, date: Date, reason: string): void;
+        schedulePurchaseRefreshes(purchase: Purchase): void;
+        clearSchedules(): void;
+    }
+
+    /**
+     * Main class for interacting with Iaptic's Stripe integration
+     */
+    export class IapticStripe {
+        /**
+         * Creates a new IapticStripe instance
+         * @param config - Configuration options for the Stripe integration
+         */
+        constructor(config: Config);
+
+        /**
+         * Gets a list of available products and their pricing
+         * @returns Promise resolving to an array of products
+         */
+        getProducts(): Promise<Product[]>;
+
+        /**
+         * Forces a refresh of the products list from the server
+         * @returns Promise resolving to an array of products
+         */
+        refreshProducts(): Promise<Product[]>;
+
+        /**
+         * Gets the current access token if one exists
+         * @returns The current access token or undefined if none exists
+         */
+        getAccessToken(): string | undefined;
+
+        /**
+         * Creates a new order and redirects to Stripe Checkout
+         * @param params - Order parameters including product and URLs
+         */
+        order(params: Order): Promise<void>;
+
+        /**
+         * Gets the customer's purchase history
+         * @param accessToken - Optional access token (uses stored token if not provided)
+         * @returns Promise resolving to an array of purchases
+         */
+        getPurchases(accessToken?: string): Promise<Purchase[]>;
+
+        /**
+         * Redirects to Stripe Customer Portal for subscription management
+         * @param params - Portal parameters including return URL
+         */
+        redirectToCustomerPortal(params: {
+            returnUrl?: string;
+            accessToken?: string;
+        }): Promise<void>;
+
+        /**
+         * Changes a subscription plan
+         * @param planChange - Plan change parameters
+         * @returns Promise resolving to the updated purchase details
+         */
+        changePlan(planChange: PlanChange): Promise<Purchase>;
+
+        /**
+         * Clears all stored data including access tokens and cached products
+         */
+        clearStoredData(): void;
+    }
+
+    /**
+     * Utility functions for the Iaptic library
+     */
+    export class Utils {
+        /**
+         * Format a currency amount from micros with proper localization
+         * @param amountMicros - Amount in micros (1/1,000,000 of currency unit)
+         * @param currency - ISO 4217 currency code (e.g., 'USD', 'EUR')
+         * @returns Formatted currency string
+         */
+        static formatCurrency(amountMicros: number, currency: string): string;
+
+        /**
+         * Format an ISO 8601 period string into human-readable English
+         * @param period - ISO 8601 duration string
+         * @returns Human-readable period string
+         */
+        static formatBillingPeriodEN(period: string): string;
+
+        /**
+         * Base64 encode a string with fallbacks for different environments
+         */
+        static base64Encode(str: string): string;
+
+        /**
+         * Build a URL with query parameters
+         */
+        static buildUrl(baseUrl: string, params: Record<string, string>): string;
+    }
+
+    /**
+     * Creates an Iaptic adapter for the specified payment platform
+     * @param config - Configuration options for the adapter
+     * @returns An initialized adapter instance
+     */
+    export function createAdapter(config: Config): IapticStripe;
+}
+
+/**
+ * Global IapticJS object available in browser environments
+ */
+interface Window {
+    IapticJS: {
+        /** Current version of the IapticJS library */
+        version: string;
+        /** Function to create a new Iaptic adapter */
+        createAdapter: typeof ModuleIapticJS.createAdapter;
+        /** Stripe adapter class */
+        IapticStripe: typeof ModuleIapticJS.IapticStripe;
+        /** Utility functions */
+        Utils: typeof ModuleIapticJS.Utils;
+    };
+}