@jolibox/implement 1.2.4 → 1.2.5-beta.3

package/src/common/rewards/fetch-reward.ts

@@ -1,93 +1,17 @@
-import { IHttpClient } from '../http';
-import { RewardsHelper, RewardType } from './reward-helper';
-import { IJolicoinRewardOption } from './type';
-import {
-  UnlockOptionsEventName,
-  UseModalFrequencyEventName,
-  rewardsEmitter,
-  DefaltJoliCoinUseAndCharge,
-  DefaltLoginGuide,
-  IUseModalFrequencyConfig
-} from './reward-emitter';
-import { StandardResponse, GlobalConfig } from '@jolibox/types';
-import { hostEmitter } from '@jolibox/common';
-
-const priority = () => {
-  return (a: RewardType, b: RewardType) => {
-    // Priority order: GEM > JOLI_COIN > ADS
-    const priorityMap: Record<RewardType, number> = {
-      JOLI_GEM: 3,
-      JOLI_GEM_ONLY: 3,
-      JOLI_COIN: 2,
-      JOLI_COIN_ONLY: 2,
-      ADS: 1
-    };
-
-    return priorityMap[b] - priorityMap[a];
-  };
-};
-
-const sortRewards = (rewardsTypes: RewardType[]): RewardType[] => {
-  if (!rewardsTypes.length) return ['ADS'];
-  if (rewardsTypes.includes('JOLI_GEM') && rewardsTypes.length <= 1) return ['JOLI_GEM_ONLY'];
-  if (rewardsTypes.includes('JOLI_COIN') && rewardsTypes.length <= 1) return ['JOLI_COIN_ONLY'];
-
-  return rewardsTypes.sort(priority());
-};
-
-export const createRewardFetcher = (rewardsHelper: RewardsHelper) => {
-  rewardsHelper.registerRewardsFetcher(async (httpClient: IHttpClient) => {
-    const defaultRewards: RewardType[] = ['ADS'];
-    try {
-      const res = await httpClient.post<IJolicoinRewardOption>('/api/games/unlock-options', {});
-      if (res.code !== 'SUCCESS') {
-        return defaultRewards;
-      }
-
-      console.log('-----res fetch reward-----', res);
-      rewardsEmitter.emit(UnlockOptionsEventName, {
-        options: res.data?.unlockOptions || [],
-        userJoliCoin: res.extra?.joliCoin || {
-          balance: 0,
-          enableAutoDeduct: false
-        },
-        userGem: res.extra?.joliGem || {
-          balance: 0,
-          enableAutoDeduct: false
-        }
-      });
-
-      const rewardsTypes =
-        res.data?.unlockOptions?.map((option) => option.type) || Array.from(defaultRewards);
-      // Sort reward types with JOLI_COIN having higher priority than ADS
-      return sortRewards(rewardsTypes);
-    } catch (e) {
-      console.error('getRewardOptions error:', e);
-      return defaultRewards;
-    }
-  });
-};
-
-export const createRewardFrequencyConfigFetcher = (rewardsHelper: RewardsHelper) => {
-  rewardsHelper.registerRewardFrequencyConfigFetcher(async (httpClient: IHttpClient) => {
-    const res = await httpClient.get<StandardResponse<GlobalConfig & IUseModalFrequencyConfig>>(
-      '/api/fe-configs/web-common/global-config',
-      {}
-    );
-
-    rewardsEmitter.emit(UseModalFrequencyEventName, {
-      joliCoinUseAndCharge: res.data?.joliCoinUseAndCharge || DefaltJoliCoinUseAndCharge,
-      loginGuide: res.data?.loginGuide || DefaltLoginGuide
-    });
-
-    res.data &&
-      hostEmitter.emit('onGlobalConfigChanged', {
-        globalConfig: res.data
-      });
-
-    return {
-      joliCoinUseAndCharge: res.data?.joliCoinUseAndCharge || DefaltJoliCoinUseAndCharge,
-      loginGuide: res.data?.loginGuide || DefaltLoginGuide
-    };
-  });
-};
+export {
+  createCachedRewardFetcher as createRewardFetcher,
+  createCachedRewardFrequencyConfigFetcher as createRewardFrequencyConfigFetcher,
+  // cache
+  getRewardCacheService,
+  refreshRewardCache,
+  refreshGlobalConfigCache,
+  warmupRewardCache,
+  clearRewardCache,
+  getRewardCacheStats
+} from './cached-fetch-reward';
+
+// original version
+export {
+  createRewardFetcher as createRewardFetcherNonCached,
+  createRewardFrequencyConfigFetcher as createRewardFrequencyConfigFetcherNonCached
+} from './cached-fetch-reward';

