capacitor-plugin-cdv-purchase 13.17.2 → 13.19.1

package/www/store.js

@@ -521,6 +521,10 @@ var CdvPurchase;
                 this.receiptsToValidate = new ReceiptsToValidate();
                 /** List of verified receipts */
                 this.verifiedReceipts = [];
+                /** Maximum number of validation attempts for a receipt when failures are temporary */
+                this.maxAttempts = 4;
+                /** Number of failed attempts in a row, per receipt */
+                this.failedAttempts = new Map();
                 this.numRequests = 0;
                 this.numResponses = 0;
                 /**
@@ -534,6 +538,36 @@ var CdvPurchase;
                 this.controller = controller;
                 this.log = log.child('Validator');
             }
+            /**
+             * Schedule a new validation if the failure is temporary and attempts remain.
+             *
+             * @return true if a retry was scheduled
+             */
+            scheduleRetry(receipt, payload) {
+                var _a;
+                if (payload.ok || !isRetriableError(payload)) {
+                    this.failedAttempts.delete(receipt);
+                    if (payload.ok && this.retry)
+                        this.retry.retryTimeout = this.retry.minTimeout;
+                    return false;
+                }
+                const attempts = ((_a = this.failedAttempts.get(receipt)) !== null && _a !== void 0 ? _a : 0) + 1;
+                if (attempts >= this.maxAttempts) {
+                    this.log.warn(`Validation failed ${attempts} times, giving up: ${payload.message}`);
+                    this.failedAttempts.delete(receipt);
+                    return false;
+                }
+                this.failedAttempts.set(receipt, attempts);
+                if (!this.retry)
+                    this.retry = new Internal.Retry();
+                this.log.info(`Validation failed (${payload.message}), retry in ${this.retry.retryTimeout}ms (attempt ${attempts + 1}/${this.maxAttempts})`);
+                this.retry.retry(() => {
+                    // the request is still counted as pending, so don't count it again
+                    this.receiptsToValidate.add(receipt);
+                    this.run();
+                });
+                return true;
+            }
             incrRequestsCounter() {
                 this.numRequests = (this.numRequests + 1) | 0;
                 this.log.debug(`Validation requests=${this.numRequests} responses=${this.numResponses}`);
@@ -574,6 +608,9 @@ var CdvPurchase;
                 const onResponse = (r) => __awaiter(this, void 0, void 0, function* () {
                     var _a;
                     const { receipt, payload } = r;
+                    // a retried request is still pending: only count final responses
+                    if (this.scheduleRetry(receipt, payload))
+                        return;
                     this.incrResponsesCounter();
                     try {
                         const adapter = this.controller.adapters.find(receipt.platform);
@@ -595,11 +632,11 @@ var CdvPurchase;
                                 this.controller.verifiedCallbacks.trigger(vr, 'payload_expired');
                             }
                             else {
-                                this.controller.unverifiedCallbacks.trigger({ receipt, payload }, 'no_verified_receipt');
+                                this.controller.unverifiedCallbacks.trigger({ receipt, payload, transient: false }, 'no_verified_receipt');
                             }
                         }
                         else {
-                            this.controller.unverifiedCallbacks.trigger({ receipt, payload }, 'validator_error');
+                            this.controller.unverifiedCallbacks.trigger({ receipt, payload, transient: isTransientError(payload) }, 'validator_error');
                         }
                     }
                     catch (err) {
@@ -608,7 +645,7 @@ var CdvPurchase;
                                 ok: false,
                                 code: CdvPurchase.ErrorCode.VERIFICATION_FAILED,
                                 message: err.message,
-                            } }, 'validator_exception');
+                            }, transient: false }, 'validator_exception');
                     }
                 });
                 receipts.forEach(receipt => this.runOnReceipt(receipt, onResponse));
@@ -768,10 +805,13 @@ var CdvPurchase;
                                     data: { latest_receipt: (_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.latest_receipt },
                                 }
                             });
