@umituz/react-native-subscription 2.27.66 → 2.27.68

package/src/infrastructure/services/SubscriptionInitializer.ts

@@ -1,176 +0,0 @@
-/**
- * Subscription Initializer
- *
- * Uses RevenueCat best practices:
- * - Non-blocking initialization (fire and forget)
- * - Relies on CustomerInfoUpdateListener for state updates
- * - No manual timeouts - uses auth state listener with cleanup
- */
-
-import { Platform } from "react-native";
-import type { CustomerInfo } from "react-native-purchases";
-import { configureCreditsRepository, getCreditsRepository } from "../repositories/CreditsRepositoryProvider";
-import { SubscriptionManager } from "../../revenuecat/infrastructure/managers/SubscriptionManager";
-import { configureAuthProvider } from "../../presentation/hooks/useAuthAwarePurchase";
-import type { RevenueCatData } from "../../domain/types/RevenueCatData";
-import { type PeriodType, type PurchaseSource } from "../../domain/entities/SubscriptionConstants";
-import type { SubscriptionInitConfig, FirebaseAuthLike } from "./SubscriptionInitializerTypes";
-
-export type { FirebaseAuthLike, CreditPackageConfig, SubscriptionInitConfig } from "./SubscriptionInitializerTypes";
-
-/**
- * Gets the current user ID from Firebase auth.
- * Uses listener pattern for reliability instead of timeout.
- * Falls back immediately if no auth is available.
- */
-const getCurrentUserId = (getAuth: () => FirebaseAuthLike | null): string | undefined => {
-  const auth = getAuth();
-  if (!auth) return undefined;
-  return auth.currentUser?.uid;
-};
-
-/**
- * Sets up auth state listener that will re-initialize subscription
- * when user auth state changes (login/logout).
- */
-const setupAuthStateListener = (
-  getAuth: () => FirebaseAuthLike | null,
-  onUserChange: (userId: string | undefined) => void
-): (() => void) | null => {
-  const auth = getAuth();
-  if (!auth) return null;
-
-  return auth.onAuthStateChanged((user) => {
-    onUserChange(user?.uid);
-  });
-};
-
-/** Extract RevenueCat data from CustomerInfo (Single Source of Truth) */
-const extractRevenueCatData = (customerInfo: CustomerInfo, entitlementId: string): RevenueCatData => {
-  const entitlement = customerInfo.entitlements.active[entitlementId]
-    ?? customerInfo.entitlements.all[entitlementId];
-  return {
-    expirationDate: entitlement?.expirationDate ?? customerInfo.latestExpirationDate ?? null,
-    willRenew: entitlement?.willRenew ?? false,
-    originalTransactionId: entitlement?.originalPurchaseDate ?? undefined,
-    periodType: entitlement?.periodType as PeriodType | undefined,
-  };
-};
-
-export const initializeSubscription = async (config: SubscriptionInitConfig): Promise<void> => {
-  const {
-    apiKey, apiKeyIos, apiKeyAndroid, entitlementId, credits,
-    getAnonymousUserId, getFirebaseAuth, showAuthModal,
-    onCreditsUpdated, creditPackages,
-  } = config;
-
-  const key = Platform.OS === 'ios' ? (apiKeyIos || apiKey || '') : (apiKeyAndroid || apiKey || '');
-  if (!key) throw new Error('API key required');
-
-  configureCreditsRepository({ ...credits, creditPackageAmounts: creditPackages?.amounts });
-
-  const onPurchase = async (userId: string, productId: string, customerInfo: CustomerInfo, source?: PurchaseSource) => {
-    if (__DEV__) console.log('[SubscriptionInitializer] onPurchase:', { userId, productId, source });
-    try {
-      const revenueCatData = extractRevenueCatData(customerInfo, entitlementId);
-      await getCreditsRepository().initializeCredits(userId, `purchase_${productId}_${Date.now()}`, productId, source, revenueCatData);
-      onCreditsUpdated?.(userId);
-    } catch (error) {
-      if (__DEV__) console.error('[SubscriptionInitializer] Credits init failed:', error);
-    }
-  };
-
-  const onRenewal = async (userId: string, productId: string, newExpirationDate: string, customerInfo: CustomerInfo) => {
-    if (__DEV__) console.log('[SubscriptionInitializer] onRenewal:', { userId, productId });
-    try {
-      const revenueCatData = extractRevenueCatData(customerInfo, entitlementId);
-      revenueCatData.expirationDate = newExpirationDate || revenueCatData.expirationDate;
-      await getCreditsRepository().initializeCredits(userId, `renewal_${productId}_${Date.now()}`, productId, "renewal", revenueCatData);
-      onCreditsUpdated?.(userId);
-    } catch (error) {
-      if (__DEV__) console.error('[SubscriptionInitializer] Renewal credits init failed:', error);
-    }
-  };
-
-  const onPremiumStatusChanged = async (
-    userId: string, isPremium: boolean, productId?: string,
-    expiresAt?: string, willRenew?: boolean, periodType?: PeriodType
-  ) => {
-    if (__DEV__) console.log('[SubscriptionInitializer] onPremiumStatusChanged:', { userId, isPremium, productId, willRenew, periodType });
-    try {
-      // If premium became false, check if actually expired or just canceled
-      if (!isPremium && productId) {
-        const isActuallyExpired = !expiresAt || new Date(expiresAt) < new Date();
-        if (isActuallyExpired) {
-          await getCreditsRepository().syncExpiredStatus(userId);
-          if (__DEV__) console.log('[SubscriptionInitializer] Subscription expired, synced status');
-        } else {
-          if (__DEV__) console.log('[SubscriptionInitializer] Canceled but not expired, preserving until:', expiresAt);
-          const revenueCatData: RevenueCatData = { expirationDate: expiresAt, willRenew: false, isPremium: true, periodType };
-          await getCreditsRepository().initializeCredits(userId, `status_sync_canceled_${Date.now()}`, productId, "settings", revenueCatData);
-        }
-        onCreditsUpdated?.(userId);
-        return;
-      }
-
-      // Premium user - initialize credits with subscription data
-      const revenueCatData: RevenueCatData = { expirationDate: expiresAt ?? null, willRenew: willRenew ?? false, isPremium, periodType };
-      await getCreditsRepository().initializeCredits(userId, `status_sync_${Date.now()}`, productId, "settings", revenueCatData);
-      if (__DEV__) console.log('[SubscriptionInitializer] Premium status synced to Firestore');
-      onCreditsUpdated?.(userId);
-    } catch (error) {
-      if (__DEV__) console.error('[SubscriptionInitializer] Premium status sync failed:', error);
-    }
-  };
-
-  SubscriptionManager.configure({
-    config: {
-      apiKey: key,
-      entitlementIdentifier: entitlementId,
-      consumableProductIdentifiers: [creditPackages?.identifierPattern || 'credit'],
-      onPurchaseCompleted: onPurchase,
-      onRenewalDetected: onRenewal,
-      onPremiumStatusChanged,
-      onCreditsUpdated,
-    },
-    apiKey: key,
-    getAnonymousUserId,
-  });
-
-  // Configure auth provider immediately (sync)
-  configureAuthProvider({
-    isAuthenticated: () => {
-      const u = getFirebaseAuth()?.currentUser;
-      return !!(u && !u.isAnonymous);
-    },
-    showAuthModal,
-  });
-
-  // Get initial user ID (sync - no waiting)
-  const initialUserId = getCurrentUserId(getFirebaseAuth);
-
-  /**
-   * Non-blocking initialization (fire and forget)
-   * RevenueCat best practice: Don't block on initialization.
-   * The CustomerInfoUpdateListener will handle state updates reactively.
-   */
-  const initializeInBackground = async (userId?: string) => {
-    try {
-      await SubscriptionManager.initialize(userId);
-      if (__DEV__) console.log('[SubscriptionInitializer] Background init complete');
-    } catch (error) {
-      // Non-critical - listener will handle updates
-      if (__DEV__) console.log('[SubscriptionInitializer] Background init error (non-critical):', error);
-    }
-  };
-
-  // Start initialization in background (non-blocking)
-  initializeInBackground(initialUserId);
-
-  // Set up auth state listener for reactive updates
-  // When user logs in/out, re-initialize with new user ID
-  setupAuthStateListener(getFirebaseAuth, (newUserId) => {
-    if (__DEV__) console.log('[SubscriptionInitializer] Auth state changed:', newUserId ? 'logged in' : 'logged out');
-    initializeInBackground(newUserId);
-  });
-};

