@umituz/react-native-subscription 1.10.1 → 2.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "1.10.1",
-  "description": "Subscription management, paywall UI and credits system for React Native apps",
+  "version": "2.1.0",
+  "description": "Complete subscription management with RevenueCat, paywall UI, and credits system for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "scripts": {
@@ -36,7 +36,8 @@
     "@umituz/react-native-design-system-atoms": "*",
     "@umituz/react-native-design-system-theme": "*",
     "@umituz/react-native-legal": "*",
-    "firebase": ">=10.0.0"
+    "firebase": ">=10.0.0",
+    "expo-constants": ">=18.0.0"
   },
   "devDependencies": {
     "@types/react": "~19.1.0",
@@ -45,7 +46,9 @@
     "@umituz/react-native-design-system-theme": "latest",
     "@umituz/react-native-firestore": "latest",
     "@tanstack/react-query": "^5.0.0",
-    "firebase": "^11.0.0"
+    "firebase": "^11.0.0",
+    "expo-constants": "~18.0.0",
+    "react-native-purchases": "~9.6.0"
   },
   "publishConfig": {
     "access": "public"

package/src/index.ts

@@ -254,3 +254,65 @@ export {
   type CreditCheckerConfig,
   type CreditChecker,
 } from "./utils/creditChecker";
+
+// =============================================================================
+// REVENUECAT - Errors
+// =============================================================================
+
+export {
+  RevenueCatError,
+  RevenueCatInitializationError,
+  RevenueCatConfigurationError,
+  RevenueCatPurchaseError,
+  RevenueCatRestoreError,
+  RevenueCatNetworkError,
+  RevenueCatExpoGoError,
+} from "./revenuecat/domain/errors/RevenueCatError";
+
+// =============================================================================
+// REVENUECAT - Types & Config
+// =============================================================================
+
+export type { RevenueCatConfig } from "./revenuecat/domain/value-objects/RevenueCatConfig";
+
+export type {
+  RevenueCatEntitlement,
+  RevenueCatPurchaseErrorInfo,
+} from "./revenuecat/domain/types/RevenueCatTypes";
+
+export { REVENUECAT_LOG_PREFIX } from "./revenuecat/domain/constants/RevenueCatConstants";
+
+export {
+  getPremiumEntitlement,
+  isUserCancelledError,
+  getErrorMessage,
+} from "./revenuecat/domain/types/RevenueCatTypes";
+
+// =============================================================================
+// REVENUECAT - Ports
+// =============================================================================
+
+export type {
+  IRevenueCatService,
+  InitializeResult,
+  PurchaseResult,
+  RestoreResult,
+} from "./revenuecat/application/ports/IRevenueCatService";
+
+// =============================================================================
+// REVENUECAT - Service
+// =============================================================================
+
+export {
+  RevenueCatService,
+  initializeRevenueCatService,
+  getRevenueCatService,
+  resetRevenueCatService,
+} from "./revenuecat/infrastructure/services/RevenueCatService";
+
+// =============================================================================
+// REVENUECAT - Hooks
+// =============================================================================
+
+export { useRevenueCat } from "./revenuecat/presentation/hooks/useRevenueCat";
+export type { UseRevenueCatResult } from "./revenuecat/presentation/hooks/useRevenueCat";

package/src/presentation/hooks/useFeatureGate.ts

@@ -28,6 +28,8 @@
 import { useCallback } from "react";
 import { useCredits } from "./useCredits";
 
+declare const __DEV__: boolean;
+
 export interface UseFeatureGateParams {
   /** User ID for credits check */
   userId: string | undefined;
@@ -66,12 +68,39 @@ export function useFeatureGate(
   // User is premium if they have credits
   const isPremium = credits !== null;
 
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    // eslint-disable-next-line no-console
+    console.log("[useFeatureGate] Hook state", {
+      userId,
+      isAuthenticated,
+      isPremium,
+      hasCredits: credits !== null,
+      isLoading,
+    });
+  }
+
   const requireFeature = useCallback(
     (action: () => void | Promise<void>) => {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[useFeatureGate] requireFeature() called", {
+          isAuthenticated,
+          isPremium,
+        });
+      }
+
       // Step 1: Check authentication
       if (!isAuthenticated) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          // eslint-disable-next-line no-console
+          console.log("[useFeatureGate] NOT authenticated → showing auth modal");
+        }
         // After auth, re-check premium before executing
         onShowAuthModal(() => {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            // eslint-disable-next-line no-console
+            console.log("[useFeatureGate] Auth modal callback → executing action");
+          }
           // This callback runs after successful auth
           // The component will re-render with new auth state
           // and user can try the action again
@@ -82,11 +111,19 @@ export function useFeatureGate(
 
       // Step 2: Check premium (has credits from TanStack Query)
       if (!isPremium) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          // eslint-disable-next-line no-console
+          console.log("[useFeatureGate] NOT premium → showing paywall");
+        }
         onShowPaywall();
         return;
       }
 
       // Step 3: User is authenticated and premium - execute action
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[useFeatureGate] PREMIUM user → executing action");
+      }
       action();
     },
     [isAuthenticated, isPremium, onShowAuthModal, onShowPaywall]

package/src/revenuecat/application/ports/IRevenueCatService.ts

