@jolibox/implement 1.2.3 → 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/call-host-method.ts

@@ -1,4 +1,4 @@
-import { canIUseNative, createAPI, registerCanIUse, t, createSyncAPI } from './base';
+import { createAPI, registerCanIUse, t } from './base';
 import { invokeNative } from '@jolibox/native-bridge';
 import { hostEmitter, UserCustomError } from '@jolibox/common';
 import { createCommands } from '@jolibox/common';

package/src/native/api/index.ts

@@ -10,3 +10,4 @@ import './navigate';
 import './runtime';
 import './is-native-support';
 import './call-host-method';
+import './payment';

package/src/native/api/navigate.ts

@@ -56,7 +56,16 @@ const interceptSystemExitSync = createSyncAPI('interceptSystemExitSync', {
 
 const navigateToNativePage = createSyncAPI('navigateToNativePage', {
   paramsSchema: t.tuple(
-    t.enum('openHistory', 'openDiscover', 'openDiscover', 'openGame', 'openDrama', 'openTopup', 'openFeed'),
+    t.enum(
+      'openHistory',
+      'openDiscover',
+      'openDiscover',
+      'openGame',
+      'openDrama',
+      'openTopup',
+      'openFeed',
+      'openRewards'
+    ),
     t.object()
   ),
   implement: (path, params) => {

package/src/native/api/payment.ts

@@ -0,0 +1,56 @@
+import { createCommands } from '@jolibox/common';
+import { createAPI, registerCanIUse, t } from './base';
+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 = createJoliGemPaymentService();
+
+const purchaseGem = createAPI('purchaseGem', {
+  paramsSchema: t.tuple(
+    t.object({
+      productId: t.string()
+    })
+  ),
+  implement: async (params: { productId: string }): Promise<{ totalAmount: string }> => {
+    const result = await paymentService.purchase(params.productId);
+
+    if (result.code !== 'SUCCESS' || !result.data?.totalAmount) {
+      throw createAPIError({
+        code: -1,
+        msg: '[JoliboxSDK]: purchase gem failed: ' + result.message
+      });
+    }
+
+    return {
+      totalAmount: result.data?.totalAmount
+    };
+  }
+});
+
+const getGemProducts = createAPI('getGemProducts', {
+  paramsSchema: t.tuple(),
+  implement: async (): Promise<{ products: IPaymentChoice[] }> => {
+    const choices = (await paymentService.getProductsInfo())?.paymentChoices ?? [];
+    console.info('choices', choices);
+    return {
+      products: choices.map((choice) => ({
+        productId: choice.productId,
+        totalAmountStr: choice.totalAmountStr ?? '',
+        quantity: choice.quantity
+      }))
+    };
+  }
+});
+
+commands.registerCommand('PaymentSDK.purchaseGem', purchaseGem);
+commands.registerCommand('PaymentSDK.getGemProducts', getGemProducts);
+
+registerCanIUse('payment.purchaseGem', {
+  version: '1.2.3'
+});
+
+registerCanIUse('payment.getGemProducts', {
+  version: '1.2.3'
+});

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

@@ -0,0 +1,274 @@
+// 导入类以便访问静态方法
+import {
+  JoliGemPaymentService,
+  clearNativePriceCache,
+  resetFailureCounters,
+  getFailureCount
+} from '../payment-service';
+
+// Mock dependencies
+jest.mock('@jolibox/native-bridge', () => ({
+  applyNative: jest.fn(),
+  onNative: jest.fn()
+}));
+
+jest.mock('@/native/network', () => ({
+  innerFetch: jest.fn()
+}));
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { applyNative } = require('@jolibox/native-bridge');
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { innerFetch: fetch } = require('@/native/network');
+
+const mockApplyNative = applyNative;
+const mockFetch = fetch;
+
+describe('PaymentService - Basic Tests', () => {
+  const mockApiEndpoint = '/api/joli-gem/balance-detail';
+  let paymentService: JoliGemPaymentService;
+
+  const mockServerData = {
+    balance: 100,
+    enableAutoDeduct: true,
+    paymentChoices: [
+      {
+        productId: 'coin_100',
+        quantity: 100,
+        appStoreProductId: 'com.joli.coin.100'
+      }
+    ]
+  };
+
+  const mockNativeData = {
+    'com.joli.coin.100': { price: '$0.99' }
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.clearAllTimers();
+    jest.useFakeTimers();
+    paymentService = new JoliGemPaymentService(); // 每次创建新实例
+    clearNativePriceCache(); // Clear native price cache
+    resetFailureCounters(); // Clear failure counters
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  it('should fetch and cache payment choices on first call', async () => {
+    mockFetch.mockResolvedValue({
+      response: {
+        data: {
+          data: mockServerData
+        }
+      }
+    });
+
+    mockApplyNative.mockResolvedValue({
+      data: mockNativeData
+    });
+
+    const result = await paymentService.getProductsInfo();
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockApplyNative).toHaveBeenCalledTimes(1);
+    expect(result).toEqual({
+      balance: 100,
+      enableAutoDeduct: true,
+      paymentChoices: [
+        {
+          productId: 'coin_100',
+          quantity: 100,
+          appStoreProductId: 'com.joli.coin.100',
+          totalAmountStr: '$0.99'
+        }
+      ]
+    });
+
+    // Check cache stats using RequestCacheService methods
+    const stats = paymentService.getCacheStats();
+    expect(stats.cacheCount).toBe(1);
+    expect(stats.validCount).toBe(1);
+  });
+
+  it('should use cache on second call', async () => {
+    mockFetch.mockResolvedValue({
+      response: {
+        data: {
+          data: mockServerData
+        }
+      }
+    });
+
+    mockApplyNative.mockResolvedValue({
+      data: mockNativeData
+    });
+
+    // First call
+    await paymentService.getProductsInfo();
+
+    // Second call - should use cache for native prices but still fetch real-time data
+    const result = await paymentService.getProductsInfo();
+
+    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: 0,
+      enableAutoDeduct: false,
+      paymentChoices: [
+        {
+          productId: 'coin_100',
+          quantity: 100,
+          appStoreProductId: 'com.joli.coin.100',
+          totalAmountStr: '$0.99'
+        }
+      ]
+    });
+  });
+
+  it('should timeout after 1 second', async () => {
+    // Mock a slow server response
+    mockFetch.mockImplementation(() => new Promise((resolve) => setTimeout(resolve, 2000)));
+
+    const promise = paymentService.getProductsInfo();
+
+    // Fast forward past timeout (1 second)
+    jest.advanceTimersByTime(1000);
+
+    await expect(promise).rejects.toThrow('[RequestCacheService] Request timeout after 1 seconds');
+  });
+
+  it('should handle cache expiration', async () => {
+    mockFetch.mockResolvedValue({
+      response: {
+        data: {
+          data: mockServerData
+        }
+      }
+    });
+
+    mockApplyNative.mockResolvedValue({
+      data: mockNativeData
+    });
+
+    // First call
+    await paymentService.getProductsInfo();
+
+    // Fast forward time beyond cache duration (10 minutes)
+    jest.advanceTimersByTime(40 * 60 * 1000);
+
+    // Second call - cache should be expired
+    await paymentService.getProductsInfo();
+
+    expect(mockApplyNative).toHaveBeenCalledTimes(2); // Called again due to expiration
+  });
+
+  it('should throw error when mockApplyNative fails', async () => {
+    mockFetch.mockResolvedValue({
+      response: {
+        data: {
+          data: mockServerData
+        }
+      }
+    });
+
+    // Mock applyNative to reject
+    mockApplyNative.mockRejectedValue(new Error('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()).rejects.toThrow('Network error');
+  });
+
+  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 2 seconds, but timeout should trigger at 1 second
+          setTimeout(() => {
+            resolve({
+              response: {
+                data: {
+                  data: mockServerData
+                }
+              }
+            });
+          }, 2000);
+        })
+    );
+
+    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
+        }
+      }
+    });
+
+    mockApplyNative.mockResolvedValue({
+      data: mockNativeData
+    });
+
+    // Successful call should reset counter
+    await paymentService.getProductsInfo();
+    expect(getFailureCount('/api/joli-gem/balance-detail')).toBe(0);
+  });
+});

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

