expo-iap 3.0.2 → 3.0.4

package/jest.config.js

@@ -35,7 +35,7 @@ module.exports = {
   ],
   coveragePathIgnorePatterns: [
     '<rootDir>/src/useIAP.ts',
-    '<rootDir>/src/ExpoIap.types.ts',
+    '<rootDir>/src/types.ts',
     '<rootDir>/src/utils/constants.ts',
   ],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-iap",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "description": "In App Purchase module in Expo",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/src/helpers/subscription.ts

@@ -1,18 +1,6 @@
 import {Platform} from 'react-native';
 import {getAvailablePurchases} from '../index';
-
-export interface ActiveSubscription {
-  productId: string;
-  isActive: boolean;
-  transactionId: string; // Transaction identifier for backend validation
-  purchaseToken?: string; // JWT token (iOS) or purchase token (Android) for backend validation
-  transactionDate: number; // Transaction timestamp
-  expirationDateIOS?: Date;
-  autoRenewingAndroid?: boolean;
-  environmentIOS?: string;
-  willExpireSoon?: boolean;
-  daysUntilExpirationIOS?: number;
-}
+import type {ActiveSubscription} from '../types';
 
 /**
  * Get all active subscriptions with detailed information
@@ -91,8 +79,7 @@ export const getActiveSubscriptions = async (
       const subscription: ActiveSubscription = {
         productId: purchase.productId,
         isActive: true,
-        // Use unified id as transaction identifier in v3
-        transactionId: purchase.id,
+        transactionId: String(purchase.id),
         purchaseToken: purchase.purchaseToken,
         transactionDate: purchase.transactionDate,
       };
@@ -100,8 +87,7 @@ export const getActiveSubscriptions = async (
       // Add platform-specific details
       if (Platform.OS === 'ios') {
         if ('expirationDateIOS' in purchase && purchase.expirationDateIOS) {
-          const expirationDate = new Date(purchase.expirationDateIOS);
-          subscription.expirationDateIOS = expirationDate;
+          subscription.expirationDateIOS = purchase.expirationDateIOS;
 
           // Calculate days until expiration (round to nearest day)
           const daysUntilExpiration = Math.round(
@@ -112,13 +98,19 @@ export const getActiveSubscriptions = async (
         }
 
         if ('environmentIOS' in purchase) {
-          subscription.environmentIOS = purchase.environmentIOS;
+          subscription.environmentIOS = purchase.environmentIOS ?? undefined;
         }
       } else if (Platform.OS === 'android') {
         if ('autoRenewingAndroid' in purchase) {
-          subscription.autoRenewingAndroid = purchase.autoRenewingAndroid;
+          if (typeof purchase.autoRenewingAndroid !== 'undefined') {
+            subscription.autoRenewingAndroid = purchase.autoRenewingAndroid;
+          }
           // If auto-renewing is false, subscription will expire soon
-          subscription.willExpireSoon = !purchase.autoRenewingAndroid;
+          if (purchase.autoRenewingAndroid === false) {
+            subscription.willExpireSoon = true;
+          } else if (purchase.autoRenewingAndroid === true) {
+            subscription.willExpireSoon = false;
+          }
         }
       }
 

package/src/index.ts

@@ -20,19 +20,20 @@ import {
 import {
   Product,
   Purchase,
-  PurchaseError,
   ErrorCode,
-  PurchaseResult,
-  RequestSubscriptionProps,
   RequestPurchaseProps,
-  SubscriptionProduct,
-  // Bring platform types from the barrel to avoid deep imports
+  RequestSubscriptionPropsByPlatforms,
+  ProductSubscription,
   PurchaseAndroid,
-  PaymentDiscount,
-} from './ExpoIap.types';
+  DiscountOfferInputIOS,
+  VoidResult,
+  ReceiptValidationResult,
+} from './types';
+import {PurchaseError} from './purchase-error';
 
 // Export all types
-export * from './ExpoIap.types';
+export * from './types';
+export {ErrorCodeUtils, ErrorCodeMapping} from './purchase-error';
 export * from './modules/android';
 export * from './modules/ios';
 
@@ -40,7 +41,6 @@ export * from './modules/ios';
 export {
   getActiveSubscriptions,
   hasActiveSubscriptions,
-  type ActiveSubscription,
 } from './helpers/subscription';
 
 // Get the native constant value
@@ -169,11 +169,11 @@ export const fetchProducts = async ({
 }: {
   skus: string[];
   type?: 'inapp' | 'subs';
-}): Promise<Product[] | SubscriptionProduct[]> => {
+}): Promise<Product[] | ProductSubscription[]> => {
   if (!skus?.length) {
     throw new PurchaseError({
       message: 'No SKUs provided',
-      code: ErrorCode.E_EMPTY_SKU_LIST,
+      code: ErrorCode.EmptySkuList,
     });
   }
 
@@ -195,7 +195,7 @@ export const fetchProducts = async ({
 
     return type === 'inapp'
       ? (filteredItems as Product[])
-      : (filteredItems as SubscriptionProduct[]);
+      : (filteredItems as ProductSubscription[]);
   }
 
   if (Platform.OS === 'android') {
@@ -213,7 +213,7 @@ export const fetchProducts = async ({
 
     return type === 'inapp'
       ? (filteredItems as Product[])
-      : (filteredItems as SubscriptionProduct[]);
+      : (filteredItems as ProductSubscription[]);
   }
 
   throw new Error('Unsupported platform');
@@ -272,8 +272,8 @@ export const restorePurchases = async (
 };
 
 const offerToRecordIOS = (
-  offer: PaymentDiscount | undefined,
-): Record<keyof PaymentDiscount, string> | undefined => {
+  offer: DiscountOfferInputIOS | undefined,
+): Record<keyof DiscountOfferInputIOS, string> | undefined => {
   if (!offer) return undefined;
   return {
     identifier: offer.identifier,
@@ -291,7 +291,7 @@ type PurchaseRequest =
       type?: 'inapp';
     }
   | {
-      request: RequestSubscriptionProps;
+      request: RequestSubscriptionPropsByPlatforms;
       type: 'subs';
     };
 
@@ -299,7 +299,7 @@ type PurchaseRequest =
  * Helper to normalize request props to platform-specific format
  */
 const normalizeRequestProps = (
-  request: RequestPurchaseProps | RequestSubscriptionProps,
+  request: RequestPurchaseProps | RequestSubscriptionPropsByPlatforms,
   platform: 'ios' | 'android',
 ): any => {
   // Platform-specific format - directly return the appropriate platform data
@@ -443,7 +443,7 @@ export const finishTransaction = ({
 }: {
   purchase: Purchase;
   isConsumable?: boolean;
-}): Promise<PurchaseResult | boolean> => {
+}): Promise<VoidResult | boolean> => {
   return (
     Platform.select({
       ios: async () => {
@@ -466,7 +466,7 @@ export const finishTransaction = ({
           return Promise.reject(
             new PurchaseError({
               message: 'Purchase token is required to finish transaction',
-              code: 'E_DEVELOPER_ERROR' as ErrorCode,
+              code: ErrorCode.DeveloperError,
               productId: androidPurchase.productId,
               platform: 'android',
             }),
@@ -539,7 +539,7 @@ export const validateReceipt = async (
     accessToken: string;
     isSub?: boolean;
   },
-): Promise<any> => {
+): Promise<ReceiptValidationResult> => {
   if (Platform.OS === 'ios') {
     return await validateReceiptIOS(sku);
   } else if (Platform.OS === 'android') {

package/src/modules/android.ts

@@ -5,17 +5,19 @@ import {Linking} from 'react-native';
 import ExpoIapModule from '../ExpoIapModule';
 
 // Types
-import type {PurchaseResult, ReceiptAndroid} from '../ExpoIap.types';
+import type {ReceiptValidationResultAndroid, VoidResult} from '../types';
+import {Platform as PurchasePlatform} from '../types';
 
 // Type guards
-export function isProductAndroid<T extends {platform?: string}>(
-  item: unknown,
-): item is T & {platform: 'android'} {
+export function isProductAndroid<
+  T extends {platform?: string | PurchasePlatform},
+>(item: unknown): item is T & {platform: PurchasePlatform.Android | 'android'} {
   return (
     item != null &&
     typeof item === 'object' &&
     'platform' in item &&
-    item.platform === 'android'
+    ((item as any).platform === 'android' ||
+      (item as any).platform === PurchasePlatform.Android)
   );
 }
 
@@ -86,7 +88,7 @@ export const validateReceiptAndroid = async ({
   productToken: string;
   accessToken: string;
   isSub?: boolean;
-}): Promise<ReceiptAndroid> => {
+}): Promise<ReceiptValidationResultAndroid> => {
   const type = isSub ? 'subscriptions' : 'products';
 
   const url =
@@ -115,14 +117,30 @@ export const validateReceiptAndroid = async ({
  * Acknowledge a product (on Android.) No-op on iOS.
  * @param {Object} params - The parameters object
  * @param {string} params.token - The product's token (on Android)
- * @returns {Promise<PurchaseResult | void>}
+ * @returns {Promise<VoidResult | void>}
  */
-export const acknowledgePurchaseAndroid = ({
+export const acknowledgePurchaseAndroid = async ({
   token,
 }: {
   token: string;
-}): Promise<PurchaseResult | boolean | void> => {
-  return ExpoIapModule.acknowledgePurchaseAndroid(token);
+}): Promise<VoidResult | boolean | void> => {
+  const result = await ExpoIapModule.acknowledgePurchaseAndroid(token);
+
+  if (typeof result === 'boolean' || typeof result === 'undefined') {
+    return result;
+  }
+
+  if (result && typeof result === 'object') {
+    const record = result as Record<string, unknown>;
+    if (typeof record.success === 'boolean') {
+      return {success: record.success};
+    }
+    if (typeof record.responseCode === 'number') {
+      return {success: record.responseCode === 0};
+    }
+  }
+
+  return {success: true};
 };
 
 /**

package/src/modules/ios.ts

@@ -8,10 +8,12 @@ import ExpoIapModule from '../ExpoIapModule';
 import type {
   Product,
   Purchase,
-  PurchaseError,
   SubscriptionStatusIOS,
-  AppTransactionIOS,
-} from '../ExpoIap.types';
+  AppTransaction,
+  ReceiptValidationResultIOS,
+} from '../types';
+import type {PurchaseError} from '../purchase-error';
+import {Platform as PurchasePlatform} from '../types';
 import {Linking} from 'react-native';
 
 export type TransactionEvent = {
@@ -22,14 +24,15 @@ export type TransactionEvent = {
 // Listeners
 
 // Type guards
-export function isProductIOS<T extends {platform?: string}>(
+export function isProductIOS<T extends {platform?: string | PurchasePlatform}>(
   item: unknown,
-): item is T & {platform: 'ios'} {
+): item is T & {platform: PurchasePlatform.Ios | 'ios'} {
   return (
     item != null &&
     typeof item === 'object' &&
     'platform' in item &&
-    item.platform === 'ios'
+    ((item as any).platform === 'ios' ||
+      (item as any).platform === PurchasePlatform.Ios)
   );
 }
 
@@ -191,12 +194,7 @@ export const getTransactionJwsIOS = (sku: string): Promise<string> => {
  */
 export const validateReceiptIOS = async (
   sku: string,
-): Promise<{
-  isValid: boolean;
-  receiptData: string;
-  jwsRepresentation: string;
-  latestTransaction?: Purchase;
-}> => {
+): Promise<ReceiptValidationResultIOS> => {
   const result = await ExpoIapModule.validateReceiptIOS(sku);
   return result;
 };
@@ -230,7 +228,7 @@ export const presentCodeRedemptionSheetIOS = (): Promise<boolean> => {
  * @platform iOS
  * @since iOS 16.0
  */
-export const getAppTransactionIOS = (): Promise<AppTransactionIOS | null> => {
+export const getAppTransactionIOS = (): Promise<AppTransaction | null> => {
   return ExpoIapModule.getAppTransactionIOS();
 };
 

package/src/purchase-error.ts

@@ -0,0 +1,268 @@
+import {NATIVE_ERROR_CODES} from './ExpoIapModule';
+import {ErrorCode, Platform} from './types';
+
+/** Platform identifiers supported by {@link PurchaseError}. */
+export type PurchaseErrorPlatform = Platform | 'ios' | 'android';
+
+/** Properties used to construct a {@link PurchaseError}. */
+export interface PurchaseErrorProps {
+  message: string;
+  responseCode?: number;
+  debugMessage?: string;
+  code?: ErrorCode;
+  productId?: string;
+  platform?: PurchaseErrorPlatform;
+}
+
+/** Shape of raw platform error objects coming from native modules. */
+type PlatformErrorData = {
+  code?: string | number;
+  message?: string;
+  responseCode?: number;
+  debugMessage?: string;
+  productId?: string;
+};
+
+const toStandardizedCode = (errorCode: ErrorCode): string =>
+  errorCode.startsWith('E_') ? errorCode : `E_${errorCode}`;
+
+const normalizePlatform = (
+  platform: PurchaseErrorPlatform,
+): 'ios' | 'android' =>
+  platform === Platform.Ios || platform === 'ios' ? 'ios' : 'android';
+
+const OPENIAP_ERROR_CODE_SET: Set<string> = new Set(
+  Object.values(ErrorCode).map((code) => toStandardizedCode(code)),
+);
+
+const COMMON_ERROR_CODE_MAP: Record<ErrorCode, string> = {
+  [ErrorCode.Unknown]: toStandardizedCode(ErrorCode.Unknown),
+  [ErrorCode.UserCancelled]: toStandardizedCode(ErrorCode.UserCancelled),
+  [ErrorCode.UserError]: toStandardizedCode(ErrorCode.UserError),
+  [ErrorCode.ItemUnavailable]: toStandardizedCode(ErrorCode.ItemUnavailable),
+  [ErrorCode.RemoteError]: toStandardizedCode(ErrorCode.RemoteError),
+  [ErrorCode.NetworkError]: toStandardizedCode(ErrorCode.NetworkError),
+  [ErrorCode.ServiceError]: toStandardizedCode(ErrorCode.ServiceError),
+  [ErrorCode.ReceiptFailed]: toStandardizedCode(ErrorCode.ReceiptFailed),
+  [ErrorCode.ReceiptFinished]: toStandardizedCode(ErrorCode.ReceiptFinished),
+  [ErrorCode.ReceiptFinishedFailed]: toStandardizedCode(
+    ErrorCode.ReceiptFinishedFailed,
+  ),
+  [ErrorCode.NotPrepared]: toStandardizedCode(ErrorCode.NotPrepared),
+  [ErrorCode.NotEnded]: toStandardizedCode(ErrorCode.NotEnded),
+  [ErrorCode.AlreadyOwned]: toStandardizedCode(ErrorCode.AlreadyOwned),
+  [ErrorCode.DeveloperError]: toStandardizedCode(ErrorCode.DeveloperError),
+  [ErrorCode.BillingResponseJsonParseError]: toStandardizedCode(
+    ErrorCode.BillingResponseJsonParseError,
+  ),
+  [ErrorCode.DeferredPayment]: toStandardizedCode(ErrorCode.DeferredPayment),
+  [ErrorCode.Interrupted]: toStandardizedCode(ErrorCode.Interrupted),
+  [ErrorCode.IapNotAvailable]: toStandardizedCode(ErrorCode.IapNotAvailable),
+  [ErrorCode.PurchaseError]: toStandardizedCode(ErrorCode.PurchaseError),
+  [ErrorCode.SyncError]: toStandardizedCode(ErrorCode.SyncError),
+  [ErrorCode.TransactionValidationFailed]: toStandardizedCode(
+    ErrorCode.TransactionValidationFailed,
+  ),
+  [ErrorCode.ActivityUnavailable]: toStandardizedCode(
+    ErrorCode.ActivityUnavailable,
+  ),
+  [ErrorCode.AlreadyPrepared]: toStandardizedCode(ErrorCode.AlreadyPrepared),
+  [ErrorCode.Pending]: toStandardizedCode(ErrorCode.Pending),
+  [ErrorCode.ConnectionClosed]: toStandardizedCode(ErrorCode.ConnectionClosed),
+  [ErrorCode.InitConnection]: toStandardizedCode(ErrorCode.InitConnection),
+  [ErrorCode.ServiceDisconnected]: toStandardizedCode(
+    ErrorCode.ServiceDisconnected,
+  ),
+  [ErrorCode.QueryProduct]: toStandardizedCode(ErrorCode.QueryProduct),
+  [ErrorCode.SkuNotFound]: toStandardizedCode(ErrorCode.SkuNotFound),
+  [ErrorCode.SkuOfferMismatch]: toStandardizedCode(ErrorCode.SkuOfferMismatch),
+  [ErrorCode.ItemNotOwned]: toStandardizedCode(ErrorCode.ItemNotOwned),
+  [ErrorCode.BillingUnavailable]: toStandardizedCode(
+    ErrorCode.BillingUnavailable,
+  ),
+  [ErrorCode.FeatureNotSupported]: toStandardizedCode(
+    ErrorCode.FeatureNotSupported,
+  ),
+  [ErrorCode.EmptySkuList]: toStandardizedCode(ErrorCode.EmptySkuList),
+};
+
+/**
+ * Mapping between platforms and their canonical error codes.
+ * Values are platform-native string identifiers.
+ */
+export const ErrorCodeMapping = {
+  ios: COMMON_ERROR_CODE_MAP,
+  android: COMMON_ERROR_CODE_MAP,
+} as const;
+
+/**
+ * Error thrown by expo-iap when purchases fail.
+ */
+export class PurchaseError extends Error {
+  public responseCode?: number;
+  public debugMessage?: string;
+  public code?: ErrorCode;
+  public productId?: string;
+  public platform?: PurchaseErrorPlatform;
+
+  constructor(
+    message: string,
+    responseCode?: number,
+    debugMessage?: string,
+    code?: ErrorCode,
+    productId?: string,
+    platform?: PurchaseErrorPlatform,
+  );
+  constructor(props: PurchaseErrorProps);
+  constructor(
+    messageOrProps: string | PurchaseErrorProps,
+    responseCode?: number,
+    debugMessage?: string,
+    code?: ErrorCode,
+    productId?: string,
+    platform?: PurchaseErrorPlatform,
+  ) {
+    super(
+      typeof messageOrProps === 'string'
+        ? messageOrProps
+        : messageOrProps.message,
+    );
+    this.name = '[expo-iap]: PurchaseError';
+    Object.setPrototypeOf(this, new.target.prototype);
+
+    if (typeof messageOrProps === 'string') {
+      this.responseCode = responseCode;
+      this.debugMessage = debugMessage;
+      this.code = code;
+      this.productId = productId;
+      this.platform = platform;
+    } else {
+      this.responseCode = messageOrProps.responseCode;
+      this.debugMessage = messageOrProps.debugMessage;
+      this.code = messageOrProps.code;
+      this.productId = messageOrProps.productId;
+      this.platform = messageOrProps.platform;
+    }
+  }
+
+  /**
+   * Create a {@link PurchaseError} from raw platform error data.
+   */
+  static fromPlatformError(
+    errorData: PlatformErrorData,
+    platform: PurchaseErrorPlatform,
+  ): PurchaseError {
+    const normalizedPlatform = normalizePlatform(platform);
+
+    const errorCode = errorData.code
+      ? ErrorCodeUtils.fromPlatformCode(errorData.code, normalizedPlatform)
+      : ErrorCode.Unknown;
+
+    return new PurchaseError({
+      message: errorData.message ?? 'Unknown error occurred',
+      responseCode: errorData.responseCode,
+      debugMessage: errorData.debugMessage,
+      code: errorCode,
+      productId: errorData.productId,
+      platform,
+    });
+  }
+
+  /**
+   * Returns the platform specific error code for this instance.
+   */
+  getPlatformCode(): string | number | undefined {
+    if (!this.code || !this.platform) {
+      return undefined;
+    }
+    return ErrorCodeUtils.toPlatformCode(this.code, this.platform);
+  }
+}
+
+/** Utility helpers for translating error codes between platforms. */
+export const ErrorCodeUtils = {
+  /**
+   * Returns the native error code for the provided {@link ErrorCode}.
+   */
+  getNativeErrorCode: (errorCode: ErrorCode): string => {
+    const standardized = toStandardizedCode(errorCode);
+    return (
+      (NATIVE_ERROR_CODES as Record<string, string | undefined>)[
+        standardized
+      ] ?? standardized
+    );
+  },
+  /**
+   * Converts a platform-specific error code into a standardized {@link ErrorCode}.
+   */
+  fromPlatformCode: (
+    platformCode: string | number,
+    _platform: PurchaseErrorPlatform,
+  ): ErrorCode => {
+    if (typeof platformCode === 'string' && platformCode.startsWith('E_')) {
+      if (OPENIAP_ERROR_CODE_SET.has(platformCode)) {
+        const match = Object.entries(COMMON_ERROR_CODE_MAP).find(
+          ([, value]) => value === platformCode,
+        );
+        if (match) {
+          return match[0] as ErrorCode;
+        }
+      }
+    }
+
+    for (const [standardized, nativeCode] of Object.entries(
+      (NATIVE_ERROR_CODES || {}) as Record<string, string | number>,
+    )) {
+      if (
+        nativeCode === platformCode &&
+        OPENIAP_ERROR_CODE_SET.has(standardized)
+      ) {
+        const match = Object.entries(COMMON_ERROR_CODE_MAP).find(
+          ([, mappedCode]) => mappedCode === standardized,
+        );
+        if (match) {
+          return match[0] as ErrorCode;
+        }
+      }
+    }
+
+    for (const [errorCode, mappedCode] of Object.entries(
+      COMMON_ERROR_CODE_MAP,
+    )) {
+      if (mappedCode === platformCode) {
+        return errorCode as ErrorCode;
+      }
+    }
+
+    return ErrorCode.Unknown;
+  },
+  /**
+   * Converts a standardized {@link ErrorCode} into its platform-specific value.
+   */
+  toPlatformCode: (
+    errorCode: ErrorCode,
+    _platform: PurchaseErrorPlatform,
+  ): string | number => {
+    const standardized = toStandardizedCode(errorCode);
+    const native = (NATIVE_ERROR_CODES as Record<string, string | number>)[
+      standardized
+    ];
+    return native ?? COMMON_ERROR_CODE_MAP[errorCode] ?? 'E_UNKNOWN';
+  },
+  /**
+   * Determines whether the error code is supported on the given platform.
+   */
+  isValidForPlatform: (
+    errorCode: ErrorCode,
+    platform: PurchaseErrorPlatform,
+  ): boolean => {
+    const standardized = toStandardizedCode(errorCode);
+    if (
+      (NATIVE_ERROR_CODES as Record<string, unknown>)[standardized] !==
+      undefined
+    ) {
+      return true;
+    }
+    return standardized in ErrorCodeMapping[normalizePlatform(platform)];
+  },
+};