@umituz/react-native-subscription 2.27.93 → 2.27.95

package/package.json

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

@@ -28,10 +28,6 @@ export async function initializeCreditsTransaction(
         throw new Error("Firestore instance is not available");
     }
 
-    if (!metadata.productId) {
-        throw new Error("productId is required in metadata");
-    }
-
     return runTransaction(db, async (transaction: Transaction) => {
         const creditsDoc = await transaction.get(creditsRef);
         const now = serverTimestamp();
@@ -44,7 +40,11 @@ export async function initializeCreditsTransaction(
         }
 
         if (existingData.processedPurchases.includes(purchaseId)) {
-            return { credits: existingData.credits, alreadyProcessed: true };
+            return {
+                credits: existingData.credits,
+                alreadyProcessed: true,
+                finalData: existingData
+            };
         }
 
         const creditLimit = CreditLimitCalculator.calculate(metadata.productId, config);
@@ -69,15 +69,17 @@ export async function initializeCreditsTransaction(
         }, existingData);
 
         const isPremium = metadata.isPremium;
-        const isExpired = metadata.expirationDate
-            ? new Date(metadata.expirationDate).getTime() < Date.now()
-            : false;
+
+        let isExpired = false;
+        if (metadata.expirationDate) {
+            isExpired = new Date(metadata.expirationDate).getTime() < Date.now();
+        }
 
         const status = resolveSubscriptionStatus({
             isPremium,
-            willRenew: metadata.willRenew,
+            willRenew: metadata.willRenew ?? false,
             isExpired,
-            periodType: metadata.periodType,
+            periodType: metadata.periodType ?? undefined,
         });
 
         const isStatusSync = purchaseId.startsWith("status_sync_");
@@ -136,6 +138,10 @@ export async function initializeCreditsTransaction(
             ...creditsData,
         };
 
-        return { credits: newCredits, finalData };
+        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/infrastructure/CreditsRepository.ts

@@ -3,7 +3,7 @@
  * Optimized to use Design Patterns: Command, Observer, and Strategy.
  */
 
-import { doc, getDoc, serverTimestamp, updateDoc, type Firestore } from "firebase/firestore";
+import { doc, getDoc, type Firestore } from "firebase/firestore";
 import { BaseRepository, getFirestore } from "@umituz/react-native-firebase";
 import type { CreditsConfig, CreditsResult, DeductCreditsResult } from "../core/Credits";
 import type { UserCreditsDocumentRead, PurchaseSource } from "../core/UserCreditsDocument";
@@ -35,11 +35,11 @@ export class CreditsRepository extends BaseRepository {
 
     const snap = await getDoc(this.getRef(db, userId));
     if (!snap.exists()) {
-      return { success: true, data: undefined };
+      return { success: true, data: null, error: null };
     }
 
     const entity = CreditsMapper.toEntity(snap.data() as UserCreditsDocumentRead);
-    return { success: true, data: entity };
+    return { success: true, data: entity, error: null };
   }
 
   async initializeCredits(
@@ -75,7 +75,8 @@ export class CreditsRepository extends BaseRepository {
 
     return {
       success: true,
-      data: result.finalData ? CreditsMapper.toEntity(result.finalData) : undefined,
+      data: result.finalData ? CreditsMapper.toEntity(result.finalData) : null,
+      error: null,
     };
   }
 

package/src/domains/subscription/application/SubscriptionInitializerTypes.ts

@@ -13,38 +13,38 @@ export interface FirebaseAuthLike {
 }
 
 export interface CreditPackageConfig {
-  identifierPattern?: string;
-  amounts?: Record<string, number>;
+  identifierPattern: string;
+  amounts: Record<string, number>;
 }
 
 export interface SubscriptionInitConfig {
-  apiKey?: string;
-  apiKeyIos?: string;
-  apiKeyAndroid?: string;
+  apiKey: string;
+  apiKeyIos: string;
+  apiKeyAndroid: string;
   entitlementId: string;
   credits: CreditsConfig;
   getAnonymousUserId: () => Promise<string>;
   getFirebaseAuth: () => FirebaseAuthLike | null;
   showAuthModal: () => void;
-  onCreditsUpdated?: (userId: string) => void;
-  creditPackages?: CreditPackageConfig;
-  timeoutMs?: number;
-  authStateTimeoutMs?: number;
+  onCreditsUpdated: (userId: string) => void;
+  creditPackages: CreditPackageConfig;
+  timeoutMs: number;
+  authStateTimeoutMs: number;
 }
 
 export interface InitializeCreditsMetadata {
-  productId?: string;
-  source?: PurchaseSource;
-  type?: PurchaseType;
-  expirationDate?: string | null;
-  willRenew?: boolean;
-  originalTransactionId?: string;
-  isPremium?: boolean;
-  periodType?: PeriodType;
+  productId: string;
+  source: PurchaseSource;
+  type: PurchaseType;
+  expirationDate: string | null;
+  willRenew: boolean | null;
+  originalTransactionId: string | null;
+  isPremium: boolean;
+  periodType: PeriodType | null;
 }
 
 export interface InitializationResult {
-    credits: number;
-    alreadyProcessed?: boolean;
-    finalData?: UserCreditsDocumentRead;
+  credits: number;
+  alreadyProcessed: boolean;
+  finalData: UserCreditsDocumentRead | null;
 }

package/src/domains/subscription/core/RevenueCatData.ts

@@ -5,10 +5,10 @@ import type { PeriodType } from "./SubscriptionStatus";
  * Used across the subscription package for storing RevenueCat data in Firestore
  */
 export interface RevenueCatData {
-  expirationDate?: string | null;
-  willRenew?: boolean;
-  originalTransactionId?: string;
-  isPremium?: boolean;
+  expirationDate: string | null;
+  willRenew: boolean | null;
+  originalTransactionId: string | null;
+  isPremium: boolean;
   /** RevenueCat period type: NORMAL, INTRO, or TRIAL */
-  periodType?: PeriodType;
+  periodType: PeriodType | null;
 }