@umituz/react-native-subscription 2.33.0 → 2.33.1

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

@@ -1,112 +0,0 @@
-/**
- * Subscription Initializer
- *
- * Uses RevenueCat best practices:
- * - Non-blocking initialization (fire and forget)
- * - Relies on CustomerInfoUpdateListener for state updates
- */
-
-import { Platform } from "react-native";
-import { configureCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryManager";
-import { SubscriptionManager } from "../infrastructure/managers/SubscriptionManager";
-import { configureAuthProvider } from "../presentation/useAuthAwarePurchase";
-import { SubscriptionSyncService } from "./SubscriptionSyncService";
-import { getCurrentUserId, setupAuthStateListener } from "./SubscriptionAuthListener";
-import type { SubscriptionInitConfig } from "./SubscriptionInitializerTypes";
-
-export type { FirebaseAuthLike, CreditPackageConfig, SubscriptionInitConfig } from "./SubscriptionInitializerTypes";
-
-export const initializeSubscription = async (config: SubscriptionInitConfig): Promise<void> => {
-  const {
-    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');
-  }
-
-  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
-  });
-
-  // 2. Setup Sync Service
-  const syncService = new SubscriptionSyncService(entitlementId);
-
-  // 3. Configure Subscription Manager
-  SubscriptionManager.configure({
-    config: {
-      apiKey: key,
-      entitlementIdentifier: entitlementId,
-      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),
-      onCreditsUpdated,
-    },
-    apiKey: key,
-    getAnonymousUserId,
-  });
-
-  // 4. Configure Auth aware actions
-  configureAuthProvider({
-    isAuthenticated: () => {
-      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): Promise<void> => {
-    await SubscriptionManager.initialize(userId);
-  };
-
-  // 5. Start Background Init
-  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(() => auth, (newUserId) => {
-    initializeInBackground(newUserId);
-  });
-};

package/src/domains/subscription/infrastructure/hooks/useCustomerInfo.ts

@@ -1,113 +0,0 @@
-/**
- * useCustomerInfo Hook
- * Fetches and manages RevenueCat CustomerInfo with real-time updates
- *
- * BEST PRACTICE: Always get expiration date from CustomerInfo (source of truth)
- * Never calculate expiration dates client-side (purchaseDate + 1 year is WRONG)
- *
- * This hook provides:
- * - Initial fetch from SDK cache (instant, no network)
- * - Real-time listener for updates (renewals, purchases, restore)
- * - Automatic cleanup on unmount
- * - SDK caches CustomerInfo and fetches every ~5 minutes
- *
- * @see https://www.revenuecat.com/docs/customers/customer-info
- */
-
-import { useEffect, useState, useCallback, useRef } from "react";
-import Purchases, { type CustomerInfo } from "react-native-purchases";
-
-export interface UseCustomerInfoResult {
-  /** Current CustomerInfo from RevenueCat SDK */
-  customerInfo: CustomerInfo | null;
-  /** Loading state (only true on initial fetch) */
-  loading: boolean;
-  /** Error message if fetch failed */
-  error: string | null;
-  /** Manually refetch CustomerInfo (usually not needed, listener handles updates) */
-  refetch: () => Promise<void>;
-  /** Whether SDK is currently fetching */
-  isFetching: boolean;
-}
-
-/**
- * Hook to get CustomerInfo from RevenueCat SDK
- *
- * Features:
- * - SDK cache: First call returns cached data (instant)
- * - Auto-updates: Listener triggers on renewals, purchases, restore
- * - Network fetch: SDK fetches every ~5 minutes in background
- * - Grace periods: Expiration dates include grace period automatically
- *
- * @example
- * ```typescript
- * const { customerInfo, loading } = useCustomerInfo();
- *
- * // Check premium status
- * const isPremium = !!customerInfo?.entitlements.active['premium'];
- *
- * // Get expiration date (ALWAYS from CustomerInfo, NEVER calculate!)
- * const expiresAt = customerInfo?.entitlements.active['premium']?.expirationDate;
- *
- * // Check will renew
- * const willRenew = customerInfo?.entitlements.active['premium']?.willRenew;
- * ```
- *
- * @returns CustomerInfo and loading state
- */
-export function useCustomerInfo(): UseCustomerInfoResult {
-  const [customerInfo, setCustomerInfo] = useState<CustomerInfo | null>(null);
-  const [loading, setLoading] = useState(true);
-  const [isFetching, setIsFetching] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
-  const fetchCustomerInfo = useCallback(async () => {
-    try {
-      setIsFetching(true);
-      setError(null);
-
-      // SDK returns cached data instantly if available
-      // Network fetch happens in background automatically
-      const info = await Purchases.getCustomerInfo();
-
-      setCustomerInfo(info);
-    } catch (err) {
-      const errorMessage =
-        err instanceof Error ? err.message : "Failed to fetch customer info";
-      setError(errorMessage);
-    } finally {
-      setLoading(false);
-      setIsFetching(false);
-    }
-  }, []);
-
-  const listenerRef = useRef<((info: CustomerInfo) => void) | null>(null);
-
-  useEffect(() => {
-    fetchCustomerInfo();
-
-    const listener = (info: CustomerInfo) => {
-      setCustomerInfo(info);
-      setError(null);
-    };
-
-    // Set ref BEFORE adding listener to ensure cleanup can always find it
-    listenerRef.current = listener;
-    Purchases.addCustomerInfoUpdateListener(listener);
-
-    return () => {
-      if (listenerRef.current) {
-        Purchases.removeCustomerInfoUpdateListener(listenerRef.current);
-        listenerRef.current = null;
-      }
-    };
-  }, [fetchCustomerInfo]);
-
-  return {
-    customerInfo,
-    loading,
-    error,
-    refetch: fetchCustomerInfo,
-    isFetching,
-  };
-}

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

@@ -1,141 +0,0 @@
-/**
- * Renewal Detector
- * Detects subscription renewals by tracking expiration date changes
- * Best Practice: Compare expiration dates to detect renewal events
- */
-
-import type { CustomerInfo } from "react-native-purchases";
-import { detectPackageType } from "../../../../utils/packageTypeDetector";
-
-export interface RenewalState {
-  previousExpirationDate: string | null;
-  previousProductId: string | null;
-}
-
-export interface RenewalDetectionResult {
-  isRenewal: boolean;
-  isPlanChange: boolean;
-  isUpgrade: boolean;
-  isDowngrade: boolean;
-  productId: string | null;
-  previousProductId: string | null;
-  newExpirationDate: string | null;
-}
-
-const PACKAGE_TIER_ORDER: Record<string, number> = {
-  weekly: 1,
-  monthly: 2,
-  yearly: 3,
-  unknown: 0,
-};
-
-function getPackageTier(productId: string | null): number {
-  if (!productId) return 0;
-  const packageType = detectPackageType(productId);
-  return PACKAGE_TIER_ORDER[packageType] ?? 0;
-}
-
-/**
- * Detects if a subscription renewal or plan change occurred
- *
- * Best Practice (RevenueCat):
- * - Track previous expiration date
- * - If new expiration > previous → Renewal detected
- * - If productId changed → Plan change (upgrade/downgrade)
- * - Reset credits on renewal or plan change (industry standard)
- *
- * @param state Previous state (expiration date, product ID)
- * @param customerInfo Current CustomerInfo from RevenueCat
- * @param entitlementId Entitlement identifier to check
- * @returns Renewal detection result
- */
-export function detectRenewal(
-  state: RenewalState,
-  customerInfo: CustomerInfo,
-  entitlementId: string
-): RenewalDetectionResult {
-  const entitlement = customerInfo.entitlements.active[entitlementId];
-
-  const baseResult: RenewalDetectionResult = {
-    isRenewal: false,
-    isPlanChange: false,
-    isUpgrade: false,
-    isDowngrade: false,
-    productId: null,
-    previousProductId: state.previousProductId,
-    newExpirationDate: null,
-  };
-
-  if (!entitlement) {
-    return baseResult;
-  }
-
-  const newExpirationDate = entitlement.expirationDate;
-  const productId = entitlement.productIdentifier;
-
-  // First time seeing this subscription - not a renewal
-  if (!state.previousExpirationDate || !state.previousProductId) {
-    return {
-      ...baseResult,
-      productId,
-      newExpirationDate,
-    };
-  }
-
-  if (!newExpirationDate) {
-    // Lifetime subscription (no expiration) - not a renewal
-    return {
-      ...baseResult,
-      productId,
-      newExpirationDate,
-    };
-  }
-  const newExpiration = new Date(newExpirationDate);
-  const previousExpiration = new Date(state.previousExpirationDate);
-  const productChanged = productId !== state.previousProductId;
-  const expirationExtended = newExpiration > previousExpiration;
-
-  // Plan change detection (upgrade/downgrade)
-  if (productChanged) {
-    const oldTier = getPackageTier(state.previousProductId);
-    const newTier = getPackageTier(productId);
-    const isUpgrade = newTier > oldTier;
-    const isDowngrade = newTier < oldTier;
-
-    return {
-      isRenewal: false,
-      isPlanChange: true,
-      isUpgrade,
-      isDowngrade,
-      productId,
-      previousProductId: state.previousProductId,
-      newExpirationDate,
-    };
-  }
-
-  // Same product renewal
-  const isRenewal = expirationExtended;
-
-  return {
-    isRenewal,
-    isPlanChange: false,
-    isUpgrade: false,
-    isDowngrade: false,
-    productId,
-    previousProductId: state.previousProductId,
-    newExpirationDate,
-  };
-}
-
-/**
- * Updates renewal state after detection
- */
-export function updateRenewalState(
-  _state: RenewalState,
-  result: RenewalDetectionResult
-): RenewalState {
-  return {
-    previousExpirationDate: result.newExpirationDate,
-    previousProductId: result.productId,
-  };
-}

package/src/domains/wallet/infrastructure/repositories/TransactionRepository.ts

@@ -1,114 +0,0 @@
-/**
- * Transaction Repository
- *
- * Firestore operations for credit transaction logs.
- * Generic repository for use across hundreds of apps.
- */
-
-import {
-    getDocs,
-    addDoc,
-    query,
-    where,
-    orderBy,
-    limit as firestoreLimit,
-    serverTimestamp,
-    type QueryConstraint,
-} from "firebase/firestore";
-import { BaseRepository } from "@umituz/react-native-firebase";
-import type {
-  CreditLog,
-  TransactionRepositoryConfig,
-  TransactionQueryOptions,
-  TransactionResult,
-  TransactionReason,
-} from "../../domain/types/transaction.types";
-import { TransactionMapper } from "../../domain/mappers/TransactionMapper";
-import { requireFirestore, buildCollectionRef, type CollectionConfig, mapErrorToResult } from "../../../../shared/infrastructure/firestore";
-
-export class TransactionRepository extends BaseRepository {
-  private config: TransactionRepositoryConfig;
-
-  constructor(config: TransactionRepositoryConfig) {
-    super(config.collectionName);
-    this.config = config;
-  }
-
-  private getCollectionConfig(): CollectionConfig {
-    return {
-      collectionName: this.config.collectionName,
-      useUserSubcollection: this.config.useUserSubcollection ?? false,
-    };
-  }
-
-  private getCollectionRef(db: any, userId: string) {
-    const config = this.getCollectionConfig();
-    return buildCollectionRef(db, userId, config);
-  }
-
-  async getTransactions(
-    options: TransactionQueryOptions
-  ): Promise<TransactionResult> {
-    try {
-      const db = requireFirestore();
-      const colRef = this.getCollectionRef(db, options.userId);
-      const constraints: QueryConstraint[] = [];
-
-      if (!this.config.useUserSubcollection) {
-        constraints.push(where("userId", "==", options.userId));
-      }
-
-      constraints.push(orderBy("createdAt", "desc"));
-      constraints.push(firestoreLimit(options.limit ?? 50));
-
-      const q = query(colRef, ...constraints);
-      const snapshot = await getDocs(q);
-
-      const transactions: CreditLog[] = snapshot.docs.map((docSnap) =>
-        TransactionMapper.toEntity(docSnap, options.userId)
-      );
-
-      return { success: true, data: transactions };
-    } catch (error) {
-      return mapErrorToResult(error);
-    }
-  }
-
-  async addTransaction(
-    userId: string,
-    change: number,
-    reason: TransactionReason,
-    metadata?: Partial<CreditLog>
-  ): Promise<TransactionResult<CreditLog>> {
-    try {
-      const db = requireFirestore();
-      const colRef = this.getCollectionRef(db, userId);
-      const docData = {
-        ...TransactionMapper.toFirestore(userId, change, reason, metadata),
-        createdAt: serverTimestamp(),
-      };
-
-      const docRef = await addDoc(colRef, docData);
-
-      return {
-        success: true,
-        data: {
-          id: docRef.id,
-          userId,
-          change,
-          reason,
-          ...metadata,
-          createdAt: Date.now(),
-        },
-      };
-    } catch (error) {
-      return mapErrorToResult<CreditLog>(error);
-    }
-  }
-}
-
-export function createTransactionRepository(
-  config: TransactionRepositoryConfig
-): TransactionRepository {
-  return new TransactionRepository(config);
-}

package/src/domains/wallet/infrastructure/services/ProductMetadataService.ts

@@ -1,114 +0,0 @@
-/**
- * Product Metadata Service
- *
- * Generic service for fetching product metadata from Firestore.
- * Collection name is configurable for use across hundreds of apps.
- */
-
-import { collection, getDocs, orderBy, query } from "firebase/firestore";
-import { requireFirestore } from "../../../../shared/infrastructure";
-import type {
-  ProductMetadata,
-  ProductMetadataConfig,
-  ProductType,
-} from "../../domain/types/wallet.types";
-
-interface CacheEntry {
-  data: ProductMetadata[];
-  timestamp: number;
-}
-
-const DEFAULT_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
-
-export class ProductMetadataService {
-  private config: ProductMetadataConfig;
-  private cache: CacheEntry | null = null;
-
-  constructor(config: ProductMetadataConfig) {
-    this.config = config;
-  }
-
-  private isCacheValid(): boolean {
-    if (!this.cache) return false;
-    const ttl = this.config.cacheTTL ?? DEFAULT_CACHE_TTL_MS;
-    return Date.now() - this.cache.timestamp < ttl;
-  }
-
-  private async fetchFromFirebase(): Promise<ProductMetadata[]> {
-    const db = requireFirestore();
-    const colRef = collection(db, this.config.collectionName);
-    const q = query(colRef, orderBy("order", "asc"));
-    const snapshot = await getDocs(q);
-
-    return snapshot.docs.map((docSnap) => ({
-      productId: docSnap.id,
-      ...docSnap.data(),
-    })) as ProductMetadata[];
-  }
-
-  async getAll(): Promise<ProductMetadata[]> {
-    if (this.isCacheValid() && this.cache) {
-      return this.cache.data;
-    }
-
-    try {
-      const data = await this.fetchFromFirebase();
-      this.cache = { data, timestamp: Date.now() };
-      return data;
-    } catch (error) {
-      if (this.cache) {
-        return this.cache.data;
-      }
-      throw error;
-    }
-  }
-
-  async getByProductId(productId: string): Promise<ProductMetadata | null> {
-    const all = await this.getAll();
-    return all.find((p) => p.productId === productId) ?? null;
-  }
-
-  async getByType(type: ProductType): Promise<ProductMetadata[]> {
-    const all = await this.getAll();
-    return all.filter((p) => p.type === type);
-  }
-
-  async getCreditsPackages(): Promise<ProductMetadata[]> {
-    return this.getByType("credits");
-  }
-
-  async getSubscriptionPackages(): Promise<ProductMetadata[]> {
-    return this.getByType("subscription");
-  }
-
-  clearCache(): void {
-    this.cache = null;
-  }
-}
-
-export function createProductMetadataService(
-  config: ProductMetadataConfig
-): ProductMetadataService {
-  return new ProductMetadataService(config);
-}
-
-let defaultService: ProductMetadataService | null = null;
-
-export function configureProductMetadataService(
-  config: ProductMetadataConfig
-): void {
-  defaultService = new ProductMetadataService(config);
-}
-
-export function getProductMetadataService(): ProductMetadataService {
-  if (!defaultService) {
-    throw new Error(
-      "ProductMetadataService not configured. Call configureProductMetadataService first."
-    );
-  }
-  return defaultService;
-}
-
-export function resetProductMetadataService(): void {
-  defaultService = null;
-}