expo-iap 3.0.3 → 3.0.4

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)];
+  },
+};