@umituz/react-native-subscription 2.37.37 → 2.37.39

package/package.json

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

@@ -4,9 +4,10 @@ import { getAppVersion, validatePlatform } from "../../../utils/appUtils";
 import type { InitializeCreditsMetadata, InitializationResult } from "../../subscription/application/SubscriptionInitializerTypes";
 import { runTransaction, type Transaction, type DocumentReference, type Firestore } from "@umituz/react-native-firebase";
 import { getCreditDocumentOrDefault } from "./creditDocumentHelpers";
-import { calculateNewCredits, buildCreditsData, shouldSkipStatusSyncWrite } from "./creditOperationUtils";
+import { calculateNewCredits, buildCreditsData } from "./creditOperationUtils";
 import { calculateCreditLimit } from "./CreditLimitCalculator";
 import { generatePurchaseMetadata } from "./PurchaseMetadataGenerator";
+import { PURCHASE_ID_PREFIXES } from "../core/CreditsConstants";
 
 export async function initializeCreditsTransaction(
     _db: Firestore,
@@ -16,11 +17,16 @@ export async function initializeCreditsTransaction(
     metadata: InitializeCreditsMetadata
 ): Promise<InitializationResult> {
 
+    if (!purchaseId.startsWith(PURCHASE_ID_PREFIXES.PURCHASE) && !purchaseId.startsWith(PURCHASE_ID_PREFIXES.RENEWAL)) {
+        throw new Error(`[CreditsInitializer] Only purchase and renewal operations can allocate credits. Received: ${purchaseId}`);
+    }
+
     const platform = validatePlatform();
     const appVersion = getAppVersion();
 
     return runTransaction(async (transaction: Transaction) => {
         const creditsDoc = await transaction.get(creditsRef);
+
         const existingData = getCreditDocumentOrDefault(creditsDoc, platform);
 
         if (existingData.processedPurchases.includes(purchaseId)) {
@@ -58,14 +64,6 @@ export async function initializeCreditsTransaction(
             platform,
         });
 
-        if (shouldSkipStatusSyncWrite(purchaseId, existingData, creditsData)) {
-            return {
-                credits: existingData.credits,
-                alreadyProcessed: true,
-                finalData: existingData
-            };
-        }
-
         transaction.set(creditsRef, creditsData, { merge: true });
 
         return {

package/src/domains/credits/application/credit-strategies/CreditAllocationOrchestrator.ts

@@ -1,21 +1,13 @@
 import type { ICreditStrategy, CreditAllocationParams } from "./ICreditStrategy";
-import { SyncCreditStrategy } from "./SyncCreditStrategy";
 import { TrialCreditStrategy } from "./TrialCreditStrategy";
 import { StandardPurchaseCreditStrategy } from "./StandardPurchaseCreditStrategy";
 
-/**
- * Orchestrator to coordinate credit allocation logic using the Strategy Pattern.
- */
 class CreditAllocationOrchestrator {
     private strategies: ICreditStrategy[] = [
-        new SyncCreditStrategy(),
         new TrialCreditStrategy(),
-        new StandardPurchaseCreditStrategy(), // Fallback strategy
+        new StandardPurchaseCreditStrategy(),
     ];
 
-    /**
-     * Finds the first applicable strategy and executes its logic.
-     */
     allocate(params: CreditAllocationParams): number {
         const strategy = this.strategies.find(s => s.canHandle(params));
 

package/src/domains/credits/application/credit-strategies/ICreditStrategy.ts

@@ -1,9 +1,8 @@
 import type { SubscriptionStatusType } from "../../../subscription/core/SubscriptionStatus";
 import type { UserCreditsDocumentRead } from "../../core/UserCreditsDocument";
 
-export interface CreditStrategyParams {
+export interface CreditAllocationParams {
     status: SubscriptionStatusType;
-    isStatusSync: boolean;
     existingData: UserCreditsDocumentRead | null;
     creditLimit: number;
     isSubscriptionActive: boolean;
@@ -14,6 +13,3 @@ export interface ICreditStrategy {
     canHandle(params: CreditAllocationParams): boolean;
     execute(params: CreditAllocationParams): number;
 }
-
-// Renaming the input for clarity
-export type CreditAllocationParams = CreditStrategyParams;

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

@@ -23,7 +23,6 @@ export function calculateNewCredits({ metadata, existingData, creditLimit, purch
 
   return creditAllocationOrchestrator.allocate({
     status,
-    isStatusSync: purchaseId.startsWith(PURCHASE_ID_PREFIXES.STATUS_SYNC),
     existingData,
     creditLimit,
     isSubscriptionActive: isPremium && !isExpired,
@@ -49,7 +48,7 @@ export function buildCreditsData({
     periodType: metadata.periodType ?? undefined,
   });
 
-  const isPurchaseOrRenewal = purchaseId.startsWith(PURCHASE_ID_PREFIXES.PURCHASE) || 
+  const isPurchaseOrRenewal = purchaseId.startsWith(PURCHASE_ID_PREFIXES.PURCHASE) ||
                               purchaseId.startsWith(PURCHASE_ID_PREFIXES.RENEWAL);
 
   const expirationTimestamp = metadata.expirationDate ? toTimestamp(metadata.expirationDate) : null;
@@ -76,44 +75,3 @@ export function buildCreditsData({
     ...(metadata.ownershipType && { ownershipType: metadata.ownershipType }),
   };
 }
-
-/**
- * Compare two Firestore Timestamp-like values by their underlying time.
- * Handles Timestamp objects (with toMillis/seconds+nanoseconds), null, and undefined.
- */
-function timestampsEqual(a: unknown, b: unknown): boolean {
-  if (a === b) return true;
-  if (a == null || b == null) return a == b;
-  if (typeof a === "object" && typeof b === "object" && a !== null && b !== null) {
-    if ("toMillis" in a && "toMillis" in b &&
-        typeof (a as { toMillis: unknown }).toMillis === "function" &&
-        typeof (b as { toMillis: unknown }).toMillis === "function") {
-      return (a as { toMillis: () => number }).toMillis() === (b as { toMillis: () => number }).toMillis();
-    }
-    if ("seconds" in a && "seconds" in b && "nanoseconds" in a && "nanoseconds" in b) {
-      return (a as { seconds: number; nanoseconds: number }).seconds === (b as { seconds: number; nanoseconds: number }).seconds &&
-             (a as { seconds: number; nanoseconds: number }).nanoseconds === (b as { seconds: number; nanoseconds: number }).nanoseconds;
-    }
-  }
-  return false;
-}
-
-export function shouldSkipStatusSyncWrite(
-  purchaseId: string,
-  existingData: any,
-  newCreditsData: Record<string, any>
-): boolean {
-  if (!purchaseId.startsWith(PURCHASE_ID_PREFIXES.STATUS_SYNC)) return false;
-
-  if (!existingData || !newCreditsData) return false;
-
-  return existingData.isPremium === newCreditsData.isPremium &&
-    existingData.status === newCreditsData.status &&
-    existingData.credits === newCreditsData.credits &&
-    existingData.creditLimit === newCreditsData.creditLimit &&
-    existingData.productId === newCreditsData.productId &&
-    existingData.willRenew === newCreditsData.willRenew &&
-    timestampsEqual(existingData.expirationDate, newCreditsData.expirationDate) &&
-    timestampsEqual(existingData.canceledAt, newCreditsData.canceledAt) &&
-    timestampsEqual(existingData.billingIssueDetectedAt, newCreditsData.billingIssueDetectedAt);
-}

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

@@ -1,6 +1,3 @@
-/**
- * Credit Error Codes
- */
 export const CREDIT_ERROR_CODES = {
   NO_CREDITS: 'NO_CREDITS',
   CREDITS_EXHAUSTED: 'CREDITS_EXHAUSTED',
@@ -8,17 +5,9 @@ export const CREDIT_ERROR_CODES = {
   DB_ERROR: 'ERR',
 } as const;
 
-/**
- * Purchase ID Prefixes
- */
 export const PURCHASE_ID_PREFIXES = {
-  STATUS_SYNC: 'status_sync_',
   PURCHASE: 'purchase_',
   RENEWAL: 'renewal_',
 } as const;
 
-/**
- * Processed Purchases Array Window Size
- * Maintains last N purchases to prevent reprocessing
- */
 export const PROCESSED_PURCHASES_WINDOW = 50;

package/src/domains/credits/infrastructure/CreditsRepository.ts

@@ -8,7 +8,7 @@ import { refundCreditsOperation } from "../application/RefundCreditsCommand";
 import { PURCHASE_TYPE, type PurchaseType } from "../../subscription/core/SubscriptionConstants";
 import { requireFirestore, buildDocRef, type CollectionConfig } from "../../../shared/infrastructure/firestore";
 import { fetchCredits, checkHasCredits } from "./operations/CreditsFetcher";
-import { syncExpiredStatus } from "./operations/CreditsWriter";
+import { syncExpiredStatus, syncPremiumMetadata, type PremiumMetadata } from "./operations/CreditsWriter";
 import { initializeCreditsWithRetry } from "./operations/CreditsInitializer";
 
 export class CreditsRepository extends BaseRepository {
@@ -74,6 +74,11 @@ export class CreditsRepository extends BaseRepository {
     const db = requireFirestore();
     await syncExpiredStatus(this.getRef(db, userId));
   }
+
+  async syncPremiumMetadata(userId: string, metadata: PremiumMetadata): Promise<void> {
+    const db = requireFirestore();
+    await syncPremiumMetadata(this.getRef(db, userId), metadata);
+  }
 }
 
 export function createCreditsRepository(config: CreditsConfig): CreditsRepository {

package/src/domains/credits/infrastructure/operations/CreditsWriter.ts

@@ -1,9 +1,14 @@
-import { setDoc } from "firebase/firestore";
+import { getDoc, setDoc } from "firebase/firestore";
 import type { DocumentReference } from "@umituz/react-native-firebase";
 import { serverTimestamp } from "@umituz/react-native-firebase";
 import { SUBSCRIPTION_STATUS } from "../../../subscription/core/SubscriptionConstants";
+import { resolveSubscriptionStatus } from "../../../subscription/core/SubscriptionStatus";
+import { toTimestamp } from "../../../../shared/utils/dateConverter";
 
 export async function syncExpiredStatus(ref: DocumentReference): Promise<void> {
+  const doc = await getDoc(ref);
+  if (!doc.exists()) return;
+
   await setDoc(ref, {
     isPremium: false,
     status: SUBSCRIPTION_STATUS.EXPIRED,
@@ -11,3 +16,48 @@ export async function syncExpiredStatus(ref: DocumentReference): Promise<void> {
     lastUpdatedAt: serverTimestamp(),
   }, { merge: true });
 }
+
+export interface PremiumMetadata {
+  isPremium: boolean;
+  willRenew: boolean;
+  expirationDate: string | null;
+  productId: string;
+  periodType: string | null;
+  unsubscribeDetectedAt: string | null;
+  billingIssueDetectedAt: string | null;
+  store: string | null;
+  ownershipType: string | null;
+}
+
+export async function syncPremiumMetadata(
+  ref: DocumentReference,
+  metadata: PremiumMetadata
+): Promise<void> {
+  const doc = await getDoc(ref);
+  if (!doc.exists()) return;
+
+  const isExpired = false;
+  const status = resolveSubscriptionStatus({
+    isPremium: metadata.isPremium,
+    willRenew: metadata.willRenew,
+    isExpired,
+    periodType: metadata.periodType ?? undefined,
+  });
+
+  const expirationTimestamp = metadata.expirationDate ? toTimestamp(metadata.expirationDate) : null;
+  const canceledAtTimestamp = metadata.unsubscribeDetectedAt ? toTimestamp(metadata.unsubscribeDetectedAt) : null;
+  const billingIssueTimestamp = metadata.billingIssueDetectedAt ? toTimestamp(metadata.billingIssueDetectedAt) : null;
+
+  await setDoc(ref, {
+    isPremium: metadata.isPremium,
+    status,
+    willRenew: metadata.willRenew,
+    productId: metadata.productId,
+    lastUpdatedAt: serverTimestamp(),
+    ...(expirationTimestamp && { expirationDate: expirationTimestamp }),
+    ...(canceledAtTimestamp && { canceledAt: canceledAtTimestamp }),
+    ...(billingIssueTimestamp && { billingIssueDetectedAt: billingIssueTimestamp }),
+    ...(metadata.store && { store: metadata.store }),
+    ...(metadata.ownershipType && { ownershipType: metadata.ownershipType }),
+  }, { merge: true });
+}

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

@@ -69,19 +69,15 @@ export class SubscriptionSyncProcessor {
   ) {
     const creditsUserId = await this.getCreditsUserId(userId);
 
-    // Expired subscription case
     if (!isPremium && productId) {
       await handleExpiredSubscription(creditsUserId);
       return;
     }
 
-    // Free user case - no Firestore document needed
-    // Credits absence means no subscription (app handles null gracefully)
     if (!isPremium && !productId) {
       return;
     }
 
-    // Premium user case - productId is required
     if (!productId) {
       return;
     }

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

@@ -15,17 +15,8 @@ export class SubscriptionSyncService {
   }
 
   async handlePurchase(userId: string, productId: string, customerInfo: CustomerInfo, source?: PurchaseSource, packageType?: PackageType | null) {
-    try {
-      await this.processor.processPurchase(userId, productId, customerInfo, source, packageType);
-      subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PURCHASE_COMPLETED, { userId, productId });
-    } catch (error) {
-      console.error('[SubscriptionSyncService] Purchase processing failed', {
-        userId,
-        productId,
-        source,
-        error
-      });
-    }
+    await this.processor.processPurchase(userId, productId, customerInfo, source, packageType);
+    subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PURCHASE_COMPLETED, { userId, productId });
   }
 
   async handleRenewal(userId: string, productId: string, newExpirationDate: string, customerInfo: CustomerInfo) {
@@ -37,7 +28,7 @@ export class SubscriptionSyncService {
         userId,
         productId,
         newExpirationDate,
-        error
+        error: error instanceof Error ? error.message : String(error)
       });
     }
   }
@@ -58,12 +49,8 @@ export class SubscriptionSyncService {
         userId,
         isPremium,
         productId,
-        expiresAt,
-        willRenew,
-        periodType,
-        error
+        error: error instanceof Error ? error.message : String(error)
       });
     }
   }
 }
-

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

@@ -1,9 +1,6 @@
-import type { RevenueCatData } from "../../revenuecat/core/types";
 import type { PeriodType } from "../core/SubscriptionConstants";
-import { PURCHASE_SOURCE, PURCHASE_TYPE } from "../core/SubscriptionConstants";
 import { getCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryManager";
 import { emitCreditsUpdated } from "./syncEventEmitter";
-import { generateStatusSyncId } from "./syncIdGenerators";
 
 export const handleExpiredSubscription = async (userId: string): Promise<void> => {
   await getCreditsRepository().syncExpiredStatus(userId);
@@ -16,32 +13,22 @@ export const handlePremiumStatusSync = async (
   productId: string,
   expiresAt: string | null,
   willRenew: boolean,
-  periodType: PeriodType | null
+  periodType: PeriodType | null,
+  unsubscribeDetectedAt?: string | null,
+  billingIssueDetectedAt?: string | null,
+  store?: string | null,
+  ownershipType?: string | null
 ): Promise<void> => {
-
-  const revenueCatData: RevenueCatData = {
-    expirationDate: expiresAt,
-    willRenew,
+  await getCreditsRepository().syncPremiumMetadata(userId, {
     isPremium,
-    periodType,
-    packageType: null,
-    originalTransactionId: null,
-    unsubscribeDetectedAt: null,
-    billingIssueDetectedAt: null,
-    store: null,
-    ownershipType: null
-  };
-
-  const statusSyncId = generateStatusSyncId(userId, isPremium);
-
-  await getCreditsRepository().initializeCredits(
-    userId,
-    statusSyncId,
+    willRenew,
+    expirationDate: expiresAt,
     productId,
-    PURCHASE_SOURCE.SETTINGS,
-    revenueCatData,
-    PURCHASE_TYPE.INITIAL
-  );
-
+    periodType,
+    unsubscribeDetectedAt: unsubscribeDetectedAt ?? null,
+    billingIssueDetectedAt: billingIssueDetectedAt ?? null,
+    store: store ?? null,
+    ownershipType: ownershipType ?? null,
+  });
   emitCreditsUpdated(userId);
 };

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

@@ -9,7 +9,3 @@ export const generateRenewalId = (originalTransactionId: string | null, productI
     ? `renewal_${originalTransactionId}_${expirationDate}`
     : `renewal_${productId}_${Date.now()}`;
 };
-
-export const generateStatusSyncId = (userId: string, isPremium: boolean): string => {
-  return `status_sync_${userId}_${isPremium ? 'premium' : 'free'}`;
-};

package/src/domains/subscription/infrastructure/utils/PremiumStatusSyncer.ts

@@ -70,16 +70,7 @@ export async function notifyPurchaseCompleted(
         return;
     }
 
-    try {
-        await config.onPurchaseCompleted(userId, productId, customerInfo, source, packageType);
-    } catch (error) {
-        // Silently fail callback notifications to prevent crashing the main flow
-        console.error('[PremiumStatusSyncer] Purchase completed callback failed:', {
-            userId,
-            productId,
-            error: error instanceof Error ? error.message : String(error)
-        });
-    }
+    await config.onPurchaseCompleted(userId, productId, customerInfo, source, packageType);
 }
 
 export async function notifyRestoreCompleted(

package/src/domains/credits/application/credit-strategies/SyncCreditStrategy.ts

@@ -1,27 +0,0 @@
-import { ICreditStrategy, type CreditAllocationParams } from "./ICreditStrategy";
-
-/**
- * Strategy for existing premium users during a simple status synchronization.
- * Preserves their current credits to avoid accidental resets.
- */
-export class SyncCreditStrategy implements ICreditStrategy {
-    canHandle(params: CreditAllocationParams): boolean {
-        return params.isStatusSync;
-    }
-
-    execute(params: CreditAllocationParams): number {
-        const existingCredits = params.existingData?.credits;
-        const hasExistingCredits = typeof existingCredits === 'number' && existingCredits >= 0;
-        const hasExistingDocument = (params.existingData?.processedPurchases?.length ?? 0) > 0;
-
-        if (params.isSubscriptionActive && !hasExistingDocument) {
-            return params.creditLimit;
-        }
-
-        if (hasExistingCredits && params.existingData) {
-            return params.existingData.credits;
-        }
-
-        return params.creditLimit;
-    }
-}