expo-iap 3.0.7 → 3.0.8

package/src/types.ts

@@ -126,10 +126,7 @@ export enum ErrorCode {
   UserError = 'USER_ERROR'
 }
 
-export interface FetchProductsResult {
-  products?: (Product[] | null);
-  subscriptions?: (ProductSubscription[] | null);
-}
+export type FetchProductsResult = Product[] | ProductSubscription[] | null;
 
 export type IapEvent = 'promoted-product-ios' | 'purchase-error' | 'purchase-updated';
 
@@ -137,57 +134,46 @@ export type IapPlatform = 'android' | 'ios';
 
 export interface Mutation {
   /** Acknowledge a non-consumable purchase or subscription */
-  acknowledgePurchaseAndroid: Promise<VoidResult>;
+  acknowledgePurchaseAndroid: Promise<boolean>;
   /** Initiate a refund request for a product (iOS 15+) */
-  beginRefundRequestIOS: Promise<RefundResultIOS>;
+  beginRefundRequestIOS?: Promise<(string | null)>;
   /** Clear pending transactions from the StoreKit payment queue */
-  clearTransactionIOS: Promise<VoidResult>;
+  clearTransactionIOS: Promise<boolean>;
   /** Consume a purchase token so it can be repurchased */
-  consumePurchaseAndroid: Promise<VoidResult>;
+  consumePurchaseAndroid: Promise<boolean>;
   /** Open the native subscription management surface */
-  deepLinkToSubscriptions: Promise<VoidResult>;
+  deepLinkToSubscriptions: Promise<void>;
   /** Close the platform billing connection */
   endConnection: Promise<boolean>;
   /** Finish a transaction after validating receipts */
-  finishTransaction: Promise<VoidResult>;
+  finishTransaction: Promise<void>;
   /** Establish the platform billing connection */
   initConnection: Promise<boolean>;
   /** Present the App Store code redemption sheet */
-  presentCodeRedemptionSheetIOS: Promise<VoidResult>;
+  presentCodeRedemptionSheetIOS: Promise<boolean>;
   /** Initiate a purchase flow; rely on events for final state */
-  requestPurchase?: Promise<(RequestPurchaseResult | null)>;
+  requestPurchase?: Promise<(Purchase | Purchase[] | null)>;
   /** Purchase the promoted product surfaced by the App Store */
-  requestPurchaseOnPromotedProductIOS: Promise<PurchaseIOS>;
+  requestPurchaseOnPromotedProductIOS: Promise<boolean>;
   /** Restore completed purchases across platforms */
-  restorePurchases: Promise<VoidResult>;
+  restorePurchases: Promise<void>;
   /** Open subscription management UI and return changed purchases (iOS 15+) */
   showManageSubscriptionsIOS: Promise<PurchaseIOS[]>;
   /** Force a StoreKit sync for transactions (iOS 15+) */
-  syncIOS: Promise<VoidResult>;
+  syncIOS: Promise<boolean>;
   /** Validate purchase receipts with the configured providers */
   validateReceipt: Promise<ReceiptValidationResult>;
 }
 
 
-export interface MutationAcknowledgePurchaseAndroidArgs {
-  purchaseToken: string;
-}
-
 
-export interface MutationBeginRefundRequestIosArgs {
-  sku: string;
-}
+export type MutationAcknowledgePurchaseAndroidArgs = string;
 
+export type MutationBeginRefundRequestIosArgs = string;
 
-export interface MutationConsumePurchaseAndroidArgs {
-  purchaseToken: string;
-}
-
-
-export interface MutationDeepLinkToSubscriptionsArgs {
-  options?: (DeepLinkOptions | null);
-}
+export type MutationConsumePurchaseAndroidArgs = string;
 
