@umituz/react-native-subscription 2.26.15 → 2.26.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.26.15",
+  "version": "2.26.17",
   "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/presentation/hooks/index.ts

@@ -1,3 +1,4 @@
+export * from "./useAuthAwarePurchase";
 export * from "./useAuthSubscriptionSync";
 export * from "./useSavedPurchaseAutoExecution";
 export * from "./useCredits";
@@ -6,5 +7,6 @@ export * from "./useFeatureGate";
 export * from "./usePaywallVisibility";
 export * from "./usePremium";
 export * from "./useSubscriptionSettingsConfig";
+export * from "./useSubscriptionStatus";
 export * from "./feedback/usePaywallFeedback";
 export * from "./feedback/useFeedbackSubmit";

package/src/presentation/hooks/useAuthAwarePurchase.ts

@@ -0,0 +1,138 @@
+/**
+ * Auth-Aware Purchase Hook
+ * Handles purchase flow with authentication requirement
+ */
+
+import { useCallback } from "react";
+import type { PurchasesPackage } from "react-native-purchases";
+import { usePremium } from "./usePremium";
+import type { PurchaseSource } from "../../domain/entities/Credits";
+
+declare const __DEV__: boolean;
+
+export interface PurchaseAuthProvider {
+  isAuthenticated: () => boolean;
+  showAuthModal: () => void;
+}
+
+let globalAuthProvider: PurchaseAuthProvider | null = null;
+let savedPackage: PurchasesPackage | null = null;
+let savedSource: PurchaseSource | null = null;
+
+export const configureAuthProvider = (provider: PurchaseAuthProvider): void => {
+  globalAuthProvider = provider;
+};
+
+export const getSavedPurchase = (): { pkg: PurchasesPackage; source: PurchaseSource } | null => {
+  if (savedPackage && savedSource) {
+    return { pkg: savedPackage, source: savedSource };
+  }
+  return null;
+};
+
+export const clearSavedPurchase = (): void => {
+  savedPackage = null;
+  savedSource = null;
+};
+
+export interface UseAuthAwarePurchaseParams {
+  source?: PurchaseSource;
+  userId?: string;
+}
+
+export interface UseAuthAwarePurchaseResult {
+  handlePurchase: (pkg: PurchasesPackage, source?: PurchaseSource) => Promise<boolean>;
+  handleRestore: () => Promise<boolean>;
+  executeSavedPurchase: () => Promise<boolean>;
+}
+
+export const useAuthAwarePurchase = (
+  params?: UseAuthAwarePurchaseParams
+): UseAuthAwarePurchaseResult => {
+  const { purchasePackage, restorePurchase } = usePremium(params?.userId);
+
+  const handlePurchase = useCallback(
+    async (pkg: PurchasesPackage, source?: PurchaseSource): Promise<boolean> => {
+      if (__DEV__) {
+        console.log("[useAuthAwarePurchase] handlePurchase called:", {
+          productId: pkg.product.identifier,
+          hasAuthProvider: !!globalAuthProvider,
+        });
+      }
+
+      if (!globalAuthProvider) {
+        if (__DEV__) {
+          console.error("[useAuthAwarePurchase] Auth provider not configured");
+        }
+        return false;
+      }
+
+      const isAuth = globalAuthProvider.isAuthenticated();
+      if (__DEV__) {
+        console.log("[useAuthAwarePurchase] Auth check:", { isAuthenticated: isAuth });
+      }
+
+      if (!isAuth) {
+        if (__DEV__) {
+          console.log("[useAuthAwarePurchase] Not authenticated, saving and showing auth");
+        }
+        savedPackage = pkg;
+        savedSource = source || params?.source || "settings";
+        globalAuthProvider.showAuthModal();
+        return false;
+      }
+
+      if (__DEV__) {
+        console.log("[useAuthAwarePurchase] Calling purchasePackage");
+      }
+      const result = await purchasePackage(pkg);
+      if (__DEV__) {
+        console.log("[useAuthAwarePurchase] purchasePackage returned:", result);
+      }
+      return result;
+    },
+    [purchasePackage, params?.source]
+  );
+
+  const handleRestore = useCallback(async (): Promise<boolean> => {
+    if (!globalAuthProvider) {
+      if (__DEV__) {
+        console.error("[useAuthAwarePurchase] Auth provider not configured");
+      }
+      return false;
+    }
+
+    if (!globalAuthProvider.isAuthenticated()) {
+      if (__DEV__) {
+        console.log("[useAuthAwarePurchase] Not authenticated for restore");
+      }
+      globalAuthProvider.showAuthModal();
+      return false;
+    }
+
+    return restorePurchase();
+  }, [restorePurchase]);
+
+  const executeSavedPurchase = useCallback(async (): Promise<boolean> => {
+    const saved = getSavedPurchase();
+    if (!saved) {
+      if (__DEV__) {
+        console.log("[useAuthAwarePurchase] No saved purchase to execute");
+      }
+      return false;
+    }
+
+    if (__DEV__) {
+      console.log("[useAuthAwarePurchase] Executing saved purchase:", saved.pkg.product.identifier);
+    }
+
+    clearSavedPurchase();
+    return purchasePackage(saved.pkg);
+  }, [purchasePackage]);
+
+  return {
+    handlePurchase,
+    handleRestore,
+    executeSavedPurchase,
+  };
+};

