@umituz/react-native-subscription 2.27.8 → 2.27.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.8",
+  "version": "2.27.10",
   "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/infrastructure/models/UserCreditsDocument.ts

@@ -57,6 +57,8 @@ export interface UserCreditsDocumentRead {
     // Credits
     credits: number;
     creditLimit?: number;
+    initialFreeCredits?: number;
+    isFreeCredits?: boolean;
 
     // Metadata
     purchaseSource?: PurchaseSource;

package/src/infrastructure/services/CreditsInitializer.ts

@@ -1,3 +1,9 @@
+/**
+ * Credits Initializer
+ * Handles subscription credit initialization (NOT free credits)
+ * Free credits are handled by CreditsRepository.initializeFreeCredits()
+ */
+
 import { Platform } from "react-native";
 import Constants from "expo-constants";
 import {
@@ -25,17 +31,14 @@ interface InitializationResult {
     credits: number;
 }
 
-/** RevenueCat data to save to Firestore (Single Source of Truth) */
 export interface InitializeCreditsMetadata {
   productId?: string;
   source?: PurchaseSource;
   type?: PurchaseType;
-  // RevenueCat subscription data
   expirationDate?: string | null;
   willRenew?: boolean;
   originalTransactionId?: string;
   isPremium?: boolean;
-  /** RevenueCat period type: NORMAL, INTRO, or TRIAL */
   periodType?: PeriodType;
 }
 
@@ -49,34 +52,23 @@ export async function initializeCreditsTransaction(
     return runTransaction(db, async (transaction: Transaction) => {
         const creditsDoc = await transaction.get(creditsRef);
         const now = serverTimestamp();
+        const existingData = creditsDoc.exists() ? creditsDoc.data() as UserCreditsDocumentRead : null;
 
-        let newCredits = config.creditLimit;
-        let purchasedAt = now;
-        let processedPurchases: string[] = [];
-
-        if (creditsDoc.exists()) {
-            const existing = creditsDoc.data() as UserCreditsDocumentRead;
-            processedPurchases = existing.processedPurchases || [];
-
-            if (purchaseId && processedPurchases.includes(purchaseId)) {
-                return {
-                    credits: existing.credits,
-                    alreadyProcessed: true,
-                } as any;
-            }
+        let purchasedAt: FieldValue = now;
+        let processedPurchases: string[] = existingData?.processedPurchases || [];
 
-            newCredits = config.creditLimit;
+        if (existingData && purchaseId && processedPurchases.includes(purchaseId)) {
+            return { credits: existingData.credits, alreadyProcessed: true } as InitializationResult & { alreadyProcessed: boolean };
+        }
 
-            if (existing.purchasedAt) {
-                purchasedAt = existing.purchasedAt as unknown as FieldValue;
-            }
+        if (existingData?.purchasedAt) {
+            purchasedAt = existingData.purchasedAt as unknown as FieldValue;
         }
 
         if (purchaseId) {
             processedPurchases = [...processedPurchases, purchaseId].slice(-10);
         }
 
-        // Detect package type and credit limit from productId
         const productId = metadata?.productId;
         const packageType = productId ? detectPackageType(productId) : undefined;
         const allocation = packageType && packageType !== "unknown"
@@ -84,29 +76,17 @@ export async function initializeCreditsTransaction(
           : null;
         const creditLimit = allocation || config.creditLimit;
 
-        // Platform and app version
         const platform = Platform.OS as "ios" | "android";
         const appVersion = Constants.expoConfig?.version;
 
-        // Determine purchase type
         let purchaseType: PurchaseType = metadata?.type ?? "initial";
-        if (creditsDoc.exists()) {
-          const existing = creditsDoc.data() as UserCreditsDocumentRead;
-          if (existing.packageType && packageType !== "unknown") {
-            const oldLimit = existing.creditLimit || 0;
-            const newLimit = creditLimit;
-            if (newLimit > oldLimit) {
-              purchaseType = "upgrade";
-            } else if (newLimit < oldLimit) {
-              purchaseType = "downgrade";
-            } else if (purchaseId?.startsWith("renewal_")) {
-              purchaseType = "renewal";
-            }
-          }
+        if (existingData?.packageType && packageType !== "unknown") {
+            const oldLimit = existingData.creditLimit || 0;
+            if (creditLimit > oldLimit) purchaseType = "upgrade";
+            else if (creditLimit < oldLimit) purchaseType = "downgrade";
+            else if (purchaseId?.startsWith("renewal_")) purchaseType = "renewal";
         }
 
-        // Create purchase metadata for history (only if productId and source exists and packageType detected)
-        // NOTE: Cannot use serverTimestamp() in arrays, using Date.now() instead
         const purchaseMetadata: PurchaseMetadata | undefined =
           productId && metadata?.source && packageType && packageType !== "unknown" ? {
             productId,
@@ -116,107 +96,59 @@ export async function initializeCreditsTransaction(
             type: purchaseType,
             platform,
             appVersion,
-            timestamp: Date.now() as any,  // Use Date.now() instead of serverTimestamp() for arrays
+            timestamp: Date.now() as unknown as PurchaseMetadata["timestamp"],
           } : undefined;
 
-        // Update purchase history (keep last 10, only if metadata exists)
-        const existing = creditsDoc.exists() ? creditsDoc.data() as UserCreditsDocumentRead : null;
         const purchaseHistory = purchaseMetadata
-          ? [...(existing?.purchaseHistory || []), purchaseMetadata].slice(-10)
-          : existing?.purchaseHistory;
+          ? [...(existingData?.purchaseHistory || []), purchaseMetadata].slice(-10)
+          : existingData?.purchaseHistory;
 
-        // Determine subscription status
         const isPremium = metadata?.isPremium ?? true;
         const willRenew = metadata?.willRenew;
         const periodType = metadata?.periodType;
 
-        const status = resolveSubscriptionStatus({
-            isPremium,
-            willRenew,
-            isExpired: !isPremium,
-            periodType,
-        });
-
-        // Determine credits based on status
-        // Trial: 5 credits, Trial canceled: 0 credits, Normal: plan-based credits
-        if (status === SUBSCRIPTION_STATUS.TRIAL) {
-            newCredits = TRIAL_CONFIG.CREDITS;
-        } else if (status === SUBSCRIPTION_STATUS.TRIAL_CANCELED) {
-            newCredits = 0;
-        }
+        const status = resolveSubscriptionStatus({ isPremium, willRenew, isExpired: !isPremium, periodType });
+
+        let newCredits = creditLimit;
+        if (status === SUBSCRIPTION_STATUS.TRIAL) newCredits = TRIAL_CONFIG.CREDITS;
+        else if (status === SUBSCRIPTION_STATUS.TRIAL_CANCELED) newCredits = 0;
 
-        // Build credits data (Single Source of Truth)
         const creditsData: Record<string, unknown> = {
-            // Core subscription
             isPremium,
             status,
-
-            // Credits
             credits: newCredits,
             creditLimit,
-
-            // Dates
             purchasedAt,
             lastUpdatedAt: now,
             lastPurchaseAt: now,
-
-            // Tracking
             processedPurchases,
         };
 
-        // RevenueCat subscription data
-        if (metadata?.expirationDate) {
-            creditsData.expirationDate = Timestamp.fromDate(new Date(metadata.expirationDate));
-        }
-        if (metadata?.willRenew !== undefined) {
-            creditsData.willRenew = metadata.willRenew;
-        }
-        if (metadata?.originalTransactionId) {
-            creditsData.originalTransactionId = metadata.originalTransactionId;
-        }
-
-        // Package info
-        if (packageType && packageType !== "unknown") {
-            creditsData.packageType = packageType;
-        }
+        if (metadata?.expirationDate) creditsData.expirationDate = Timestamp.fromDate(new Date(metadata.expirationDate));
+        if (metadata?.willRenew !== undefined) creditsData.willRenew = metadata.willRenew;
+        if (metadata?.originalTransactionId) creditsData.originalTransactionId = metadata.originalTransactionId;
+        if (packageType && packageType !== "unknown") creditsData.packageType = packageType;
         if (productId) {
             creditsData.productId = productId;
             creditsData.platform = platform;
             creditsData.appVersion = appVersion;
         }
 
-        // Trial-specific fields
         const isTrialing = status === SUBSCRIPTION_STATUS.TRIAL || status === SUBSCRIPTION_STATUS.TRIAL_CANCELED;
-
-        if (periodType) {
-            creditsData.periodType = periodType;
-        }
+        if (periodType) creditsData.periodType = periodType;
         if (isTrialing) {
             creditsData.isTrialing = status === SUBSCRIPTION_STATUS.TRIAL;
             creditsData.trialCredits = TRIAL_CONFIG.CREDITS;
-            // Set trial dates if this is a new trial
-            if (!existing?.trialStartDate) {
-                creditsData.trialStartDate = now;
-            }
-            if (metadata?.expirationDate) {
-                creditsData.trialEndDate = Timestamp.fromDate(new Date(metadata.expirationDate));
-            }
-        } else if (existing?.isTrialing && isPremium) {
-            // User converted from trial to paid
+            if (!existingData?.trialStartDate) creditsData.trialStartDate = now;
+            if (metadata?.expirationDate) creditsData.trialEndDate = Timestamp.fromDate(new Date(metadata.expirationDate));
+        } else if (existingData?.isTrialing && isPremium) {
             creditsData.isTrialing = false;
             creditsData.convertedFromTrial = true;
         }
 
-        // Purchase metadata
-        if (metadata?.source) {
-            creditsData.purchaseSource = metadata.source;
-        }
-        if (metadata?.type) {
-            creditsData.purchaseType = purchaseType;
-        }
-        if (purchaseHistory && purchaseHistory.length > 0) {
-            creditsData.purchaseHistory = purchaseHistory;
-        }
+        if (metadata?.source) creditsData.purchaseSource = metadata.source;
+        if (metadata?.type) creditsData.purchaseType = purchaseType;
+        if (purchaseHistory?.length) creditsData.purchaseHistory = purchaseHistory;
 
         transaction.set(creditsRef, creditsData, { merge: true });
 

package/src/infrastructure/services/SubscriptionInitializer.ts

@@ -118,6 +118,25 @@ export const initializeSubscription = async (config: SubscriptionInitConfig): Pr
       console.log('[SubscriptionInitializer] onPremiumStatusChanged:', { userId, isPremium, productId, willRenew, periodType });
     }
     try {
+      // If not premium and no productId, this is a free user - don't overwrite free credits
+      if (!isPremium && !productId) {
+        if (__DEV__) {
+          console.log('[SubscriptionInitializer] Free user detected, preserving free credits');
+        }
+        return;
+      }
+
+      // If premium became false (subscription expired/canceled), sync expired status only
+      if (!isPremium && productId) {
+        await getCreditsRepository().syncExpiredStatus(userId);
+        if (__DEV__) {
+          console.log('[SubscriptionInitializer] Subscription expired, synced status');
+        }
+        onCreditsUpdated?.(userId);
+        return;
+      }
+
+      // Premium user - initialize credits with subscription data
       const revenueCatData: RevenueCatData = {
         expirationDate: expiresAt ?? null,
         willRenew: willRenew ?? false,