@@ -0,0 +1,64 @@
+/**
+ * RevenueCat Service Interface
+ * Port for subscription operations
+ */
+
+import type { PurchasesPackage, PurchasesOffering, CustomerInfo } from "react-native-purchases";
+
+export interface InitializeResult {
+  success: boolean;
+  offering: PurchasesOffering | null;
+  hasPremium: boolean;
+}
+
+export interface PurchaseResult {
+  success: boolean;
+  isPremium: boolean;
+  customerInfo?: CustomerInfo;
+  isConsumable?: boolean;
+  productId?: string;
+}
+
+export interface RestoreResult {
+  success: boolean;
+  isPremium: boolean;
+  customerInfo?: CustomerInfo;
+}
+
+export interface IRevenueCatService {
+  /**
+   * Initialize RevenueCat SDK
+   */
+  initialize(userId: string, apiKey: string): Promise<InitializeResult>;
+
+  /**
+   * Fetch offerings from RevenueCat
+   */
+  fetchOfferings(): Promise<PurchasesOffering | null>;
+
+  /**
+   * Purchase a package
+   */
+  purchasePackage(pkg: PurchasesPackage, userId: string): Promise<PurchaseResult>;
+
+  /**
+   * Restore purchases
+   */
+  restorePurchases(userId: string): Promise<RestoreResult>;
+
+  /**
+   * Reset RevenueCat SDK (for logout)
+   */
+  reset(): Promise<void>;
+
+  /**
+   * Get RevenueCat API key for current platform
+   */
+  getRevenueCatKey(): string | null;
+
+  /**
+   * Check if RevenueCat is initialized
+   */
+  isInitialized(): boolean;
+}
+

package/src/revenuecat/domain/constants/RevenueCatConstants.ts

@@ -0,0 +1,6 @@
+/**
+ * RevenueCat Constants
+ * Internal constants for logging
+ */
+
+export const REVENUECAT_LOG_PREFIX = "[RevenueCat]";

package/src/revenuecat/domain/errors/RevenueCatError.ts

@@ -0,0 +1,56 @@
+/**
+ * RevenueCat Error Classes
+ * Domain-specific error types for RevenueCat operations
+ */
+
+export class RevenueCatError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "RevenueCatError";
+  }
+}
+
+export class RevenueCatInitializationError extends RevenueCatError {
+  constructor(message = "RevenueCat service is not initialized") {
+    super(message);
+    this.name = "RevenueCatInitializationError";
+  }
+}
+
+export class RevenueCatConfigurationError extends RevenueCatError {
+  constructor(message = "RevenueCat configuration is invalid") {
+    super(message);
+    this.name = "RevenueCatConfigurationError";
+  }
+}
+
+export class RevenueCatPurchaseError extends RevenueCatError {
+  public productId: string | undefined;
+
+  constructor(message: string, productId?: string) {
+    super(message);
+    this.name = "RevenueCatPurchaseError";
+    this.productId = productId;
+  }
+}
+
+export class RevenueCatRestoreError extends RevenueCatError {
+  constructor(message = "Failed to restore purchases") {
+    super(message);
+    this.name = "RevenueCatRestoreError";
+  }
+}
+
+export class RevenueCatNetworkError extends RevenueCatError {
+  constructor(message = "Network error during RevenueCat operation") {
+    super(message);
+    this.name = "RevenueCatNetworkError";
+  }
+}
+
+export class RevenueCatExpoGoError extends RevenueCatError {
+  constructor(message = "RevenueCat is not available in Expo Go. Use a development build or test store.") {
+    super(message);
+    this.name = "RevenueCatExpoGoError";
+  }
+}

package/src/revenuecat/domain/types/RevenueCatTypes.ts

@@ -0,0 +1,77 @@
+/**
+ * RevenueCat Type Definitions
+ * Proper typing for RevenueCat entitlements and errors
+ */
+
+import type { CustomerInfo } from "react-native-purchases";
+
+/**
+ * RevenueCat Entitlement Info
+ * Represents active entitlement data from CustomerInfo
+ */
+export interface RevenueCatEntitlement {
+  identifier: string;
+  productIdentifier: string;
+  isSandbox: boolean;
+  willRenew: boolean;
+  periodType: string;
+  latestPurchaseDate: string | null;
+  originalPurchaseDate: string | null;
+  expirationDate: string | null;
+  unsubscribeDetectedAt: string | null;
+  billingIssueDetectedAt: string | null;
+}
+
+/**
+ * RevenueCat Purchase Error with userCancelled flag
+ */
+export interface RevenueCatPurchaseErrorInfo extends Error {
+  userCancelled?: boolean;
+  code?: string;
+}
+
+/**
+ * Extract entitlement from CustomerInfo
+ */
+export function getPremiumEntitlement(
+  customerInfo: CustomerInfo,
+  entitlementIdentifier: string = 'premium'
+): RevenueCatEntitlement | null {
+  const entitlement = customerInfo.entitlements.active[entitlementIdentifier];
+  if (!entitlement) {
+    return null;
+  }
+
+  return {
+    identifier: entitlement.identifier,
+    productIdentifier: entitlement.productIdentifier,
+    isSandbox: entitlement.isSandbox,
+    willRenew: entitlement.willRenew,
+    periodType: entitlement.periodType,
+    latestPurchaseDate: entitlement.latestPurchaseDate,
+    originalPurchaseDate: entitlement.originalPurchaseDate,
+    expirationDate: entitlement.expirationDate,
+    unsubscribeDetectedAt: entitlement.unsubscribeDetectedAt,
+    billingIssueDetectedAt: entitlement.billingIssueDetectedAt,
+  };
+}
+
+/**
+ * Check if error is a user cancellation
+ */
+export function isUserCancelledError(error: unknown): boolean {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  return (error as RevenueCatPurchaseErrorInfo).userCancelled === true;
+}
+
+/**
+ * Extract error message safely
+ */
+export function getErrorMessage(error: unknown, fallback: string): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return fallback;
+}

