@umituz/react-native-subscription 2.27.142 → 2.27.144

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.142",
+  "version": "2.27.144",
   "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/subscription/application/SubscriptionSyncProcessor.ts

@@ -1,23 +1,19 @@
 import type { CustomerInfo } from "react-native-purchases";
-import type { RevenueCatData } from "../core/RevenueCatData";
-import { 
-  type PeriodType, 
-  type PurchaseSource, 
-  PURCHASE_SOURCE, 
-  PURCHASE_TYPE 
-} from "../core/SubscriptionConstants";
+import type { PeriodType, PurchaseSource } from "../core/SubscriptionConstants";
+import { PURCHASE_SOURCE, PURCHASE_TYPE } from "../core/SubscriptionConstants";
 import { getCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryManager";
 import { extractRevenueCatData } from "./SubscriptionSyncUtils";
-import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
+import { emitCreditsUpdated } from "./syncEventEmitter";
+import { generatePurchaseId, generateRenewalId } from "./syncIdGenerators";
+import { handleExpiredSubscription, handleFreeUserInitialization, handlePremiumStatusSync } from "./statusChangeHandlers";
+import { NO_SUBSCRIPTION_PRODUCT_ID } from "./syncConstants";
 
 export class SubscriptionSyncProcessor {
   constructor(private entitlementId: string) {}
 
   async processPurchase(userId: string, productId: string, customerInfo: CustomerInfo, source?: PurchaseSource) {
     const revenueCatData = extractRevenueCatData(customerInfo, this.entitlementId);
-    const purchaseId = revenueCatData.originalTransactionId
-      ? `purchase_${revenueCatData.originalTransactionId}`
-      : `purchase_${productId}_${Date.now()}`;
+    const purchaseId = generatePurchaseId(revenueCatData.originalTransactionId, productId);
 
     await getCreditsRepository().initializeCredits(
       userId,
@@ -28,15 +24,13 @@ export class SubscriptionSyncProcessor {
       PURCHASE_TYPE.INITIAL
     );
 
-    subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
+    emitCreditsUpdated(userId);
   }
 
   async processRenewal(userId: string, productId: string, newExpirationDate: string, customerInfo: CustomerInfo) {
     const revenueCatData = extractRevenueCatData(customerInfo, this.entitlementId);
     revenueCatData.expirationDate = newExpirationDate || revenueCatData.expirationDate;
-    const purchaseId = revenueCatData.originalTransactionId
-      ? `renewal_${revenueCatData.originalTransactionId}_${newExpirationDate}`
-      : `renewal_${productId}_${Date.now()}`;
+    const purchaseId = generateRenewalId(revenueCatData.originalTransactionId, productId, newExpirationDate);
 
     await getCreditsRepository().initializeCredits(
       userId,
@@ -47,19 +41,19 @@ export class SubscriptionSyncProcessor {
       PURCHASE_TYPE.RENEWAL
     );
 
-    subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
+    emitCreditsUpdated(userId);
   }
 
   async processStatusChange(
-    userId: string, 
-    isPremium: boolean, 
+    userId: string,
+    isPremium: boolean,
     productId?: string,
-    expiresAt?: string, 
-    willRenew?: boolean, 
+    expiresAt?: string,
+    willRenew?: boolean,
     periodType?: PeriodType
   ) {
     const repository = getCreditsRepository();
-    
+
     if (!isPremium && !productId) {
       const currentCredits = await repository.getCredits(userId);
       if (currentCredits.success && currentCredits.data?.isPremium) {
@@ -68,49 +62,22 @@ export class SubscriptionSyncProcessor {
     }
 
     if (!isPremium && productId) {
-      await repository.syncExpiredStatus(userId);
-      subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
+      await handleExpiredSubscription(userId);
       return;
     }
 
     if (!isPremium && !productId) {
-      const stableSyncId = `init_sync_${userId}`;
-      await repository.initializeCredits(
-        userId, 
-        stableSyncId, 
-        'no_subscription', 
-        PURCHASE_SOURCE.SETTINGS, 
-        { 
-          isPremium: false, 
-          expirationDate: null, 
-          willRenew: false, 
-          periodType: null, 
-          originalTransactionId: null 
-        },
-        PURCHASE_TYPE.INITIAL
-      );
-      subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
+      await handleFreeUserInitialization(userId);
       return;
     }
 
-    const revenueCatData: RevenueCatData = { 
-      expirationDate: expiresAt ?? null, 
-      willRenew: willRenew ?? false, 
-      isPremium, 
-      periodType: periodType ?? null,
-      originalTransactionId: null 
-    };
-    
-    const statusSyncId = `status_sync_${userId}_${isPremium ? 'premium' : 'free'}`;
-    await repository.initializeCredits(
-      userId, 
-      statusSyncId, 
-      productId ?? 'no_subscription', 
-      PURCHASE_SOURCE.SETTINGS, 
-      revenueCatData,
-      PURCHASE_TYPE.INITIAL
+    await handlePremiumStatusSync(
+      userId,
+      isPremium,
+      productId ?? NO_SUBSCRIPTION_PRODUCT_ID,
+      expiresAt ?? null,
+      willRenew ?? false,
+      periodType ?? null
     );
-    
-    subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
   }
 }

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

@@ -0,0 +1,54 @@
+import type { RevenueCatData } from "../core/RevenueCatData";
+import type { PeriodType } from "../core/SubscriptionConstants";
+import { PURCHASE_SOURCE, PURCHASE_TYPE } from "../core/SubscriptionConstants";
+import { getCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryManager";
+import { emitCreditsUpdated } from "./syncEventEmitter";
+import { generateInitSyncId, generateStatusSyncId } from "./syncIdGenerators";
+import { NO_SUBSCRIPTION_PRODUCT_ID, DEFAULT_FREE_USER_DATA } from "./syncConstants";
+
+export const handleExpiredSubscription = async (userId: string): Promise<void> => {
+  await getCreditsRepository().syncExpiredStatus(userId);
+  emitCreditsUpdated(userId);
+};
+
+export const handleFreeUserInitialization = async (userId: string): Promise<void> => {
+  const stableSyncId = generateInitSyncId(userId);
+  await getCreditsRepository().initializeCredits(
+    userId,
+    stableSyncId,
+    NO_SUBSCRIPTION_PRODUCT_ID,
+    PURCHASE_SOURCE.SETTINGS,
+    DEFAULT_FREE_USER_DATA,
+    PURCHASE_TYPE.INITIAL
+  );
+  emitCreditsUpdated(userId);
+};
+
+export const handlePremiumStatusSync = async (
+  userId: string,
+  isPremium: boolean,
+  productId: string,
+  expiresAt: string | null,
+  willRenew: boolean,
+  periodType: PeriodType | null
+): Promise<void> => {
+  const revenueCatData: RevenueCatData = {
+    expirationDate: expiresAt,
+    willRenew,
+    isPremium,
+    periodType,
+    originalTransactionId: null
+  };
+
+  const statusSyncId = generateStatusSyncId(userId, isPremium);
+  await getCreditsRepository().initializeCredits(
+    userId,
+    statusSyncId,
+    productId,
+    PURCHASE_SOURCE.SETTINGS,
+    revenueCatData,
+    PURCHASE_TYPE.INITIAL
+  );
+
+  emitCreditsUpdated(userId);
+};

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

@@ -0,0 +1,11 @@
+import type { RevenueCatData } from "../core/RevenueCatData";
+
+export const NO_SUBSCRIPTION_PRODUCT_ID = 'no_subscription';
+
+export const DEFAULT_FREE_USER_DATA: RevenueCatData = {
+  isPremium: false,
+  expirationDate: null,
+  willRenew: false,
+  periodType: null,
+  originalTransactionId: null,
+};

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

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

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

@@ -0,0 +1,19 @@
+export const generatePurchaseId = (originalTransactionId: string | null, productId: string): string => {
+  return originalTransactionId
+    ? `purchase_${originalTransactionId}`
+    : `purchase_${productId}_${Date.now()}`;
+};
+
+export const generateRenewalId = (originalTransactionId: string | null, productId: string, expirationDate: string): string => {
+  return originalTransactionId
+    ? `renewal_${originalTransactionId}_${expirationDate}`
+    : `renewal_${productId}_${Date.now()}`;
+};
+
+export const generateInitSyncId = (userId: string): string => {
+  return `init_sync_${userId}`;
+};
+
+export const generateStatusSyncId = (userId: string, isPremium: boolean): string => {
+  return `status_sync_${userId}_${isPremium ? 'premium' : 'free'}`;
+};

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

@@ -1,7 +1 @@
 export const EXPIRATION_WARNING_DAYS = 7;
-
-export const REVENUE_CAT_IGNORED_LOG_MESSAGES = [
-  'Purchase was cancelled',
-  'AppTransaction',
-  "Couldn't find previous transactions",
-] as const;

package/src/domains/subscription/infrastructure/managers/SubscriptionManager.ts

@@ -1,21 +1,13 @@
 import type { PurchasesPackage } from "react-native-purchases";
 import type { IRevenueCatService } from "../../../../shared/application/ports/IRevenueCatService";
-import { initializeRevenueCatService, getRevenueCatService } from "../services/RevenueCatService";
-import { PackageHandler } from "../handlers/PackageHandler";
+import type { PackageHandler } from "../handlers/PackageHandler";
 import { SubscriptionInternalState } from "./SubscriptionInternalState";
-import {
-    ensureConfigured,
-    getCurrentUserIdOrThrow,
-    getOrCreateService,
-    ensureServiceAvailable,
-} from "./subscriptionManagerUtils";
-
-import type { 
-    SubscriptionManagerConfig, 
-    PremiumStatus, 
-    RestoreResultInfo 
-} from "./SubscriptionManager.types";
-
+import { ensureConfigured, ensureServiceAvailable } from "./subscriptionManagerUtils";
+import type { SubscriptionManagerConfig, PremiumStatus, RestoreResultInfo } from "./SubscriptionManager.types";
+import { createPackageHandler } from "./packageHandlerFactory";
+import { checkPremiumStatusFromService } from "./premiumStatusChecker";
+import { getPackagesOperation, purchasePackageOperation, restoreOperation } from "./managerOperations";
+import { performServiceInitialization } from "./initializationHandler";
 
 class SubscriptionManagerImpl {
   private managerConfig: SubscriptionManagerConfig | null = null;
@@ -29,17 +21,8 @@ class SubscriptionManagerImpl {
   }
 
   private ensurePackageHandlerInitialized(): void {
-    if (this.packageHandler) {
-      return;
-    }
-
-    ensureServiceAvailable(this.serviceInstance);
-    ensureConfigured(this.managerConfig);
-
-    this.packageHandler = new PackageHandler(
-      this.serviceInstance!,
-      this.managerConfig!.config.entitlementIdentifier
-    );
+    if (this.packageHandler) return;
+    this.packageHandler = createPackageHandler(this.serviceInstance, this.managerConfig);
   }
 
   async initialize(userId?: string): Promise<boolean> {
@@ -52,66 +35,41 @@ class SubscriptionManagerImpl {
       return existingPromise;
     }
 
-    const promise = (async () => {
-        await initializeRevenueCatService(this.managerConfig!.config);
-        this.serviceInstance = getRevenueCatService();
-
-        ensureServiceAvailable(this.serviceInstance);
-        this.ensurePackageHandlerInitialized();
-
-        const result = await this.serviceInstance!.initialize(actualUserId);
-        return result.success;
-    })();
-
+    const promise = this.performInitialization(actualUserId);
     this.state.initCache.setPromise(promise, actualUserId);
     return promise;
   }
 
-  isInitializedForUser(userId: string): boolean {
-    if (!this.serviceInstance?.isInitialized()) {
-      return false;
-    }
-
-    return this.state.initCache.getCurrentUserId() === userId;
+  private async performInitialization(userId: string): Promise<boolean> {
+    const { service, success } = await performServiceInitialization(this.managerConfig!.config, userId);
+    this.serviceInstance = service;
+    this.ensurePackageHandlerInitialized();
+    return success;
   }
 
+  isInitializedForUser = (userId: string): boolean =>
+    this.serviceInstance?.isInitialized() && this.state.initCache.getCurrentUserId() === userId;
+
   async getPackages(): Promise<PurchasesPackage[]> {
-    ensureConfigured(this.managerConfig);
-    this.serviceInstance = getOrCreateService(this.serviceInstance);
     this.ensurePackageHandlerInitialized();
-
-    return this.packageHandler!.fetchPackages();
+    return getPackagesOperation(this.managerConfig, this.serviceInstance, this.packageHandler!);
   }
 
   async purchasePackage(pkg: PurchasesPackage): Promise<boolean> {
-    ensureConfigured(this.managerConfig);
-    const userId = getCurrentUserIdOrThrow(this.state);
     this.ensurePackageHandlerInitialized();
-
-    return this.packageHandler!.purchase(pkg, userId);
+    return purchasePackageOperation(pkg, this.managerConfig, this.state, this.packageHandler!);
   }
 
   async restore(): Promise<RestoreResultInfo> {
-    ensureConfigured(this.managerConfig);
-    const userId = getCurrentUserIdOrThrow(this.state);
     this.ensurePackageHandlerInitialized();
-
-    return this.packageHandler!.restore(userId);
+    return restoreOperation(this.managerConfig, this.state, this.packageHandler!);
   }
 
   async checkPremiumStatus(): Promise<PremiumStatus> {
     ensureConfigured(this.managerConfig);
-    getCurrentUserIdOrThrow(this.state);
     ensureServiceAvailable(this.serviceInstance);
-
-    const customerInfo = await this.serviceInstance!.getCustomerInfo();
-
-    if (!customerInfo) {
-      throw new Error("Customer info not available");
-    }
-
     this.ensurePackageHandlerInitialized();
-    return this.packageHandler!.checkPremiumStatusFromInfo(customerInfo);
+    return checkPremiumStatusFromService(this.serviceInstance!, this.packageHandler!);
   }
 
   async reset(): Promise<void> {
@@ -121,13 +79,9 @@ class SubscriptionManagerImpl {
     this.packageHandler = null;
   }
 
-  isConfigured(): boolean {
-    return this.managerConfig !== null;
-  }
+  isConfigured = (): boolean => this.managerConfig !== null;
 
-  isInitialized(): boolean {
-    return this.serviceInstance?.isInitialized() ?? false;
-  }
+  isInitialized = (): boolean => this.serviceInstance?.isInitialized() ?? false;
 
   getEntitlementId(): string {
     ensureConfigured(this.managerConfig);

package/src/domains/subscription/infrastructure/managers/initializationHandler.ts

@@ -0,0 +1,14 @@
+import type { IRevenueCatService } from "../../../../shared/application/ports/IRevenueCatService";
+import { initializeRevenueCatService, getRevenueCatService } from "../services/RevenueCatService";
+import { ensureServiceAvailable } from "./subscriptionManagerUtils";
+import type { RevenueCatConfig } from "../../core/RevenueCatConfig";
+
+export const performServiceInitialization = async (config: RevenueCatConfig, userId: string): Promise<{ service: IRevenueCatService; success: boolean }> => {
+  await initializeRevenueCatService(config);
+  const service = getRevenueCatService();
+
+  ensureServiceAvailable(service);
+
+  const result = await service!.initialize(userId);
+  return { service: service!, success: result.success };
+};

package/src/domains/subscription/infrastructure/managers/managerConstants.ts

@@ -0,0 +1,3 @@
+export const ERROR_MESSAGES = {
+  CUSTOMER_INFO_NOT_AVAILABLE: "Customer info not available",
+} as const;

package/src/domains/subscription/infrastructure/managers/managerOperations.ts

@@ -0,0 +1,38 @@
+import type { PurchasesPackage } from "react-native-purchases";
+import type { IRevenueCatService } from "../../../../shared/application/ports/IRevenueCatService";
+import type { PackageHandler } from "../handlers/PackageHandler";
+import type { RestoreResultInfo } from "./SubscriptionManager.types";
+import { SubscriptionInternalState } from "./SubscriptionInternalState";
+import { ensureConfigured, getCurrentUserIdOrThrow, getOrCreateService } from "./subscriptionManagerUtils";
+import type { SubscriptionManagerConfig } from "./SubscriptionManager.types";
+
+export const getPackagesOperation = async (
+  managerConfig: SubscriptionManagerConfig | null,
+  serviceInstance: IRevenueCatService | null,
+  packageHandler: PackageHandler
+): Promise<PurchasesPackage[]> => {
+  ensureConfigured(managerConfig);
+  getOrCreateService(serviceInstance);
+  return packageHandler.fetchPackages();
+};
+
+export const purchasePackageOperation = async (
+  pkg: PurchasesPackage,
+  managerConfig: SubscriptionManagerConfig | null,
+  state: SubscriptionInternalState,
+  packageHandler: PackageHandler
+): Promise<boolean> => {
+  ensureConfigured(managerConfig);
+  const userId = getCurrentUserIdOrThrow(state);
+  return packageHandler.purchase(pkg, userId);
+};
+
+export const restoreOperation = async (
+  managerConfig: SubscriptionManagerConfig | null,
+  state: SubscriptionInternalState,
+  packageHandler: PackageHandler
+): Promise<RestoreResultInfo> => {
+  ensureConfigured(managerConfig);
+  const userId = getCurrentUserIdOrThrow(state);
+  return packageHandler.restore(userId);
+};

package/src/domains/subscription/infrastructure/managers/packageHandlerFactory.ts

@@ -0,0 +1,17 @@
+import type { IRevenueCatService } from "../../../../shared/application/ports/IRevenueCatService";
+import { PackageHandler } from "../handlers/PackageHandler";
+import { ensureServiceAvailable, ensureConfigured } from "./subscriptionManagerUtils";
+import type { SubscriptionManagerConfig } from "./SubscriptionManager.types";
+
+export const createPackageHandler = (
+  service: IRevenueCatService | null,
+  config: SubscriptionManagerConfig | null
+): PackageHandler => {
+  ensureServiceAvailable(service);
+  ensureConfigured(config);
+
+  return new PackageHandler(
+    service!,
+    config!.config.entitlementIdentifier
+  );
+};

package/src/domains/subscription/infrastructure/managers/premiumStatusChecker.ts

@@ -0,0 +1,17 @@
+import type { IRevenueCatService } from "../../../../shared/application/ports/IRevenueCatService";
+import type { PackageHandler } from "../handlers/PackageHandler";
+import type { PremiumStatus } from "./SubscriptionManager.types";
+import { ERROR_MESSAGES } from "./managerConstants";
+
+export const checkPremiumStatusFromService = async (
+  service: IRevenueCatService,
+  packageHandler: PackageHandler
+): Promise<PremiumStatus> => {
+  const customerInfo = await service.getCustomerInfo();
+
+  if (!customerInfo) {
+    throw new Error(ERROR_MESSAGES.CUSTOMER_INFO_NOT_AVAILABLE);
+  }
+
+  return packageHandler.checkPremiumStatusFromInfo(customerInfo);
+};

package/src/domains/subscription/infrastructure/services/RevenueCatInitializer.ts

@@ -1,41 +1,17 @@
 import Purchases, { type CustomerInfo, type PurchasesOfferings } from "react-native-purchases";
 import type { InitializeResult } from "../../../../shared/application/ports/IRevenueCatService";
-import type { RevenueCatConfig } from "../../core/RevenueCatConfig";
 import { resolveApiKey } from "../utils/ApiKeyResolver";
+import type { InitializerDeps } from "./RevenueCatInitializer.types";
+import { FAILED_INITIALIZATION_RESULT, CONFIGURATION_RETRY_DELAY_MS } from "./initializerConstants";
 
-export interface InitializerDeps {
-  config: RevenueCatConfig;
-  isInitialized: () => boolean;
-  getCurrentUserId: () => string | null;
-  setInitialized: (value: boolean) => void;
-  setCurrentUserId: (userId: string) => void;
-}
+export type { InitializerDeps } from "./RevenueCatInitializer.types";
 
-// State management to prevent race conditions
 const configurationState = {
     isPurchasesConfigured: false,
-    isLogHandlerConfigured: false,
     configurationInProgress: false,
     configurationPromise: null as Promise<InitializeResult> | null,
 };
 
-
-// Simple lock mechanism to prevent concurrent configurations (implementation deferred)
-
-function configureLogHandler(): void {
-  if (configurationState.isLogHandlerConfigured) return;
-  if (typeof Purchases.setLogHandler !== 'function') return;
-  try {
-    Purchases.setLogHandler((_logLevel, message) => {
-      const ignoreMessages = ['Purchase was cancelled', 'AppTransaction', "Couldn't find previous transactions"];
-      if (ignoreMessages.some(m => message.includes(m))) return;
-    });
-    configurationState.isLogHandlerConfigured = true;
-  } catch {
-    // Failing to set log handler should not block initialization
-  }
-}
-
 function buildSuccessResult(deps: InitializerDeps, customerInfo: CustomerInfo, offerings: PurchasesOfferings): InitializeResult {
   const isPremium = !!customerInfo.entitlements.active[deps.config.entitlementIdentifier];
   return { success: true, offering: offerings.current, isPremium };
@@ -54,7 +30,7 @@ export async function initializeSDK(
       ]);
       return buildSuccessResult(deps, customerInfo, offerings);
     } catch {
-      return { success: false, offering: null, isPremium: false };
+      return FAILED_INITIALIZATION_RESULT;
     }
   }
 
@@ -73,7 +49,7 @@ export async function initializeSDK(
       const offerings = await Purchases.getOfferings();
       return buildSuccessResult(deps, customerInfo, offerings);
     } catch {
-      return { success: false, offering: null, isPremium: false };
+      return FAILED_INITIALIZATION_RESULT;
     }
   }
 
@@ -82,13 +58,13 @@ export async function initializeSDK(
         await configurationState.configurationPromise;
         return initializeSDK(deps, userId, apiKey);
     }
-    await new Promise(resolve => setTimeout(resolve, 100));
+    await new Promise(resolve => setTimeout(resolve, CONFIGURATION_RETRY_DELAY_MS));
     return initializeSDK(deps, userId, apiKey);
   }
 
   const key = apiKey || resolveApiKey(deps.config);
   if (!key) {
-    return { success: false, offering: null, isPremium: false };
+    return FAILED_INITIALIZATION_RESULT;
   }
 
   let resolveInProgress: (value: InitializeResult) => void;
@@ -98,7 +74,6 @@ export async function initializeSDK(
   
   configurationState.configurationInProgress = true;
   try {
-    configureLogHandler();
     await Purchases.configure({ apiKey: key, appUserID: userId });
     configurationState.isPurchasesConfigured = true;
     deps.setInitialized(true);
@@ -113,9 +88,8 @@ export async function initializeSDK(
     resolveInProgress!(result);
     return result;
   } catch {
-    const errorResult = { success: false, offering: null, isPremium: false };
-    resolveInProgress!(errorResult);
-    return errorResult;
+    resolveInProgress!(FAILED_INITIALIZATION_RESULT);
+    return FAILED_INITIALIZATION_RESULT;
   } finally {
     configurationState.configurationInProgress = false;
     configurationState.configurationPromise = null;

package/src/domains/subscription/infrastructure/services/RevenueCatInitializer.types.ts

@@ -0,0 +1,9 @@
+import type { RevenueCatConfig } from "../../core/RevenueCatConfig";
+
+export interface InitializerDeps {
+  config: RevenueCatConfig;
+  isInitialized: () => boolean;
+  getCurrentUserId: () => string | null;
+  setInitialized: (value: boolean) => void;
+  setCurrentUserId: (userId: string) => void;
+}

package/src/domains/subscription/infrastructure/services/RevenueCatService.ts

@@ -1,134 +1,2 @@
-/**
- * RevenueCat Service Implementation
- * Main service class for RevenueCat operations
- */
-
-import Purchases from "react-native-purchases";
-import type {
-    PurchasesOffering,
-    PurchasesPackage,
-    CustomerInfo,
-} from "react-native-purchases";
-import type {
-    IRevenueCatService,
-    InitializeResult,
-    PurchaseResult,
-    RestoreResult,
-} from "../../../../shared/application/ports/IRevenueCatService";
-import type { RevenueCatConfig } from "../../core/RevenueCatConfig";
-import { resolveApiKey } from "../utils/ApiKeyResolver";
-import { initializeSDK } from "./RevenueCatInitializer";
-import { fetchOfferings } from "./OfferingsFetcher";
-import { handlePurchase } from "./PurchaseHandler";
-import { handleRestore } from "./RestoreHandler";
-import { CustomerInfoListenerManager } from "./CustomerInfoListenerManager";
-import { ServiceStateManager } from "./ServiceStateManager";
-
-export class RevenueCatService implements IRevenueCatService {
-    private stateManager: ServiceStateManager;
-    private listenerManager: CustomerInfoListenerManager;
-
-    constructor(config: RevenueCatConfig) {
-        this.stateManager = new ServiceStateManager(config);
-        this.listenerManager = new CustomerInfoListenerManager();
-    }
-
-    getRevenueCatKey(): string | null {
-        return resolveApiKey(this.stateManager.getConfig());
-    }
-
-    isInitialized(): boolean {
-        return this.stateManager.isInitialized();
-    }
-
-    getCurrentUserId(): string | null {
-        return this.stateManager.getCurrentUserId();
-    }
-
-    private getSDKParams() {
-        return {
-            config: this.stateManager.getConfig(),
-            isInitialized: () => this.isInitialized(),
-            getCurrentUserId: () => this.stateManager.getCurrentUserId(),
-            setInitialized: (value: boolean) => this.stateManager.setInitialized(value),
-            setCurrentUserId: (id: string | null) => this.stateManager.setCurrentUserId(id),
-        };
-    }
-
-    async initialize(userId: string, apiKey?: string): Promise<InitializeResult> {
-        if (this.isInitialized() && this.getCurrentUserId() === userId) {
-            const customerInfo = await Purchases.getCustomerInfo();
-            const isPremium = !!customerInfo.entitlements.active[this.stateManager.getConfig().entitlementIdentifier];
-            return {
-                success: true,
-                offering: await this.fetchOfferings(),
-                isPremium,
-            };
-        }
-
-        const result = await initializeSDK(this.getSDKParams(), userId, apiKey);
-
-        if (result.success) {
-            this.listenerManager.setUserId(userId);
-            this.listenerManager.setupListener(this.stateManager.getConfig());
-        }
-
-        return result;
-    }
-
-    async fetchOfferings(): Promise<PurchasesOffering | null> {
-        return fetchOfferings(this.getSDKParams());
-    }
-
-    async purchasePackage(
-        pkg: PurchasesPackage,
-        userId: string
-    ): Promise<PurchaseResult> {
-        return handlePurchase(this.getSDKParams(), pkg, userId);
-    }
-
-    async restorePurchases(userId: string): Promise<RestoreResult> {
-        return handleRestore(this.getSDKParams(), userId);
-    }
-
-    async getCustomerInfo(): Promise<CustomerInfo | null> {
-        if (!this.isInitialized()) {
-            return null;
-        }
-        return Purchases.getCustomerInfo();
-    }
-
-    async reset(): Promise<void> {
-        if (!this.isInitialized()) {
-            return;
-        }
-
-        this.listenerManager.destroy();
-
-        try {
-            await Purchases.logOut();
-            this.stateManager.setInitialized(false);
-        } catch {
-            // Silently fail during logout to allow cleanup to complete
-        }
-    }
-}
-
-let revenueCatServiceInstance: RevenueCatService | null = null;
-
-export function initializeRevenueCatService(
-    config: RevenueCatConfig
-): RevenueCatService {
-    if (!revenueCatServiceInstance) {
-        revenueCatServiceInstance = new RevenueCatService(config);
-    }
-    return revenueCatServiceInstance;
-}
-
-export function getRevenueCatService(): RevenueCatService | null {
-    return revenueCatServiceInstance;
-}
-
-export function resetRevenueCatService(): void {
-    revenueCatServiceInstance = null;
-}
+export { RevenueCatService } from "./RevenueCatService.types";
+export { initializeRevenueCatService, getRevenueCatService, resetRevenueCatService } from "./revenueCatServiceInstance";

package/src/domains/subscription/infrastructure/services/RevenueCatService.types.ts

@@ -0,0 +1,87 @@
+import Purchases from "react-native-purchases";
+import type { PurchasesOffering, PurchasesPackage, CustomerInfo } from "react-native-purchases";
+import type { IRevenueCatService, InitializeResult, PurchaseResult, RestoreResult } from "../../../../shared/application/ports/IRevenueCatService";
+import type { RevenueCatConfig } from "../../core/RevenueCatConfig";
+import { resolveApiKey } from "../utils/ApiKeyResolver";
+import { initializeSDK } from "./RevenueCatInitializer";
+import { fetchOfferings } from "./OfferingsFetcher";
+import { handlePurchase } from "./PurchaseHandler";
+import { handleRestore } from "./RestoreHandler";
+import { CustomerInfoListenerManager } from "./CustomerInfoListenerManager";
+import { ServiceStateManager } from "./ServiceStateManager";
+
+export class RevenueCatService implements IRevenueCatService {
+    private stateManager: ServiceStateManager;
+    private listenerManager: CustomerInfoListenerManager;
+
+    constructor(config: RevenueCatConfig) {
+        this.stateManager = new ServiceStateManager(config);
+        this.listenerManager = new CustomerInfoListenerManager();
+    }
+
+    getRevenueCatKey = (): string | null => resolveApiKey(this.stateManager.getConfig());
+
+    isInitialized = (): boolean => this.stateManager.isInitialized();
+
+    getCurrentUserId = (): string | null => this.stateManager.getCurrentUserId();
+
+    private getSDKParams() {
+        return {
+            config: this.stateManager.getConfig(),
+            isInitialized: () => this.isInitialized(),
+            getCurrentUserId: () => this.stateManager.getCurrentUserId(),
+            setInitialized: (value: boolean) => this.stateManager.setInitialized(value),
+            setCurrentUserId: (id: string | null) => this.stateManager.setCurrentUserId(id),
+        };
+    }
+
+    async initialize(userId: string, apiKey?: string): Promise<InitializeResult> {
+        if (this.isInitialized() && this.getCurrentUserId() === userId) {
+            const customerInfo = await Purchases.getCustomerInfo();
+            const isPremium = !!customerInfo.entitlements.active[this.stateManager.getConfig().entitlementIdentifier];
+            return {
+                success: true,
+                offering: await this.fetchOfferings(),
+                isPremium,
+            };
+        }
+
+        const result = await initializeSDK(this.getSDKParams(), userId, apiKey);
+
+        if (result.success) {
+            this.listenerManager.setUserId(userId);
+            this.listenerManager.setupListener(this.stateManager.getConfig());
+        }
+
+        return result;
+    }
+
+    async fetchOfferings(): Promise<PurchasesOffering | null> {
+        return fetchOfferings(this.getSDKParams());
+    }
+
+    async purchasePackage(pkg: PurchasesPackage, userId: string): Promise<PurchaseResult> {
+        return handlePurchase(this.getSDKParams(), pkg, userId);
+    }
+
+    async restorePurchases(userId: string): Promise<RestoreResult> {
+        return handleRestore(this.getSDKParams(), userId);
+    }
+
+    async getCustomerInfo(): Promise<CustomerInfo | null> {
+        if (!this.isInitialized()) return null;
+        return Purchases.getCustomerInfo();
+    }
+
+    async reset(): Promise<void> {
+        if (!this.isInitialized()) return;
+
+        this.listenerManager.destroy();
+
+        try {
+            await Purchases.logOut();
+            this.stateManager.setInitialized(false);
+        } catch {
+        }
+    }
+}

package/src/domains/subscription/infrastructure/services/initializerConstants.ts

@@ -0,0 +1,9 @@
+import type { InitializeResult } from "../../../../shared/application/ports/IRevenueCatService";
+
+export const FAILED_INITIALIZATION_RESULT: InitializeResult = {
+  success: false,
+  offering: null,
+  isPremium: false,
+};
+
+export const CONFIGURATION_RETRY_DELAY_MS = 100;

package/src/domains/subscription/infrastructure/services/revenueCatServiceInstance.ts

@@ -0,0 +1,17 @@
+import { RevenueCatService } from "./RevenueCatService.types";
+import type { RevenueCatConfig } from "../../core/RevenueCatConfig";
+
+let revenueCatServiceInstance: RevenueCatService | null = null;
+
+export const initializeRevenueCatService = (config: RevenueCatConfig): RevenueCatService => {
+  if (!revenueCatServiceInstance) {
+    revenueCatServiceInstance = new RevenueCatService(config);
+  }
+  return revenueCatServiceInstance;
+};
+
+export const getRevenueCatService = (): RevenueCatService | null => revenueCatServiceInstance;
+
+export const resetRevenueCatService = (): void => {
+  revenueCatServiceInstance = null;
+};