@mpgd/capacitor-play-billing 0.1.7 → 0.2.0

package/dist/provider.js

@@ -1,4 +1,5 @@
 import { Capacitor } from '@capacitor/core';
+import { createGooglePlayTokenPurchaseKey } from '@mpgd/platform/commerce';
 import { CapacitorPlayBilling } from './plugin.js';
 const googlePlayProductPurchaseEvidenceSchema = 'google-play.product-purchase.v2';
 class PlayPurchaseIntegrityError extends Error {
@@ -13,6 +14,12 @@ function isValidPurchaseToken(value) {
 /**
  * Resubmit owned purchases after a callback was missed or the app restarted.
  * A native purchase is never credited locally; only the backend response grants it.
+ *
+ * @deprecated v1 recovery driver. Commerce v2 games register
+ * `createCapacitorPlayBillingServiceProvider` and let the single reconciler
+ * in `@mpgd/game-services` (PR C1) resolve unfinished purchases from
+ * `getAvailablePurchases` and `purchaseUpdated`; this driver is removed with
+ * the v1 adapter in the next major version.
  */
 export async function recoverOwnedPlayPurchases(input) {
     if (input.playerId.trim() === '') {
@@ -38,7 +45,7 @@ export async function recoverOwnedPlayPurchases(input) {
                 playerId: input.playerId,
                 productId,
                 platformTransactionId: result.transactionId,
-                idempotencyKey: await createGooglePlayTokenTransactionId(token),
+                idempotencyKey: await createGooglePlayTokenPurchaseKey(token),
                 purchasedAt: purchasedAt ?? input.now?.() ?? new Date().toISOString(),
                 evidence: result.evidence,
             });
@@ -268,7 +275,7 @@ async function convertPurchase(purchase) {
         return { status: 'pending', entitlementIds: [], evidence };
     }
     const transactionId = purchase.orderId?.trim()
-        || await createGooglePlayTokenTransactionId(purchase.purchaseToken);
+        || await createGooglePlayTokenPurchaseKey(purchase.purchaseToken);
     return {
         status: 'completed',
         transactionId,
@@ -276,18 +283,15 @@ async function convertPurchase(purchase) {
         evidence,
     };
 }
-/** Must remain byte-for-byte compatible with the server's token transaction ID. */
-export async function createGooglePlayTokenTransactionId(purchaseToken) {
-    if (!isValidPurchaseToken(purchaseToken)) {
-        throw new TypeError('Google Play purchase token is invalid.');
-    }
-    const subtle = globalThis.crypto?.subtle;
-    if (subtle === undefined) {
-        throw new Error('Web Crypto is required to hash Google Play purchase tokens.');
-    }
-    const digest = new Uint8Array(await subtle.digest('SHA-256', new TextEncoder().encode(purchaseToken)));
-    return `play-token-sha256:${[...digest].map((value) => value.toString(16).padStart(2, '0')).join('')}`;
-}
+/**
+ * The server's token transaction ID, computed by the one shared helper so the
+ * plugin and `@mpgd/game-services` can never drift.
+ *
+ * @deprecated Use `createGooglePlayTokenPurchaseKey` from `@mpgd/platform/commerce`;
+ * this alias is the same function (same key, same `TypeError` for an invalid
+ * token) and will be removed in the next major version.
+ */
+export const createGooglePlayTokenTransactionId = createGooglePlayTokenPurchaseKey;
 function success(id, data) {
     return { id, ok: true, data };
 }

package/dist/store-sdk.d.ts

@@ -0,0 +1,89 @@
+import type { PlatformProviderAvailability } from '@mpgd/platform';
+import { type StoreSdk, type StoreSdkCapabilities, type StoreSdkError, type StoreSdkErrorCodeMap, type StoreSdkPurchase } from '@mpgd/adapter-capacitor';
+import type { CapacitorPlayBillingPlugin, PlayPurchase } from './definitions.js';
+/** The store id of the Play Billing `StoreSdk` (RFC "Capabilities", `google-play`). */
+export declare const googlePlayStoreId: 'google-play';
+/**
+* What the Play Billing plugin supports (RFC "Capabilities" profile row for
+* `google-play`): one-time consumables and durables, no subscriptions, no
+* multi-quantity, pending purchases, no restore call, one-time offers, and a
+* server-owned finish (the backend acknowledges or consumes after the grant).
+*/
+export declare const playBillingStoreSdkCapabilities: StoreSdkCapabilities;
+/**
+* `defaultStoreSdkErrorCodeMap` plus every `PLAY_BILLING_*` code the plugin or
+* this SDK emits that the default map does not already normalize.
+*/
+export declare const playBillingStoreSdkErrorCodeMap: StoreSdkErrorCodeMap;
+/** One Play product the SDK sells; the provider maps it to a logical id. */
+export interface PlayBillingStoreSdkProduct {
+  /** The Play product id (SKU). */
+  readonly sku: string;
+  readonly kind: 'consumable' | 'durable';
+  /**
+  * Default one-time offer (`offerToken`) when Play lists more than one
+  * eligible offer; a request may name another through `offerId`.
+  */
+  readonly offerToken?: string;
+}
+export interface CreateCapacitorPlayBillingStoreSdkInput {
+  readonly products: readonly PlayBillingStoreSdkProduct[];
+  /** Defaults to the registered `CapacitorPlayBilling` plugin. */
+  readonly plugin?: CapacitorPlayBillingPlugin;
+  /** Defaults to `Capacitor.getPlatform() === 'android'`. */
+  readonly isAndroid?: () => boolean;
+  /**
+  * Diagnostics hook for a plugin purchase the SDK leaves out of
+  * `getAvailablePurchases` and events: a SKU not in `products` (for example
+  * a retired product) or a multi-line purchase. Such a purchase has no
+  * logical id for the reconciler; the backend finalizer still sees it
+  * through the Play Developer API.
+  */
+  readonly onUnmappedPurchase?: (purchase: PlayPurchase) => void;
+}
+export interface CapacitorPlayBillingStoreSdk extends StoreSdk {
+  readonly store: typeof googlePlayStoreId;
+  getAvailability(): Promise<PlatformProviderAvailability>;
+}
+interface PlayBillingStoreSdkErrorOptions {
+  readonly retryable?: boolean;
+  readonly storeCode?: string;
+  readonly cause?: unknown;
+}
+/** A plugin rejection or an SDK integrity failure, carrying the plugin code. */
+export declare class PlayBillingStoreSdkError extends Error implements StoreSdkError {
+  readonly code: string;
+  readonly retryable?: boolean;
+  readonly storeCode?: string;
+  constructor(code: string, message: string, options?: PlayBillingStoreSdkErrorOptions);
+}
+/**
+* `StoreSdk` over `@mpgd/capacitor-play-billing`'s plugin for
+* `createStoreCommerceProvider`. It speaks Play product ids and plugin codes
+* only: `fetchProducts` is `getProducts`, `requestPurchase` is `purchase` with
+* the obfuscated account id from the request's account binding and the offer
+* token from `offerId`, `getAvailablePurchases` is `getPurchases` filtered to
+* unfinished entries (purchased and not acknowledged, plus pending on
+* request), and `purchaseUpdated` events are the plugin's. A purchased plugin
+* outcome is `purchased`; a pending one is `launched`, because Play resolves
+* it later through `purchaseUpdated` or `getPurchases`; a cancelled one is
+* `cancelled`; a plugin rejection is `failed` with the plugin code, which the
+* provider normalizes (`PLAY_BILLING_TIMEOUT`, `PLAY_BILLING_INTERRUPTED`, and
+* `PLAY_BILLING_EMPTY_PURCHASE` become `OUTCOME_UNKNOWN` and stay recoverable).
+* `transactionId` is the order id or, until Play assigns one, the token key
+* `play-token-sha256:<hex>` v1 ledgers already use. Nothing here grants, and
+* nothing here acknowledges or consumes: the backend finalizer owns both.
+*/
+export declare function createCapacitorPlayBillingStoreSdk(input: CreateCapacitorPlayBillingStoreSdkInput): CapacitorPlayBillingStoreSdk;
+/** Validates a purchase token exactly as the v1 provider does. */
+export declare function isValidPlayPurchaseToken(value: unknown): value is string;
+/**
+* `StoreSdkPurchase` of one plugin purchase: `token` is the purchase token,
+* `transactionId` is the order id or the token key when Play has not assigned
+* one yet (the v1 rule, so ledgers written by v1 deduplicate), `purchasedAt`
+* is `purchaseTime` as ISO 8601 when it is a valid instant, and the account
+* binding is the obfuscated account id the purchase flow recorded. Throws
+* `PLAY_BILLING_EVIDENCE_INVALID` for a shape the plugin never produces.
+*/
+export declare function toPlayBillingSdkPurchase(purchase: PlayPurchase): Promise<StoreSdkPurchase>;
+export {};