package/src/revenuecat/domain/value-objects/RevenueCatConfig.ts

@@ -0,0 +1,44 @@
+/**
+ * RevenueCat Configuration Value Object
+ * Validates and stores RevenueCat configuration
+ */
+
+import type { CustomerInfo } from "react-native-purchases";
+
+export interface RevenueCatConfig {
+  /** iOS API key */
+  iosApiKey?: string;
+  /** Android API key */
+  androidApiKey?: string;
+  /** Test Store key for development/Expo Go testing */
+  testStoreKey?: string;
+  /** Entitlement identifier to check for premium status (REQUIRED - app specific) */
+  entitlementIdentifier: string;
+  /** Product identifiers for consumable products (e.g., credits packages) */
+  consumableProductIdentifiers?: string[];
+  /** Callback for premium status sync to database */
+  onPremiumStatusChanged?: (
+    userId: string,
+    isPremium: boolean,
+    productId?: string,
+    expiresAt?: string
+  ) => Promise<void> | void;
+  /** Callback for purchase completion */
+  onPurchaseCompleted?: (
+    userId: string,
+    productId: string,
+    customerInfo: CustomerInfo
+  ) => Promise<void> | void;
+  /** Callback for restore completion */
+  onRestoreCompleted?: (
+    userId: string,
+    isPremium: boolean,
+    customerInfo: CustomerInfo
+  ) => Promise<void> | void;
+}
+
+export interface RevenueCatConfigRequired {
+  iosApiKey: string;
+  androidApiKey: string;
+}
+

package/src/revenuecat/infrastructure/services/CustomerInfoListenerManager.ts

@@ -0,0 +1,64 @@
+/**
+ * Customer Info Listener Manager
+ * Handles RevenueCat customer info update listeners
+ */
+
+import Purchases, {
+  type CustomerInfo,
+  type CustomerInfoUpdateListener,
+} from "react-native-purchases";
+import type { RevenueCatConfig } from "../../domain/value-objects/RevenueCatConfig";
+import { syncPremiumStatus } from "../utils/PremiumStatusSyncer";
+
+export class CustomerInfoListenerManager {
+  private listener: CustomerInfoUpdateListener | null = null;
+  private currentUserId: string | null = null;
+  private entitlementIdentifier: string;
+
+  constructor(entitlementIdentifier: string) {
+    this.entitlementIdentifier = entitlementIdentifier;
+  }
+
+  setUserId(userId: string): void {
+    this.currentUserId = userId;
+  }
+
+  clearUserId(): void {
+    this.currentUserId = null;
+  }
+
+  setupListener(config: RevenueCatConfig): void {
+    this.removeListener();
+
+    this.listener = (customerInfo: CustomerInfo) => {
+      if (!this.currentUserId) return;
+
+      const hasPremium =
+        !!customerInfo.entitlements.active[this.entitlementIdentifier];
+
+      if (__DEV__) {
+        console.log("[RevenueCat] CustomerInfo updated", {
+          userId: this.currentUserId,
+          hasPremium,
+          entitlementIdentifier: this.entitlementIdentifier,
+        });
+      }
+
+      syncPremiumStatus(config, this.currentUserId, customerInfo);
+    };
+
+    Purchases.addCustomerInfoUpdateListener(this.listener);
+  }
+
+  removeListener(): void {
+    if (this.listener) {
+      Purchases.removeCustomerInfoUpdateListener(this.listener);
+      this.listener = null;
+    }
+  }
+
+  destroy(): void {
+    this.removeListener();
+    this.clearUserId();
+  }
+}

package/src/revenuecat/infrastructure/services/OfferingsFetcher.ts

