@umituz/react-native-subscription 2.27.92 → 2.27.94

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.92",
+  "version": "2.27.94",
   "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/domains/credits/application/CreditsInitializer.ts

@@ -1,13 +1,14 @@
 import { Platform } from "react-native";
 import Constants from "expo-constants";
+import {
+  getFirestore,
+} from "@umituz/react-native-firebase";
 import {
   runTransaction,
   serverTimestamp,
-  Timestamp,
   type Transaction,
   type DocumentReference,
-  type Firestore,
-} from "@umituz/react-native-firebase";
+} from "firebase/firestore";
 import type { CreditsConfig } from "../core/Credits";
 import type { UserCreditsDocumentRead } from "../core/UserCreditsDocument";
 import { resolveSubscriptionStatus } from "../../subscription/core/SubscriptionStatus";
@@ -17,41 +18,72 @@ import { creditAllocationContext } from "./credit-strategies/CreditAllocationCon
 import type { InitializeCreditsMetadata, InitializationResult } from "../../subscription/application/SubscriptionInitializerTypes";
 
 export async function initializeCreditsTransaction(
-    db: Firestore,
+    db: ReturnType<typeof getFirestore>,
     creditsRef: DocumentReference,
     config: CreditsConfig,
-    purchaseId?: string,
-    metadata?: InitializeCreditsMetadata
+    purchaseId: string,
+    metadata: InitializeCreditsMetadata
 ): Promise<InitializationResult> {
+    if (!db) {
+        throw new Error("Firestore instance is not available");
+    }
+
     return runTransaction(db, async (transaction: Transaction) => {
         const creditsDoc = await transaction.get(creditsRef);
         const now = serverTimestamp();
-        const existingData = creditsDoc.exists() ? creditsDoc.data() as UserCreditsDocumentRead : null;
+        const existingData = creditsDoc.exists()
+            ? creditsDoc.data() as UserCreditsDocumentRead
+            : null;
+
+        if (!existingData) {
+            throw new Error("Credits document does not exist");
+        }
+
+        if (existingData.processedPurchases.includes(purchaseId)) {
+            return {
+                credits: existingData.credits,
+                alreadyProcessed: true,
+                finalData: existingData
+            };
+        }
 
-        if (existingData && purchaseId && existingData.processedPurchases?.includes(purchaseId)) {
-            return { credits: existingData.credits, alreadyProcessed: true };
+        const creditLimit = CreditLimitCalculator.calculate(metadata.productId, config);
+
+        const platform = Platform.OS;
+        if (platform !== "ios" && platform !== "android") {
+            throw new Error(`Invalid platform: ${platform}`);
+        }
+
+        const appVersion = Constants.expoConfig?.version;
+        if (!appVersion) {
+            throw new Error("appVersion is required in expoConfig");
         }
 
-        const creditLimit = CreditLimitCalculator.calculate(metadata?.productId, config);
         const { purchaseHistory } = PurchaseMetadataGenerator.generate({
-          productId: metadata?.productId,
-          source: metadata?.source,
-          type: metadata?.type,
-          creditLimit,
-          platform: Platform.OS as "ios" | "android",
-          appVersion: Constants.expoConfig?.version,
+            productId: metadata.productId,
+            source: metadata.source,
+            type: metadata.type,
+            creditLimit,
+            platform,
+            appVersion,
         }, existingData);
 
-        const isPremium = metadata?.isPremium ?? true;
-        const isExpired = metadata?.expirationDate ? new Date(metadata.expirationDate).getTime() < Date.now() : false;
-        const status = resolveSubscriptionStatus({ 
-          isPremium, willRenew: metadata?.willRenew, isExpired, periodType: metadata?.periodType 
+        const isPremium = metadata.isPremium;
+
+        let isExpired = false;
+        if (metadata.expirationDate) {
+            isExpired = new Date(metadata.expirationDate).getTime() < Date.now();
+        }
+
+        const status = resolveSubscriptionStatus({
+            isPremium,
+            willRenew: metadata.willRenew ?? false,
+            isExpired,
+            periodType: metadata.periodType ?? undefined,
         });
 
-        // Resolve credits using Strategy Pattern
-        const isStatusSync = purchaseId?.startsWith("status_sync_") ?? false;
+        const isStatusSync = purchaseId.startsWith("status_sync_");
         const isSubscriptionActive = isPremium && !isExpired;
-        const productId = metadata?.productId;
 
         const newCredits = creditAllocationContext.allocate({
             status,
@@ -59,30 +91,57 @@ export async function initializeCreditsTransaction(
             existingData,
             creditLimit,
             isSubscriptionActive,
-            productId,
+            productId: metadata.productId,
         });
 
+        const newProcessedPurchases = [...existingData.processedPurchases, purchaseId].slice(-50);
+
         const creditsData: Record<string, any> = {
-            isPremium, status, credits: newCredits, creditLimit, 
-            lastUpdatedAt: now, 
-            // Increase history window to 50 for better idempotency
-            processedPurchases: (purchaseId ? [...(existingData?.processedPurchases || []), purchaseId].slice(-50) : existingData?.processedPurchases) || [],
-            purchaseHistory: purchaseHistory.length ? purchaseHistory : undefined
+            isPremium,
+            status,
+            credits: newCredits,
+            creditLimit,
+            lastUpdatedAt: now,
+            processedPurchases: newProcessedPurchases,
         };
 
-        const isNewPurchaseOrRenewal = purchaseId?.startsWith("purchase_") || purchaseId?.startsWith("renewal_");
-        if (isNewPurchaseOrRenewal) creditsData.lastPurchaseAt = now;
-        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 (metadata?.productId) {
-            creditsData.productId = metadata.productId;
-            creditsData.platform = Platform.OS;
+        if (purchaseHistory.length > 0) {
+            creditsData.purchaseHistory = purchaseHistory;
+        }
+
+        const isNewPurchaseOrRenewal = purchaseId.startsWith("purchase_")
+            || purchaseId.startsWith("renewal_");
+
+        if (isNewPurchaseOrRenewal) {
+            creditsData.lastPurchaseAt = now;
+        }
+
+        if (metadata.expirationDate) {
+            creditsData.expirationDate = serverTimestamp();
+        }
+
+        if (metadata.willRenew !== undefined) {
+            creditsData.willRenew = metadata.willRenew;
+        }
+
+        if (metadata.originalTransactionId) {
+            creditsData.originalTransactionId = metadata.originalTransactionId;
         }
 
+        creditsData.productId = metadata.productId;
+        creditsData.platform = platform;
+
         transaction.set(creditsRef, creditsData, { merge: true });
-        
-        const finalData = { ...(existingData || {}), ...creditsData } as UserCreditsDocumentRead;
-        return { credits: newCredits, finalData };
+
+        const finalData: UserCreditsDocumentRead = {
+            ...existingData,
+            ...creditsData,
+        };
+
+        return {
+            credits: newCredits,
+            alreadyProcessed: false,
+            finalData
+        };
     });
 }

package/src/domains/credits/application/DeductCreditsCommand.ts

@@ -16,37 +16,55 @@ export class DeductCreditsCommand implements IDeductCreditsCommand {
     private getCreditsRef: (db: Firestore, userId: string) => DocumentReference
   ) {}
 
-  async execute(userId: string, cost: number = 1): Promise<DeductCreditsResult> {
+  async execute(userId: string, cost: number): Promise<DeductCreditsResult> {
     const db = getFirestore();
-    if (!db) return { success: false, error: { message: "No DB", code: "ERR" } };
+    if (!db) {
+      return {
+        success: false,
+        remainingCredits: null,
+        error: { message: "No DB", code: "ERR" }
+      };
+    }
 
     try {
       const remaining = await runTransaction(db, async (tx: Transaction) => {
         const ref = this.getCreditsRef(db, userId);
         const docSnap = await tx.get(ref);
-        
-        if (!docSnap.exists()) throw new Error("NO_CREDITS");
-        
+
+        if (!docSnap.exists()) {
+          throw new Error("NO_CREDITS");
+        }
+
         const current = docSnap.data().credits as number;
-        if (current < cost) throw new Error("CREDITS_EXHAUSTED");
-        
+        if (current < cost) {
+          throw new Error("CREDITS_EXHAUSTED");
+        }
+
         const updated = current - cost;
-        tx.update(ref, { 
-            credits: updated, 
-            lastUpdatedAt: serverTimestamp() 
+        tx.update(ref, {
+          credits: updated,
+          lastUpdatedAt: serverTimestamp()
         });
-        
+
         return updated;
       });
 
       // Emit event via EventBus (Observer Pattern)
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
 
-      return { success: true, remainingCredits: remaining };
+      return {
+        success: true,
+        remainingCredits: remaining,
+        error: null
+      };
     } catch (e: unknown) {
       const message = e instanceof Error ? e.message : String(e);
       const code = message === "NO_CREDITS" || message === "CREDITS_EXHAUSTED" ? message : "DEDUCT_ERR";
-      return { success: false, error: { message, code } };
+      return {
+        success: false,
+        remainingCredits: null,
+        error: { message, code }
+      };
     }
   }
 }

package/src/domains/credits/application/PurchaseMetadataGenerator.ts

@@ -1,6 +1,6 @@
 import { Timestamp } from "firebase/firestore";
-import type { 
-  PurchaseType, 
+import type {
+  PurchaseType,
   PurchaseMetadata,
   UserCreditsDocumentRead,
   PurchaseSource
@@ -8,37 +8,31 @@ import type {
 import { detectPackageType } from "../../../utils/packageTypeDetector";
 
 export interface MetadataGeneratorConfig {
-  productId?: string;
-  source?: PurchaseSource;
-  type?: PurchaseType;
+  productId: string;
+  source: PurchaseSource;
+  type: PurchaseType;
   creditLimit: number;
   platform: "ios" | "android";
-  appVersion?: string;
+  appVersion: string;
 }
 
 export class PurchaseMetadataGenerator {
   static generate(
     config: MetadataGeneratorConfig,
-    existingData: UserCreditsDocumentRead | null
+    existingData: UserCreditsDocumentRead
   ): { purchaseType: PurchaseType; purchaseHistory: PurchaseMetadata[] } {
     const { productId, source, type, creditLimit, platform, appVersion } = config;
-    
-    if (!productId || !source) {
-      return { 
-        purchaseType: type ?? "initial", 
-        purchaseHistory: existingData?.purchaseHistory || [] 
-      };
-    }
 
     const packageType = detectPackageType(productId);
-    let purchaseType: PurchaseType = type ?? "initial";
+    let purchaseType: PurchaseType = type;
 
-    if (existingData?.packageType && packageType !== "unknown") {
-      const oldLimit = existingData.creditLimit || 0;
-      if (creditLimit > oldLimit) purchaseType = "upgrade";
-      else if (creditLimit < oldLimit) purchaseType = "downgrade";
-      // This check is a bit fragile if purchaseId is not passed here, 
-      // but we use the explicit 'type' if provided.
+    if (packageType !== "unknown") {
+      const oldLimit = existingData.creditLimit;
+      if (creditLimit > oldLimit) {
+        purchaseType = "upgrade";
+      } else if (creditLimit < oldLimit) {
+        purchaseType = "downgrade";
+      }
     }
 
     const newMetadata: PurchaseMetadata = {
@@ -49,10 +43,10 @@ export class PurchaseMetadataGenerator {
       type: purchaseType,
       platform,
       appVersion,
-      timestamp: Timestamp.fromDate(new Date()) as any,
+      timestamp: Timestamp.fromDate(new Date()),
     };
 
-    const purchaseHistory = [...(existingData?.purchaseHistory || []), newMetadata].slice(-10);
+    const purchaseHistory = [...existingData.purchaseHistory, newMetadata].slice(-10);
 
     return { purchaseType, purchaseHistory };
   }

package/src/domains/credits/core/Credits.ts

@@ -6,22 +6,22 @@
  */
 
 import type { SubscriptionPackageType } from "../../../utils/packageTypeDetector";
-import type { 
-  SubscriptionStatusType, 
-  PeriodType, 
-  PackageType, 
-  Platform, 
-  PurchaseSource, 
-  PurchaseType 
+import type {
+  SubscriptionStatusType,
+  PeriodType,
+  PackageType,
+  Platform,
+  PurchaseSource,
+  PurchaseType
 } from "../../subscription/core/SubscriptionConstants";
 
-export type { 
-  SubscriptionStatusType, 
-  PeriodType, 
-  PackageType, 
-  Platform, 
-  PurchaseSource, 
-  PurchaseType 
+export type {
+  SubscriptionStatusType,
+  PeriodType,
+  PackageType,
+  Platform,
+  PurchaseSource,
+  PurchaseType
 };
 
 export type CreditType = "text" | "image";
@@ -36,30 +36,31 @@ export interface UserCredits {
   purchasedAt: Date | null;
   expirationDate: Date | null;
   lastUpdatedAt: Date | null;
+  lastPurchaseAt: Date | null;
 
   // RevenueCat subscription details
-  willRenew: boolean;
-  productId?: string;
-  packageType?: PackageType;
-  originalTransactionId?: string;
+  willRenew: boolean | null;
+  productId: string | null;
+  packageType: PackageType | null;
+  originalTransactionId: string | null;
 
   // Trial fields
-  periodType?: PeriodType;
-  isTrialing?: boolean;
-  trialStartDate?: Date | null;
-  trialEndDate?: Date | null;
-  trialCredits?: number;
-  convertedFromTrial?: boolean;
+  periodType: PeriodType | null;
+  isTrialing: boolean | null;
+  trialStartDate: Date | null;
+  trialEndDate: Date | null;
+  trialCredits: number | null;
+  convertedFromTrial: boolean | null;
 
   // Credits
   credits: number;
-  creditLimit?: number;
+  creditLimit: number;
 
   // Metadata
-  purchaseSource?: PurchaseSource;
-  purchaseType?: PurchaseType;
-  platform?: Platform;
-  appVersion?: string;
+  purchaseSource: PurchaseSource | null;
+  purchaseType: PurchaseType | null;
+  platform: Platform;
+  appVersion: string | null;
 }
 
 export interface CreditAllocation {
@@ -75,28 +76,27 @@ export interface CreditsConfig {
   collectionName: string;
   creditLimit: number;
   /** When true, stores credits at users/{userId}/credits instead of {collectionName}/{userId} */
-  useUserSubcollection?: boolean;
+  useUserSubcollection: boolean;
   /** Credit amounts per product ID for consumable credit packages */
-  creditPackageAmounts?: Record<string, number>;
+  creditPackageAmounts: Record<string, number>;
   /** Credit allocations for different subscription types (weekly, monthly, yearly) */
-  packageAllocations?: PackageAllocationMap;
+  packageAllocations: PackageAllocationMap;
 }
 
 export interface CreditsResult<T = UserCredits> {
   success: boolean;
-  data?: T;
-  error?: {
+  data: T | null;
+  error: {
     message: string;
     code: string;
-  };
+  } | null;
 }
 
 export interface DeductCreditsResult {
   success: boolean;
-  remainingCredits?: number;
-  error?: {
+  remainingCredits: number | null;
+  error: {
     message: string;
     code: string;
-  };
+  } | null;
 }
-

package/src/domains/credits/core/CreditsMapper.ts

@@ -6,8 +6,8 @@ import type { UserCreditsDocumentRead } from "./UserCreditsDocument";
 /** Maps Firestore document to domain entity with expiration validation */
 export class CreditsMapper {
   static toEntity(doc: UserCreditsDocumentRead): UserCredits {
-    const expirationDate = doc.expirationDate?.toDate?.() ?? null;
-    const periodType = doc.periodType as PeriodType | undefined;
+    const expirationDate = doc.expirationDate ? doc.expirationDate.toDate() : null;
+    const periodType = doc.periodType;
 
     // Validate isPremium against expirationDate (real-time check)
     const { isPremium, status } = CreditsMapper.validateSubscription(doc, expirationDate, periodType);
@@ -18,12 +18,13 @@ export class CreditsMapper {
       status,
 
       // Dates
-      purchasedAt: doc.purchasedAt?.toDate?.() ?? null,
+      purchasedAt: doc.purchasedAt.toDate(),
       expirationDate,
-      lastUpdatedAt: doc.lastUpdatedAt?.toDate?.() ?? null,
+      lastUpdatedAt: doc.lastUpdatedAt.toDate(),
+      lastPurchaseAt: doc.lastPurchaseAt ? doc.lastPurchaseAt.toDate() : null,
 
       // RevenueCat details
-      willRenew: doc.willRenew ?? false,
+      willRenew: doc.willRenew,
       productId: doc.productId,
       packageType: doc.packageType,
       originalTransactionId: doc.originalTransactionId,
@@ -31,8 +32,8 @@ export class CreditsMapper {
       // Trial fields
       periodType,
       isTrialing: doc.isTrialing,
-      trialStartDate: doc.trialStartDate?.toDate?.() ?? null,
-      trialEndDate: doc.trialEndDate?.toDate?.() ?? null,
+      trialStartDate: doc.trialStartDate ? doc.trialStartDate.toDate() : null,
+      trialEndDate: doc.trialEndDate ? doc.trialEndDate.toDate() : null,
       trialCredits: doc.trialCredits,
       convertedFromTrial: doc.convertedFromTrial,
 
@@ -52,9 +53,9 @@ export class CreditsMapper {
   private static validateSubscription(
     doc: UserCreditsDocumentRead,
     expirationDate: Date | null,
-    periodType?: PeriodType
+    periodType: PeriodType | null
   ): { isPremium: boolean; status: SubscriptionStatusType } {
-    const isPremium = doc.isPremium ?? false;
+    const isPremium = doc.isPremium;
     const willRenew = doc.willRenew ?? false;
     const isExpired = expirationDate ? expirationDate < new Date() : false;
 
@@ -62,7 +63,7 @@ export class CreditsMapper {
       isPremium,
       willRenew,
       isExpired,
-      periodType,
+      periodType: periodType ?? undefined,
     });
 
     // Override isPremium if expired

package/src/domains/credits/core/UserCreditsDocument.ts

@@ -1,17 +1,17 @@
-import type { 
-  PurchaseSource, 
-  PurchaseType, 
-  SubscriptionStatusType, 
+import type {
+  PurchaseSource,
+  PurchaseType,
+  SubscriptionStatusType,
   PeriodType,
   PackageType,
   Platform
 } from "../../subscription/core/SubscriptionConstants";
 
-export type { 
-  PurchaseSource, 
-  PurchaseType, 
-  SubscriptionStatusType, 
-  PeriodType 
+export type {
+  PurchaseSource,
+  PurchaseType,
+  SubscriptionStatusType,
+  PeriodType
 };
 
 export interface FirestoreTimestamp {
@@ -25,45 +25,45 @@ export interface PurchaseMetadata {
   source: PurchaseSource;
   type: PurchaseType;
   platform: Platform;
-  appVersion?: string;
+  appVersion: string;
   timestamp: FirestoreTimestamp;
 }
 
 /** Single Source of Truth for user subscription data */
 export interface UserCreditsDocumentRead {
     // Core subscription status
-    isPremium?: boolean;
-    status?: SubscriptionStatusType;
+    isPremium: boolean;
+    status: SubscriptionStatusType;
 
     // Dates (all from RevenueCat)
-    purchasedAt?: FirestoreTimestamp;
-    expirationDate?: FirestoreTimestamp;
-    lastUpdatedAt?: FirestoreTimestamp;
-    lastPurchaseAt?: FirestoreTimestamp;
+    purchasedAt: FirestoreTimestamp;
+    expirationDate: FirestoreTimestamp | null;
+    lastUpdatedAt: FirestoreTimestamp;
+    lastPurchaseAt: FirestoreTimestamp | null;
 
     // RevenueCat subscription details
-    willRenew?: boolean;
-    productId?: string;
-    packageType?: PackageType;
-    originalTransactionId?: string;
+    willRenew: boolean | null;
+    productId: string | null;
+    packageType: PackageType | null;
+    originalTransactionId: string | null;
 
     // Trial fields
-    periodType?: PeriodType;
-    isTrialing?: boolean;
-    trialStartDate?: FirestoreTimestamp;
-    trialEndDate?: FirestoreTimestamp;
-    trialCredits?: number;
-    convertedFromTrial?: boolean;
+    periodType: PeriodType | null;
+    isTrialing: boolean | null;
+    trialStartDate: FirestoreTimestamp | null;
+    trialEndDate: FirestoreTimestamp | null;
+    trialCredits: number | null;
+    convertedFromTrial: boolean | null;
 
     // Credits
     credits: number;
-    creditLimit?: number;
+    creditLimit: number;
 
     // Metadata
-    purchaseSource?: PurchaseSource;
-    purchaseType?: PurchaseType;
-    platform?: Platform;
-    appVersion?: string;
-    processedPurchases?: string[];
-    purchaseHistory?: PurchaseMetadata[];
+    purchaseSource: PurchaseSource | null;
+    purchaseType: PurchaseType | null;
+    platform: Platform;
+    appVersion: string | null;
+    processedPurchases: string[];
+    purchaseHistory: PurchaseMetadata[];
 }