@umituz/react-native-subscription 2.27.139 → 2.27.140

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.139",
+  "version": "2.27.140",
   "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/presentation/useCredits.ts

@@ -9,6 +9,8 @@ import {
   isCreditsRepositoryConfigured,
 } from "../infrastructure/CreditsRepositoryManager";
 import { calculateCreditPercentage, canAfford as canAffordCheck } from "../../../shared/utils/numberUtils";
+import { createUserQueryKey } from "../../../shared/utils/queryKeyFactory";
+import { isAuthenticated } from "../../subscription/utils/authGuards";
 
 export const creditsQueryKeys = {
   all: ["credits"] as const,
@@ -42,14 +44,14 @@ function deriveLoadStatus(
 export const useCredits = (): UseCreditsResult => {
   const userId = useAuthStore(selectUserId);
   const isConfigured = isCreditsRepositoryConfigured();
-  
+
   const config = isConfigured ? getCreditsConfig() : null;
-  const queryEnabled = !!userId && isConfigured;
+  const queryEnabled = isAuthenticated(userId) && isConfigured;
 
   const { data, status, error, refetch } = useQuery({
-    queryKey: userId ? creditsQueryKeys.user(userId) : creditsQueryKeys.all,
+    queryKey: createUserQueryKey(creditsQueryKeys.all, userId, creditsQueryKeys.user),
     queryFn: async () => {
-      if (!userId || !isConfigured) return null;
+      if (!isAuthenticated(userId) || !isConfigured) return null;
 
       const repository = getCreditsRepository();
       const result = await repository.getCredits(userId);
@@ -74,7 +76,7 @@ export const useCredits = (): UseCreditsResult => {
   }, [queryClient]);
 
   useEffect(() => {
-    if (!userId) return;
+    if (!isAuthenticated(userId)) return;
 
     const unsubscribe = subscriptionEventBus.on(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, (updatedUserId) => {
       if (updatedUserId === userId) {

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

@@ -0,0 +1,27 @@
+import { isDefined, isValidNumber, isNonNegative } from "../../../shared/utils/typeGuards";
+
+export const isValidBalance = (balance: number | null | undefined): balance is number => {
+  return isValidNumber(balance) && isNonNegative(balance);
+};
+
+export const isValidCost = (cost: number): boolean => {
+  return isValidNumber(cost) && isNonNegative(cost);
+};
+
+export const isValidMaxCredits = (max: number): boolean => {
+  return isValidNumber(max) && max > 0;
+};
+
+export const canAffordAmount = (balance: number | null | undefined, cost: number): boolean => {
+  if (!isValidBalance(balance) || !isValidCost(cost)) return false;
+  return balance >= cost;
+};
+
+export const calculateSafePercentage = (
+  current: number | null | undefined,
+  max: number
+): number => {
+  if (!isValidNumber(current) || !isValidMaxCredits(max)) return 0;
+  const percentage = (current / max) * 100;
+  return Math.min(Math.max(percentage, 0), 100);
+};

package/src/domains/subscription/presentation/usePremium.ts

@@ -8,7 +8,7 @@ import {
   useRestorePurchase,
 } from '../infrastructure/hooks/useSubscriptionQueries';
 import { usePaywallVisibility } from './usePaywallVisibility';
-
+import { isPremiumSyncPending } from '../utils/syncStatus';
 import { UsePremiumResult } from './usePremium.types';
 
 export const usePremium = (): UsePremiumResult => {
@@ -24,12 +24,12 @@ export const usePremium = (): UsePremiumResult => {
   const { showPaywall, setShowPaywall, closePaywall, openPaywall } = usePaywallVisibility();
 
   const isPremium = subscriptionActive || (credits?.isPremium ?? false);
-  const isSyncing =
-    !statusLoading &&
-    !creditsLoading &&
-    subscriptionActive &&
-    credits !== null &&
-    !credits.isPremium;
+  const isSyncing = isPremiumSyncPending({
+    statusLoading,
+    creditsLoading,
+    subscriptionActive,
+    credits,
+  });
 
   const handlePurchase = useCallback(
     async (pkg: PurchasesPackage): Promise<boolean> => {

package/src/domains/subscription/presentation/useSubscriptionStatus.ts

@@ -4,6 +4,8 @@ import { useAuthStore, selectUserId } from "@umituz/react-native-auth";
 import { SubscriptionManager } from "../infrastructure/managers/SubscriptionManager";
 import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
 import { SubscriptionStatusResult } from "./useSubscriptionStatus.types";
+import { createUserQueryKey } from "../../../shared/utils/queryKeyFactory";
+import { isAuthenticated } from "../utils/authGuards";
 
 export const subscriptionStatusQueryKeys = {
   all: ["subscriptionStatus"] as const,
@@ -14,12 +16,16 @@ export const useSubscriptionStatus = (): SubscriptionStatusResult => {
   const userId = useAuthStore(selectUserId);
   const queryClient = useQueryClient();
 
-  const queryEnabled = !!userId && SubscriptionManager.isInitializedForUser(userId);
+  const queryEnabled = isAuthenticated(userId) && SubscriptionManager.isInitializedForUser(userId);
 
   const { data, status, error, refetch } = useQuery({
-    queryKey: userId ? subscriptionStatusQueryKeys.user(userId) : subscriptionStatusQueryKeys.all,
+    queryKey: createUserQueryKey(
+      subscriptionStatusQueryKeys.all,
+      userId,
+      subscriptionStatusQueryKeys.user
+    ),
     queryFn: async () => {
-      if (!userId) {
+      if (!isAuthenticated(userId)) {
         return { isPremium: false, expirationDate: null };
       }
 
@@ -34,10 +40,10 @@ export const useSubscriptionStatus = (): SubscriptionStatusResult => {
   });
 
   useEffect(() => {
-    if (!userId) return;
+    if (!isAuthenticated(userId)) return;
 
     const unsubscribe = subscriptionEventBus.on(
-      SUBSCRIPTION_EVENTS.PREMIUM_STATUS_CHANGED, 
+      SUBSCRIPTION_EVENTS.PREMIUM_STATUS_CHANGED,
       (event: { userId: string; isPremium: boolean }) => {
         if (event.userId === userId) {
           queryClient.invalidateQueries({

package/src/domains/subscription/utils/authGuards.ts

@@ -0,0 +1,5 @@
+import { isDefined } from "../../../shared/utils/typeGuards";
+
+export const isAuthenticated = (userId: string | null | undefined): userId is string => {
+  return isDefined(userId) && userId.length > 0;
+};

package/src/domains/subscription/utils/syncStatus.ts

@@ -0,0 +1,21 @@
+import { isDefined } from "../../../shared/utils/typeGuards";
+import type { UserCredits } from "../../credits/core/Credits";
+
+export interface SyncState {
+  statusLoading: boolean;
+  creditsLoading: boolean;
+  subscriptionActive: boolean;
+  credits: UserCredits | null;
+}
+
+export const isPremiumSyncPending = (state: SyncState): boolean => {
+  const { statusLoading, creditsLoading, subscriptionActive, credits } = state;
+
+  if (statusLoading || creditsLoading) return false;
+
+  if (!subscriptionActive) return false;
+
+  if (!isDefined(credits)) return false;
+
+  return !credits.isPremium;
+};

package/src/shared/utils/numberUtils.core.ts

@@ -1,72 +1,40 @@
-/**
- * Number Utilities - Core Operations
- * Basic numeric calculation functions
- */
+import { canAffordAmount, calculateSafePercentage } from "../../domains/credits/utils/creditValidation";
 
-/**
- * Clamp a number between min and max values
- */
 export function clamp(value: number, min: number, max: number): number {
   return Math.min(Math.max(value, min), max);
 }
 
-/**
- * Round a number to specified decimal places
- */
 export function roundTo(value: number, decimals: number = 2): number {
   const multiplier = Math.pow(10, decimals);
   return Math.round(value * multiplier) / multiplier;
 }
 
-/**
- * Calculate percentage
- */
 export function calculatePercentage(value: number, total: number): number {
   if (total === 0) return 0;
   return (value / total) * 100;
 }
 
-/**
- * Calculate percentage and clamp between 0-100
- */
 export function calculatePercentageClamped(value: number, total: number): number {
   return clamp(calculatePercentage(value, total), 0, 100);
 }
 
-/**
- * Check if two numbers are approximately equal (within epsilon)
- */
 export function isApproximatelyEqual(a: number, b: number, epsilon: number = 0.0001): boolean {
   return Math.abs(a - b) < epsilon;
 }
 
-/**
- * Safe division that returns 0 instead of NaN
- */
 export function safeDivide(numerator: number, denominator: number): number {
   if (denominator === 0) return 0;
   return numerator / denominator;
 }
 
-/**
- * Calculate remaining value after subtraction with floor at 0
- */
 export function calculateRemaining(current: number, cost: number): number {
   return Math.max(0, current - cost);
 }
 
-/**
- * Check if user can afford a cost
- */
 export function canAfford(balance: number | null | undefined, cost: number): boolean {
-  if (balance === null || balance === undefined || cost < 0) return false;
-  return balance >= cost;
+  return canAffordAmount(balance, cost);
 }
 
-/**
- * Calculate credit percentage for UI display
- */
 export function calculateCreditPercentage(current: number | null | undefined, max: number): number {
-  if (current === null || current === undefined || max <= 0) return 0;
-  return calculatePercentageClamped(current, max);
+  return calculateSafePercentage(current, max);
 }

package/src/shared/utils/queryKeyFactory.ts

@@ -0,0 +1,9 @@
+import { isAuthenticated } from "../../domains/subscription/utils/authGuards";
+
+export const createUserQueryKey = <T extends readonly unknown[]>(
+  baseKey: T,
+  userId: string | null | undefined,
+  userSpecificKey: (userId: string) => readonly unknown[]
+): readonly unknown[] => {
+  return isAuthenticated(userId) ? userSpecificKey(userId) : baseKey;
+};

package/src/shared/utils/typeGuards.ts

@@ -0,0 +1,15 @@
+export const isDefined = <T>(value: T | null | undefined): value is T => {
+  return value !== null && value !== undefined;
+};
+
+export const isPositive = (value: number): boolean => {
+  return value > 0;
+};
+
+export const isNonNegative = (value: number): boolean => {
+  return value >= 0;
+};
+
+export const isValidNumber = (value: number | null | undefined): value is number => {
+  return isDefined(value) && !isNaN(value) && isFinite(value);
+};