package/src/common/rewards/index.ts

@@ -10,3 +10,7 @@ export * from './registers/use-jolicoin';
 export * from './registers/use-jolicoin-only';
 export * from './registers/use-gem';
 export * from './registers/use-gem-only';
+export * from './registers/use-subscription';
+
+export { warmupBalanceCache } from './registers/utils/coins/jolicoin/cached-fetch-balance';
+export { warmupGemBalanceCache } from './registers/utils/coins/joligem/cached-fetch-gem-balance';

package/src/common/rewards/registers/use-subscription.ts

@@ -0,0 +1,34 @@
+import { IHttpClient } from '@/common/http';
+import { IAdBreakParams } from '@/common/ads';
+import { unlockOptionsHandler } from './utils/common';
+import { createCommonSubscriptionHandler } from './utils/subscription/sub-handler';
+import { createShowSubscriptionModal } from './utils/subscription/commands/use-subscription';
+
+export type SubscriptionRewardsHandler = (params: IAdBreakParams) => Promise<boolean>;
+export const createSubscriptionRewardHandler = (
+  httpClient: IHttpClient,
+  {
+    onSubSuccess,
+    onSubFailed
+  }: {
+    onSubSuccess?: () => void;
+    onSubFailed?: () => void;
+  }
+): SubscriptionRewardsHandler => {
+  const handleUnlockFailed = () => {
+    onSubFailed?.();
+  };
+
+  const showSubscriptionModal = createShowSubscriptionModal('SUBSCRIPTION');
+
+  const subscriptionRewardHandler = createCommonSubscriptionHandler('SUBSCRIPTION', httpClient, {
+    handlers: {
+      handleSubSuccess: onSubSuccess,
+      handleSubFailed: handleUnlockFailed,
+      unlockOptionsHandler,
+      showSubscriptionModal
+    }
+  });
+
+  return subscriptionRewardHandler;
+};

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