-                        this.cache[bodyTransactionHash] = {
-                            payload: response,
-                            expires: (+new Date()) + 120000, // expires in 2 minutes
-                        };
+                        // don't cache temporary errors, so a retry makes a new request
+                        if (response.ok || !isTransientError(response)) {
+                            this.cache[bodyTransactionHash] = {
+                                payload: response,
+                                expires: (+new Date()) + 120000, // expires in 2 minutes
+                            };
+                        }
                         callback({ receipt, payload: response });
                     },
                     error: (status, message, data) => {
@@ -793,6 +833,44 @@ var CdvPurchase;
             }
         }
         Internal.Validator = Validator;
+        /** Validator error code: the validator couldn't reach the store (Apple, Google, ...). */
+        const VALIDATOR_CONNECTION_FAILED = 6778002;
+        /**
+         * True if a validation error is temporary (validator or store unreachable,
+         * server error, timeout, no network) rather than a definitive answer about
+         * the receipt.
+         *
+         * Error responses from the validator come in two shapes:
+         * - HTTP 200 with `{ ok: false, status, code }` in the body (iaptic does this,
+         *   so a store outage is `status: 502, code: 6778002` in the body);
+         * - a failed HTTP request, reported by the plugin as `code: COMMUNICATION`
+         *   with the transport status: 5xx, 408 (timeout), 417 (unreadable response,
+         *   e.g. a captive portal page), 0 or negative (no network, as reported by
+         *   XMLHttpRequest or cordova-plugin-advanced-http).
+         */
+        function isTransientError(payload) {
+            const status = payload.status;
+            if (typeof status === 'number' && status >= 500)
+                return true;
+            if (payload.code === VALIDATOR_CONNECTION_FAILED)
+                return true;
+            if (payload.code === CdvPurchase.ErrorCode.COMMUNICATION) {
+                if (typeof status !== 'number' || status <= 0)
+                    return true;
+                if (status === CdvPurchase.Utils.Ajax.HTTP_REQUEST_TIMEOUT || status === 417)
+                    return true;
+            }
+            return false;
+        }
+        Internal.isTransientError = isTransientError;
+        /**
+         * True if a validation failure is worth retrying: a temporary error
+         * (see isTransientError) or an invalid response from the validator.
+         * Validator verdicts (invalid receipt, expired, ...) are not retried.
+         */
+        function isRetriableError(payload) {
+            return isTransientError(payload) || payload.code === CdvPurchase.ErrorCode.BAD_RESPONSE;
+        }
         /**
          * Check if a payload looks like a valid validator response.
          *
@@ -1674,6 +1752,276 @@ var CdvPurchase;
         Utils.md5toUUID = md5toUUID;
     })(Utils = CdvPurchase.Utils || (CdvPurchase.Utils = {}));
 })(CdvPurchase || (CdvPurchase = {}));
+var CdvPurchase;
+(function (CdvPurchase) {
+    /**
+     * Persist a subset of {@link VerifiedPurchase} to device storage so that
+     * `offline.isOwned()` can answer "is this product owned?" when the device
+     * is offline or has just restarted without connectivity.
+     *
+     * Phase 1 — unsigned cache. No JWT, no crypto, no server changes.
+     *
+     * @example
+     * ```typescript
+     * const offline = new CdvPurchase.OfflineEntitlements(store, {
+     *     gracePeriodMs: 30 * 24 * 60 * 60 * 1000, // 30 days
+     *     onExpiredOffline: 'readonly',
+     *     detectClockRollback: true,
+     * });
+     *
+     * await offline.ready();
+     *
+     * function isUserPremium(): boolean {
+     *     return store.owned('premium') || offline.isOwned('premium');
+     * }
+     * ```
+     *
+     * **Durability warning:** for long-offline deployments (weeks without
+     * connectivity), pass a file-based or secure-storage adapter. `localStorage`
+     * (the default) can be evicted by the WebView under storage pressure, which
+     * would silently lose the cached entitlements.
+     */
+    class OfflineEntitlements {
+        constructor(store, options = {}) {
+            var _a, _b, _c, _d;
+            /** In-memory cache of persisted entitlements, keyed by `platform:productId`. */
+            this.cache = {};
+            /** Last seen timestamp persisted with the data, used for clock rollback detection. */
+            this.lastSeenTimestamp = 0;
+            /** True once `ready()` has resolved. */
+            this.isReady = false;
+            /** Last event fired per productId, to deduplicate events on repeated isOwned() calls. */
+            this.lastEventPerProduct = {};
+            this.store = store;
+            this.storage = (_a = options.storage) !== null && _a !== void 0 ? _a : OfflineEntitlements.createLocalStorageAdapter();
+            this.gracePeriodMs = (_b = options.gracePeriodMs) !== null && _b !== void 0 ? _b : OfflineEntitlements.DEFAULT_GRACE_PERIOD_MS;
+            this.onExpiredOffline = (_c = options.onExpiredOffline) !== null && _c !== void 0 ? _c : 'readonly';
+            this.detectClockRollback = (_d = options.detectClockRollback) !== null && _d !== void 0 ? _d : false;
+            this.eventCallbacks = new CdvPurchase.Internal.Callbacks(store.log, 'OfflineEntitlements');
+            this.store.when().verified((receipt) => { void this.onVerified(receipt); });
+        }
+        /** Wrap the global `localStorage` as an async `OfflineStorageAdapter`. */
+        static createLocalStorageAdapter() {
+            return {
+                getItem: (key) => Promise.resolve(localStorage.getItem(key)),
+                setItem: (key, value) => { localStorage.setItem(key, value); return Promise.resolve(); },
+                removeItem: (key) => { localStorage.removeItem(key); return Promise.resolve(); },
+            };
+        }
+        /** Load persisted entitlements from storage into the in-memory cache. Idempotent. */
+        ready() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.isReady)
+                    return;
+                yield this.loadFromStorage();
+                this.isReady = true;
+            });
+        }
+        /** Reload from storage and re-evaluate. Resolves when the reload is complete. Call after reconnecting or manually. */
+        refresh() {
+            return this.loadFromStorage();
+        }
+        /** Register a callback for {@link OfflineEntitlementEvent}s. */
+        onEvent(callback) {
+            this.eventCallbacks.push(callback);
+        }
+        /** Remove all persisted entitlements from storage and clear the in-memory cache. For user logout. */
+        clear() {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.cache = {};
+                this.lastSeenTimestamp = 0;
+                this.isReady = false;
+                this.lastEventPerProduct = {};
+                yield this.storage.removeItem(OfflineEntitlements.STORAGE_KEY);
+            });
+        }
+        /**
+         * Return `true` if the product is owned, using the persisted cache when
+         * the in-memory `verifiedReceipts` don't grant ownership.
+         *
+         * Returns `false` for all products until `ready()` has resolved.
+         */
+        isOwned(productId) {
+            if (!this.isReady) {
+                this.store.log.warn('OfflineEntitlements.isOwned("' + productId + '") called before ready() — returning false. Call await offline.ready() at startup.');
+                return false;
+            }
+            // 1. If store.verifiedReceipts has a valid (non-expired) entry, return true.
+            const online = CdvPurchase.Internal.VerifiedReceipts.isOwned(this.store.verifiedReceipts, { id: productId });
+            if (online)
+                return true;
+            const now = +new Date();
+            // 2. Find persisted purchase for this productId across all platforms.
+            const persisted = this.findPersisted(productId);
+            if (!persisted) {
+                // No persisted entitlement.
+                this.fireEvent('entitlement_missing', productId, 'No persisted entitlement for this product.');
+                return false;
+            }
+            // 3. Branch by product type.
+            // Subscriptions have an expiryDate; non-consumables don't.
+            if (persisted.expiryDate !== undefined && persisted.expiryDate !== null) {
+                // Subscription
+                // Clock rollback detection — scoped to subscriptions (non-consumables have no time component).
+                if (this.detectClockRollback && this.lastSeenTimestamp > now) {
+                    this.fireEvent('clock_rollback', persisted.id, 'Clock appears to have rolled back; denying offline entitlement.');
+                    return false;
+                }
+                if (persisted.isExpired) {
+                    this.fireEvent('expired', persisted.id, 'Subscription is marked as expired.');
+                    return false;
+                }
+                if (now < persisted.expiryDate) {
+                    return true;
+                }
+                const renewalIntent = persisted.renewalIntent;
+                if (renewalIntent === CdvPurchase.RenewalIntent.RENEW && now < persisted.expiryDate + this.gracePeriodMs) {
+                    this.fireEvent('grace', persisted.id, 'Subscription expired but within grace period.');
+                    return true;
+                }
+                if (renewalIntent === CdvPurchase.RenewalIntent.LAPSE) {
+                    // Lapsed subscriptions deny at expiryDate.
+                    return false;
+                }
+                // Unknown/undefined renewalIntent: fall through to onExpiredOffline.
+                if (this.onExpiredOffline === 'readonly') {
+                    this.fireEvent('readonly', persisted.id, 'Subscription expired and grace period elapsed; granting readonly access.');
+                    return true;
+                }
+                return false;
+            }
+            else {
+                // Non-consumable: never hard-expires, no clock rollback check.
+                return true;
+            }
+        }
+        /**
+         * Retrieve the persisted entitlement for a product, analogous to
+         * `store.findInVerifiedReceipts()`.
+         *
+         * Returns the {@link PersistedPurchase} (with `expiryDate`,
+         * `renewalIntent`, `lastRenewalDate`, etc.) if one has been cached,
+         * or `undefined` if no offline entitlement exists for this product.
+         *
+         * Returns `undefined` for all products until `ready()` has resolved.
+         *
+         * @example
+         * ```typescript
+         * const entitlement = offline.find('premium');
+         * if (entitlement?.expiryDate) {
+         *     const daysLeft = Math.ceil((entitlement.expiryDate - Date.now()) / 86400000);
+         *     showRenewalBanner(daysLeft);
+         * }
+         * ```
+         */
+        find(productId) {
+            if (!this.isReady)
+                return undefined;
+            return this.findPersisted(productId);
+        }
+        /** Persist all `VerifiedPurchase`s in a verified receipt to storage. */
+        onVerified(receipt) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                for (const purchase of receipt.collection) {
+                    // Skip consumables — they don't need offline entitlement.
+                    if (purchase.isConsumed)
+                        continue;
+                    const platform = (_a = purchase.platform) !== null && _a !== void 0 ? _a : receipt.platform;
+                    const product = this.store.get(purchase.id, platform);
+                    if (product && product.type === CdvPurchase.ProductType.CONSUMABLE)
+                        continue;
+                    const key = platform + ':' + purchase.id;
+                    this.cache[key] = {
+                        id: purchase.id,
+                        platform,
+                        expiryDate: purchase.expiryDate,
+                        isExpired: purchase.isExpired,
+                        renewalIntent: purchase.renewalIntent,
+                        lastRenewalDate: purchase.lastRenewalDate,
+                        purchaseDate: purchase.purchaseDate,
+                        cancelationReason: purchase.cancelationReason,
+                        isBillingRetryPeriod: purchase.isBillingRetryPeriod,
+                    };
+                }
+                this.lastSeenTimestamp = +new Date();
+                yield this.saveToStorage();
+            });
+        }
+        /** Find the persisted purchase for a productId across all platforms. */
+        findPersisted(productId) {
+            var _a, _b, _c, _d;
+            let found;
+            for (const key of Object.keys(this.cache)) {
+                const entry = this.cache[key];
+                if (entry.id === productId) {
+                    if (!found || ((_b = (_a = found.lastRenewalDate) !== null && _a !== void 0 ? _a : found.purchaseDate) !== null && _b !== void 0 ? _b : 0) < ((_d = (_c = entry.lastRenewalDate) !== null && _c !== void 0 ? _c : entry.purchaseDate) !== null && _d !== void 0 ? _d : 0)) {
+                        found = entry;
+                    }
+                }
+            }
+            return found;
+        }
+        /** Load the persisted payload from storage into the in-memory cache. */
+        loadFromStorage() {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const raw = yield this.storage.getItem(OfflineEntitlements.STORAGE_KEY);
+                    if (!raw) {
+                        this.cache = {};
+                        this.lastSeenTimestamp = 0;
+                        return;
+                    }
+                    const parsed = JSON.parse(raw);
+                    if (parsed.schemaVersion !== OfflineEntitlements.SCHEMA_VERSION) {
+                        this.store.log.warn('OfflineEntitlements: schema version mismatch, ignoring cached data.');
+                        this.cache = {};
+                        this.lastSeenTimestamp = 0;
+                        return;
+                    }
+                    this.cache = (_a = parsed.receipts) !== null && _a !== void 0 ? _a : {};
+                    this.lastSeenTimestamp = (_b = parsed.lastSeenTimestamp) !== null && _b !== void 0 ? _b : 0;
+                }
+                catch (err) {
+                    this.store.log.warn('OfflineEntitlements: failed to load from storage: ' + err.message);
+                    this.cache = {};
+                    this.lastSeenTimestamp = 0;
+                }
+            });
+        }
+        /** Serialize the in-memory cache to storage. */
+        saveToStorage() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const payload = {
+                    receipts: this.cache,
+                    lastSeenTimestamp: this.lastSeenTimestamp,
+                    schemaVersion: OfflineEntitlements.SCHEMA_VERSION,
+                };
+                try {
+                    yield this.storage.setItem(OfflineEntitlements.STORAGE_KEY, JSON.stringify(payload));
+                }
+                catch (err) {
+                    this.store.log.warn('OfflineEntitlements: failed to save to storage: ' + err.message);
+                }
+            });
+        }
+        /** Fire an event to all registered callbacks, deduplicating per productId. */
+        fireEvent(type, productId, message) {
+            if (this.lastEventPerProduct[productId] === type)
+                return;
+            this.lastEventPerProduct[productId] = type;
+            this.eventCallbacks.trigger({ type, productId, message }, 'offline_entitlements');
+        }
+    }
+    /** Storage key used in the storage adapter. */
+    OfflineEntitlements.STORAGE_KEY = 'cdvpurchase.offline_entitlements';
+    /** Schema version for the persisted payload. */
+    OfflineEntitlements.SCHEMA_VERSION = 1;
+    /** Default grace period: 30 days. */
+    OfflineEntitlements.DEFAULT_GRACE_PERIOD_MS = 30 * 24 * 60 * 60 * 1000;
+    CdvPurchase.OfflineEntitlements = OfflineEntitlements;
+})(CdvPurchase || (CdvPurchase = {}));
 /// <reference path="types.ts" />
 /// <reference path="utils/compatibility.ts" />
 /// <reference path="utils/platform-name.ts" />