package/src/infrastructure/services/SubscriptionService.ts

@@ -1,133 +0,0 @@
-/**
- * Subscription Service Implementation
- * Database-first subscription management
- */
-
-import { timezoneService } from "@umituz/react-native-design-system";
-import type { ISubscriptionService } from "../../application/ports/ISubscriptionService";
-import type { ISubscriptionRepository } from "../../application/ports/ISubscriptionRepository";
-import type { SubscriptionStatus } from "../../domain/entities/SubscriptionStatus";
-import { createDefaultSubscriptionStatus } from "../../domain/entities/SubscriptionStatus";
-import {
-  SubscriptionRepositoryError,
-  SubscriptionValidationError,
-} from "../../domain/errors/SubscriptionError";
-import type { SubscriptionConfig } from "../../domain/value-objects/SubscriptionConfig";
-import {
-  activateSubscription,
-  deactivateSubscription,
-  safeHandleError,
-  type ActivationHandlerConfig,
-} from "./ActivationHandler";
-
-export class SubscriptionService implements ISubscriptionService {
-  private repository: ISubscriptionRepository;
-  private handlerConfig: ActivationHandlerConfig;
-
-  constructor(config: SubscriptionConfig) {
-    if (!config.repository) {
-      throw new SubscriptionValidationError("Repository is required");
-    }
-
-    this.repository = config.repository;
-    this.handlerConfig = {
-      repository: config.repository,
-      onStatusChanged: config.onStatusChanged,
-      onError: config.onError,
-    };
-  }
-
-  async getSubscriptionStatus(userId: string): Promise<SubscriptionStatus> {
-    try {
-      const status = await this.repository.getSubscriptionStatus(userId);
-      if (!status) {
-        return createDefaultSubscriptionStatus();
-      }
-
-      const isValid = this.repository.isSubscriptionValid(status);
-      if (!isValid && status.isPremium) {
-        return await this.deactivateSubscription(userId);
-      }
-
-      return status;
-    } catch (error) {
-      await this.handleError(error, "getSubscriptionStatus");
-      return createDefaultSubscriptionStatus();
-    }
-  }
-
-  async isPremium(userId: string): Promise<boolean> {
-    const status = await this.getSubscriptionStatus(userId);
-    return this.repository.isSubscriptionValid(status);
-  }
-
-  async activateSubscription(
-    userId: string,
-    productId: string,
-    expiresAt: string | null
-  ): Promise<SubscriptionStatus> {
-    return activateSubscription(
-      this.handlerConfig,
-      userId,
-      productId,
-      expiresAt
-    );
-  }
-
-  async deactivateSubscription(userId: string): Promise<SubscriptionStatus> {
-    return deactivateSubscription(this.handlerConfig, userId);
-  }
-
-  async updateSubscriptionStatus(
-    userId: string,
-    updates: Partial<SubscriptionStatus>
-  ): Promise<SubscriptionStatus> {
-    try {
-      const updatesWithSync = {
-        ...updates,
-        syncedAt: timezoneService.getCurrentISOString(),
-      };
-
-      const updatedStatus = await this.repository.updateSubscriptionStatus(
-        userId,
-        updatesWithSync
-      );
-
-      if (this.handlerConfig.onStatusChanged) {
-        try {
-          await this.handlerConfig.onStatusChanged(userId, updatedStatus);
-        } catch (error) {
-          await this.handleError(error, "updateSubscriptionStatus.callback");
-        }
-      }
-
-      return updatedStatus;
-    } catch (error) {
-      await this.handleError(error, "updateSubscriptionStatus");
-      throw new SubscriptionRepositoryError("Failed to update subscription");
-    }
-  }
-
-  private async handleError(error: unknown, context: string): Promise<void> {
-    await safeHandleError(this.handlerConfig.onError, error, `SubscriptionService.${context}`);
-  }
-}
-
-let subscriptionServiceInstance: SubscriptionService | null = null;
-
-export function initializeSubscriptionService(
-  config: SubscriptionConfig
-): SubscriptionService {
-  if (!subscriptionServiceInstance) {
-    subscriptionServiceInstance = new SubscriptionService(config);
-  }
-  return subscriptionServiceInstance;
-}
-
-export function getSubscriptionService(): SubscriptionService | null {
-  return subscriptionServiceInstance;
-}
-
-export function resetSubscriptionService(): void {
-  subscriptionServiceInstance = null;
-}