@@ -0,0 +1,177 @@
+import { RequestCacheService, RequestAdapter } from '@jolibox/common';
+import { IHttpClient } from '@/common/http';
+import { StandardResponse } from '@jolibox/types';
+
+interface BalanceRequest {
+  endpoint: string;
+  query?: Record<string, unknown>;
+  method?: 'GET' | 'POST';
+}
+
+// 定义余额响应类型
+interface BalanceResponse {
+  balance: number;
+}
+
+interface BalanceCacheData {
+  balance: number;
+  timestamp: number;
+}
+
+class BalanceRequestAdapter
+  implements RequestAdapter<BalanceRequest, StandardResponse<BalanceResponse>, BalanceCacheData, undefined>
+{
+  constructor(private httpClient: IHttpClient) {}
+
+  async execute(endpoint: string, options?: BalanceRequest): Promise<StandardResponse<BalanceResponse>> {
+    const method = options?.method || 'GET';
+    const query = options?.query || {};
+
+    if (method === 'GET') {
+      return await this.httpClient.get<StandardResponse<BalanceResponse>>(endpoint, {
+        query: query as Record<string, string>
+      });
+    } else {
+      return await this.httpClient.post<StandardResponse<BalanceResponse>>(endpoint, {
+        query: query as Record<string, string>
+      });
+    }
+  }
+
+  extractCacheableData(response: StandardResponse<BalanceResponse>): BalanceCacheData {
+    return {
+      balance: response.data?.balance || 0,
+      timestamp: Date.now()
+    };
+  }
+
+  // 余额使用纯缓存模式
+  extractRealTimeData?: undefined;
+  mergeData?: undefined;
+
+  processCachedData(cached: BalanceCacheData): StandardResponse<BalanceResponse> {
+    return {
+      code: 'SUCCESS',
+      message: 'success from cache',
+      data: {
+        balance: cached.balance
+      }
+    };
+  }
+}
+
+// 缓存余额服务
+export class CachedBalanceService {
+  private balanceService: RequestCacheService<
+    BalanceRequest,
+    StandardResponse<BalanceResponse>,
+    BalanceCacheData,
+    undefined
+  >;
+
+  constructor(httpClient: IHttpClient) {
+    this.balanceService = new (RequestCacheService as new (...args: unknown[]) => RequestCacheService<
+      BalanceRequest,
+      StandardResponse<BalanceResponse>,
+      BalanceCacheData,
+      undefined
+    >)(new BalanceRequestAdapter(httpClient), {
+      duration: 20 * 60 * 1000, // 10min cache， force update every query
+      timeout: 1000, // 1s timeout for request
+      keyGenerator: (endpoint: string, params?: BalanceRequest) => {
+        const queryStr = params?.query ? JSON.stringify(params.query) : '';
+        return `${endpoint}:${queryStr}`;
+      }
+    });
+  }
+
+  async getBalance(type = 'JOLI_COIN'): Promise<BalanceResponse | undefined> {
+    const response = await this.balanceService.request('/api/joli-coin/balance', {
+      endpoint: '/api/joli-coin/balance',
+      query: { type },
+      method: 'GET'
+    });
+    return response.data;
+  }
+
+  async refreshBalance(type = 'JOLI_COIN'): Promise<BalanceResponse | undefined> {
+    const response = await this.balanceService.forceRequest('/api/joli-coin/balance', {
+      endpoint: '/api/joli-coin/balance',
+      query: { type },
+      method: 'GET'
+    });
+    return response.data;
+  }
+
+  async warmupBalance(type = 'JOLI_COIN'): Promise<void> {
+    await this.balanceService.warmupCache('/api/joli-coin/balance', {
+      endpoint: '/api/joli-coin/balance',
+      query: { type },
+      method: 'GET'
+    });
+  }
+
+  clearBalanceCache(): void {
+    this.balanceService.clearCache();
+  }
+
+  getBalanceCacheStats() {
+    return this.balanceService.getCacheStats();
+  }
+
+  clearExpiredCache(): void {
+    this.balanceService.clearExpiredCache();
+  }
+}
+
+// create instance
+let cachedBalanceServiceInstance: CachedBalanceService | null = null;
+
+function getCachedBalanceService(httpClient: IHttpClient): CachedBalanceService {
+  if (!cachedBalanceServiceInstance) {
+    cachedBalanceServiceInstance = new CachedBalanceService(httpClient);
+  }
+  return cachedBalanceServiceInstance;
+}
+
+/**
+ * 缓存版本的 fetchBalance 函数
+ */
+export const fetchBalanceCached = async (httpClient: IHttpClient, type = 'JOLI_COIN') => {
+  const cachedBalanceService = getCachedBalanceService(httpClient);
+  return await cachedBalanceService.getBalance(type);
+};
+
+/**
+ * 强制刷新余额缓存
+ */
+export const refreshBalanceCache = async (httpClient: IHttpClient, type = 'JOLI_COIN') => {
+  const cachedBalanceService = getCachedBalanceService(httpClient);
+  const result = await cachedBalanceService.refreshBalance(type);
+  console.log(`Balance cache refreshed for type: ${type}`);
+  return result;
+};
+
+/**
+ * 预热余额缓存
+ */
+export const warmupBalanceCache = async (httpClient: IHttpClient, type = 'JOLI_COIN') => {
+  const cachedBalanceService = getCachedBalanceService(httpClient);
+  await cachedBalanceService.warmupBalance(type);
+  console.log(`Balance cache warmed up for type: ${type}`);
+};
+
+export const clearBalanceCache = (httpClient: IHttpClient) => {
+  const cachedBalanceService = getCachedBalanceService(httpClient);
+  cachedBalanceService.clearBalanceCache();
+  console.log('Balance cache cleared');
+};
+
+export const getBalanceCacheStats = (httpClient: IHttpClient) => {
+  const cachedBalanceService = getCachedBalanceService(httpClient);
+  return cachedBalanceService.getBalanceCacheStats();
+};
+
+export const getBalanceCacheService = (httpClient: IHttpClient): CachedBalanceService => {
+  return getCachedBalanceService(httpClient);
+};

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