@@ -0,0 +1,55 @@
+/**
+ * Offerings Fetcher
+ * Handles RevenueCat offerings retrieval
+ */
+
+import Purchases, { type PurchasesOffering } from "react-native-purchases";
+import { isExpoGo } from "../utils/ExpoGoDetector";
+
+export interface OfferingsFetcherDeps {
+  isInitialized: () => boolean;
+  isUsingTestStore: () => boolean;
+}
+
+export async function fetchOfferings(
+  deps: OfferingsFetcherDeps
+): Promise<PurchasesOffering | null> {
+  if (__DEV__) {
+    console.log(
+      "[RevenueCat] fetchOfferings() called, isInitialized:",
+      deps.isInitialized()
+    );
+  }
+
+  if (!deps.isInitialized()) {
+    if (__DEV__) {
+      console.log("[RevenueCat] fetchOfferings() - NOT initialized");
+    }
+    return null;
+  }
+
+  if (isExpoGo() && !deps.isUsingTestStore()) {
+    if (__DEV__) {
+      console.log("[RevenueCat] fetchOfferings() - ExpoGo without test store");
+    }
+    return null;
+  }
+
+  try {
+    const offerings = await Purchases.getOfferings();
+
+    if (__DEV__) {
+      console.log("[RevenueCat] fetchOfferings() result:", {
+        hasCurrent: !!offerings.current,
+        packagesCount: offerings.current?.availablePackages?.length ?? 0,
+      });
+    }
+
+    return offerings.current;
+  } catch (error) {
+    if (__DEV__) {
+      console.log("[RevenueCat] fetchOfferings() error:", error);
+    }
+    return null;
+  }
+}

package/src/revenuecat/infrastructure/services/PurchaseHandler.ts

@@ -0,0 +1,103 @@
+/**
+ * Purchase Handler
+ * Handles RevenueCat purchase operations for both subscriptions and consumables
+ */
+
+import Purchases, { type PurchasesPackage } from "react-native-purchases";
+import type { PurchaseResult } from "../../application/ports/IRevenueCatService";
+import {
+  RevenueCatPurchaseError,
+  RevenueCatExpoGoError,
+  RevenueCatInitializationError,
+} from "../../domain/errors/RevenueCatError";
+import type { RevenueCatConfig } from "../../domain/value-objects/RevenueCatConfig";
+import {
+  isUserCancelledError,
+  getErrorMessage,
+} from "../../domain/types/RevenueCatTypes";
+import { isExpoGo } from "../utils/ExpoGoDetector";
+import {
+  syncPremiumStatus,
+  notifyPurchaseCompleted,
+} from "../utils/PremiumStatusSyncer";
+
+export interface PurchaseHandlerDeps {
+  config: RevenueCatConfig;
+  isInitialized: () => boolean;
+  isUsingTestStore: () => boolean;
+}
+
+function isConsumableProduct(
+  pkg: PurchasesPackage,
+  consumableIds: string[]
+): boolean {
+  if (consumableIds.length === 0) return false;
+  const identifier = pkg.product.identifier.toLowerCase();
+  return consumableIds.some((id) => identifier.includes(id.toLowerCase()));
+}
+
+/**
+ * Handle package purchase - supports both subscriptions and consumables
+ */
+export async function handlePurchase(
+  deps: PurchaseHandlerDeps,
+  pkg: PurchasesPackage,
+  userId: string
+): Promise<PurchaseResult> {
+  if (__DEV__) {
+    console.log("[RevenueCat] handlePurchase() called for:", pkg.product.identifier);
+  }
+
+  if (!deps.isInitialized()) {
+    throw new RevenueCatInitializationError();
+  }
+
+  if (isExpoGo() && !deps.isUsingTestStore()) {
+    throw new RevenueCatExpoGoError();
+  }
+
+  const consumableIds = deps.config.consumableProductIdentifiers || [];
+  const isConsumable = isConsumableProduct(pkg, consumableIds);
+
+  try {
+    const purchaseResult = await Purchases.purchasePackage(pkg);
+    const customerInfo = purchaseResult.customerInfo;
+
+    // For consumable products (credits), purchase success is enough
+    if (isConsumable) {
+      return {
+        success: true,
+        isPremium: false,
+        customerInfo,
+        isConsumable: true,
+        productId: pkg.product.identifier,
+      };
+    }
+
+    // For subscriptions, check premium entitlement
+    const entitlementIdentifier = deps.config.entitlementIdentifier;
+    const isPremium = !!customerInfo.entitlements.active[entitlementIdentifier];
+
+    if (isPremium) {
+      await syncPremiumStatus(deps.config, userId, customerInfo);
+      await notifyPurchaseCompleted(
+        deps.config,
+        userId,
+        pkg.product.identifier,
+        customerInfo
+      );
+      return { success: true, isPremium: true, customerInfo };
+    }
+
+    throw new RevenueCatPurchaseError(
+      "Purchase completed but premium entitlement not active",
+      pkg.product.identifier
+    );
+  } catch (error) {
+    if (isUserCancelledError(error)) {
+      return { success: false, isPremium: false };
+    }
+    const errorMessage = getErrorMessage(error, "Purchase failed");
+    throw new RevenueCatPurchaseError(errorMessage, pkg.product.identifier);
+  }
+}

package/src/revenuecat/infrastructure/services/RestoreHandler.ts