package/src/infrastructure/services/TrialService.ts

@@ -1,197 +0,0 @@
-/**
- * Trial Service - Device-based trial tracking to prevent abuse
- */
-
-import { doc, getDoc, setDoc, serverTimestamp, arrayUnion } from "firebase/firestore";
-import { getFirestore } from "@umituz/react-native-firebase";
-import { PersistentDeviceIdService } from "@umituz/react-native-design-system";
-import type { TrialEligibilityResult } from "./TrialTypes";
-
-export { TRIAL_CONFIG, type DeviceTrialRecord, type TrialEligibilityResult } from "./TrialTypes";
-
-const DEVICE_TRIALS_COLLECTION = "device_trials";
-
-/** Get persistent device ID */
-export async function getDeviceId(): Promise<string> {
-  return PersistentDeviceIdService.getDeviceId();
-}
-
-/** Check if device is eligible for trial */
-export async function checkTrialEligibility(deviceId?: string): Promise<TrialEligibilityResult> {
-  try {
-    const effectiveDeviceId = deviceId || await getDeviceId();
-    const db = getFirestore();
-
-    if (!db) {
-      if (__DEV__) {
-        console.log("[TrialService] No Firestore instance");
-      }
-      return { eligible: true, deviceId: effectiveDeviceId };
-    }
-
-    const trialRef = doc(db, DEVICE_TRIALS_COLLECTION, effectiveDeviceId);
-    const trialDoc = await getDoc(trialRef);
-
-    if (!trialDoc.exists()) {
-      if (__DEV__) {
-        console.log("[TrialService] No trial record found, eligible");
-      }
-      return { eligible: true, deviceId: effectiveDeviceId };
-    }
-
-    const data = trialDoc.data();
-    const hasUsedTrial = data?.hasUsedTrial === true;
-    const trialInProgress = data?.trialInProgress === true;
-
-    if (__DEV__) {
-      console.log("[TrialService] Trial record found:", {
-        deviceId: effectiveDeviceId.slice(0, 8),
-        hasUsedTrial,
-        trialInProgress,
-      });
-    }
-
-    // Not eligible if trial was already used (converted or ended)
-    // OR if trial is currently in progress
-    if (hasUsedTrial || trialInProgress) {
-      return {
-        eligible: false,
-        reason: "already_used",
-        deviceId: effectiveDeviceId,
-      };
-    }
-
-    return { eligible: true, deviceId: effectiveDeviceId };
-  } catch (error) {
-    if (__DEV__) {
-      console.error("[TrialService] Eligibility check error:", error);
-    }
-    return { eligible: false, reason: "error" };
-  }
-}
-
-/** Record trial start for a device */
-export async function recordTrialStart(userId: string, deviceId?: string): Promise<boolean> {
-  try {
-    const effectiveDeviceId = deviceId || await getDeviceId();
-    const db = getFirestore();
-
-    if (!db) {
-      if (__DEV__) {
-        console.log("[TrialService] No Firestore instance");
-      }
-      return false;
-    }
-
-    const trialRef = doc(db, DEVICE_TRIALS_COLLECTION, effectiveDeviceId);
-
-    await setDoc(
-      trialRef,
-      {
-        deviceId: effectiveDeviceId,
-        trialInProgress: true,
-        trialStartedAt: serverTimestamp(),
-        lastUserId: userId,
-        userIds: arrayUnion(userId),
-        updatedAt: serverTimestamp(),
-      },
-      { merge: true }
-    );
-
-    // Also set createdAt if it's a new record
-    const existingDoc = await getDoc(trialRef);
-    if (!existingDoc.data()?.createdAt) {
-      await setDoc(
-        trialRef,
-        { createdAt: serverTimestamp() },
-        { merge: true }
-      );
-    }
-
-    if (__DEV__) {
-      console.log("[TrialService] Trial recorded:", {
-        deviceId: effectiveDeviceId.slice(0, 8),
-        userId: userId.slice(0, 8),
-      });
-    }
-
-    return true;
-  } catch (error) {
-    if (__DEV__) {
-      console.error("[TrialService] Record trial error:", error);
-    }
-    return false;
-  }
-}
-
-/**
- * Record trial end (cancelled or expired)
- */
-export async function recordTrialEnd(deviceId?: string): Promise<boolean> {
-  try {
-    const effectiveDeviceId = deviceId || await getDeviceId();
-    const db = getFirestore();
-
-    if (!db) return false;
-
-    const trialRef = doc(db, DEVICE_TRIALS_COLLECTION, effectiveDeviceId);
-
-    await setDoc(
-      trialRef,
-      {
-        hasUsedTrial: true,
-        trialInProgress: false,
-        trialEndedAt: serverTimestamp(),
-        updatedAt: serverTimestamp(),
-      },
-      { merge: true }
-    );
-
-    if (__DEV__) {
-      console.log("[TrialService] Trial end recorded - trial now consumed");
-    }
-
-    return true;
-  } catch (error) {
-    if (__DEV__) {
-      console.error("[TrialService] Record trial end error:", error);
-    }
-    return false;
-  }
-}
-
-/**
- * Record trial conversion to paid subscription
- */
-export async function recordTrialConversion(deviceId?: string): Promise<boolean> {
-  try {
-    const effectiveDeviceId = deviceId || await getDeviceId();
-    const db = getFirestore();
-
-    if (!db) return false;
-
-    const trialRef = doc(db, DEVICE_TRIALS_COLLECTION, effectiveDeviceId);
-
-    await setDoc(
-      trialRef,
-      {
-        hasUsedTrial: true,
-        trialInProgress: false,
-        trialConvertedAt: serverTimestamp(),
-        updatedAt: serverTimestamp(),
-      },
-      { merge: true }
-    );
-
-    if (__DEV__) {
-      console.log("[TrialService] Trial conversion recorded - user converted to paid");
-    }
-
-    return true;
-  } catch (error) {
-    if (__DEV__) {
-      console.error("[TrialService] Record conversion error:", error);
-    }
-    return false;
-  }
-}

