@umituz/react-native-subscription 2.27.47 → 2.27.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.47",
+  "version": "2.27.49",
   "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/domain/entities/Credits.ts

@@ -74,10 +74,6 @@ export interface CreditsConfig {
   creditPackageAmounts?: Record<string, number>;
   /** Credit allocations for different subscription types (weekly, monthly, yearly) */
   packageAllocations?: PackageAllocationMap;
-  /** Enable free credits for new users (default: false) */
-  enableFreeCredits?: boolean;
-  /** Free credits given to new users on registration (only used when enableFreeCredits: true) */
-  freeCredits?: number;
 }
 
 export interface CreditsResult<T = UserCredits> {
@@ -101,6 +97,4 @@ export interface DeductCreditsResult {
 export const DEFAULT_CREDITS_CONFIG: CreditsConfig = {
   collectionName: "user_credits",
   creditLimit: 100,
-  enableFreeCredits: false,
-  freeCredits: 0,
 };

package/src/infrastructure/repositories/CreditsRepository.ts

@@ -12,7 +12,6 @@ import { detectPackageType } from "../../utils/packageTypeDetector";
 import { getCreditAllocation } from "../../utils/creditMapper";
 import { CreditsMapper } from "../mappers/CreditsMapper";
 import type { RevenueCatData } from "../../domain/types/RevenueCatData";
-import { initializeFreeCredits as initializeFreeCreditsService } from "../services/FreeCreditsService";
 
 export type { RevenueCatData } from "../../domain/types/RevenueCatData";
 
@@ -111,10 +110,6 @@ export class CreditsRepository extends BaseRepository {
     return !!(res.success && res.data && res.data.credits >= cost);
   }
 
-  async initializeFreeCredits(userId: string): Promise<CreditsResult> {
-    return initializeFreeCreditsService({ config: this.config, getRef: this.getRef.bind(this) }, userId);
-  }
-
   async syncExpiredStatus(userId: string): Promise<void> {
     const db = getFirestore();
     if (!db) return;

package/src/infrastructure/services/CreditsInitializer.ts

@@ -1,7 +1,6 @@
 /**
  * Credits Initializer
- * Handles subscription credit initialization (NOT free credits)
- * Free credits are handled by CreditsRepository.initializeFreeCredits()
+ * Handles subscription credit initialization for premium users
  */
 
 import { Platform } from "react-native";

package/src/presentation/hooks/useCredits.ts

@@ -3,23 +3,17 @@
  *
  * Fetches user credits with TanStack Query best practices.
  * Uses status-based state management for reliable loading detection.
- * Free credits initialization is delegated to useFreeCreditsInit hook.
  */
 
 import { useQuery } from "@umituz/react-native-design-system";
 import { useCallback, useMemo } from "react";
-import {
-  useAuthStore,
-  selectUserId,
-  selectIsAnonymous,
-} from "@umituz/react-native-auth";
+import { useAuthStore, selectUserId } from "@umituz/react-native-auth";
 import type { UserCredits } from "../../domain/entities/Credits";
 import {
   getCreditsRepository,
   getCreditsConfig,
   isCreditsRepositoryConfigured,
 } from "../../infrastructure/repositories/CreditsRepositoryProvider";
-import { useFreeCreditsInit } from "./useFreeCreditsInit";
 
 declare const __DEV__: boolean;
 
@@ -28,7 +22,7 @@ export const creditsQueryKeys = {
   user: (userId: string) => ["credits", userId] as const,
 };
 
-export type CreditsLoadStatus = "idle" | "loading" | "initializing" | "ready" | "error";
+export type CreditsLoadStatus = "idle" | "loading" | "ready" | "error";
 
 export interface UseCreditsResult {
   credits: UserCredits | null;
@@ -44,21 +38,16 @@ export interface UseCreditsResult {
 
 function deriveLoadStatus(
   queryStatus: "pending" | "error" | "success",
-  isInitializing: boolean,
   queryEnabled: boolean
 ): CreditsLoadStatus {
   if (!queryEnabled) return "idle";
   if (queryStatus === "pending") return "loading";
   if (queryStatus === "error") return "error";
-  if (isInitializing) return "initializing";
   return "ready";
 }
 
 export const useCredits = (): UseCreditsResult => {
   const userId = useAuthStore(selectUserId);
-  const isAnonymous = useAuthStore(selectIsAnonymous);
-  const isRegisteredUser = !!userId && !isAnonymous;
-
   const isConfigured = isCreditsRepositoryConfigured();
   const config = getCreditsConfig();
   const queryEnabled = !!userId && isConfigured;
@@ -104,18 +93,6 @@ export const useCredits = (): UseCreditsResult => {
   });
 
   const credits = data ?? null;
-  const querySuccess = status === "success";
-  const hasCreditsData = (credits?.credits ?? 0) > 0;
-
-  // Delegate free credits initialization to dedicated hook
-  const { isInitializing, needsInit } = useFreeCreditsInit({
-    userId,
-    isRegisteredUser,
-    isAnonymous,
-    hasCredits: hasCreditsData,
-    querySuccess,
-    onInitComplete: refetch,
-  });
 
   const derivedValues = useMemo(() => {
     const has = (credits?.credits ?? 0) > 0;
@@ -128,14 +105,9 @@ export const useCredits = (): UseCreditsResult => {
     [credits]
   );
 
-  // Include needsInit in initializing state for accurate loading detection
-  const loadStatus = deriveLoadStatus(
-    status,
-    isInitializing || needsInit,
-    queryEnabled
-  );
+  const loadStatus = deriveLoadStatus(status, queryEnabled);
   const isCreditsLoaded = loadStatus === "ready";
-  const isLoading = loadStatus === "loading" || loadStatus === "initializing";
+  const isLoading = loadStatus === "loading";
 
   return {
     credits,

package/src/infrastructure/services/FreeCreditsService.ts

@@ -1,83 +0,0 @@
-/**
- * Free Credits Service
- * Handles initialization of free credits for new users
- */
-declare const __DEV__: boolean;
-
-import { runTransaction, serverTimestamp, type Firestore, type DocumentReference, type Transaction } from "firebase/firestore";
-import { getFirestore } from "@umituz/react-native-firebase";
-import type { CreditsConfig, CreditsResult, UserCredits } from "../../domain/entities/Credits";
-import type { UserCreditsDocumentRead } from "../models/UserCreditsDocument";
-import { CreditsMapper } from "../mappers/CreditsMapper";
-
-export interface FreeCreditsServiceConfig {
-  config: CreditsConfig;
-  getRef: (db: Firestore, userId: string) => DocumentReference;
-}
-
-/**
- * Initialize free credits for new users
- * Creates a credits document with freeCredits amount (no subscription)
- * Uses transaction to prevent race condition with premium init
- */
-export async function initializeFreeCredits(
-  deps: FreeCreditsServiceConfig,
-  userId: string
-): Promise<CreditsResult> {
-  const db = getFirestore();
-  if (!db) return { success: false, error: { message: "No DB", code: "INIT_ERR" } };
-
-  const freeCredits = deps.config.freeCredits ?? 0;
-  if (freeCredits <= 0) {
-    return { success: false, error: { message: "Free credits not configured", code: "NO_FREE_CREDITS" } };
-  }
-
-  try {
-    const ref = deps.getRef(db, userId);
-
-    const result = await runTransaction(db, async (tx: Transaction) => {
-      const snap = await tx.get(ref);
-
-      // Don't overwrite if document already exists (premium or previous init)
-      if (snap.exists()) {
-        if (__DEV__) console.log("[FreeCreditsService] Credits document exists, skipping");
-        const existing = snap.data() as UserCreditsDocumentRead;
-        return { skipped: true, data: CreditsMapper.toEntity(existing) };
-      }
-
-      // Create new document with free credits
-      const now = serverTimestamp();
-      const creditsData = {
-        isPremium: false,
-        status: "free" as const,
-        credits: freeCredits,
-        creditLimit: freeCredits,
-        initialFreeCredits: freeCredits,
-        isFreeCredits: true,
-        createdAt: now,
-        lastUpdatedAt: now,
-      };
-
-      tx.set(ref, creditsData);
-
-      if (__DEV__) console.log("[FreeCreditsService] Initialized:", { userId: userId.slice(0, 8), credits: freeCredits });
-
-      const entity: UserCredits = {
-        isPremium: false,
-        status: "free",
-        credits: freeCredits,
-        creditLimit: freeCredits,
-        purchasedAt: null,
-        expirationDate: null,
-        lastUpdatedAt: null,
-        willRenew: false,
-      };
-      return { skipped: false, data: entity };
-    });
-
-    return { success: true, data: result.data };
-  } catch (e: any) {
-    if (__DEV__) console.error("[FreeCreditsService] Init error:", e.message);
-    return { success: false, error: { message: e.message, code: "INIT_ERR" } };
-  }
-}

package/src/presentation/hooks/useFreeCreditsInit.ts

@@ -1,174 +0,0 @@
-/**
- * useFreeCreditsInit Hook
- *
- * Handles free credits initialization for newly registered users.
- * Uses singleton pattern to prevent race conditions across multiple hook instances.
- *
- * @see https://medium.com/@shubhamkandharkar/creating-a-singleton-hook-in-react-a-practical-guide-fe5bf9aaefed
- */
-
-import { useEffect, useCallback, useSyncExternalStore } from "react";
-import {
-  getCreditsRepository,
-  getCreditsConfig,
-  isCreditsRepositoryConfigured,
-} from "../../infrastructure/repositories/CreditsRepositoryProvider";
-
-declare const __DEV__: boolean;
-
-// ============================================================================
-// SINGLETON STATE - Shared across all hook instances
-// ============================================================================
-const freeCreditsInitAttempted = new Set<string>();
-const freeCreditsInitInProgress = new Set<string>();
-const initPromises = new Map<string, Promise<boolean>>();
-const subscribers = new Set<() => void>();
-
-function notifySubscribers(): void {
-  subscribers.forEach((cb) => cb());
-}
-
-function subscribe(callback: () => void): () => void {
-  subscribers.add(callback);
-  return () => subscribers.delete(callback);
-}
-
-function getSnapshot(): Set<string> {
-  return freeCreditsInitInProgress;
-}
-
-async function initializeFreeCreditsForUser(
-  userId: string,
-  onComplete: () => void
-): Promise<boolean> {
-  // Already completed for this user
-  if (freeCreditsInitAttempted.has(userId) && !freeCreditsInitInProgress.has(userId)) {
-    return true;
-  }
-
-  // Already in progress - return existing promise
-  const existingPromise = initPromises.get(userId);
-  if (existingPromise) {
-    return existingPromise;
-  }
-
-  // Mark as attempted and in progress
-  freeCreditsInitAttempted.add(userId);
-  freeCreditsInitInProgress.add(userId);
-  notifySubscribers();
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[useFreeCreditsInit] Initializing free credits:", userId.slice(0, 8));
-  }
-
-  const promise = (async () => {
-    try {
-      if (!isCreditsRepositoryConfigured()) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.warn("[useFreeCreditsInit] Credits repository not configured");
-        }
-        return false;
-      }
-
-      const repository = getCreditsRepository();
-      const result = await repository.initializeFreeCredits(userId);
-
-      if (result.success) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[useFreeCreditsInit] Free credits initialized:", result.data?.credits);
-        }
-        onComplete();
-        return true;
-      } else {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.warn("[useFreeCreditsInit] Free credits init failed:", result.error?.message);
-        }
-        return false;
-      }
-    } catch (error) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.error("[useFreeCreditsInit] Unexpected error:", error);
-      }
-      return false;
-    } finally {
-      freeCreditsInitInProgress.delete(userId);
-      initPromises.delete(userId);
-      notifySubscribers();
-    }
-  })();
-
-  initPromises.set(userId, promise);
-  return promise;
-}
-
-// ============================================================================
-// HOOK INTERFACE
-// ============================================================================
-export interface UseFreeCreditsInitParams {
-  userId: string | null | undefined;
-  isRegisteredUser: boolean;
-  isAnonymous: boolean;
-  hasCredits: boolean;
-  querySuccess: boolean;
-  onInitComplete: () => void;
-}
-
-export interface UseFreeCreditsInitResult {
-  isInitializing: boolean;
-  needsInit: boolean;
-}
-
-export function useFreeCreditsInit(params: UseFreeCreditsInitParams): UseFreeCreditsInitResult {
-  const { userId, isRegisteredUser, isAnonymous, hasCredits, querySuccess, onInitComplete } = params;
-
-  // Subscribe to singleton state changes
-  const inProgressSet = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-
-  const isConfigured = isCreditsRepositoryConfigured();
-  const config = getCreditsConfig();
-  const freeCredits = config.freeCredits ?? 0;
-  // Free credits only enabled when explicitly set to true AND freeCredits > 0
-  const isFreeCreditsEnabled = config.enableFreeCredits === true && freeCredits > 0;
-
-  // Check if THIS user's init is in progress (shared across all hook instances)
-  const isInitializing = userId ? inProgressSet.has(userId) : false;
-
-  // Need init if: query succeeded, registered user, no credits, not attempted yet
-  const needsInit =
-    querySuccess &&
-    !!userId &&
-    isRegisteredUser &&
-    isConfigured &&
-    !hasCredits &&
-    isFreeCreditsEnabled &&
-    !freeCreditsInitAttempted.has(userId);
-
-  // Stable callback reference
-  const stableOnComplete = useCallback(() => {
-    onInitComplete();
-  }, [onInitComplete]);
-
-  useEffect(() => {
-    if (!userId) return;
-
-    if (needsInit) {
-      // Double-check inside effect to handle race conditions
-      if (!freeCreditsInitAttempted.has(userId)) {
-        initializeFreeCreditsForUser(userId, stableOnComplete).catch((error) => {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error("[useFreeCreditsInit] Init failed:", error);
-          }
-        });
-      }
-    } else if (querySuccess && isAnonymous && !hasCredits && isFreeCreditsEnabled) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[useFreeCreditsInit] Skipping - anonymous user must register first");
-      }
-    }
-  }, [needsInit, userId, querySuccess, isAnonymous, hasCredits, isFreeCreditsEnabled, stableOnComplete]);
-
-  return {
-    isInitializing: isInitializing || needsInit,
-    needsInit,
-  };
-}