@@ -4,12 +4,18 @@ import { StandardResponse } from '@jolibox/types';
 import { reportError } from '@/common/report/errors/report';
 import { BaseError } from '@jolibox/common';
 
-type PaymentResult = StandardResponse<void>;
+export type PaymentResult<T> = StandardResponse<T>;
 
 export interface PaymentHandlerMap {
-  JOLI_COIN: (productId: string) => Promise<PaymentResult>; // jolicoin
-  JOLI_COIN_IAP: (params: { productId: string; appStoreProductId: string }) => Promise<PaymentResult>; // jolicoin iap
-  JOLI_GEM_IAP: (params: { productId: string; appStoreProductId: string }) => Promise<PaymentResult>; // gem iap
+  JOLI_COIN: (productId: string) => Promise<PaymentResult<void>>; // jolicoin
+  JOLI_COIN_IAP: (params: {
+    productId: string;
+    appStoreProductId: string;
+  }) => Promise<PaymentResult<{ totalAmount: string }>>; // jolicoin iap
+  JOLI_GEM_IAP: (params: {
+    productId: string;
+    appStoreProductId: string;
+  }) => Promise<PaymentResult<{ totalAmount: string }>>; // gem iap
 }
 
 export type PaymentHandler<T extends PaymentType> = PaymentHandlerMap[T];