@umituz/react-native-subscription 2.14.82 → 2.14.83

package/src/infrastructure/repositories/CreditsRepository.ts

@@ -1,212 +1,78 @@
 /**
  * Credits Repository
- *
- * Firestore operations for user credits management.
- * Extends BaseRepository from @umituz/react-native-firebase.
  */
 
-import {
-    doc,
-    getDoc,
-    runTransaction,
-    serverTimestamp,
-    type Firestore,
-    type Transaction,
-} from "firebase/firestore";
+import { doc, getDoc, runTransaction, serverTimestamp, type Firestore, type Transaction } from "firebase/firestore";
 import { BaseRepository, getFirestore } from "@umituz/react-native-firebase";
-import type {
-  CreditType,
-  CreditsConfig,
-  CreditsResult,
-  DeductCreditsResult,
-} from "../../domain/entities/Credits";
+import type { CreditType, CreditsConfig, CreditsResult, DeductCreditsResult } from "../../domain/entities/Credits";
 import type { UserCreditsDocumentRead } from "../models/UserCreditsDocument";
 import { initializeCreditsTransaction } from "../services/CreditsInitializer";
 import { detectPackageType } from "../../utils/packageTypeDetector";
 import { getCreditAllocation } from "../../utils/creditMapper";
 
-declare const __DEV__: boolean;
-
 export class CreditsRepository extends BaseRepository {
-  private config: CreditsConfig;
-
-  constructor(config: CreditsConfig) {
-    super();
-    this.config = config;
-  }
+  constructor(private config: CreditsConfig) { super(); }
 
-  private getCreditsDocRef(db: Firestore, userId: string) {
-    if (this.config.useUserSubcollection) {
-      // Path: users/{userId}/credits/balance - credits stored in user subcollection
-      return doc(db, "users", userId, "credits", "balance");
-    }
-    return doc(db, this.config.collectionName, userId);
+  private getRef(db: Firestore, userId: string) {
+    return this.config.useUserSubcollection 
+      ? doc(db, "users", userId, "credits", "balance") 
+      : doc(db, this.config.collectionName, userId);
   }
 
   async getCredits(userId: string): Promise<CreditsResult> {
     const db = getFirestore();
-    if (!db) {
-      return {
-        success: false,
-        error: { message: "Database not available", code: "DB_NOT_AVAILABLE" },
-      };
-    }
-
+    if (!db) return { success: false, error: { message: "No DB", code: "DB_ERR" } };
     try {
-      const creditsRef = this.getCreditsDocRef(db, userId);
-      const snapshot = await getDoc(creditsRef);
-
-      if (!snapshot.exists()) {
-        return { success: true, data: undefined };
-      }
-
-      const data = snapshot.data() as UserCreditsDocumentRead;
-      return {
-        success: true,
-        data: {
-          textCredits: data.textCredits,
-          imageCredits: data.imageCredits,
-          purchasedAt: data.purchasedAt?.toDate?.() || new Date(),
-          lastUpdatedAt: data.lastUpdatedAt?.toDate?.() || new Date(),
-        },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: {
-          message: error instanceof Error ? error.message : "Failed to get credits",
-          code: "FETCH_FAILED",
-        },
-      };
-    }
+      const snap = await getDoc(this.getRef(db, userId));
+      if (!snap.exists()) return { success: true, data: undefined };
+      const d = snap.data() as UserCreditsDocumentRead;
+      return { success: true, data: { textCredits: d.textCredits, imageCredits: d.imageCredits, purchasedAt: d.purchasedAt?.toDate?.() || new Date(), lastUpdatedAt: d.lastUpdatedAt?.toDate?.() || new Date() } };
+    } catch (e: any) { return { success: false, error: { message: e.message, code: "FETCH_ERR" } }; }
   }
 
-  async initializeCredits(
-    userId: string,
-    purchaseId?: string,
-    productId?: string
-  ): Promise<CreditsResult> {
+  async initializeCredits(userId: string, purchaseId?: string, productId?: string): Promise<CreditsResult> {
     const db = getFirestore();
-    if (!db) {
-      return {
-        success: false,
-        error: { message: "Database not available", code: "INIT_FAILED" },
-      };
-    }
-
+    if (!db) return { success: false, error: { message: "No DB", code: "INIT_ERR" } };
     try {
-      const creditsRef = this.getCreditsDocRef(db, userId);
-
-      // Determine credit allocation based on product ID
-      let configToUse = this.config;
-
+      let cfg = { ...this.config };
       if (productId) {
-        // First check credit package amounts (for consumable credit packages)
-        const creditPackageAmount = this.config.creditPackageAmounts?.[productId];
-
-        if (creditPackageAmount) {
-          // Credit package: use the configured amount
-          if (__DEV__) {
-            console.log("[CreditsRepository] Credit package detected:", { productId, amount: creditPackageAmount });
-          }
-          configToUse = {
-            ...this.config,
-            imageCreditLimit: creditPackageAmount,
-            textCreditLimit: creditPackageAmount,
-          };
-        } else {
-          // Subscription package: use package type detection
-          const packageType = detectPackageType(productId);
-          const allocation = getCreditAllocation(packageType);
-
-          if (allocation) {
-            configToUse = {
-              ...this.config,
-              imageCreditLimit: allocation.imageCredits,
-              textCreditLimit: allocation.textCredits,
-            };
-          }
+        const amt = this.config.creditPackageAmounts?.[productId];
+        if (amt) cfg = { ...cfg, imageCreditLimit: amt, textCreditLimit: amt };
+        else {
+          const alloc = getCreditAllocation(detectPackageType(productId));
+          if (alloc) cfg = { ...cfg, imageCreditLimit: alloc.imageCredits, textCreditLimit: alloc.textCredits };
         }
       }
-
-      const result = await initializeCreditsTransaction(
-        db,
-        creditsRef,
-        configToUse,
-        purchaseId
-      );
-
-      return {
-        success: true,
-        data: {
-          textCredits: result.textCredits,
-          imageCredits: result.imageCredits,
-          purchasedAt: new Date(),
-          lastUpdatedAt: new Date(),
-        },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: {
-          message: error instanceof Error ? error.message : "Failed to initialize credits",
-          code: "INIT_FAILED",
-        },
-      };
-    }
+      const res = await initializeCreditsTransaction(db, this.getRef(db, userId), cfg, purchaseId);
+      return { success: true, data: { textCredits: res.textCredits, imageCredits: res.imageCredits, purchasedAt: new Date(), lastUpdatedAt: new Date() } };
+    } catch (e: any) { return { success: false, error: { message: e.message, code: "INIT_ERR" } }; }
   }
 
-  async deductCredit(
-    userId: string,
-    creditType: CreditType
-  ): Promise<DeductCreditsResult> {
+  async deductCredit(userId: string, type: CreditType): Promise<DeductCreditsResult> {
     const db = getFirestore();
-    if (!db) {
-      return {
-        success: false,
-        error: { message: "Database not available", code: "DEDUCT_FAILED" },
-      };
-    }
-
+    if (!db) return { success: false, error: { message: "No DB", code: "ERR" } };
+    const field = type === "text" ? "textCredits" : "imageCredits";
     try {
-      const creditsRef = this.getCreditsDocRef(db, userId);
-      const fieldName = creditType === "text" ? "textCredits" : "imageCredits";
-
-      const newCredits = await runTransaction(db, async (transaction: Transaction) => {
-        const creditsDoc = await transaction.get(creditsRef);
-        if (!creditsDoc.exists()) throw new Error("NO_CREDITS");
-
-        const currentCredits = creditsDoc.data()[fieldName] as number;
-        if (currentCredits <= 0) throw new Error("CREDITS_EXHAUSTED");
-
-        const updatedCredits = currentCredits - 1;
-        transaction.update(creditsRef, {
-          [fieldName]: updatedCredits,
-          lastUpdatedAt: serverTimestamp(),
-        });
-        return updatedCredits;
+      const remaining = await runTransaction(db, async (tx: Transaction) => {
+        const docSnap = await tx.get(this.getRef(db, userId));
+        if (!docSnap.exists()) throw new Error("NO_CREDITS");
+        const current = docSnap.data()[field] as number;
+        if (current <= 0) throw new Error("CREDITS_EXHAUSTED");
+        const updated = current - 1;
+        tx.update(this.getRef(db, userId), { [field]: updated, lastUpdatedAt: serverTimestamp() });
+        return updated;
       });
-
-      return { success: true, remainingCredits: newCredits };
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : "Unknown error";
-      const code = msg === "NO_CREDITS" || msg === "CREDITS_EXHAUSTED" ? msg : "DEDUCT_FAILED";
-      const message = msg === "NO_CREDITS" ? "No credits found" : msg === "CREDITS_EXHAUSTED" ? "Credits exhausted" : msg;
-
-      return { success: false, error: { message, code } };
+      return { success: true, remainingCredits: remaining };
+    } catch (e: any) {
+      const code = e.message === "NO_CREDITS" || e.message === "CREDITS_EXHAUSTED" ? e.message : "DEDUCT_ERR";
+      return { success: false, error: { message: e.message, code } };
     }
   }
 
-  async hasCredits(userId: string, creditType: CreditType): Promise<boolean> {
-    const result = await this.getCredits(userId);
-    if (!result.success || !result.data) return false;
-    const credits = creditType === "text" ? result.data.textCredits : result.data.imageCredits;
-    return credits > 0;
+  async hasCredits(userId: string, type: CreditType): Promise<boolean> {
+    const res = await this.getCredits(userId);
+    return !!(res.success && res.data && (type === "text" ? res.data.textCredits : res.data.imageCredits) > 0);
   }
 }
 
-export const createCreditsRepository = (
-  config: CreditsConfig
-): CreditsRepository => {
-  return new CreditsRepository(config);
-};
+export const createCreditsRepository = (c: CreditsConfig) => new CreditsRepository(c);

package/src/infrastructure/services/SubscriptionInitializer.ts

@@ -1,11 +1,8 @@
 /**
  * Subscription Initializer
- * Single entry point for subscription system initialization
- * Apps just call initializeSubscription with config
  */
 
 import { Platform } from "react-native";
-import type { CustomerInfo } from "react-native-purchases";
 import type { CreditsConfig } from "../../domain/entities/Credits";
 import { configureCreditsRepository, getCreditsRepository } from "../repositories/CreditsRepositoryProvider";
 import { SubscriptionManager } from "../../revenuecat/infrastructure/managers/SubscriptionManager";
@@ -16,213 +13,62 @@ export interface FirebaseAuthLike {
   onAuthStateChanged: (callback: (user: { uid: string; isAnonymous: boolean } | null) => void) => () => void;
 }
 
-export interface CreditPackageConfig {
-  /** Identifier pattern to match credit packages (e.g., "credit") */
-  identifierPattern?: string;
-  /** Map of productId to credit amounts */
-  amounts?: Record<string, number>;
-}
+export interface CreditPackageConfig { identifierPattern?: string; amounts?: Record<string, number>; }
 
 export interface SubscriptionInitConfig {
-  /** API key for RevenueCat (can provide single key or platform-specific keys) */
-  apiKey?: string;
-  /** iOS-specific API key (overrides apiKey if provided on iOS) */
-  apiKeyIos?: string;
-  /** Android-specific API key (overrides apiKey if provided on Android) */
-  apiKeyAndroid?: string;
-  testStoreKey?: string;
-  entitlementId: string;
-  credits: CreditsConfig;
-  getAnonymousUserId: () => Promise<string>;
-  getFirebaseAuth: () => FirebaseAuthLike | null;
-  showAuthModal: () => void;
-  /** Callback after credits are updated (for cache invalidation) */
-  onCreditsUpdated?: (userId: string) => void;
-  /** Credit package configuration for consumable purchases */
-  creditPackages?: CreditPackageConfig;
-  timeoutMs?: number;
-  authStateTimeoutMs?: number;
+  apiKey?: string; apiKeyIos?: string; apiKeyAndroid?: string; testStoreKey?: string; entitlementId: string; credits: CreditsConfig;
+  getAnonymousUserId: () => Promise<string>; getFirebaseAuth: () => FirebaseAuthLike | null; showAuthModal: () => void;
+  onCreditsUpdated?: (userId: string) => void; creditPackages?: CreditPackageConfig; timeoutMs?: number; authStateTimeoutMs?: number;
 }
 
-/**
- * Wait for Firebase Auth state to be ready
- * This prevents unnecessary logIn calls that trigger Apple Sign In dialog
- */
-const waitForAuthState = async (
-  getFirebaseAuth: () => FirebaseAuthLike | null,
-  timeoutMs: number
-): Promise<string | undefined> => {
-  const auth = getFirebaseAuth();
+const waitForAuthState = async (getAuth: () => FirebaseAuthLike | null, timeoutMs: number): Promise<string | undefined> => {
+  const auth = getAuth();
   if (!auth) return undefined;
-
-  // If user already available, return immediately
-  if (auth.currentUser) {
-    return auth.currentUser.uid;
-  }
-
-  // Wait for auth state to settle
-  return new Promise<string | undefined>((resolve) => {
-    const unsubscribe = auth.onAuthStateChanged((user) => {
-      unsubscribe();
-      resolve(user?.uid || undefined);
-    });
-
-    // Timeout fallback - don't wait forever
-    setTimeout(() => {
-      unsubscribe();
-      resolve(undefined);
-    }, timeoutMs);
+  if (auth.currentUser) return auth.currentUser.uid;
+  return new Promise((resolve) => {
+    const unsub = auth.onAuthStateChanged((u) => { unsub(); resolve(u?.uid); });
+    setTimeout(() => { unsub(); resolve(undefined); }, timeoutMs);
   });
 };
 
-/**
- * Check if a product is a credit package
- */
-const isCreditPackage = (productId: string, pattern?: string): boolean => {
-  const patternToUse = pattern || "credit";
-  return productId.toLowerCase().includes(patternToUse.toLowerCase());
-};
-
-
-export const initializeSubscription = async (
-  config: SubscriptionInitConfig,
-): Promise<void> => {
-  const {
-    apiKey,
-    apiKeyIos,
-    apiKeyAndroid,
-    testStoreKey,
-    entitlementId,
-    credits,
-    getAnonymousUserId,
-    getFirebaseAuth,
-    showAuthModal,
-    onCreditsUpdated,
-    creditPackages,
-    timeoutMs = 10000,
-    authStateTimeoutMs = 2000,
-  } = config;
-
-  // Resolve API key based on platform
-  const resolvedApiKey = Platform.OS === "ios"
-    ? (apiKeyIos || apiKey || "")
-    : (apiKeyAndroid || apiKey || "");
-
-  if (!resolvedApiKey) {
-    throw new Error("RevenueCat API key is required");
-  }
-
-  // Merge credit package amounts into credits config
-  const creditsConfigWithPackages = {
-    ...credits,
-    creditPackageAmounts: creditPackages?.amounts,
-  };
-  configureCreditsRepository(creditsConfigWithPackages);
+const isCreditPkg = (id: string, pat?: string) => id.toLowerCase().includes((pat || "credit").toLowerCase());
 
-  // Build consumable product identifiers from credit package pattern
-  const consumableIdentifiers: string[] = [];
-  if (creditPackages?.identifierPattern) {
-    consumableIdentifiers.push(creditPackages.identifierPattern);
-  } else {
-    consumableIdentifiers.push("credit");
-  }
+export const initializeSubscription = async (config: SubscriptionInitConfig): Promise<void> => {
+  const { apiKey, apiKeyIos, apiKeyAndroid, testStoreKey, entitlementId, credits, getAnonymousUserId, getFirebaseAuth, showAuthModal, onCreditsUpdated, creditPackages, timeoutMs = 10000, authStateTimeoutMs = 2000 } = config;
 
-  // Create onPurchaseCompleted handler for credit packages
-  const handlePurchaseCompleted = async (
-    userId: string,
-    productId: string,
-    _customerInfo: CustomerInfo
-  ): Promise<void> => {
-    const isCredit = isCreditPackage(productId, creditPackages?.identifierPattern);
+  const key = Platform.OS === "ios" ? (apiKeyIos || apiKey || "") : (apiKeyAndroid || apiKey || "");
+  if (!key) throw new Error("API key required");
 
-    if (!isCredit) {
-      return;
-    }
+  configureCreditsRepository({ ...credits, creditPackageAmounts: creditPackages?.amounts });
 
+  const onPurchase = async (userId: string, productId: string) => {
+    if (!isCreditPkg(productId, creditPackages?.identifierPattern)) return;
     try {
-      const repository = getCreditsRepository();
-      const purchaseId = `purchase_${productId}_${Date.now()}`;
-
-      await repository.initializeCredits(userId, purchaseId, productId);
-
-      if (__DEV__) {
-        console.log("[SubscriptionInitializer] Credits added for purchase:", {
-          userId,
-          productId,
-          purchaseId,
-        });
-      }
-
-      if (onCreditsUpdated) {
-        onCreditsUpdated(userId);
-      }
-    } catch (error) {
-      if (__DEV__) {
-        console.error("[SubscriptionInitializer] Failed to add credits:", error);
-      }
-    }
+      await getCreditsRepository().initializeCredits(userId, `purchase_${productId}_${Date.now()}`, productId);
+      onCreditsUpdated?.(userId);
+    } catch { /* Silent */ }
   };
 
-  // Create onCreditRenewal handler for subscription renewals
-  const handleCreditRenewal = async (
-    userId: string,
-    productId: string,
-    renewalId: string
-  ): Promise<void> => {
+  const onRenewal = async (userId: string, productId: string, renewalId: string) => {
     try {
-      const repository = getCreditsRepository();
-      await repository.initializeCredits(userId, renewalId, productId);
-
-      if (__DEV__) {
-        console.log("[SubscriptionInitializer] Credits renewed:", {
-          userId,
-          productId,
-          renewalId,
-        });
-      }
-
-      if (onCreditsUpdated) {
-        onCreditsUpdated(userId);
-      }
-    } catch (error) {
-      if (__DEV__) {
-        console.error("[SubscriptionInitializer] Failed to renew credits:", error);
-      }
-    }
+      await getCreditsRepository().initializeCredits(userId, renewalId, productId);
+      onCreditsUpdated?.(userId);
+    } catch { /* Silent */ }
   };
 
   SubscriptionManager.configure({
-    config: {
-      apiKey: resolvedApiKey,
-      testStoreKey,
-      entitlementIdentifier: entitlementId,
-      consumableProductIdentifiers: consumableIdentifiers,
-      onCreditRenewal: handleCreditRenewal,
-      onCreditsUpdated,
-      onPurchaseCompleted: handlePurchaseCompleted,
-    },
-    apiKey: resolvedApiKey,
-    getAnonymousUserId,
+    config: { apiKey: key, testStoreKey, entitlementIdentifier: entitlementId, consumableProductIdentifiers: [creditPackages?.identifierPattern || "credit"], onCreditRenewal: onRenewal, onPurchaseCompleted: onPurchase, onCreditsUpdated },
+    apiKey: key, getAnonymousUserId
   });
 
-  // Wait for auth state to get correct user ID
-  const initialUserId = await waitForAuthState(getFirebaseAuth, authStateTimeoutMs);
-
-  const initPromise = SubscriptionManager.initialize(initialUserId);
-  const timeoutPromise = new Promise<boolean>((_, reject) =>
-    setTimeout(
-      () => reject(new Error("Subscription initialization timeout")),
-      timeoutMs,
-    ),
-  );
-
-  await Promise.race([initPromise, timeoutPromise]);
+  const userId = await waitForAuthState(getFirebaseAuth, authStateTimeoutMs);
+  const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), timeoutMs));
+  await Promise.race([SubscriptionManager.initialize(userId), timeout]);
 
   configureAuthProvider({
     isAuthenticated: () => {
-      const auth = getFirebaseAuth();
-      const user = auth?.currentUser;
-      return !!(user && !user.isAnonymous);
+      const u = getFirebaseAuth()?.currentUser;
+      return !!(u && !u.isAnonymous);
     },
     showAuthModal,
   });

package/src/presentation/hooks/index.ts

@@ -0,0 +1,23 @@
+export * from "./useAuthAwarePurchase";
+export * from "./useAuthGate";
+export * from "./useAuthSubscriptionSync";
+export * from "./useCreditChecker";
+export * from "./useCredits";
+export * from "./useCreditsGate";
+export * from "./useDeductCredit";
+export * from "./useInitializeCredits";
+export * from "./useDevTestCallbacks";
+export * from "./useFeatureGate";
+export * from "./usePaywallOperations";
+export * from "./usePaywallVisibility";
+export * from "./usePremium";
+export * from "./usePremiumGate";
+export * from "./usePremiumWithCredits";
+export * from "./useSubscription";
+export * from "./useSubscriptionDetails";
+export * from "./useSubscriptionGate";
+export * from "./useSubscriptionSettingsConfig";
+export * from "./useSubscriptionStatus";
+export * from "./useUserTier";
+export * from "./useUserTierWithRepository";
+export * from "./feedback/usePaywallFeedback";