@umituz/react-native-subscription 2.37.38 → 2.37.40

package/package.json

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

@@ -1,20 +1,14 @@
 import type { CreditsConfig } from "../core/Credits";
 import { detectPackageType } from "../../../utils/packageTypeDetector";
 import { getCreditAllocation } from "../../../utils/creditMapper";
-import { NO_SUBSCRIPTION_PRODUCT_ID } from "../../subscription/application/syncConstants";
 
 export function calculateCreditLimit(productId: string | undefined, config: CreditsConfig): number {
   if (!productId) {
     throw new Error("[CreditLimitCalculator] Cannot calculate credit limit without productId");
   }
 
-  // Free tier users (no subscription) get 0 credits - strict paywall
-  if (productId === NO_SUBSCRIPTION_PRODUCT_ID) {
-    return 0;
-  }
-
   const explicitAmount = config.creditPackageAmounts?.[productId];
-  if (explicitAmount) return explicitAmount;
+  if (explicitAmount !== undefined && explicitAmount !== null) return explicitAmount;
 
   const packageType = detectPackageType(productId);
   const dynamicLimit = getCreditAllocation(packageType, config.packageAllocations);
@@ -25,5 +19,3 @@ export function calculateCreditLimit(productId: string | undefined, config: Cred
 
   return dynamicLimit;
 }
-
-

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

@@ -4,7 +4,7 @@ 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";
@@ -17,23 +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);
 
