@umituz/react-native-subscription 2.33.0 → 2.33.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.33.0",
+  "version": "2.33.1",
   "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/infrastructure/operations/CreditsFetcher.ts

@@ -1,9 +1,8 @@
 import { getDoc } from "firebase/firestore";
-import type { Firestore, DocumentReference } from "@umituz/react-native-firebase";
+import type { DocumentReference } from "@umituz/react-native-firebase";
 import type { CreditsResult } from "../../core/Credits";
 import type { UserCreditsDocumentRead } from "../../core/UserCreditsDocument";
 import { mapCreditsDocumentToEntity } from "../../core/CreditsMapper";
-import { requireFirestore } from "../../../../shared/infrastructure/firestore";
 
 export async function fetchCredits(ref: DocumentReference): Promise<CreditsResult> {
   const snap = await getDoc(ref);

package/src/domains/credits/infrastructure/operations/CreditsInitializer.ts

@@ -1,6 +1,6 @@
 import type { Firestore, DocumentReference } from "@umituz/react-native-firebase";
 import type { CreditsConfig, CreditsResult } from "../../core/Credits";
-import type { UserCreditsDocumentRead, PurchaseSource } from "../../core/UserCreditsDocument";
+import type { PurchaseSource } from "../../core/UserCreditsDocument";
 import { initializeCreditsTransaction } from "../../application/CreditsInitializer";
 import { mapCreditsDocumentToEntity } from "../../core/CreditsMapper";
 import type { RevenueCatData } from "../../../revenuecat/core/types";

package/src/domains/credits/presentation/deduct-credit/index.ts

@@ -0,0 +1,2 @@
+export { useDeductCredit } from "./useDeductCredit";
+export type { UseDeductCreditParams, UseDeductCreditResult } from "./types";

package/src/domains/credits/presentation/deduct-credit/mutationConfig.ts

@@ -0,0 +1,81 @@
+import type { QueryClient } from "@umituz/react-native-design-system";
+import { timezoneService } from "@umituz/react-native-design-system";
+import type { UserCredits } from "../../core/Credits";
+import type { CreditsRepository } from "../../infrastructure/CreditsRepository";
+import { creditsQueryKeys } from "../creditsQueryKeys";
+import { calculateRemaining } from "../../../../shared/utils/numberUtils";
+
+interface MutationContext {
+  previousCredits: UserCredits | null;
+  skippedOptimistic: boolean;
+  wasInsufficient?: boolean;
+  capturedUserId: string | null;
+}
+
+export function createDeductCreditMutationConfig(
+  userId: string | undefined,
+  repository: CreditsRepository,
+  queryClient: QueryClient
+) {
+  return {
+    mutationFn: async (cost: number) => {
+      if (!userId) throw new Error("User not authenticated");
+      return repository.deductCredit(userId, cost);
+    },
+    onMutate: async (cost: number): Promise<MutationContext> => {
+      if (!userId) {
+        return { previousCredits: null, skippedOptimistic: true, capturedUserId: null };
+      }
+
+      const capturedUserId = userId;
+
+      await queryClient.cancelQueries({ queryKey: creditsQueryKeys.user(capturedUserId) });
+      const previousCredits = queryClient.getQueryData<UserCredits>(
+        creditsQueryKeys.user(capturedUserId)
+      );
+
+      if (!previousCredits) {
+        return {
+          previousCredits: null as UserCredits | null,
+          skippedOptimistic: true,
+          capturedUserId
+        };
+      }
+
+      const newCredits = calculateRemaining(previousCredits.credits, cost);
+
+      queryClient.setQueryData<UserCredits | null>(
+        creditsQueryKeys.user(capturedUserId),
+        (old) => {
+          if (!old) return old;
+          return {
+            ...old,
+            credits: newCredits,
+            lastUpdatedAt: timezoneService.getNow()
+          };
+        }
+      );
+
+      return {
+        previousCredits,
+        skippedOptimistic: false,
+        wasInsufficient: previousCredits.credits < cost,
+        capturedUserId
+      };
+    },
+    onError: (_err: unknown, _cost: number, context: MutationContext | undefined) => {
+      if (context?.capturedUserId && context.previousCredits && !context.skippedOptimistic) {
+        queryClient.setQueryData(
+          creditsQueryKeys.user(context.capturedUserId),
+          context.previousCredits
+        );
+      }
+    },
+    onSuccess: (_data: unknown, _cost: number, context: MutationContext | undefined) => {
+      const targetUserId = context?.capturedUserId ?? userId;
+      if (targetUserId) {
+        queryClient.invalidateQueries({ queryKey: creditsQueryKeys.user(targetUserId) });
+      }
+    },
+  };
+}

package/src/domains/credits/presentation/deduct-credit/types.ts

@@ -0,0 +1,11 @@
+export interface UseDeductCreditParams {
+  userId: string | undefined;
+  onCreditsExhausted?: () => void;
+}
+
+export interface UseDeductCreditResult {
+  checkCredits: (cost?: number) => Promise<boolean>;
+  deductCredit: (cost?: number) => Promise<boolean>;
+  deductCredits: (cost: number) => Promise<boolean>;
+  isDeducting: boolean;
+}

package/src/domains/credits/presentation/deduct-credit/useDeductCredit.ts

@@ -0,0 +1,44 @@
+import { useCallback } from "react";
+import { useMutation, useQueryClient } from "@umituz/react-native-design-system";
+import { getCreditsRepository } from "../../infrastructure/CreditsRepositoryManager";
+import type { UseDeductCreditParams, UseDeductCreditResult } from "./types";
+import { createDeductCreditMutationConfig } from "./mutationConfig";
+
+export const useDeductCredit = ({
+  userId,
+  onCreditsExhausted,
+}: UseDeductCreditParams): UseDeductCreditResult => {
+  const repository = getCreditsRepository();
+  const queryClient = useQueryClient();
+
+  const mutation = useMutation(createDeductCreditMutationConfig(userId, repository, queryClient));
+
+  const deductCredit = useCallback(async (cost: number = 1): Promise<boolean> => {
+    try {
+      const res = await mutation.mutateAsync(cost);
+      if (!res.success) {
+        if (res.error?.code === "CREDITS_EXHAUSTED") onCreditsExhausted?.();
+        return false;
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }, [mutation, onCreditsExhausted]);
+
+  const deductCredits = useCallback(async (cost: number): Promise<boolean> => {
+    return await deductCredit(cost);
+  }, [deductCredit]);
+
+  const checkCredits = useCallback(async (cost: number = 1): Promise<boolean> => {
+    if (!userId) return false;
+    return repository.hasCredits(userId, cost);
+  }, [userId, repository]);
+
+  return {
+    checkCredits,
+    deductCredit,
+    deductCredits,
+    isDeducting: mutation.isPending
+  };
+};

package/src/domains/subscription/application/initializer/BackgroundInitializer.ts

@@ -0,0 +1,21 @@
+import { SubscriptionManager } from "../../infrastructure/managers/SubscriptionManager";
+import { getCurrentUserId, setupAuthStateListener } from "../SubscriptionAuthListener";
+import type { SubscriptionInitConfig } from "../SubscriptionInitializerTypes";
+
+export async function startBackgroundInitialization(config: SubscriptionInitConfig): Promise<void> {
+  const initializeInBackground = async (userId?: string): Promise<void> => {
+    await SubscriptionManager.initialize(userId);
+  };
+
+  const auth = config.getFirebaseAuth();
+  if (!auth) {
+    throw new Error("Firebase auth is not available");
+  }
+
+  const initialUserId = getCurrentUserId(() => auth);
+  await initializeInBackground(initialUserId);
+
+  setupAuthStateListener(() => auth, (newUserId) => {
+    initializeInBackground(newUserId);
+  });
+}

package/src/domains/subscription/application/initializer/ConfigValidator.ts

@@ -0,0 +1,33 @@
+import { Platform } from "react-native";
+import type { SubscriptionInitConfig } from "../SubscriptionInitializerTypes";
+
+export function getApiKey(config: SubscriptionInitConfig): string {
+  const { apiKey, apiKeyIos, apiKeyAndroid } = config;
+  const key = Platform.OS === 'ios'
+    ? (apiKeyIos || apiKey)
+    : (apiKeyAndroid || apiKey);
+
+  if (!key) {
+    throw new Error('API key required');
+  }
+
+  return key;
+}
+
+export function validateConfig(config: SubscriptionInitConfig): void {
+  if (!config.creditPackages) {
+    throw new Error('creditPackages is required');
+  }
+
+  if (!config.creditPackages.identifierPattern) {
+    throw new Error('creditPackages.identifierPattern is required');
+  }
+
+  if (!config.creditPackages.amounts) {
+    throw new Error('creditPackages.amounts is required');
+  }
+
+  if (!config.getAnonymousUserId) {
+    throw new Error('getAnonymousUserId is required');
+  }
+}

package/src/domains/subscription/application/initializer/ServiceConfigurator.ts

@@ -0,0 +1,45 @@
+import { configureCreditsRepository } from "../../../credits/infrastructure/CreditsRepositoryManager";
+import { SubscriptionManager } from "../../infrastructure/managers/SubscriptionManager";
+import { configureAuthProvider } from "../../presentation/useAuthAwarePurchase";
+import { SubscriptionSyncService } from "../SubscriptionSyncService";
+import type { SubscriptionInitConfig } from "../SubscriptionInitializerTypes";
+
+export function configureServices(config: SubscriptionInitConfig, apiKey: string): SubscriptionSyncService {
+  const { entitlementId, credits, creditPackages, getAnonymousUserId, getFirebaseAuth, showAuthModal, onCreditsUpdated } = config;
+
+  configureCreditsRepository({
+    ...credits,
+    creditPackageAmounts: creditPackages!.amounts
+  });
+
+  const syncService = new SubscriptionSyncService(entitlementId);
+
+  SubscriptionManager.configure({
+    config: {
+      apiKey,
+      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,
+    getAnonymousUserId: getAnonymousUserId!,
+  });
+
+  configureAuthProvider({
+    isAuthenticated: () => {
+      const auth = getFirebaseAuth();
+      if (!auth) {
+        throw new Error("Firebase auth is not available");
+      }
+
+      const u = auth.currentUser;
+      return !!(u && !u.isAnonymous);
+    },
+    showAuthModal,
+  });
+
+  return syncService;
+}

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

@@ -0,0 +1,11 @@
+import type { SubscriptionInitConfig } from "../SubscriptionInitializerTypes";
+import { getApiKey, validateConfig } from "./ConfigValidator";
+import { configureServices } from "./ServiceConfigurator";
+import { startBackgroundInitialization } from "./BackgroundInitializer";
+
+export const initializeSubscription = async (config: SubscriptionInitConfig): Promise<void> => {
+  const apiKey = getApiKey(config);
+  validateConfig(config);
+  configureServices(config, apiKey);
+  await startBackgroundInitialization(config);
+};

package/src/domains/subscription/application/initializer/index.ts

@@ -0,0 +1,2 @@
+export { initializeSubscription } from "./SubscriptionInitializer";
+export type { FirebaseAuthLike, CreditPackageConfig, SubscriptionInitConfig } from "../SubscriptionInitializerTypes";

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

@@ -1,19 +1,13 @@
-/**
- * Package Handler
- * Handles operations: fetch, purchase, restore
- */
-
 import type { PurchasesPackage, CustomerInfo } from "react-native-purchases";
 import type { IRevenueCatService } from "../../../../shared/application/ports/IRevenueCatService";
-import { getPremiumEntitlement } from "../../../revenuecat/core/types";
-import { PurchaseStatusResolver, type PremiumStatus } from "./PurchaseStatusResolver";
-
-declare const __DEV__: boolean;
-
-export interface RestoreResultInfo {
-  success: boolean;
-  productId: string | null;
-}
+import type { PremiumStatus } from "./PurchaseStatusResolver";
+import {
+  fetchPackages,
+  executePurchase,
+  restorePurchases,
+  checkPremiumStatus,
+  type RestoreResultInfo,
+} from "./package-operations";
 
 export class PackageHandler {
   constructor(
@@ -26,95 +20,20 @@ export class PackageHandler {
   }
 
   async fetchPackages(): Promise<PurchasesPackage[]> {
-    if (!this.service.isInitialized()) {
-      throw new Error("Service not initialized. Please initialize before fetching packages.");
-    }
-
-    try {
-      const offering = await this.service.fetchOfferings();
-
-      if (__DEV__) {
-        console.log('[PackageHandler] fetchOfferings result:', {
-          hasOffering: !!offering,
-          offeringId: offering?.identifier,
-          packagesCount: offering?.availablePackages?.length,
-        });
-      }
-
-      if (!offering) {
-        if (__DEV__) {
-          console.warn('[PackageHandler] No offering returned, returning empty array');
-        }
-        return [];
-      }
-
-      const packages = offering.availablePackages;
-      if (!packages || packages.length === 0) {
-        if (__DEV__) {
-          console.warn('[PackageHandler] Offering has no packages, returning empty array');
-        }
-        return [];
-      }
-
-      if (__DEV__) {
-        console.log('[PackageHandler] Returning packages:', {
-          count: packages.length,
-          packageIds: packages.map(p => p.product.identifier),
-        });
-      }
-
-      return packages;
-    } catch (error) {
-      if (__DEV__) {
-        console.error('[PackageHandler] Error fetching packages:', error);
-      }
-      throw new Error(
-        `Failed to fetch subscription packages. ${
-          error instanceof Error ? error.message : "Unknown error"
-        }`
-      );
-    }
+    return fetchPackages(this.service);
   }
 
   async purchase(pkg: PurchasesPackage, userId: string): Promise<boolean> {
-    if (!this.service.isInitialized()) {
-      throw new Error("Service not initialized");
-    }
-
-    const result = await this.service.purchasePackage(pkg, userId);
-    return result.success;
+    return executePurchase(this.service, pkg, userId);
   }
 
   async restore(userId: string): Promise<RestoreResultInfo> {
-    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,
-    };
+    return restorePurchases(this.service, userId, this.entitlementId);
   }
 
   checkPremiumStatusFromInfo(customerInfo: CustomerInfo): PremiumStatus {
-    return PurchaseStatusResolver.resolve(customerInfo, this.entitlementId);
+    return checkPremiumStatus(customerInfo, this.entitlementId);
   }
 }
 
-export type { PremiumStatus };
+export type { PremiumStatus, RestoreResultInfo };

package/src/domains/subscription/infrastructure/handlers/package-operations/PackageFetcher.ts

@@ -0,0 +1,57 @@
+import type { PurchasesPackage } from "react-native-purchases";
+import type { IRevenueCatService } from "../../../../../shared/application/ports/IRevenueCatService";
+
+declare const __DEV__: boolean;
+
+export async function fetchPackages(
+  service: IRevenueCatService
+): Promise<PurchasesPackage[]> {
+  if (!service.isInitialized()) {
+    throw new Error("Service not initialized. Please initialize before fetching packages.");
+  }
+
+  try {
+    const offering = await service.fetchOfferings();
+
+    if (__DEV__) {
+      console.log('[PackageHandler] fetchOfferings result:', {
+        hasOffering: !!offering,
+        offeringId: offering?.identifier,
+        packagesCount: offering?.availablePackages?.length,
+      });
+    }
+
+    if (!offering) {
+      if (__DEV__) {
+        console.warn('[PackageHandler] No offering returned, returning empty array');
+      }
+      return [];
+    }
+
+    const packages = offering.availablePackages;
+    if (!packages || packages.length === 0) {
+      if (__DEV__) {
+        console.warn('[PackageHandler] Offering has no packages, returning empty array');
+      }
+      return [];
+    }
+
+    if (__DEV__) {
+      console.log('[PackageHandler] Returning packages:', {
+        count: packages.length,
+        packageIds: packages.map(p => p.product.identifier),
+      });
+    }
+
+    return packages;
+  } catch (error) {
+    if (__DEV__) {
+      console.error('[PackageHandler] Error fetching packages:', error);
+    }
+    throw new Error(
+      `Failed to fetch subscription packages. ${
+        error instanceof Error ? error.message : "Unknown error"
+      }`
+    );
+  }
+}

package/src/domains/subscription/infrastructure/handlers/package-operations/PackagePurchaser.ts

@@ -0,0 +1,15 @@
+import type { PurchasesPackage } from "react-native-purchases";
+import type { IRevenueCatService } from "../../../../../shared/application/ports/IRevenueCatService";
+
+export async function executePurchase(
+  service: IRevenueCatService,
+  pkg: PurchasesPackage,
+  userId: string
+): Promise<boolean> {
+  if (!service.isInitialized()) {
+    throw new Error("Service not initialized");
+  }
+
+  const result = await service.purchasePackage(pkg, userId);
+  return result.success;
+}

package/src/domains/subscription/infrastructure/handlers/package-operations/PackageRestorer.ts

@@ -0,0 +1,34 @@
+import type { IRevenueCatService } from "../../../../../shared/application/ports/IRevenueCatService";
+import { getPremiumEntitlement } from "../../../../revenuecat/core/types";
+import type { RestoreResultInfo } from "./types";
+
+export async function restorePurchases(
+  service: IRevenueCatService,
+  userId: string,
+  entitlementId: string
+): Promise<RestoreResultInfo> {
+  if (!service.isInitialized()) {
+    throw new Error("Service not initialized");
+  }
+
+  const result = await service.restorePurchases(userId);
+
+  if (!result.success) {
+    return { success: false, productId: null };
+  }
+
+  if (!result.customerInfo) {
+    return { success: true, productId: null };
+  }
+
+  const entitlement = getPremiumEntitlement(result.customerInfo, entitlementId);
+
+  if (!entitlement) {
+    return { success: true, productId: null };
+  }
+
+  return {
+    success: true,
+    productId: entitlement.productIdentifier,
+  };
+}

package/src/domains/subscription/infrastructure/handlers/package-operations/PremiumStatusChecker.ts

@@ -0,0 +1,9 @@
+import type { CustomerInfo } from "react-native-purchases";
+import { PurchaseStatusResolver, type PremiumStatus } from "../PurchaseStatusResolver";
+
+export function checkPremiumStatus(
+  customerInfo: CustomerInfo,
+  entitlementId: string
+): PremiumStatus {
+  return PurchaseStatusResolver.resolve(customerInfo, entitlementId);
+}

package/src/domains/subscription/infrastructure/handlers/package-operations/index.ts

@@ -0,0 +1,5 @@
+export type { RestoreResultInfo } from "./types";
+export { fetchPackages } from "./PackageFetcher";
+export { executePurchase } from "./PackagePurchaser";
+export { restorePurchases } from "./PackageRestorer";
+export { checkPremiumStatus } from "./PremiumStatusChecker";

package/src/domains/subscription/infrastructure/handlers/package-operations/types.ts

@@ -0,0 +1,4 @@
+export interface RestoreResultInfo {
+  success: boolean;
+  productId: string | null;
+}

package/src/domains/subscription/infrastructure/hooks/customer-info/index.ts

@@ -0,0 +1,2 @@
+export { useCustomerInfo } from "./useCustomerInfo";
+export type { UseCustomerInfoResult } from "./types";

package/src/domains/subscription/infrastructure/hooks/customer-info/types.ts

@@ -0,0 +1,9 @@
+import type { CustomerInfo } from "react-native-purchases";
+
+export interface UseCustomerInfoResult {
+  customerInfo: CustomerInfo | null;
+  loading: boolean;
+  error: string | null;
+  refetch: () => Promise<void>;
+  isFetching: boolean;
+}

package/src/domains/subscription/infrastructure/hooks/customer-info/useCustomerInfo.ts

@@ -0,0 +1,57 @@
+import { useEffect, useState, useCallback, useRef } from "react";
+import Purchases, { type CustomerInfo } from "react-native-purchases";
+import type { UseCustomerInfoResult } from "./types";
+
+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);
+
+      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);
+    };
+
+    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/services/listeners/CustomerInfoHandler.ts

@@ -1,7 +1,7 @@
 import type { CustomerInfo } from "react-native-purchases";
 import type { RevenueCatConfig } from "../../../../revenuecat/core/types";
 import { syncPremiumStatus } from "../../utils/PremiumStatusSyncer";
-import { detectRenewal, updateRenewalState, type RenewalState } from "../../utils/RenewalDetector";
+import { detectRenewal, updateRenewalState, type RenewalState } from "../../utils/renewal";
 
 async function handleRenewal(
   userId: string,

package/src/domains/subscription/infrastructure/services/listeners/ListenerState.ts

@@ -1,5 +1,5 @@
 import type { CustomerInfoUpdateListener } from "react-native-purchases";
-import type { RenewalState } from "../../utils/RenewalDetector";
+import type { RenewalState } from "../../utils/renewal";
 
 export class ListenerState {
   listener: CustomerInfoUpdateListener | null = null;

package/src/domains/subscription/infrastructure/services/purchase/PurchaseErrorHandler.ts

@@ -7,7 +7,6 @@ import {
 import {
   isUserCancelledError,
   isNetworkError,
-  isAlreadyPurchasedError,
   isInvalidCredentialsError,
   getRawErrorMessage,
   getErrorCode,

package/src/domains/subscription/infrastructure/utils/renewal/PackageTierComparator.ts

@@ -0,0 +1,14 @@
+import { detectPackageType } from "../../../../../utils/packageTypeDetector";
+
+const PACKAGE_TIER_ORDER: Record<string, number> = {
+  weekly: 1,
+  monthly: 2,
+  yearly: 3,
+  unknown: 0,
+};
+
+export function getPackageTier(productId: string | null): number {
+  if (!productId) return 0;
+  const packageType = detectPackageType(productId);
+  return PACKAGE_TIER_ORDER[packageType] ?? 0;
+}