@@ -1689,6 +2037,7 @@ var CdvPurchase;
 /// <reference path="internal/receipts-monitor.ts" />
 /// <reference path="internal/expiry-monitor.ts" />
 /// <reference path="utils/to-uuid.ts" />
+/// <reference path="offline-entitlements.ts" />
 /**
  * Namespace for the cordova-plugin-purchase plugin.
  *
@@ -1722,7 +2071,7 @@ var CdvPurchase;
     /**
      * Current release number of the plugin.
      */
-    CdvPurchase.PLUGIN_VERSION = '13.17.2';
+    CdvPurchase.PLUGIN_VERSION = '13.19.1';
     /**
      * Entry class of the plugin.
      */
@@ -3443,13 +3792,19 @@ var CdvPurchase;
                             yield this.receiptsUpdated.wait();
                             this.log.info('finish: ' + transactionIdentifier + ' - ' + productId);
                             this.removeTransactionInProgress(productId);
-                            yield this.upsertTransaction(productId, transactionIdentifier, CdvPurchase.TransactionState.FINISHED);
+                            const finishedTransaction = yield this.upsertTransaction(productId, transactionIdentifier, CdvPurchase.TransactionState.FINISHED);
+                            finishedTransaction.isAcknowledged = true;
                             this.receiptsUpdated.call();
                         }),