package/src/presentation/hooks/useSubscriptionStatus.ts

@@ -0,0 +1,64 @@
+/**
+ * useSubscriptionStatus Hook
+ *
+ * TanStack Query hook for checking real subscription status from RevenueCat.
+ * This provides the actual premium status based on entitlements, not credits.
+ */
+
+import { useQuery } from "@umituz/react-native-design-system";
+import { SubscriptionManager } from "../../revenuecat/infrastructure/managers/SubscriptionManager";
+
+export const subscriptionStatusQueryKeys = {
+  all: ["subscriptionStatus"] as const,
+  user: (userId: string) => ["subscriptionStatus", userId] as const,
+};
+
+export interface SubscriptionStatusResult {
+  isPremium: boolean;
+  expirationDate: Date | null;
+  isLoading: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+
+export interface UseSubscriptionStatusParams {
+  userId: string | undefined;
+  enabled?: boolean;
+}
+
+/**
+ * Check real subscription status from RevenueCat
+ *
+ * @param userId - User ID
+ * @param enabled - Whether to enable the query
+ * @returns Subscription status with isPremium flag
+ */
+export const useSubscriptionStatus = ({
+  userId,
+  enabled = true,
+}: UseSubscriptionStatusParams): SubscriptionStatusResult => {
+  const { data, isLoading, error, refetch } = useQuery({
+    queryKey: subscriptionStatusQueryKeys.user(userId ?? ""),
+    queryFn: async () => {
+      if (!userId) {
+        return { isPremium: false, expirationDate: null };
+      }
+
+      return SubscriptionManager.checkPremiumStatus();
+    },
+    enabled: enabled && !!userId && SubscriptionManager.isInitializedForUser(userId),
+    staleTime: 0, // No cache - always fetch fresh premium status
+    gcTime: 0, // Don't cache - garbage collect immediately
+    refetchOnMount: true,
+    refetchOnWindowFocus: true,
+    refetchOnReconnect: true,
+  });
+
+  return {
+    isPremium: data?.isPremium ?? false,
+    expirationDate: data?.expirationDate ?? null,
+    isLoading,
+    error: error as Error | null,
+    refetch,
+  };
+};

package/src/revenuecat/presentation/hooks/useRevenueCatTrialEligibility.ts

@@ -97,7 +97,7 @@ export function useRevenueCatTrialEligibility(): UseRevenueCatTrialEligibilityRe
 
     try {
       const eligibilities: Record<string, IntroEligibility> =
-        await Purchases.checkTrialOrIntroDiscountEligibility(productIds);
+        await Purchases.checkTrialOrIntroductoryPriceEligibility(productIds);
 
       const newMap: TrialEligibilityMap = {};