@umituz/react-native-subscription 2.27.92 → 2.27.94

package/src/domains/credits/infrastructure/CreditsRepository.ts

@@ -3,7 +3,7 @@
  * Optimized to use Design Patterns: Command, Observer, and Strategy.
  */
 
-import { doc, getDoc, serverTimestamp, updateDoc, type Firestore } from "firebase/firestore";
+import { doc, getDoc, type Firestore } from "firebase/firestore";
 import { BaseRepository, getFirestore } from "@umituz/react-native-firebase";
 import type { CreditsConfig, CreditsResult, DeductCreditsResult } from "../core/Credits";
 import type { UserCreditsDocumentRead, PurchaseSource } from "../core/UserCreditsDocument";
@@ -16,8 +16,8 @@ import { CreditLimitCalculator } from "../application/CreditLimitCalculator";
 export class CreditsRepository extends BaseRepository {
   private deductCommand: DeductCreditsCommand;
 
-  constructor(private config: CreditsConfig) { 
-    super(); 
+  constructor(private config: CreditsConfig) {
+    super();
     this.deductCommand = new DeductCreditsCommand((db, uid) => this.getRef(db, uid));
   }
 
@@ -29,74 +29,61 @@ export class CreditsRepository extends BaseRepository {
 
   async getCredits(userId: string): Promise<CreditsResult> {
     const db = getFirestore();
-    if (!db) return { success: false, error: { message: "No DB", code: "DB_ERR" } };
-    try {
-      const snap = await getDoc(this.getRef(db, userId));
-      if (!snap.exists()) return { success: true, data: undefined };
-      
-      const entity = CreditsMapper.toEntity(snap.data() as UserCreditsDocumentRead);
-      return { success: true, data: entity };
-    } catch (e: unknown) {
-      const message = e instanceof Error ? e.message : String(e);
-      return { success: false, error: { message, code: "FETCH_ERR" } };
+    if (!db) {
+      throw new Error("Firestore instance is not available");
     }
+
+    const snap = await getDoc(this.getRef(db, userId));
+    if (!snap.exists()) {
+      return { success: true, data: null, error: null };
+    }
+
+    const entity = CreditsMapper.toEntity(snap.data() as UserCreditsDocumentRead);
+    return { success: true, data: entity, error: null };
   }
 
   async initializeCredits(
-    userId: string, purchaseId?: string, productId?: string,
-    source?: PurchaseSource, revenueCatData?: RevenueCatData
+    userId: string,
+    purchaseId: string,
+    productId: string,
+    source: PurchaseSource,
+    revenueCatData: RevenueCatData
   ): Promise<CreditsResult> {
     const db = getFirestore();
-    if (!db) return { success: false, error: { message: "No DB", code: "INIT_ERR" } };
-    try {
-      // Use CreditLimitCalculator (Refactoring Logic)
-      const creditLimit = CreditLimitCalculator.calculate(productId, this.config);
-      const cfg = { ...this.config, creditLimit };
-
-      const result = await initializeCreditsTransaction(db, this.getRef(db, userId), cfg, purchaseId, {
-        productId, source,
-        expirationDate: revenueCatData?.expirationDate,
-        willRenew: revenueCatData?.willRenew,
-        originalTransactionId: revenueCatData?.originalTransactionId,
-        isPremium: revenueCatData?.isPremium,
-        periodType: revenueCatData?.periodType,
-      });
-      
-      return {
-        success: true,
-        data: result.finalData ? CreditsMapper.toEntity(result.finalData) : undefined,
-      };
-    } catch (e: unknown) {
-      const message = e instanceof Error ? e.message : String(e);
-      return { success: false, error: { message, code: "INIT_ERR" } };
+    if (!db) {
+      throw new Error("Firestore instance is not available");
     }
+
+    const creditLimit = CreditLimitCalculator.calculate(productId, this.config);
+    const cfg = { ...this.config, creditLimit };
+
+    const result = await initializeCreditsTransaction(
+      db,
+      this.getRef(db, userId),
+      cfg,
+      purchaseId,
+      {
+        productId,
+        source,
+        expirationDate: revenueCatData.expirationDate,
+        willRenew: revenueCatData.willRenew,
+        originalTransactionId: revenueCatData.originalTransactionId,
+        isPremium: revenueCatData.isPremium,
+        periodType: revenueCatData.periodType,
+      }
+    );
+
+    return {
+      success: true,
+      data: result.finalData ? CreditsMapper.toEntity(result.finalData) : null,
+      error: null,
+    };
   }
 
   /**
    * Delegates to DeductCreditsCommand (Command Pattern)
    */
-  async deductCredit(userId: string, cost: number = 1): Promise<DeductCreditsResult> {
+  async deductCredit(userId: string, cost: number): Promise<DeductCreditsResult> {
     return this.deductCommand.execute(userId, cost);
   }
-
-  async hasCredits(userId: string, cost: number = 1): Promise<boolean> {
-    const res = await this.getCredits(userId);
-    return !!(res.success && res.data && res.data.credits >= cost);
-  }
-
-  async syncExpiredStatus(userId: string): Promise<void> {
-    const db = getFirestore();
-    if (!db) return;
-    try {
-      await updateDoc(this.getRef(db, userId), { 
-        isPremium: false, 
-        status: "expired", 
-        lastUpdatedAt: serverTimestamp() 
-      });
-    } catch (e) {
-      if (__DEV__) console.error("[CreditsRepository] Sync expired failed:", e);
-    }
-  }
 }
-
-export const createCreditsRepository = (c: CreditsConfig) => new CreditsRepository(c);

package/src/domains/paywall/components/PaywallModal.tsx

@@ -12,7 +12,7 @@ import type { SubscriptionFeature, PaywallTranslations, PaywallLegalUrls } from
 import { paywallModalStyles as styles } from "./PaywallModal.styles";
 import { PaywallFeatures } from "./PaywallFeatures";
 import { PaywallFooter } from "./PaywallFooter";
-import { usePurchaseLoadingStore, selectIsPurchasing } from "../../../presentation/stores";
+import { usePurchaseLoadingStore, selectIsPurchasing } from "../../subscription/presentation/stores";
 
 /** Trial eligibility info per product */
 export interface TrialEligibilityInfo {

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

@@ -18,16 +18,47 @@ export type { FirebaseAuthLike, CreditPackageConfig, SubscriptionInitConfig } fr
 
 export const initializeSubscription = async (config: SubscriptionInitConfig): Promise<void> => {
   const {
-    apiKey, apiKeyIos, apiKeyAndroid, entitlementId, credits,
-    getAnonymousUserId, getFirebaseAuth, showAuthModal,
-    onCreditsUpdated, creditPackages,
+    apiKey,
+    apiKeyIos,
+    apiKeyAndroid,
+    entitlementId,
+    credits,
+    getAnonymousUserId,
+    getFirebaseAuth,
+    showAuthModal,
+    onCreditsUpdated,
+    creditPackages,
   } = config;
 
-  const key = Platform.OS === 'ios' ? (apiKeyIos || apiKey || '') : (apiKeyAndroid || apiKey || '');
-  if (!key) throw new Error('API key required');
+  const key = Platform.OS === 'ios'
+    ? (apiKeyIos || apiKey)
+    : (apiKeyAndroid || apiKey);
+
+  if (!key) {
+    throw new Error('API key required');
+  }
+
+  if (!creditPackages) {
+    throw new Error('creditPackages is required');
+  }
+
+  if (!creditPackages.identifierPattern) {
+    throw new Error('creditPackages.identifierPattern is required');
+  }
+
+  if (!creditPackages.amounts) {
+    throw new Error('creditPackages.amounts is required');
+  }
+
+  if (!getAnonymousUserId) {
+    throw new Error('getAnonymousUserId is required');
+  }
 
   // 1. Configure Repository
-  configureCreditsRepository({ ...credits, creditPackageAmounts: creditPackages?.amounts });
+  configureCreditsRepository({
+    ...credits,
+    creditPackageAmounts: creditPackages.amounts
+  });
 
   // 2. Setup Sync Service
   const syncService = new SubscriptionSyncService(entitlementId);
@@ -37,7 +68,7 @@ export const initializeSubscription = async (config: SubscriptionInitConfig): Pr
     config: {
       apiKey: key,
       entitlementIdentifier: entitlementId,
-      consumableProductIdentifiers: [creditPackages?.identifierPattern || 'credit'],
+      consumableProductIdentifiers: [creditPackages.identifierPattern],
       onPurchaseCompleted: (u: string, p: string, c: any, s: any) => syncService.handlePurchase(u, p, c, s),
       onRenewalDetected: (u: string, p: string, expires: string, c: any) => syncService.handleRenewal(u, p, expires, c),
       onPremiumStatusChanged: (u: string, isP: boolean, pId: any, exp: any, willR: any, pt: any) => syncService.handlePremiumStatusChanged(u, isP, pId, exp, willR, pt),
@@ -50,28 +81,38 @@ export const initializeSubscription = async (config: SubscriptionInitConfig): Pr
   // 4. Configure Auth aware actions
   configureAuthProvider({
     isAuthenticated: () => {
-      const u = getFirebaseAuth()?.currentUser;
+      const auth = getFirebaseAuth();
+      if (!auth) {
+        throw new Error("Firebase auth is not available");
+      }
+
+      const u = auth.currentUser;
       return !!(u && !u.isAnonymous);
     },
     showAuthModal,
   });
 
-  const initializeInBackground = async (userId?: string) => {
-    try {
-      await SubscriptionManager.initialize(userId);
-      if (__DEV__) console.log('[SubscriptionInitializer] Background init complete');
-    } catch (error) {
-      if (__DEV__) console.log('[SubscriptionInitializer] Background init failed (non-critical):', error);
+  const initializeInBackground = async (userId: string): Promise<void> => {
+    await SubscriptionManager.initialize(userId);
+    if (__DEV__) {
+      console.log('[SubscriptionInitializer] Background init complete');
     }
   };
 
   // 5. Start Background Init
-  const initialUserId = getCurrentUserId(getFirebaseAuth);
-  initializeInBackground(initialUserId);
+  const auth = getFirebaseAuth();
+  if (!auth) {
+    throw new Error("Firebase auth is not available");
+  }
+
+  const initialUserId = getCurrentUserId(() => auth);
+  await initializeInBackground(initialUserId);
 
   // 6. Listen for Auth Changes
-  setupAuthStateListener(getFirebaseAuth, (newUserId) => {
-    if (__DEV__) console.log('[SubscriptionInitializer] Auth changed, re-init:', newUserId);
+  setupAuthStateListener(() => auth, (newUserId) => {
+    if (__DEV__) {
+      console.log('[SubscriptionInitializer] Auth changed, re-init:', newUserId);
+    }
     initializeInBackground(newUserId);
   });
 };

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

@@ -13,38 +13,38 @@ export interface FirebaseAuthLike {
 }
 
 export interface CreditPackageConfig {
-  identifierPattern?: string;
-  amounts?: Record<string, number>;
+  identifierPattern: string;
+  amounts: Record<string, number>;
 }
 
 export interface SubscriptionInitConfig {
-  apiKey?: string;
-  apiKeyIos?: string;
-  apiKeyAndroid?: string;
+  apiKey: string;
+  apiKeyIos: string;
+  apiKeyAndroid: string;
   entitlementId: string;
   credits: CreditsConfig;
   getAnonymousUserId: () => Promise<string>;
   getFirebaseAuth: () => FirebaseAuthLike | null;
   showAuthModal: () => void;
-  onCreditsUpdated?: (userId: string) => void;
-  creditPackages?: CreditPackageConfig;
-  timeoutMs?: number;
-  authStateTimeoutMs?: number;
+  onCreditsUpdated: (userId: string) => void;
+  creditPackages: CreditPackageConfig;
+  timeoutMs: number;
+  authStateTimeoutMs: number;
 }
 
 export interface InitializeCreditsMetadata {
-  productId?: string;
-  source?: PurchaseSource;
-  type?: PurchaseType;
-  expirationDate?: string | null;
-  willRenew?: boolean;
-  originalTransactionId?: string;
-  isPremium?: boolean;
-  periodType?: PeriodType;
+  productId: string;
+  source: PurchaseSource;
+  type: PurchaseType;
+  expirationDate: string | null;
+  willRenew: boolean | null;
+  originalTransactionId: string | null;
+  isPremium: boolean;
+  periodType: PeriodType | null;
 }
 
 export interface InitializationResult {
-    credits: number;
-    alreadyProcessed?: boolean;
-    finalData?: UserCreditsDocumentRead;
+  credits: number;
+  alreadyProcessed: boolean;
+  finalData: UserCreditsDocumentRead | null;
 }

package/src/domains/subscription/infrastructure/handlers/PackageHandler.ts

@@ -15,48 +15,67 @@ export interface RestoreResultInfo {
 
 export class PackageHandler {
   constructor(
-    private service: IRevenueCatService | null,
+    private service: IRevenueCatService,
     private entitlementId: string
   ) { }
 
-  setService = (service: IRevenueCatService | null) => { this.service = service; };
+  setService(service: IRevenueCatService): void {
+    this.service = service;
+  }
 
   async fetchPackages(): Promise<PurchasesPackage[]> {
-    if (!this.service?.isInitialized()) return [];
-    try {
-      const offering = await this.service.fetchOfferings();
-      return offering?.availablePackages ?? [];
-    } catch (error) {
-      if (__DEV__) console.error('[PackageHandler] fetchOfferings failed:', error);
-      return [];
+    if (!this.service.isInitialized()) {
+      throw new Error("Service not initialized");
     }
+
+    const offering = await this.service.fetchOfferings();
+
+    if (!offering) {
+      throw new Error("No offerings available");
+    }
+
+    const packages = offering.availablePackages;
+    if (!packages) {
+      throw new Error("No packages available in offering");
+    }
+
+    return packages;
   }
 
   async purchase(pkg: PurchasesPackage, userId: string): Promise<boolean> {
-    if (!this.service?.isInitialized()) return false;
-    try {
-      const result = await this.service.purchasePackage(pkg, userId);
-      return result.success;
-    } catch (error) {
-      if (__DEV__) console.error('[PackageHandler] Purchase failed:', error);
-      return false;
+    if (!this.service.isInitialized()) {
+      throw new Error("Service not initialized");
     }
+
+    const result = await this.service.purchasePackage(pkg, userId);
+    return result.success;
   }
 
   async restore(userId: string): Promise<RestoreResultInfo> {
-    if (!this.service?.isInitialized()) return { success: false, productId: null };
-    try {
-      const result = await this.service.restorePurchases(userId);
-      let productId: string | null = null;
-      if (result.success && result.customerInfo) {
-        const entitlement = getPremiumEntitlement(result.customerInfo, this.entitlementId);
-        if (entitlement) productId = entitlement.productIdentifier;
-      }
-      return { success: result.success, productId };
-    } catch (error) {
-      if (__DEV__) console.error('[PackageHandler] Restore failed:', error);
+    if (!this.service.isInitialized()) {
+      throw new Error("Service not initialized");
+    }
+
+    const result = await this.service.restorePurchases(userId);
+
+    if (!result.success) {
       return { success: false, productId: null };
     }
+
+    if (!result.customerInfo) {
+      return { success: true, productId: null };
+    }
+
+    const entitlement = getPremiumEntitlement(result.customerInfo, this.entitlementId);
+
+    if (!entitlement) {
+      return { success: true, productId: null };
+    }
+
+    return {
+      success: true,
+      productId: entitlement.productIdentifier,
+    };
   }
 
   checkPremiumStatusFromInfo(customerInfo: CustomerInfo): PremiumStatus {

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

@@ -14,7 +14,7 @@ import { SubscriptionInternalState } from "./SubscriptionInternalState";
 export interface SubscriptionManagerConfig {
   config: RevenueCatConfig;
   apiKey: string;
-  getAnonymousUserId?: () => Promise<string>;
+  getAnonymousUserId: () => Promise<string>;
 }
 
 class SubscriptionManagerImpl {
@@ -25,97 +25,161 @@ class SubscriptionManagerImpl {
 
   configure(config: SubscriptionManagerConfig): void {
     this.managerConfig = config;
-    this.packageHandler = new PackageHandler(null, config.config.entitlementIdentifier);
-    if (config.getAnonymousUserId) this.state.userIdProvider.configure(config.getAnonymousUserId);
+    this.state.userIdProvider.configure(config.getAnonymousUserId);
+  }
+
+  private ensurePackageHandlerInitialized(): void {
+    if (this.packageHandler) {
+      return;
+    }
+
+    if (!this.serviceInstance) {
+      throw new Error("Service instance not available");
+    }
+
+    if (!this.managerConfig) {
+      throw new Error("Manager not configured");
+    }
+
+    this.packageHandler = new PackageHandler(
+      this.serviceInstance,
+      this.managerConfig.config.entitlementIdentifier
+    );
   }
 
   private ensureConfigured(): void {
-    if (!this.managerConfig || !this.packageHandler) throw new Error("SubscriptionManager not configured");
+    if (!this.managerConfig) {
+      throw new Error("SubscriptionManager not configured");
+    }
   }
 
-  async initialize(userId?: string): Promise<boolean> {
+  async initialize(userId: string): Promise<boolean> {
     this.ensureConfigured();
-    const effectiveUserId = userId || (await this.state.userIdProvider.getOrCreateAnonymousUserId());
-    const { shouldInit, existingPromise } = this.state.initCache.tryAcquireInitialization(effectiveUserId);
 
-    if (!shouldInit && existingPromise) return existingPromise;
+    const { shouldInit, existingPromise } = this.state.initCache.tryAcquireInitialization(userId);
+
+    if (!shouldInit && existingPromise) {
+      return existingPromise;
+    }
 
     const promise = (async () => {
-        try {
-          await initializeRevenueCatService(this.managerConfig!.config);
-          this.serviceInstance = getRevenueCatService();
-          if (!this.serviceInstance) {
-            if (__DEV__) {
-              console.error('[SubscriptionManager] Service instance not available after initialization');
-            }
-            return false;
-          }
-          this.packageHandler!.setService(this.serviceInstance);
-          const result = await this.serviceInstance.initialize(effectiveUserId);
-          return result.success;
-        } catch (error) {
-          if (__DEV__) {
-            console.error('[SubscriptionManager] Initialization failed:', error);
-          }
-          return false;
+        await initializeRevenueCatService(this.managerConfig!.config);
+        this.serviceInstance = getRevenueCatService();
+
+        if (!this.serviceInstance) {
+          throw new Error("Service instance not available after initialization");
         }
+
+        this.ensurePackageHandlerInitialized();
+        const result = await this.serviceInstance.initialize(userId);
+        return result.success;
     })();
 
-    this.state.initCache.setPromise(promise, effectiveUserId);
+    this.state.initCache.setPromise(promise, userId);
     return promise;
   }
 
   isInitializedForUser(userId: string): boolean {
-    return this.serviceInstance?.isInitialized() === true && this.state.initCache.getCurrentUserId() === userId;
+    if (!this.serviceInstance) {
+      return false;
+    }
+
+    if (!this.serviceInstance.isInitialized()) {
+      return false;
+    }
+
+    return this.state.initCache.getCurrentUserId() === userId;
   }
 
   async getPackages(): Promise<PurchasesPackage[]> {
     this.ensureConfigured();
+
     if (!this.serviceInstance) {
       this.serviceInstance = getRevenueCatService();
-      this.packageHandler!.setService(this.serviceInstance);
     }
+
+    if (!this.serviceInstance) {
+      throw new Error("Service instance not available");
+    }
+
+    this.ensurePackageHandlerInitialized();
     return this.packageHandler!.fetchPackages();
   }
 
   async purchasePackage(pkg: PurchasesPackage): Promise<boolean> {
     this.ensureConfigured();
+
     const userId = this.state.initCache.getCurrentUserId();
-    if (!userId) return false;
+    if (!userId) {
+      throw new Error("No current user found");
+    }
+
+    this.ensurePackageHandlerInitialized();
     return this.packageHandler!.purchase(pkg, userId);
   }
 
   async restore(): Promise<RestoreResultInfo> {
     this.ensureConfigured();
+
     const userId = this.state.initCache.getCurrentUserId();
-    if (!userId) return { success: false, productId: null };
+    if (!userId) {
+      throw new Error("No current user found");
+    }
+
+    this.ensurePackageHandlerInitialized();
     return this.packageHandler!.restore(userId);
   }
 
   async checkPremiumStatus(): Promise<PremiumStatus> {
     this.ensureConfigured();
+
     const userId = this.state.initCache.getCurrentUserId();
-    if (!userId) return { isPremium: false, expirationDate: null };
+    if (!userId) {
+      throw new Error("No current user found");
+    }
+
+    if (!this.serviceInstance) {
+      throw new Error("Service instance not available");
+    }
+
+    const customerInfo = await this.serviceInstance.getCustomerInfo();
 
-    try {
-      const customerInfo = await this.serviceInstance?.getCustomerInfo();
-      if (customerInfo) return this.packageHandler!.checkPremiumStatusFromInfo(customerInfo);
-    } catch (error) {
-      throw error;
+    if (!customerInfo) {
+      throw new Error("Customer info not available");
     }
-    return { isPremium: false, expirationDate: null };
+
+    this.ensurePackageHandlerInitialized();
+    return this.packageHandler!.checkPremiumStatusFromInfo(customerInfo);
   }
 
   async reset(): Promise<void> {
-    if (this.serviceInstance) await this.serviceInstance.reset();
+    if (this.serviceInstance) {
+      await this.serviceInstance.reset();
+    }
+
     this.state.reset();
     this.serviceInstance = null;
   }
 
-  // Helper status checks
-  isConfigured = () => !!this.managerConfig;
-  isInitialized = () => this.serviceInstance?.isInitialized() ?? false;
-  getEntitlementId = () => this.managerConfig?.config.entitlementIdentifier || null;
+  isConfigured(): boolean {
+    return this.managerConfig !== null;
+  }
+
+  isInitialized(): boolean {
+    if (!this.serviceInstance) {
+      return false;
+    }
+
+    return this.serviceInstance.isInitialized();
+  }
+
+  getEntitlementId(): string {
+    if (!this.managerConfig) {
+      throw new Error("SubscriptionManager not configured");
+    }
+
+    return this.managerConfig.config.entitlementIdentifier;
+  }
 }
 
 export const SubscriptionManager = new SubscriptionManagerImpl();

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

@@ -15,14 +15,16 @@ export async function handleRestore(deps: RestoreHandlerDeps, userId: string): P
 
   try {
     const customerInfo = await Purchases.restorePurchases();
-    const isPremium = !!customerInfo.entitlements.active[deps.config.entitlementIdentifier];
+    const entitlement = customerInfo.entitlements.active[deps.config.entitlementIdentifier];
+    const isPremium = !!entitlement;
+    const productId = entitlement?.productIdentifier ?? null;
 
     if (isPremium) {
       await syncPremiumStatus(deps.config, userId, customerInfo);
     }
     await notifyRestoreCompleted(deps.config, userId, isPremium, customerInfo);
 
-    return { success: true, isPremium, customerInfo };
+    return { success: true, isPremium, productId, customerInfo };
   } catch (error) {
     throw new RevenueCatRestoreError(getErrorMessage(error, "Restore failed"));
   }

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

@@ -19,8 +19,7 @@ const configurationState = {
     configurationPromise: null as Promise<ReturnType<typeof initializeSDK>> | null,
 };
 
-// Simple lock mechanism to prevent concurrent configurations
-let configurationLocks = new Set<string>();
+// Simple lock mechanism to prevent concurrent configurations (implementation deferred)
 
 function configureLogHandler(): void {
   if (configurationState.isLogHandlerConfigured) return;

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

@@ -5,7 +5,7 @@
  */
 
 import type { CustomerInfo } from "react-native-purchases";
-import { detectPackageType, type SubscriptionPackageType } from "../../../../utils/packageTypeDetector";
+import { detectPackageType } from "../../../../utils/packageTypeDetector";
 
 export interface RenewalState {
   previousExpirationDate: string | null;