@umituz/react-native-subscription 2.9.6 → 2.10.0

package/package.json

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

@@ -239,6 +239,22 @@ export {
   type UseCreditCheckerResult,
 } from "./presentation/hooks/useCreditChecker";
 
+export {
+  usePaywallVisibility,
+  type UsePaywallVisibilityResult,
+} from "./presentation/hooks/usePaywallVisibility";
+
+export {
+  usePremiumWithConfig,
+  type UsePremiumWithConfigParams,
+  type UsePremiumWithConfigResult,
+} from "./presentation/hooks/usePremiumWithConfig";
+
+export {
+  useAuthSubscriptionSync,
+  type AuthSubscriptionSyncConfig,
+} from "./presentation/hooks/useAuthSubscriptionSync";
+
 // =============================================================================
 // CREDITS SYSTEM - Utilities
 // =============================================================================
@@ -250,6 +266,12 @@ export {
   type CreditChecker,
 } from "./utils/creditChecker";
 
+export {
+  createAICreditHelpers,
+  type AICreditHelpersConfig,
+  type AICreditHelpers,
+} from "./utils/aiCreditHelpers";
+
 // =============================================================================
 // REVENUECAT - Errors
 // =============================================================================

package/src/presentation/hooks/useAuthSubscriptionSync.ts

@@ -0,0 +1,56 @@
+/**
+ * useAuthSubscriptionSync Hook
+ * Single source of truth for RevenueCat initialization
+ * Handles initial setup and auth state transitions
+ * Generic implementation for 100+ apps with auth provider abstraction
+ */
+
+import { useEffect, useRef, useCallback } from "react";
+
+export interface AuthSubscriptionSyncConfig {
+  /** Function to subscribe to auth state changes - returns unsubscribe function */
+  onAuthStateChanged: (callback: (userId: string | null) => void) => () => void;
+  /** Function to initialize subscription for a user */
+  initializeSubscription: (userId: string) => Promise<void>;
+}
+
+export function useAuthSubscriptionSync(
+  config: AuthSubscriptionSyncConfig,
+): void {
+  const { onAuthStateChanged, initializeSubscription } = config;
+  const previousUserIdRef = useRef<string | null>(null);
+  const isInitializedRef = useRef(false);
+
+  const initialize = useCallback(
+    async (userId: string) => {
+      await initializeSubscription(userId);
+    },
+    [initializeSubscription],
+  );
+
+  useEffect(() => {
+    const unsubscribe = onAuthStateChanged(async (userId: string | null) => {
+      if (!userId) {
+        previousUserIdRef.current = null;
+        return;
+      }
+
+      const previousUserId = previousUserIdRef.current;
+
+      if (userId === previousUserId) {
+        return;
+      }
+
+      if (previousUserId && previousUserId !== userId) {
+        await initialize(userId);
+      } else if (!isInitializedRef.current) {
+        await initialize(userId);
+        isInitializedRef.current = true;
+      }
+
+      previousUserIdRef.current = userId;
+    });
+
+    return () => unsubscribe();
+  }, [onAuthStateChanged, initialize]);
+}

package/src/presentation/hooks/usePaywallVisibility.ts

@@ -0,0 +1,54 @@
+/**
+ * Paywall Visibility Hook
+ * Simple global state for paywall visibility using module-level state
+ * Generic implementation for 100+ apps
+ */
+
+import { useCallback, useSyncExternalStore } from "react";
+
+type Listener = () => void;
+
+let paywallVisible = false;
+const listeners = new Set<Listener>();
+
+const subscribe = (listener: Listener): (() => void) => {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+};
+
+const getSnapshot = (): boolean => paywallVisible;
+
+const setPaywallVisible = (visible: boolean): void => {
+  paywallVisible = visible;
+  listeners.forEach((listener) => listener());
+};
+
+export interface UsePaywallVisibilityResult {
+  showPaywall: boolean;
+  setShowPaywall: (visible: boolean) => void;
+  openPaywall: () => void;
+  closePaywall: () => void;
+}
+
+export function usePaywallVisibility(): UsePaywallVisibilityResult {
+  const showPaywall = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+
+  const setShowPaywall = useCallback((visible: boolean) => {
+    setPaywallVisible(visible);
+  }, []);
+
+  const openPaywall = useCallback(() => {
+    setPaywallVisible(true);
+  }, []);
+
+  const closePaywall = useCallback(() => {
+    setPaywallVisible(false);
+  }, []);
+
+  return {
+    showPaywall,
+    setShowPaywall,
+    openPaywall,
+    closePaywall,
+  };
+}

package/src/presentation/hooks/usePremiumWithConfig.ts