@@ -0,0 +1,57 @@
+/**
+ * Restore Handler
+ * Handles RevenueCat restore operations
+ */
+
+import Purchases from "react-native-purchases";
+import type { RestoreResult } from "../../application/ports/IRevenueCatService";
+import {
+  RevenueCatRestoreError,
+  RevenueCatExpoGoError,
+  RevenueCatInitializationError,
+} from "../../domain/errors/RevenueCatError";
+import type { RevenueCatConfig } from "../../domain/value-objects/RevenueCatConfig";
+import { getErrorMessage } from "../../domain/types/RevenueCatTypes";
+import { isExpoGo } from "../utils/ExpoGoDetector";
+import {
+  syncPremiumStatus,
+  notifyRestoreCompleted,
+} from "../utils/PremiumStatusSyncer";
+
+export interface RestoreHandlerDeps {
+  config: RevenueCatConfig;
+  isInitialized: () => boolean;
+  isUsingTestStore: () => boolean;
+}
+
+/**
+ * Handle restore purchases
+ */
+export async function handleRestore(
+  deps: RestoreHandlerDeps,
+  userId: string
+): Promise<RestoreResult> {
+  if (!deps.isInitialized()) {
+    throw new RevenueCatInitializationError();
+  }
+
+  if (isExpoGo() && !deps.isUsingTestStore()) {
+    throw new RevenueCatExpoGoError();
+  }
+
+  try {
+    const customerInfo = await Purchases.restorePurchases();
+    const entitlementIdentifier = deps.config.entitlementIdentifier;
+    const isPremium = !!customerInfo.entitlements.active[entitlementIdentifier];
+
+    if (isPremium) {
+      await syncPremiumStatus(deps.config, userId, customerInfo);
+    }
+    await notifyRestoreCompleted(deps.config, userId, isPremium, customerInfo);
+
+    return { success: isPremium, isPremium, customerInfo };
+  } catch (error) {
+    const errorMessage = getErrorMessage(error, "Restore failed");
+    throw new RevenueCatRestoreError(errorMessage);
+  }
+}

package/src/revenuecat/infrastructure/services/RevenueCatInitializer.ts

@@ -0,0 +1,124 @@
+/**
+ * RevenueCat Initializer
+ * Handles SDK initialization logic
+ */
+
+import Purchases from "react-native-purchases";
+import type { InitializeResult } from "../../application/ports/IRevenueCatService";
+import type { RevenueCatConfig } from "../../domain/value-objects/RevenueCatConfig";
+import { getErrorMessage } from "../../domain/types/RevenueCatTypes";
+import { isExpoGo } from "../utils/ExpoGoDetector";
+import { resolveApiKey } from "../utils/ApiKeyResolver";
+
+export interface InitializerDeps {
+  config: RevenueCatConfig;
+  isUsingTestStore: () => boolean;
+  isInitialized: () => boolean;
+  getCurrentUserId: () => string | null;
+  setInitialized: (value: boolean) => void;
+  setCurrentUserId: (userId: string) => void;
+}
+
+export async function initializeSDK(
+  deps: InitializerDeps,
+  userId: string,
+  apiKey?: string
+): Promise<InitializeResult> {
+  if (__DEV__) {
+    console.log("[RevenueCat] initializeSDK() called with userId:", userId);
+  }
+
+  // Check if already initialized with same userId - skip re-configuration
+  if (deps.isInitialized()) {
+    const currentUserId = deps.getCurrentUserId();
+    if (currentUserId === userId) {
+      if (__DEV__) {
+        console.log("[RevenueCat] Already initialized with same userId, skipping configure");
+      }
+      // Just fetch current state without re-configuring
+      try {
+        const [customerInfo, offerings] = await Promise.all([
+          Purchases.getCustomerInfo(),
+          Purchases.getOfferings(),
+        ]);
+        const entitlementId = deps.config.entitlementIdentifier;
+        const hasPremium = !!customerInfo.entitlements.active[entitlementId];
+        return { success: true, offering: offerings.current, hasPremium };
+      } catch (error) {
+        if (__DEV__) {
+          console.log("[RevenueCat] Failed to get current state:", error);
+        }
+        return { success: false, offering: null, hasPremium: false };
+      }
+    } else {
+      if (__DEV__) {
+        console.log("[RevenueCat] Different userId, will re-configure");
+      }
+      // Different userId - need to logout first
+      try {
+        await Purchases.logOut();
+      } catch {
+        // Ignore logout errors
+      }
+    }
+  }
+
+  if (isExpoGo() && !deps.isUsingTestStore()) {
+    if (__DEV__) {
+      console.log("[RevenueCat] Skipping - ExpoGo without test store");
+    }
+    return { success: false, offering: null, hasPremium: false };
+  }
+
+  const key = apiKey || resolveApiKey(deps.config);
+  if (!key) {
+    if (__DEV__) {
+      console.log("[RevenueCat] No API key available");
+    }
+    return { success: false, offering: null, hasPremium: false };
+  }
+
+  try {
+    if (deps.isUsingTestStore()) {
+      if (__DEV__) {
+        console.log("[RevenueCat] Using Test Store key");
+      }
+    }
+
+    if (__DEV__) {
+      console.log("[RevenueCat] Calling Purchases.configure()...");
+    }
+
+    await Purchases.configure({ apiKey: key, appUserID: userId });
+    deps.setInitialized(true);
+    deps.setCurrentUserId(userId);
+
+    if (__DEV__) {
+      console.log("[RevenueCat] SDK configured successfully");
+    }
+
+    const [customerInfo, offerings] = await Promise.all([
+      Purchases.getCustomerInfo(),
+      Purchases.getOfferings(),
+    ]);
+
+    if (__DEV__) {
+      console.log("[RevenueCat] Fetched offerings:", {
+        hasCurrent: !!offerings.current,
+        packagesCount: offerings.current?.availablePackages?.length ?? 0,
+        allOfferingsCount: Object.keys(offerings.all).length,
+      });
+    }
+
+    const entitlementId = deps.config.entitlementIdentifier;
+    const hasPremium = !!customerInfo.entitlements.active[entitlementId];
+
+    return { success: true, offering: offerings.current, hasPremium };
+  } catch (error) {
+    const errorMessage = getErrorMessage(error, "RevenueCat init failed");
+    if (__DEV__) {
+      console.log("[RevenueCat] Init failed:", errorMessage);
+    }
+    return { success: false, offering: null, hasPremium: false };
+  }
+}

