@jolibox/implement 1.2.7 → 1.2.9-beta.9

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

@@ -6,7 +6,7 @@ import { applyNative } from '@jolibox/native-bridge';
 import { innerFetch as fetch } from '@/native/network';
 import type { PaymentResult } from './payment-helper';
 import { RequestCacheService, RequestAdapter } from '@jolibox/common';
-
+import { executeWithPersistentCache } from './utils/cache-with-storage';
 type PaymentPurchaseType = 'JOLI_COIN' | 'JOLI_GEM';
 
 // Request/Response interfaces for RequestCacheService
@@ -51,7 +51,7 @@ class PaymentRequestAdapter
 {
   // applyNative 的缓存
   private static nativePriceCache = new Map<string, { [appStoreProductId: string]: { price: string } }>();
-  private static readonly NATIVE_PRICE_CACHE_DURATION = 30 * 60 * 1000; // 30分钟缓存
+  private static readonly NATIVE_PRICE_CACHE_DURATION = 1 * 24 * 60 * 60 * 1000; // 1 day
   private static nativePriceCacheTimestamp = new Map<string, number>();
 
   async execute(endpoint: string, _options?: PaymentRequest): Promise<PaymentResponse> {
@@ -92,34 +92,33 @@ class PaymentRequestAdapter
   private async getNativePriceData(
     appStoreProductIds: string[]
   ): Promise<{ [appStoreProductId: string]: { price: string } } | null> {
-    // 检查缓存
     const cacheKey = appStoreProductIds.sort().join(',');
-    const cached = PaymentRequestAdapter.nativePriceCache.get(cacheKey);
-    const cacheTime = PaymentRequestAdapter.nativePriceCacheTimestamp.get(cacheKey) || 0;
-
-    if (cached && Date.now() - cacheTime < PaymentRequestAdapter.NATIVE_PRICE_CACHE_DURATION) {
-      console.log('[PaymentService] Using cached native price data');
-      return cached;
-    }
 
-    console.log('[PaymentService] Fetching fresh native price data');
-
-    try {
-      const { data } = await applyNative('requestProductDetailsAsync', {
-        appStoreProductIds
-      });
-
-      if (data) {
-        // cache
-        PaymentRequestAdapter.nativePriceCache.set(cacheKey, data);
-        PaymentRequestAdapter.nativePriceCacheTimestamp.set(cacheKey, Date.now());
+    return executeWithPersistentCache(
+      cacheKey,
+      async () => {
+        try {
+          const { data } = await applyNative('requestProductDetailsAsync', {
+            appStoreProductIds
+          });
+
+          if (data) {
+            // cache
+            PaymentRequestAdapter.nativePriceCache.set(cacheKey, data);
+            PaymentRequestAdapter.nativePriceCacheTimestamp.set(cacheKey, Date.now());
+          }
+
+          return data;
+        } catch (error) {
+          console.warn('[PaymentService] Failed to fetch native product details:', error);
+          throw error; // rethrow error, let upper layer handle it
+        }
+      },
+      {
+        cacheDuration: PaymentRequestAdapter.NATIVE_PRICE_CACHE_DURATION,
+        storageKeyPrefix: 'joli_native_price_'
       }
-
-      return data;
-    } catch (error) {
-      console.warn('[PaymentService] Failed to fetch native product details:', error);
-      throw error; // rethrow error, let upper layer handle it
-    }
+    );
   }
 
   extractCacheableData(response: PaymentResponse): PaymentCacheData {

package/src/native/payment/utils/__tests__/cache-with-storage.test.ts

@@ -0,0 +1,414 @@
+import { executeWithPersistentCache } from '../cache-with-storage';
+import { setGlobalStorage, getGlobalStorage } from '@/native/api/storage';
+
+// Mock native bridge to prevent invokeNative errors
+jest.mock('@jolibox/native-bridge', () => ({
+  invokeNative: jest.fn(),
+  applyNative: jest.fn()
+}));
+
+// Mock storage functions
+jest.mock('@/native/api/storage', () => ({
+  setGlobalStorage: jest.fn(),
+  getGlobalStorage: jest.fn()
+}));
+
+const mockSetGlobalStorage = setGlobalStorage as jest.MockedFunction<typeof setGlobalStorage>;
+const mockGetGlobalStorage = getGlobalStorage as jest.MockedFunction<typeof getGlobalStorage>;
+
+describe('executeWithPersistentCache', () => {
+  const mockExecutor = jest.fn();
+  const testCacheKey = 'test-key';
+  const testData = { value: 'test-data' };
+  const mockTimestamp = 1640000000000;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(Date, 'now').mockReturnValue(mockTimestamp);
+    jest.spyOn(console, 'log').mockImplementation();
+    jest.spyOn(console, 'warn').mockImplementation();
+    // Mock 成功的 setGlobalStorage 响应
+    mockSetGlobalStorage.mockResolvedValue({
+      code: 'SUCCESS',
+      message: 'success'
+    });
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('Cache miss scenarios', () => {
+    it('should execute function and cache result when no cached data exists', async () => {
+      // Setup: no cached data
+      mockGetGlobalStorage.mockResolvedValue({
+        code: 'SUCCESS',
+        message: 'success',
+        data: null
+      });
+      mockExecutor.mockResolvedValue(testData);
+
+      const result = await executeWithPersistentCache(testCacheKey, mockExecutor);
+
+      expect(result).toEqual(testData);
+      expect(mockExecutor).toHaveBeenCalledTimes(1);
+      expect(mockSetGlobalStorage).toHaveBeenCalledWith('joli_cache_test-key', testData);
+      expect(mockSetGlobalStorage).toHaveBeenCalledWith(
+        'joli_cache_test-key_timestamp',
+        mockTimestamp.toString()
+      );
+    });
+
+    it('should execute function when cached data is expired', async () => {
+      const expiredTimestamp = (mockTimestamp - 60 * 60 * 1000).toString(); // 1 hour ago
+
+      mockGetGlobalStorage
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: JSON.stringify(testData)
+        })
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: expiredTimestamp
+        });
+      mockExecutor.mockResolvedValue({ value: 'fresh-data' });
+
+      const result = await executeWithPersistentCache(testCacheKey, mockExecutor, {
+        cacheDuration: 30 * 60 * 1000 // 30 minutes
+      });
+
+      expect(result).toEqual({ value: 'fresh-data' });
+      expect(mockExecutor).toHaveBeenCalledTimes(1);
+      // Should clear expired cache
+      expect(mockSetGlobalStorage).toHaveBeenCalledWith('joli_cache_test-key', null);
+      expect(mockSetGlobalStorage).toHaveBeenCalledWith('joli_cache_test-key_timestamp', null);
+    });
+  });
+
+  describe('Cache hit scenarios', () => {
+    it('should return cached data when valid cache exists', async () => {
+      const validTimestamp = (mockTimestamp - 10 * 60 * 1000).toString(); // 10 minutes ago
+
+      mockGetGlobalStorage
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: JSON.stringify(testData)
+        })
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: validTimestamp
+        });
+
+      const result = await executeWithPersistentCache(testCacheKey, mockExecutor, {
+        cacheDuration: 30 * 60 * 1000 // 30 minutes
+      });
+
+      expect(result).toEqual(testData);
+      expect(mockExecutor).not.toHaveBeenCalled();
+    });
+
+    it('should return cached data and update in background when cache is valid but not never-expire', async () => {
+      const validTimestamp = (mockTimestamp - 10 * 60 * 1000).toString();
+
+      mockGetGlobalStorage
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: JSON.stringify(testData)
+        })
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: validTimestamp
+        });
+
+      // 创建一个新的 executor 实例以避免跨测试的状态污染
+      const backgroundExecutor = jest.fn().mockResolvedValue({ value: 'updated-data' });
+
+      const result = await executeWithPersistentCache(testCacheKey, backgroundExecutor, {
+        cacheDuration: 30 * 60 * 1000
+      });
+
+      expect(result).toEqual(testData);
+
+      // 等待更长时间确保背景更新完成
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      expect(backgroundExecutor).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('Never-expire cache', () => {
+    it('should return cached data without background update when cacheDuration is Infinity', async () => {
+      const oldTimestamp = (mockTimestamp - 24 * 60 * 60 * 1000).toString(); // 24 hours ago
+
+      mockGetGlobalStorage
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: JSON.stringify(testData)
+        })
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: oldTimestamp
+        });
+
+      const result = await executeWithPersistentCache(testCacheKey, mockExecutor, {
+        cacheDuration: Infinity
+      });
+
+      expect(result).toEqual(testData);
+      expect(mockExecutor).not.toHaveBeenCalled();
+
+      // Wait to ensure no background update
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      expect(mockExecutor).not.toHaveBeenCalled();
+    });
+
+    it('should return cached data without background update when cacheDuration is -1', async () => {
+      const oldTimestamp = (mockTimestamp - 24 * 60 * 60 * 1000).toString();
+
+      mockGetGlobalStorage
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: JSON.stringify(testData)
+        })
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: oldTimestamp
+        });
+
+      const result = await executeWithPersistentCache(testCacheKey, mockExecutor, {
+        cacheDuration: -1
+      });
+
+      expect(result).toEqual(testData);
+      expect(mockExecutor).not.toHaveBeenCalled();
+    });
+
+    it('should use default Infinity cacheDuration when not specified', async () => {
+      const oldTimestamp = (mockTimestamp - 24 * 60 * 60 * 1000).toString();
+
+      mockGetGlobalStorage
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: JSON.stringify(testData)
+        })
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: oldTimestamp
+        });
+
+      const result = await executeWithPersistentCache(testCacheKey, mockExecutor);
+
+      expect(result).toEqual(testData);
+      expect(mockExecutor).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Storage options', () => {
+    it('should use custom storage key prefix', async () => {
+      mockGetGlobalStorage.mockResolvedValue({
+        code: 'SUCCESS',
+        message: 'success',
+        data: null
+      });
+      mockExecutor.mockResolvedValue(testData);
+
+      await executeWithPersistentCache(testCacheKey, mockExecutor, {
+        storageKeyPrefix: 'custom_prefix_'
+      });
+
+      expect(mockGetGlobalStorage).toHaveBeenCalledWith('custom_prefix_test-key');
+      expect(mockGetGlobalStorage).toHaveBeenCalledWith('custom_prefix_test-key_timestamp');
+      expect(mockSetGlobalStorage).toHaveBeenCalledWith('custom_prefix_test-key', testData);
+      expect(mockSetGlobalStorage).toHaveBeenCalledWith(
+        'custom_prefix_test-key_timestamp',
+        mockTimestamp.toString()
+      );
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should handle getGlobalStorage error and fallback to executor', async () => {
+      mockGetGlobalStorage.mockRejectedValue(new Error('Storage read error'));
+      mockExecutor.mockResolvedValue(testData);
+
+      const result = await executeWithPersistentCache(testCacheKey, mockExecutor);
+
+      expect(result).toEqual(testData);
+      expect(mockExecutor).toHaveBeenCalledTimes(1);
+      expect(console.warn).toHaveBeenCalledWith(
+        '[Cache] Failed to read from localStorage for key:',
+        testCacheKey,
+        expect.any(Error)
+      );
+    });
+
+    it('should handle setGlobalStorage error but still return data', async () => {
+      mockGetGlobalStorage.mockResolvedValue({
+        code: 'SUCCESS',
+        message: 'success',
+        data: null
+      });
+      mockSetGlobalStorage.mockRejectedValue(new Error('Storage write error'));
+      mockExecutor.mockResolvedValue(testData);
+
+      const result = await executeWithPersistentCache(testCacheKey, mockExecutor);
+
+      expect(result).toEqual(testData);
+      expect(console.warn).toHaveBeenCalledWith(
+        '[Cache] Failed to save to localStorage for key:',
+        testCacheKey,
+        expect.any(Error)
+      );
+    });
+
+    it('should propagate executor errors', async () => {
+      mockGetGlobalStorage.mockResolvedValue({
+        code: 'SUCCESS',
+        message: 'success',
+        data: null
+      });
+      const executorError = new Error('Executor failed');
+      mockExecutor.mockRejectedValue(executorError);
+
+      await expect(executeWithPersistentCache(testCacheKey, mockExecutor)).rejects.toThrow('Executor failed');
+      expect(console.warn).toHaveBeenCalledWith(
+        '[Cache] Executor failed for key:',
+        testCacheKey,
+        executorError
+      );
+    });
+
+    it('should handle JSON parse error in cached data', async () => {
+      mockGetGlobalStorage
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: 'invalid-json{'
+        })
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: mockTimestamp.toString()
+        });
+      mockExecutor.mockResolvedValue(testData);
+
+      const result = await executeWithPersistentCache(testCacheKey, mockExecutor);
+
+      expect(result).toEqual(testData);
+      expect(mockExecutor).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle background update errors gracefully', async () => {
+      const validTimestamp = (mockTimestamp - 10 * 60 * 1000).toString();
+
+      mockGetGlobalStorage
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: JSON.stringify(testData)
+        })
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: validTimestamp
+        });
+
+      const backgroundExecutor = jest.fn().mockRejectedValue(new Error('Background update failed'));
+
+      const result = await executeWithPersistentCache(testCacheKey, backgroundExecutor, {
+        cacheDuration: 30 * 60 * 1000
+      });
+
+      expect(result).toEqual(testData);
+
+      // Wait for background update to fail
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      expect(console.warn).toHaveBeenCalledWith(
+        '[Cache] Background cache update failed for key:',
+        testCacheKey,
+        expect.any(Error)
+      );
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle missing timestamp in cache', async () => {
+      mockGetGlobalStorage
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: JSON.stringify(testData)
+        })
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: null
+        }); // Missing timestamp
+      mockExecutor.mockResolvedValue({ value: 'fresh-data' });
+
+      const result = await executeWithPersistentCache(testCacheKey, mockExecutor, {
+        cacheDuration: 30 * 60 * 1000
+      });
+
+      expect(result).toEqual({ value: 'fresh-data' });
+      expect(mockExecutor).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle invalid timestamp format', async () => {
+      mockGetGlobalStorage
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: JSON.stringify(testData)
+        })
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: 'invalid-timestamp'
+        });
+      mockExecutor.mockResolvedValue({ value: 'fresh-data' });
+
+      const result = await executeWithPersistentCache(testCacheKey, mockExecutor, {
+        cacheDuration: 30 * 60 * 1000
+      });
+
+      expect(result).toEqual({ value: 'fresh-data' });
+      expect(mockExecutor).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle zero cacheDuration (immediate expiration)', async () => {
+      mockGetGlobalStorage
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: JSON.stringify(testData)
+        })
+        .mockResolvedValueOnce({
+          code: 'SUCCESS',
+          message: 'success',
+          data: mockTimestamp.toString()
+        });
+      mockExecutor.mockResolvedValue({ value: 'fresh-data' });
+
+      const result = await executeWithPersistentCache(testCacheKey, mockExecutor, {
+        cacheDuration: 0
+      });
+
+      expect(result).toEqual({ value: 'fresh-data' });
+      expect(mockExecutor).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/src/native/payment/utils/cache-with-storage.ts

