@umituz/react-native-subscription 2.37.105 → 2.37.107

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.37.105",
+  "version": "2.37.107",
   "description": "Complete subscription management with RevenueCat, paywall UI, and credits system for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domains/revenuecat/core/types/RevenueCatConfig.ts

@@ -1,43 +1,19 @@
-import type { CustomerInfo } from "react-native-purchases";
-import type { PackageType } from "./RevenueCatTypes";
+import type {
+  PurchaseCompletedEvent,
+  RenewalDetectedEvent,
+  PremiumStatusChangedEvent,
+  PlanChangedEvent,
+  RestoreCompletedEvent,
+} from "../../../subscription/core/SubscriptionEvents";
 
 export interface RevenueCatConfig {
   apiKey?: string;
   entitlementIdentifier: string;
   consumableProductIdentifiers?: string[];
-  onPremiumStatusChanged?: (
-    userId: string,
-    isPremium: boolean,
-    productId?: string,
-    expiresAt?: string,
-    willRenew?: boolean,
-    periodType?: string,
-    originalTransactionId?: string
-  ) => Promise<void> | void;
-  onPurchaseCompleted?: (
-    userId: string,
-    productId: string,
-    customerInfo: CustomerInfo,
-    source?: string,
-    packageType?: PackageType | null
-  ) => Promise<void> | void;
-  onRestoreCompleted?: (
-    userId: string,
-    isPremium: boolean,
-    customerInfo: CustomerInfo
-  ) => Promise<void> | void;
-  onRenewalDetected?: (
-    userId: string,
-    productId: string,
-    newExpirationDate: string,
-    customerInfo: CustomerInfo
-  ) => Promise<void> | void;
-  onPlanChanged?: (
-    userId: string,
-    newProductId: string,
-    previousProductId: string,
-    isUpgrade: boolean,
-    customerInfo: CustomerInfo
-  ) => Promise<void> | void;
+  onPremiumStatusChanged?: (event: PremiumStatusChangedEvent) => Promise<void> | void;
+  onPurchaseCompleted?: (event: PurchaseCompletedEvent) => Promise<void> | void;
+  onRestoreCompleted?: (event: RestoreCompletedEvent) => Promise<void> | void;
+  onRenewalDetected?: (event: RenewalDetectedEvent) => Promise<void> | void;
+  onPlanChanged?: (event: PlanChangedEvent) => Promise<void> | void;
   onCreditsUpdated?: (userId: string) => void;
 }

package/src/domains/revenuecat/infrastructure/services/userSwitchHandler.ts

@@ -1,12 +1,10 @@
 import Purchases, { type CustomerInfo, type PurchasesOfferings } from "react-native-purchases";
-import { doc, setDoc } from "firebase/firestore";
 import type { InitializeResult } from "../../../../shared/application/ports/IRevenueCatService";
 import type { InitializerDeps } from "./RevenueCatInitializer.types";
 import { FAILED_INITIALIZATION_RESULT } from "./initializerConstants";
 import { UserSwitchMutex } from "./UserSwitchMutex";
 import { getPremiumEntitlement } from "../../core/types";
 import { ANONYMOUS_CACHE_KEY, type PeriodType } from "../../../subscription/core/SubscriptionConstants";
-import { requireFirestore } from "../../../../shared/infrastructure/firestore";
 
 declare const __DEV__: boolean;
 
@@ -39,17 +37,6 @@ function isAnonymousId(userId: string): boolean {
   return userId.startsWith('$RCAnonymous') || userId.startsWith('device_');
 }
 