package/src/revenuecat/infrastructure/services/RevenueCatService.ts

@@ -0,0 +1,132 @@
+/**
+ * RevenueCat Service Implementation
+ * Main service class for RevenueCat operations
+ */
+
+import Purchases from "react-native-purchases";
+import type { PurchasesOffering, PurchasesPackage } from "react-native-purchases";
+import type {
+  IRevenueCatService,
+  InitializeResult,
+  PurchaseResult,
+  RestoreResult,
+} from "../../application/ports/IRevenueCatService";
+import type { RevenueCatConfig } from "../../domain/value-objects/RevenueCatConfig";
+import { resolveApiKey } from "../utils/ApiKeyResolver";
+import { initializeSDK } from "./RevenueCatInitializer";
+import { fetchOfferings } from "./OfferingsFetcher";
+import { handlePurchase } from "./PurchaseHandler";
+import { handleRestore } from "./RestoreHandler";
+import { CustomerInfoListenerManager } from "./CustomerInfoListenerManager";
+import { ServiceStateManager } from "./ServiceStateManager";
+
+export class RevenueCatService implements IRevenueCatService {
+  private stateManager: ServiceStateManager;
+  private listenerManager: CustomerInfoListenerManager;
+
+  constructor(config: RevenueCatConfig) {
+    this.stateManager = new ServiceStateManager(config);
+    this.listenerManager = new CustomerInfoListenerManager(
+      config.entitlementIdentifier
+    );
+  }
+
+  getRevenueCatKey(): string | null {
+    return resolveApiKey(this.stateManager.getConfig());
+  }
+
+  isInitialized(): boolean {
+    return this.stateManager.isInitialized();
+  }
+
+  isUsingTestStore(): boolean {
+    return this.stateManager.isUsingTestStore();
+  }
+
+  async initialize(userId: string, apiKey?: string): Promise<InitializeResult> {
+    const result = await initializeSDK(
+      {
+        config: this.stateManager.getConfig(),
+        isUsingTestStore: () => this.isUsingTestStore(),
+        isInitialized: () => this.isInitialized(),
+        getCurrentUserId: () => this.stateManager.getCurrentUserId(),
+        setInitialized: (value) => this.stateManager.setInitialized(value),
+        setCurrentUserId: (id) => this.stateManager.setCurrentUserId(id),
+      },
+      userId,
+      apiKey
+    );
+
+    if (result.success) {
+      this.listenerManager.setUserId(userId);
+      this.listenerManager.setupListener(this.stateManager.getConfig());
+    }
+
+    return result;
+  }
+
+  async fetchOfferings(): Promise<PurchasesOffering | null> {
+    return fetchOfferings({
+      isInitialized: () => this.isInitialized(),
+      isUsingTestStore: () => this.isUsingTestStore(),
+    });
+  }
+
+  async purchasePackage(
+    pkg: PurchasesPackage,
+    userId: string
+  ): Promise<PurchaseResult> {
+    return handlePurchase(
+      {
+        config: this.stateManager.getConfig(),
+        isInitialized: () => this.isInitialized(),
+        isUsingTestStore: () => this.isUsingTestStore(),
+      },
+      pkg,
+      userId
+    );
+  }
+
+  async restorePurchases(userId: string): Promise<RestoreResult> {
+    return handleRestore(
+      {
+        config: this.stateManager.getConfig(),
+        isInitialized: () => this.isInitialized(),
+        isUsingTestStore: () => this.isUsingTestStore(),
+      },
+      userId
+    );
+  }
+
+  async reset(): Promise<void> {
+    if (!this.isInitialized()) return;
+
+    this.listenerManager.destroy();
+
+    try {
+      await Purchases.logOut();
+      this.stateManager.setInitialized(false);
+    } catch {
+      // Reset errors are non-critical
+    }
+  }
+}
+
+let revenueCatServiceInstance: RevenueCatService | null = null;
+
+export function initializeRevenueCatService(
+  config: RevenueCatConfig
+): RevenueCatService {
+  if (!revenueCatServiceInstance) {
+    revenueCatServiceInstance = new RevenueCatService(config);
+  }
+  return revenueCatServiceInstance;
+}
+
+export function getRevenueCatService(): RevenueCatService | null {
+  return revenueCatServiceInstance;
+}
+
+export function resetRevenueCatService(): void {
+  revenueCatServiceInstance = null;
+}

package/src/revenuecat/infrastructure/services/ServiceStateManager.ts

