@jolibox/implement 1.3.1 → 1.3.2

package/dist/native/subscription/subscription-service.d.ts

@@ -24,6 +24,7 @@ declare class BaseSubscriptionService extends RequestCacheService<SubscriptionRe
         message: string;
         result: 'SUCCESS' | 'FAILED' | 'FAILURE_SUBSCRIPTED';
     }>;
+    private pollSubscriptionStatus;
     invokeSubscriptionPanel(): Promise<StandardResponse<{
         result: 'SUCCESS' | 'FAILED';
         subPlanId?: string;

package/implement.build.log

@@ -1,9 +1,9 @@
 Invoking: npm run clean && npm run build:esm && tsc 
 
-> @jolibox/implement@1.3.1 clean
+> @jolibox/implement@1.3.2 clean
 > rimraf ./dist
 
 
-> @jolibox/implement@1.3.1 build:esm
+> @jolibox/implement@1.3.2 build:esm
 > BUILD_VERSION=$(node -p "require('./package.json').version")  node esbuild.config.js --format=esm
 

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@jolibox/implement",
   "description": "This project is Jolibox JS-SDk implement for Native && H5",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "@jolibox/common": "1.3.1",
-    "@jolibox/types": "1.3.1",
-    "@jolibox/native-bridge": "1.3.1",
-    "@jolibox/ads": "1.3.1",
+    "@jolibox/common": "1.3.2",
+    "@jolibox/types": "1.3.2",
+    "@jolibox/native-bridge": "1.3.2",
+    "@jolibox/ads": "1.3.2",
     "localforage": "1.10.0",
     "@jolibox/ui": "1.0.0",
     "web-vitals": "4.2.4"

package/src/native/api/payment.ts

@@ -34,7 +34,7 @@ const purchaseGem = createAPI('purchaseGem', {
 const getGemProducts = createAPI('getGemProducts', {
   paramsSchema: t.tuple(),
   implement: async (): Promise<{ products: IPaymentChoice[] }> => {
-    const choices = (await paymentService.getProductsInfo())?.paymentChoices ?? [];
+    const choices = (await paymentService.getProductsInfoWithBalance())?.paymentChoices ?? [];
     console.info('choices', choices);
     return {
       products: choices.map((choice) => ({
@@ -92,7 +92,14 @@ const subscribe = createAPI('subscribe', {
       });
     }
     const { basePlanId, appStoreProductId, nativeProductId } = tier;
-    const result = await subscriptionService.subscribe({ basePlanId, nativeProductId, appStoreProductId });
+
+    // Use subscription service with built-in compensation polling
+    const result = await subscriptionService.subscribe({
+      basePlanId,
+      nativeProductId,
+      appStoreProductId
+    });
+
     return {
       result: result.result,
       subPlanId: result.subPlanId,

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

@@ -151,9 +151,9 @@ describe('PaymentService - Basic Tests', () => {
     const promise = paymentService.getProductsInfo();
 
     // Fast forward past timeout (1 second)
-    jest.advanceTimersByTime(1000);
+    jest.advanceTimersByTime(3000);
 
-    await expect(promise).rejects.toThrow('[RequestCacheService] Request timeout after 1 seconds');
+    await expect(promise).rejects.toThrow('[RequestCacheService] Request timeout after 3 seconds');
   });
 
   it('should handle cache expiration', async () => {
@@ -217,16 +217,16 @@ describe('PaymentService - Basic Tests', () => {
                 }
               }
             });
-          }, 2000);
+          }, 5000);
         })
     );
 
     const promise = paymentService.getProductsInfo();
 
     // Advance timers to 1 second to trigger timeout
-    jest.advanceTimersByTime(1000);
+    jest.advanceTimersByTime(3000);
 
-    await expect(promise).rejects.toThrow('[RequestCacheService] Request timeout after 1 seconds');
+    await expect(promise).rejects.toThrow('[RequestCacheService] Request timeout after 3 seconds');
   });
 
   it('should increment failure count on failed requests', async () => {

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

@@ -167,7 +167,7 @@ class BasePaymentService extends RequestCacheService<
   constructor(private apiEndpoint: string, private paymentType: PaymentPurchaseType) {
     super(new PaymentRequestAdapter(), {
       duration: 10 * 60 * 1000, // 10分钟缓存 paymentChoices
-      timeout: 1000 // 1秒超时
+      timeout: 3000 // 3秒超时
     });
   }
 

package/src/native/payment/registers/jolicoin-iap.ts

@@ -40,10 +40,6 @@ onNative('onPaymentStateChange', (data) => {
   }
 
   if (status === 'SUCCESS') {
-    createToast(`{slot-success} {slot-i18n-jolicoin.unlockSuccess}`, {
-      position: 'center',
-      duration: 3000
-    });
     deferred.resolve({
       code: 'SUCCESS' as ResponseType,
       message: 'jolicoin payment success',

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

@@ -7,7 +7,7 @@ import {
   UseModalFrequencyEventName,
   IUseModalFrequencyConfig
 } from '@/common/rewards/reward-emitter';
-import { createPaymentJolicoinModal } from '@jolibox/ui';
+import { createPaymentJolicoinModal, createToast } from '@jolibox/ui';
 import { innerFetch as fetch } from '@/native/network';
 import { StandardResponse } from '@jolibox/types';
 import { context } from '@/common/context';
@@ -220,6 +220,7 @@ rewardsEmitter.on(
                 productId,
                 appStoreProductId
               });
+
               loading.hide();
               track(paymentConfig.trackEvents.payResult, {
                 eventType: EventType.Other,
@@ -232,12 +233,15 @@ rewardsEmitter.on(
                     ?.totalAmountStr ?? '',
                 payResult: code
               });
-              console.log('payment result', code);
               if (code !== 'SUCCESS') {
                 /** add timeout for google panel closed */
                 console.info('[JoliboxSDK] payment failed in payment.invokePaymet');
                 return;
               }
+              createToast(`{slot-success} {slot-i18n-jolicoin.unlockSuccess}`, {
+                position: 'center',
+                duration: 3000
+              });
               rewardsEmitter.emit(PaymentResultEventName, {
                 paymentResult: 'SUCCESS',
                 currency: currencyType

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

@@ -1,6 +1,6 @@
 import { ISubscriptionPlanData } from './type';
 import { ISubscriptionTierData } from '@jolibox/types';
-import { Deferred, isUndefinedOrNull } from '@jolibox/common';
+import { Deferred, isUndefinedOrNull, sleep } from '@jolibox/common';
 import { StandardResponse } from '@jolibox/types';
 import { applyNative, onNative } from '@jolibox/native-bridge';
 import { innerFetch as fetch } from '@/native/network';
@@ -12,6 +12,16 @@ import { createSubscriptionInternalError } from './registers/base';
 import { SubscriptionErrorCodeMap } from './registers/type';
 import { ResponseType } from '@jolibox/types';
 
+interface IUserSubData {
+  subPlanId: string;
+  tier: string;
+  domain: string;
+  status: 'ACTIVE' | 'CANCELED' | 'IN_GRACE' | 'EXPIRED';
+  validUntil: number;
+  planType: string;
+  haveNextPayment: boolean;
+}
+
 // Request/Response interfaces for RequestCacheService
 type SubscriptionRequest = Record<string, never>;
 
@@ -215,19 +225,85 @@ class BaseSubscriptionService extends RequestCacheService<
     appStoreProductId: string;
   }): Promise<{ subPlanId: string; message: string; result: 'SUCCESS' | 'FAILED' | 'FAILURE_SUBSCRIPTED' }> {
     console.log('[SubscriptionService] subscribe params', subscriptionHelper);
-    const result = await subscriptionHelper.invokeSubscription('SUB_APP', {
+
+    // Start subscription and compensation polling in parallel
+    const abortController = new AbortController();
+    const subscribePromise = subscriptionHelper.invokeSubscription('SUB_APP', {
       productId: params.nativeProductId,
       appStoreProductId: params.appStoreProductId,
       planId: params.basePlanId
     });
+    const compensationPromise = this.pollSubscriptionStatus(abortController.signal);
+
+    // Wait for both to complete or first success
+    const result = (await Promise.race([
+      subscribePromise.then((subscribeResult) => {
+        // Cancel polling when subscribe completes
+        abortController.abort();
+        return {
+          result: subscribeResult.code as 'SUCCESS' | 'FAILED' | 'FAILURE_SUBSCRIPTED',
+          subPlanId: subscribeResult.data?.subPlanId,
+          message: subscribeResult.message
+        };
+      }),
+      compensationPromise.then((pollingResult) => {
+        if (pollingResult?.result === 'SUCCESS') {
+          abortController.abort();
+          return pollingResult;
+        }
+        // If polling fails or times out, wait forever (let subscribe resolve)
+        return new Promise(() => {
+          console.log('[SubscriptionPolling] Timeout for subscriptionService.subscribe completion');
+        });
+      })
+    ])) as { result: 'SUCCESS' | 'FAILED' | 'FAILURE_SUBSCRIPTED'; subPlanId: string; message?: string };
 
     return {
-      result: result.code as 'SUCCESS' | 'FAILED' | 'FAILURE_SUBSCRIPTED',
-      subPlanId: result.data?.subPlanId,
-      message: result.message
+      result: result.result,
+      subPlanId: result.subPlanId,
+      message: result.message ?? ''
     };
   }
 
+  // Polling function for subscription status compensation
+  private async pollSubscriptionStatus(abortSignal: AbortSignal): Promise<{
+    result: 'SUCCESS' | 'FAILED' | 'FAILURE_SUBSCRIPTED';
+    subPlanId: string;
+    message?: string;
+  } | void> {
+    const maxAttempts = 10; // Poll for 50 seconds max
+    const interval = 5000; // 5 second intervals
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      if (abortSignal.aborted) {
+        console.log('[SubscriptionPolling] Aborted due to subscribe completion');
+        return;
+      }
+
+      try {
+        const { response } = await fetch<StandardResponse<IUserSubData>>('/api/subs/info', {
+          method: 'GET',
+          appendHostCookie: true,
+          responseType: 'json'
+        });
+
+        if (response.data?.data?.status === 'ACTIVE') {
+          return {
+            result: 'SUCCESS',
+            subPlanId: response.data.data.subPlanId,
+            message: 'Subscription activated via polling'
+          };
+        }
+      } catch (error) {
+        console.warn(`[SubscriptionPolling] Attempt ${attempt + 1} failed:`, error);
+      }
+
+      if (attempt < maxAttempts - 1 && !abortSignal.aborted) {
+        await sleep(interval);
+      }
+    }
+  }
+
   async invokeSubscriptionPanel(): Promise<
     StandardResponse<{ result: 'SUCCESS' | 'FAILED'; subPlanId?: string }>
   > {