@jolibox/implement 1.2.4 → 1.2.5

package/src/native/payment/payment-service.ts

@@ -5,149 +5,81 @@ import { StandardResponse } from '@jolibox/types';
 import { applyNative } from '@jolibox/native-bridge';
 import { innerFetch as fetch } from '@/native/network';
 import type { PaymentResult } from './payment-helper';
+import { RequestCacheService, RequestAdapter } from '@/common/cache/request-cache-service';
 
 type PaymentPurchaseType = 'JOLI_COIN' | 'JOLI_GEM';
 
-const CoinFetchUrlMap: Record<PaymentPurchaseType, string> = {
-  JOLI_COIN: '/api/joli-coin/balance-detail',
-  JOLI_GEM: '/api/joli-gem/balance-detail'
-};
+// Request/Response interfaces for RequestCacheService
 
-// 缓存数据接口
-export interface CachedPaymentChoices {
-  choices: IPaymentChoice[];
-  timestamp: number;
-  expiresAt: number;
-  productIds: string[];
-}
+type PaymentRequest = Record<string, never>;
 
-export class PaymentService {
-  private productInfoCache: Record<PaymentPurchaseType, IPaymentChoice[]> = {
-    JOLI_COIN: [],
-    JOLI_GEM: []
-  };
+interface PaymentResponse {
+  balance: number;
+  enableAutoDeduct: boolean;
+  paymentChoices: IPaymentChoice[];
+}
 
-  // 新增：paymentChoices 缓存
-  private static paymentChoicesCache = new Map<string, CachedPaymentChoices>();
-  private static readonly PAYMENT_CHOICES_CACHE_DURATION = 10 * 60 * 1000; // 10分钟缓存
+interface PaymentCacheData {
+  paymentChoices: IPaymentChoice[];
+}
 
-  async getJolicoinProductsInfo(type: PaymentPurchaseType) {
-    if (this.productInfoCache[type].length > 0) {
-      return this.productInfoCache[type];
-    }
-    const productsInfo = await PaymentService.getProductsInfo(CoinFetchUrlMap[type]);
-    this.productInfoCache[type] = productsInfo?.paymentChoices ?? [];
-    return this.productInfoCache[type];
-  }
+interface PaymentRealTimeData {
+  balance: number;
+  enableAutoDeduct: boolean;
+}
 
-  async purchase(type: PaymentPurchaseType, productId: string) {
-    const productsInfo = await this.getJolicoinProductsInfo(type);
-    const appStoreProductId = productsInfo.find(
-      (choice) => choice.productId === productId
-    )?.appStoreProductId;
-    if (!appStoreProductId) {
-      throw new Error('appStoreProductId not found');
+// Utility function for merging response data
+function mergeResponseData(
+  responseData: { paymentChoices: IPaymentChoice[] },
+  data: { [appStoreProductId: string]: { price: string } }
+) {
+  Object.keys(data).forEach((key) => {
+    const choice = responseData.paymentChoices.find((choice) => choice.appStoreProductId === key);
+    if (choice) {
+      choice.totalAmountStr = data[key].price;
     }
+  });
 
-    const result = (await paymentHelper.invokePayment(
-      type === 'JOLI_COIN' ? 'JOLI_COIN_IAP' : 'JOLI_GEM_IAP',
-      {
-        productId,
-        appStoreProductId
-      }
-    )) as PaymentResult<{ totalAmount: string }>;
-
-    return result;
-  }
-
-  private static mergeResponseData(
-    responseData: { paymentChoices: IPaymentChoice[] },
-    data: { [appStoreProductId: string]: { price: string } }
-  ) {
-    Object.keys(data).forEach((key) => {
-      const choice = responseData.paymentChoices.find((choice) => choice.appStoreProductId === key);
-      if (choice) {
-        choice.totalAmountStr = data[key].price;
-      }
-    });
-
-    responseData.paymentChoices = responseData.paymentChoices.filter(
-      (choice) => !isUndefinedOrNull(choice.totalAmountStr)
-    ) as IPaymentChoice[];
-  }
-
-  static async getProductsInfo(apiEndpoint: string): Promise<
-    | {
-        balance: number;
-        enableAutoDeduct: boolean;
-        paymentChoices: IPaymentChoice[];
-      }
-    | undefined
-  > {
-    return Promise.race([
-      this.getProductsInfoInternal(apiEndpoint),
-      new Promise<never>((_, reject) => {
-        setTimeout(() => {
-          reject(new Error('[PaymentService] Request timeout after 3 seconds'));
-        }, 3000);
-      })
-    ]);
-  }
+  responseData.paymentChoices = responseData.paymentChoices.filter(
+    (choice) => !isUndefinedOrNull(choice.totalAmountStr)
+  ) as IPaymentChoice[];
+}
 
-  private static async getProductsInfoInternal(apiEndpoint: string): Promise<
-    | {
-        balance: number;
-        enableAutoDeduct: boolean;
-        paymentChoices: IPaymentChoice[];
-      }
-    | undefined
-  > {
-    // 首先获取服务端数据（余额等实时数据）
-    const { response } = await fetch<
-      StandardResponse<{
-        balance: number;
-        enableAutoDeduct: boolean;
-        paymentChoices: IPaymentChoice[];
-      }>
-    >(apiEndpoint, {
+// Payment Request Adapter for RequestCacheService
+class PaymentRequestAdapter
+  implements RequestAdapter<PaymentRequest, PaymentResponse, PaymentCacheData, PaymentRealTimeData>
+{
+  // applyNative 的缓存
+  private static nativePriceCache = new Map<string, { [appStoreProductId: string]: { price: string } }>();
+  private static readonly NATIVE_PRICE_CACHE_DURATION = 30 * 60 * 1000; // 30分钟缓存
+  private static nativePriceCacheTimestamp = new Map<string, number>();
+
+  async execute(endpoint: string, _options?: PaymentRequest): Promise<PaymentResponse> {
+    // 获取服务端数据（余额等实时数据）
+    const { response } = await fetch<StandardResponse<PaymentResponse>>(endpoint, {
       method: 'GET',
       appendHostCookie: true,
       responseType: 'json'
     });
 
+    console.log('[PaymentService] get products info from server', endpoint, response.data);
+
     if (!response.data?.data) {
       throw new Error('get products info failed');
     }
 
     const serverData = response.data.data;
 
-    // 检查 paymentChoices 缓存
-    const cachedChoices = this.getPaymentChoicesFromCache(apiEndpoint, serverData.paymentChoices);
-
-    if (cachedChoices) {
-      console.log('[PaymentService] Using cached paymentChoices');
-
-      // 使用缓存的 paymentChoices，但保持服务端的余额等实时数据
-      return {
-        balance: serverData.balance,
-        enableAutoDeduct: serverData.enableAutoDeduct,
-        paymentChoices: cachedChoices
-      };
-    }
-
-    console.log('[PaymentService] Fetching fresh paymentChoices from native');
-
-    // 缓存未命中，请求原生数据
-    const { data } = await applyNative('requestProductDetailsAsync', {
-      appStoreProductIds:
-        serverData.paymentChoices
-          ?.filter((choice) => typeof choice.appStoreProductId === 'string')
-          .map((choice) => choice.appStoreProductId as string) ?? []
-    });
+    const appStoreProductIds =
+      serverData.paymentChoices
+        ?.filter((choice) => typeof choice.appStoreProductId === 'string')
+        .map((choice) => choice.appStoreProductId as string) ?? [];
 
-    if (data) {
-      this.mergeResponseData(serverData, data);
-      this.cachePaymentChoices(apiEndpoint, serverData.paymentChoices);
+    if (appStoreProductIds.length > 0) {
+      const nativeData = await this.getNativePriceData(appStoreProductIds);
+      if (nativeData) {
+        mergeResponseData(serverData, nativeData);
+      }
     }
 
     if (serverData.paymentChoices.length === 0) {
@@ -157,123 +89,205 @@ export class PaymentService {
     return serverData;
   }
 
-  // read paymentChoices from cache
-  private static getPaymentChoicesFromCache(
-    apiEndpoint: string,
-    serverChoices: IPaymentChoice[]
-  ): IPaymentChoice[] | null {
-    const cached = this.paymentChoicesCache.get(apiEndpoint);
-
-    if (!cached) {
-      return null;
+  private async getNativePriceData(
+    appStoreProductIds: string[]
+  ): Promise<{ [appStoreProductId: string]: { price: string } } | null> {
+    // 检查缓存
+    const cacheKey = appStoreProductIds.sort().join(',');
+    const cached = PaymentRequestAdapter.nativePriceCache.get(cacheKey);
+    const cacheTime = PaymentRequestAdapter.nativePriceCacheTimestamp.get(cacheKey) || 0;
+
+    if (cached && Date.now() - cacheTime < PaymentRequestAdapter.NATIVE_PRICE_CACHE_DURATION) {
+      console.log('[PaymentService] Using cached native price data');
+      return cached;
     }
 
-    if (Date.now() > cached.expiresAt) {
-      this.paymentChoicesCache.delete(apiEndpoint);
-      return null;
-    }
+    console.log('[PaymentService] Fetching fresh native price data');
+
+    try {
+      const { data } = await applyNative('requestProductDetailsAsync', {
+        appStoreProductIds
+      });
 
-    const serverProductIds = this.extractProductIds(serverChoices);
-    const cachedProductIds = cached.productIds;
+      if (data) {
+        // cache
+        PaymentRequestAdapter.nativePriceCache.set(cacheKey, data);
+        PaymentRequestAdapter.nativePriceCacheTimestamp.set(cacheKey, Date.now());
+      }
 
-    if (!this.arraysEqual(serverProductIds, cachedProductIds)) {
-      console.log('[PaymentService] Server paymentChoices changed, invalidating cache');
-      this.paymentChoicesCache.delete(apiEndpoint);
-      return null;
+      return data;
+    } catch (error) {
+      console.warn('[PaymentService] Failed to fetch native product details:', error);
+      throw error; // rethrow error, let upper layer handle it
     }
+  }
 
-    const updatedChoices = this.updateChoicesWithServerData(cached.choices, serverChoices);
+  extractCacheableData(response: PaymentResponse): PaymentCacheData {
+    return {
+      paymentChoices: response.paymentChoices
+    };
+  }
 
-    return updatedChoices;
+  extractRealTimeData?: undefined;
+  mergeData(cached: PaymentCacheData, realTime: PaymentRealTimeData): PaymentResponse {
+    return {
+      balance: realTime.balance,
+      enableAutoDeduct: realTime.enableAutoDeduct,
+      paymentChoices: cached.paymentChoices
+    };
   }
 
-  private static cachePaymentChoices(apiEndpoint: string, choices: IPaymentChoice[]): void {
-    this.paymentChoicesCache.set(apiEndpoint, {
-      choices: JSON.parse(JSON.stringify(choices)), // deep copy
-      timestamp: Date.now(),
-      expiresAt: Date.now() + this.PAYMENT_CHOICES_CACHE_DURATION,
-      productIds: this.extractProductIds(choices)
-    });
+  processCachedData(cached: PaymentCacheData): PaymentResponse {
+    // when only cached data is available, use default real-time data values
+    return {
+      balance: 0, // default balance
+      enableAutoDeduct: false, // default not enable auto deduct
+      paymentChoices: cached.paymentChoices
+    };
+  }
 
-    console.log(`[PaymentService] Cached ${choices.length} payment choices for ${apiEndpoint}`);
+  // clear native price cache static method
+  static clearNativePriceCache(): void {
+    this.nativePriceCache.clear();
+    this.nativePriceCacheTimestamp.clear();
+    console.log('[PaymentService] Cleared native price cache');
   }
+}
 
-  private static extractProductIds(choices: IPaymentChoice[]): string[] {
-    return choices
-      .map((choice) => choice.productId)
-      .filter(Boolean)
-      .sort();
+// Base Payment Service class
+class BasePaymentService extends RequestCacheService<
+  PaymentRequest,
+  PaymentResponse,
+  PaymentCacheData,
+  PaymentRealTimeData
+> {
+  // 失败计数器，按 endpoint 统计
+  private static failureCounters = new Map<string, number>();
+  private static readonly MAX_FAILURE_COUNT = 2;
+
+  constructor(private apiEndpoint: string, private paymentType: PaymentPurchaseType) {
+    super(new PaymentRequestAdapter(), {
+      duration: 10 * 60 * 1000, // 10分钟缓存 paymentChoices
+      timeout: 1000 // 1秒超时
+    });
   }
 
-  private static arraysEqual(arr1: string[], arr2: string[]): boolean {
-    if (arr1.length !== arr2.length) {
-      return false;
+  async getProductsInfo(): Promise<PaymentResponse | undefined> {
+    // 检查失败计数，如果达到最大失败次数则直接抛出错误
+    const currentFailureCount = BasePaymentService.failureCounters.get(this.apiEndpoint) || 0;
+    if (currentFailureCount >= BasePaymentService.MAX_FAILURE_COUNT) {
+      throw new Error(
+        `getProductsInfo has failed more than ${BasePaymentService.MAX_FAILURE_COUNT} times for ${this.apiEndpoint}`
+      );
     }
 
-    return arr1.every((item, index) => item === arr2[index]);
+    try {
+      const result = await this.request(this.apiEndpoint);
+      // 成功时重置失败计数器
+      BasePaymentService.failureCounters.delete(this.apiEndpoint);
+      return result;
+    } catch (error) {
+      // 失败时增加计数器
+      const newCount = currentFailureCount + 1;
+      BasePaymentService.failureCounters.set(this.apiEndpoint, newCount);
+      console.warn(
+        `[PaymentService] getProductsInfo failed (${newCount}/${
+          BasePaymentService.MAX_FAILURE_COUNT + 1
+        }) for ${this.apiEndpoint}:`,
+        error
+      );
+      throw error;
+    }
   }
 
-  private static updateChoicesWithServerData(
-    cachedChoices: IPaymentChoice[],
-    serverChoices: IPaymentChoice[]
-  ): IPaymentChoice[] {
-    const serverChoiceMap = new Map(serverChoices.map((choice) => [choice.productId, choice]));
-
-    return cachedChoices.map((cachedChoice) => {
-      const serverChoice = serverChoiceMap.get(cachedChoice.productId);
+  async purchase(productId: string): Promise<PaymentResult<{ totalAmount: string }>> {
+    const productsInfo = await this.getProductsInfo();
+    const appStoreProductId = productsInfo?.paymentChoices.find(
+      (choice) => choice.productId === productId
+    )?.appStoreProductId;
+    if (!appStoreProductId) {
+      throw new Error('appStoreProductId not found');
+    }
 
-      if (serverChoice) {
-        return {
-          ...cachedChoice,
-          quantity: serverChoice.quantity
-        };
+    const result = (await paymentHelper.invokePayment(
+      this.paymentType === 'JOLI_COIN' ? 'JOLI_COIN_IAP' : 'JOLI_GEM_IAP',
+      {
+        productId,
+        appStoreProductId
       }
+    )) as PaymentResult<{ totalAmount: string }>;
 
-      return cachedChoice;
-    });
+    return result;
   }
 
-  // clear paymentChoices cache
-  public static clearPaymentChoicesCache(apiEndpoint?: string): void {
-    if (apiEndpoint) {
-      this.paymentChoicesCache.delete(apiEndpoint);
-      console.log(`[PaymentService] Cleared cache for ${apiEndpoint}`);
-    } else {
-      this.paymentChoicesCache.clear();
-      console.log('[PaymentService] Cleared all payment choices cache');
-    }
+  // 获取产品信息（使用 RequestCacheService）
+  async getProductsInfoWithBalance(): Promise<PaymentResponse | undefined> {
+    return this.request(this.apiEndpoint);
   }
 
-  public static getPaymentChoicesCacheStats(): {
-    cacheCount: number;
-    validCount: number;
-    expiredCount: number;
-  } {
-    const now = Date.now();
-    let validCount = 0;
-    let expiredCount = 0;
-
-    for (const cached of this.paymentChoicesCache.values()) {
-      if (now > cached.expiresAt) {
-        expiredCount++;
-      } else {
-        validCount++;
-      }
-    }
+  // 强制刷新产品信息
+  async refreshProductsInfo(): Promise<PaymentResponse | undefined> {
+    return this.forceRequest(this.apiEndpoint);
+  }
 
-    return {
-      cacheCount: this.paymentChoicesCache.size,
-      validCount,
-      expiredCount
-    };
+  // 重置失败计数器（供测试使用）
+  static resetFailureCounters(): void {
+    this.failureCounters.clear();
   }
 
-  public static clearExpiredPaymentChoicesCache(): void {
-    const now = Date.now();
-    for (const [key, cached] of this.paymentChoicesCache) {
-      if (now > cached.expiresAt) {
-        this.paymentChoicesCache.delete(key);
-      }
-    }
+  // 获取失败计数器状态（供测试使用）
+  static getFailureCount(endpoint: string): number {
+    return this.failureCounters.get(endpoint) || 0;
+  }
+}
+
+// JOLI_COIN payment service
+export class JoliCoinPaymentService extends BasePaymentService {
+  constructor() {
+    super('/api/joli-coin/balance-detail', 'JOLI_COIN');
+  }
+}
+
+// JOLI_GEM payment service
+export class JoliGemPaymentService extends BasePaymentService {
+  constructor() {
+    super('/api/joli-gem/balance-detail', 'JOLI_GEM');
   }
 }
+
+// service instance management
+let joliCoinServiceInstance: JoliCoinPaymentService | null = null;
+let joliGemServiceInstance: JoliGemPaymentService | null = null;
+
+// create JOLI_COIN payment service instance
+export const createJoliCoinPaymentService = (): JoliCoinPaymentService => {
+  if (joliCoinServiceInstance) {
+    return joliCoinServiceInstance;
+  }
+  joliCoinServiceInstance = new JoliCoinPaymentService();
+  return joliCoinServiceInstance;
+};
+
+// create JOLI_GEM payment service instance
+export const createJoliGemPaymentService = (): JoliGemPaymentService => {
+  if (joliGemServiceInstance) {
+    return joliGemServiceInstance;
+  }
+  joliGemServiceInstance = new JoliGemPaymentService();
+  return joliGemServiceInstance;
+};
+
+// 导出原生价格缓存清理方法供测试使用
+export const clearNativePriceCache = (): void => {
+  PaymentRequestAdapter.clearNativePriceCache();
+};
+
+// 导出失败计数器重置方法供测试使用
+export const resetFailureCounters = (): void => {
+  BasePaymentService.resetFailureCounters();
+};
+
+// 导出获取失败计数方法供测试使用
+export const getFailureCount = (endpoint: string): number => {
+  return BasePaymentService.getFailureCount(endpoint);
+};

package/src/native/rewards/ui/payment-modal.ts

@@ -28,7 +28,7 @@ import { track } from '@/native/report';
 import { updateAutoDeductConfig } from './utils';
 import { createEventPromiseHandler } from '@/common/rewards/registers/utils/event-listener';
 import { TrackEvent } from '@jolibox/types';
-import { PaymentService } from '@/native/payment/payment-service';
+import { createJoliCoinPaymentService, createJoliGemPaymentService } from '@/native/payment/payment-service';
 
 // 货币配置映射
 interface CurrencyPaymentConfig {
@@ -85,6 +85,9 @@ const CURRENCY_PAYMENT_CONFIG: Record<'JOLI_COIN' | 'JOLI_GEM', CurrencyPaymentC
 
 const loading = createLoading();
 
+const JoliCoinPaymentService = createJoliCoinPaymentService();
+const JoliGemPaymentService = createJoliGemPaymentService();
+
 const modalUseFrequencyConfig = createEventPromiseHandler<
   IUseModalFrequencyConfig,
   typeof UseModalFrequencyEventName
@@ -114,6 +117,7 @@ rewardsEmitter.on(
         await loading.show({
           duration: 3000
         });
+
         const config = await modalUseFrequencyConfig.getData();
         const { canShow: canShowPaymentModal } = await paymentConfig.frequencyChecker(
           config.joliCoinUseAndCharge[paymentConfig.frequencyConfigKey]
@@ -134,7 +138,9 @@ rewardsEmitter.on(
       await loading.show({
         duration: 3000
       });
-      const balenceDetails = await PaymentService.getProductsInfo(paymentConfig.apiEndpoint);
+      const paymentService = currencyType === 'JOLI_COIN' ? JoliCoinPaymentService : JoliGemPaymentService;
+      // get product info from cache, if not found, get from server and cache it
+      const balenceDetails = await paymentService.getProductsInfo();
       loading.hide();
 
       if (!balenceDetails) {
@@ -158,7 +164,7 @@ rewardsEmitter.on(
               ...choice,
               totalAmountStr: choice.totalAmountStr ?? ''
             })) ?? [],
-          enableAutoDeduct: balenceDetails.enableAutoDeduct
+          enableAutoDeduct: params.enableAutoDeduct
         },
         buttons: {
           confirm: {
@@ -183,8 +189,8 @@ rewardsEmitter.on(
                   return;
                 }
 
-                const balenceDetails = await PaymentService.getProductsInfo(paymentConfig.apiEndpoint);
-                if ((balenceDetails?.balance ?? 0) >= params.quantity) {
+                const newBalence = await paymentService.refreshProductsInfo();
+                if ((newBalence?.balance ?? 0) >= params.quantity) {
                   rewardsEmitter.emit(PaymentResultEventName, {
                     paymentResult: 'SUCCESS',
                     currency: currencyType
@@ -193,6 +199,7 @@ rewardsEmitter.on(
                   return;
                 }
               }
+              // invoke native payment
               console.log('invokeNativePayment', productId);
               const appStoreProductId = balenceDetails?.paymentChoices?.find(
                 (choice) => choice.productId === productId
@@ -280,9 +287,9 @@ rewardsEmitter.on(
 
 /** preload payment details */
 
-PaymentService.getProductsInfo(CURRENCY_PAYMENT_CONFIG.JOLI_COIN.apiEndpoint).catch((e) => {
+JoliCoinPaymentService.getProductsInfo().catch((e) => {
   console.error('preload joli coin payment details failed', e);
 });
-PaymentService.getProductsInfo(CURRENCY_PAYMENT_CONFIG.JOLI_GEM.apiEndpoint).catch((e) => {
+JoliGemPaymentService.getProductsInfo().catch((e) => {
   console.error('preload joli gem payment details failed', e);
 });