@jolibox/implement 1.2.5 → 1.2.7

package/src/h5/bootstrap/auth/__tests__/auth.test.ts

@@ -0,0 +1,308 @@
+// Mock dependencies first
+const mockOnCustomEvent = jest.fn();
+const mockNotifyCustomEvent = jest.fn();
+const mockUuidv4 = jest.fn();
+
+jest.mock('@jolibox/common', () => ({
+  uuidv4: mockUuidv4,
+  EventEmitter: jest.fn().mockImplementation(() => ({
+    emit: jest.fn(),
+    on: jest.fn(),
+    off: jest.fn(),
+    once: jest.fn(),
+    removeAllListeners: jest.fn()
+  })),
+  InternalGlobalJSError: jest.fn().mockImplementation((error) => error)
+}));
+
+jest.mock('@/common/utils', () => ({
+  onCustomEvent: mockOnCustomEvent,
+  notifyCustomEvent: mockNotifyCustomEvent
+}));
+
+jest.mock('@/common/report/errors/report', () => ({
+  reportError: jest.fn()
+}));
+
+import { getUserSubStatus, resetSubState } from '../sub';
+
+// Define event data interface
+interface EventData {
+  sequenceId: string;
+  isSubUser: boolean;
+}
+
+describe('getUserSubStatus', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.clearAllTimers();
+    jest.useRealTimers(); // Use real timers to avoid timing issues
+
+    // Reset module state between tests
+    resetSubState();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should resolve with correct value when event is received', async () => {
+    let eventHandler: ((data: EventData) => void) | null = null;
+    mockOnCustomEvent.mockImplementation((eventName: string, handler: (data: EventData) => void) => {
+      if (eventName === 'ON_GET_USER_SUB_STATUS') {
+        eventHandler = handler;
+      }
+      return jest.fn();
+    });
+
+    mockUuidv4.mockReturnValue('test-sequence-id');
+
+    const promise = getUserSubStatus();
+
+    // Verify notification was sent
+    expect(mockNotifyCustomEvent).toHaveBeenCalledWith('JOLIBOX_GET_USER_SUB_STATUS', {
+      sequenceId: 'test-sequence-id'
+    });
+
+    // Simulate response immediately
+    if (eventHandler) {
+      (eventHandler as any)({
+        sequenceId: 'test-sequence-id',
+        isSubUser: true
+      });
+    }
+
+    const result = await promise;
+    expect(result).toBe(true);
+  });
+
+  it('should resolve with false when isSubUser is false', async () => {
+    let eventHandler: ((data: EventData) => void) | null = null;
+    mockOnCustomEvent.mockImplementation((eventName: string, handler: (data: EventData) => void) => {
+      if (eventName === 'ON_GET_USER_SUB_STATUS') {
+        eventHandler = handler;
+      }
+      return jest.fn();
+    });
+
+    mockUuidv4.mockReturnValue('test-sequence-id');
+
+    const promise = getUserSubStatus();
+
+    // Simulate response with false
+    if (eventHandler) {
+      (eventHandler as any)({
+        sequenceId: 'test-sequence-id',
+        isSubUser: false
+      });
+    }
+
+    const result = await promise;
+    expect(result).toBe(false);
+  });
+
+  it('should reject on timeout', async () => {
+    mockOnCustomEvent.mockImplementation(() => jest.fn());
+    mockUuidv4.mockReturnValue('timeout-test-id');
+
+    const promise = getUserSubStatus();
+
+    // Fast forward time to trigger timeout
+    jest.advanceTimersByTime(3000);
+
+    await expect(promise).rejects.toThrow('Timeout waiting for user sub status response');
+  });
+
+  it('should initialize event listener only once', async () => {
+    let eventHandler: ((data: EventData) => void) | null = null;
+    mockOnCustomEvent.mockImplementation((eventName: string, handler: (data: EventData) => void) => {
+      if (eventName === 'ON_GET_USER_SUB_STATUS') {
+        eventHandler = handler;
+      }
+      return jest.fn();
+    });
+
+    // Mock different UUIDs for different calls
+    mockUuidv4.mockReturnValueOnce('uuid-1').mockReturnValueOnce('uuid-2');
+
+    // First call
+    const promise1 = getUserSubStatus();
+
+    // Second call
+    const promise2 = getUserSubStatus();
+
+    // Should only initialize listener once
+    expect(mockOnCustomEvent).toHaveBeenCalledTimes(1);
+    expect(mockOnCustomEvent).toHaveBeenCalledWith('ON_GET_USER_SUB_STATUS', expect.any(Function));
+
+    // Should send notification for both calls
+    expect(mockNotifyCustomEvent).toHaveBeenCalledTimes(2);
+
+    // Simulate responses with different sequence IDs
+    if (eventHandler) {
+      (eventHandler as any)({ sequenceId: 'uuid-1', isSubUser: true });
+      (eventHandler as any)({ sequenceId: 'uuid-2', isSubUser: false });
+    }
+
+    const [result1, result2] = await Promise.all([promise1, promise2]);
+    expect(result1).toBe(true);
+    expect(result2).toBe(false);
+  });
+
+  it('should ignore responses with different sequenceId', async () => {
+    let eventHandler: ((data: EventData) => void) | null = null;
+    mockOnCustomEvent.mockImplementation((eventName: string, handler: (data: EventData) => void) => {
+      if (eventName === 'ON_GET_USER_SUB_STATUS') {
+        eventHandler = handler;
+      }
+      return jest.fn();
+    });
+
+    mockUuidv4.mockReturnValue('correct-sequence-id');
+
+    const promise = getUserSubStatus();
+
+    // Simulate response with wrong sequenceId first
+    if (eventHandler) {
+      (eventHandler as any)({
+        sequenceId: 'wrong-sequence-id',
+        isSubUser: true
+      });
+    }
+
+    // Promise should still be pending after wrong sequenceId
+    let isResolved = false;
+    let promiseResult: any;
+    promise
+      .then((result) => {
+        isResolved = true;
+        promiseResult = result;
+      })
+      .catch(() => {
+        isResolved = true;
+      });
+
+    // Flush microtasks
+    await Promise.resolve();
+    expect(isResolved).toBe(false);
+
+    // Now send correct response
+    if (eventHandler) {
+      (eventHandler as any)({
+        sequenceId: 'correct-sequence-id',
+        isSubUser: true
+      });
+    }
+
+    await promise;
+    expect(promiseResult).toBe(true);
+  });
+
+  it('should handle multiple concurrent requests with different sequenceIds', async () => {
+    let eventHandler: ((data: EventData) => void) | null = null;
+    mockOnCustomEvent.mockImplementation((eventName: string, handler: (data: EventData) => void) => {
+      if (eventName === 'ON_GET_USER_SUB_STATUS') {
+        eventHandler = handler;
+      }
+      return jest.fn();
+    });
+
+    // Mock different UUIDs for different calls
+    mockUuidv4
+      .mockReturnValueOnce('request-1')
+      .mockReturnValueOnce('request-2')
+      .mockReturnValueOnce('request-3');
+
+    const promise1 = getUserSubStatus();
+    const promise2 = getUserSubStatus();
+    const promise3 = getUserSubStatus();
+
+    // Should initialize listener only once
+    expect(mockOnCustomEvent).toHaveBeenCalledTimes(1);
+
+    // Should send three notifications
+    expect(mockNotifyCustomEvent).toHaveBeenCalledTimes(3);
+    expect(mockNotifyCustomEvent).toHaveBeenNthCalledWith(1, 'JOLIBOX_GET_USER_SUB_STATUS', {
+      sequenceId: 'request-1'
+    });
+    expect(mockNotifyCustomEvent).toHaveBeenNthCalledWith(2, 'JOLIBOX_GET_USER_SUB_STATUS', {
+      sequenceId: 'request-2'
+    });
+    expect(mockNotifyCustomEvent).toHaveBeenNthCalledWith(3, 'JOLIBOX_GET_USER_SUB_STATUS', {
+      sequenceId: 'request-3'
+    });
+
+    // Simulate responses in reverse order
+    if (eventHandler) {
+      (eventHandler as any)({ sequenceId: 'request-3', isSubUser: false });
+      (eventHandler as any)({ sequenceId: 'request-1', isSubUser: true });
+      (eventHandler as any)({ sequenceId: 'request-2', isSubUser: true });
+    }
+
+    const [result1, result2, result3] = await Promise.all([promise1, promise2, promise3]);
+    expect(result1).toBe(true);
+    expect(result2).toBe(true);
+    expect(result3).toBe(false);
+  });
+
+  it('should clean up timeout when response is received', async () => {
+    let eventHandler: ((data: EventData) => void) | null = null;
+    mockOnCustomEvent.mockImplementation((eventName: string, handler: (data: EventData) => void) => {
+      if (eventName === 'ON_GET_USER_SUB_STATUS') {
+        eventHandler = handler;
+      }
+      return jest.fn();
+    });
+
+    mockUuidv4.mockReturnValue('cleanup-test-id');
+
+    // Spy on clearTimeout
+    const clearTimeoutSpy = jest.spyOn(global, 'clearTimeout');
+
+    const promise = getUserSubStatus();
+
+    // Simulate response before timeout
+    if (eventHandler) {
+      (eventHandler as any)({
+        sequenceId: 'cleanup-test-id',
+        isSubUser: true
+      });
+    }
+
+    await promise;
+
+    // Verify timeout was cleared
+    expect(clearTimeoutSpy).toHaveBeenCalled();
+
+    clearTimeoutSpy.mockRestore();
+  });
+
+  it('should not resolve after timeout even if response comes later', async () => {
+    let eventHandler: ((data: EventData) => void) | null = null;
+    mockOnCustomEvent.mockImplementation((eventName: string, handler: (data: EventData) => void) => {
+      if (eventName === 'ON_GET_USER_SUB_STATUS') {
+        eventHandler = handler;
+      }
+      return jest.fn();
+    });
+
+    mockUuidv4.mockReturnValue('late-response-id');
+
+    const promise = getUserSubStatus();
+
+    // Trigger timeout first
+    jest.advanceTimersByTime(3000);
+
+    await expect(promise).rejects.toThrow('Timeout waiting for user sub status response');
+
+    // Try to send response after timeout
+    if (eventHandler) {
+      (eventHandler as any)({
+        sequenceId: 'late-response-id',
+        isSubUser: true
+      });
+    }
+
+    // Promise should already be rejected, no additional effects
+  });
+});

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

