@jolibox/implement 1.2.4 → 1.2.5

package/src/common/rewards/registers/utils/coins/joligem/cached-fetch-gem-balance.ts

@@ -0,0 +1,181 @@
+import { RequestCacheService, RequestAdapter } from '@/common/cache/request-cache-service';
+import { IHttpClient } from '@/common/http';
+import { StandardResponse } from '@jolibox/types';
+
+interface GemBalanceRequest {
+  endpoint: string;
+  query?: Record<string, unknown>;
+  method?: 'GET' | 'POST';
+}
+
+// 定义宝石余额响应类型
+interface GemBalanceResponse {
+  balance: number;
+}
+
+interface GemBalanceCacheData {
+  balance: number;
+  timestamp: number;
+}
+
+class GemBalanceRequestAdapter
+  implements
+    RequestAdapter<GemBalanceRequest, StandardResponse<GemBalanceResponse>, GemBalanceCacheData, undefined>
+{
+  constructor(private httpClient: IHttpClient) {}
+
+  async execute(
+    endpoint: string,
+    options?: GemBalanceRequest
+  ): Promise<StandardResponse<GemBalanceResponse>> {
+    const method = options?.method || 'GET';
+    const query = options?.query || {};
+
+    if (method === 'GET') {
+      return await this.httpClient.get<StandardResponse<GemBalanceResponse>>(endpoint, {
+        query: query as Record<string, string>
+      });
+    } else {
+      return await this.httpClient.post<StandardResponse<GemBalanceResponse>>(endpoint, {
+        query: query as Record<string, string>
+      });
+    }
+  }
+
+  extractCacheableData(response: StandardResponse<GemBalanceResponse>): GemBalanceCacheData {
+    return {
+      balance: response.data?.balance || 0,
+      timestamp: Date.now()
+    };
+  }
+
+  // 宝石余额使用纯缓存模式
+  extractRealTimeData?: undefined;
+  mergeData?: undefined;
+
+  processCachedData(cached: GemBalanceCacheData): StandardResponse<GemBalanceResponse> {
+    return {
+      code: 'SUCCESS',
+      message: 'success from cache',
+      data: {
+        balance: cached.balance
+      }
+    };
+  }
+}
+
+// 缓存宝石余额服务
+export class CachedGemBalanceService {
+  private gemBalanceService: RequestCacheService<
+    GemBalanceRequest,
+    StandardResponse<GemBalanceResponse>,
+    GemBalanceCacheData,
+    undefined
+  >;
+
+  constructor(httpClient: IHttpClient) {
+    this.gemBalanceService = new (RequestCacheService as new (...args: unknown[]) => RequestCacheService<
+      GemBalanceRequest,
+      StandardResponse<GemBalanceResponse>,
+      GemBalanceCacheData,
+      undefined
+    >)(new GemBalanceRequestAdapter(httpClient), {
+      duration: 20 * 60 * 1000, // 20分钟缓存（宝石余额变化较少）
+      timeout: 1000, // 1s timeout for request
+      keyGenerator: (endpoint: string, params?: GemBalanceRequest) => {
+        const queryStr = params?.query ? JSON.stringify(params.query) : '';
+        return `${endpoint}:${queryStr}`;
+      }
+    });
+  }
+
+  async getGemBalance(type = 'GEM'): Promise<GemBalanceResponse | undefined> {
+    const response = await this.gemBalanceService.request('/api/joli-gem/balance', {
+      endpoint: '/api/joli-gem/balance',
+      query: { type },
+      method: 'GET'
+    });
+    return response.data;
+  }
+
+  async refreshGemBalance(type = 'GEM'): Promise<GemBalanceResponse | undefined> {
+    const response = await this.gemBalanceService.forceRequest('/api/joli-gem/balance', {
+      endpoint: '/api/joli-gem/balance',
+      query: { type },
+      method: 'GET'
+    });
+    return response.data;
+  }
+
+  async warmupGemBalance(type = 'GEM'): Promise<void> {
+    await this.gemBalanceService.warmupCache('/api/joli-gem/balance', {
+      endpoint: '/api/joli-gem/balance',
+      query: { type },
+      method: 'GET'
+    });
+  }
+
+  clearGemBalanceCache(): void {
+    this.gemBalanceService.clearCache();
+  }
+
+  getGemBalanceCacheStats() {
+    return this.gemBalanceService.getCacheStats();
+  }
+
+  clearExpiredCache(): void {
+    this.gemBalanceService.clearExpiredCache();
+  }
+}
+
+// create instance
+let cachedGemBalanceServiceInstance: CachedGemBalanceService | null = null;
+
+function getCachedGemBalanceService(httpClient: IHttpClient): CachedGemBalanceService {
+  if (!cachedGemBalanceServiceInstance) {
+    cachedGemBalanceServiceInstance = new CachedGemBalanceService(httpClient);
+  }
+  return cachedGemBalanceServiceInstance;
+}
+
+/**
+ * 缓存版本的 fetchGemBalance 函数
+ */
+export const fetchGemBalanceCached = async (httpClient: IHttpClient, type = 'GEM') => {
+  const cachedGemBalanceService = getCachedGemBalanceService(httpClient);
+  return await cachedGemBalanceService.getGemBalance(type);
+};
+
+/**
+ * 强制刷新宝石余额缓存
+ */
+export const refreshGemBalanceCache = async (httpClient: IHttpClient, type = 'GEM') => {
+  const cachedGemBalanceService = getCachedGemBalanceService(httpClient);
+  const result = await cachedGemBalanceService.refreshGemBalance(type);
+  console.log(`Gem balance cache refreshed for type: ${type}`);
+  return result;
+};
+
+/**
+ * 预热宝石余额缓存
+ */
+export const warmupGemBalanceCache = async (httpClient: IHttpClient, type = 'GEM') => {
+  const cachedGemBalanceService = getCachedGemBalanceService(httpClient);
+  await cachedGemBalanceService.warmupGemBalance(type);
+  console.log(`Gem balance cache warmed up for type: ${type}`);
+};
+
+export const clearGemBalanceCache = (httpClient: IHttpClient) => {
+  const cachedGemBalanceService = getCachedGemBalanceService(httpClient);
+  cachedGemBalanceService.clearGemBalanceCache();
+  console.log('Gem balance cache cleared');
+};
+
+export const getGemBalanceCacheStats = (httpClient: IHttpClient) => {
+  const cachedGemBalanceService = getCachedGemBalanceService(httpClient);
+  return cachedGemBalanceService.getGemBalanceCacheStats();
+};
+
+export const getGemBalanceCacheService = (httpClient: IHttpClient): CachedGemBalanceService => {
+  return getCachedGemBalanceService(httpClient);
+};

