@umituz/react-native-subscription 2.44.0 → 2.45.0

package/src/domains/subscription/application/sync/StatusChangeSyncHandler.ts

@@ -0,0 +1,57 @@
+/**
+ * Status Change Sync Handler
+ * Handles premium status changes (expire, sync metadata, recovery)
+ */
+
+import { getCreditsRepository } from "../../../credits/infrastructure/CreditsRepositoryManager";
+import type { PremiumStatusChangedEvent } from "../../core/SubscriptionEvents";
+import { UserIdResolver } from "./UserIdResolver";
+import { CreditDocumentOperations } from "./CreditDocumentOperations";
+import { PurchaseSyncHandler } from "./PurchaseSyncHandler";
+
+export class StatusChangeSyncHandler {
+  constructor(
+    private userIdResolver: UserIdResolver,
+    private creditOps: CreditDocumentOperations,
+    private purchaseHandler: PurchaseSyncHandler
+  ) {}
+
+  async processStatusChange(event: PremiumStatusChangedEvent): Promise<void> {
+    // If purchase is in progress, only do recovery sync
+    if (this.purchaseHandler.isProcessing()) {
+      if (__DEV__) {
+        console.log("[StatusChangeSyncHandler] Purchase in progress - running recovery only");
+      }
+      if (event.isPremium && event.productId) {
+        const creditsUserId = await this.userIdResolver.resolveCreditsUserId(event.userId);
+        await this.creditOps.syncPremiumStatus(creditsUserId, event);
+      }
+      return;
+    }
+
+    const creditsUserId = await this.userIdResolver.resolveCreditsUserId(event.userId);
+
+    // Expired subscription
+    if (!event.isPremium && event.productId) {
+      await this.creditOps.expireSubscription(creditsUserId);
+      return;
+    }
+
+    // No product ID - check if credits doc exists and expire if needed
+    if (!event.isPremium && !event.productId) {
+      const hasDoc = await getCreditsRepository().creditsDocumentExists(creditsUserId);
+      if (hasDoc) {
+        await this.creditOps.expireSubscription(creditsUserId);
+      }
+      return;
+    }
+
+    // No product ID and is premium - nothing to do
+    if (!event.productId) {
+      return;
+    }
+
+    // Sync premium status (with recovery if needed)
+    await this.creditOps.syncPremiumStatus(creditsUserId, event);
+  }
+}

package/src/domains/subscription/application/sync/SyncProcessorLogger.ts

