@jolibox/implement 1.2.4 → 1.2.5

package/src/common/rewards/cached-reward-service.ts

@@ -0,0 +1,255 @@
+import { RequestCacheService, RequestAdapter } from '../cache/request-cache-service';
+import { IHttpClient } from '../http';
+import { StandardResponse, GlobalConfig } from '@jolibox/types';
+import { IJolicoinRewardOption, IUnlockOption, IJoliCoin, IGem } from './type';
+import { IUseModalFrequencyConfig } from './reward-emitter';
+
+// 定义请求参数类型
+interface RewardRequest {
+  endpoint: string;
+  body?: Record<string, unknown>;
+  method?: 'GET' | 'POST';
+}
+
+interface UnlockOptionsCacheData {
+  unlockOptions: IUnlockOption[];
+  joliCoin: IJoliCoin;
+  joliGem: IGem;
+}
+
+interface UnlockOptionsRealTimeData {
+  timestamp?: number;
+}
+
+// 定义全局配置的缓存数据
+interface GlobalConfigCacheData {
+  joliCoinUseAndCharge: IUseModalFrequencyConfig['joliCoinUseAndCharge'];
+  loginGuide: IUseModalFrequencyConfig['loginGuide'];
+  // 其他全局配置字段
+  [key: string]: unknown;
+}
+
+// 奖励接口适配器
+class RewardRequestAdapter
+  implements
+    RequestAdapter<RewardRequest, IJolicoinRewardOption, UnlockOptionsCacheData, UnlockOptionsRealTimeData>
+{
+  constructor(private httpClient: IHttpClient) {}
+
+  async execute(endpoint: string, options?: RewardRequest): Promise<IJolicoinRewardOption> {
+    const method = options?.method || 'POST';
+    const body = options?.body || {};
+
+    if (method === 'GET') {
+      return await this.httpClient.get<IJolicoinRewardOption>(endpoint, body);
+    } else {
+      return await this.httpClient.post<IJolicoinRewardOption>(endpoint, body);
+    }
+  }
+
+  extractCacheableData(response: IJolicoinRewardOption): UnlockOptionsCacheData {
+    return {
+      unlockOptions: response.data?.unlockOptions || [],
+      joliCoin: response.extra.joliCoin,
+      joliGem: response.extra.joliGem || { balance: 0, enableAutoDeduct: false }
+    };
+  }
+
+  extractRealTimeData?: undefined;
+
+  mergeData(cached: UnlockOptionsCacheData, realTime: UnlockOptionsRealTimeData): IJolicoinRewardOption {
+    return {
+      code: 'SUCCESS',
+      message: 'success',
+      data: {
+        unlockOptions: cached.unlockOptions
+      },
+      extra: {
+        joliCoin: cached.joliCoin,
+        joliGem: cached.joliGem
+      }
+    };
+  }
+
+  processCachedData(cached: UnlockOptionsCacheData): IJolicoinRewardOption {
+    return {
+      code: 'SUCCESS',
+      message: 'success from cache',
+      data: {
+        unlockOptions: cached.unlockOptions
+      },
+      extra: {
+        joliCoin: cached.joliCoin,
+        joliGem: cached.joliGem
+      }
+    };
+  }
+}
+
+class GlobalConfigRequestAdapter
+  implements
+    RequestAdapter<
+      RewardRequest,
+      StandardResponse<GlobalConfig & IUseModalFrequencyConfig>,
+      GlobalConfigCacheData,
+      undefined
+    >
+{
+  constructor(private httpClient: IHttpClient) {}
+
+  async execute(
+    endpoint: string,
+    options?: RewardRequest
+  ): Promise<StandardResponse<GlobalConfig & IUseModalFrequencyConfig>> {
+    const method = options?.method || 'GET';
+    const body = options?.body || {};
+
+    if (method === 'GET') {
+      return await this.httpClient.get<StandardResponse<GlobalConfig & IUseModalFrequencyConfig>>(
+        endpoint,
+        body
+      );
+    } else {
+      return await this.httpClient.post<StandardResponse<GlobalConfig & IUseModalFrequencyConfig>>(
+        endpoint,
+        body
+      );
+    }
+  }
+
+  extractCacheableData(
+    response: StandardResponse<GlobalConfig & IUseModalFrequencyConfig>
+  ): GlobalConfigCacheData {
+    const data = response.data;
+    return {
+      joliCoinUseAndCharge: data?.joliCoinUseAndCharge,
+      loginGuide: data?.loginGuide,
+      ...data // 包含其他所有配置字段
+    } as GlobalConfigCacheData;
+  }
+
+  extractRealTimeData?: undefined;
+  mergeData?: undefined;
+
+  processCachedData(
+    cached: GlobalConfigCacheData
+  ): StandardResponse<GlobalConfig & IUseModalFrequencyConfig> {
+    return {
+      code: 'SUCCESS',
+      message: 'success from cache',
+      data: cached as GlobalConfig & IUseModalFrequencyConfig
+    };
+  }
+}
+
+export class CachedRewardService {
+  private unlockOptionsService: RequestCacheService<
+    RewardRequest,
+    IJolicoinRewardOption,
+    UnlockOptionsCacheData,
+    UnlockOptionsRealTimeData
+  >;
+  private globalConfigService: RequestCacheService<
+    RewardRequest,
+    StandardResponse<GlobalConfig & IUseModalFrequencyConfig>,
+    GlobalConfigCacheData,
+    undefined
+  >;
+
+  constructor(httpClient: IHttpClient) {
+    // 创建 unlock-options 服务，缓存 unlockOptions，实时获取余额
+    this.unlockOptionsService = new (RequestCacheService as new (...args: unknown[]) => RequestCacheService<
+      RewardRequest,
+      IJolicoinRewardOption,
+      UnlockOptionsCacheData,
+      UnlockOptionsRealTimeData
+    >)(new RewardRequestAdapter(httpClient), {
+      duration: 30 * 60 * 1000, // 30分钟缓存
+      timeout: 1000, // 1s timeout for request
+      keyGenerator: (endpoint: string) => endpoint,
+      // unlockOptions 结构一致性检查
+      consistencyChecker: (cached: UnlockOptionsCacheData, serverData: UnlockOptionsCacheData) => {
+        if (cached.unlockOptions.length !== serverData.unlockOptions.length) {
+          return false;
+        }
+        return cached.unlockOptions.every((cachedOption: IUnlockOption, index: number) => {
+          const serverOption = serverData.unlockOptions[index];
+          return (
+            cachedOption.type === serverOption.type &&
+            cachedOption.joliGemChoice?.joliGemQuantity === serverOption.joliGemChoice?.joliGemQuantity
+          );
+        });
+      }
+    });
+
+    this.globalConfigService = new (RequestCacheService as new (...args: unknown[]) => RequestCacheService<
+      RewardRequest,
+      StandardResponse<GlobalConfig & IUseModalFrequencyConfig>,
+      GlobalConfigCacheData,
+      undefined
+    >)(new GlobalConfigRequestAdapter(httpClient), {
+      duration: 60 * 60 * 1000, // 60分钟缓存
+      timeout: 1000, // 1s timeout for request
+      keyGenerator: (endpoint: string) => endpoint
+    });
+  }
+
+  async getUnlockOptions(body: Record<string, unknown> = {}): Promise<IJolicoinRewardOption> {
+    return await this.unlockOptionsService.request('/api/games/unlock-options', {
+      endpoint: '/api/games/unlock-options',
+      body,
+      method: 'POST'
+    });
+  }
+
+  async getGlobalConfig(): Promise<StandardResponse<GlobalConfig & IUseModalFrequencyConfig>> {
+    return await this.globalConfigService.request('/api/fe-configs/web-common/global-config', {
+      endpoint: '/api/fe-configs/web-common/global-config',
+      method: 'GET'
+    });
+  }
+  async refreshUnlockOptions(body: Record<string, unknown> = {}): Promise<IJolicoinRewardOption> {
+    return await this.unlockOptionsService.forceRequest('/api/games/unlock-options', {
+      endpoint: '/api/games/unlock-options',
+      body,
+      method: 'POST'
+    });
+  }
+
+  async refreshGlobalConfig(): Promise<StandardResponse<GlobalConfig & IUseModalFrequencyConfig>> {
+    return await this.globalConfigService.forceRequest('/api/fe-configs/web-common/global-config', {
+      endpoint: '/api/fe-configs/web-common/global-config',
+      method: 'GET'
+    });
+  }
+
+  async warmupCache(): Promise<void> {
+    await Promise.all([
+      this.unlockOptionsService.warmupCache('/api/games/unlock-options', {
+        endpoint: '/api/games/unlock-options',
+        method: 'POST'
+      }),
+      this.globalConfigService.warmupCache('/api/fe-configs/web-common/global-config', {
+        endpoint: '/api/fe-configs/web-common/global-config',
+        method: 'GET'
+      })
+    ]);
+  }
+
+  clearAllCache(): void {
+    this.unlockOptionsService.clearCache();
+    this.globalConfigService.clearCache();
+  }
+
+  getCacheStats() {
+    return {
+      unlockOptions: this.unlockOptionsService.getCacheStats(),
+      globalConfig: this.globalConfigService.getCacheStats()
+    };
+  }
+
+  clearExpiredCache(): void {
+    this.unlockOptionsService.clearExpiredCache();
+    this.globalConfigService.clearExpiredCache();
+  }
+}

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,6 @@ export * from './registers/use-jolicoin';
 export * from './registers/use-jolicoin-only';
 export * from './registers/use-gem';
 export * from './registers/use-gem-only';
+
+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/utils/coins/commands/use-payment.ts

@@ -10,6 +10,8 @@ import {
   InvokePaymentEventName
 } from '@/common/rewards/reward-emitter';
 import { CURRENCY_HANDLERS, CurrencyType } from './currency-handlers';
+import { refreshGemBalanceCache } from '../joligem/cached-fetch-gem-balance';
+import { refreshBalanceCache } from '../jolicoin/cached-fetch-balance';
 
 export const registerUsePaymentCommand = <T extends IJoliCoin | IGem>(
   prefix: 'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM',
@@ -48,6 +50,12 @@ export const registerUsePaymentCommand = <T extends IJoliCoin | IGem>(
         currency: currency as T extends IJoliCoin ? 'JOLI_COIN' : 'JOLI_GEM'
       });
 
+      if (currency === 'JOLI_GEM') {
+        refreshGemBalanceCache(httpClient);
+      } else {
+        refreshBalanceCache(httpClient);
+      }
+
       return {
         result: paymentResult === 'SUCCESS' ? 'SUCCESS' : 'FAILED'
       };

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

@@ -0,0 +1,177 @@
+import { RequestCacheService, RequestAdapter } from '@/common/cache/request-cache-service';
+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);
         }