@umituz/react-native-subscription 2.27.143 → 2.27.145

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.143",
+  "version": "2.27.145",
   "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,40 +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 { REVENUE_CAT_IGNORED_LOG_MESSAGES } from "../../core/SubscriptionDisplayConfig";
+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) => {
-      if (REVENUE_CAT_IGNORED_LOG_MESSAGES.some(m => message.includes(m))) return;
-    });
-    configurationState.isLogHandlerConfigured = true;
-  } catch {
-  }
-}
-
 function buildSuccessResult(deps: InitializerDeps, customerInfo: CustomerInfo, offerings: PurchasesOfferings): InitializeResult {
   const isPremium = !!customerInfo.entitlements.active[deps.config.entitlementIdentifier];
   return { success: true, offering: offerings.current, isPremium };
@@ -53,7 +30,7 @@ export async function initializeSDK(
       ]);
       return buildSuccessResult(deps, customerInfo, offerings);
     } catch {
-      return { success: false, offering: null, isPremium: false };
+      return FAILED_INITIALIZATION_RESULT;
     }
   }
 
@@ -72,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;
     }
   }
 
@@ -81,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;
@@ -97,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);
@@ -112,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;
+};

package/src/domains/wallet/presentation/components/TransactionItem.styles.ts

@@ -0,0 +1,30 @@
+import { StyleSheet } from "react-native";
+
+export const transactionItemStyles = StyleSheet.create({
+  container: {
+    flexDirection: "row",
+    alignItems: "center",
+    padding: 12,
+    borderRadius: 12,
+    marginBottom: 8,
+  },
+  iconContainer: {
+    width: 40,
+    height: 40,
+    borderRadius: 20,
+    justifyContent: "center",
+    alignItems: "center",
+    marginRight: 12,
+  },
+  content: {
+    flex: 1,
+    gap: 2,
+  },
+  reason: {
+    fontWeight: "600",
+  },
+  change: {
+    fontWeight: "700",
+    marginLeft: 12,
+  },
+});

package/src/domains/wallet/presentation/components/TransactionItem.tsx

@@ -1,41 +1,12 @@
-/**
- * Transaction Item Component
- *
- * Displays a single credit transaction.
- * Props-driven for full customization.
- */
-
 import React, { useMemo } from "react";
-import { View, StyleSheet } from "react-native";
-import {
-    useAppDesignTokens,
-    AtomicText,
-    AtomicIcon,
-} from "@umituz/react-native-design-system";
-import { timezoneService } from "@umituz/react-native-design-system";
-import type { CreditLog } from "../../domain/types/transaction.types";
+import { View } from "react-native";
+import { useAppDesignTokens, AtomicText, AtomicIcon } from "@umituz/react-native-design-system";
 import { getTransactionIcon } from "../../utils/transactionIconMap";
+import { transactionItemStyles } from "./TransactionItem.styles";
+import type { TransactionItemProps } from "./TransactionItem.types";
+import { defaultDateFormatter, getReasonLabel, getChangePrefix } from "./transactionItemHelpers";
 