-                        restored: (transactionIdentifier, productId, originalTransactionIdentifier, transactionDate, discountId, expirationDate, jwsRepresentation, quantity) => __awaiter(this, void 0, void 0, function* () {
+                        restored: (transactionIdentifier, productId, originalTransactionIdentifier, transactionDate, discountId, expirationDate, jwsRepresentation, quantity, isFinished) => __awaiter(this, void 0, void 0, function* () {
                             this.log.info('restore: ' + transactionIdentifier + ' - ' + productId);
                             const transaction = yield this.upsertTransaction(productId, transactionIdentifier, CdvPurchase.TransactionState.APPROVED);
                             transaction.refresh(productId, originalTransactionIdentifier, transactionDate, discountId, expirationDate, jwsRepresentation, quantity);
+                            // StoreKit 2 re-emits finished entitlements (non-consumables,
+                            // non-renewing subscriptions) at every launch. Expose the finished
+                            // state the same way Google Play does, so apps can skip them in approved().
+                            if (isFinished !== undefined)
+                                transaction.isAcknowledged = isFinished;
                             this.receiptsUpdated.call();
                         }),
                         receiptsRefreshed: (receipt) => {
@@ -4083,7 +4438,7 @@ var CdvPurchase;
                     }
                     // Listen for transaction updates from native
                     plugin.addListener('transactionUpdated', (data) => {
-                        this.transactionUpdated(data.state, data.errorCode, data.errorText, data.transactionIdentifier, data.productId, data.transactionReceipt, data.originalTransactionIdentifier, data.transactionDate, data.discountId, data.expirationDate, data.jwsRepresentation, data.quantity);
+                        this.transactionUpdated(data.state, data.errorCode, data.errorText, data.transactionIdentifier, data.productId, data.transactionReceipt, data.originalTransactionIdentifier, data.transactionDate, data.discountId, data.expirationDate, data.jwsRepresentation, data.quantity, data.isFinished);
                     });
                     plugin.addListener('restoreCompleted', () => {
                         this.restoreCompletedTransactionsFinished();
@@ -4104,7 +4459,7 @@ var CdvPurchase;
                         const pending = this.pendingTransactionUpdates;
                         this.pendingTransactionUpdates = [];
                         for (const args of pending) {
-                            this.transactionUpdated(args.state, args.errorCode, args.errorText, args.transactionIdentifier, args.productId, args.transactionReceipt, args.originalTransactionIdentifier, args.transactionDate, args.discountId, args.expirationDate, args.jwsRepresentation, args.quantity);
+                            this.transactionUpdated(args.state, args.errorCode, args.errorText, args.transactionIdentifier, args.productId, args.transactionReceipt, args.originalTransactionIdentifier, args.transactionDate, args.discountId, args.expirationDate, args.jwsRepresentation, args.quantity, args.isFinished);
                         }
                         if (this.options.ready)
                             this.options.ready();
@@ -4188,13 +4543,13 @@ var CdvPurchase;
                         .catch((err) => errorCb(CdvPurchase.ErrorCode.LOAD, (err === null || err === void 0 ? void 0 : err.message) || 'loadReceipts failed'));
                 }
                 // Called when the native side sends a transaction update
-                transactionUpdated(state, errorCode, errorText, transactionIdentifier, productId, transactionReceipt, originalTransactionIdentifier, transactionDate, discountId, expirationDate, jwsRepresentation, quantity) {
+                transactionUpdated(state, errorCode, errorText, transactionIdentifier, productId, transactionReceipt, originalTransactionIdentifier, transactionDate, discountId, expirationDate, jwsRepresentation, quantity, isFinished) {
                     if (!this.initialized) {
                         this.pendingTransactionUpdates.push({
                             state, errorCode, errorText, transactionIdentifier,
                             productId, transactionReceipt, originalTransactionIdentifier,
                             transactionDate, discountId, expirationDate, jwsRepresentation,
-                            quantity,
+                            quantity, isFinished,
                         });
                         return;
                     }
@@ -4230,7 +4585,7 @@ var CdvPurchase;
                             // purchased, but is meaningless here: consumables cannot be
                             // restored, so restored transactions are always quantity 1.
                             if (this.options.restored) {
-                                this.options.restored(transactionIdentifier, productId, originalTransactionIdentifier, transactionDate, discountId, expirationDate, jwsRepresentation, quantity);
+                                this.options.restored(transactionIdentifier, productId, originalTransactionIdentifier, transactionDate, discountId, expirationDate, jwsRepresentation, quantity, isFinished);
                             }
                             break;
                         case 'PaymentTransactionStateDeferred':