@umituz/react-native-subscription 2.27.126 → 2.27.133

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.126",
+  "version": "2.27.133",
   "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/CreditLimitCalculator.ts

@@ -2,16 +2,16 @@ import type { CreditsConfig } from "../core/Credits";
 import { detectPackageType } from "../../../utils/packageTypeDetector";
 import { getCreditAllocation } from "../../../utils/creditMapper";
 
-export class CreditLimitCalculator {
-  static calculate(productId: string | undefined, config: CreditsConfig): number {
-    if (!productId) return config.creditLimit;
+export function calculateCreditLimit(productId: string | undefined, config: CreditsConfig): number {
+  if (!productId) return config.creditLimit;
 
-    const explicitAmount = config.creditPackageAmounts?.[productId];
-    if (explicitAmount) return explicitAmount;
+  const explicitAmount = config.creditPackageAmounts?.[productId];
+  if (explicitAmount) return explicitAmount;
 
-    const packageType = detectPackageType(productId);
-    const dynamicLimit = getCreditAllocation(packageType, config.packageAllocations);
-    
-    return dynamicLimit ?? config.creditLimit;
-  }
+  const packageType = detectPackageType(productId);
+  const dynamicLimit = getCreditAllocation(packageType, config.packageAllocations);
+  
+  return dynamicLimit ?? config.creditLimit;
 }
+
+

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

@@ -1,14 +1,12 @@
 import type { CreditsConfig } from "../core/Credits";
-import type { UserCreditsDocumentRead } from "../core/UserCreditsDocument";
 import { getAppVersion, validatePlatform } from "../../../utils/appUtils";
 
 import type { InitializeCreditsMetadata, InitializationResult } from "../../subscription/application/SubscriptionInitializerTypes";
-import { runTransaction, type Transaction, type DocumentReference } from "firebase/firestore";
-import type { Firestore } from "firebase/firestore";
+import { runTransaction, type Transaction, type DocumentReference, type Firestore } from "firebase/firestore";
 import { getCreditDocumentOrDefault } from "./creditDocumentHelpers";
 import { calculateNewCredits, buildCreditsData, shouldSkipStatusSyncWrite } from "./creditOperationUtils";
-import { CreditLimitCalculator } from "./CreditLimitCalculator";
-import { PurchaseMetadataGenerator } from "./PurchaseMetadataGenerator";
+import { calculateCreditLimit } from "./CreditLimitCalculator";
+import { generatePurchaseMetadata } from "./PurchaseMetadataGenerator";
 
 export async function initializeCreditsTransaction(
     db: Firestore,
@@ -17,14 +15,13 @@ export async function initializeCreditsTransaction(
     purchaseId: string,
     metadata: InitializeCreditsMetadata
 ): Promise<InitializationResult> {
-    if (!db) {
-        throw new Error("Firestore instance is not available");
-    }
+    if (!db) throw new Error("Firestore instance is not available");
+
+    const platform = validatePlatform();
+    const appVersion = getAppVersion();
 
     return runTransaction(db, async (transaction: Transaction) => {
         const creditsDoc = await transaction.get(creditsRef);
-        const platform = validatePlatform();
-
         const existingData = getCreditDocumentOrDefault(creditsDoc, platform);
 
         if (existingData.processedPurchases.includes(purchaseId)) {
@@ -35,10 +32,8 @@ export async function initializeCreditsTransaction(
             };
         }
 
-        const creditLimit = CreditLimitCalculator.calculate(metadata.productId, config);
-        const appVersion = getAppVersion();
-
-        const { purchaseHistory } = PurchaseMetadataGenerator.generate({
+        const creditLimit = calculateCreditLimit(metadata.productId, config);
+        const { purchaseHistory } = generatePurchaseMetadata({
             productId: metadata.productId,
             source: metadata.source,
             type: metadata.type,
@@ -74,15 +69,10 @@ export async function initializeCreditsTransaction(
 
         transaction.set(creditsRef, creditsData, { merge: true });
 
-        const finalData: UserCreditsDocumentRead = {
-            ...existingData,
-            ...creditsData,
-        };
-
         return {
             credits: newCredits,
             alreadyProcessed: false,
-            finalData
+            finalData: { ...existingData, ...creditsData }
         };
     });
 }

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

@@ -1,70 +1,57 @@
-import { runTransaction, serverTimestamp, type Firestore, type Transaction, type DocumentReference } from "firebase/firestore";
-import { getFirestore } from "@umituz/react-native-firebase";
+import { runTransaction, serverTimestamp, type Transaction, type DocumentReference, type Firestore } from "firebase/firestore";
 import type { DeductCreditsResult } from "../core/Credits";
+import { CREDIT_ERROR_CODES } from "../core/CreditsConstants";
 import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
 
-export interface IDeductCreditsCommand {
-  execute(userId: string, cost: number): Promise<DeductCreditsResult>;
-}
-
 /**
- * Command for deducting credits.
+ * Deducts credits from a user's balance.
  * Encapsulates the domain rules and transaction logic for credit usage.
  */
-export class DeductCreditsCommand implements IDeductCreditsCommand {
-  constructor(
-    private getCreditsRef: (db: Firestore, userId: string) => DocumentReference
-  ) {}
-
-  async execute(userId: string, cost: number): Promise<DeductCreditsResult> {
-    const db = getFirestore();
-    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");
-        }
-
-        const current = docSnap.data().credits as number;
-        if (current < cost) {
-          throw new Error("CREDITS_EXHAUSTED");
-        }
-
-        const updated = current - cost;
-        tx.update(ref, {
-          credits: updated,
-          lastUpdatedAt: serverTimestamp()
-        });
-
-        return updated;
+export async function deductCreditsOperation(
+  db: Firestore,
+  creditsRef: DocumentReference,
+  cost: number,
+  userId: string
+): Promise<DeductCreditsResult> {
+  try {
+    const remaining = await runTransaction(db, async (tx: Transaction) => {
+      const docSnap = await tx.get(creditsRef);
+
+      if (!docSnap.exists()) {
+        throw new Error(CREDIT_ERROR_CODES.NO_CREDITS);
+      }
+
+      const current = docSnap.data().credits as number;
+      if (current < cost) {
+        throw new Error(CREDIT_ERROR_CODES.CREDITS_EXHAUSTED);
+      }
+
+      const updated = current - cost;
+      tx.update(creditsRef, {
+        credits: updated,
+        lastUpdatedAt: serverTimestamp()
       });
 
-      // Emit event via EventBus (Observer Pattern)
-      subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
-
-      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,
-        remainingCredits: null,
-        error: { message, code }
-      };
-    }
+      return updated;
+    });
+
+    subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
+
+    return {
+      success: true,
+      remainingCredits: remaining,
+      error: null
+    };
+  } catch (e: unknown) {
+    const message = e instanceof Error ? e.message : String(e);
+    const code = (message === CREDIT_ERROR_CODES.NO_CREDITS || message === CREDIT_ERROR_CODES.CREDITS_EXHAUSTED) 
+      ? message 
+      : CREDIT_ERROR_CODES.DEDUCT_ERR;
+
+    return {
+      success: false,
+      remainingCredits: null,
+      error: { message, code }
+    };
   }
 }

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

@@ -6,48 +6,42 @@ import type {
   PurchaseSource
 } from "../core/UserCreditsDocument";
 import { detectPackageType } from "../../../utils/packageTypeDetector";
+import { PACKAGE_TYPE, PURCHASE_TYPE, type Platform } from "../../subscription/core/SubscriptionConstants";
 
 export interface MetadataGeneratorConfig {
   productId: string;
   source: PurchaseSource;
   type: PurchaseType;
   creditLimit: number;
-  platform: "ios" | "android";
+  platform: Platform;
   appVersion: string;
 }
 
-export class PurchaseMetadataGenerator {
-  static generate(
-    config: MetadataGeneratorConfig,
-    existingData: UserCreditsDocumentRead
-  ): { purchaseType: PurchaseType; purchaseHistory: PurchaseMetadata[] } {
-    const { productId, source, type, creditLimit, platform, appVersion } = config;
+export function generatePurchaseMetadata(
+  config: MetadataGeneratorConfig,
+  existingData: UserCreditsDocumentRead
+): { purchaseType: PurchaseType; purchaseHistory: PurchaseMetadata[] } {
+  const { productId, source, type, creditLimit, platform, appVersion } = config;
 
-    const packageType = detectPackageType(productId);
-    let purchaseType: PurchaseType = type;
+  const packageType = detectPackageType(productId);
+  let purchaseType: PurchaseType = type;
 
-    if (packageType !== "unknown") {
-      const oldLimit = existingData.creditLimit;
-      if (creditLimit > oldLimit) {
-        purchaseType = "upgrade";
-      } else if (creditLimit < oldLimit) {
-        purchaseType = "downgrade";
-      }
-    }
+  if (packageType !== PACKAGE_TYPE.UNKNOWN && creditLimit > existingData.creditLimit) {
+    purchaseType = PURCHASE_TYPE.UPGRADE;
+  }
 
-    const newMetadata: PurchaseMetadata = {
-      productId,
-      packageType,
-      creditLimit,
-      source,
-      type: purchaseType,
-      platform,
-      appVersion,
-      timestamp: Timestamp.fromDate(new Date()),
-    };
+  const newMetadata: PurchaseMetadata = {
+    productId,
+    packageType,
+    creditLimit,
+    source,
+    type: purchaseType,
+    platform,
+    appVersion,
+    timestamp: Timestamp.fromDate(new Date()),
+  };
 
-    const purchaseHistory = [...existingData.purchaseHistory, newMetadata].slice(-10);
+  const purchaseHistory = [...existingData.purchaseHistory, newMetadata].slice(-10);
 
-    return { purchaseType, purchaseHistory };
-  }
+  return { purchaseType, purchaseHistory };
 }

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

@@ -1,24 +1,15 @@
 import { ICreditStrategy, type CreditAllocationParams } from "./ICreditStrategy";
 import { isCreditPackage } from "../../../../utils/packageTypeDetector";
 
-/**
- * Default strategy for new purchases, renewals, or upgrades.
- * Resets credits for subscriptions, but ADDS credits for consumable packages.
- */
 export class StandardPurchaseCreditStrategy implements ICreditStrategy {
     canHandle(_params: CreditAllocationParams): boolean {
-        // This is a catch-all strategy
         return true;
     }
 
     execute(params: CreditAllocationParams): number {
-        // If it's a credit package (consumable), we add to existing balance
-        if (params.productId && isCreditPackage(params.productId)) {
-            const existing = params.existingData?.credits ?? 0;
-            return existing + params.creditLimit;
-        }
-
-        // Standard subscription behavior: Reset to the calculated limit (e.g. 100/mo)
-        return params.creditLimit;
+        const isConsumable = params.productId && isCreditPackage(params.productId);
+        return isConsumable 
+            ? (params.existingData?.credits ?? 0) + params.creditLimit
+            : params.creditLimit;
     }
 }

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

@@ -5,13 +5,14 @@
 
 import type { UserCreditsDocumentRead } from "../core/UserCreditsDocument";
 import { serverTimestamp, type DocumentSnapshot } from "firebase/firestore";
+import { SUBSCRIPTION_STATUS, type Platform } from "../../subscription/core/SubscriptionConstants";
 
 /**
  * Get existing credit document or create default
  */
 export function getCreditDocumentOrDefault(
     creditsDoc: DocumentSnapshot,
-    platform: "ios" | "android"
+    platform: Platform
 ): UserCreditsDocumentRead {
     if (creditsDoc.exists()) {
         return creditsDoc.data() as UserCreditsDocumentRead;
@@ -23,7 +24,7 @@ export function getCreditDocumentOrDefault(
         credits: 0,
         creditLimit: 0,
         isPremium: false,
-        status: "none",
+        status: SUBSCRIPTION_STATUS.NONE,
         processedPurchases: [],
         purchaseHistory: [],
         platform,
@@ -42,6 +43,8 @@ export function getCreditDocumentOrDefault(
         trialEndDate: null,
         trialCredits: 0,
         convertedFromTrial: false,
+        purchaseSource: null,
+        purchaseType: null,
     } as any;
 }
 

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

@@ -2,25 +2,27 @@ import { Timestamp, serverTimestamp } from "firebase/firestore";
 import { resolveSubscriptionStatus } from "../../subscription/core/SubscriptionStatus";
 import { creditAllocationOrchestrator } from "./credit-strategies/CreditAllocationOrchestrator";
 import { isPast } from "../../../utils/dateUtils";
-
+import { isCreditPackage } from "../../../utils/packageTypeDetector";
 import { 
   CalculateCreditsParams, 
   BuildCreditsDataParams 
 } from "./creditOperationUtils.types";
+import { PURCHASE_ID_PREFIXES } from "../core/CreditsConstants";
+
 
 export function calculateNewCredits({ metadata, existingData, creditLimit, purchaseId }: CalculateCreditsParams): number {
-  const isPremium = metadata.isPremium;
   const isExpired = metadata.expirationDate ? isPast(metadata.expirationDate) : false;
+  const isPremium = metadata.isPremium;
   const status = resolveSubscriptionStatus({
     isPremium,
     willRenew: metadata.willRenew ?? false,
     isExpired,
     periodType: metadata.periodType ?? undefined,
   });
-  const isStatusSync = purchaseId.startsWith("status_sync_");
+
   return creditAllocationOrchestrator.allocate({
     status,
-    isStatusSync,
+    isStatusSync: purchaseId.startsWith(PURCHASE_ID_PREFIXES.STATUS_SYNC),
     existingData,
     creditLimit,
     isSubscriptionActive: isPremium && !isExpired,
@@ -31,8 +33,13 @@ export function calculateNewCredits({ metadata, existingData, creditLimit, purch
 export function buildCreditsData({
   existingData, newCredits, creditLimit, purchaseId, metadata, purchaseHistory, platform
 }: BuildCreditsDataParams): Record<string, any> {
-  const isPremium = metadata.isPremium;
+  const isConsumable = isCreditPackage(metadata.productId ?? "");
+  const isPremium = isConsumable ? (existingData?.isPremium ?? metadata.isPremium) : metadata.isPremium;
   const isExpired = metadata.expirationDate ? isPast(metadata.expirationDate) : false;
+  const resolvedCreditLimit = isConsumable 
+    ? (existingData?.creditLimit || creditLimit) 
+    : creditLimit;
+
   const status = resolveSubscriptionStatus({
     isPremium,
     willRenew: metadata.willRenew ?? false,
@@ -40,24 +47,24 @@ export function buildCreditsData({
     periodType: metadata.periodType ?? undefined,
   });
 
-  const creditsData: Record<string, any> = {
+  const isPurchaseOrRenewal = purchaseId.startsWith(PURCHASE_ID_PREFIXES.PURCHASE) || 
+                              purchaseId.startsWith(PURCHASE_ID_PREFIXES.RENEWAL);
+
+  return {
     isPremium,
     status,
     credits: newCredits,
-    creditLimit,
+    creditLimit: resolvedCreditLimit,
     lastUpdatedAt: serverTimestamp(),
     processedPurchases: [...(existingData?.processedPurchases ?? []), purchaseId].slice(-50),
     productId: metadata.productId,
     platform,
+    ...(purchaseHistory.length > 0 && { purchaseHistory }),
+    ...(isPurchaseOrRenewal && { lastPurchaseAt: serverTimestamp() }),
+    ...(metadata.expirationDate && { expirationDate: Timestamp.fromDate(new Date(metadata.expirationDate)) }),
+    ...(metadata.willRenew !== undefined && { willRenew: metadata.willRenew }),
+    ...(metadata.originalTransactionId && { originalTransactionId: metadata.originalTransactionId }),
   };
-
-  if (purchaseHistory.length > 0) creditsData.purchaseHistory = purchaseHistory;
-  if (purchaseId.startsWith("purchase_") || purchaseId.startsWith("renewal_")) creditsData.lastPurchaseAt = serverTimestamp();
-  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;
-
-  return creditsData;
 }
 
 export function shouldSkipStatusSyncWrite(
@@ -65,12 +72,11 @@ export function shouldSkipStatusSyncWrite(
   existingData: any,
   newCreditsData: Record<string, any>
 ): boolean {
-  if (!purchaseId.startsWith("status_sync_")) return false;
-  return (
-    existingData.isPremium === newCreditsData.isPremium &&
+  if (!purchaseId.startsWith(PURCHASE_ID_PREFIXES.STATUS_SYNC)) return false;
+  
+  return existingData.isPremium === newCreditsData.isPremium &&
     existingData.status === newCreditsData.status &&
     existingData.credits === newCreditsData.credits &&
     existingData.creditLimit === newCreditsData.creditLimit &&
-    existingData.productId === newCreditsData.productId
-  );
+    existingData.productId === newCreditsData.productId;
 }

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

@@ -1,5 +1,6 @@
 import type { UserCreditsDocumentRead } from "../core/UserCreditsDocument";
 import type { InitializeCreditsMetadata } from "../../subscription/application/SubscriptionInitializerTypes";
+import type { Platform } from "../../subscription/core/SubscriptionConstants";
 
 export interface CalculateCreditsParams {
   metadata: InitializeCreditsMetadata;
@@ -15,5 +16,5 @@ export interface BuildCreditsDataParams {
   purchaseId: string;
   metadata: InitializeCreditsMetadata;
   purchaseHistory: any[];
-  platform: "ios" | "android";
+  platform: Platform;
 }

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

@@ -0,0 +1,18 @@
+/**
+ * Credit Error Codes
+ */
+export const CREDIT_ERROR_CODES = {
+  NO_CREDITS: 'NO_CREDITS',
+  CREDITS_EXHAUSTED: 'CREDITS_EXHAUSTED',
+  DEDUCT_ERR: 'DEDUCT_ERR',
+  DB_ERROR: 'ERR',
+} as const;
+
+/**
+ * Purchase ID Prefixes
+ */
+export const PURCHASE_ID_PREFIXES = {
+  STATUS_SYNC: 'status_sync_',
+  PURCHASE: 'purchase_',
+  RENEWAL: 'renewal_',
+} as const;

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

@@ -2,76 +2,64 @@ import type { UserCredits } from "./Credits";
 import { resolveSubscriptionStatus } from "../../subscription/core/SubscriptionStatus";
 import type { PeriodType, SubscriptionStatusType } from "../../subscription/core/SubscriptionConstants";
 import type { UserCreditsDocumentRead } from "./UserCreditsDocument";
-
 import { toSafeDate } from "../../../utils/dateUtils";
 
-/** Maps Firestore document to domain entity with expiration validation */
-export class CreditsMapper {
-  static toEntity(doc: UserCreditsDocumentRead): UserCredits {
-    const expirationDate = toSafeDate(doc.expirationDate);
-    const periodType = doc.periodType;
-
-    // Validate isPremium against expirationDate (real-time check)
-    const { isPremium, status } = CreditsMapper.validateSubscription(doc, expirationDate, periodType);
-
-    return {
-      // Core subscription (validated)
-      isPremium,
-      status,
-
-      // Dates
-      purchasedAt: toSafeDate(doc.purchasedAt) ?? new Date(),
-      expirationDate,
-      lastUpdatedAt: toSafeDate(doc.lastUpdatedAt) ?? new Date(),
-      lastPurchaseAt: toSafeDate(doc.lastPurchaseAt),
+/**
+ * Validate subscription status against expirationDate and periodType
+ */
+function validateSubscription(
+  doc: UserCreditsDocumentRead,
+  expirationDate: Date | null,
+  periodType: PeriodType | null
+): { isPremium: boolean; status: SubscriptionStatusType } {
+  const isPremium = doc.isPremium;
+  const willRenew = doc.willRenew ?? false;
+  const isExpired = expirationDate ? expirationDate < new Date() : false;
 
-      // RevenueCat details
-      willRenew: doc.willRenew,
-      productId: doc.productId,
-      packageType: doc.packageType,
-      originalTransactionId: doc.originalTransactionId,
+  const status = resolveSubscriptionStatus({
+    isPremium,
+    willRenew,
+    isExpired,
+    periodType: periodType ?? undefined,
+  });
 
-      // Trial fields
-      periodType,
-      isTrialing: doc.isTrialing,
-      trialStartDate: toSafeDate(doc.trialStartDate),
-      trialEndDate: toSafeDate(doc.trialEndDate),
-      trialCredits: doc.trialCredits,
-      convertedFromTrial: doc.convertedFromTrial,
-
-      // Credits
-      credits: doc.credits,
-      creditLimit: doc.creditLimit,
-
-      // Metadata
-      purchaseSource: doc.purchaseSource,
-      purchaseType: doc.purchaseType,
-      platform: doc.platform,
-      appVersion: doc.appVersion,
-    };
-  }
+  return {
+    isPremium: isExpired ? false : isPremium,
+    status,
+  };
+}
 
-  /** Validate subscription status against expirationDate and periodType */
-  private static validateSubscription(
-    doc: UserCreditsDocumentRead,
-    expirationDate: Date | null,
-    periodType: PeriodType | null
-  ): { isPremium: boolean; status: SubscriptionStatusType } {
-    const isPremium = doc.isPremium;
-    const willRenew = doc.willRenew ?? false;
-    const isExpired = expirationDate ? expirationDate < new Date() : false;
+/** 
+ * Maps Firestore document to domain entity with expiration validation 
+ */
+export function mapCreditsDocumentToEntity(doc: UserCreditsDocumentRead): UserCredits {
+  const expirationDate = toSafeDate(doc.expirationDate);
+  const periodType = doc.periodType;
 
-    const status = resolveSubscriptionStatus({
-      isPremium,
-      willRenew,
-      isExpired,
-      periodType: periodType ?? undefined,
-    });
+  const { isPremium, status } = validateSubscription(doc, expirationDate, periodType);
 
-    // Override isPremium if expired
-    return {
-      isPremium: isExpired ? false : isPremium,
-      status,
-    };
-  }
+  return {
+    isPremium,
+    status,
+    purchasedAt: toSafeDate(doc.purchasedAt) ?? new Date(),
+    expirationDate,
+    lastUpdatedAt: toSafeDate(doc.lastUpdatedAt) ?? new Date(),
+    lastPurchaseAt: toSafeDate(doc.lastPurchaseAt),
+    willRenew: doc.willRenew,
+    productId: doc.productId,
+    packageType: doc.packageType,
+    originalTransactionId: doc.originalTransactionId,
+    periodType,
+    isTrialing: doc.isTrialing,
+    trialStartDate: toSafeDate(doc.trialStartDate),
+    trialEndDate: toSafeDate(doc.trialEndDate),
+    trialCredits: doc.trialCredits,
+    convertedFromTrial: doc.convertedFromTrial,
+    credits: doc.credits,
+    creditLimit: doc.creditLimit,
+    purchaseSource: doc.purchaseSource,
+    purchaseType: doc.purchaseType,
+    platform: doc.platform,
+    appVersion: doc.appVersion,
+  };
 }

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

@@ -1,36 +1,33 @@
-/**
- * Credits Repository
- * Optimized to use Design Patterns: Command, Observer, and Strategy.
- */
-
-import { getDoc, setDoc, type Firestore } from "firebase/firestore";
+import { getDoc, setDoc, type Firestore, type DocumentReference } from "firebase/firestore";
 import { BaseRepository } from "@umituz/react-native-firebase";
 import type { CreditsConfig, CreditsResult, DeductCreditsResult } from "../core/Credits";
 import type { UserCreditsDocumentRead, PurchaseSource } from "../core/UserCreditsDocument";
 import { initializeCreditsTransaction } from "../application/CreditsInitializer";
-import { CreditsMapper } from "../core/CreditsMapper";
+import { mapCreditsDocumentToEntity } from "../core/CreditsMapper";
 import type { RevenueCatData } from "../../subscription/core/RevenueCatData";
-import { DeductCreditsCommand } from "../application/DeductCreditsCommand";
-import { CreditLimitCalculator } from "../application/CreditLimitCalculator";
+import { deductCreditsOperation } from "../application/DeductCreditsCommand";
+import { calculateCreditLimit } from "../application/CreditLimitCalculator";
 import { PURCHASE_TYPE, type PurchaseType } from "../../subscription/core/SubscriptionConstants";
 import { requireFirestore, buildDocRef, type CollectionConfig } from "../../../shared/infrastructure/firestore";
+import { SUBSCRIPTION_STATUS } from "../../subscription/core/SubscriptionConstants";
 
+/**
+ * Credits Repository
+ * Provides domain-specific database operations for credits system.
+ */
 export class CreditsRepository extends BaseRepository {
-  private deductCommand: DeductCreditsCommand;
-
   constructor(private config: CreditsConfig) {
     super();
-    this.deductCommand = new DeductCreditsCommand((db, uid) => this.getRef(db, uid));
   }
 
   private getCollectionConfig(): CollectionConfig {
     return {
-      collectionName: "credits",
+      collectionName: this.config.collectionName,
       useUserSubcollection: this.config.useUserSubcollection,
     };
   }
 
-  private getRef(db: Firestore, userId: string) {
+  private getRef(db: Firestore, userId: string): DocumentReference {
     const config = this.getCollectionConfig();
     return buildDocRef(db, userId, "balance", config);
   }
@@ -43,7 +40,7 @@ export class CreditsRepository extends BaseRepository {
       return { success: true, data: null, error: null };
     }
 
-    const entity = CreditsMapper.toEntity(snap.data() as UserCreditsDocumentRead);
+    const entity = mapCreditsDocumentToEntity(snap.data() as UserCreditsDocumentRead);
     return { success: true, data: entity, error: null };
   }
 
@@ -56,7 +53,7 @@ export class CreditsRepository extends BaseRepository {
     type: PurchaseType = PURCHASE_TYPE.INITIAL
   ): Promise<CreditsResult> {
     const db = requireFirestore();
-    const creditLimit = CreditLimitCalculator.calculate(productId, this.config);
+    const creditLimit = calculateCreditLimit(productId, this.config);
     const cfg = { ...this.config, creditLimit };
 
     const result = await initializeCreditsTransaction(
@@ -78,16 +75,17 @@ export class CreditsRepository extends BaseRepository {
 
     return {
       success: true,
-      data: result.finalData ? CreditsMapper.toEntity(result.finalData) : null,
+      data: result.finalData ? mapCreditsDocumentToEntity(result.finalData) : null,
       error: null,
     };
   }
 
   /**
-   * Delegates to DeductCreditsCommand (Command Pattern)
+   * Deducts credits using atomic transaction logic.
    */
   async deductCredit(userId: string, cost: number): Promise<DeductCreditsResult> {
-    return this.deductCommand.execute(userId, cost);
+    const db = requireFirestore();
+    return deductCreditsOperation(db, this.getRef(db, userId), cost, userId);
   }
 
   async hasCredits(userId: string, cost: number): Promise<boolean> {
@@ -101,7 +99,7 @@ export class CreditsRepository extends BaseRepository {
     const ref = this.getRef(db, userId);
     await setDoc(ref, {
       isPremium: false,
-      status: "expired",
+      status: SUBSCRIPTION_STATUS.EXPIRED,
       willRenew: false,
       expirationDate: new Date().toISOString()
     }, { merge: true });

package/src/domains/credits/presentation/useCredits.ts

@@ -8,7 +8,7 @@ import {
   getCreditsConfig,
   isCreditsRepositoryConfigured,
 } from "../infrastructure/CreditsRepositoryManager";
-import { calculateCreditPercentage, canAffordCost } from "../utils/creditCalculations";
+import { calculateCreditPercentage, canAfford as canAffordCheck } from "../../../shared/utils/numberUtils";
 
 export const creditsQueryKeys = {
   all: ["credits"] as const,
@@ -90,7 +90,7 @@ export const useCredits = (): UseCreditsResult => {
   }, [credits, config?.creditLimit]);
 
   const canAfford = useCallback(
-    (cost: number): boolean => canAffordCost(credits?.credits, cost),
+    (cost: number): boolean => canAffordCheck(credits?.credits, cost),
     [credits]
   );
 

package/src/domains/credits/presentation/useDeductCredit.ts

@@ -8,7 +8,7 @@ import { useMutation, useQueryClient } from "@umituz/react-native-design-system"
 import type { UserCredits } from "../core/Credits";
 import { getCreditsRepository } from "../infrastructure/CreditsRepositoryManager";
 import { creditsQueryKeys } from "./useCredits";
-import { calculateRemainingCredits } from "../utils/creditCalculations";
+import { calculateRemaining } from "../../../shared/utils/numberUtils";
 
 import { timezoneService } from "@umituz/react-native-design-system";
 
@@ -48,7 +48,7 @@ export const useDeductCredit = ({
       }
 
       // Calculate new credits using utility
-      const newCredits = calculateRemainingCredits(previousCredits.credits, cost);
+      const newCredits = calculateRemaining(previousCredits.credits, cost);
 
       queryClient.setQueryData<UserCredits | null>(creditsQueryKeys.user(userId), (old) => {
         if (!old) return old;

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

@@ -60,8 +60,8 @@ export const PURCHASE_TYPE = {
   INITIAL: 'initial',
   RENEWAL: 'renewal',
   UPGRADE: 'upgrade',
-  DOWNGRADE: 'downgrade',
 } as const;
 
 export type PurchaseType = (typeof PURCHASE_TYPE)[keyof typeof PURCHASE_TYPE];
 
+

package/src/domains/credits/utils/creditCalculations.ts

@@ -1,28 +0,0 @@
-/**
- * Credit Calculation Utilities
- * Centralized logic for credit mathematical operations
- * Uses shared number utilities for consistency
- */
-
-import { calculateCreditPercentage as calcPct, canAfford as canAffordCheck, calculateRemaining } from "../../../shared/utils/numberUtils";
-
-export const calculateCreditPercentage = (
-  currentCredits: number | null | undefined,
-  creditLimit: number
-): number => {
-  return calcPct(currentCredits, creditLimit);
-};
-
-export const canAffordCost = (
-  currentCredits: number | null | undefined,
-  cost: number
-): boolean => {
-  return canAffordCheck(currentCredits, cost);
-};
-
-export const calculateRemainingCredits = (
-  currentCredits: number,
-  cost: number
-): number => {
-  return calculateRemaining(currentCredits, cost);
-};