-export interface TransactionItemTranslations {
-  purchase: string;
-  usage: string;
-  refund: string;
-  bonus: string;
-  subscription: string;
-  admin: string;
-  reward: string;
-  expired: string;
-}
-
-export interface TransactionItemProps {
-  transaction: CreditLog;
-  translations: TransactionItemTranslations;
-  dateFormatter?: (timestamp: number) => string;
-}
-
-const defaultDateFormatter = (timestamp: number): string => {
-  return timezoneService.formatToDisplayDateTime(new Date(timestamp));
-};
+export type { TransactionItemTranslations, TransactionItemProps } from "./TransactionItem.types";
 
 export const TransactionItem: React.FC<TransactionItemProps> = ({
   transaction,
@@ -44,89 +15,34 @@ export const TransactionItem: React.FC<TransactionItemProps> = ({
 }) => {
   const tokens = useAppDesignTokens();
 
-  const reasonLabel = useMemo(() => {
-    return translations[transaction.reason] || transaction.reason;
-  }, [transaction.reason, translations]);
+  const reasonLabel = useMemo(() => getReasonLabel(transaction.reason, translations), [transaction.reason, translations]);
 
   const isPositive = transaction.change > 0;
   const changeColor = isPositive ? tokens.colors.success : tokens.colors.error;
-  const changePrefix = isPositive ? "+" : "";
+  const changePrefix = getChangePrefix(transaction.change);
   const iconName = getTransactionIcon(transaction.reason);
 
   return (
-    <View
-      style={[
-        styles.container,
-        { backgroundColor: tokens.colors.surfaceSecondary },
-      ]}
-    >
-      <View
-        style={[
-          styles.iconContainer,
-          { backgroundColor: tokens.colors.surface },
-        ]}
-      >
+    <View style={[transactionItemStyles.container, { backgroundColor: tokens.colors.surfaceSecondary }]}>
+      <View style={[transactionItemStyles.iconContainer, { backgroundColor: tokens.colors.surface }]}>
         <AtomicIcon name={iconName} size="md" color="secondary" />
       </View>
-      <View style={styles.content}>
-        <AtomicText
-          type="bodyMedium"
-          style={[styles.reason, { color: tokens.colors.textPrimary }]}
-        >
+      <View style={transactionItemStyles.content}>
+        <AtomicText type="bodyMedium" style={[transactionItemStyles.reason, { color: tokens.colors.textPrimary }]}>
           {reasonLabel}
         </AtomicText>
         {transaction.description && (
-          <AtomicText
-            type="bodySmall"
-            style={{ color: tokens.colors.textSecondary }}
-            numberOfLines={1}
-          >
+          <AtomicText type="bodySmall" style={{ color: tokens.colors.textSecondary }} numberOfLines={1}>
             {transaction.description}
           </AtomicText>
         )}
-        <AtomicText
-          type="bodySmall"
-          style={{ color: tokens.colors.textSecondary }}
-        >
+        <AtomicText type="bodySmall" style={{ color: tokens.colors.textSecondary }}>
           {dateFormatter(transaction.createdAt)}
         </AtomicText>
       </View>
-      <AtomicText
-        type="titleMedium"
-        style={[styles.change, { color: changeColor }]}
-      >
-        {changePrefix}
-        {transaction.change}
+      <AtomicText type="titleMedium" style={[transactionItemStyles.change, { color: changeColor }]}>
+        {changePrefix}{transaction.change}
       </AtomicText>
     </View>
   );
 };
-
-const styles = StyleSheet.create({
-  container: {
-    flexDirection: "row",
-    alignItems: "center",
-    padding: 12,
-    borderRadius: 12,
-    marginBottom: 8,
-  },
-  iconContainer: {
-    width: 40,
-    height: 40,
-    borderRadius: 20,
-    justifyContent: "center",
-    alignItems: "center",
-    marginRight: 12,
-  },
-  content: {
-    flex: 1,
-    gap: 2,
-  },
-  reason: {
-    fontWeight: "600",
-  },
-  change: {
-    fontWeight: "700",
-    marginLeft: 12,
-  },
-});

package/src/domains/wallet/presentation/components/TransactionItem.types.ts

@@ -0,0 +1,18 @@
+import type { CreditLog } from "../../domain/types/transaction.types";
+
+export interface TransactionItemTranslations {
+  purchase: string;
+  usage: string;
+  refund: string;
+  bonus: string;
+  subscription: string;
+  admin: string;
+  reward: string;
+  expired: string;
+}
+
+export interface TransactionItemProps {
+  transaction: CreditLog;
+  translations: TransactionItemTranslations;
+  dateFormatter?: (timestamp: number) => string;
+}

package/src/domains/wallet/presentation/components/TransactionList.constants.ts

@@ -0,0 +1 @@
+export const DEFAULT_TRANSACTION_LIST_MAX_HEIGHT = 400;

package/src/domains/wallet/presentation/components/TransactionList.styles.ts

@@ -0,0 +1,34 @@
+import { StyleSheet } from "react-native";
+
+export const transactionListStyles = StyleSheet.create({
+  container: {
+    marginTop: 24,
+    marginBottom: 24,
+  },
+  header: {
+    flexDirection: "row",
+    justifyContent: "space-between",
+    alignItems: "center",
+    marginHorizontal: 16,
+    marginBottom: 16,
+  },
+  title: {
+    fontSize: 20,
+    fontWeight: "700",
+  },
+  scrollView: {
+    paddingHorizontal: 16,
+  },
+  scrollContent: {
+    paddingBottom: 8,
+  },
+  stateContainer: {
+    padding: 40,
+    alignItems: "center",
+    gap: 12,
+  },
+  stateText: {
+    fontSize: 14,
+    fontWeight: "500",
+  },
+});

package/src/domains/wallet/presentation/components/TransactionList.tsx

@@ -1,23 +1,11 @@
-/**
- * Transaction List Component
- *
- * Displays a list of credit transactions.
- * Props-driven for full customization.
- */
-
 import React from "react";
-import { View, StyleSheet, ScrollView } from "react-native";
-import {
-    useAppDesignTokens,
-    AtomicText,
-    AtomicIcon,
-    AtomicSpinner,
-} from "@umituz/react-native-design-system";
+import { View, ScrollView } from "react-native";
+import { useAppDesignTokens, AtomicText, AtomicIcon } from "@umituz/react-native-design-system";
 import type { CreditLog } from "../../domain/types/transaction.types";
-import {
-    TransactionItem,
-    type TransactionItemTranslations,
-} from "./TransactionItem";
+import { TransactionItem, type TransactionItemTranslations } from "./TransactionItem";
+import { transactionListStyles } from "./TransactionList.styles";
+import { LoadingState, EmptyState } from "./TransactionListStates";
+import { DEFAULT_TRANSACTION_LIST_MAX_HEIGHT } from "./TransactionList.constants";
 
 export interface TransactionListTranslations extends TransactionItemTranslations {
   title: string;
@@ -37,89 +25,35 @@ export const TransactionList: React.FC<TransactionListProps> = ({
   transactions,
   loading,
   translations,
-  maxHeight = 400,
+  maxHeight = DEFAULT_TRANSACTION_LIST_MAX_HEIGHT,
   dateFormatter,
 }) => {
   const tokens = useAppDesignTokens();
 
   return (
-    <View style={styles.container}>
-      <View style={styles.header}>
-        <AtomicText
-          type="titleLarge"
-          style={[styles.title, { color: tokens.colors.textPrimary }]}
-        >
+    <View style={transactionListStyles.container}>
+      <View style={transactionListStyles.header}>
+        <AtomicText type="titleLarge" style={[transactionListStyles.title, { color: tokens.colors.textPrimary }]}>
           {translations.title}
         </AtomicText>
         <AtomicIcon name="time-outline" size="md" color="secondary" />
       </View>
 
       {loading ? (
-        <AtomicSpinner
-          size="lg"
-          color="primary"
-          text={translations.loading}
-          style={styles.stateContainer}
-        />
+        <LoadingState message={translations.loading} />
       ) : transactions.length === 0 ? (
-        <View style={styles.stateContainer}>
-          <AtomicIcon name="file-tray-outline" size="xl" color="secondary" />
-          <AtomicText
-            type="bodyMedium"
-            style={[styles.stateText, { color: tokens.colors.textSecondary }]}
-          >
-            {translations.empty}
-          </AtomicText>
-        </View>
+        <EmptyState message={translations.empty} />
       ) : (
         <ScrollView
-          style={[styles.scrollView, { maxHeight }]}
-          contentContainerStyle={styles.scrollContent}
+          style={[transactionListStyles.scrollView, { maxHeight }]}
+          contentContainerStyle={transactionListStyles.scrollContent}
           showsVerticalScrollIndicator={false}
         >
           {transactions.map((transaction) => (
-            <TransactionItem
-              key={transaction.id}
-              transaction={transaction}
-              translations={translations}
-              dateFormatter={dateFormatter}
-            />
+            <TransactionItem key={transaction.id} transaction={transaction} translations={translations} dateFormatter={dateFormatter} />
           ))}
         </ScrollView>
       )}
     </View>
   );
 };
-
-const styles = StyleSheet.create({
-  container: {
-    marginTop: 24,
-    marginBottom: 24,
-  },
-  header: {
-    flexDirection: "row",
-    justifyContent: "space-between",
-    alignItems: "center",
-    marginHorizontal: 16,
-    marginBottom: 16,
-  },
-  title: {
-    fontSize: 20,
-    fontWeight: "700",
-  },
-  scrollView: {
-    paddingHorizontal: 16,
-  },
-  scrollContent: {
-    paddingBottom: 8,
-  },
-  stateContainer: {
-    padding: 40,
-    alignItems: "center",
-    gap: 12,
-  },
-  stateText: {
-    fontSize: 14,
-    fontWeight: "500",
-  },
-});

package/src/domains/wallet/presentation/components/TransactionListStates.tsx

@@ -0,0 +1,28 @@
+import React from "react";
+import { View } from "react-native";
+import { useAppDesignTokens, AtomicText, AtomicIcon, AtomicSpinner } from "@umituz/react-native-design-system";
+import { transactionListStyles } from "./TransactionList.styles";
+
+interface LoadingStateProps {
+  message: string;
+}
+
+export const LoadingState: React.FC<LoadingStateProps> = ({ message }) => (
+  <AtomicSpinner size="lg" color="primary" text={message} style={transactionListStyles.stateContainer} />
+);
+
+interface EmptyStateProps {
+  message: string;
+}
+
+export const EmptyState: React.FC<EmptyStateProps> = ({ message }) => {
+  const tokens = useAppDesignTokens();
+  return (
+    <View style={transactionListStyles.stateContainer}>
+      <AtomicIcon name="file-tray-outline" size="xl" color="secondary" />
+      <AtomicText type="bodyMedium" style={[transactionListStyles.stateText, { color: tokens.colors.textSecondary }]}>
+        {message}
+      </AtomicText>
+    </View>
+  );
+};

package/src/domains/wallet/presentation/components/transactionItemHelpers.ts

@@ -0,0 +1,14 @@
+import { timezoneService } from "@umituz/react-native-design-system";
+import type { TransactionItemTranslations } from "./TransactionItem.types";
+
+export const defaultDateFormatter = (timestamp: number): string => {
+  return timezoneService.formatToDisplayDateTime(new Date(timestamp));
+};
+
+export const getReasonLabel = (reason: string, translations: TransactionItemTranslations): string => {
+  return translations[reason as keyof TransactionItemTranslations] || reason;
+};
+
+export const getChangePrefix = (change: number): string => {
+  return change > 0 ? "+" : "";
+};