@umituz/react-native-subscription 2.27.92 → 2.27.93

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.92",
+  "version": "2.27.93",
   "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/credits/application/CreditsInitializer.ts

@@ -1,13 +1,14 @@
 import { Platform } from "react-native";
 import Constants from "expo-constants";
+import {
+  getFirestore,
+} from "@umituz/react-native-firebase";
 import {
   runTransaction,
   serverTimestamp,
-  Timestamp,
   type Transaction,
   type DocumentReference,
-  type Firestore,
-} from "@umituz/react-native-firebase";
+} from "firebase/firestore";
 import type { CreditsConfig } from "../core/Credits";
 import type { UserCreditsDocumentRead } from "../core/UserCreditsDocument";
 import { resolveSubscriptionStatus } from "../../subscription/core/SubscriptionStatus";
@@ -17,41 +18,70 @@ import { creditAllocationContext } from "./credit-strategies/CreditAllocationCon
 import type { InitializeCreditsMetadata, InitializationResult } from "../../subscription/application/SubscriptionInitializerTypes";
 
 export async function initializeCreditsTransaction(
-    db: Firestore,
+    db: ReturnType<typeof getFirestore>,
     creditsRef: DocumentReference,
     config: CreditsConfig,
-    purchaseId?: string,
-    metadata?: InitializeCreditsMetadata
+    purchaseId: string,
+    metadata: InitializeCreditsMetadata
 ): Promise<InitializationResult> {
+    if (!db) {
+        throw new Error("Firestore instance is not available");
+    }
+
+    if (!metadata.productId) {
+        throw new Error("productId is required in metadata");
+    }
+
     return runTransaction(db, async (transaction: Transaction) => {
         const creditsDoc = await transaction.get(creditsRef);
         const now = serverTimestamp();
-        const existingData = creditsDoc.exists() ? creditsDoc.data() as UserCreditsDocumentRead : null;
+        const existingData = creditsDoc.exists()
+            ? creditsDoc.data() as UserCreditsDocumentRead
+            : null;
+
+        if (!existingData) {
+            throw new Error("Credits document does not exist");
+        }
 
-        if (existingData && purchaseId && existingData.processedPurchases?.includes(purchaseId)) {
+        if (existingData.processedPurchases.includes(purchaseId)) {
             return { credits: existingData.credits, alreadyProcessed: true };
         }
 
-        const creditLimit = CreditLimitCalculator.calculate(metadata?.productId, config);
+        const creditLimit = CreditLimitCalculator.calculate(metadata.productId, config);
+
+        const platform = Platform.OS;
+        if (platform !== "ios" && platform !== "android") {
+            throw new Error(`Invalid platform: ${platform}`);
+        }
+
+        const appVersion = Constants.expoConfig?.version;
+        if (!appVersion) {
+            throw new Error("appVersion is required in expoConfig");
+        }
+
         const { purchaseHistory } = PurchaseMetadataGenerator.generate({
-          productId: metadata?.productId,
-          source: metadata?.source,
-          type: metadata?.type,
-          creditLimit,
-          platform: Platform.OS as "ios" | "android",
-          appVersion: Constants.expoConfig?.version,
+            productId: metadata.productId,
+            source: metadata.source,
+            type: metadata.type,
+            creditLimit,
+            platform,
+            appVersion,
         }, existingData);
 
-        const isPremium = metadata?.isPremium ?? true;
-        const isExpired = metadata?.expirationDate ? new Date(metadata.expirationDate).getTime() < Date.now() : false;
-        const status = resolveSubscriptionStatus({ 
-          isPremium, willRenew: metadata?.willRenew, isExpired, periodType: metadata?.periodType 
+        const isPremium = metadata.isPremium;
+        const isExpired = metadata.expirationDate
+            ? new Date(metadata.expirationDate).getTime() < Date.now()
+            : false;
+
+        const status = resolveSubscriptionStatus({
+            isPremium,
+            willRenew: metadata.willRenew,
+            isExpired,
+            periodType: metadata.periodType,
         });
 
-        // Resolve credits using Strategy Pattern
-        const isStatusSync = purchaseId?.startsWith("status_sync_") ?? false;
+        const isStatusSync = purchaseId.startsWith("status_sync_");
         const isSubscriptionActive = isPremium && !isExpired;
-        const productId = metadata?.productId;
 
         const newCredits = creditAllocationContext.allocate({
             status,
@@ -59,30 +89,53 @@ export async function initializeCreditsTransaction(
             existingData,
             creditLimit,
             isSubscriptionActive,
-            productId,
+            productId: metadata.productId,
         });
 
+        const newProcessedPurchases = [...existingData.processedPurchases, purchaseId].slice(-50);
+
         const creditsData: Record<string, any> = {
-            isPremium, status, credits: newCredits, creditLimit, 
-            lastUpdatedAt: now, 
-            // Increase history window to 50 for better idempotency
-            processedPurchases: (purchaseId ? [...(existingData?.processedPurchases || []), purchaseId].slice(-50) : existingData?.processedPurchases) || [],
-            purchaseHistory: purchaseHistory.length ? purchaseHistory : undefined
+            isPremium,
+            status,
+            credits: newCredits,
+            creditLimit,
+            lastUpdatedAt: now,
+            processedPurchases: newProcessedPurchases,
         };
 
-        const isNewPurchaseOrRenewal = purchaseId?.startsWith("purchase_") || purchaseId?.startsWith("renewal_");
-        if (isNewPurchaseOrRenewal) creditsData.lastPurchaseAt = now;
-        if (metadata?.expirationDate) creditsData.expirationDate = Timestamp.fromDate(new Date(metadata.expirationDate));
-        if (metadata?.willRenew !== undefined) creditsData.willRenew = metadata.willRenew;
-        if (metadata?.originalTransactionId) creditsData.originalTransactionId = metadata.originalTransactionId;
-        if (metadata?.productId) {
-            creditsData.productId = metadata.productId;
-            creditsData.platform = Platform.OS;
+        if (purchaseHistory.length > 0) {
+            creditsData.purchaseHistory = purchaseHistory;
+        }
+
+        const isNewPurchaseOrRenewal = purchaseId.startsWith("purchase_")
+            || purchaseId.startsWith("renewal_");
+
+        if (isNewPurchaseOrRenewal) {
+            creditsData.lastPurchaseAt = now;
+        }
+
+        if (metadata.expirationDate) {
+            creditsData.expirationDate = serverTimestamp();
         }
 
+        if (metadata.willRenew !== undefined) {
+            creditsData.willRenew = metadata.willRenew;
+        }
+
+        if (metadata.originalTransactionId) {
+            creditsData.originalTransactionId = metadata.originalTransactionId;
+        }
+
+        creditsData.productId = metadata.productId;
+        creditsData.platform = platform;
+
         transaction.set(creditsRef, creditsData, { merge: true });
-        
-        const finalData = { ...(existingData || {}), ...creditsData } as UserCreditsDocumentRead;
+
+        const finalData: UserCreditsDocumentRead = {
+            ...existingData,
+            ...creditsData,
+        };
+
         return { credits: newCredits, finalData };
     });
 }

package/src/domains/credits/core/UserCreditsDocument.ts

@@ -1,17 +1,17 @@
-import type { 
-  PurchaseSource, 
-  PurchaseType, 
-  SubscriptionStatusType, 
+import type {
+  PurchaseSource,
+  PurchaseType,
+  SubscriptionStatusType,
   PeriodType,
   PackageType,
   Platform
 } from "../../subscription/core/SubscriptionConstants";
 
-export type { 
-  PurchaseSource, 
-  PurchaseType, 
-  SubscriptionStatusType, 
-  PeriodType 
+export type {
+  PurchaseSource,
+  PurchaseType,
+  SubscriptionStatusType,
+  PeriodType
 };
 
 export interface FirestoreTimestamp {
@@ -25,45 +25,45 @@ export interface PurchaseMetadata {
   source: PurchaseSource;
   type: PurchaseType;
   platform: Platform;
-  appVersion?: string;
+  appVersion: string;
   timestamp: FirestoreTimestamp;
 }
 
 /** Single Source of Truth for user subscription data */
 export interface UserCreditsDocumentRead {
     // Core subscription status
-    isPremium?: boolean;
-    status?: SubscriptionStatusType;
+    isPremium: boolean;
+    status: SubscriptionStatusType;
 
     // Dates (all from RevenueCat)
-    purchasedAt?: FirestoreTimestamp;
-    expirationDate?: FirestoreTimestamp;
-    lastUpdatedAt?: FirestoreTimestamp;
-    lastPurchaseAt?: FirestoreTimestamp;
+    purchasedAt: FirestoreTimestamp;
+    expirationDate: FirestoreTimestamp | null;
+    lastUpdatedAt: FirestoreTimestamp;
+    lastPurchaseAt: FirestoreTimestamp | null;
 
     // RevenueCat subscription details
-    willRenew?: boolean;
-    productId?: string;
-    packageType?: PackageType;
-    originalTransactionId?: string;
+    willRenew: boolean | null;
+    productId: string | null;
+    packageType: PackageType | null;
+    originalTransactionId: string | null;
 
     // Trial fields
-    periodType?: PeriodType;
-    isTrialing?: boolean;
-    trialStartDate?: FirestoreTimestamp;
-    trialEndDate?: FirestoreTimestamp;
-    trialCredits?: number;
-    convertedFromTrial?: boolean;
+    periodType: PeriodType | null;
+    isTrialing: boolean | null;
+    trialStartDate: FirestoreTimestamp | null;
+    trialEndDate: FirestoreTimestamp | null;
+    trialCredits: number | null;
+    convertedFromTrial: boolean | null;
 
     // Credits
     credits: number;
-    creditLimit?: number;
+    creditLimit: number;
 
     // Metadata
-    purchaseSource?: PurchaseSource;
-    purchaseType?: PurchaseType;
-    platform?: Platform;
-    appVersion?: string;
-    processedPurchases?: string[];
-    purchaseHistory?: PurchaseMetadata[];
+    purchaseSource: PurchaseSource | null;
+    purchaseType: PurchaseType | null;
+    platform: Platform;
+    appVersion: string | null;
+    processedPurchases: string[];
+    purchaseHistory: PurchaseMetadata[];
 }

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

@@ -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,60 @@ 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: undefined };
+    }
+
+    const entity = CreditsMapper.toEntity(snap.data() as UserCreditsDocumentRead);
+    return { success: true, data: entity };
   }
 
   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) : undefined,
+    };
   }
 
   /**
    * 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/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 {