@jolibox/implement 1.2.4 → 1.2.5-beta.3

package/src/h5/bootstrap/auth/sub.ts

@@ -0,0 +1,56 @@
+import { onCustomEvent, notifyCustomEvent } from '@/common/utils';
+import { uuidv4 as v4 } from '@jolibox/common';
+// global event listener manager
+interface PendingRequest {
+  resolve: (value: boolean) => void;
+  reject: (error: Error) => void;
+  timeoutId: NodeJS.Timeout;
+}
+
+const pendingRequests = new Map<string, PendingRequest>();
+let isListenerInitialized = false;
+
+// initialize global event listener
+const initializeEventListener = () => {
+  if (isListenerInitialized) return;
+
+  onCustomEvent('ON_GET_USER_SUB_STATUS', (data) => {
+    const pendingRequest = pendingRequests.get(data.sequenceId);
+    if (pendingRequest) {
+      clearTimeout(pendingRequest.timeoutId);
+      pendingRequest.resolve(data.isSubUser);
+      pendingRequests.delete(data.sequenceId);
+    }
+  });
+
+  isListenerInitialized = true;
+};
+
+// Reset function for testing
+export const resetSubState = () => {
+  isListenerInitialized = false;
+  pendingRequests.clear();
+};
+
+export async function getUserSubStatus(): Promise<boolean> {
+  initializeEventListener();
+
+  return new Promise((resolve, reject) => {
+    const sequenceId = v4();
+
+    const timeoutId = setTimeout(() => {
+      pendingRequests.delete(sequenceId);
+      reject(new Error('Timeout waiting for user sub status response'));
+    }, 3000); // 3 second timeout
+
+    pendingRequests.set(sequenceId, {
+      resolve,
+      reject,
+      timeoutId
+    });
+
+    notifyCustomEvent('JOLIBOX_GET_USER_SUB_STATUS', {
+      sequenceId
+    });
+  });
+}

package/src/h5/bootstrap/index.ts

@@ -1,10 +1,8 @@
-import { hostEmitter, InternalGlobalJSError, UserCustomError } from '@jolibox/common';
+import { hostEmitter } from '@jolibox/common';
 import { taskTracker, track } from '../report';
 import { onFCP, onLCP, onTTFB } from 'web-vitals';
 import { context } from '@/common/context';
-import { httpClientManager } from '../http';
-import { StandardResponse } from '@jolibox/types';
-import { reportError } from '@/common/report/errors/report';
+import { checkSession, getUserSubStatus } from './auth';
 
 function trackPerformance() {
   onFCP((metric) => {
@@ -32,24 +30,11 @@ function trackPerformance() {
   });
 }
 
-async function checkSession(): Promise<boolean> {
-  const httpClient = httpClientManager.create();
-  try {
-    const response = await httpClient.get<StandardResponse<void>>('/api/users/info');
-    if (response.code !== 'SUCCESS' || !response.data) {
-      return false;
-    }
-    return true;
-  } catch (error) {
-    reportError(new InternalGlobalJSError(error as Error));
-    return false;
-  }
-}
-
 function addDomContentLoaded() {
   hostEmitter.on('onDocumentReady', async (startTime: number) => {
     const isLogin = await checkSession();
-    context.onEnvConfigChanged({ hostUserInfo: { isLogin } });
+    const isSubUser = await getUserSubStatus().catch(() => false);
+    context.onEnvConfigChanged({ hostUserInfo: { isLogin, isSubUser } });
     hostEmitter.emit('LifecycleEvent.onReady', {
       ...(context.hostUserInfo ? context.hostUserInfo : { isLogin: false })
     });

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/h5/rewards/index.ts

@@ -13,7 +13,9 @@ import {
   IInvokePaymentEvent,
   IUseModalResultEvent,
   UseUnloginModalResultEventName,
-  InvokeUnloginModalEventName
+  InvokeUnloginModalEventName,
+  InvokeSubscriptionEventName,
+  UseSubscriptionResultEventName
 } from '@/common/rewards/reward-emitter';
 import { notifyCustomEvent, onCustomEvent } from '@/common/utils';
 import { uuidv4 as v4 } from '@jolibox/common';
@@ -108,3 +110,18 @@ rewardsEmitter.on(InvokeUnloginModalEventName, async (type) => {
     type: type
   });
 });
+
+// subscription
+onCustomEvent('ON_JOLIBOX_SUB_RESULT_EVENT', (params) => {
+  console.log('----on custom event ON_JOLIBOX_SUB_RESULT_EVENT-----', params);
+  rewardsEmitter.emit(UseSubscriptionResultEventName, {
+    result: params.result
+  });
+});
+
+rewardsEmitter.on(InvokeSubscriptionEventName, async (type) => {
+  console.log('----notify custom event-----', type);
+  notifyCustomEvent('JOLIBOX_SUB_EVENT', {
+    sequenceId: v4()
+  });
+});

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);
   });
 });