@@ -1,7 +1,19 @@
 import { IHttpClient } from '@/common/http';
 import { StandardResponse } from '@jolibox/types';
 
-export const fetchBalance = async (httpClient: IHttpClient) => {
+// 重新导出缓存版本作为默认实现
+export {
+  fetchBalanceCached as fetchBalance,
+  // 提供缓存管理功能
+  refreshBalanceCache,
+  warmupBalanceCache,
+  clearBalanceCache,
+  getBalanceCacheStats,
+  getBalanceCacheService
+} from './cached-fetch-balance';
+
+// original version
+export const fetchBalanceNonCached = async (httpClient: IHttpClient) => {
   const res = await httpClient.get<
     StandardResponse<{
       balance: number;

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

@@ -16,6 +16,7 @@ import {
 } from '../commands';
 import { rewardsCommands } from '../rewards-command';
 import { RewardsCommandType } from '@jolibox/types';
+import { refreshBalanceCache, warmupBalanceCache } from './cached-fetch-balance';
 
 interface ICurrencyUnlockRes {
   code: 'SUCCESS' | 'BALANCE_NOT_ENOUGH' | 'EPISODE_LOCK_JUMP' | 'EPISODE_UNLOCK_ALREADY';
@@ -103,6 +104,7 @@ const createCommonCurrencyRewardHandler = (
           if ('adViewed' in params) {
             params.adViewed?.();
           }
+          refreshBalanceCache(httpClient);
         } catch (e) {
           console.error('-----unlockWithJolicoin adBreakDone error-----', e);
         }

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

@@ -0,0 +1,181 @@
+import { RequestCacheService, RequestAdapter } from '@jolibox/common';
+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/common/rewards/registers/utils/subscription/commands/index.ts

@@ -0,0 +1 @@
+export * from './use-subscription';

package/src/common/rewards/registers/utils/subscription/commands/use-subscription.ts

@@ -0,0 +1,29 @@
+import { rewardsCommands } from '../../coins/rewards-command';
+import { createEventPromiseHandler } from '../../event-listener';
+import { IUseSubscriptionResultEvent, UseSubscriptionResultEventName } from '@/common/rewards/reward-emitter';
+import { rewardsEmitter, InvokeSubscriptionEventName } from '@/common/rewards/reward-emitter';
+
+export const registerUseSubscriptionCommand = (params: {
+  showSubscriptionModal: () => Promise<'SUCCESS' | 'CANCEL' | 'FAILED'>;
+}) => {
+  const { showSubscriptionModal } = params;
+  rewardsCommands.registerCommand(`Rewards.subscription`, async () => {
+    const subscriptionResult = await showSubscriptionModal();
+    return {
+      result: subscriptionResult === 'SUCCESS' ? 'SUCCESS' : 'FAILED'
+    };
+  });
+};
+
+// EVENTS
+export const createShowSubscriptionModal = (type: 'SUBSCRIPTION') => {
+  return async () => {
+    const modalHandler = createEventPromiseHandler<
+      IUseSubscriptionResultEvent,
+      typeof UseSubscriptionResultEventName
+    >(rewardsEmitter, UseSubscriptionResultEventName);
+    rewardsEmitter.emit(InvokeSubscriptionEventName, type);
+    const modalResult = await modalHandler.getFreshData();
+    return modalResult.result;
+  };
+};