@@ -0,0 +1,112 @@
+import { setGlobalStorage, getGlobalStorage } from '@/native/api/storage';
+
+export async function executeAndCache<T>(
+  cacheKey: string,
+  executor: () => Promise<T>,
+  options: {
+    storageKeyPrefix?: string;
+  } = {}
+): Promise<T> {
+  const { storageKeyPrefix = 'joli_cache_' } = options;
+
+  const storageKey = storageKeyPrefix + cacheKey;
+  const timestampKey = storageKey + '_timestamp';
+
+  try {
+    const data = await executor();
+    const timestamp = Date.now();
+
+    // 执行后直接缓存结果
+    try {
+      if (data !== null && data !== undefined) {
+        await setGlobalStorage(storageKey, data);
+        await setGlobalStorage(timestampKey, timestamp.toString());
+        console.log('[Cache] Cached result for key:', cacheKey);
+      }
+    } catch (error) {
+      console.warn('[Cache] Failed to save to localStorage for key:', cacheKey, error);
+    }
+
+    return data;
+  } catch (error) {
+    console.warn('[Cache] Executor failed for key:', cacheKey, error);
+    throw error;
+  }
+}
+
+export async function executeWithPersistentCache<T>(
+  cacheKey: string,
+  executor: () => Promise<T>,
+  options: {
+    cacheDuration?: number;
+    storageKeyPrefix?: string;
+  } = {}
+): Promise<T> {
+  const {
+    cacheDuration = -1, // 永不过期
+    storageKeyPrefix = 'joli_cache_'
+  } = options;
+
+  const storageKey = storageKeyPrefix + cacheKey;
+  const timestampKey = storageKey + '_timestamp';
+  const neverExpires = cacheDuration === Infinity || cacheDuration === -1;
+
+  // 1. 先尝试从 localStorage 读取数据
+  try {
+    const { data: dataStr } = await getGlobalStorage(storageKey);
+    const { data: timestampStr } = await getGlobalStorage(timestampKey);
+
+    if (dataStr && timestampStr) {
+      const timestamp = parseInt(timestampStr, 10);
+
+      if (neverExpires || Date.now() - timestamp < cacheDuration) {
+        console.log('[Cache] Using localStorage cached data for key:', cacheKey);
+        const data = JSON.parse(dataStr);
+
+        // 如果不是永不过期，后台异步更新缓存（不阻塞返回）
+        if (!neverExpires) {
+          setTimeout(async () => {
+            try {
+              console.log('[Cache] Background updating cache for key:', cacheKey);
+              const freshData = await executor();
+              const newTimestamp = Date.now();
+
+              await setGlobalStorage(storageKey, freshData);
+              await setGlobalStorage(timestampKey, newTimestamp.toString());
+              console.log('[Cache] Background cache update completed for key:', cacheKey);
+            } catch (error) {
+              console.warn('[Cache] Background cache update failed for key:', cacheKey, error);
+            }
+          }, 0);
+        }
+
+        return data;
+      } else {
+        await setGlobalStorage(storageKey, null);
+        await setGlobalStorage(timestampKey, null);
+      }
+    }
+  } catch (error) {
+    console.warn('[Cache] Failed to read from localStorage for key:', cacheKey, error);
+  }
+
+  try {
+    const data = await executor();
+    const timestamp = Date.now();
+
+    // 保存到 localStorage
+    try {
+      if (data) {
+        await setGlobalStorage(storageKey, data);
+        await setGlobalStorage(timestampKey, timestamp.toString());
+      }
+    } catch (error) {
+      console.warn('[Cache] Failed to save to localStorage for key:', cacheKey, error);
+    }
+
+    return data;
+  } catch (error) {
+    console.warn('[Cache] Executor failed for key:', cacheKey, error);
+    throw error;
+  }
+}

