@umituz/react-native-subscription 2.14.82 → 2.14.84

package/src/presentation/hooks/useDeductCredit.ts

@@ -1,8 +1,6 @@
 /**
  * useDeductCredit Hook
- *
  * TanStack Query mutation hook for deducting credits.
- * Generic and reusable - uses module-level repository.
  */
 
 import { useCallback } from "react";
@@ -17,9 +15,7 @@ export interface UseDeductCreditParams {
 }
 
 export interface UseDeductCreditResult {
-  /** Deduct a single credit */
   deductCredit: (creditType: CreditType) => Promise<boolean>;
-  /** Deduct multiple credits (loops internally) */
   deductCredits: (cost: number, creditType?: CreditType) => Promise<boolean>;
   isDeducting: boolean;
 }
@@ -33,169 +29,47 @@ export const useDeductCredit = ({
 
   const mutation = useMutation({
     mutationFn: async (creditType: CreditType) => {
-      if (!userId) {
-        throw new Error("User not authenticated");
-      }
+      if (!userId) throw new Error("User not authenticated");
       return repository.deductCredit(userId, creditType);
     },
     onMutate: async (creditType: CreditType) => {
       if (!userId) return;
-
-      await queryClient.cancelQueries({
-        queryKey: creditsQueryKeys.user(userId),
+      await queryClient.cancelQueries({ queryKey: creditsQueryKeys.user(userId) });
+      const previousCredits = queryClient.getQueryData<UserCredits>(creditsQueryKeys.user(userId));
+      queryClient.setQueryData<UserCredits | null>(creditsQueryKeys.user(userId), (old) => {
+        if (!old) return old;
+        const field = creditType === "text" ? "textCredits" : "imageCredits";
+        return { ...old, [field]: Math.max(0, old[field] - 1), lastUpdatedAt: new Date() };
       });
-
-      const previousCredits = queryClient.getQueryData<UserCredits>(
-        creditsQueryKeys.user(userId)
-      );
-
-      queryClient.setQueryData<UserCredits | null>(
-        creditsQueryKeys.user(userId),
-        (old) => {
-          if (!old) return old;
-          const fieldName =
-            creditType === "text" ? "textCredits" : "imageCredits";
-          return {
-            ...old,
-            [fieldName]: Math.max(0, old[fieldName] - 1),
-            lastUpdatedAt: new Date(),
-          };
-        }
-      );
-
       return { previousCredits };
     },
-    onError: (_err, _creditType, context) => {
+    onError: (_err, _type, context) => {
       if (userId && context?.previousCredits) {
-        queryClient.setQueryData(
-          creditsQueryKeys.user(userId),
-          context.previousCredits
-        );
+        queryClient.setQueryData(creditsQueryKeys.user(userId), context.previousCredits);
       }
     },
     onSettled: () => {
-      if (userId) {
-        queryClient.invalidateQueries({
-          queryKey: creditsQueryKeys.user(userId),
-        });
-      }
+      if (userId) queryClient.invalidateQueries({ queryKey: creditsQueryKeys.user(userId) });
     },
   });
 
-  const deductCredit = useCallback(async (creditType: CreditType): Promise<boolean> => {
+  const deductCredit = useCallback(async (type: CreditType): Promise<boolean> => {
     try {
-      const result = await mutation.mutateAsync(creditType);
-
-      if (!result.success) {
-        if (result.error?.code === "CREDITS_EXHAUSTED") {
-          onCreditsExhausted?.();
-        }
+      const res = await mutation.mutateAsync(type);
+      if (!res.success) {
+        if (res.error?.code === "CREDITS_EXHAUSTED") onCreditsExhausted?.();
         return false;
       }
-
       return true;
-    } catch {
-      return false;
-    }
+    } catch { return false; }
   }, [mutation, onCreditsExhausted]);
 
-  /**
-   * Deduct multiple credits at once
-   * Loops internally to deduct `cost` credits of the specified type
-   */
-  const deductCredits = useCallback(
-    async (cost: number, creditType: CreditType = "image"): Promise<boolean> => {
-      for (let i = 0; i < cost; i++) {
-        const success = await deductCredit(creditType);
-        if (!success) return false;
-      }
-      return true;
-    },
-    [deductCredit],
-  );
-
-  return {
-    deductCredit,
-    deductCredits,
-    isDeducting: mutation.isPending,
-  };
-};
-
-export interface UseInitializeCreditsParams {
-  userId: string | undefined;
-}
-
-export interface InitializeCreditsOptions {
-  purchaseId?: string;
-  productId?: string;
-}
-
-export interface UseInitializeCreditsResult {
-  initializeCredits: (options?: InitializeCreditsOptions) => Promise<boolean>;
-  isInitializing: boolean;
-}
-
-export const useInitializeCredits = ({
-  userId,
-}: UseInitializeCreditsParams): UseInitializeCreditsResult => {
-  const repository = getCreditsRepository();
-  const queryClient = useQueryClient();
-
-  const mutation = useMutation({
-    mutationFn: async (options?: InitializeCreditsOptions) => {
-      if (!userId) {
-        throw new Error("User not authenticated");
-      }
-
-      if (__DEV__) {
-        console.log("[useInitializeCredits] Initializing credits:", {
-          userId,
-          purchaseId: options?.purchaseId,
-          productId: options?.productId,
-        });
-      }
-
-      return repository.initializeCredits(
-        userId,
-        options?.purchaseId,
-        options?.productId
-      );
-    },
-    onSuccess: (result) => {
-      if (userId && result.success && result.data) {
-        if (__DEV__) {
-          console.log("[useInitializeCredits] Success, updating cache:", result.data);
-        }
-
-        // Set the data immediately for optimistic UI
-        queryClient.setQueryData(creditsQueryKeys.user(userId), result.data);
-        // Also invalidate to ensure all subscribers get the update
-        queryClient.invalidateQueries({
-          queryKey: creditsQueryKeys.user(userId),
-        });
-      }
-    },
-    onError: (error) => {
-      if (__DEV__) {
-        console.error("[useInitializeCredits] Error:", error);
-      }
-    },
-  });
-
-  const initializeCredits = useCallback(
-    async (options?: InitializeCreditsOptions): Promise<boolean> => {
-      try {
-        const result = await mutation.mutateAsync(options);
-        return result.success;
-      } catch {
-        return false;
-      }
-    },
-    [mutation]
-  );
+  const deductCredits = useCallback(async (cost: number, type: CreditType = "image"): Promise<boolean> => {
+    for (let i = 0; i < cost; i++) {
+      if (!(await deductCredit(type))) return false;
+    }
+    return true;
+  }, [deductCredit]);
 
-  return {
-    initializeCredits,
-    isInitializing: mutation.isPending,
-  };
+  return { deductCredit, deductCredits, isDeducting: mutation.isPending };
 };

package/src/presentation/hooks/useInitializeCredits.ts

@@ -0,0 +1,57 @@
+/**
+ * useInitializeCredits Hook
+ * TanStack Query mutation hook for initializing credits after purchase.
+ */
+
+import { useCallback } from "react";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { getCreditsRepository } from "../../infrastructure/repositories/CreditsRepositoryProvider";
+import { creditsQueryKeys } from "./useCredits";
+
+declare const __DEV__: boolean;
+
+export interface UseInitializeCreditsParams {
+  userId: string | undefined;
+}
+
+export interface InitializeCreditsOptions {
+  purchaseId?: string;
+  productId?: string;
+}
+
+export interface UseInitializeCreditsResult {
+  initializeCredits: (options?: InitializeCreditsOptions) => Promise<boolean>;
+  isInitializing: boolean;
+}
+
+export const useInitializeCredits = ({
+  userId,
+}: UseInitializeCreditsParams): UseInitializeCreditsResult => {
+  const repository = getCreditsRepository();
+  const queryClient = useQueryClient();
+
+  const mutation = useMutation({
+    mutationFn: async (options?: InitializeCreditsOptions) => {
+      if (!userId) throw new Error("User not authenticated");
+      if (__DEV__) console.log("[useInitializeCredits] Initializing:", { userId, ...options });
+      return repository.initializeCredits(userId, options?.purchaseId, options?.productId);
+    },
+    onSuccess: (result) => {
+      if (userId && result.success && result.data) {
+        if (__DEV__) console.log("[useInitializeCredits] Success:", result.data);
+        queryClient.setQueryData(creditsQueryKeys.user(userId), result.data);
+        queryClient.invalidateQueries({ queryKey: creditsQueryKeys.user(userId) });
+      }
+    },
+    onError: (error) => { if (__DEV__) console.error("[useInitializeCredits] Error:", error); },
+  });
+
+  const initializeCredits = useCallback(async (opts?: InitializeCreditsOptions): Promise<boolean> => {
+    try {
+      const res = await mutation.mutateAsync(opts);
+      return res.success;
+    } catch { return false; }
+  }, [mutation]);
+
+  return { initializeCredits, isInitializing: mutation.isPending };
+};

package/src/presentation/hooks/usePremiumWithCredits.ts

@@ -7,7 +7,7 @@
 
 import { useEffect, useCallback } from "react";
 import { useCredits, type UseCreditsResult } from "./useCredits";
-import { useInitializeCredits } from "./useDeductCredit";
+import { useInitializeCredits } from "./useInitializeCredits";
 
 export interface UsePremiumWithCreditsParams {
   userId: string | undefined;

package/src/presentation/hooks/useSubscription.ts

@@ -4,9 +4,13 @@
  */
 
 import { useState, useCallback } from 'react';
-import { getSubscriptionService } from '../../infrastructure/services/SubscriptionService';
 import type { SubscriptionStatus } from '../../domain/entities/SubscriptionStatus';
 import { isSubscriptionValid } from '../../domain/entities/SubscriptionStatus';
+import {
+  checkSubscriptionService,
+  validateUserId,
+  executeSubscriptionOperation,
+} from './useSubscription.utils';
 
 export interface UseSubscriptionResult {
   /** Current subscription status */
@@ -45,120 +49,96 @@ export function useSubscription(): UseSubscriptionResult {
   const [error, setError] = useState<string | null>(null);
 
   const loadStatus = useCallback(async (userId: string) => {
-    if (!userId) {
-      setError('User ID is required');
+    const validationError = validateUserId(userId);
+    if (validationError) {
+      setError(validationError);
       return;
     }
 
-    const service = getSubscriptionService();
-    if (!service) {
-      setError('Subscription service is not initialized');
+    const serviceCheck = checkSubscriptionService();
+    if (!serviceCheck.success) {
+      setError(serviceCheck.error || "Service error");
       return;
     }
 
-    setLoading(true);
-    setError(null);
-
-    try {
-      const subscriptionStatus = await service.getSubscriptionStatus(userId);
-      setStatus(subscriptionStatus);
-    } catch (err) {
-      const errorMessage =
-        err instanceof Error ? err.message : 'Failed to load subscription status';
-      setError(errorMessage);
-    } finally {
-      setLoading(false);
-    }
+    await executeSubscriptionOperation(
+      () => serviceCheck.service!.getSubscriptionStatus(userId),
+      setLoading,
+      setError,
+      (result) => setStatus(result)
+    );
   }, []);
 
   const refreshStatus = useCallback(async (userId: string) => {
-    if (!userId) {
-      setError('User ID is required');
+    const validationError = validateUserId(userId);
+    if (validationError) {
+      setError(validationError);
       return;
     }
 
-    const service = getSubscriptionService();
-    if (!service) {
-      setError('Subscription service is not initialized');
+    const serviceCheck = checkSubscriptionService();
+    if (!serviceCheck.success) {
+      setError(serviceCheck.error || "Service error");
       return;
     }
 
-    setLoading(true);
-    setError(null);
-
-    try {
-      const subscriptionStatus = await service.getSubscriptionStatus(userId);
-      setStatus(subscriptionStatus);
-    } catch (err) {
-      const errorMessage =
-        err instanceof Error ? err.message : 'Failed to refresh subscription status';
-      setError(errorMessage);
-    } finally {
-      setLoading(false);
-    }
+    await executeSubscriptionOperation(
+      () => serviceCheck.service!.getSubscriptionStatus(userId),
+      setLoading,
+      setError,
+      (result) => setStatus(result)
+    );
   }, []);
 
   const activateSubscription = useCallback(
     async (userId: string, productId: string, expiresAt: string | null) => {
-      if (!userId || !productId) {
-        setError('User ID and Product ID are required');
+      const validationError = validateUserId(userId);
+      if (validationError) {
+        setError(validationError);
         return;
       }
 
-      const service = getSubscriptionService();
-      if (!service) {
-        setError('Subscription service is not initialized');
+      if (!productId) {
+        setError("Product ID is required");
         return;
       }
 
-      setLoading(true);
-      setError(null);
-
-      try {
-        const updatedStatus = await service.activateSubscription(
-          userId,
-          productId,
-          expiresAt,
-        );
-        setStatus(updatedStatus);
-      } catch (err) {
-        const errorMessage =
-          err instanceof Error ? err.message : 'Failed to activate subscription';
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setLoading(false);
+      const serviceCheck = checkSubscriptionService();
+      if (!serviceCheck.success) {
+        setError(serviceCheck.error || "Service error");
+        return;
       }
+
+      await executeSubscriptionOperation(
+        () =>
+          serviceCheck.service!.activateSubscription(userId, productId, expiresAt),
+        setLoading,
+        setError,
+        (result) => setStatus(result)
+      );
     },
-    [],
+    []
   );
 
   const deactivateSubscription = useCallback(async (userId: string) => {
-    if (!userId) {
-      setError('User ID is required');
+    const validationError = validateUserId(userId);
+    if (validationError) {
+      setError(validationError);
       return;
     }
 
-    const service = getSubscriptionService();
-    if (!service) {
-      setError('Subscription service is not initialized');
+    const serviceCheck = checkSubscriptionService();
+    if (!serviceCheck.success) {
+      setError(serviceCheck.error || "Service error");
       return;
     }
 
-    setLoading(true);
-    setError(null);
-
-    try {
-      const updatedStatus = await service.deactivateSubscription(userId);
-      setStatus(updatedStatus);
-    } catch (err) {
-      const errorMessage =
-        err instanceof Error ? err.message : 'Failed to deactivate subscription';
-      setError(errorMessage);
-      throw err;
-    } finally {
-      setLoading(false);
-    }
+    await executeSubscriptionOperation(
+      () => serviceCheck.service!.deactivateSubscription(userId),
+      setLoading,
+      setError,
+      (result) => setStatus(result)
+    );
   }, []);
 
   const isPremium = isSubscriptionValid(status);

package/src/presentation/hooks/useSubscription.utils.ts

@@ -0,0 +1,78 @@
+/**
+ * useSubscription Utilities
+ * Shared utilities for subscription hook operations
+ */
+
+export type AsyncSubscriptionOperation<T> = () => Promise<T>;
+
+/**
+ * Result of a subscription service initialization check
+ */
+export interface ServiceCheckResult {
+  success: boolean;
+  service: ReturnType<typeof import("../../infrastructure/services/SubscriptionService").getSubscriptionService> | null;
+  error?: string;
+}
+
+/**
+ * Checks if subscription service is initialized
+ * Returns service instance or error
+ */
+export function checkSubscriptionService(): ServiceCheckResult {
+  const { getSubscriptionService } = require("../../infrastructure/services/SubscriptionService");
+  const service = getSubscriptionService();
+
+  if (!service) {
+    return {
+      success: false,
+      service: null,
+      error: "Subscription service is not initialized",
+    };
+  }
+
+  return { success: true, service, error: undefined };
+}
+
+/**
+ * Validates user ID
+ */
+export function validateUserId(userId: string): string | null {
+  if (!userId) {
+    return "User ID is required";
+  }
+  return null;
+}
+
+/**
+ * Wraps async subscription operations with loading state, error handling, and state updates
+ */
+export async function executeSubscriptionOperation<T>(
+  operation: AsyncSubscriptionOperation<T>,
+  setLoading: (loading: boolean) => void,
+  setError: (error: string | null) => void,
+  onSuccess?: (result: T) => void
+): Promise<void> {
+  setLoading(true);
+  setError(null);
+
+  try {
+    const result = await operation();
+    if (onSuccess) {
+      onSuccess(result);
+    }
+  } catch (err) {
+    const errorMessage =
+      err instanceof Error ? err.message : "Operation failed";
+    setError(errorMessage);
+    throw err;
+  } finally {
+    setLoading(false);
+  }
+}
+
+/**
+ * Formats error message from unknown error
+ */
+export function formatErrorMessage(err: unknown, fallbackMessage: string): string {
+  return err instanceof Error ? err.message : fallbackMessage;
+}

package/src/presentation/hooks/useSubscriptionSettingsConfig.ts

@@ -15,6 +15,7 @@ import {
     formatDateForLocale,
     calculateDaysRemaining,
 } from "../utils/subscriptionDateUtils";
+import { useCreditsArray, getSubscriptionStatusType } from "./useSubscriptionSettingsConfig.utils";
 import type {
   SubscriptionSettingsConfig,
   SubscriptionStatusType,
@@ -104,23 +105,10 @@ export const useSubscriptionSettingsConfig = (
   );
 
   // Status type
-  const statusType: SubscriptionStatusType = isPremium ? "active" : "none";
+  const statusType: SubscriptionStatusType = getSubscriptionStatusType(isPremium);
 
   // Credits array
-  const creditsArray = useMemo(() => {
-    if (!credits) return [];
-    const total = getCreditLimit
-      ? getCreditLimit(credits.imageCredits)
-      : credits.imageCredits;
-    return [
-      {
-        id: "image",
-        label: translations.imageCreditsLabel || "Image Credits",
-        current: credits.imageCredits,
-        total,
-      },
-    ];
-  }, [credits, getCreditLimit, translations.imageCreditsLabel]);
+  const creditsArray = useCreditsArray(credits, getCreditLimit, translations);
 
   // Build config
   const config = useMemo(

package/src/presentation/hooks/useSubscriptionSettingsConfig.utils.ts

@@ -0,0 +1,48 @@
+/**
+ * useSubscriptionSettingsConfig Utilities
+ * Helper functions for subscription settings config
+ */
+
+import { useMemo } from "react";
+import type { UserCredits } from "../../domain/entities/Credits";
+import type { SubscriptionSettingsTranslations } from "../types/SubscriptionSettingsTypes";
+
+export interface CreditsInfo {
+  id: string;
+  label: string;
+  current: number;
+  total: number;
+}
+
+/**
+ * Builds credits array for display
+ */
+export function useCreditsArray(
+  credits: UserCredits | null | undefined,
+  getCreditLimit: ((credits: number) => number) | undefined,
+  translations: SubscriptionSettingsTranslations
+): CreditsInfo[] {
+  return useMemo(() => {
+    if (!credits) return [];
+    const total = getCreditLimit
+      ? getCreditLimit(credits.imageCredits)
+      : credits.imageCredits;
+    return [
+      {
+        id: "image",
+        label: translations.imageCreditsLabel || "Image Credits",
+        current: credits.imageCredits,
+        total,
+      },
+    ];
+  }, [credits, getCreditLimit, translations.imageCreditsLabel]);
+}
+
+/**
+ * Calculates subscription status type
+ */
+export function getSubscriptionStatusType(
+  isPremium: boolean
+): "active" | "none" {
+  return isPremium ? "active" : "none";
+}

package/src/revenuecat/index.ts

@@ -0,0 +1,12 @@
+export * from "./domain/errors/RevenueCatError";
+export * from "./domain/value-objects/RevenueCatConfig";
+export * from "./domain/types/RevenueCatTypes";
+export * from "./domain/constants/RevenueCatConstants";
+export * from "./application/ports/IRevenueCatService";
+export * from "./infrastructure/services/RevenueCatService";
+export * from "./infrastructure/managers/SubscriptionManager";
+export * from "./infrastructure/handlers/PackageHandler";
+export * from "./presentation/hooks/useRevenueCat";
+export * from "./presentation/hooks/useCustomerInfo";
+export * from "./presentation/hooks/usePaywallFlow";
+export * from "./presentation/hooks/useSubscriptionQueries";

package/src/utils/index.ts

@@ -0,0 +1,15 @@
+export * from "./aiCreditHelpers";
+export * from "./authUtils";
+export * from "./creditChecker";
+export * from "./creditMapper";
+export * from "./dateValidationUtils";
+export * from "./packageFilter";
+export * from "./packagePeriodUtils";
+export * from "./packageTypeDetector";
+export * from "./premiumAsyncUtils";
+export * from "./premiumStatusUtils";
+export * from "./priceUtils";
+export * from "./tierUtils";
+export * from "./types";
+export * from "./userTierUtils";
+export * from "./validation";