package/src/common/rewards/registers/utils/coins/joligem/fetch-gem-balance.ts

@@ -1,7 +1,19 @@
 import { IHttpClient } from '@/common/http';
 import { StandardResponse } from '@jolibox/types';
 
-export const fetchGemBalance = async (httpClient: IHttpClient) => {
+// export cached version as default implementation
+export {
+  fetchGemBalanceCached as fetchGemBalance,
+  // 提供缓存管理功能
+  refreshGemBalanceCache,
+  warmupGemBalanceCache,
+  clearGemBalanceCache,
+  getGemBalanceCacheStats,
+  getGemBalanceCacheService
+} from './cached-fetch-gem-balance';
+
+// original version
+export const fetchGemBalanceNonCached = async (httpClient: IHttpClient) => {
   const res = await httpClient.get<
     StandardResponse<{
       balance: number;

package/src/common/rewards/registers/utils/coins/joligem/gem-handler.ts

@@ -15,6 +15,7 @@ import {
 import { registerUseJolicoinCommand, createShowUnlockWithCurrencyModal } from '../commands/use-jolicoin';
 import { rewardsCommands } from '../rewards-command';
 import { RewardsCommandType } from '@jolibox/types';
+import { refreshGemBalanceCache, warmupGemBalanceCache } from './cached-fetch-gem-balance';
 
 interface IGemUnlockRes {
   code: 'SUCCESS' | 'BALANCE_NOT_ENOUGH' | 'EPISODE_LOCK_JUMP' | 'EPISODE_UNLOCK_ALREADY';
@@ -103,6 +104,7 @@ export const createCommonGemRewardHandler = (
           if ('adViewed' in params) {
             params.adViewed?.();
           }
+          refreshGemBalanceCache(httpClient);
         } catch (e) {
           console.error('-----unlockWithGem adBreakDone error-----', e);
         }

package/src/h5/api/ads.ts

@@ -23,6 +23,8 @@ import HuaweiQuickAdsHandler from './platformAdsHandle/HuaweiQuickAdsHandler';
 import GamedistributionAdsHandler from './platformAdsHandle/GamedistributionAdsHandler';
 import FunmaxAdsHandler from './platformAdsHandle/FunmaxAdsHandler';
 import JoliboxAdsHandler from './platformAdsHandle/JoliboxAdsHandler';
+import { warmupRewardCache } from '@/common/rewards/fetch-reward';
+import { warmupBalanceCache, warmupGemBalanceCache } from '@/common/rewards';
 
 declare global {
   interface Window {
@@ -154,6 +156,9 @@ rewardsHelper.registerRewardHandler(
   }) as unknown as (params?: unknown) => Promise<boolean>
 );
 
+warmupRewardCache(httpClient);
+warmupBalanceCache(httpClient);
+
 adEventEmitter.on('isAdShowing', (isAdShowing) => {
   notifyCustomEvent('JOLIBOX_ADS_EVENT', { isAdShowing });
 });

package/src/h5/api/storage.ts

@@ -1,5 +1,5 @@
 import { createAPI, t, registerCanIUse } from './base';
-import { createCommands, getApiHost } from '@jolibox/common';
+import { createCommands, getH5ApiHost } from '@jolibox/common';
 import { httpClientManager } from '@/h5/http';
 import { context } from '@/common/context';
 import { StorageResponse } from '@jolibox/types';
@@ -10,7 +10,7 @@ const commands = createCommands();
 export class JoliboxCloudStorage {
   private gameId: string;
   private httpClient = httpClientManager.create({
-    baseUrl: getApiHost(context.testMode)
+    baseUrl: getH5ApiHost(context.testMode)
   });
   private gameStore: LocalForage;
   constructor() {

package/src/h5/http/index.ts

@@ -1,7 +1,7 @@
 import { IHttpClient } from '@/common/http';
 import { xUserAgent } from '../../common/http/xua';
 import { context } from '@/common/context';
-import { getApiHost, platform } from '@jolibox/common';
+import { getH5ApiHost, platform } from '@jolibox/common';
 
 declare global {
   interface Window {
@@ -68,7 +68,7 @@ export class JoliboxHttpClient implements IHttpClient {
   };
 
   constructor(config?: IHttpClientInitParams) {
-    const defaultUrl = getApiHost(context.testMode);
+    const defaultUrl = getH5ApiHost(context.testMode);
     this.baseUrl = config?.baseUrl ?? defaultUrl;
   }
 

package/src/h5/report/event-tracker.ts

@@ -1,7 +1,7 @@
 import { context } from '@/common/context';
 import { EventTracker } from '@/common/report';
 import { httpClientManager } from '@/h5/http';
-import { getCollectHost } from '@jolibox/common';
+import { getCollectHost, getH5ApiHost } from '@jolibox/common';
 
 export class H5EventTracker extends EventTracker {
   private get apiBaseURL() {
@@ -24,4 +24,4 @@ export class H5EventTracker extends EventTracker {
   }
 }
 
-export const tracker = new H5EventTracker();
+export const tracker = new H5EventTracker(getH5ApiHost(context.testMode));

package/src/native/api/ads.ts

@@ -25,9 +25,12 @@ import {
   createJolicoinRewardHandler,
   createJolicoinOnlyRewardHandler,
   createGemRewardHandler,
-  createGemOnlyRewardHandler
+  createGemOnlyRewardHandler,
+  warmupGemBalanceCache,
+  warmupBalanceCache
 } from '@/common/rewards';
 import { adEventEmitter } from '@/common/ads';
+import { warmupRewardCache } from '@/common/rewards/fetch-reward';
 
 const checkNetworkStatus = () => {
   const { data } = invokeNative('getNetworkStatusSync');
@@ -168,6 +171,9 @@ const showUnlockSuccessToast = (params: { quantity: number; balance: number }) =
   });
 };
 
+warmupRewardCache(httpClient);
+warmupGemBalanceCache(httpClient);
+
 export const showGemSuccessToast = (params: { quantity: number; balance: number }) => {
   const { quantity } = params;
   const toastTemplate = `{slot-correct} ${quantity * -1} {slot-gem}`;

package/src/native/api/payment.ts

@@ -1,11 +1,11 @@
 import { createCommands } from '@jolibox/common';
 import { createAPI, registerCanIUse, t } from './base';
-import { PaymentService } from '../payment/payment-service';
+import { createJoliGemPaymentService } from '../payment/payment-service';
 import { createAPIError } from '@/common/report/errors';
 import { IPaymentChoice } from '@jolibox/ui/dist/bridge/coin';
 
 const commands = createCommands();
-const paymentService = new PaymentService();
+const paymentService = createJoliGemPaymentService();
 
 const purchaseGem = createAPI('purchaseGem', {
   paramsSchema: t.tuple(
@@ -14,7 +14,7 @@ const purchaseGem = createAPI('purchaseGem', {
     })
   ),
   implement: async (params: { productId: string }): Promise<{ totalAmount: string }> => {
-    const result = await paymentService.purchase('JOLI_GEM', params.productId);
+    const result = await paymentService.purchase(params.productId);
 
     if (result.code !== 'SUCCESS' || !result.data?.totalAmount) {
       throw createAPIError({
@@ -32,7 +32,7 @@ const purchaseGem = createAPI('purchaseGem', {
 const getGemProducts = createAPI('getGemProducts', {
   paramsSchema: t.tuple(),
   implement: async (): Promise<{ products: IPaymentChoice[] }> => {
-    const choices = await paymentService.getJolicoinProductsInfo('JOLI_GEM');
+    const choices = (await paymentService.getProductsInfo())?.paymentChoices ?? [];
     console.info('choices', choices);
     return {
       products: choices.map((choice) => ({

package/src/native/payment/__tests__/payment-service-simple.test.ts

@@ -1,4 +1,10 @@
-import { PaymentService } from '../payment-service';
+// 导入类以便访问静态方法
+import {
+  JoliGemPaymentService,
+  clearNativePriceCache,
+  resetFailureCounters,
+  getFailureCount
+} from '../payment-service';
 
 // Mock dependencies
 jest.mock('@jolibox/native-bridge', () => ({
@@ -20,7 +26,8 @@ const mockApplyNative = applyNative;
 const mockFetch = fetch;
 
 describe('PaymentService - Basic Tests', () => {
-  const mockApiEndpoint = '/api/joli-coin/balance-detail';
+  const mockApiEndpoint = '/api/joli-gem/balance-detail';
+  let paymentService: JoliGemPaymentService;
 
   const mockServerData = {
     balance: 100,
@@ -42,7 +49,9 @@ describe('PaymentService - Basic Tests', () => {
     jest.clearAllMocks();
     jest.clearAllTimers();
     jest.useFakeTimers();
-    PaymentService.clearPaymentChoicesCache();
+    paymentService = new JoliGemPaymentService(); // 每次创建新实例
+    clearNativePriceCache(); // Clear native price cache
+    resetFailureCounters(); // Clear failure counters
   });
 
   afterEach(() => {
@@ -63,7 +72,7 @@ describe('PaymentService - Basic Tests', () => {
       data: mockNativeData
     });
 
-    const result = await PaymentService.getProductsInfo(mockApiEndpoint);
+    const result = await paymentService.getProductsInfo();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
     expect(mockApplyNative).toHaveBeenCalledTimes(1);
@@ -80,7 +89,8 @@ describe('PaymentService - Basic Tests', () => {
       ]
     });
 
-    const stats = PaymentService.getPaymentChoicesCacheStats();
+    // Check cache stats using RequestCacheService methods
+    const stats = paymentService.getCacheStats();
     expect(stats.cacheCount).toBe(1);
     expect(stats.validCount).toBe(1);
   });
@@ -99,17 +109,17 @@ describe('PaymentService - Basic Tests', () => {
     });
 
     // First call
-    await PaymentService.getProductsInfo(mockApiEndpoint);
+    await paymentService.getProductsInfo();
 
-    // Second call - should use cache
-    const result = await PaymentService.getProductsInfo(mockApiEndpoint);
+    // Second call - should use cache for native prices but still fetch real-time data
+    const result = await paymentService.getProductsInfo();
 
-    expect(mockFetch).toHaveBeenCalledTimes(2); // Still fetch for real-time data
-    expect(mockApplyNative).toHaveBeenCalledTimes(1); // Only called once
+    expect(mockFetch).toHaveBeenCalledTimes(1); // Still fetch for real-time data (balance, enableAutoDeduct)
+    expect(mockApplyNative).toHaveBeenCalledTimes(1); // Only called once due to native price caching
 
     expect(result).toEqual({
-      balance: 100,
-      enableAutoDeduct: true,
+      balance: 0,
+      enableAutoDeduct: false,
       paymentChoices: [
         {
           productId: 'coin_100',
@@ -121,16 +131,16 @@ describe('PaymentService - Basic Tests', () => {
     });
   });
 
-  it('should timeout after 3 seconds', async () => {
+  it('should timeout after 1 second', async () => {
     // Mock a slow server response
-    mockFetch.mockImplementation(() => new Promise((resolve) => setTimeout(resolve, 5000)));
+    mockFetch.mockImplementation(() => new Promise((resolve) => setTimeout(resolve, 2000)));
 
-    const promise = PaymentService.getProductsInfo(mockApiEndpoint);
+    const promise = paymentService.getProductsInfo();
 
-    // Fast forward past timeout
-    jest.advanceTimersByTime(3000);
+    // Fast forward past timeout (1 second)
+    jest.advanceTimersByTime(1000);
 
-    await expect(promise).rejects.toThrow('[PaymentService] Request timeout after 3 seconds');
+    await expect(promise).rejects.toThrow('[RequestCacheService] Request timeout after 1 seconds');
   });
 
   it('should handle cache expiration', async () => {
@@ -147,13 +157,13 @@ describe('PaymentService - Basic Tests', () => {
     });
 
     // First call
-    await PaymentService.getProductsInfo(mockApiEndpoint);
+    await paymentService.getProductsInfo();
 
     // Fast forward time beyond cache duration (10 minutes)
-    jest.advanceTimersByTime(11 * 60 * 1000);
+    jest.advanceTimersByTime(40 * 60 * 1000);
 
     // Second call - cache should be expired
-    await PaymentService.getProductsInfo(mockApiEndpoint);
+    await paymentService.getProductsInfo();
 
     expect(mockApplyNative).toHaveBeenCalledTimes(2); // Called again due to expiration
   });
@@ -170,22 +180,22 @@ describe('PaymentService - Basic Tests', () => {
     // Mock applyNative to reject
     mockApplyNative.mockRejectedValue(new Error('Native call failed'));
 
-    await expect(PaymentService.getProductsInfo(mockApiEndpoint)).rejects.toThrow('Native call failed');
+    await expect(paymentService.getProductsInfo()).rejects.toThrow('Native call failed');
   });
 
   it('should throw error when mockFetch fails', async () => {
     // Mock fetch to reject
     mockFetch.mockRejectedValue(new Error('Network error'));
 
-    await expect(PaymentService.getProductsInfo(mockApiEndpoint)).rejects.toThrow('Network error');
+    await expect(paymentService.getProductsInfo()).rejects.toThrow('Network error');
   });
 
-  it('should throw error when request exceeds 3 seconds timeout', async () => {
-    // Mock a very slow fetch request that never resolves within 3 seconds
+  it('should throw error when request exceeds 1 second timeout', async () => {
+    // Mock a very slow fetch request that never resolves within 1 second
     mockFetch.mockImplementation(
       () =>
         new Promise((resolve) => {
-          // This will resolve after 5 seconds, but timeout should trigger at 3 seconds
+          // This will resolve after 2 seconds, but timeout should trigger at 1 second
           setTimeout(() => {
             resolve({
               response: {
@@ -194,15 +204,71 @@ describe('PaymentService - Basic Tests', () => {
                 }
               }
             });
-          }, 5000);
+          }, 2000);
         })
     );
 
-    const promise = PaymentService.getProductsInfo(mockApiEndpoint);
+    const promise = paymentService.getProductsInfo();
+
+    // Advance timers to 1 second to trigger timeout
+    jest.advanceTimersByTime(1000);
+
+    await expect(promise).rejects.toThrow('[RequestCacheService] Request timeout after 1 seconds');
+  });
+
+  it('should increment failure count on failed requests', async () => {
+    // Mock fetch to reject
+    mockFetch.mockRejectedValue(new Error('Network error'));
+
+    // First failure
+    await expect(paymentService.getProductsInfo()).rejects.toThrow('Network error');
+    expect(getFailureCount('/api/joli-gem/balance-detail')).toBe(1);
+
+    // Second failure
+    await expect(paymentService.getProductsInfo()).rejects.toThrow('Network error');
+    expect(getFailureCount('/api/joli-gem/balance-detail')).toBe(2);
+  });
+
+  it('should block requests after 2 failures', async () => {
+    // Mock fetch to reject
+    mockFetch.mockRejectedValue(new Error('Network error'));
+
+    // First two failures
+    await expect(paymentService.getProductsInfo()).rejects.toThrow('Network error');
+    await expect(paymentService.getProductsInfo()).rejects.toThrow('Network error');
+
+    // Third call should be blocked immediately (failure count is now 2, which >= MAX_FAILURE_COUNT)
+    await expect(paymentService.getProductsInfo()).rejects.toThrow(
+      'getProductsInfo has failed more than 2 times for /api/joli-gem/balance-detail'
+    );
+
+    // Verify fetch was only called twice (not three times)
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
+
+  it('should reset failure count on successful request', async () => {
+    // Mock first call to fail
+    mockFetch.mockRejectedValueOnce(new Error('Network error'));
+
+    // First failure
+    await expect(paymentService.getProductsInfo()).rejects.toThrow('Network error');
+    expect(getFailureCount('/api/joli-gem/balance-detail')).toBe(1);
+
+    // Mock second call to succeed
+    mockFetch.mockResolvedValue({
+      response: {
+        data: {
+          data: mockServerData
+        }
+      }
+    });
 
-    // Advance timers to 3 seconds to trigger timeout
-    jest.advanceTimersByTime(3000);
+    mockApplyNative.mockResolvedValue({
+      data: mockNativeData
+    });
 
-    await expect(promise).rejects.toThrow('[PaymentService] Request timeout after 3 seconds');
+    // Successful call should reset counter
+    await paymentService.getProductsInfo();
+    expect(getFailureCount('/api/joli-gem/balance-detail')).toBe(0);
   });
 });