package/src/native/rewards/check-frequency.ts

@@ -58,6 +58,9 @@ export const checkUseModalFrequencyGem = createFrequencyChecker('joli_gem_use_mo
 export const checkPaymentFrequencyGem = createFrequencyChecker('joli_gem_payment_frequency');
 export const checkUnloginModalFrequencyGem = createFrequencyChecker('joli_gem_unlogin_modal_frequency');
 
+// subscription frequency
+export const checkSubscriptionFrequency = createFrequencyChecker('subscription_frequency');
+
 // common update frequency
 function createFrequencyUpdater(storageKey: string) {
   return async () => {
@@ -78,3 +81,6 @@ export const updateUnloginModalFrequency = createFrequencyUpdater('joli_coin_unl
 export const updateUseModalFrequencyGem = createFrequencyUpdater('joli_gem_use_modal_frequency');
 export const updatePaymentFrequencyGem = createFrequencyUpdater('joli_gem_payment_frequency');
 export const updateUnloginModalFrequencyGem = createFrequencyUpdater('joli_gem_unlogin_modal_frequency');
+
+// subscription frequency
+export const updateSubscriptionFrequency = createFrequencyUpdater('subscription_frequency');

package/src/native/rewards/index.ts

@@ -5,3 +5,4 @@
 import './ui/use-modal';
 import './ui/payment-modal';
 import './ui/unlogin-modal';
+import './ui/subscription-modal';

package/src/native/rewards/ui/payment-modal.ts

@@ -143,7 +143,7 @@ rewardsEmitter.on(
       const balenceDetails = await paymentService.getProductsInfo();
       loading.hide();
 
-      if (!balenceDetails) {
+      if (!balenceDetails || !balenceDetails.paymentChoices?.length) {
         rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED', currency: currencyType });
         return;
       }
@@ -279,7 +279,7 @@ rewardsEmitter.on(
 
       await paymentConfig.frequencyUpdater();
     } catch (error) {
-      console.info('payment failed', error);
+      console.error('payment failed', error);
       rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED', currency: params.currency });
     }
   }