-async function syncRevenueCatIdToProfile(firebaseUserId: string, revenueCatUserId: string): Promise<void> {
-  try {
-    const db = requireFirestore();
-    const userRef = doc(db, "users", firebaseUserId);
-    await setDoc(userRef, { revenueCatUserId }, { merge: true });
-  } catch (error) {
-    // Non-fatal: profile update failure should not block SDK initialization
-    console.warn('[UserSwitchHandler] Failed to sync RevenueCat ID to profile:', error instanceof Error ? error.message : String(error));
-  }
-}
-
 export async function handleUserSwitch(
   deps: InitializerDeps,
   userId: string
@@ -100,7 +87,7 @@ async function performUserSwitch(
         const result = await Purchases.logIn(normalizedUserId!);
         customerInfo = result.customerInfo;
         if (typeof __DEV__ !== 'undefined' && __DEV__) {
-          console.log('[UserSwitchHandler] ✅ Purchases.logIn() successful, created:', result.created);
+          console.log('[UserSwitchHandler] Purchases.logIn() successful, created:', result.created);
         }
       } else {
         if (typeof __DEV__ !== 'undefined' && __DEV__) {
@@ -119,13 +106,8 @@ async function performUserSwitch(
     deps.setCurrentUserId(normalizedUserId || undefined);
     const offerings = await fetchOfferingsSafe();
 
-    if (normalizedUserId) {
-      const rcId = await Purchases.getAppUserID();
-      void syncRevenueCatIdToProfile(normalizedUserId, rcId);
-    }
-
     if (typeof __DEV__ !== 'undefined' && __DEV__) {
-      console.log('[UserSwitchHandler] ✅ User switch completed successfully');
+      console.log('[UserSwitchHandler] User switch completed successfully');
     }
 
     return buildSuccessResult(deps, customerInfo, offerings);
@@ -174,7 +156,7 @@ export async function handleInitialConfiguration(
     deps.setCurrentUserId(normalizedUserId || undefined);
 
     if (typeof __DEV__ !== 'undefined' && __DEV__) {
-      console.log('[UserSwitchHandler] ✅ Purchases.configure() successful');
+      console.log('[UserSwitchHandler] Purchases.configure() successful');
     }
 
     // Fetch customer info (critical) and offerings (non-fatal) separately.
@@ -184,14 +166,9 @@ export async function handleInitialConfiguration(
       fetchOfferingsSafe(),
     ]);
 
-    const currentUserId = await Purchases.getAppUserID();
-
-    if (normalizedUserId) {
-      void syncRevenueCatIdToProfile(normalizedUserId, currentUserId);
-    }
-
     if (typeof __DEV__ !== 'undefined' && __DEV__) {
-      console.log('[UserSwitchHandler] ✅ Initial configuration completed:', {
+      const currentUserId = await Purchases.getAppUserID();
+      console.log('[UserSwitchHandler] Initial configuration completed:', {
         revenueCatUserId: currentUserId,
         activeEntitlements: Object.keys(customerInfo.entitlements.active),
         offeringsCount: offerings?.all ? Object.keys(offerings.all).length : 0,
@@ -211,27 +188,21 @@ export async function handleInitialConfiguration(
 
         if (premiumEntitlement) {
           const subscription = customerInfo.subscriptionsByProductIdentifier?.[premiumEntitlement.productIdentifier];
-          const originalTransactionId = subscription?.storeTransactionId ?? undefined;
 
-          await deps.config.onPremiumStatusChanged(
-            normalizedUserId,
-            true,
-            premiumEntitlement.productIdentifier,
-            premiumEntitlement.expirationDate ?? undefined,
-            premiumEntitlement.willRenew,
-            premiumEntitlement.periodType as PeriodType | undefined,
-            originalTransactionId
-          );
+          await deps.config.onPremiumStatusChanged({
+            userId: normalizedUserId,
+            isPremium: true,
+            productId: premiumEntitlement.productIdentifier,
+            expiresAt: premiumEntitlement.expirationDate ?? undefined,
+            willRenew: premiumEntitlement.willRenew,
+            periodType: premiumEntitlement.periodType as PeriodType | undefined,
+            originalTransactionId: subscription?.storeTransactionId ?? undefined,
+          });
         } else {
-          await deps.config.onPremiumStatusChanged(
-            normalizedUserId,
-            false,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            undefined
-          );
+          await deps.config.onPremiumStatusChanged({
+            userId: normalizedUserId,
+            isPremium: false,
+          });
         }
       } catch (error) {
         // Log error but don't fail initialization

package/src/domains/subscription/application/SubscriptionSyncProcessor.ts

@@ -1,14 +1,21 @@
-import type { CustomerInfo } from "react-native-purchases";
 import Purchases from "react-native-purchases";
-import type { PeriodType, PurchaseSource } from "../core/SubscriptionConstants";
 import { PURCHASE_SOURCE, PURCHASE_TYPE } from "../core/SubscriptionConstants";
+import type { PremiumStatusChangedEvent, PurchaseCompletedEvent, RenewalDetectedEvent } from "../core/SubscriptionEvents";
 import { getCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryManager";
 import { extractRevenueCatData } from "./SubscriptionSyncUtils";
-import { emitCreditsUpdated } from "./syncEventEmitter";
 import { generatePurchaseId, generateRenewalId } from "./syncIdGenerators";
-import { handleExpiredSubscription, handlePremiumStatusSync } from "./statusChangeHandlers";
-import type { PackageType } from "../../revenuecat/core/types";
-
+import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
+
+/**
+ * Central processor for all subscription sync operations.
+ * Handles purchases, renewals, and status changes with credit allocation.
+ *
+ * Responsibilities:
+ * - Purchase: allocate initial credits via atomic Firestore transaction
+ * - Renewal: allocate renewal credits
+ * - Status change: sync metadata (no credit allocation) or mark expired
+ * - Recovery: create missing credits document for premium users
+ */
 export class SubscriptionSyncProcessor {
   private purchaseInProgress = false;
 
@@ -17,6 +24,62 @@ export class SubscriptionSyncProcessor {
     private getAnonymousUserId: () => Promise<string>
   ) {}
 
+  // ─── Public API (replaces SubscriptionSyncService) ────────────────
+
+  async handlePurchase(event: PurchaseCompletedEvent): Promise<void> {
+    try {
+      await this.processPurchase(event);
+      subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PURCHASE_COMPLETED, {
+        userId: event.userId,
+        productId: event.productId,
+      });
+    } catch (error) {
+      console.error('[SubscriptionSyncProcessor] Purchase processing failed', {
+        userId: event.userId,
+        productId: event.productId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    }
+  }
+
+  async handleRenewal(event: RenewalDetectedEvent): Promise<void> {
+    try {
+      await this.processRenewal(event);
+      subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.RENEWAL_DETECTED, {
+        userId: event.userId,
+        productId: event.productId,
+      });
+    } catch (error) {
+      console.error('[SubscriptionSyncProcessor] Renewal processing failed', {
+        userId: event.userId,
+        productId: event.productId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    }
+  }
+
+  async handlePremiumStatusChanged(event: PremiumStatusChangedEvent): Promise<void> {
+    try {
+      await this.processStatusChange(event);
+      subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PREMIUM_STATUS_CHANGED, {
+        userId: event.userId,
+        isPremium: event.isPremium,
+      });
+    } catch (error) {
+      console.error('[SubscriptionSyncProcessor] Status change processing failed', {
+        userId: event.userId,
+        isPremium: event.isPremium,
+        productId: event.productId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    }
+  }
+
+  // ─── Internal Processing ──────────────────────────────────────────
+
   private async getRevenueCatAppUserId(): Promise<string | null> {
     try {
       return await Purchases.getAppUserID();
@@ -40,22 +103,22 @@ export class SubscriptionSyncProcessor {
     return trimmedAnonymous;
   }
 
-  async processPurchase(userId: string, productId: string, customerInfo: CustomerInfo, source?: PurchaseSource, packageType?: PackageType | null) {
+  private async processPurchase(event: PurchaseCompletedEvent): Promise<void> {
     this.purchaseInProgress = true;
     try {
-      const revenueCatData = extractRevenueCatData(customerInfo, this.entitlementId);
-      revenueCatData.packageType = packageType ?? null;
+      const revenueCatData = extractRevenueCatData(event.customerInfo, this.entitlementId);
+      revenueCatData.packageType = event.packageType ?? null;
       const revenueCatAppUserId = await this.getRevenueCatAppUserId();
-      revenueCatData.revenueCatUserId = revenueCatAppUserId ?? userId;
-      const purchaseId = generatePurchaseId(revenueCatData.originalTransactionId, productId);
+      revenueCatData.revenueCatUserId = revenueCatAppUserId ?? event.userId;
+      const purchaseId = generatePurchaseId(revenueCatData.originalTransactionId, event.productId);
 
-      const creditsUserId = await this.getCreditsUserId(userId);
+      const creditsUserId = await this.getCreditsUserId(event.userId);
 
       const result = await getCreditsRepository().initializeCredits(
         creditsUserId,
         purchaseId,
-        productId,
-        source ?? PURCHASE_SOURCE.SETTINGS,
+        event.productId,
+        event.source ?? PURCHASE_SOURCE.SETTINGS,
         revenueCatData,
         PURCHASE_TYPE.INITIAL
       );
@@ -64,27 +127,27 @@ export class SubscriptionSyncProcessor {
         throw new Error(`[SubscriptionSyncProcessor] Credit initialization failed for purchase: ${result.error?.message ?? 'unknown'}`);
       }
 
-      emitCreditsUpdated(creditsUserId);
+      this.emitCreditsUpdated(creditsUserId);
     } finally {
       this.purchaseInProgress = false;
     }
   }
 
-  async processRenewal(userId: string, productId: string, newExpirationDate: string, customerInfo: CustomerInfo) {
+  private async processRenewal(event: RenewalDetectedEvent): Promise<void> {
     this.purchaseInProgress = true;
     try {
-      const revenueCatData = extractRevenueCatData(customerInfo, this.entitlementId);
-      revenueCatData.expirationDate = newExpirationDate ?? revenueCatData.expirationDate;
+      const revenueCatData = extractRevenueCatData(event.customerInfo, this.entitlementId);
+      revenueCatData.expirationDate = event.newExpirationDate ?? revenueCatData.expirationDate;
       const revenueCatAppUserId = await this.getRevenueCatAppUserId();
-      revenueCatData.revenueCatUserId = revenueCatAppUserId ?? userId;
-      const purchaseId = generateRenewalId(revenueCatData.originalTransactionId, productId, newExpirationDate);
+      revenueCatData.revenueCatUserId = revenueCatAppUserId ?? event.userId;
+      const purchaseId = generateRenewalId(revenueCatData.originalTransactionId, event.productId, event.newExpirationDate);
 
-      const creditsUserId = await this.getCreditsUserId(userId);
+      const creditsUserId = await this.getCreditsUserId(event.userId);
 
       const result = await getCreditsRepository().initializeCredits(
         creditsUserId,
         purchaseId,
-        productId,
+        event.productId,
         PURCHASE_SOURCE.RENEWAL,
         revenueCatData,
         PURCHASE_TYPE.RENEWAL
@@ -94,21 +157,13 @@ export class SubscriptionSyncProcessor {
         throw new Error(`[SubscriptionSyncProcessor] Credit initialization failed for renewal: ${result.error?.message ?? 'unknown'}`);
       }
 
-      emitCreditsUpdated(creditsUserId);
+      this.emitCreditsUpdated(creditsUserId);
     } finally {
       this.purchaseInProgress = false;
     }
   }
 
-  async processStatusChange(
-    userId: string,
-    isPremium: boolean,
-    productId?: string,
-    expiresAt?: string,
-    willRenew?: boolean,
-    periodType?: PeriodType,
-    originalTransactionId?: string
-  ) {
+  private async processStatusChange(event: PremiumStatusChangedEvent): Promise<void> {
     // If a purchase is in progress, skip metadata sync (purchase handler does it)
     // but still allow recovery to run — the purchase handler's credit initialization
     // might have failed, and this is the safety net.
@@ -116,59 +171,82 @@ export class SubscriptionSyncProcessor {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[SubscriptionSyncProcessor] Purchase in progress - running recovery only");
       }
-      if (isPremium && productId) {
-        const creditsUserId = await this.getCreditsUserId(userId);
-        await handlePremiumStatusSync(
-          creditsUserId,
-          isPremium,
-          productId,
-          expiresAt ?? null,
-          willRenew ?? false,
-          periodType ?? null,
-          undefined,
-          undefined,
-          undefined,
-          undefined,
-          originalTransactionId
-        );
+      if (event.isPremium && event.productId) {
+        const creditsUserId = await this.getCreditsUserId(event.userId);
+        await this.syncPremiumStatus(creditsUserId, event);
       }
       return;
     }
 
-    const creditsUserId = await this.getCreditsUserId(userId);
+    const creditsUserId = await this.getCreditsUserId(event.userId);
 
-    if (!isPremium && productId) {
-      await handleExpiredSubscription(creditsUserId);
+    if (!event.isPremium && event.productId) {
+      await this.expireSubscription(creditsUserId);
       return;
     }
 
-    if (!isPremium && !productId) {
+    if (!event.isPremium && !event.productId) {
       // No entitlement and no productId — could be:
       // 1. Free user who never purchased (no credits doc) → skip
       // 2. Previously premium user whose entitlement was removed → expire
       const hasDoc = await getCreditsRepository().creditsDocumentExists(creditsUserId);
       if (hasDoc) {
-        await handleExpiredSubscription(creditsUserId);
+        await this.expireSubscription(creditsUserId);
       }
       return;
     }
 
-    if (!productId) {
+    if (!event.productId) {
       return;
     }
 
-    await handlePremiumStatusSync(
-      creditsUserId,
-      isPremium,
-      productId,
-      expiresAt ?? null,
-      willRenew ?? false,
-      periodType ?? null,
-      undefined,
-      undefined,
-      undefined,
-      undefined,
-      originalTransactionId
-    );
+    await this.syncPremiumStatus(creditsUserId, event);
+  }
+
+  // ─── Credit Document Operations (replaces statusChangeHandlers) ───
+
+  private async expireSubscription(userId: string): Promise<void> {
+    await getCreditsRepository().syncExpiredStatus(userId);
+    this.emitCreditsUpdated(userId);
+  }
+
+  private async syncPremiumStatus(userId: string, event: PremiumStatusChangedEvent): Promise<void> {
+    const repo = getCreditsRepository();
+
+    // Recovery: if premium user has no credits document, create one.
+    // Handles edge cases like test store, reinstalls, or failed purchase initialization.
+    if (event.isPremium) {
+      const created = await repo.ensurePremiumCreditsExist(
+        userId,
+        event.productId!,
+        event.willRenew ?? false,
+        event.expiresAt ?? null,
+        event.periodType ?? null,
+        event.originalTransactionId,
+      );
+      if (__DEV__ && created) {
+        console.log('[SubscriptionSyncProcessor] Recovery: created missing credits document for premium user', {
+          userId,
+          productId: event.productId,
+        });
+      }
+    }
+
+    await repo.syncPremiumMetadata(userId, {
+      isPremium: event.isPremium,
+      willRenew: event.willRenew ?? false,
+      expirationDate: event.expiresAt ?? null,
+      productId: event.productId!,
+      periodType: event.periodType ?? null,
+      unsubscribeDetectedAt: null,
+      billingIssueDetectedAt: null,
+      store: null,
+      ownershipType: null,
+    });
+    this.emitCreditsUpdated(userId);
+  }
+
+  private emitCreditsUpdated(userId: string): void {
+    subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
   }
 }

package/src/domains/subscription/application/SubscriptionSyncUtils.ts

@@ -39,6 +39,10 @@ export const extractRevenueCatData = (customerInfo: CustomerInfo, entitlementId:
   return {
     expirationDate: entitlement.expirationDate ?? null,
     willRenew: entitlement.willRenew ?? null,
+    // Maps SDK's `storeTransactionId` (current transaction ID from Apple/Google)
+    // to our domain's `originalTransactionId`. Used as dedup key in processedTransactions.
+    // Note: The SDK does not expose `original_store_transaction_id` (the first purchase's
+    // ID that stays constant across renewals) — only available via server-side webhooks.
     originalTransactionId: subscription?.storeTransactionId ?? null,
     periodType: validatePeriodType(entitlement.periodType),
     packageType: null,

package/src/domains/subscription/application/initializer/ServiceConfigurator.ts

@@ -1,13 +1,10 @@
 import { configureCreditsRepository } from "../../../credits/infrastructure/CreditsRepositoryManager";
 import { SubscriptionManager } from "../../infrastructure/managers/SubscriptionManager";
 import { configureAuthProvider } from "../../presentation/useAuthAwarePurchase";
-import { SubscriptionSyncService } from "../SubscriptionSyncService";
+import { SubscriptionSyncProcessor } from "../SubscriptionSyncProcessor";
 import type { SubscriptionInitConfig } from "../SubscriptionInitializerTypes";
-import type { CustomerInfo } from "react-native-purchases";
-import type { PackageType } from "../../../revenuecat/core/types/RevenueCatTypes";
-import { PURCHASE_SOURCE, PERIOD_TYPE, type PurchaseSource, type PeriodType } from "../../core/SubscriptionConstants";
 
-export function configureServices(config: SubscriptionInitConfig, apiKey: string): SubscriptionSyncService {
+export function configureServices(config: SubscriptionInitConfig, apiKey: string): SubscriptionSyncProcessor {
   const { entitlementId, credits, creditPackages, getFirebaseAuth, showAuthModal, onCreditsUpdated, getAnonymousUserId } = config;
 
   if (!creditPackages) {
@@ -19,41 +16,16 @@ export function configureServices(config: SubscriptionInitConfig, apiKey: string
     creditPackageAmounts: creditPackages.amounts
   });
 
-  const syncService = new SubscriptionSyncService(entitlementId, getAnonymousUserId);
+  const syncProcessor = new SubscriptionSyncProcessor(entitlementId, getAnonymousUserId);
 
   SubscriptionManager.configure({
     config: {
       apiKey,
       entitlementIdentifier: entitlementId,
       consumableProductIdentifiers: [creditPackages.identifierPattern],
-      onPurchaseCompleted: (
-        u: string,
-        p: string,
-        c: CustomerInfo,
-        s?: string,
-        pkgType?: PackageType | null
-      ) => {
-        const validSource = s && Object.values(PURCHASE_SOURCE).includes(s as PurchaseSource) ? s as PurchaseSource : undefined;
-        return syncService.handlePurchase(u, p, c, validSource, pkgType);
-      },
-      onRenewalDetected: (
-        u: string,
-        p: string,
-        expires: string,
-        c: CustomerInfo
-      ) => syncService.handleRenewal(u, p, expires, c),
-      onPremiumStatusChanged: (
-        u: string,
-        isP: boolean,
-        pId?: string,
-        exp?: string,
-        willR?: boolean,
-        pt?: string,
-        txnId?: string
-      ) => {
-        const validPeriodType = pt && Object.values(PERIOD_TYPE).includes(pt as PeriodType) ? pt as PeriodType : undefined;
-        return syncService.handlePremiumStatusChanged(u, isP, pId, exp, willR, validPeriodType, txnId);
-      },
+      onPurchaseCompleted: (event) => syncProcessor.handlePurchase(event),
+      onRenewalDetected: (event) => syncProcessor.handleRenewal(event),
+      onPremiumStatusChanged: (event) => syncProcessor.handlePremiumStatusChanged(event),
       onCreditsUpdated,
     },
     apiKey,
@@ -67,5 +39,5 @@ export function configureServices(config: SubscriptionInitConfig, apiKey: string
     showAuthModal,
   });
 
-  return syncService;
+  return syncProcessor;
 }

package/src/domains/subscription/core/SubscriptionEvents.ts

@@ -0,0 +1,42 @@
+import type { CustomerInfo } from "react-native-purchases";
+import type { PeriodType, PurchaseSource } from "./SubscriptionConstants";
+import type { PackageType } from "../../revenuecat/core/types/RevenueCatTypes";
+
+export interface PurchaseCompletedEvent {
+  userId: string;
+  productId: string;
+  customerInfo: CustomerInfo;
+  source?: PurchaseSource;
+  packageType?: PackageType | null;
+}
+
+export interface RenewalDetectedEvent {
+  userId: string;
+  productId: string;
+  newExpirationDate: string;
+  customerInfo: CustomerInfo;
+}
+
+export interface PremiumStatusChangedEvent {
+  userId: string;
+  isPremium: boolean;
+  productId?: string;
+  expiresAt?: string;
+  willRenew?: boolean;
+  periodType?: PeriodType;
+  originalTransactionId?: string;
+}
+
+export interface PlanChangedEvent {
+  userId: string;
+  newProductId: string;
+  previousProductId: string;
+  isUpgrade: boolean;
+  customerInfo: CustomerInfo;
+}
+
+export interface RestoreCompletedEvent {
+  userId: string;
+  isPremium: boolean;
+  customerInfo: CustomerInfo;
+}

package/src/domains/subscription/infrastructure/services/listeners/CustomerInfoHandler.ts

@@ -13,9 +13,8 @@ async function handleRenewal(
   if (!onRenewalDetected) return;
 
   try {
-    await onRenewalDetected(userId, productId, expirationDate, customerInfo);
+    await onRenewalDetected({ userId, productId, newExpirationDate: expirationDate, customerInfo });
   } catch (error) {
-    // Callback errors should not break customer info processing
     console.error('[CustomerInfoHandler] Renewal callback failed:', {
       userId,
       productId,
@@ -35,9 +34,8 @@ async function handlePlanChange(
   if (!onPlanChanged) return;
 
   try {
-    await onPlanChanged(userId, newProductId, previousProductId, isUpgrade, customerInfo);
+    await onPlanChanged({ userId, newProductId, previousProductId, isUpgrade, customerInfo });
   } catch (error) {
-    // Callback errors should not break customer info processing
     console.error('[CustomerInfoHandler] Plan change callback failed:', {
       userId,
       newProductId,
@@ -56,7 +54,6 @@ async function handlePremiumStatusSync(
   try {
     await syncPremiumStatus(config, userId, customerInfo);
   } catch (error) {
-    // Sync errors are logged by PremiumStatusSyncer, don't break processing
     console.error('[CustomerInfoHandler] Premium status sync failed:', {
       userId,
       error: error instanceof Error ? error.message : String(error)

package/src/domains/subscription/infrastructure/utils/PremiumStatusSyncer.ts

@@ -1,7 +1,9 @@
 import type { CustomerInfo } from "react-native-purchases";
-import type { RevenueCatConfig, PackageType } from "../../../revenuecat/core/types";
-import type { PurchaseSource } from "../../../subscription/core/SubscriptionConstants";
+import type { RevenueCatConfig } from "../../../revenuecat/core/types";
+import type { PurchaseSource } from "../../core/SubscriptionConstants";
+import type { PackageType } from "../../../revenuecat/core/types";
 import { getPremiumEntitlement } from "../../../revenuecat/core/types";
+import type { PeriodType } from "../../core/SubscriptionConstants";
 
 export async function syncPremiumStatus(
     config: RevenueCatConfig,
@@ -29,19 +31,18 @@ export async function syncPremiumStatus(
     try {
         if (premiumEntitlement) {
             const subscription = customerInfo.subscriptionsByProductIdentifier?.[premiumEntitlement.productIdentifier];
-            const originalTransactionId = subscription?.storeTransactionId ?? undefined;
 
-            await config.onPremiumStatusChanged(
+            await config.onPremiumStatusChanged({
                 userId,
-                true,
-                premiumEntitlement.productIdentifier,
-                premiumEntitlement.expirationDate ?? undefined,
-                premiumEntitlement.willRenew,
-                premiumEntitlement.periodType as "NORMAL" | "INTRO" | undefined,
-                originalTransactionId
-            );
+                isPremium: true,
+                productId: premiumEntitlement.productIdentifier,
+                expiresAt: premiumEntitlement.expirationDate ?? undefined,
+                willRenew: premiumEntitlement.willRenew,
+                periodType: premiumEntitlement.periodType as PeriodType | undefined,
+                originalTransactionId: subscription?.storeTransactionId ?? undefined,
+            });
         } else {
-            await config.onPremiumStatusChanged(userId, false, undefined, undefined, undefined, undefined, undefined);
+            await config.onPremiumStatusChanged({ userId, isPremium: false });
         }
         return { success: true };
     } catch (error) {
@@ -65,11 +66,9 @@ export async function notifyPurchaseCompleted(
     source?: PurchaseSource,
     packageType?: PackageType | null
 ): Promise<void> {
-    if (!config.onPurchaseCompleted) {
-        return;
-    }
+    if (!config.onPurchaseCompleted) return;
 
-    await config.onPurchaseCompleted(userId, productId, customerInfo, source, packageType);
+    await config.onPurchaseCompleted({ userId, productId, customerInfo, source, packageType });
 }
 
 export async function notifyRestoreCompleted(
@@ -78,12 +77,10 @@ export async function notifyRestoreCompleted(
     isPremium: boolean,
     customerInfo: CustomerInfo
 ): Promise<void> {
-    if (!config.onRestoreCompleted) {
-        return;
-    }
+    if (!config.onRestoreCompleted) return;
 
     try {
-        await config.onRestoreCompleted(userId, isPremium, customerInfo);
+        await config.onRestoreCompleted({ userId, isPremium, customerInfo });
     } catch (error) {
         console.error('[PremiumStatusSyncer] Restore callback failed:', error instanceof Error ? error.message : String(error));
     }

package/src/domains/subscription/presentation/screens/SubscriptionDetailScreen.tsx

@@ -110,10 +110,12 @@ const DevTestPanel: React.FC<{ statusType: string }> = ({ statusType }) => {
 
   const handleCancel = useCallback(() => run("Cancel", async () => {
     const { useAuthStore, selectUserId } = require("@umituz/react-native-auth");
-    const { handleExpiredSubscription } = require("../../application/statusChangeHandlers");
+    const { getCreditsRepository } = require("../../../credits/infrastructure/CreditsRepositoryManager");
+    const { subscriptionEventBus, SUBSCRIPTION_EVENTS } = require("../../../../shared/infrastructure/SubscriptionEventBus");
     const userId = selectUserId(useAuthStore.getState());
     if (!userId) throw new Error("No userId found");
-    await handleExpiredSubscription(userId);
+    await getCreditsRepository().syncExpiredStatus(userId);
+    subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
   }), [run]);
 
   const handleRestore = useCallback(() => run("Restore", async () => {

package/src/domains/subscription/application/SubscriptionSyncService.ts

@@ -1,68 +0,0 @@
-import type { CustomerInfo } from "react-native-purchases";
-import { type PeriodType, type PurchaseSource } from "../core/SubscriptionConstants";
-import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
-import { SubscriptionSyncProcessor } from "./SubscriptionSyncProcessor";
-import type { PackageType } from "../../revenuecat/core/types";
-
-export class SubscriptionSyncService {
-  private processor: SubscriptionSyncProcessor;
-
-  constructor(
-    entitlementId: string,
-    getAnonymousUserId: () => Promise<string>
-  ) {
-    this.processor = new SubscriptionSyncProcessor(entitlementId, getAnonymousUserId);
-  }
-
-  async handlePurchase(userId: string, productId: string, customerInfo: CustomerInfo, source?: PurchaseSource, packageType?: PackageType | null) {
-    try {
-      await this.processor.processPurchase(userId, productId, customerInfo, source, packageType);
-      subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PURCHASE_COMPLETED, { userId, productId });
-    } catch (error) {
-      console.error('[SubscriptionSyncService] Purchase processing failed', {
-        userId,
-        productId,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-  }
-
-  async handleRenewal(userId: string, productId: string, newExpirationDate: string, customerInfo: CustomerInfo) {
-    try {
-      await this.processor.processRenewal(userId, productId, newExpirationDate, customerInfo);
-      subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.RENEWAL_DETECTED, { userId, productId });
-    } catch (error) {
-      console.error('[SubscriptionSyncService] Renewal processing failed', {
-        userId,
-        productId,
-        newExpirationDate,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-  }
-
-  async handlePremiumStatusChanged(
-    userId: string,
-    isPremium: boolean,
-    productId?: string,
-    expiresAt?: string,
-    willRenew?: boolean,
-    periodType?: PeriodType,
-    originalTransactionId?: string
-  ) {
-    try {
-      await this.processor.processStatusChange(userId, isPremium, productId, expiresAt, willRenew, periodType, originalTransactionId);
-      subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PREMIUM_STATUS_CHANGED, { userId, isPremium });
-    } catch (error) {
-      console.error('[SubscriptionSyncService] Status change processing failed', {
-        userId,
-        isPremium,
-        productId,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-  }
-}

package/src/domains/subscription/application/statusChangeHandlers.ts

@@ -1,55 +0,0 @@
-import type { PeriodType } from "../core/SubscriptionConstants";
-import { getCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryManager";
-import { emitCreditsUpdated } from "./syncEventEmitter";
-
-export const handleExpiredSubscription = async (userId: string): Promise<void> => {
-  await getCreditsRepository().syncExpiredStatus(userId);
-  emitCreditsUpdated(userId);
-};
-
-export const handlePremiumStatusSync = async (
-  userId: string,
-  isPremium: boolean,
-  productId: string,
-  expiresAt: string | null,
-  willRenew: boolean,
-  periodType: PeriodType | null,
-  unsubscribeDetectedAt?: string | null,
-  billingIssueDetectedAt?: string | null,
-  store?: string | null,
-  ownershipType?: string | null,
-  originalTransactionId?: string
-): Promise<void> => {
-  const repo = getCreditsRepository();
-
-  // Recovery: if premium user has no credits document, create one.
-  // Handles edge cases like test store, reinstalls, or failed purchase initialization.
-  // The originalTransactionId is passed for cross-user deduplication: if this
-  // transaction was already processed by another UID, recovery is skipped.
-  if (isPremium) {
-    const created = await repo.ensurePremiumCreditsExist(
-      userId,
-      productId,
-      willRenew,
-      expiresAt,
-      periodType,
-      originalTransactionId,
-    );
-    if (__DEV__ && created) {
-      console.log('[handlePremiumStatusSync] Recovery: created missing credits document for premium user', { userId, productId });
-    }
-  }
-
-  await repo.syncPremiumMetadata(userId, {
-    isPremium,
-    willRenew,
-    expirationDate: expiresAt,
-    productId,
-    periodType,
-    unsubscribeDetectedAt: unsubscribeDetectedAt ?? null,
-    billingIssueDetectedAt: billingIssueDetectedAt ?? null,
-    store: store ?? null,
-    ownershipType: ownershipType ?? null,
-  });
-  emitCreditsUpdated(userId);
-};

package/src/domains/subscription/application/syncEventEmitter.ts

@@ -1,5 +0,0 @@
-import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
-
-export const emitCreditsUpdated = (userId: string): void => {
-  subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
-};