@@ -0,0 +1,71 @@
+/**
+ * Service State Manager
+ * Manages RevenueCat service state
+ */
+
+import type { RevenueCatConfig } from "../../domain/value-objects/RevenueCatConfig";
+import { isExpoGo, isDevelopment } from "../utils/ExpoGoDetector";
+
+export class ServiceStateManager {
+  private isInitializedFlag: boolean = false;
+  private usingTestStore: boolean = false;
+  private currentUserId: string | null = null;
+  private config: RevenueCatConfig;
+
+  constructor(config: RevenueCatConfig) {
+    this.config = config;
+    this.usingTestStore = this.shouldUseTestStore();
+
+    if (__DEV__) {
+      console.log("[RevenueCat] Config", {
+        hasTestKey: !!this.config.testStoreKey,
+        usingTestStore: this.usingTestStore,
+        entitlementIdentifier: this.config.entitlementIdentifier,
+      });
+    }
+  }
+
+  private shouldUseTestStore(): boolean {
+    const testKey = this.config.testStoreKey;
+    return !!(testKey && (isExpoGo() || isDevelopment()));
+  }
+
+  setInitialized(value: boolean): void {
+    this.isInitializedFlag = value;
+    if (!value) {
+      this.currentUserId = null;
+    }
+  }
+
+  isInitialized(): boolean {
+    return this.isInitializedFlag;
+  }
+
+  setCurrentUserId(userId: string): void {
+    this.currentUserId = userId;
+  }
+
+  getCurrentUserId(): string | null {
+    return this.currentUserId;
+  }
+
+  isUsingTestStore(): boolean {
+    return this.usingTestStore;
+  }
+
+  getConfig(): RevenueCatConfig {
+    return this.config;
+  }
+
+  updateConfig(config: RevenueCatConfig): void {
+    this.config = config;
+    this.usingTestStore = this.shouldUseTestStore();
+
+    if (__DEV__) {
+      console.log("[RevenueCat] Config updated", {
+        hasTestKey: !!this.config.testStoreKey,
+        usingTestStore: this.usingTestStore,
+      });
+    }
+  }
+}

package/src/revenuecat/infrastructure/utils/ApiKeyResolver.ts

@@ -0,0 +1,38 @@
+/**
+ * API Key Resolver
+ * Resolves RevenueCat API key from configuration
+ */
+
+import { Platform } from "react-native";
+import type { RevenueCatConfig } from "../../domain/value-objects/RevenueCatConfig";
+import { isExpoGo, isDevelopment } from "./ExpoGoDetector";
+
+/**
+ * Check if Test Store key should be used
+ */
+export function shouldUseTestStore(config: RevenueCatConfig): boolean {
+  const testKey = config.testStoreKey;
+  return !!(testKey && (isExpoGo() || isDevelopment()));
+}
+
+/**
+ * Get RevenueCat API key from config
+ * Returns Test Store key if in dev/Expo Go environment
+ */
+export function resolveApiKey(config: RevenueCatConfig): string | null {
+  if (shouldUseTestStore(config)) {
+    return config.testStoreKey ?? null;
+  }
+
+  const key = Platform.OS === 'ios'
+    ? config.iosApiKey
+    : Platform.OS === 'android'
+      ? config.androidApiKey
+      : config.iosApiKey;
+
+  if (!key || key === "" || key.includes("YOUR_")) {
+    return null;
+  }
+
+  return key;
+}

package/src/revenuecat/infrastructure/utils/ExpirationDateCalculator.ts

@@ -0,0 +1,20 @@
+/**
+ * Expiration Date Calculator
+ * Handles RevenueCat expiration date extraction
+ */
+
+import type { RevenueCatEntitlement } from "../../domain/types/RevenueCatTypes";
+
+export function getExpirationDate(
+  entitlement: RevenueCatEntitlement | null
+): string | null {
+  if (!entitlement) {
+    return null;
+  }
+
+  if (!entitlement.expirationDate) {
+    return null;
+  }
+
+  return new Date(entitlement.expirationDate).toISOString();
+}

package/src/revenuecat/infrastructure/utils/ExpoGoDetector.ts

@@ -0,0 +1,27 @@
+/**
+ * Expo Go Detector
+ * Detects runtime environment for RevenueCat configuration
+ */
+
+import Constants from "expo-constants";
+
+/**
+ * Check if running in Expo Go
+ */
+export function isExpoGo(): boolean {
+  return Constants.executionEnvironment === "storeClient";
+}
+
+/**
+ * Check if running in development mode
+ */
+export function isDevelopment(): boolean {
+  return typeof __DEV__ !== "undefined" && __DEV__;
+}
+
+/**
+ * Check if Test Store should be used (Expo Go or development)
+ */
+export function isTestStoreEnvironment(): boolean {
+  return isExpoGo() || isDevelopment();
+}

package/src/revenuecat/infrastructure/utils/PremiumStatusSyncer.ts