@@ -0,0 +1,120 @@
+/**
+ * Sync Processor Logger
+ * Centralized logging for subscription sync operations
+ */
+
+import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../../shared/infrastructure/SubscriptionEventBus";
+import type { PurchaseCompletedEvent, RenewalDetectedEvent, PremiumStatusChangedEvent } from "../../core/SubscriptionEvents";
+
+export type SyncPhase = 'purchase' | 'renewal' | 'status_change';
+
+export class SyncProcessorLogger {
+  emitSyncStatus(phase: SyncPhase, status: 'syncing' | 'success' | 'error', data: {
+    userId: string;
+    productId: string;
+    error?: string;
+  }) {
+    subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.SYNC_STATUS_CHANGED, {
+      status,
+      phase,
+      userId: data.userId,
+      productId: data.productId,
+      error: data.error,
+    });
+  }
+
+  logPurchaseStart(event: PurchaseCompletedEvent) {
+    if (__DEV__) {
+      console.log('[SubscriptionSyncProcessor] 🔵 PURCHASE START', {
+        userId: event.userId,
+        productId: event.productId,
+        source: event.source,
+        packageType: event.packageType,
+        timestamp: new Date().toISOString(),
+      });
+    }
+  }
+
+  logPurchaseSuccess(userId: string, productId: string) {
+    if (__DEV__) {
+      console.log('[SubscriptionSyncProcessor] 🟢 PURCHASE SUCCESS', {
+        userId,
+        productId,
+        timestamp: new Date().toISOString(),
+      });
+    }
+  }
+
+  logPurchaseError(userId: string, productId: string, error: string) {
+    console.error('[SubscriptionSyncProcessor] 🔴 PURCHASE FAILED', {
+      userId,
+      productId,
+      error,
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  logRenewalStart(event: RenewalDetectedEvent) {
+    if (__DEV__) {
+      console.log('[SubscriptionSyncProcessor] 🔵 RENEWAL START', {
+        userId: event.userId,
+        productId: event.productId,
+        newExpirationDate: event.newExpirationDate,
+        timestamp: new Date().toISOString(),
+      });
+    }
+  }
+
+  logRenewalSuccess(userId: string, productId: string) {
+    if (__DEV__) {
+      console.log('[SubscriptionSyncProcessor] 🟢 RENEWAL SUCCESS', {
+        userId,
+        productId,
+        timestamp: new Date().toISOString(),
+      });
+    }
+  }
+
+  logRenewalError(userId: string, productId: string, error: string) {
+    console.error('[SubscriptionSyncProcessor] 🔴 RENEWAL FAILED', {
+      userId,
+      productId,
+      error,
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  logStatusChangeStart(event: PremiumStatusChangedEvent) {
+    if (__DEV__) {
+      console.log('[SubscriptionSyncProcessor] 🔵 STATUS CHANGE START', {
+        userId: event.userId,
+        isPremium: event.isPremium,
+        productId: event.productId,
+        willRenew: event.willRenew,
+        expirationDate: event.expirationDate,
+        timestamp: new Date().toISOString(),
+      });
+    }
+  }
+
+  logStatusChangeSuccess(userId: string, isPremium: boolean, productId?: string) {
+    if (__DEV__) {
+      console.log('[SubscriptionSyncProcessor] 🟢 STATUS CHANGE SUCCESS', {
+        userId,
+        isPremium,
+        productId,
+        timestamp: new Date().toISOString(),
+      });
+    }
+  }
+
+  logStatusChangeError(userId: string, isPremium: boolean, productId: string | undefined, error: string) {
+    console.error('[SubscriptionSyncProcessor] 🔴 STATUS CHANGE FAILED', {
+      userId,
+      isPremium,
+      productId,
+      error,
+      timestamp: new Date().toISOString(),
+    });
+  }
+}

package/src/domains/subscription/application/sync/UserIdResolver.ts

@@ -0,0 +1,31 @@
+/**
+ * User ID Resolver
+ * Handles resolution of RevenueCat user ID to credits user ID
+ */
+
+export class UserIdResolver {
+  constructor(private getAnonymousUserId: () => Promise<string>) {}
+
+  async resolveCreditsUserId(revenueCatUserId: string | null | undefined): Promise<string> {
+    // Try revenueCatUserId first
+    const trimmed = revenueCatUserId?.trim();
+    if (this.isValidUserId(trimmed)) {
+      return trimmed;
+    }
+
+    // Fallback to anonymous user ID
+    console.warn("[UserIdResolver] revenueCatUserId is empty/null, falling back to anonymousUserId");
+    const anonymousId = await this.getAnonymousUserId();
+    const trimmedAnonymous = anonymousId?.trim();
+
+    if (!this.isValidUserId(trimmedAnonymous)) {
+      throw new Error("[UserIdResolver] Cannot resolve credits userId: both revenueCatUserId and anonymousUserId are empty");
+    }
+
+    return trimmedAnonymous;
+  }
+
+  private isValidUserId(userId: string | undefined): boolean {
+    return !!userId && userId.length > 0 && userId !== 'undefined' && userId !== 'null';
+  }
+}

package/src/domains/subscription/presentation/components/ManagedSubscriptionFlow.states.tsx

@@ -0,0 +1,187 @@
+/**
+ * State Components for ManagedSubscriptionFlow
+ * Separated for better maintainability
+ */
+
+import React from "react";
+import type { NavigationProp } from "@react-navigation/native";
+import { SplashScreen } from "@umituz/react-native-design-system/molecules";
+import { OnboardingScreen } from "@umituz/react-native-design-system/onboarding";
+import { useSubscriptionFlowStore } from "../useSubscriptionFlow";
+import type { ManagedSubscriptionFlowProps } from "./ManagedSubscriptionFlow";
+import { PaywallScreen } from "../../../paywall/components/PaywallScreen";
+import { PaywallFeedbackScreen } from "./feedback/PaywallFeedbackScreen";
+import { usePaywallFeedbackSubmit } from "../../../../presentation/hooks/feedback/useFeedbackSubmit";
+
+// ============================================================================
+// INITIALIZING STATE
+// ============================================================================
+
+interface InitializingStateProps {
+  tokens: any;
+  splash?: ManagedSubscriptionFlowProps["splash"];
+}
+
+export const InitializingState: React.FC<InitializingStateProps> = ({ tokens, splash }) => (
+  <SplashScreen
+    appName={splash?.appName || "Loading..."}
+    tagline={splash?.tagline || "Please wait while we set things up"}
+    colors={tokens.colors}
+  />
+);
+
+// ============================================================================
+// ONBOARDING STATE
+// ============================================================================
+
+interface OnboardingStateProps {
+  config: ManagedSubscriptionFlowProps["onboarding"];
+  onComplete: () => void;
+}
+
+export const OnboardingState: React.FC<OnboardingStateProps> = ({ config, onComplete }) => (
+  <OnboardingScreen
+    slides={config.slides}
+    onComplete={onComplete}
+    showSkipButton={config.showSkipButton ?? true}
+    showBackButton={config.showBackButton ?? true}
+    showProgressBar={config.showProgressBar ?? true}
+    themeColors={config.themeColors}
+    translations={config.translations}
+  />
+);
+
+// ============================================================================
+// PAYWALL STATE
+// ============================================================================
+
+interface PaywallStateProps {
+  config: ManagedSubscriptionFlowProps["paywall"];
+  packages: any[];
+  isPremium: boolean;
+  credits: number | null;
+  isSyncing: boolean;
+  onPurchase: (pkgId: string) => Promise<any>;
+  onRestore: () => Promise<any>;
+  onClose: (purchased: boolean) => void;
+}
+
+export const PaywallState: React.FC<PaywallStateProps> = ({
+  config,
+  packages,
+  isPremium,
+  credits,
+  isSyncing,
+  onPurchase,
+  onRestore,
+  onClose,
+}) => {
+  const [purchaseSuccessful, setPurchaseSuccessful] = React.useState(false);
+
+  const handlePurchase = async (pkgId: string) => {
+    const result = await onPurchase(pkgId);
+    if (result?.success) {
+      setPurchaseSuccessful(true);
+    }
+    return result;
+  };
+
+  const handleClose = () => {
+    onClose(purchaseSuccessful);
+  };
+
+  return (
+    <PaywallScreen
+      translations={config.translations}
+      legalUrls={config.legalUrls}
+      features={config.features}
+      bestValueIdentifier={config.bestValueIdentifier}
+      creditsLabel={config.creditsLabel}
+      heroImage={config.heroImage}
+      source="onboarding"
+      packages={packages}
+      isPremium={isPremium}
+      credits={credits}
+      isSyncing={isSyncing}
+      onPurchase={handlePurchase}
+      onRestore={onRestore}
+      onClose={handleClose}
+    />
+  );
+};
+
+// ============================================================================
+// FEEDBACK STATE
+// ============================================================================
+
+interface FeedbackStateProps {
+  config: ManagedSubscriptionFlowProps["feedback"];
+  onClose: () => void;
+}
+
+export const FeedbackState: React.FC<FeedbackStateProps> = ({ config, onClose }) => {
+  const { submit: internalSubmit } = usePaywallFeedbackSubmit();
+
+  const handleSubmit = async (data: { reason: string; otherText?: string }) => {
+    if (config.onSubmit) {
+      await config.onSubmit(data);
+    } else {
+      const description = data.otherText ? `${data.reason}: ${data.otherText}` : data.reason;
+      await internalSubmit(description);
+    }
+  };
+
+  return (
+    <PaywallFeedbackScreen
+      onClose={onClose}
+      onSubmit={handleSubmit}
+      translations={config.translations}
+    />
+  );
+};
+
+// ============================================================================
+// READY STATE (APP CONTENT)
+// ============================================================================
+
+interface ReadyStateProps {
+  children: React.ReactNode;
+  offline?: ManagedSubscriptionFlowProps["offline"];
+  feedbackConfig: ManagedSubscriptionFlowProps["feedback"];
+  showFeedback: boolean;
+  tokens: any;
+  onFeedbackClose: () => void;
+}
+
+export const ReadyState: React.FC<ReadyStateProps> = ({
+  children,
+  offline,
+  feedbackConfig,
+  showFeedback,
+  tokens,
+  onFeedbackClose,
+}) => {
+  const { OfflineBanner } = require("@umituz/react-native-design-system/offline");
+
+  return (
+    <>
+      {children}
+
+      {offline && (
+        <OfflineBanner
+          visible={offline.isOffline}
+          message={offline.message}
+          backgroundColor={offline.backgroundColor || tokens.colors.error}
+          position={offline.position || "top"}
+        />
+      )}
+
+      {showFeedback && (
+        <FeedbackState
+          config={feedbackConfig}
+          onClose={onFeedbackClose}
+        />
+      )}
+    </>
+  );
+};

package/src/domains/subscription/presentation/components/ManagedSubscriptionFlow.tsx

@@ -1,27 +1,26 @@
 /**
  * ManagedSubscriptionFlow
  *
- * State machine-based flow orchestration.
- * No complex if/else - clean state transitions.
+ * Clean state machine-based flow orchestration.
+ * All state components separated to individual files.
  */
 
-import React, { useEffect, useCallback } from "react";
+import React, { useEffect } from "react";
 import type { NavigationProp } from "@react-navigation/native";
 import type { ImageSourcePropType } from "react-native";
-import { View } from "react-native";
-import { SplashScreen, useSplashFlow } from "@umituz/react-native-design-system/molecules";
-import { OnboardingScreen } from "@umituz/react-native-design-system/onboarding";
-import { OfflineBanner } from "@umituz/react-native-design-system/offline";
 import { useAppDesignTokens } from "@umituz/react-native-design-system/theme";
 import { usePremiumStatus } from "../../presentation/usePremiumStatus";
 import { usePremiumPackages } from "../../presentation/usePremiumPackages";
 import { usePremiumActions } from "../../presentation/usePremiumActions";
 import { useSubscriptionFlowStore, SubscriptionFlowStatus } from "../useSubscriptionFlow";
-import { PaywallFeedbackScreen } from "./feedback/PaywallFeedbackScreen";
 import type { PaywallFeedbackTranslations } from "./feedback/PaywallFeedbackScreen.types";
 import type { PaywallTranslations, PaywallLegalUrls, SubscriptionFeature } from "../../../paywall/entities/types";
-import { usePaywallFeedbackSubmit } from "../../../../presentation/hooks/feedback/useFeedbackSubmit";
-import { PaywallScreen } from "../../../paywall/components/PaywallScreen";
+import {
+  InitializingState,
+  OnboardingState,
+  PaywallState,
+  ReadyState,
+} from "./ManagedSubscriptionFlow.states";
 
 export interface ManagedSubscriptionFlowProps {
   children: React.ReactNode;
@@ -79,123 +78,8 @@ import {
   useSubscriptionFlowStatus
 } from "../providers/SubscriptionFlowProvider";
 
-// ============================================================================
-// STATE MACHINE COMPONENTS
-// ============================================================================
-
-interface StateComponentProps {
-  status: SubscriptionFlowStatus;
-  tokens: any;
-  onboardingConfig: ManagedSubscriptionFlowProps["onboarding"];
-  paywallConfig: ManagedSubscriptionFlowProps["paywall"];
-  feedbackConfig: ManagedSubscriptionFlowProps["feedback"];
-  isPremium: boolean;
-  packages: any[];
-  credits: number | null;
-  isSyncing: boolean;
-  onPurchasePackage: (pkgId: string) => Promise<any>;
-  onRestorePurchase: () => Promise<any>;
-  navigation: NavigationProp<any>;
-}
-
-const InitializingState: React.FC<{ tokens: any; splash?: ManagedSubscriptionFlowProps["splash"] }> = ({ tokens, splash }) => (
-  <SplashScreen
-    appName={splash?.appName || "Loading..."}
-    tagline={splash?.tagline || "Please wait while we set things up"}
-    colors={tokens.colors}
-  />
-);
-
-const OnboardingState: React.FC<{
-  config: ManagedSubscriptionFlowProps["onboarding"];
-  onComplete: () => void;
-}> = ({ config, onComplete }) => (
-  <OnboardingScreen
-    slides={config.slides}
-    onComplete={onComplete}
-    showSkipButton={config.showSkipButton ?? true}
-    showBackButton={config.showBackButton ?? true}
-    showProgressBar={config.showProgressBar ?? true}
-    themeColors={config.themeColors}
-    translations={config.translations}
-  />
-);
-
-const PaywallState: React.FC<{
-  config: ManagedSubscriptionFlowProps["paywall"];
-  packages: any[];
-  isPremium: boolean;
-  credits: number | null;
-  isSyncing: boolean;
-  onPurchase: (pkgId: string) => Promise<any>;
-  onRestore: () => Promise<any>;
-  onClose: (purchased: boolean) => void;
-}> = ({ config, packages, isPremium, credits, isSyncing, onPurchase, onRestore, onClose }) => {
-  const [purchaseSuccessful, setPurchaseSuccessful] = React.useState(false);
-
-  const handlePurchase = async (pkgId: string) => {
-    const result = await onPurchase(pkgId);
-    if (result?.success) {
-      setPurchaseSuccessful(true);
-    }
-    return result;
-  };
-
-  const handleClose = () => {
-    onClose(purchaseSuccessful);
-  };
-
-  return (
-    <PaywallScreen
-      translations={config.translations}
-      legalUrls={config.legalUrls}
-      features={config.features}
-      bestValueIdentifier={config.bestValueIdentifier}
-      creditsLabel={config.creditsLabel}
-      heroImage={config.heroImage}
-      source="onboarding"
-      packages={packages}
-      isPremium={isPremium}
-      credits={credits}
-      isSyncing={isSyncing}
-      onPurchase={handlePurchase}
-      onRestore={onRestore}
-      onClose={handleClose}
-    />
-  );
-};
-
-const FeedbackState: React.FC<{
-  config: ManagedSubscriptionFlowProps["feedback"];
-  onClose: () => void;
-}> = ({ config, onClose }) => {
-  const { submit: internalSubmit } = usePaywallFeedbackSubmit();
-
-  const handleSubmit = async (data: { reason: string; otherText?: string }) => {
-    if (config.onSubmit) {
-      await config.onSubmit(data);
-    } else {
-      const description = data.otherText ? `${data.reason}: ${data.otherText}` : data.reason;
-      await internalSubmit(description);
-    }
-  };
-
-  return (
-    <PaywallFeedbackScreen
-      onClose={onClose}
-      onSubmit={handleSubmit}
-      translations={config.translations}
-    />
-  );
-};
-
-// ============================================================================
-// MAIN COMPONENT
-// ============================================================================
-
-const ManagedSubscriptionFlowInner = React.memo<ManagedSubscriptionFlowProps>(({
+const ManagedSubscriptionFlowInner: React.FC<ManagedSubscriptionFlowProps> = ({
   children,
-  navigation,
   islocalizationReady,
   splash,
   onboarding,
@@ -205,9 +89,6 @@ const ManagedSubscriptionFlowInner = React.memo<ManagedSubscriptionFlowProps>(({
 }) => {
   const tokens = useAppDesignTokens();
   const status = useSubscriptionFlowStatus();
-  const { isInitialized: isSplashComplete } = useSplashFlow({
-    duration: splash?.duration || 0,
-  });
 
   // Premium hooks
   const { isPremium, isSyncing, credits, isLoading: isPremiumLoading } = usePremiumStatus();
@@ -220,32 +101,26 @@ const ManagedSubscriptionFlowInner = React.memo<ManagedSubscriptionFlowProps>(({
   const completePaywall = useSubscriptionFlowStore((s) => s.completePaywall);
   const hideFeedback = useSubscriptionFlowStore((s) => s.hideFeedback);
   const showFeedbackScreen = useSubscriptionFlowStore((s) => s.showFeedbackScreen);
-
   const showFeedback = useSubscriptionFlowStore((s) => s.showFeedback);
 
   // ========================================================================
   // STATE TRANSITIONS
   // ========================================================================
 
-  // CHECK_PREMIUM state transition logic
   useEffect(() => {
     if (status === SubscriptionFlowStatus.CHECK_PREMIUM && !isPremiumLoading) {
       const paywallShown = useSubscriptionFlowStore.getState().paywallShown;
 
       if (isPremium) {
-        // User is premium, go to ready
         completePaywall(true);
       } else if (!paywallShown) {
-        // User not premium and paywall not shown, show paywall
         showPaywall();
       } else {
-        // Paywall already shown, go to ready
         completePaywall(false);
       }
     }
   }, [status, isPremium, isPremiumLoading, showPaywall, completePaywall]);
 
-  // Show feedback when needed
   useEffect(() => {
     if (status === SubscriptionFlowStatus.READY && showFeedback) {
       showFeedbackScreen();
@@ -253,21 +128,18 @@ const ManagedSubscriptionFlowInner = React.memo<ManagedSubscriptionFlowProps>(({
   }, [status, showFeedback, showFeedbackScreen]);
 
   // ========================================================================
-  // RENDER
+  // RENDER BY STATE
   // ========================================================================
 
-  // Wait for localization
   if (!islocalizationReady || status === SubscriptionFlowStatus.INITIALIZING) {
     return <InitializingState tokens={tokens} splash={splash} />;
   }
 
-  // Render by state
   switch (status) {
     case SubscriptionFlowStatus.ONBOARDING:
       return <OnboardingState config={onboarding} onComplete={completeOnboarding} />;
 
     case SubscriptionFlowStatus.CHECK_PREMIUM:
-      // Show loading while checking premium
       return <InitializingState tokens={tokens} splash={splash} />;
 
     case SubscriptionFlowStatus.POST_ONBOARDING_PAYWALL:
@@ -286,31 +158,20 @@ const ManagedSubscriptionFlowInner = React.memo<ManagedSubscriptionFlowProps>(({
 
     case SubscriptionFlowStatus.READY:
       return (
-        <>
-          {children}
-
-          {offline && (
-            <OfflineBanner
-              visible={offline.isOffline}
-              message={offline.message}
-              backgroundColor={offline.backgroundColor || tokens.colors.error}
-              position={offline.position || "top"}
-            />
-          )}
-
-          {showFeedback && (
-            <FeedbackState
-              config={feedback}
-              onClose={hideFeedback}
-            />
-          )}
-        </>
+        <ReadyState
+          children={children}
+          offline={offline}
+          feedbackConfig={feedback}
+          showFeedback={showFeedback}
+          tokens={tokens}
+          onFeedbackClose={hideFeedback}
+        />
       );
 
     default:
       return <InitializingState tokens={tokens} splash={splash} />;
   }
-});
+};
 
 ManagedSubscriptionFlowInner.displayName = "ManagedSubscriptionFlowInner";