expo-iap 3.0.7 → 3.1.0

package/src/index.ts

@@ -9,6 +9,7 @@ import {
   validateReceiptIOS,
   deepLinkToSubscriptionsIOS,
   syncIOS,
+  getStorefrontIOS,
 } from './modules/ios';
 import {
   isProductAndroid,
@@ -17,29 +18,31 @@ import {
 } from './modules/android';
 
 // Types
-import {
+import type {
+  AndroidSubscriptionOfferInput,
+  DeepLinkOptions,
+  FetchProductsResult,
+  MutationField,
+  MutationRequestPurchaseArgs,
+  MutationValidateReceiptArgs,
   Product,
+  ProductQueryType,
+  ProductSubscription,
   Purchase,
-  ErrorCode,
-  RequestPurchaseProps,
+  PurchaseOptions,
+  QueryField,
   RequestPurchasePropsByPlatforms,
   RequestPurchaseAndroidProps,
   RequestPurchaseIosProps,
   RequestSubscriptionPropsByPlatforms,
   RequestSubscriptionAndroidProps,
   RequestSubscriptionIosProps,
-  ProductSubscription,
-  PurchaseAndroid,
-  DiscountOfferInputIOS,
-  VoidResult,
-  ReceiptValidationResult,
-  AndroidSubscriptionOfferInput,
 } from './types';
-import {PurchaseError} from './purchase-error';
+import {ErrorCode} from './types';
+import {createPurchaseError, type PurchaseError} from './utils/errorMapping';
 
 // Export all types
 export * from './types';
-export {ErrorCodeUtils, ErrorCodeMapping} from './purchase-error';
 export * from './modules/android';
 export * from './modules/ios';
 
@@ -50,18 +53,12 @@ export {
 } from './helpers/subscription';
 
 // Get the native constant value
-export const PI = ExpoIapModule.PI;
-
 export enum OpenIapEvent {
   PurchaseUpdated = 'purchase-updated',
   PurchaseError = 'purchase-error',
   PromotedProductIOS = 'promoted-product-ios',
 }
 
-export function setValueAsync(value: string) {
-  return ExpoIapModule.setValueAsync(value);
-}
-
 type ExpoIapEventPayloads = {
   [OpenIapEvent.PurchaseUpdated]: Purchase;
   [OpenIapEvent.PurchaseError]: PurchaseError;
@@ -90,32 +87,7 @@ export const emitter = (ExpoIapModule ||
 /**
  * TODO(v3.1.0): Remove legacy 'inapp' alias once downstream apps migrate to 'in-app'.
  */
-export type ProductTypeInput = 'inapp' | 'in-app' | 'subs';
-export type InAppTypeInput = Exclude<ProductTypeInput, 'subs'>;
-
-type PurchaseRequestInApp = {
-  request: RequestPurchasePropsByPlatforms;
-  type?: InAppTypeInput;
-};
-
-type PurchaseRequestSubscription = {
-  request: RequestSubscriptionPropsByPlatforms;
-  type: 'subs';
-};
-
-export type PurchaseRequestInput =
-  | PurchaseRequestInApp
-  | PurchaseRequestSubscription;
-
-export type PurchaseRequest =
-  | {
-      request: RequestPurchaseProps;
-      type?: InAppTypeInput;
-    }
-  | {
-      request: RequestSubscriptionPropsByPlatforms;
-      type: 'subs';
-    };
+export type ProductTypeInput = ProductQueryType | 'inapp';
 
 const normalizeProductType = (type?: ProductTypeInput) => {
   if (type === 'inapp') {
@@ -126,48 +98,66 @@ const normalizeProductType = (type?: ProductTypeInput) => {
 
   if (!type || type === 'inapp' || type === 'in-app') {
     return {
-      canonical: 'in-app' as const,
-      native: 'inapp' as const,
+      canonical: 'in-app' as ProductQueryType,
+      native: 'in-app' as const,
     };
   }
   if (type === 'subs') {
     return {
-      canonical: 'subs' as const,
+      canonical: 'subs' as ProductQueryType,
       native: 'subs' as const,
     };
   }
+  if (type === 'all') {
+    return {
+      canonical: 'all' as ProductQueryType,
+      native: 'all' as const,
+    };
+  }
   throw new Error(`Unsupported product type: ${type}`);
 };
 
+const normalizePurchasePlatform = (purchase: Purchase): Purchase => {
+  const platform = purchase.platform;
+  if (typeof platform !== 'string') {
+    return purchase;
+  }
+
+  const lowered = platform.toLowerCase();
+  if (lowered === platform || (lowered !== 'ios' && lowered !== 'android')) {
+    return purchase;
+  }
+
+  return {...purchase, platform: lowered};
+};
+
+const normalizePurchaseArray = (purchases: Purchase[]): Purchase[] =>
+  purchases.map((purchase) => normalizePurchasePlatform(purchase));
+
 export const purchaseUpdatedListener = (
   listener: (event: Purchase) => void,
 ) => {
-  console.log('[JS] Registering purchaseUpdatedListener');
   const wrappedListener = (event: Purchase) => {
-    console.log('[JS] purchaseUpdatedListener fired:', event);
-    listener(event);
+    const normalized = normalizePurchasePlatform(event);
+    listener(normalized);
   };
   const emitterSubscription = emitter.addListener(
     OpenIapEvent.PurchaseUpdated,
     wrappedListener,
   );
-  console.log('[JS] purchaseUpdatedListener registered successfully');
   return emitterSubscription;
 };
 
 export const purchaseErrorListener = (
   listener: (error: PurchaseError) => void,
 ) => {
-  console.log('[JS] Registering purchaseErrorListener');
   const wrappedListener = (error: PurchaseError) => {
-    console.log('[JS] purchaseErrorListener fired:', error);
     listener(error);
   };
   const emitterSubscription = emitter.addListener(
     OpenIapEvent.PurchaseError,
     wrappedListener,
   );
-  console.log('[JS] purchaseErrorListener registered successfully');
   return emitterSubscription;
 };
 
@@ -203,158 +193,114 @@ export const promotedProductListenerIOS = (
   return emitter.addListener(OpenIapEvent.PromotedProductIOS, listener);
 };
 
-export function initConnection(): Promise<boolean> {
-  const result = ExpoIapModule.initConnection();
-  return Promise.resolve(result);
-}
+export const initConnection: MutationField<'initConnection'> = async () =>
+  ExpoIapModule.initConnection();
 
-export async function endConnection(): Promise<boolean> {
-  return ExpoIapModule.endConnection();
-}
+export const endConnection: MutationField<'endConnection'> = async () =>
+  ExpoIapModule.endConnection();
 
 /**
  * Fetch products with unified API (v2.7.0+)
  *
- * @param params - Product fetch configuration
- * @param params.skus - Array of product SKUs to fetch
- * @param params.type - Type of products: 'in-app' for regular products (default) or 'subs' for subscriptions
- *
- * @example
- * ```typescript
- * // Regular products
- * const products = await fetchProducts({
- *   skus: ['product1', 'product2'],
- *   type: 'in-app'
- * });
- *
- * // Subscriptions
- * const subscriptions = await fetchProducts({
- *   skus: ['sub1', 'sub2'],
- *   type: 'subs'
- * });
- * ```
+ * @param request - Product fetch configuration
+ * @param request.skus - Array of product SKUs to fetch
+ * @param request.type - Product query type: 'in-app', 'subs', or 'all'
  */
-export const fetchProducts = async ({
-  skus,
-  type,
-}: {
-  skus: string[];
-  type?: ProductTypeInput;
-}): Promise<Product[] | ProductSubscription[]> => {
-  if (!skus?.length) {
-    throw new PurchaseError({
+export const fetchProducts: QueryField<'fetchProducts'> = async (request) => {
+  console.log('fetchProducts called with:', request);
+  const {skus, type} = request ?? {};
+
+  if (!Array.isArray(skus) || skus.length === 0) {
+    throw createPurchaseError({
       message: 'No SKUs provided',
       code: ErrorCode.EmptySkuList,
     });
   }
 
-  const {canonical, native} = normalizeProductType(type);
-
-  if (Platform.OS === 'ios') {
-    const rawItems = await ExpoIapModule.fetchProducts({skus, type: native});
+  const {canonical, native} = normalizeProductType(
+    type as ProductTypeInput | undefined,
+  );
+  const skuSet = new Set(skus);
 
-    const filteredItems = rawItems.filter((item: unknown) => {
+  const filterIosItems = (
+    items: unknown[],
+  ): Product[] | ProductSubscription[] =>
+    items.filter((item): item is Product | ProductSubscription => {
       if (!isProductIOS(item)) {
         return false;
       }
-      const isValid =
-        typeof item === 'object' &&
-        item !== null &&
-        'id' in item &&
-        typeof item.id === 'string' &&
-        skus.includes(item.id);
-      return isValid;
+      const candidate = item as Product | ProductSubscription;
+      return typeof candidate.id === 'string' && skuSet.has(candidate.id);
+    });
+
+  const filterAndroidItems = (
+    items: unknown[],
+  ): Product[] | ProductSubscription[] =>
+    items.filter((item): item is Product | ProductSubscription => {
+      if (!isProductAndroid(item)) {
+        return false;
+      }
+      const candidate = item as Product | ProductSubscription;
+      return typeof candidate.id === 'string' && skuSet.has(candidate.id);
     });
 
-    return canonical === 'in-app'
-      ? (filteredItems as Product[])
-      : (filteredItems as ProductSubscription[]);
+  const castResult = (
+    items: Product[] | ProductSubscription[],
+  ): FetchProductsResult => {
+    if (canonical === 'in-app') {
+      return items as Product[];
+    }
+    if (canonical === 'subs') {
+      return items as ProductSubscription[];
+    }
+    return items;
+  };
+
+  if (Platform.OS === 'ios') {
+    const rawItems = await ExpoIapModule.fetchProducts({skus, type: native});
+    return castResult(filterIosItems(rawItems));
   }
 
   if (Platform.OS === 'android') {
-    const items = await ExpoIapModule.fetchProducts(native, skus);
-    const filteredItems = items.filter((item: unknown) => {
-      if (!isProductAndroid(item)) return false;
-      return (
-        typeof item === 'object' &&
-        item !== null &&
-        'id' in item &&
-        typeof item.id === 'string' &&
-        skus.includes(item.id)
-      );
-    });
-
-    return canonical === 'in-app'
-      ? (filteredItems as Product[])
-      : (filteredItems as ProductSubscription[]);
+    const rawItems = await ExpoIapModule.fetchProducts(native, skus);
+    return castResult(filterAndroidItems(rawItems));
   }
 
   throw new Error('Unsupported platform');
 };
 
-export const getAvailablePurchases = ({
-  alsoPublishToEventListenerIOS = false,
-  onlyIncludeActiveItemsIOS = true,
-}: {
-  alsoPublishToEventListenerIOS?: boolean;
-  onlyIncludeActiveItemsIOS?: boolean;
-} = {}): Promise<Purchase[]> =>
-  (
+export const getAvailablePurchases: QueryField<
+  'getAvailablePurchases'
+> = async (options) => {
+  const normalizedOptions: PurchaseOptions = {
+    alsoPublishToEventListenerIOS:
+      options?.alsoPublishToEventListenerIOS ?? false,
+    onlyIncludeActiveItemsIOS: options?.onlyIncludeActiveItemsIOS ?? true,
+  };
+
+  const resolvePurchases: () => Promise<Purchase[]> =
     Platform.select({
       ios: () =>
         ExpoIapModule.getAvailableItems(
-          alsoPublishToEventListenerIOS,
-          onlyIncludeActiveItemsIOS,
-        ),
-      android: () => ExpoIapModule.getAvailableItems(),
-    }) || (() => Promise.resolve([]))
-  )();
-
-/**
- * Restore completed transactions (cross-platform behavior)
- *
- * - iOS: perform a lightweight sync to refresh transactions and ignore sync errors,
- *   then fetch available purchases to surface restored items to the app.
- * - Android: simply fetch available purchases (restoration happens via query).
- *
- * This helper returns the restored/available purchases so callers can update UI/state.
- *
- * @param options.alsoPublishToEventListenerIOS - iOS only: whether to also publish to the event listener
- * @param options.onlyIncludeActiveItemsIOS - iOS only: whether to only include active items
- * @returns Promise resolving to the list of available/restored purchases
- */
-export const restorePurchases = async (
-  options: {
-    alsoPublishToEventListenerIOS?: boolean;
-    onlyIncludeActiveItemsIOS?: boolean;
-  } = {},
-): Promise<Purchase[]> => {
-  if (Platform.OS === 'ios') {
-    // Perform best-effort sync on iOS and ignore sync errors to avoid blocking restore flow
-    await syncIOS().catch(() => undefined);
-  }
-
-  // Then, fetch available purchases for both platforms
-  const purchases = await getAvailablePurchases({
-    alsoPublishToEventListenerIOS:
-      options.alsoPublishToEventListenerIOS ?? false,
-    onlyIncludeActiveItemsIOS: options.onlyIncludeActiveItemsIOS ?? true,
-  });
-
-  return purchases;
+          normalizedOptions.alsoPublishToEventListenerIOS,
+          normalizedOptions.onlyIncludeActiveItemsIOS,
+        ) as Promise<Purchase[]>,
+      android: () => ExpoIapModule.getAvailableItems() as Promise<Purchase[]>,
+    }) ?? (() => Promise.resolve([] as Purchase[]));
+
+  const purchases = await resolvePurchases();
+  return normalizePurchaseArray(purchases as Purchase[]);
 };
 
-const offerToRecordIOS = (
-  offer: DiscountOfferInputIOS | undefined,
-): Record<keyof DiscountOfferInputIOS, string> | undefined => {
-  if (!offer) return undefined;
-  return {
-    identifier: offer.identifier,
-    keyIdentifier: offer.keyIdentifier,
-    nonce: offer.nonce,
-    signature: offer.signature,
-    timestamp: offer.timestamp.toString(),
-  };
+export const getStorefront: QueryField<'getStorefrontIOS'> = async () => {
+  // Cross-platform storefront
+  if (Platform.OS === 'android') {
+    if (typeof ExpoIapModule.getStorefrontAndroid === 'function') {
+      return ExpoIapModule.getStorefrontAndroid();
+    }
+    return '';
+  }
+  return getStorefrontIOS();
 };
 
 /**
@@ -417,11 +363,11 @@ function normalizeRequestProps(
  * });
  * ```
  */
-export const requestPurchase = (
-  requestObj: PurchaseRequestInput,
-): Promise<Purchase | Purchase[] | void> => {
-  const {request, type} = requestObj;
-  const {canonical, native} = normalizeProductType(type);
+export const requestPurchase: MutationField<'requestPurchase'> = async (
+  args,
+) => {
+  const {request, type} = args;
+  const {canonical, native} = normalizeProductType(type as ProductTypeInput);
   const isInAppPurchase = canonical === 'in-app';
 
   if (Platform.OS === 'ios') {
@@ -433,35 +379,43 @@ export const requestPurchase = (
       );
     }
 
-    const {
-      sku,
-      andDangerouslyFinishTransactionAutomatically = false,
-      appAccountToken,
-      quantity,
-      withOffer,
-    } = normalizedRequest;
-
-    return (async () => {
-      const offer = offerToRecordIOS(withOffer ?? undefined);
-      const purchase = await ExpoIapModule.requestPurchase({
-        sku,
-        andDangerouslyFinishTransactionAutomatically,
-        appAccountToken,
-        quantity,
-        withOffer: offer,
-      });
+    let payload: MutationRequestPurchaseArgs;
+    if (canonical === 'in-app') {
+      payload = {
+        type: 'in-app',
+        request: request as RequestPurchasePropsByPlatforms,
+      };
+    } else if (canonical === 'subs') {
+      payload = {
+        type: 'subs',
+        request: request as RequestSubscriptionPropsByPlatforms,
+      };
+    } else {
+      throw new Error(`Unsupported product type: ${canonical}`);
+    }
+
+    const purchase = (await ExpoIapModule.requestPurchase(payload)) as
+      | Purchase
+      | Purchase[]
+      | null;
+
+    if (Array.isArray(purchase)) {
+      return normalizePurchaseArray(purchase);
+    }
+
+    if (purchase) {
+      return normalizePurchasePlatform(purchase);
+    }
 
-      return purchase as Purchase;
-    })();
+    return canonical === 'subs' ? [] : null;
   }
 
   if (Platform.OS === 'android') {
     if (isInAppPurchase) {
-      const normalizedRequest: RequestPurchaseAndroidProps | null | undefined =
-        normalizeRequestProps(
-          request as RequestPurchasePropsByPlatforms,
-          'android',
-        );
+      const normalizedRequest = normalizeRequestProps(
+        request as RequestPurchasePropsByPlatforms,
+        'android',
+      ) as RequestPurchaseAndroidProps | null | undefined;
 
       if (!normalizedRequest?.skus?.length) {
         throw new Error(
@@ -476,28 +430,25 @@ export const requestPurchase = (
         isOfferPersonalized,
       } = normalizedRequest;
 
-      return (async () => {
-        return ExpoIapModule.requestPurchase({
-          type: native,
-          skuArr: skus,
-          purchaseToken: undefined,
-          replacementMode: -1,
-          obfuscatedAccountId: obfuscatedAccountIdAndroid,
-          obfuscatedProfileId: obfuscatedProfileIdAndroid,
-          offerTokenArr: [],
-          isOfferPersonalized: isOfferPersonalized ?? false,
-        }) as Promise<Purchase[]>;
-      })();
+      const result = (await ExpoIapModule.requestPurchase({
+        type: native,
+        skuArr: skus,
+        purchaseToken: undefined,
+        replacementMode: -1,
+        obfuscatedAccountId: obfuscatedAccountIdAndroid,
+        obfuscatedProfileId: obfuscatedProfileIdAndroid,
+        offerTokenArr: [],
+        isOfferPersonalized: isOfferPersonalized ?? false,
+      })) as Purchase[];
+
+      return normalizePurchaseArray(result);
     }
 
     if (canonical === 'subs') {
-      const normalizedRequest:
-        | RequestSubscriptionAndroidProps
-        | null
-        | undefined = normalizeRequestProps(
+      const normalizedRequest = normalizeRequestProps(
         request as RequestSubscriptionPropsByPlatforms,
         'android',
-      );
+      ) as RequestSubscriptionAndroidProps | null | undefined;
 
       if (!normalizedRequest?.skus?.length) {
         throw new Error(
@@ -519,21 +470,21 @@ export const requestPurchase = (
       const replacementMode = replacementModeAndroid ?? -1;
       const purchaseToken = purchaseTokenAndroid ?? undefined;
 
-      return (async () => {
-        return ExpoIapModule.requestPurchase({
-          type: native,
-          skuArr: skus,
-          purchaseToken,
-          replacementMode,
-          obfuscatedAccountId: obfuscatedAccountIdAndroid,
-          obfuscatedProfileId: obfuscatedProfileIdAndroid,
-          offerTokenArr: normalizedOffers.map(
-            (so: AndroidSubscriptionOfferInput) => so.offerToken,
-          ),
-          subscriptionOffers: normalizedOffers,
-          isOfferPersonalized: isOfferPersonalized ?? false,
-        }) as Promise<Purchase[]>;
-      })();
+      const result = (await ExpoIapModule.requestPurchase({
+        type: native,
+        skuArr: skus,
+        purchaseToken,
+        replacementMode,
+        obfuscatedAccountId: obfuscatedAccountIdAndroid,
+        obfuscatedProfileId: obfuscatedProfileIdAndroid,
+        offerTokenArr: normalizedOffers.map(
+          (offer: AndroidSubscriptionOfferInput) => offer.offerToken,
+        ),
+        subscriptionOffers: normalizedOffers,
+        isOfferPersonalized: isOfferPersonalized ?? false,
+      })) as Purchase[];
+
+      return normalizePurchaseArray(result);
     }
 
     throw new Error(
@@ -541,93 +492,95 @@ export const requestPurchase = (
     );
   }
 
-  return Promise.resolve(); // Fallback for unsupported platforms
+  throw new Error('Platform not supported');
 };
 
-export const finishTransaction = ({
+export const finishTransaction: MutationField<'finishTransaction'> = async ({
   purchase,
   isConsumable = false,
-}: {
-  purchase: Purchase;
-  isConsumable?: boolean;
-}): Promise<VoidResult | boolean> => {
-  return (
-    Platform.select({
-      ios: async () => {
-        const transactionId = purchase.id;
-        if (!transactionId) {
-          return Promise.reject(
-            new Error('purchase.id required to finish iOS transaction'),
-          );
-        }
-        await ExpoIapModule.finishTransaction(transactionId);
-        return Promise.resolve(true);
-      },
-      android: async () => {
-        const androidPurchase = purchase as PurchaseAndroid;
-
-        // Use purchaseToken if available, fallback to purchaseTokenAndroid for backward compatibility
-        const token = androidPurchase.purchaseToken;
-
-        if (!token) {
-          return Promise.reject(
-            new PurchaseError({
-              message: 'Purchase token is required to finish transaction',
-              code: ErrorCode.DeveloperError,
-              productId: androidPurchase.productId,
-              platform: 'android',
-            }),
-          );
-        }
-
-        if (isConsumable) {
-          return ExpoIapModule.consumePurchaseAndroid(token);
-        }
-
-        return ExpoIapModule.acknowledgePurchaseAndroid(token);
-      },
-    }) || (() => Promise.reject(new Error('Unsupported Platform')))
-  )();
+}) => {
+  if (Platform.OS === 'ios') {
+    await ExpoIapModule.finishTransaction(purchase, isConsumable);
+    return;
+  }
+
+  if (Platform.OS === 'android') {
+    const token = purchase.purchaseToken ?? undefined;
+
+    if (!token) {
+      throw createPurchaseError({
+        message: 'Purchase token is required to finish transaction',
+        code: ErrorCode.DeveloperError,
+        productId: purchase.productId,
+        platform: 'android',
+      });
+    }
+
+    if (isConsumable) {
+      await ExpoIapModule.consumePurchaseAndroid(token);
+      return;
+    }
+
+    await ExpoIapModule.acknowledgePurchaseAndroid(token);
+    return;
+  }
+
+  throw new Error('Unsupported Platform');
 };
 
 /**
- * Retrieves the current storefront information from iOS App Store
- *
- * @returns Promise resolving to the storefront country code
- * @throws Error if called on non-iOS platform
+ * Restore completed transactions (cross-platform behavior)
  *
- * @example
- * ```typescript
- * const storefront = await getStorefrontIOS();
- * console.log(storefront); // 'US'
- * ```
+ * - iOS: perform a lightweight sync to refresh transactions and ignore sync errors,
+ *   then fetch available purchases to surface restored items to the app.
+ * - Android: simply fetch available purchases (restoration happens via query).
  *
- * @platform iOS
+ * This helper triggers the refresh flows but does not return the purchases; consumers should
+ * call `getAvailablePurchases` or rely on hook state to inspect the latest items.
  */
-export const getStorefrontIOS = (): Promise<string> => {
-  if (Platform.OS !== 'ios') {
-    console.warn('getStorefrontIOS: This method is only available on iOS');
-    return Promise.resolve('');
+export const restorePurchases: MutationField<'restorePurchases'> = async () => {
+  if (Platform.OS === 'ios') {
+    await syncIOS().catch(() => undefined);
   }
-  return ExpoIapModule.getStorefrontIOS();
+
+  await getAvailablePurchases({
+    alsoPublishToEventListenerIOS: false,
+    onlyIncludeActiveItemsIOS: true,
+  });
 };
 
 /**
- * Gets the storefront country code from the underlying native store.
- * Returns a two-letter country code such as 'US', 'KR', or empty string on failure.
+ * Deeplinks to native interface that allows users to manage their subscriptions
+ * @param options.skuAndroid - Required for Android to locate specific subscription (ignored on iOS)
+ * @param options.packageNameAndroid - Required for Android to identify your app (ignored on iOS)
  *
- * @platform ios
- * @platform android
+ * @returns Promise that resolves when the deep link is successfully opened
+ *
+ * @throws {Error} When called on unsupported platform or when required Android parameters are missing
+ *
+ * @example
+ * import { deepLinkToSubscriptions } from 'expo-iap';
+ *
+ * // Works on both iOS and Android
+ * await deepLinkToSubscriptions({
+ *   skuAndroid: 'your_subscription_sku',
+ *   packageNameAndroid: 'com.example.app'
+ * });
  */
-export const getStorefront = (): Promise<string> => {
-  // Cross-platform storefront
+export const deepLinkToSubscriptions: MutationField<
+  'deepLinkToSubscriptions'
+> = async (options) => {
+  if (Platform.OS === 'ios') {
+    await deepLinkToSubscriptionsIOS();
+    return;
+  }
+
   if (Platform.OS === 'android') {
-    if (typeof ExpoIapModule.getStorefrontAndroid === 'function') {
-      return ExpoIapModule.getStorefrontAndroid();
-    }
-    return Promise.resolve('');
+    await deepLinkToSubscriptionsAndroid((options as DeepLinkOptions) ?? null);
+    return;
   }
-  return getStorefrontIOS();
+
+  throw new Error(`Unsupported platform: ${Platform.OS}`);
 };
 
 /**
@@ -638,18 +591,16 @@ export const getStorefront = (): Promise<string> => {
  * - iOS: Send receipt data to Apple's verification endpoint from your server
  * - Android: Use Google Play Developer API with service account credentials
  */
-export const validateReceipt = async (
-  sku: string,
-  androidOptions?: {
-    packageName: string;
-    productToken: string;
-    accessToken: string;
-    isSub?: boolean;
-  },
-): Promise<ReceiptValidationResult> => {
+export const validateReceipt: MutationField<'validateReceipt'> = async (
+  options,
+) => {
+  const {sku, androidOptions} = options as MutationValidateReceiptArgs;
+
   if (Platform.OS === 'ios') {
-    return await validateReceiptIOS(sku);
-  } else if (Platform.OS === 'android') {
+    return validateReceiptIOS({sku});
+  }
+
+  if (Platform.OS === 'android') {
     if (
       !androidOptions ||
       !androidOptions.packageName ||
@@ -660,53 +611,26 @@ export const validateReceipt = async (
         'Android validation requires packageName, productToken, and accessToken',
       );
     }
-    return await validateReceiptAndroid({
+    return validateReceiptAndroid({
       packageName: androidOptions.packageName,
       productId: sku,
       productToken: androidOptions.productToken,
       accessToken: androidOptions.accessToken,
-      isSub: androidOptions.isSub,
+      isSub: androidOptions.isSub ?? undefined,
     });
-  } else {
-    throw new Error('Platform not supported');
   }
-};
 
-/**
- * Deeplinks to native interface that allows users to manage their subscriptions
- * @param options.skuAndroid - Required for Android to locate specific subscription (ignored on iOS)
- * @param options.packageNameAndroid - Required for Android to identify your app (ignored on iOS)
- *
- * @returns Promise that resolves when the deep link is successfully opened
- *
- * @throws {Error} When called on unsupported platform or when required Android parameters are missing
- *
- * @example
- * import { deepLinkToSubscriptions } from 'expo-iap';
- *
- * // Works on both iOS and Android
- * await deepLinkToSubscriptions({
- *   skuAndroid: 'your_subscription_sku',
- *   packageNameAndroid: 'com.example.app'
- * });
- */
-export const deepLinkToSubscriptions = (options: {
-  skuAndroid?: string;
-  packageNameAndroid?: string;
-}): Promise<void> => {
-  if (Platform.OS === 'ios') {
-    return deepLinkToSubscriptionsIOS();
-  }
-
-  if (Platform.OS === 'android') {
-    return deepLinkToSubscriptionsAndroid({
-      sku: options?.skuAndroid,
-      packageName: options?.packageNameAndroid,
-    });
-  }
-
-  return Promise.reject(new Error(`Unsupported platform: ${Platform.OS}`));
+  throw new Error('Platform not supported');
 };
 
 export * from './useIAP';
-export * from './utils/errorMapping';
+export {
+  ErrorCodeUtils,
+  ErrorCodeMapping,
+  createPurchaseError,
+  createPurchaseErrorFromPlatform,
+} from './utils/errorMapping';
+export type {
+  PurchaseError as ExpoPurchaseError,
+  PurchaseErrorProps,
+} from './utils/errorMapping';