package/src/infrastructure/services/app-service-helpers.ts

@@ -1,111 +0,0 @@
-/**
- * App Service Helpers
- * Creates ready-to-use service implementations for configureAppServices
- */
-
-import { getCreditsRepository } from "../repositories/CreditsRepositoryProvider";
-import { getRevenueCatService } from "../../revenuecat/infrastructure/services/RevenueCatService";
-import { getPremiumEntitlement } from "../../revenuecat/domain/types/RevenueCatTypes";
-import { creditsQueryKeys } from "../../presentation/hooks/useCredits";
-import { paywallControl } from "../../presentation/hooks/usePaywallVisibility";
-import {
-  getGlobalQueryClient,
-  hasGlobalQueryClient,
-} from "@umituz/react-native-design-system";
-import {
-  useAuthStore,
-  selectUserId,
-} from "@umituz/react-native-auth";
-
-export interface CreditServiceConfig {
-  entitlementId: string;
-}
-
-export interface ICreditService {
-  checkCredits: (cost: number) => Promise<boolean>;
-  deductCredits: (cost: number) => Promise<void>;
-  refundCredits: (amount: number, error?: unknown) => Promise<void>;
-  calculateCost: (capability: string, metadata?: Record<string, unknown>) => number;
-}
-
-export interface IPaywallService {
-  showPaywall: (requiredCredits: number) => void;
-}
-
-const checkPremiumStatus = async (entitlementId: string): Promise<boolean> => {
-  try {
-    const rcService = getRevenueCatService();
-    if (!rcService) return false;
-
-    const customerInfo = await rcService.getCustomerInfo();
-    if (!customerInfo) return false;
-
-    return !!getPremiumEntitlement(customerInfo, entitlementId);
-  } catch {
-    return false;
-  }
-};
-
-/**
- * Creates a credit service implementation
- */
-export function createCreditService(config: CreditServiceConfig): ICreditService {
-  const { entitlementId } = config;
-
-  return {
-    checkCredits: async (cost: number): Promise<boolean> => {
-      const userId = selectUserId(useAuthStore.getState());
-      if (!userId) return false;
-
-      // Premium users bypass credit check
-      if (await checkPremiumStatus(entitlementId)) return true;
-
-      try {
-        const repository = getCreditsRepository();
-        const result = await repository.getCredits(userId);
-        if (!result.success || !result.data) return false;
-        return (result.data.credits ?? 0) >= cost;
-      } catch {
-        return false;
-      }
-    },
-
-    deductCredits: async (cost: number): Promise<void> => {
-      const userId = selectUserId(useAuthStore.getState());
-      if (!userId) return;
-
-      // Premium users don't consume credits
-      if (await checkPremiumStatus(entitlementId)) return;
-
-      try {
-        const repository = getCreditsRepository();
-        await repository.deductCredit(userId, cost);
-
-        if (hasGlobalQueryClient()) {
-          getGlobalQueryClient().invalidateQueries({
-            queryKey: creditsQueryKeys.user(userId),
-          });
-        }
-      } catch (error) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error("[CreditService] Deduct error:", error);
-        }
-      }
-    },
-
-    refundCredits: async (): Promise<void> => {
-      // No-op for now
-    },
-
-    calculateCost: (): number => 1,
-  };
-}
-
-/**
- * Creates a paywall service implementation
- */
-export function createPaywallService(): IPaywallService {
-  return {
-    showPaywall: () => paywallControl.open(),
-  };
-}