@@ -0,0 +1,20 @@
+import { httpClientManager } from '@/h5/http';
+import { StandardResponse } from '@jolibox/types';
+import { reportError } from '@/common/report/errors/report';
+import { InternalGlobalJSError } from '@jolibox/common';
+
+export 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;
+  }
+}
+
+export { getUserSubStatus } from './sub';

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/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/payment/payment-service.ts

@@ -5,7 +5,7 @@ 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';
+import { RequestCacheService, RequestAdapter } from '@jolibox/common';
 
 type PaymentPurchaseType = 'JOLI_COIN' | 'JOLI_GEM';
 

package/dist/common/cache/request-cache-service.d.ts

@@ -1,111 +0,0 @@
-/**
- * 通用请求缓存服务基类
- * 支持部分数据缓存，部分数据实时获取的混合模式
- */
-export interface CacheConfig<TCacheData, TServerData> {
-    /** 缓存持续时间，默认10分钟 */
-    duration?: number;
-    /** 请求超时时间，默认3秒 */
-    timeout?: number;
-    /** 缓存键生成函数 */
-    keyGenerator?: <TRequest>(endpoint: string, params?: TRequest) => string;
-    /** 数据一致性校验函数 */
-    consistencyChecker?: (cached: TCacheData, serverData: TServerData) => boolean;
-}
-export interface CacheEntry<T> {
-    data: T;
-    timestamp: number;
-    expiresAt: number;
-    key: string;
-    sequence: number;
-    metadata?: Record<string, unknown>;
-}
-export interface CacheStats {
-    cacheCount: number;
-    validCount: number;
-    expiredCount: number;
-}
-export interface RequestAdapter<TRequest, TResponse, TCacheData, TRealTimeData> {
-    /** 执行实际的网络请求 */
-    execute(endpoint: string, options?: TRequest): Promise<TResponse>;
-    /** 从响应中提取需要缓存的部分（不变数据） */
-    extractCacheableData?(response: TResponse): TCacheData;
-    /** 从响应中提取实时数据部分（变化数据） */
-    extractRealTimeData?(response: TResponse): TRealTimeData;
-    /** 合并缓存数据和实时数据 */
-    mergeData?(cached: TCacheData, realTime: TRealTimeData): TResponse;
-    /** 处理纯缓存场景的数据，当没有新的网络请求时 */
-    processCachedData?(cached: TCacheData): TResponse;
-}
-export declare abstract class RequestCacheService<TRequest, TResponse, TCacheData, TRealTimeData> {
-    protected requestAdapter: RequestAdapter<TRequest, TResponse, TCacheData, TRealTimeData>;
-    private cache;
-    private readonly config;
-    private pendingRequests;
-    private requestSequence;
-    private cacheSequences;
-    constructor(requestAdapter: RequestAdapter<TRequest, TResponse, TCacheData, TRealTimeData>, config?: Partial<CacheConfig<TCacheData, TCacheData>>);
-    /**
-     * 带缓存的请求方法 - 缓存优先 + 实时数据混合模式 + 请求去重
-     */
-    request(endpoint: string, options?: TRequest): Promise<TResponse>;
-    private requestInternal;
-    /**
-     * timeout
-     */
-    private createTimeoutPromise;
-    /**
-     * get valid cached data
-     */
-    private getValidCachedData;
-    /**
-     * 设置缓存数据 (带序列号检查)
-     */
-    private setCachedDataWithSequence;
-    /**
-     * refresh cache
-     */
-    refreshCache(endpoint: string, options?: TRequest): Promise<TResponse>;
-    /**
-     * force request and update cache
-     */
-    forceRequest(endpoint: string, options?: TRequest): Promise<TResponse>;
-    /**
-     * warmup cache - 避免与正在进行的请求冲突
-     */
-    warmupCache(endpoint: string, options?: TRequest): Promise<void>;
-    /**
-     * clear cache with target key
-     */
-    clearCache(key?: string): void;
-    /**
-     * clear expired cache
-     */
-    clearExpiredCache(): void;
-    /**
-     * get cache stats
-     */
-    getCacheStats(): CacheStats & {
-        pendingRequestCount: number;
-    };
-    /**
-     * get all cache keys
-     */
-    getCacheKeys(): string[];
-    /**
-     * check if the target key has valid cache
-     */
-    hasValidCache(key: string): boolean;
-    /**
-     * get pending request keys for debugging
-     */
-    getPendingRequestKeys(): string[];
-    /**
-     * check if a request is currently pending
-     */
-    hasPendingRequest(key: string): boolean;
-    /**
-     * get cache sequence for a specific key
-     */
-    getCacheSequence(key: string): number | undefined;
-}