@umituz/react-native-subscription 2.11.20 → 2.11.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.11.20",
+  "version": "2.11.22",
   "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

@@ -227,6 +227,7 @@ export {
   type UseDeductCreditResult,
   type UseInitializeCreditsParams,
   type UseInitializeCreditsResult,
+  type InitializeCreditsOptions,
 } from "./presentation/hooks/useDeductCredit";
 
 export {
@@ -274,6 +275,19 @@ export {
   type AICreditHelpers,
 } from "./utils/aiCreditHelpers";
 
+export {
+  detectPackageType,
+  type SubscriptionPackageType,
+} from "./utils/packageTypeDetector";
+
+export {
+  getCreditAllocation,
+  getImageCreditsForPackage,
+  getTextCreditsForPackage,
+  CREDIT_ALLOCATIONS,
+  type CreditAllocation,
+} from "./utils/creditMapper";
+
 // =============================================================================
 // REVENUECAT - Errors
 // =============================================================================

package/src/infrastructure/repositories/CreditsRepository.ts

@@ -23,6 +23,8 @@ import type {
 } from "../../domain/entities/Credits";
 import type { UserCreditsDocumentRead } from "../models/UserCreditsDocument";
 import { initializeCreditsTransaction } from "../services/CreditsInitializer";
+import { detectPackageType } from "../../utils/packageTypeDetector";
+import { getCreditAllocation } from "../../utils/creditMapper";
 
 export class CreditsRepository extends BaseRepository {
   private config: CreditsConfig;
@@ -79,7 +81,8 @@ export class CreditsRepository extends BaseRepository {
 
   async initializeCredits(
     userId: string,
-    purchaseId?: string
+    purchaseId?: string,
+    productId?: string
   ): Promise<CreditsResult> {
     const db = getFirestore();
     if (!db) {
@@ -89,15 +92,63 @@ export class CreditsRepository extends BaseRepository {
       };
     }
 
+    if (__DEV__) {
+      console.log("[CreditsRepository] Initialize credits:", {
+        userId,
+        purchaseId,
+        productId,
+      });
+    }
+
     try {
       const creditsRef = this.getCreditsDocRef(db, userId);
+
+      // Determine credit allocation based on product ID
+      let configToUse = this.config;
+
+      if (productId) {
+        const packageType = detectPackageType(productId);
+        const allocation = getCreditAllocation(packageType);
+
+        if (allocation) {
+          // Override config with tier-specific credit amounts
+          configToUse = {
+            ...this.config,
+            imageCreditLimit: allocation.imageCredits,
+            textCreditLimit: allocation.textCredits,
+          };
+
+          if (__DEV__) {
+            console.log("[CreditsRepository] Using tier-based allocation:", {
+              packageType,
+              imageCredits: allocation.imageCredits,
+              textCredits: allocation.textCredits,
+            });
+          }
+        } else {
+          if (__DEV__) {
+            console.warn(
+              "[CreditsRepository] Could not determine package type, using default config:",
+              this.config
+            );
+          }
+        }
+      }
+
       const result = await initializeCreditsTransaction(
         db,
         creditsRef,
-        this.config,
+        configToUse,
         purchaseId
       );
 
+      if (__DEV__) {
+        console.log("[CreditsRepository] Credits initialized successfully:", {
+          imageCredits: result.imageCredits,
+          textCredits: result.textCredits,
+        });
+      }
+
       return {
         success: true,
         data: {
@@ -108,6 +159,10 @@ export class CreditsRepository extends BaseRepository {
         },
       };
     } catch (error) {
+      if (__DEV__) {
+        console.error("[CreditsRepository] Failed to initialize credits:", error);
+      }
+
       return {
         success: false,
         error: {

package/src/infrastructure/services/CreditsInitializer.ts

@@ -21,6 +21,14 @@ export async function initializeCreditsTransaction(
     config: CreditsConfig,
     purchaseId?: string
 ): Promise<InitializationResult> {
+    if (__DEV__) {
+        console.log("[CreditsInitializer] Starting transaction with config:", {
+            textCreditLimit: config.textCreditLimit,
+            imageCreditLimit: config.imageCreditLimit,
+            purchaseId,
+        });
+    }
+
     return runTransaction(db, async (transaction: Transaction) => {
         const creditsDoc = await transaction.get(creditsRef);
         const now = serverTimestamp();
@@ -34,7 +42,21 @@ export async function initializeCreditsTransaction(
             const existing = creditsDoc.data() as UserCreditsDocumentRead;
             processedPurchases = existing.processedPurchases || [];
 
+            if (__DEV__) {
+                console.log("[CreditsInitializer] Existing credits found:", {
+                    textCredits: existing.textCredits,
+                    imageCredits: existing.imageCredits,
+                    processedPurchases,
+                });
+            }
+
             if (purchaseId && processedPurchases.includes(purchaseId)) {
+                if (__DEV__) {
+                    console.warn(
+                        "[CreditsInitializer] Purchase already processed:",
+                        purchaseId
+                    );
+                }
                 return {
                     textCredits: existing.textCredits,
                     imageCredits: existing.imageCredits,
@@ -44,9 +66,32 @@ export async function initializeCreditsTransaction(
 
             newTextCredits = (existing.textCredits || 0) + config.textCreditLimit;
             newImageCredits = (existing.imageCredits || 0) + config.imageCreditLimit;
+
+            if (__DEV__) {
+                console.log("[CreditsInitializer] Adding to existing credits:", {
+                    existingText: existing.textCredits || 0,
+                    existingImage: existing.imageCredits || 0,
+                    adding: {
+                        text: config.textCreditLimit,
+                        image: config.imageCreditLimit,
+                    },
+                    newTotal: {
+                        text: newTextCredits,
+                        image: newImageCredits,
+                    },
+                });
+            }
+
             if (existing.purchasedAt) {
                 purchasedAt = existing.purchasedAt as unknown as FieldValue;
             }
+        } else {
+            if (__DEV__) {
+                console.log("[CreditsInitializer] Creating new credits document:", {
+                    textCredits: newTextCredits,
+                    imageCredits: newImageCredits,
+                });
+            }
         }
 
         if (purchaseId) {
@@ -62,6 +107,13 @@ export async function initializeCreditsTransaction(
             processedPurchases,
         });
 
+        if (__DEV__) {
+            console.log("[CreditsInitializer] Transaction completed successfully:", {
+                textCredits: newTextCredits,
+                imageCredits: newImageCredits,
+            });
+        }
+
         return { textCredits: newTextCredits, imageCredits: newImageCredits };
     });
 }

package/src/presentation/components/paywall/accordion/PlanCardHeader.tsx

@@ -19,7 +19,6 @@ export const PlanCardHeader: React.FC<PlanCardHeaderProps> = ({
   price,
   creditAmount,
   isSelected,
-  isExpanded,
   isBestValue,
   onToggle,
 }) => {

package/src/presentation/hooks/useDeductCredit.ts

@@ -106,8 +106,13 @@ export interface UseInitializeCreditsParams {
   userId: string | undefined;
 }
 
+export interface InitializeCreditsOptions {
+  purchaseId?: string;
+  productId?: string;
+}
+
 export interface UseInitializeCreditsResult {
-  initializeCredits: (purchaseId?: string) => Promise<boolean>;
+  initializeCredits: (options?: InitializeCreditsOptions) => Promise<boolean>;
   isInitializing: boolean;
 }
 
@@ -118,14 +123,31 @@ export const useInitializeCredits = ({
   const queryClient = useQueryClient();
 
   const mutation = useMutation({
-    mutationFn: async (purchaseId?: string) => {
+    mutationFn: async (options?: InitializeCreditsOptions) => {
       if (!userId) {
         throw new Error("User not authenticated");
       }
-      return repository.initializeCredits(userId, purchaseId);
+
+      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
@@ -134,16 +156,24 @@ export const useInitializeCredits = ({
         });
       }
     },
+    onError: (error) => {
+      if (__DEV__) {
+        console.error("[useInitializeCredits] Error:", error);
+      }
+    },
   });
 
-  const initializeCredits = useCallback(async (purchaseId?: string): Promise<boolean> => {
-    try {
-      const result = await mutation.mutateAsync(purchaseId);
-      return result.success;
-    } catch {
-      return false;
-    }
-  }, [mutation]);
+  const initializeCredits = useCallback(
+    async (options?: InitializeCreditsOptions): Promise<boolean> => {
+      try {
+        const result = await mutation.mutateAsync(options);
+        return result.success;
+      } catch {
+        return false;
+      }
+    },
+    [mutation]
+  );
 
   return {
     initializeCredits,

package/src/presentation/hooks/usePremiumWithConfig.ts

@@ -67,7 +67,7 @@ export const usePremiumWithConfig = (
     async (pkg: PurchasesPackage): Promise<boolean> => {
       const success = await purchaseMutation.mutateAsync(pkg);
       if (success && userId) {
-        await initializeCredits();
+        await initializeCredits({ productId: pkg.product.identifier });
       }
       return success;
     },

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

@@ -14,24 +14,31 @@ import {
 
 /**
  * Fetch available subscription packages
+ * Works for both authenticated and anonymous users
  */
 export const useSubscriptionPackages = (userId: string | undefined) => {
   return useQuery({
-    queryKey: [...SUBSCRIPTION_QUERY_KEYS.packages, userId] as const,
+    queryKey: [...SUBSCRIPTION_QUERY_KEYS.packages, userId ?? "anonymous"] as const,
     queryFn: async () => {
       addPackageBreadcrumb("subscription", "Fetch packages query started", {
-        userId: userId ?? "NO_USER",
+        userId: userId ?? "ANONYMOUS",
       });
 
-      // Skip if already initialized for this specific user
-      if (!userId || !SubscriptionManager.isInitializedForUser(userId)) {
-        await SubscriptionManager.initialize(userId);
+      // Initialize if needed (works for both authenticated and anonymous users)
+      if (userId) {
+        if (!SubscriptionManager.isInitializedForUser(userId)) {
+          await SubscriptionManager.initialize(userId);
+        }
+      } else {
+        if (!SubscriptionManager.isInitialized()) {
+          await SubscriptionManager.initialize(undefined);
+        }
       }
 
       const packages = await SubscriptionManager.getPackages();
 
       addPackageBreadcrumb("subscription", "Fetch packages query success", {
-        userId: userId ?? "NO_USER",
+        userId: userId ?? "ANONYMOUS",
         count: packages.length,
       });
 
@@ -39,6 +46,6 @@ export const useSubscriptionPackages = (userId: string | undefined) => {
     },
     staleTime: STALE_TIME,
     gcTime: GC_TIME,
-    enabled: !!userId, // Only run when userId is available
+    enabled: true, // Always enabled - works for both authenticated and anonymous users
   });
 };

package/src/utils/creditMapper.ts

@@ -0,0 +1,83 @@
+/**
+ * Credit Mapper
+ * Maps subscription package types to credit amounts
+ * Based on SUBSCRIPTION_GUIDE.md pricing strategy
+ */
+
+import type { SubscriptionPackageType } from "./packageTypeDetector";
+
+export interface CreditAllocation {
+  imageCredits: number;
+  textCredits: number;
+}
+
+/**
+ * Standard credit allocations per package type
+ * Based on profitability analysis and value ladder strategy
+ *
+ * Weekly:  6 images  - $2.99 (62% margin) - Trial users
+ * Monthly: 25 images - $9.99 (60% margin) - Regular users
+ * Yearly:  300 images - $79.99 (55% margin) - Best value (46% cheaper/image)
+ */
+export const CREDIT_ALLOCATIONS: Record<
+  Exclude<SubscriptionPackageType, "unknown">,
+  CreditAllocation
+> = {
+  weekly: {
+    imageCredits: 6,
+    textCredits: 6,
+  },
+  monthly: {
+    imageCredits: 25,
+    textCredits: 25,
+  },
+  yearly: {
+    imageCredits: 300,
+    textCredits: 300,
+  },
+};
+
+/**
+ * Get credit allocation for a package type
+ * Returns null for unknown package types to prevent incorrect credit assignment
+ */
+export function getCreditAllocation(
+  packageType: SubscriptionPackageType
+): CreditAllocation | null {
+  if (packageType === "unknown") {
+    if (__DEV__) {
+      console.warn(
+        "[CreditMapper] Cannot allocate credits for unknown package type"
+      );
+    }
+    return null;
+  }
+
+  const allocation = CREDIT_ALLOCATIONS[packageType];
+
+  if (__DEV__) {
+    console.log("[CreditMapper] Credit allocation for", packageType, ":", allocation);
+  }
+
+  return allocation;
+}
+
+/**
+ * Get image credits for a package type
+ */
+export function getImageCreditsForPackage(
+  packageType: SubscriptionPackageType
+): number | null {
+  const allocation = getCreditAllocation(packageType);
+  return allocation?.imageCredits ?? null;
+}
+
+/**
+ * Get text credits for a package type
+ */
+export function getTextCreditsForPackage(
+  packageType: SubscriptionPackageType
+): number | null {
+  const allocation = getCreditAllocation(packageType);
+  return allocation?.textCredits ?? null;
+}

package/src/utils/packageTypeDetector.ts

@@ -0,0 +1,62 @@
+/**
+ * Package Type Detector
+ * Detects subscription package type from RevenueCat package identifier
+ */
+
+export type SubscriptionPackageType = "weekly" | "monthly" | "yearly" | "unknown";
+
+/**
+ * Detect package type from product identifier
+ * Supports common RevenueCat naming patterns:
+ * - premium_weekly, weekly_premium, premium-weekly
+ * - premium_monthly, monthly_premium, premium-monthly
+ * - premium_yearly, yearly_premium, premium-yearly, premium_annual, annual_premium
+ */
+export function detectPackageType(productIdentifier: string): SubscriptionPackageType {
+  if (!productIdentifier) {
+    if (__DEV__) {
+      console.log("[PackageTypeDetector] No product identifier provided");
+    }
+    return "unknown";
+  }
+
+  const normalized = productIdentifier.toLowerCase();
+
+  if (__DEV__) {
+    console.log("[PackageTypeDetector] Detecting package type for:", normalized);
+  }
+
+  // Weekly detection
+  if (normalized.includes("weekly") || normalized.includes("week")) {
+    if (__DEV__) {
+      console.log("[PackageTypeDetector] Detected: WEEKLY");
+    }
+    return "weekly";
+  }
+
+  // Monthly detection
+  if (normalized.includes("monthly") || normalized.includes("month")) {
+    if (__DEV__) {
+      console.log("[PackageTypeDetector] Detected: MONTHLY");
+    }
+    return "monthly";
+  }
+
+  // Yearly detection (includes annual)
+  if (
+    normalized.includes("yearly") ||
+    normalized.includes("year") ||
+    normalized.includes("annual")
+  ) {
+    if (__DEV__) {
+      console.log("[PackageTypeDetector] Detected: YEARLY");
+    }
+    return "yearly";
+  }
+
+  if (__DEV__) {
+    console.warn("[PackageTypeDetector] Unknown package type for:", productIdentifier);
+  }
+
+  return "unknown";
+}