+export type MutationDeepLinkToSubscriptionsArgs = (DeepLinkOptions | null) | undefined;
 
 export interface MutationFinishTransactionArgs {
   isConsumable?: (boolean | null);
@@ -195,14 +181,20 @@ export interface MutationFinishTransactionArgs {
 }
 
 
-export interface MutationRequestPurchaseArgs {
-  params: RequestPurchaseProps;
-}
+export type MutationRequestPurchaseArgs =
+  | {
+      /** Per-platform purchase request props */
+      request: RequestPurchasePropsByPlatforms;
+      type: 'in-app';
+    }
+  | {
+      /** Per-platform subscription request props */
+      request: RequestSubscriptionPropsByPlatforms;
+      type: 'subs';
+    };
 
 
-export interface MutationValidateReceiptArgs {
-  options: ReceiptValidationProps;
-}
+export type MutationValidateReceiptArgs = ReceiptValidationProps;
 
 export type PaymentModeIOS = 'empty' | 'free-trial' | 'pay-as-you-go' | 'pay-up-front';
 
@@ -440,9 +432,9 @@ export type PurchaseState = 'deferred' | 'failed' | 'pending' | 'purchased' | 'r
 
 export interface Query {
   /** Get current StoreKit 2 entitlements (iOS 15+) */
-  currentEntitlementIOS: Promise<EntitlementIOS[]>;
+  currentEntitlementIOS?: Promise<(PurchaseIOS | null)>;
   /** Retrieve products or subscriptions from the store */
-  fetchProducts: Promise<FetchProductsResult>;
+  fetchProducts: Promise<(Product[] | ProductSubscription[] | null)>;
   /** Get active subscriptions (filters by subscriptionIds when provided) */
   getActiveSubscriptions: Promise<ActiveSubscription[]>;
   /** Fetch the current app transaction (iOS 16+) */
@@ -454,14 +446,14 @@ export interface Query {
   /** Get the currently promoted product (iOS 11+) */
   getPromotedProductIOS?: Promise<(ProductIOS | null)>;
   /** Get base64-encoded receipt data for validation */
-  getReceiptDataIOS: Promise<string>;
+  getReceiptDataIOS?: Promise<(string | null)>;
   /** Get the current App Store storefront country code */
   getStorefrontIOS: Promise<string>;
   /** Get the transaction JWS (StoreKit 2) */
-  getTransactionJwsIOS: Promise<string>;
+  getTransactionJwsIOS?: Promise<(string | null)>;
   /** Check whether the user has active subscriptions */
   hasActiveSubscriptions: Promise<boolean>;
-  /** Check introductory offer eligibility for specific products */
+  /** Check introductory offer eligibility for a subscription group */
   isEligibleForIntroOfferIOS: Promise<boolean>;
   /** Verify a StoreKit 2 transaction signature */
   isTransactionVerifiedIOS: Promise<boolean>;
@@ -469,57 +461,33 @@ export interface Query {
   latestTransactionIOS?: Promise<(PurchaseIOS | null)>;
   /** Get StoreKit 2 subscription status details (iOS 15+) */
   subscriptionStatusIOS: Promise<SubscriptionStatusIOS[]>;
+  /** Validate a receipt for a specific product */
+  validateReceiptIOS: Promise<ReceiptValidationResultIOS>;
 }
 
 
-export interface QueryCurrentEntitlementIosArgs {
-  skus?: (string[] | null);
-}
-
-
-export interface QueryFetchProductsArgs {
-  params: ProductRequest;
-}
-
-
-export interface QueryGetActiveSubscriptionsArgs {
-  subscriptionIds?: (string[] | null);
-}
 
+export type QueryCurrentEntitlementIosArgs = string;
 
-export interface QueryGetAvailablePurchasesArgs {
-  options?: (PurchaseOptions | null);
-}
-
-
-export interface QueryGetTransactionJwsIosArgs {
-  transactionId: string;
-}
-
+export type QueryFetchProductsArgs = ProductRequest;
 
-export interface QueryHasActiveSubscriptionsArgs {
-  subscriptionIds?: (string[] | null);
-}
+export type QueryGetActiveSubscriptionsArgs = (string[] | null) | undefined;
 
+export type QueryGetAvailablePurchasesArgs = (PurchaseOptions | null) | undefined;
 
-export interface QueryIsEligibleForIntroOfferIosArgs {
-  productIds: string[];
-}
+export type QueryGetTransactionJwsIosArgs = string;
 
+export type QueryHasActiveSubscriptionsArgs = (string[] | null) | undefined;
 
-export interface QueryIsTransactionVerifiedIosArgs {
-  transactionId: string;
-}
+export type QueryIsEligibleForIntroOfferIosArgs = string;
 
+export type QueryIsTransactionVerifiedIosArgs = string;
 
-export interface QueryLatestTransactionIosArgs {
-  sku: string;
-}
+export type QueryLatestTransactionIosArgs = string;
 
+export type QuerySubscriptionStatusIosArgs = string;
 
-export interface QuerySubscriptionStatusIosArgs {
-  skus?: (string[] | null);
-}
+export type QueryValidateReceiptIosArgs = ReceiptValidationProps;
 
 export interface ReceiptValidationAndroidOptions {
   accessToken: string;
@@ -623,10 +591,7 @@ export interface RequestPurchasePropsByPlatforms {
   ios?: (RequestPurchaseIosProps | null);
 }
 
-export interface RequestPurchaseResult {
-  purchase?: (Purchase | null);
-  purchases?: (Purchase[] | null);
-}
+export type RequestPurchaseResult = Purchase | Purchase[] | null;
 
 export interface RequestSubscriptionAndroidProps {
   /** Personalized offer flag */
@@ -669,6 +634,7 @@ export interface Subscription {
   purchaseUpdated: Purchase;
 }
 
+
 export interface SubscriptionInfoIOS {
   introductoryOffer?: (SubscriptionOfferIOS | null);
   promotionalOffers?: (SubscriptionOfferIOS[] | null);
@@ -700,6 +666,86 @@ export interface SubscriptionStatusIOS {
   state: string;
 }
 
-export interface VoidResult {
-  success: boolean;
-}
+export type VoidResult = void;
+
+// -- Query helper types (auto-generated)
+export type QueryArgsMap = {
+  currentEntitlementIOS: QueryCurrentEntitlementIosArgs;
+  fetchProducts: QueryFetchProductsArgs;
+  getActiveSubscriptions: QueryGetActiveSubscriptionsArgs;
+  getAppTransactionIOS: never;
+  getAvailablePurchases: QueryGetAvailablePurchasesArgs;
+  getPendingTransactionsIOS: never;
+  getPromotedProductIOS: never;
+  getReceiptDataIOS: never;
+  getStorefrontIOS: never;
+  getTransactionJwsIOS: QueryGetTransactionJwsIosArgs;
+  hasActiveSubscriptions: QueryHasActiveSubscriptionsArgs;
+  isEligibleForIntroOfferIOS: QueryIsEligibleForIntroOfferIosArgs;
+  isTransactionVerifiedIOS: QueryIsTransactionVerifiedIosArgs;
+  latestTransactionIOS: QueryLatestTransactionIosArgs;
+  subscriptionStatusIOS: QuerySubscriptionStatusIosArgs;
+  validateReceiptIOS: QueryValidateReceiptIosArgs;
+};
+
+export type QueryField<K extends keyof Query> =
+  QueryArgsMap[K] extends never
+    ? () => NonNullable<Query[K]>
+    : undefined extends QueryArgsMap[K]
+      ? (args?: QueryArgsMap[K]) => NonNullable<Query[K]>
+      : (args: QueryArgsMap[K]) => NonNullable<Query[K]>;
+
+export type QueryFieldMap = {
+  [K in keyof Query]?: QueryField<K>;
+};
+// -- End query helper types
+
+// -- Mutation helper types (auto-generated)
+export type MutationArgsMap = {
+  acknowledgePurchaseAndroid: MutationAcknowledgePurchaseAndroidArgs;
+  beginRefundRequestIOS: MutationBeginRefundRequestIosArgs;
+  clearTransactionIOS: never;
+  consumePurchaseAndroid: MutationConsumePurchaseAndroidArgs;
+  deepLinkToSubscriptions: MutationDeepLinkToSubscriptionsArgs;
+  endConnection: never;
+  finishTransaction: MutationFinishTransactionArgs;
+  initConnection: never;
+  presentCodeRedemptionSheetIOS: never;
+  requestPurchase: MutationRequestPurchaseArgs;
+  requestPurchaseOnPromotedProductIOS: never;
+  restorePurchases: never;
+  showManageSubscriptionsIOS: never;
+  syncIOS: never;
+  validateReceipt: MutationValidateReceiptArgs;
+};
+
+export type MutationField<K extends keyof Mutation> =
+  MutationArgsMap[K] extends never
+    ? () => NonNullable<Mutation[K]>
+    : undefined extends MutationArgsMap[K]
+      ? (args?: MutationArgsMap[K]) => NonNullable<Mutation[K]>
+      : (args: MutationArgsMap[K]) => NonNullable<Mutation[K]>;
+
+export type MutationFieldMap = {
+  [K in keyof Mutation]?: MutationField<K>;
+};
+// -- End mutation helper types
+
+// -- Subscription helper types (auto-generated)
+export type SubscriptionArgsMap = {
+  promotedProductIOS: never;
+  purchaseError: never;
+  purchaseUpdated: never;
+};
+
+export type SubscriptionField<K extends keyof Subscription> =
+  SubscriptionArgsMap[K] extends never
+    ? () => NonNullable<Subscription[K]>
+    : undefined extends SubscriptionArgsMap[K]
+      ? (args?: SubscriptionArgsMap[K]) => NonNullable<Subscription[K]>
+      : (args: SubscriptionArgsMap[K]) => NonNullable<Subscription[K]>;
+
+export type SubscriptionFieldMap = {
+  [K in keyof Subscription]?: SubscriptionField<K>;
+};
+// -- End subscription helper types

package/src/useIAP.ts

@@ -19,7 +19,6 @@ import {
   hasActiveSubscriptions,
   type ActiveSubscription,
   type ProductTypeInput,
-  type PurchaseRequestInput,
   restorePurchases,
 } from './index';
 import {
@@ -28,14 +27,18 @@ import {
 } from './modules/ios';
 
 // Types
-import {
+import type {
   Product,
-  Purchase,
   ProductSubscription,
-  ErrorCode,
-  VoidResult,
+  ProductQueryType,
+  ProductRequest,
+  Purchase,
+  MutationRequestPurchaseArgs,
+  PurchaseInput,
+  ReceiptValidationProps,
   ReceiptValidationResult,
 } from './types';
+import {ErrorCode} from './types';
 import {PurchaseError} from './purchase-error';
 import {
   getUserFriendlyErrorMessage,
@@ -58,7 +61,7 @@ type UseIap = {
   }: {
     purchase: Purchase;
     isConsumable?: boolean;
-  }) => Promise<VoidResult | boolean>;
+  }) => Promise<void>;
   getAvailablePurchases: () => Promise<void>;
   fetchProducts: (params: {
     skus: string[];
@@ -66,20 +69,14 @@ type UseIap = {
   }) => Promise<void>;
 
   requestPurchase: (
-    params: PurchaseRequestInput,
+    params: MutationRequestPurchaseArgs,
   ) => ReturnType<typeof requestPurchaseInternal>;
   validateReceipt: (
-    sku: string,
-    androidOptions?: {
-      packageName: string;
-      productToken: string;
-      accessToken: string;
-      isSub?: boolean;
-    },
+    props: ReceiptValidationProps,
   ) => Promise<ReceiptValidationResult>;
   restorePurchases: () => Promise<void>;
   getPromotedProductIOS: () => Promise<Product | null>;
-  requestPurchaseOnPromotedProductIOS: () => Promise<void>;
+  requestPurchaseOnPromotedProductIOS: () => Promise<boolean>;
   getActiveSubscriptions: (subscriptionIds?: string[]) => Promise<void>;
   hasActiveSubscriptions: (subscriptionIds?: string[]) => Promise<boolean>;
 };
@@ -154,14 +151,40 @@ export function useIAP(options?: UseIAPOptions): UseIap {
     subscriptionsRefState.current = subscriptions;
   }, [subscriptions]);
 
+  const normalizeProductQueryType = useCallback(
+    (type?: ProductTypeInput): ProductQueryType => {
+      if (!type || type === 'inapp' || type === 'in-app') {
+        return 'in-app';
+      }
+      return type;
+    },
+    [],
+  );
+
+  const toPurchaseInput = useCallback(
+    (purchase: Purchase): PurchaseInput => ({
+      id: purchase.id,
+      ids: purchase.ids ?? undefined,
+      isAutoRenewing: purchase.isAutoRenewing,
+      platform: purchase.platform,
+      productId: purchase.productId,
+      purchaseState: purchase.purchaseState,
+      purchaseToken: purchase.purchaseToken ?? null,
+      quantity: purchase.quantity,
+      transactionDate: purchase.transactionDate,
+    }),
+    [],
+  );
+
   const getSubscriptionsInternal = useCallback(
     async (skus: string[]): Promise<void> => {
       try {
         const result = await fetchProducts({skus, type: 'subs'});
+        const subscriptionsResult = (result ?? []) as ProductSubscription[];
         setSubscriptions((prevSubscriptions) =>
           mergeWithDuplicateCheck(
             prevSubscriptions,
-            result as ProductSubscription[],
+            subscriptionsResult,
             (subscription) => subscription.id,
           ),
         );
@@ -178,30 +201,58 @@ export function useIAP(options?: UseIAPOptions): UseIap {
       type?: ProductTypeInput;
     }): Promise<void> => {
       try {
-        const result = await fetchProducts(params);
+        const queryType = normalizeProductQueryType(params.type);
+        const request: ProductRequest = {skus: params.skus, type: queryType};
+        const result = await fetchProducts(request);
+        const items = (result ?? []) as (Product | ProductSubscription)[];
 
-        if (params.type === 'subs') {
+        if (queryType === 'subs') {
+          const subscriptionsResult = items as ProductSubscription[];
           setSubscriptions((prevSubscriptions) =>
             mergeWithDuplicateCheck(
               prevSubscriptions,
-              result as ProductSubscription[],
+              subscriptionsResult,
               (subscription) => subscription.id,
             ),
           );
+        } else if (queryType === 'in-app') {
+          const productsResult = items as Product[];
+          setProducts((prevProducts) =>
+            mergeWithDuplicateCheck(
+              prevProducts,
+              productsResult,
+              (product) => product.id,
+            ),
+          );
         } else {
+          const productItems = items.filter(
+            (item) => item.type === 'in-app',
+          ) as Product[];
+          const subscriptionItems = items.filter(
+            (item) => item.type === 'subs',
+          ) as ProductSubscription[];
+
           setProducts((prevProducts) =>
             mergeWithDuplicateCheck(
               prevProducts,
-              result as Product[],
+              productItems,
               (product) => product.id,
             ),
           );
+
+          setSubscriptions((prevSubscriptions) =>
+            mergeWithDuplicateCheck(
+              prevSubscriptions,
+              subscriptionItems,
+              (subscription) => subscription.id,
+            ),
+          );
         }
       } catch (error) {
         console.error('Error fetching products:', error);
       }
     },
-    [mergeWithDuplicateCheck],
+    [mergeWithDuplicateCheck, normalizeProductQueryType],
   );
 
   const getAvailablePurchasesInternal = useCallback(async (): Promise<void> => {
@@ -242,23 +293,23 @@ export function useIAP(options?: UseIAPOptions): UseIap {
   );
 
   const finishTransaction = useCallback(
-    ({
+    async ({
       purchase,
       isConsumable,
     }: {
       purchase: Purchase;
       isConsumable?: boolean;
-    }): Promise<VoidResult | boolean> => {
-      return finishTransactionInternal({
-        purchase,
+    }): Promise<void> => {
+      await finishTransactionInternal({
+        purchase: toPurchaseInput(purchase),
         isConsumable,
       });
     },
-    [],
+    [toPurchaseInput],
   );
 
   const requestPurchaseWithReset = useCallback(
-    (requestObj: PurchaseRequestInput) => {
+    (requestObj: MutationRequestPurchaseArgs) => {
       return requestPurchaseInternal(requestObj);
     },
     [],
@@ -283,7 +334,8 @@ export function useIAP(options?: UseIAPOptions): UseIap {
   // Android: fetch available purchases directly.
   const restorePurchasesInternal = useCallback(async (): Promise<void> => {
     try {
-      const purchases = await restorePurchases({
+      await restorePurchases();
+      const purchases = await getAvailablePurchases({
         alsoPublishToEventListenerIOS: false,
         onlyIncludeActiveItemsIOS: true,
       });
@@ -293,20 +345,9 @@ export function useIAP(options?: UseIAPOptions): UseIap {
     }
   }, []);
 
-  const validateReceipt = useCallback(
-    async (
-      sku: string,
-      androidOptions?: {
-        packageName: string;
-        productToken: string;
-        accessToken: string;
-        isSub?: boolean;
-      },
-    ) => {
-      return validateReceiptInternal(sku, androidOptions);
-    },
-    [],
-  );
+  const validateReceipt = useCallback(async (props: ReceiptValidationProps) => {
+    return validateReceiptInternal(props);
+  }, []);
 
   const initIapWithSubscriptions = useCallback(async (): Promise<void> => {
     // CRITICAL: Register listeners BEFORE initConnection to avoid race condition

package/src/utils/purchase.ts

@@ -0,0 +1,52 @@
+import type {Purchase} from '../types';
+
+const isPurchaseObject = (value: unknown): value is Record<string, unknown> =>
+  Boolean(value) && typeof value === 'object';
+
+/**
+ * Normalizes purchase identifiers so `id` reflects the transaction identifier (if present).
+ * Falls back to the existing `id` when no transaction identifier is available.
+ */
+export const normalizePurchaseId = <T extends Purchase | null | undefined>(
+  purchase: T,
+): T => {
+  if (!isPurchaseObject(purchase)) {
+    return purchase;
+  }
+
+  const transactionId = (purchase as Record<string, unknown>).transactionId;
+  if (typeof transactionId !== 'string' || transactionId.length === 0) {
+    return purchase;
+  }
+
+  if (purchase.id === transactionId) {
+    return purchase;
+  }
+
+  return {...purchase, id: transactionId} as T;
+};
+
+export const normalizePurchaseList = <T extends Purchase>(
+  purchases: T[] | null | undefined,
+): T[] => {
+  if (!Array.isArray(purchases)) {
+    return purchases ?? [];
+  }
+
+  if (purchases.length === 0) {
+    return purchases;
+  }
+
+  return purchases.map((purchase) => normalizePurchaseId(purchase)) as T[];
+};
+
+export const normalizePurchasePayload = <T extends Purchase | null | undefined>(
+  payload: T | T[] | null | undefined,
+): typeof payload => {
+  if (Array.isArray(payload)) {
+    return payload.map((purchase) =>
+      normalizePurchaseId(purchase),
+    ) as typeof payload;
+  }
+  return normalizePurchaseId(payload as T) as typeof payload;
+};