-        // Status sync must NEVER create new documents.
-        // Credits documents are only created by purchase/renewal flows.
-        const isStatusSync = purchaseId.startsWith(PURCHASE_ID_PREFIXES.STATUS_SYNC);
-        if (isStatusSync && !creditsDoc.exists()) {
-            return {
-                credits: 0,
-                alreadyProcessed: true,
-                finalData: null
-            };
-        }
-
         const existingData = getCreditDocumentOrDefault(creditsDoc, platform);
 
         if (existingData.processedPurchases.includes(purchaseId)) {
@@ -71,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/DeductCreditsCommand.ts

@@ -3,10 +3,6 @@ import type { DeductCreditsResult } from "../core/Credits";
 import { CREDIT_ERROR_CODES } from "../core/CreditsConstants";
 import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
 
-/**
- * Deducts credits from a user's balance.
- * Encapsulates the domain rules and transaction logic for credit usage.
- */
 export async function deductCreditsOperation(
   _db: Firestore,
   creditsRef: DocumentReference,
@@ -24,6 +20,17 @@ export async function deductCreditsOperation(
     };
   }
 
+  if (cost <= 0 || !Number.isFinite(cost)) {
+    return {
+      success: false,
+      remainingCredits: null,
+      error: {
+        message: 'Cost must be a positive finite number',
+        code: 'INVALID_AMOUNT'
+      }
+    };
+  }
+
   try {
     const remaining = await runTransaction(async (tx: Transaction) => {
       const docSnap = await tx.get(creditsRef);
@@ -55,8 +62,8 @@ export async function deductCreditsOperation(
     };
   } 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 
+    const code = (message === CREDIT_ERROR_CODES.NO_CREDITS || message === CREDIT_ERROR_CODES.CREDITS_EXHAUSTED)
+      ? message
       : CREDIT_ERROR_CODES.DEDUCT_ERR;
 
     return {

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

@@ -3,10 +3,6 @@ import type { DeductCreditsResult } from "../core/Credits";
 import { CREDIT_ERROR_CODES } from "../core/CreditsConstants";
 import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
 
-/**
- * Refunds credits to a user's balance.
- * Used for optimistic billing rollbacks when generation fails due to transient errors.
- */
 export async function refundCreditsOperation(
   _db: Firestore,
   creditsRef: DocumentReference,
@@ -24,7 +20,7 @@ export async function refundCreditsOperation(
     };
   }
 
-  if (amount <= 0) {
+  if (amount <= 0 || !Number.isFinite(amount)) {
     return {
       success: false,
       remainingCredits: null,

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/credit-strategies/TrialCreditStrategy.ts

@@ -2,13 +2,9 @@ import { ICreditStrategy, type CreditAllocationParams } from "./ICreditStrategy"
 import { SUBSCRIPTION_STATUS } from "../../../subscription/core/SubscriptionConstants";
 import { TRIAL_CONFIG } from "../../../trial/core/TrialTypes";
 
-/**
- * Strategy for Trial and Trial Canceled users.
- * Allocates credits based on trial configuration.
- */
 export class TrialCreditStrategy implements ICreditStrategy {
     canHandle(params: CreditAllocationParams): boolean {
-        return params.status === SUBSCRIPTION_STATUS.TRIAL || 
+        return params.status === SUBSCRIPTION_STATUS.TRIAL ||
                params.status === SUBSCRIPTION_STATUS.TRIAL_CANCELED;
     }
 

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

@@ -1,14 +1,7 @@
-/**
- * Credit Document Helpers
- * Utilities for getting and creating credit documents
- */
-
 import type { UserCreditsDocumentRead } from "../core/UserCreditsDocument";
 import { serverTimestamp, type DocumentSnapshot } from "@umituz/react-native-firebase";
 import { SUBSCRIPTION_STATUS, type Platform } from "../../subscription/core/SubscriptionConstants";
-/**
- * Get existing credit document or create default
- */
+
 export function getCreditDocumentOrDefault(
     creditsDoc: DocumentSnapshot,
     platform: Platform
@@ -17,7 +10,7 @@ export function getCreditDocumentOrDefault(
         return creditsDoc.data() as UserCreditsDocumentRead;
     }
 
-    const now = serverTimestamp() as any; // FieldValue for Firestore write
+    const now = serverTimestamp() as any;
 
     const defaultDocument: UserCreditsDocumentRead = {
         credits: 0,

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/Credits.ts

@@ -1,12 +1,4 @@
-/**
- * Credits Domain Entities
- *
- * Generic credit system types for subscription-based apps.
- * Designed to be used across hundreds of apps with configurable limits.
- */
-
 import type { SubscriptionPackageType } from "../../../utils/packageTypeDetector";
-// Types imported from SubscriptionConstants are used directly in UserCredits interface
 import type {
   SubscriptionStatusType,
   PackageType,
@@ -17,37 +9,25 @@ import type {
 
 export type CreditType = "text" | "image";
 
-/** Single Source of Truth for user subscription + credits data */
 export interface UserCredits {
-  // Core subscription
   isPremium: boolean;
   status: SubscriptionStatusType;
-
-  // Dates
   purchasedAt: Date | null;
   expirationDate: Date | null;
   lastUpdatedAt: Date | null;
   lastPurchaseAt: Date | null;
-
-  // RevenueCat subscription details
   willRenew: boolean | null;
   productId: string | null;
   packageType: PackageType | null;
   originalTransactionId: string | null;
-
-  // Trial fields - periodType comes from RevenueCat SDK
   periodType: string | null;
   isTrialing: boolean | null;
   trialStartDate: Date | null;
   trialEndDate: Date | null;
   trialCredits: number | null;
   convertedFromTrial: boolean | null;
-
-  // Credits
   credits: number;
   creditLimit: number;
-
-  // Metadata
   purchaseSource: PurchaseSource | null;
   purchaseType: PurchaseType | null;
   platform: Platform;
@@ -66,11 +46,8 @@ export type PackageAllocationMap = Partial<Record<
 export interface CreditsConfig {
   collectionName: string;
   creditLimit: number;
-  /** When true, stores credits at users/{userId}/credits instead of {collectionName}/{userId} */
   useUserSubcollection: boolean;
-  /** Credit amounts per product ID for consumable credit packages */
   creditPackageAmounts: Record<string, number>;
-  /** Credit allocations for different subscription types (weekly, monthly, yearly) */
   packageAllocations: PackageAllocationMap;
 }
 

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/core/CreditsMapper.ts

@@ -3,9 +3,6 @@ import { resolveSubscriptionStatus, type SubscriptionStatusType } from "../../su
 import type { UserCreditsDocumentRead } from "./UserCreditsDocument";
 import { toSafeDate } from "../../../utils/dateUtils";
 
-/**
- * Validate subscription status against expirationDate and periodType
- */
 function validateSubscription(
   doc: UserCreditsDocumentRead,
   expirationDate: Date | null,
@@ -28,9 +25,6 @@ function validateSubscription(
   };
 }
 
-/** 
- * Maps Firestore document to domain entity with expiration validation 
- */
 export function mapCreditsDocumentToEntity(doc: UserCreditsDocumentRead): UserCredits {
   const expirationDate = toSafeDate(doc.expirationDate);
   const periodType = doc.periodType;

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

@@ -30,41 +30,29 @@ export interface PurchaseMetadata {
   timestamp: FirestoreTimestamp;
 }
 
-/** Single Source of Truth for user subscription data */
 export interface UserCreditsDocumentRead {
-    // Core subscription status
     isPremium: boolean;
     status: SubscriptionStatusType;
-
-    // Dates (all from RevenueCat)
     purchasedAt: FirestoreTimestamp;
     expirationDate: FirestoreTimestamp | null;
     lastUpdatedAt: FirestoreTimestamp;
     lastPurchaseAt: FirestoreTimestamp | null;
     canceledAt: FirestoreTimestamp | null;
     billingIssueDetectedAt: FirestoreTimestamp | null;
-
-    // RevenueCat subscription details
     willRenew: boolean | null;
     productId: string | null;
     packageType: PackageType | null;
     originalTransactionId: string | null;
     store: Store | null;
     ownershipType: OwnershipType | null;
-
-    // Trial fields
     periodType: string | null;
     isTrialing: boolean | null;
     trialStartDate: FirestoreTimestamp | null;
     trialEndDate: FirestoreTimestamp | null;
     trialCredits: number | null;
     convertedFromTrial: boolean | null;
-
-    // Credits
     credits: number;
     creditLimit: number;
-
-    // Metadata
     purchaseSource: PurchaseSource | null;
     purchaseType: PurchaseType | null;
     platform: Platform;

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/CreditsRepositoryManager.ts

@@ -1,9 +1,3 @@
-/**
- * Credits Repository Manager
- * Module-level singleton for credits repository configuration
- * Provides a clean, testable approach for repository access
- */
-
 import type { CreditsConfig } from "../core/Credits";
 import type { CreditsRepository } from "./CreditsRepository";
 import { createCreditsRepository } from "./CreditsRepository";
@@ -11,26 +5,15 @@ import { createCreditsRepository } from "./CreditsRepository";
 let globalRepository: CreditsRepository | null = null;
 let globalConfig: CreditsConfig | null = null;
 
-/**
- * Configure credits repository for the application
- * Must be called once during app initialization
- */
 export function configureCreditsRepository(config: CreditsConfig): void {
   globalConfig = config;
   globalRepository = createCreditsRepository(globalConfig);
 }
 
-/**
- * Check if credits repository is configured
- */
 export function isCreditsRepositoryConfigured(): boolean {
   return globalRepository !== null;
 }
 
-/**
- * Get the configured credits repository
- * Throws if repository not configured
- */
 export function getCreditsRepository(): CreditsRepository {
   if (!globalRepository) {
     throw new Error(
@@ -40,9 +23,6 @@ export function getCreditsRepository(): CreditsRepository {
   return globalRepository;
 }
 
-/**
- * Get the current credits configuration
- */
 export function getCreditsConfig(): CreditsConfig {
   if (!globalConfig) {
     throw new Error(
@@ -51,4 +31,3 @@ export function getCreditsConfig(): CreditsConfig {
   }
   return globalConfig;
 }
-

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

@@ -1,9 +1,15 @@
-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";
+import { isPast } from "../../../../utils/dateUtils";
 
 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 +17,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 = metadata.expirationDate ? isPast(metadata.expirationDate) : 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/credits/presentation/deduct-credit/useDeductCredit.ts

@@ -35,9 +35,9 @@ export const useDeductCredit = ({
       console.error('[useDeductCredit] Unexpected error during credit deduction', {
         cost,
         userId,
-        error
+        error: error instanceof Error ? error.message : String(error)
       });
-      throw error;
+      return false;
     }
   }, [onCreditsExhausted, userId]);
 

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

@@ -1,6 +1,6 @@
 import { useQuery, useQueryClient } from "@umituz/react-native-design-system";
 import { useCallback, useMemo, useEffect } from "react";
-import { useAuthStore, selectUserId } from "@umituz/react-native-auth";
+import { useAuthStore, selectUserId, selectIsAnonymous } from "@umituz/react-native-auth";
 import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
 import { NO_CACHE_QUERY_CONFIG } from "../../../shared/infrastructure/react-query/queryConfig";
 import { usePreviousUserCleanup } from "../../../shared/infrastructure/react-query/hooks/usePreviousUserCleanup";
@@ -10,7 +10,7 @@ import {
   isCreditsRepositoryConfigured,
 } from "../infrastructure/CreditsRepositoryManager";
 import { calculateSafePercentage, canAffordAmount } from "../utils/creditValidation";
-import { isAuthenticated } from "../../subscription/utils/authGuards";
+import { isRegisteredUser } from "../../subscription/utils/authGuards";
 import { creditsQueryKeys } from "./creditsQueryKeys";
 import type { UseCreditsResult, CreditsLoadStatus } from "./useCredits.types";
 
@@ -26,15 +26,17 @@ const deriveLoadStatus = (
 
 export const useCredits = (): UseCreditsResult => {
   const userId = useAuthStore(selectUserId);
+  const isAnonymous = useAuthStore(selectIsAnonymous);
   const isConfigured = isCreditsRepositoryConfigured();
 
   const config = isConfigured ? getCreditsConfig() : null;
-  const queryEnabled = isAuthenticated(userId) && isConfigured;
+  const isUserRegistered = isRegisteredUser(userId, isAnonymous);
+  const queryEnabled = isUserRegistered && isConfigured;
 
   const { data, status, error, refetch } = useQuery({
     queryKey: creditsQueryKeys.user(userId),
     queryFn: async () => {
-      if (!isAuthenticated(userId) || !isConfigured) return null;
+      if (!isUserRegistered || !isConfigured) return null;
 
       const repository = getCreditsRepository();
       const result = await repository.getCredits(userId);
@@ -51,11 +53,10 @@ export const useCredits = (): UseCreditsResult => {
 
   const queryClient = useQueryClient();
 
-  // Clean up previous user's cache on logout/user switch
   usePreviousUserCleanup(userId, queryClient, creditsQueryKeys.user);
 
   useEffect(() => {
-    if (!isAuthenticated(userId)) return undefined;
+    if (!isUserRegistered) return undefined;
 
     const unsubscribe = subscriptionEventBus.on(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, (updatedUserId) => {
       if (updatedUserId === userId) {
@@ -64,13 +65,13 @@ export const useCredits = (): UseCreditsResult => {
     });
 
     return unsubscribe;
-  }, [userId, queryClient]);
+  }, [userId, isUserRegistered, queryClient]);
 
   const credits = data ?? null;
 
   const derivedValues = useMemo(() => {
     const has = (credits?.credits ?? 0) > 0;
-    const limit = config?.creditLimit ?? 0;
+    const limit = credits?.creditLimit ?? config?.creditLimit ?? 0;
     const percent = calculateSafePercentage(credits?.credits, limit);
     return { hasCredits: has, creditsPercent: percent };
   }, [credits, config?.creditLimit]);
@@ -95,4 +96,4 @@ export const useCredits = (): UseCreditsResult => {
     refetch,
     canAfford,
   };
-};
+};