@@ -0,0 +1,88 @@
+/**
+ * Premium Status Syncer
+ * Syncs premium status to database via callbacks
+ */
+
+import type { CustomerInfo } from "react-native-purchases";
+import type { RevenueCatConfig } from "../../domain/value-objects/RevenueCatConfig";
+import { getPremiumEntitlement } from "../../domain/types/RevenueCatTypes";
+import { getExpirationDate } from "./ExpirationDateCalculator";
+
+export async function syncPremiumStatus(
+  config: RevenueCatConfig,
+  userId: string,
+  customerInfo: CustomerInfo
+): Promise<void> {
+  if (!config.onPremiumStatusChanged) {
+    return;
+  }
+
+  const entitlementIdentifier = config.entitlementIdentifier;
+  const premiumEntitlement = getPremiumEntitlement(
+    customerInfo,
+    entitlementIdentifier
+  );
+
+  try {
+    if (premiumEntitlement) {
+      const productId = premiumEntitlement.productIdentifier;
+      const expiresAt = getExpirationDate(premiumEntitlement);
+      await config.onPremiumStatusChanged(
+        userId,
+        true,
+        productId,
+        expiresAt || undefined
+      );
+    } else {
+      await config.onPremiumStatusChanged(userId, false);
+    }
+  } catch (error) {
+    if (__DEV__) {
+      const message =
+        error instanceof Error ? error.message : "Premium sync failed";
+      console.log("[RevenueCat] Premium status sync failed:", message);
+    }
+  }
+}
+
+export async function notifyPurchaseCompleted(
+  config: RevenueCatConfig,
+  userId: string,
+  productId: string,
+  customerInfo: CustomerInfo
+): Promise<void> {
+  if (!config.onPurchaseCompleted) {
+    return;
+  }
+
+  try {
+    await config.onPurchaseCompleted(userId, productId, customerInfo);
+  } catch (error) {
+    if (__DEV__) {
+      const message =
+        error instanceof Error ? error.message : "Purchase callback failed";
+      console.log("[RevenueCat] Purchase completion callback failed:", message);
+    }
+  }
+}
+
+export async function notifyRestoreCompleted(
+  config: RevenueCatConfig,
+  userId: string,
+  isPremium: boolean,
+  customerInfo: CustomerInfo
+): Promise<void> {
+  if (!config.onRestoreCompleted) {
+    return;
+  }
+
+  try {
+    await config.onRestoreCompleted(userId, isPremium, customerInfo);
+  } catch (error) {
+    if (__DEV__) {
+      const message =
+        error instanceof Error ? error.message : "Restore callback failed";
+      console.log("[RevenueCat] Restore completion callback failed:", message);
+    }
+  }
+}

package/src/revenuecat/presentation/hooks/useRevenueCat.ts

@@ -0,0 +1,101 @@
+/**
+ * useRevenueCat Hook
+ * React hook for RevenueCat subscription management
+ */
+
+import { useState, useCallback } from "react";
+import type { PurchasesOffering, PurchasesPackage } from "react-native-purchases";
+import { getRevenueCatService } from "../../infrastructure/services/RevenueCatService";
+import type { PurchaseResult, RestoreResult } from "../../application/ports/IRevenueCatService";
+
+export interface UseRevenueCatResult {
+  /** Current offering */
+  offering: PurchasesOffering | null;
+  /** Whether RevenueCat is loading */
+  loading: boolean;
+  /** Initialize RevenueCat SDK */
+  initialize: (userId: string, apiKey?: string) => Promise<void>;
+  /** Load offerings */
+  loadOfferings: () => Promise<void>;
+  /** Purchase a package */
+  purchasePackage: (pkg: PurchasesPackage, userId: string) => Promise<PurchaseResult>;
+  /** Restore purchases */
+  restorePurchases: (userId: string) => Promise<RestoreResult>;
+}
+
+/**
+ * Hook for RevenueCat operations
+ * Only initialize when subscription screen is opened
+ * 
+ * @example
+ * ```typescript
+ * const { offering, loading, initialize, purchasePackage } = useRevenueCat();
+ * ```
+ */
+export function useRevenueCat(): UseRevenueCatResult {
+  const [offering, setOffering] = useState<PurchasesOffering | null>(null);
+  const [loading, setLoading] = useState(false);
+
+  const initialize = useCallback(async (userId: string, apiKey?: string) => {
+    setLoading(true);
+    try {
+      const service = getRevenueCatService();
+      if (!service) {
+        return;
+      }
+      const result = await service.initialize(userId, apiKey);
+      if (result.success) {
+        setOffering(result.offering);
+      }
+    } catch {
+      // Error handling is done by service
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  const loadOfferings = useCallback(async () => {
+    setLoading(true);
+    try {
+      const service = getRevenueCatService();
+      if (!service) {
+        return;
+      }
+      const fetchedOffering = await service.fetchOfferings();
+      setOffering(fetchedOffering);
+    } catch {
+      // Error handling is done by service
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  const purchasePackage = useCallback(async (pkg: PurchasesPackage, userId: string) => {
+    const service = getRevenueCatService();
+    if (!service) {
+      throw new Error("RevenueCat service is not initialized");
+    }
+    return await service.purchasePackage(pkg, userId);
+  }, []);
+
+  const restorePurchases = useCallback(async (userId: string) => {
+    const service = getRevenueCatService();
+    if (!service) {
+      throw new Error("RevenueCat service is not initialized");
+    }
+    return await service.restorePurchases(userId);
+  }, []);
+
+  // Note: State cleanup is handled by React automatically on unmount
+  // No explicit cleanup needed for these state variables
+
+  return {
+    offering,
+    loading,
+    initialize,
+    loadOfferings,
+    purchasePackage,
+    restorePurchases,
+  };
+}
+