@umituz/react-native-subscription 2.27.89 → 2.27.92

package/package.json

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

@@ -66,24 +66,6 @@ export const useCredits = (): UseCreditsResult => {
         throw new Error(result.error?.message || "Failed to fetch credits");
       }
 
-      // If subscription is expired, immediately return 0 credits
-      // to prevent any window where expired user could deduct
-      if (result.data?.status === "expired") {
-        // Sync to Firestore in background
-        repository.syncExpiredStatus(userId).catch((syncError) => {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.warn("[useCredits] Background sync failed:", syncError);
-          }
-        });
-
-        // Return expired data with 0 credits immediately
-        return {
-          ...result.data,
-          credits: 0,
-          isPremium: false,
-        };
-      }
-
       return result.data || null;
     },
     enabled: queryEnabled,

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

@@ -8,6 +8,7 @@ import { useMutation, useQueryClient } from "@umituz/react-native-design-system"
 import type { UserCredits } from "../core/Credits";
 import { getCreditsRepository } from "../infrastructure/CreditsRepositoryProvider";
 import { creditsQueryKeys } from "./useCredits";
+import { calculateRemainingCredits } from "../utils/creditCalculations";
 
 import { timezoneService } from "@umituz/react-native-design-system";
 
@@ -42,14 +43,12 @@ export const useDeductCredit = ({
       await queryClient.cancelQueries({ queryKey: creditsQueryKeys.user(userId) });
       const previousCredits = queryClient.getQueryData<UserCredits>(creditsQueryKeys.user(userId));
 
-      // Improved optimistic update logic
       if (!previousCredits) {
         return { previousCredits: null, skippedOptimistic: true };
       }
 
-      // If credits are insufficient, show 0 but don't skip optimistic update
-      // This provides better UX by showing the user what will happen
-      const newCredits = Math.max(0, previousCredits.credits - cost);
+      // Calculate new credits using utility
+      const newCredits = calculateRemainingCredits(previousCredits.credits, cost);
 
       queryClient.setQueryData<UserCredits | null>(creditsQueryKeys.user(userId), (old) => {
         if (!old) return old;
@@ -67,10 +66,10 @@ export const useDeductCredit = ({
       };
     },
     onError: (_err, _cost, context) => {
-      // Restore previous credits on error
-      // Skip restoration if credits were insufficient (optimistic update showed 0, which is correct)
-      if (userId && context?.previousCredits && !context.skippedOptimistic && !context.wasInsufficient) {
-        queryClient.setQueryData(creditsQueryKeys.user(userId), context.previousCredits);
+      // Always restore previous credits on error to prevent UI desync
+      // Use optional chaining to be safe
+      if (userId && context?.previousCredits && !context.skippedOptimistic) {
+         queryClient.setQueryData(creditsQueryKeys.user(userId), context.previousCredits);
       }
     },
     onSuccess: () => {

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

@@ -24,3 +24,10 @@ export const canAffordCost = (
   }
   return currentCredits >= cost;
 };
+
+export const calculateRemainingCredits = (
+  currentCredits: number,
+  cost: number
+): number => {
+  return Math.max(0, currentCredits - cost);
+};

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

@@ -4,6 +4,7 @@
  */
 
 import type { CustomerInfo } from "react-native-purchases";
+import { DEFAULT_ENTITLEMENT_ID } from "./SubscriptionConstants";
 
 /**
  * RevenueCat Entitlement Info
@@ -35,7 +36,7 @@ export interface RevenueCatPurchaseErrorInfo extends Error {
  */
 export function getPremiumEntitlement(
   customerInfo: CustomerInfo,
-  entitlementIdentifier: string = 'premium'
+  entitlementIdentifier: string = DEFAULT_ENTITLEMENT_ID
 ): RevenueCatEntitlement | null {
   const entitlement = customerInfo.entitlements.active[entitlementIdentifier];
   if (!entitlement) {

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

@@ -3,6 +3,18 @@
  * Centralized source of truth for subscription-related enums and types.
  */
 
+/** User tier constants */
+export const USER_TIER = {
+  ANONYMOUS: 'anonymous',
+  FREEMIUM: 'freemium',
+  PREMIUM: 'premium',
+} as const;
+
+export type UserTierType = (typeof USER_TIER)[keyof typeof USER_TIER];
+
+/** Default entitlement identifier */
+export const DEFAULT_ENTITLEMENT_ID = 'premium';
+
 /** Subscription status constants */
 export const SUBSCRIPTION_STATUS = {
   ACTIVE: 'active',

package/src/index.ts

@@ -54,11 +54,11 @@ export {
 export * from "./presentation/hooks";
 
 // Presentation Layer - Components
-export * from "./presentation/components/details/PremiumDetailsCard";
-export * from "./presentation/components/details/PremiumStatusBadge";
-export * from "./presentation/components/sections/SubscriptionSection";
-export * from "./presentation/components/feedback/PaywallFeedbackModal";
-export * from "./presentation/screens/SubscriptionDetailScreen";
+export * from "./domains/subscription/presentation/components/details/PremiumDetailsCard";
+export * from "./domains/subscription/presentation/components/details/PremiumStatusBadge";
+export * from "./domains/subscription/presentation/components/sections/SubscriptionSection";
+export * from "./domains/subscription/presentation/components/feedback/PaywallFeedbackModal";
+export * from "./domains/subscription/presentation/screens/SubscriptionDetailScreen";
 export * from "./domains/paywall/components/PaywallContainer";
 
 export type {

package/src/presentation/hooks/README.md

@@ -103,7 +103,7 @@ All hooks follow consistent patterns:
 - **ALWAYS** handle loading and error states
 - **NEVER** trust client-side state for security
 - **MUST** implement error boundaries
-- **ALWAYS** test with various user states (guest, free, premium)
+- **ALWAYS** test with various user states (anonymous, free, premium)
 
 ## AI Agent Guidelines
 

package/src/presentation/hooks/usePremium.md

@@ -40,7 +40,7 @@ Hook for checking and managing premium subscription status.
 
 - **NEVER** use for security decisions (server-side validation required)
 - **NEVER** assume instant data availability (always check loading state)
-- **DO NOT** use for guest users without proper handling
+- **DO NOT** use for anonymous users without proper handling
 
 ### CRITICAL SAFETY
 
@@ -67,7 +67,7 @@ Hook for checking and managing premium subscription status.
 - [ ] Provide upgrade path for free users
 - [ ] Test with premium user
 - [ ] Test with free user
-- [ ] Test with guest user
+- [ ] Test with anonymous user
 - [ ] Test offline scenario
 
 ### Common Patterns

package/src/utils/index.ts

@@ -1,6 +1,4 @@
-export * from "./aiCreditHelpers";
-export * from "./authUtils";
-export * from "./creditChecker";
+
 export * from "./creditMapper";
 export * from "./packagePeriodUtils";
 export * from "./packageTypeDetector";

package/src/utils/packageTypeDetector.ts

@@ -16,8 +16,10 @@ export type SubscriptionPackageType = PackageType;
  * Credit packages use a different system and don't need type detection
  */
 export function isCreditPackage(identifier: string): boolean {
+  if (!identifier) return false;
   // Matches "credit" as a word or part of a common naming pattern
-  return /\bcredit\b|_credit_|-credit-/i.test(identifier) || identifier.toLowerCase().includes("credit");
+  // More strict to avoid false positives (e.g. "accredited")
+  return /(?:^|[._-])credit(?:$|[._-])/i.test(identifier);
 }
 
 /**
@@ -36,37 +38,25 @@ export function detectPackageType(productIdentifier: string): SubscriptionPackag
     return PACKAGE_TYPE.UNKNOWN;
   }
 
-  // Preview API mode (Expo Go testing)
-  if (normalized.includes("preview")) {
-    if (__DEV__) {
-      console.log("[PackageTypeDetector] Detected: PREVIEW (monthly)");
-    }
-    return PACKAGE_TYPE.MONTHLY;
-  }
-
   // Weekly detection: matches "weekly" or "week" as distinct parts of the ID
   if (/\bweekly?\b|_week_|-week-|\.week\./i.test(normalized)) {
-    if (__DEV__) {
-      console.log("[PackageTypeDetector] Detected: WEEKLY");
-    }
     return PACKAGE_TYPE.WEEKLY;
   }
 
   // Monthly detection: matches "monthly" or "month"
   if (/\bmonthly?\b|_month_|-month-|\.month\./i.test(normalized)) {
-    if (__DEV__) {
-      console.log("[PackageTypeDetector] Detected: MONTHLY");
-    }
     return PACKAGE_TYPE.MONTHLY;
   }
 
   // Yearly detection: matches "yearly", "year", or "annual"
   if (/\byearly?\b|_year_|-year-|\.year\.|annual/i.test(normalized)) {
-    if (__DEV__) {
-      console.log("[PackageTypeDetector] Detected: YEARLY");
-    }
     return PACKAGE_TYPE.YEARLY;
   }
+  
+  // Lifetime detection: matches "lifetime"
+  if (/\blifetime\b|_lifetime_|-lifetime-|\.lifetime\./i.test(normalized)) {
+      return PACKAGE_TYPE.LIFETIME;
+  }
 
   if (__DEV__) {
     console.warn("[PackageTypeDetector] Unknown package type for:", productIdentifier);

package/src/utils/premiumStatusUtils.ts

@@ -5,18 +5,18 @@
  */
 
 import type { PremiumStatusFetcher } from './types';
-import { isGuest } from './authUtils';
+
 
 /**
  * Get isPremium value with centralized logic
  */
 export function getIsPremium(
-  isGuestFlag: boolean,
+  isAnonymous: boolean,
   userId: string | null,
   isPremiumOrFetcher: boolean | PremiumStatusFetcher,
 ): Promise<boolean> {
-  // Guest users NEVER have premium
-  if (isGuest(isGuestFlag, userId)) return Promise.resolve(false);
+  // Anonymous users NEVER have premium
+  if (isAnonymous || userId === null) return Promise.resolve(false);
 
   // Sync mode: return the provided isPremium value
   if (typeof isPremiumOrFetcher === 'boolean') return Promise.resolve(isPremiumOrFetcher);

package/src/utils/tierUtils.ts

@@ -4,38 +4,38 @@
  * Core logic for determining user tier and premium status
  */
 
-import type { UserTierInfo } from './types';
-import { isGuest } from './authUtils';
+import { USER_TIER, type UserTierInfo } from './types';
+
 
 export function getUserTierInfo(
-  isGuestFlag: boolean,
+  isAnonymous: boolean,
   userId: string | null,
   isPremium: boolean,
 ): UserTierInfo {
-  if (isGuest(isGuestFlag, userId)) {
+  if (isAnonymous || userId === null) {
     return {
-      tier: 'guest',
+      tier: USER_TIER.ANONYMOUS,
       isPremium: false,
-      isGuest: true,
+      isAnonymous: true,
       isAuthenticated: false,
       userId: null,
     };
   }
 
   return {
-    tier: isPremium ? 'premium' : 'freemium',
+    tier: isPremium ? USER_TIER.PREMIUM : USER_TIER.FREEMIUM,
     isPremium,
-    isGuest: false,
+    isAnonymous: false,
     isAuthenticated: true,
     userId,
   };
 }
 
 export function checkPremiumAccess(
-  isGuestFlag: boolean,
+  isAnonymous: boolean,
   userId: string | null,
   isPremium: boolean,
 ): boolean {
-  if (isGuest(isGuestFlag, userId)) return false;
+  if (isAnonymous || userId === null) return false;
   return isPremium;
 }

package/src/utils/types.ts

@@ -4,7 +4,10 @@
  * Type definitions for user tier system
  */
 
-export type UserTier = 'guest' | 'freemium' | 'premium';
+import { USER_TIER, type UserTierType } from '../domains/subscription/core/SubscriptionConstants';
+
+export type UserTier = UserTierType;
+export { USER_TIER };
 
 export interface UserTierInfo {
   /** User tier classification */
@@ -13,13 +16,13 @@ export interface UserTierInfo {
   /** Whether user has premium access */
   isPremium: boolean;
 
-  /** Whether user is a guest (not authenticated) */
-  isGuest: boolean;
+  /** Whether user is anonymous (not authenticated) */
+  isAnonymous: boolean;
 
   /** Whether user is authenticated */
   isAuthenticated: boolean;
 
-  /** User ID (null for guests) */
+  /** User ID (null for anonymous users) */
   userId: string | null;
 }
 

package/src/utils/validation.ts

@@ -4,10 +4,10 @@
  * Type guards and validation functions for user tier system
  */
 
-import type { UserTier, UserTierInfo } from './types';
+import { USER_TIER, type UserTier, type UserTierInfo } from './types';
 
 export function isValidUserTier(value: unknown): value is UserTier {
-  return value === 'guest' || value === 'freemium' || value === 'premium';
+  return value === USER_TIER.ANONYMOUS || value === USER_TIER.FREEMIUM || value === USER_TIER.PREMIUM;
 }
 
 export function isUserTierInfo(value: unknown): value is UserTierInfo {
@@ -16,7 +16,7 @@ export function isUserTierInfo(value: unknown): value is UserTierInfo {
   return (
     isValidUserTier(obj.tier) &&
     typeof obj.isPremium === 'boolean' &&
-    typeof obj.isGuest === 'boolean' &&
+    typeof obj.isAnonymous === 'boolean' &&
     typeof obj.isAuthenticated === 'boolean' &&
     (obj.userId === null || typeof obj.userId === 'string')
   );

package/src/domains/config/README.md

@@ -1,100 +0,0 @@
-# Config Domain
-
-Central configuration system for subscription plans, product configurations, and package management.
-
-## Location
-
-- **Base Path**: `/Users/umituz/Desktop/github/umituz/apps/artificial_intelligence/npm-packages/react-native-subscription/src/domains/config/`
-- **Domain**: `src/domains/config/domain/`
-- **Entities**: `src/domains/config/domain/entities/`
-
-## Strategy
-
-### Plan Management
-
-Comprehensive subscription plan configuration system.
-
-- **Plan Types**: Monthly, annual, and lifetime plan configurations
-- **Product Metadata**: RevenueCat product metadata management
-- **Validation**: Configuration validation and type safety
-- **Helper Functions**: Plan comparison and filtering utilities
-
-### Configuration Objects
-
-Structured configuration for different aspects of the system.
-
-- **SubscriptionConfig**: Main subscription configuration
-- **WalletConfig**: Credit system configuration
-- **Plan Entities**: Individual plan definitions
-- **Validation Rules**: Configuration validation schemas
-
-### Helper Utilities
-
-Plan comparison and manipulation functions.
-
-- **Plan Comparison**: Value comparison between plans
-- **Price Formatting**: Currency-aware price formatting
-- **Discount Calculation**: Savings and discount calculations
-- **Package Filtering**: Type-based package filtering
-
-### Validation System
-
-Comprehensive configuration validation.
-
-- **Plan Validation**: Plan entity validation rules
-- **Config Validation**: Complete configuration validation
-- **Type Safety**: TypeScript type definitions
-- **Error Messages**: Detailed validation error reporting
-
-## Restrictions
-
-### REQUIRED
-
-- **Type Safety**: Always use TypeScript type definitions
-- **Validation**: Validate configurations before runtime use
-- **Default Values**: Provide meaningful default values
-- **Immutable Updates**: Create new copies instead of modifying
-
-### PROHIBITED
-
-- **Invalid Prices**: Negative or zero prices not allowed
-- **Missing IDs**: All plans must have valid IDs
-- **Duplicate Plans**: No duplicate plan IDs allowed
-- **Hardcoded Values**: Use configuration system
-
-### CRITICAL
-
-- **Configuration Integrity**: All configurations must be valid
-- **Plan Consistency**: Related plans must be consistent
-- **Currency Handling**: Proper currency code usage
-- **Feature Lists**: Accurate feature mapping
-
-## AI Agent Guidelines
-
-### When Modifying Configuration System
-
-1. **Type Definitions**: Update TypeScript types for new config
-2. **Validation Rules**: Add validation for new fields
-3. **Default Values**: Provide sensible defaults
-4. **Documentation**: Document configuration options
-
-### When Adding New Plan Types
-
-1. **Entity Pattern**: Follow existing entity patterns
-2. **Validation**: Add validation rules
-3. **Helper Functions**: Create helper functions
-4. **Testing**: Test with various configurations
-
-### When Fixing Configuration Bugs
-
-1. **Validation Logic**: Check validation rules
-2. **Type Definitions**: Verify type correctness
-3. **Default Values**: Ensure proper defaults
-4. **Edge Cases**: Test boundary conditions
-
-## Related Documentation
-
-- [Paywall Domain](/Users/umituz/Desktop/github/umituz/apps/artificial_intelligence/npm-packages/react-native-subscription/src/domains/paywall/README.md)
-- [Wallet Domain](/Users/umituz/Desktop/github/umituz/apps/artificial_intelligence/npm-packages/react-native-subscription/src/domains/wallet/README.md)
-- [RevenueCat Integration](/Users/umituz/Desktop/github/umituz/apps/artificial_intelligence/npm-packages/react-native-subscription/src/revenuecat/README.md)
-- [Domain Layer](/Users/umituz/Desktop/github/umituz/apps/artificial_intelligence/npm-packages/react-native-subscription/src/domain/README.md)

package/src/utils/README.md

@@ -1,42 +0,0 @@
-# Utils
-
-## Location
-Abonelik sistemi için yardımcı fonksiyonlar ve utility araçları.
-
-## Strategy
-Bu dizin, premium durum kontrolü, kullanıcı tier yönetimi, paket işlemleri, fiyat hesaplama, periyot formatlama, asenkron işlemler, validasyon ve veri dönüşümü için yardımcı fonksiyonlar içerir.
-
-## Restrictions
-
-### REQUIRED
-- Must maintain type safety for all functions
-- Must handle null checks safely
-- Must support localization
-- Must validate all inputs
-
-### PROHIBITED
-- DO NOT bypass null safety checks
-- DO NOT ignore error handling
-- DO NOT hardcode locale values
-- DO NOT skip validation
-
-### CRITICAL SAFETY
-- All functions MUST be type-safe
-- Null checks MUST be performed safely
-- Errors MUST be caught and handled
-- Validation MUST return clear results
-
-## AI Agent Guidelines
-1. Maintain type safety for all utility functions
-2. Perform null checks safely with proper guards
-3. Catch and handle errors appropriately
-4. Support localization for different locales
-5. Write JSDoc comments for all functions
-6. Test utility functions thoroughly with edge cases
-7. Provide clear validation error messages
-
-## Related Documentation
-- Premium utilities for status checks
-- User tier utilities for tier management
-- Package utilities for RevenueCat integration
-- Price utilities for formatting and calculation

package/src/utils/__tests__/authUtils.test.ts

@@ -1,37 +0,0 @@
-/**
- * Authentication Utilities Tests
- *
- * Tests for authentication check functions
- */
-
-import { isAuthenticated, isGuest } from '../authUtils';
-
-describe('isAuthenticated', () => {
-  it('should return false for guest users', () => {
-    expect(isAuthenticated(true, null)).toBe(false);
-    expect(isAuthenticated(true, 'user123')).toBe(false);
-  });
-
-  it('should return false when userId is null', () => {
-    expect(isAuthenticated(false, null)).toBe(false);
-  });
-
-  it('should return true for authenticated users', () => {
-    expect(isAuthenticated(false, 'user123')).toBe(true);
-  });
-});
-
-describe('isGuest', () => {
-  it('should return true for guest users', () => {
-    expect(isGuest(true, null)).toBe(true);
-    expect(isGuest(true, 'user123')).toBe(true);
-  });
-
-  it('should return true when userId is null', () => {
-    expect(isGuest(false, null)).toBe(true);
-  });
-
-  it('should return false for authenticated users', () => {
-    expect(isGuest(false, 'user123')).toBe(false);
-  });
-});

package/src/utils/__tests__/edgeCases.test.ts

@@ -1,79 +0,0 @@
-/**
- * Edge Cases Tests
- *
- * Tests for edge cases and special scenarios
- */
-
-import { getUserTierInfo } from '../tierUtils';
-import { isAuthenticated, isGuest } from '../authUtils';
-import { validateUserId } from '../validation';
-
-describe('Edge Cases', () => {
-  describe('User ID validation', () => {
-    it('should handle empty string userId as invalid', () => {
-      expect(() => validateUserId('')).toThrow(TypeError);
-    });
-
-    it('should handle whitespace-only userId as invalid', () => {
-      expect(() => validateUserId('   ')).toThrow(TypeError);
-    });
-
-    it('should handle very long userId strings', () => {
-      const longUserId = 'a'.repeat(1000);
-      const result = getUserTierInfo(false, longUserId, true);
-      expect(result.userId).toBe(longUserId);
-      expect(result.tier).toBe('premium');
-    });
-
-    it('should handle special characters in userId', () => {
-      const specialUserId = 'user-123_test@example.com';
-      const result = getUserTierInfo(false, specialUserId, false);
-      expect(result.userId).toBe(specialUserId);
-      expect(result.tier).toBe('freemium');
-    });
-  });
-
-  describe('Authentication edge cases', () => {
-    it('should handle conflicting auth states consistently', () => {
-      // isGuest=true but userId provided - should prioritize guest logic
-      expect(isAuthenticated(true, 'user123')).toBe(false);
-      expect(isGuest(true, 'user123')).toBe(true);
-
-      const result = getUserTierInfo(true, 'user123', true);
-      expect(result.tier).toBe('guest');
-      expect(result.isPremium).toBe(false);
-    });
-
-    it('should handle isGuest=false but null userId', () => {
-      // isGuest=false but userId=null - should treat as guest
-      expect(isAuthenticated(false, null)).toBe(false);
-      expect(isGuest(false, null)).toBe(true);
-
-      const result = getUserTierInfo(false, null, true);
-      expect(result.tier).toBe('guest');
-      expect(result.isPremium).toBe(false);
-    });
-  });
-
-  describe('Premium status edge cases', () => {
-    it('should ignore isPremium for guest users regardless of value', () => {
-      const guestTrue = getUserTierInfo(true, null, true);
-      const guestFalse = getUserTierInfo(true, null, false);
-
-      expect(guestTrue.isPremium).toBe(false);
-      expect(guestFalse.isPremium).toBe(false);
-      expect(guestTrue.tier).toBe('guest');
-      expect(guestFalse.tier).toBe('guest');
-    });
-
-    it('should handle authenticated users with various premium states', () => {
-      const premium = getUserTierInfo(false, 'user123', true);
-      const freemium = getUserTierInfo(false, 'user123', false);
-
-      expect(premium.tier).toBe('premium');
-      expect(premium.isPremium).toBe(true);
-      expect(freemium.tier).toBe('freemium');
-      expect(freemium.isPremium).toBe(false);
-    });
-  });
-});

package/src/utils/__tests__/premiumUtils.test.ts

@@ -1,89 +0,0 @@
-/**
- * Premium Utilities Tests
- *
- * Tests for premium status fetching and async functions
- */
-
-import { getIsPremium } from '../premiumStatusUtils';
-import type { PremiumStatusFetcher } from '../types';
-
-describe('getIsPremium', () => {
-  describe('Sync mode (boolean isPremium)', () => {
-    it('should return false for guest users', () => {
-      const result = getIsPremium(true, null, true);
-      expect(result).toBe(false);
-    });
-
-    it('should return false when userId is null', () => {
-      const result = getIsPremium(false, null, true);
-      expect(result).toBe(false);
-    });
-
-    it('should return true when isPremium is true', () => {
-      const result = getIsPremium(false, 'user123', true);
-      expect(result).toBe(true);
-    });
-
-    it('should return false when isPremium is false', () => {
-      const result = getIsPremium(false, 'user123', false);
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('Async mode (fetcher)', () => {
-    const mockFetcher: PremiumStatusFetcher = {
-      isPremium: jest.fn(),
-    };
-
-    beforeEach(() => {
-      jest.clearAllMocks();
-    });
-
-    it('should return false for guest users without calling fetcher', async () => {
-      const result = await getIsPremium(true, null, mockFetcher);
-      expect(result).toBe(false);
-      expect(mockFetcher.isPremium).not.toHaveBeenCalled();
-    });
-
-    it('should return false when userId is null without calling fetcher', async () => {
-      const result = await getIsPremium(false, null, mockFetcher);
-      expect(result).toBe(false);
-      expect(mockFetcher.isPremium).not.toHaveBeenCalled();
-    });
-
-    it('should call fetcher for authenticated users', async () => {
-      (mockFetcher.isPremium as jest.Mock).mockResolvedValue(true);
-
-      const result = await getIsPremium(false, 'user123', mockFetcher);
-      expect(result).toBe(true);
-      expect(mockFetcher.isPremium).toHaveBeenCalledWith('user123');
-      expect(mockFetcher.isPremium).toHaveBeenCalledTimes(1);
-    });
-
-    it('should return false when fetcher returns false', async () => {
-      (mockFetcher.isPremium as jest.Mock).mockResolvedValue(false);
-
-      const result = await getIsPremium(false, 'user123', mockFetcher);
-      expect(result).toBe(false);
-      expect(mockFetcher.isPremium).toHaveBeenCalledWith('user123');
-    });
-
-    it('should throw error when fetcher throws Error', async () => {
-      const error = new Error('Database error');
-      (mockFetcher.isPremium as jest.Mock).mockRejectedValue(error);
-
-      await expect(getIsPremium(false, 'user123', mockFetcher)).rejects.toThrow(
-        'Failed to fetch premium status: Database error'
-      );
-    });
-
-    it('should throw error when fetcher throws non-Error', async () => {
-      const error = 'String error';
-      (mockFetcher.isPremium as jest.Mock).mockRejectedValue(error);
-
-      await expect(getIsPremium(false, 'user123', mockFetcher)).rejects.toThrow(
-        'Failed to fetch premium status: String error'
-      );
-    });
-  });
-});

package/src/utils/__tests__/tierUtils.test.ts

@@ -1,74 +0,0 @@
-/**
- * Tier Utilities Tests
- *
- * Tests for tier determination and comparison functions
- */
-
-import { getUserTierInfo, checkPremiumAccess } from '../tierUtils';
-
-describe('getUserTierInfo', () => {
-  describe('Guest users', () => {
-    it('should return guest tier when isGuest is true', () => {
-      const result = getUserTierInfo(true, null, false);
-      expect(result.tier).toBe('guest');
-      expect(result.isPremium).toBe(false);
-      expect(result.isGuest).toBe(true);
-      expect(result.isAuthenticated).toBe(false);
-      expect(result.userId).toBe(null);
-    });
-
-    it('should return guest tier when userId is null', () => {
-      const result = getUserTierInfo(false, null, false);
-      expect(result.tier).toBe('guest');
-      expect(result.isPremium).toBe(false);
-      expect(result.isGuest).toBe(true);
-      expect(result.isAuthenticated).toBe(false);
-      expect(result.userId).toBe(null);
-    });
-
-    it('should ignore isPremium for guest users', () => {
-      const result = getUserTierInfo(true, null, true);
-      expect(result.tier).toBe('guest');
-      expect(result.isPremium).toBe(false);
-    });
-  });
-
-  describe('Authenticated users', () => {
-    it('should return premium tier for authenticated premium users', () => {
-      const result = getUserTierInfo(false, 'user123', true);
-      expect(result.tier).toBe('premium');
-      expect(result.isPremium).toBe(true);
-      expect(result.isGuest).toBe(false);
-      expect(result.isAuthenticated).toBe(true);
-      expect(result.userId).toBe('user123');
-    });
-
-    it('should return freemium tier for authenticated non-premium users', () => {
-      const result = getUserTierInfo(false, 'user123', false);
-      expect(result.tier).toBe('freemium');
-      expect(result.isPremium).toBe(false);
-      expect(result.isGuest).toBe(false);
-      expect(result.isAuthenticated).toBe(true);
-      expect(result.userId).toBe('user123');
-    });
-  });
-});
-
-describe('checkPremiumAccess', () => {
-  it('should return false for guest users', () => {
-    expect(checkPremiumAccess(true, null, true)).toBe(false);
-    expect(checkPremiumAccess(true, null, false)).toBe(false);
-  });
-
-  it('should return false when userId is null', () => {
-    expect(checkPremiumAccess(false, null, true)).toBe(false);
-  });
-
-  it('should return true for authenticated premium users', () => {
-    expect(checkPremiumAccess(false, 'user123', true)).toBe(true);
-  });
-
-  it('should return false for authenticated freemium users', () => {
-    expect(checkPremiumAccess(false, 'user123', false)).toBe(false);
-  });
-});

package/src/utils/__tests__/validation.test.ts

@@ -1,105 +0,0 @@
-/**
- * User Tier Validation Tests
- *
- * Tests for validation functions and type guards
- */
-
-import {
-  isValidUserTier,
-  isUserTierInfo,
-  validateUserId,
-  validateIsGuest,
-  validateIsPremium,
-  validateFetcher,
-} from '../validation';
-import type { UserTierInfo, PremiumStatusFetcher } from '../types';
-
-describe('isValidUserTier', () => {
-  it('should return true for valid tiers', () => {
-    expect(isValidUserTier('guest')).toBe(true);
-    expect(isValidUserTier('freemium')).toBe(true);
-    expect(isValidUserTier('premium')).toBe(true);
-  });
-
-  it('should return false for invalid values', () => {
-    expect(isValidUserTier('invalid')).toBe(false);
-    expect(isValidUserTier('')).toBe(false);
-    expect(isValidUserTier(null)).toBe(false);
-    expect(isValidUserTier(undefined)).toBe(false);
-    expect(isValidUserTier(123)).toBe(false);
-    expect(isValidUserTier({})).toBe(false);
-  });
-});
-
-describe('isUserTierInfo', () => {
-  it('should return true for valid UserTierInfo', () => {
-    const validInfo: UserTierInfo = {
-      tier: 'premium',
-      isPremium: true,
-      isGuest: false,
-      isAuthenticated: true,
-      userId: 'user123',
-    };
-    expect(isUserTierInfo(validInfo)).toBe(true);
-  });
-
-  it('should return false for invalid objects', () => {
-    expect(isUserTierInfo(null)).toBe(false);
-    expect(isUserTierInfo(undefined)).toBe(false);
-    expect(isUserTierInfo('string')).toBe(false);
-    expect(isUserTierInfo({})).toBe(false);
-    expect(isUserTierInfo({ tier: 'invalid' })).toBe(false);
-    expect(isUserTierInfo({ tier: 'premium' })).toBe(false);
-  });
-});
-
-describe('validateUserId', () => {
-  it('should not throw for valid userId', () => {
-    expect(() => validateUserId('user123')).not.toThrow();
-    expect(() => validateUserId(null)).not.toThrow();
-  });
-
-  it('should throw for invalid userId', () => {
-    expect(() => validateUserId('')).toThrow(TypeError);
-    expect(() => validateUserId('   ')).toThrow(TypeError);
-  });
-});
-
-describe('validateIsGuest', () => {
-  it('should not throw for valid isGuest', () => {
-    expect(() => validateIsGuest(true)).not.toThrow();
-    expect(() => validateIsGuest(false)).not.toThrow();
-  });
-
-  it('should throw for invalid isGuest', () => {
-    expect(() => validateIsGuest('true' as unknown as boolean)).toThrow(TypeError);
-    expect(() => validateIsGuest(1 as unknown as boolean)).toThrow(TypeError);
-  });
-});
-
-describe('validateIsPremium', () => {
-  it('should not throw for valid isPremium', () => {
-    expect(() => validateIsPremium(true)).not.toThrow();
-    expect(() => validateIsPremium(false)).not.toThrow();
-  });
-
-  it('should throw for invalid isPremium', () => {
-    expect(() => validateIsPremium('true' as unknown as boolean)).toThrow(TypeError);
-    expect(() => validateIsPremium(1 as unknown as boolean)).toThrow(TypeError);
-  });
-});
-
-describe('validateFetcher', () => {
-  it('should not throw for valid fetcher', () => {
-    const validFetcher: PremiumStatusFetcher = {
-      isPremium: async () => true,
-    };
-    expect(() => validateFetcher(validFetcher)).not.toThrow();
-  });
-
-  it('should throw for invalid fetcher', () => {
-    expect(() => validateFetcher(null as unknown as PremiumStatusFetcher)).toThrow(TypeError);
-    expect(() => validateFetcher({} as unknown as PremiumStatusFetcher)).toThrow(TypeError);
-    expect(() => validateFetcher({ isPremium: 'not a function' } as unknown as PremiumStatusFetcher)).toThrow(TypeError);
-  });
-});

package/src/utils/aiCreditHelpers.ts

@@ -1,113 +0,0 @@
-/**
- * AI Credit Helpers
- *
- * Common patterns for AI generation apps to handle credits.
- * Provides ready-to-use functions for credit checking and deduction.
- *
- * Usage:
- *   import { createAICreditHelpers } from '@umituz/react-native-subscription';
- *
- *   const helpers = createAICreditHelpers({
- *     repository,
- *     imageGenerationTypes: ['future_image', 'santa_transform'],
- *     onCreditDeducted: (userId) => invalidateCache(userId)
- *   });
- */
-
-import type { CreditsRepository } from "../domains/credits/infrastructure/CreditsRepository";
-import { createCreditChecker } from "./creditChecker";
-
-export interface AICreditHelpersConfig {
-  /**
-   * Credits repository instance
-   */
-  repository: CreditsRepository;
-
-  /**
-   * Optional map of operation types to credit costs.
-   * If an operation isn't in this map, cost defaults to 1.
-   * @example { 'high_res_image': 5, 'text_summary': 1 }
-   */
-  operationCosts?: Record<string, number>;
-
-  /**
-   * Optional callback called after successful credit deduction.
-   * Use this to invalidate TanStack Query cache or trigger UI updates.
-   */
-  onCreditDeducted?: (userId: string, cost: number) => void;
-}
-
-export interface AICreditHelpers {
-  /**
-   * Check if user has credits for a specific generation type
-   * @param userId - User ID
-   * @param generationType - Type of generation
-   * @returns boolean indicating if credits are available
-   */
-  checkCreditsForGeneration: (
-    userId: string | undefined,
-    generationType: string
-  ) => Promise<boolean>;
-
-  /**
-   * Deduct credits after successful generation
-   * @param userId - User ID
-   * @param generationType - Type of generation that was performed
-   */
-  deductCreditsForGeneration: (
-    userId: string | undefined,
-    generationType: string
-  ) => Promise<void>;
-
-  /**
-   * Get cost for a generation type
-   * @param generationType - Type of generation
-   * @returns number of credits
-   */
-  getCost: (generationType: string) => number;
-}
-
-/**
- * Creates AI-specific credit helper functions
- */
-export function createAICreditHelpers(
-  config: AICreditHelpersConfig
-): AICreditHelpers {
-  const { repository, operationCosts = {}, onCreditDeducted } = config;
-
-  // Map generation type to cost
-  const getCost = (generationType: string): number => {
-    return operationCosts[generationType] ?? 1;
-  };
-
-  // Create credit checker
-  const checker = createCreditChecker({
-    repository,
-    onCreditDeducted,
-  });
-
-  // Check if credits are available for generation
-  const checkCreditsForGeneration = async (
-    userId: string | undefined,
-    generationType: string
-  ): Promise<boolean> => {
-    const cost = getCost(generationType);
-    const result = await checker.checkCreditsAvailable(userId, cost);
-    return result.success;
-  };
-
-  // Deduct credits after successful generation
-  const deductCreditsForGeneration = async (
-    userId: string | undefined,
-    generationType: string
-  ): Promise<void> => {
-    const cost = getCost(generationType);
-    await checker.deductCreditsAfterSuccess(userId, cost);
-  };
-
-  return {
-    checkCreditsForGeneration,
-    deductCreditsForGeneration,
-    getCost,
-  };
-}

package/src/utils/authUtils.ts

@@ -1,19 +0,0 @@
-/**
- * Authentication Utilities
- *
- * Centralized logic for authentication checks
- */
-
-export function isAuthenticated(
-  isGuest: boolean,
-  userId: string | null,
-): boolean {
-  return !isGuest && userId !== null;
-}
-
-export function isGuest(
-  isGuestFlag: boolean,
-  userId: string | null,
-): boolean {
-  return isGuestFlag || userId === null;
-}

package/src/utils/creditChecker.ts

@@ -1,82 +0,0 @@
-/**
- * Credit Checker Utility
- *
- * Validates credit availability before operations.
- * Generic - works with any generation type mapping.
- */
-
-import type { CreditsRepository } from "../domains/credits/infrastructure/CreditsRepository";
-
-export interface CreditCheckResult {
-  success: boolean;
-  error?: string;
-}
-
-export interface CreditCheckerConfig {
-  repository: CreditsRepository;
-  /**
-   * Optional callback called after successful credit deduction.
-   * Use this to invalidate TanStack Query cache or trigger UI updates.
-   * @param userId - The user whose credits were deducted
-   * @param cost - The amount of credits deducted
-   */
-  onCreditDeducted?: (userId: string, cost: number) => void;
-}
-
-export const createCreditChecker = (config: CreditCheckerConfig) => {
-  const { repository, onCreditDeducted } = config;
-
-  const checkCreditsAvailable = async (
-    userId: string | undefined,
-    cost: number = 1
-  ): Promise<CreditCheckResult> => {
-    if (!userId) {
-      return { success: false, error: "anonymous_user_blocked" };
-    }
-
-    const hasCreditsAvailable = await repository.hasCredits(userId, cost);
-
-    if (!hasCreditsAvailable) {
-      return {
-        success: false,
-        error: "credits_exhausted",
-      };
-    }
-
-    return { success: true };
-  };
-
-  const deductCreditsAfterSuccess = async (
-    userId: string | undefined,
-    cost: number = 1
-  ): Promise<void> => {
-    if (!userId) return;
-
-    const maxRetries = 3;
-    let lastError: Error | null = null;
-
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-      const result = await repository.deductCredit(userId, cost);
-      if (result.success) {
-        // Notify subscribers that credits were deducted
-        onCreditDeducted?.(userId, cost);
-        return;
-      }
-      lastError = new Error(result.error?.message || "Deduction failed");
-      await new Promise<void>((r) => setTimeout(() => r(), 500 * (attempt + 1)));
-    }
-
-    if (lastError) {
-      throw lastError;
-    }
-  };
-
-
-  return {
-    checkCreditsAvailable,
-    deductCreditsAfterSuccess,
-  };
-};
-
-export type CreditChecker = ReturnType<typeof createCreditChecker>;
-