@@ -0,0 +1,97 @@
+/**
+ * usePremiumWithConfig Hook
+ * Premium status from TanStack Query (credits)
+ * Subscription state from TanStack Query
+ * Generic implementation for 100+ apps with auth provider abstraction
+ */
+
+import { useCallback } from "react";
+import type { PurchasesPackage } from "react-native-purchases";
+import { useCredits } from "./useCredits";
+import { useInitializeCredits } from "./useDeductCredit";
+import {
+  useSubscriptionPackages,
+  usePurchasePackage,
+  useRestorePurchase,
+} from "../../revenuecat/presentation/hooks/useSubscriptionQueries";
+import { usePaywallVisibility } from "./usePaywallVisibility";
+
+export interface UsePremiumWithConfigParams {
+  /** Function to get current user ID (can be from Firebase, Supabase, etc.) */
+  getUserId: () => string | null | undefined;
+  /** Enable/disable credits query */
+  enabled?: boolean;
+}
+
+export interface UsePremiumWithConfigResult {
+  isPremium: boolean;
+  isLoading: boolean;
+  packages: PurchasesPackage[];
+  credits: any; // UserCredits from subscription package
+  showPaywall: boolean;
+  purchasePackage: (pkg: PurchasesPackage) => Promise<boolean>;
+  restorePurchase: () => Promise<boolean>;
+  setShowPaywall: (show: boolean) => void;
+  closePaywall: () => void;
+  openPaywall: () => void;
+}
+
+export const usePremiumWithConfig = (
+  params: UsePremiumWithConfigParams,
+): UsePremiumWithConfigResult => {
+  const { getUserId, enabled = true } = params;
+  const userId = getUserId();
+
+  const { credits, isLoading: creditsLoading } = useCredits({
+    userId,
+    enabled: enabled && !!userId,
+  });
+
+  const { initializeCredits } = useInitializeCredits({ userId });
+
+  const { data: packages = [], isLoading: packagesLoading } =
+    useSubscriptionPackages(userId);
+  const purchaseMutation = usePurchasePackage(userId);
+  const restoreMutation = useRestorePurchase(userId);
+
+  const { showPaywall, setShowPaywall, closePaywall, openPaywall } =
+    usePaywallVisibility();
+
+  const isPremium = credits !== null;
+
+  const handlePurchase = useCallback(
+    async (pkg: PurchasesPackage): Promise<boolean> => {
+      const success = await purchaseMutation.mutateAsync(pkg);
+      if (success && userId) {
+        await initializeCredits();
+      }
+      return success;
+    },
+    [purchaseMutation, userId, initializeCredits],
+  );
+
+  const handleRestore = useCallback(async (): Promise<boolean> => {
+    const success = await restoreMutation.mutateAsync();
+    if (success && userId) {
+      await initializeCredits();
+    }
+    return success;
+  }, [restoreMutation, userId, initializeCredits]);
+
+  return {
+    isPremium,
+    isLoading:
+      creditsLoading ||
+      packagesLoading ||
+      purchaseMutation.isPending ||
+      restoreMutation.isPending,
+    packages,
+    credits,
+    showPaywall,
+    purchasePackage: handlePurchase,
+    restorePurchase: handleRestore,
+    setShowPaywall,
+    closePaywall,
+    openPaywall,
+  };
+};

package/src/utils/aiCreditHelpers.ts

@@ -0,0 +1,114 @@
+/**
+ * AI Credit Helpers
+ *
+ * Common patterns for AI generation apps to handle credits.
+ * Provides ready-to-use functions for credit checking and deduction.
+ *
+ * Usage:
+ *   import { createAICreditHelpers } from '@umituz/react-native-subscription';
+ *
+ *   const helpers = createAICreditHelpers({
+ *     repository,
+ *     imageGenerationTypes: ['future_image', 'santa_transform'],
+ *     onCreditDeducted: (userId) => invalidateCache(userId)
+ *   });
+ */
+
+import type { CreditType } from "../domain/entities/Credits";
+import type { CreditsRepository } from "../infrastructure/repositories/CreditsRepository";
+import { createCreditChecker } from "./creditChecker";
+
+export interface AICreditHelpersConfig {
+  /**
+   * Credits repository instance
+   */
+  repository: CreditsRepository;
+
+  /**
+   * List of operation types that should use "image" credits.
+   * All other types will use "text" credits.
+   * @example ['future_image', 'santa_transform', 'photo_generation']
+   */
+  imageGenerationTypes: string[];
+
+  /**
+   * Optional callback called after successful credit deduction.
+   * Use this to invalidate TanStack Query cache or trigger UI updates.
+   */
+  onCreditDeducted?: (userId: string, creditType: CreditType) => void;
+}
+
+export interface AICreditHelpers {
+  /**
+   * Check if user has credits for a specific generation type
+   * @param userId - User ID
+   * @param generationType - Type of generation (e.g., 'future_image', 'text_summary')
+   * @returns boolean indicating if credits are available
+   */
+  checkCreditsForGeneration: (
+    userId: string | undefined,
+    generationType: string
+  ) => Promise<boolean>;
+
+  /**
+   * Deduct credits after successful generation
+   * @param userId - User ID
+   * @param generationType - Type of generation that was performed
+   */
+  deductCreditsForGeneration: (
+    userId: string | undefined,
+    generationType: string
+  ) => Promise<void>;
+
+  /**
+   * Get credit type for a generation type (useful for UI display)
+   * @param generationType - Type of generation
+   * @returns "image" or "text"
+   */
+  getCreditType: (generationType: string) => CreditType;
+}
+
+/**
+ * Creates AI-specific credit helper functions
+ */
+export function createAICreditHelpers(
+  config: AICreditHelpersConfig
+): AICreditHelpers {
+  const { repository, imageGenerationTypes, onCreditDeducted } = config;
+
+  // Map generation type to credit type
+  const getCreditType = (generationType: string): CreditType => {
+    return imageGenerationTypes.includes(generationType) ? "image" : "text";
+  };
+
+  // Create credit checker with the mapping
+  const checker = createCreditChecker({
+    repository,
+    getCreditType,
+    onCreditDeducted,
+  });
+
+  // Check if credits are available for generation
+  const checkCreditsForGeneration = async (
+    userId: string | undefined,
+    generationType: string
+  ): Promise<boolean> => {
+    const result = await checker.checkCreditsAvailable(userId, generationType);
+    return result.success;
+  };
+
+  // Deduct credits after successful generation
+  const deductCreditsForGeneration = async (
+    userId: string | undefined,
+    generationType: string
+  ): Promise<void> => {
+    const creditType = getCreditType(generationType);
+    await checker.deductCreditsAfterSuccess(userId, creditType);
+  };
+
+  return {
+    checkCreditsForGeneration,
+    deductCreditsForGeneration,
+    getCreditType,
+  };
+}