@umituz/react-native-subscription 2.21.0 → 2.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.21.0",
+  "version": "2.22.1",
   "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/index.ts

@@ -14,6 +14,13 @@ export type { ISubscriptionRepository } from "./application/ports/ISubscriptionR
 
 // Infrastructure Layer
 export { SubscriptionService, initializeSubscriptionService } from "./infrastructure/services/SubscriptionService";
+export {
+  submitFeedback,
+  submitPaywallFeedback,
+  submitSettingsFeedback,
+  type FeedbackData,
+  type FeedbackSubmitResult,
+} from "./infrastructure/services/FeedbackService";
 export { initializeSubscription, type SubscriptionInitConfig, type CreditPackageConfig } from "./infrastructure/services/SubscriptionInitializer";
 export { CreditsRepository, createCreditsRepository } from "./infrastructure/repositories/CreditsRepository";
 export { configureCreditsRepository, getCreditsRepository, getCreditsConfig, resetCreditsRepository, isCreditsRepositoryConfigured } from "./infrastructure/repositories/CreditsRepositoryProvider";

package/src/infrastructure/services/FeedbackService.ts

@@ -0,0 +1,117 @@
+/**
+ * Feedback Service
+ * Handles feedback submission to Firestore
+ */
+
+import { getFirestore } from "@umituz/react-native-firebase";
+import { collection, addDoc } from "firebase/firestore";
+
+export interface FeedbackData {
+  userId: string | null;
+  userEmail: string | null;
+  type: string;
+  title: string;
+  description: string;
+  rating?: number;
+  status?: string;
+}
+
+export interface FeedbackSubmitResult {
+  success: boolean;
+  error?: Error;
+}
+
+const FEEDBACK_COLLECTION = "feedback";
+
+/**
+ * Submit feedback to Firestore
+ */
+export async function submitFeedback(
+  data: FeedbackData
+): Promise<FeedbackSubmitResult> {
+  const db = getFirestore();
+
+  if (!db) {
+    if (__DEV__) {
+      console.warn("[FeedbackService] Firestore not available");
+    }
+    return { success: false, error: new Error("Firestore not available") };
+  }
+
+  try {
+    if (__DEV__) {
+      console.log("[FeedbackService] Submitting feedback:", {
+        type: data.type,
+        userId: data.userId?.slice(0, 8),
+      });
+    }
+
+    const now = new Date().toISOString();
+
+    await addDoc(collection(db, FEEDBACK_COLLECTION), {
+      userId: data.userId,
+      userEmail: data.userEmail,
+      type: data.type,
+      title: data.title,
+      description: data.description,
+      rating: data.rating ?? null,
+      status: data.status ?? "pending",
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    if (__DEV__) {
+      console.log("[FeedbackService] Feedback submitted successfully");
+    }
+
+    return { success: true };
+  } catch (error) {
+    if (__DEV__) {
+      console.error("[FeedbackService] Submit error:", error);
+    }
+    return {
+      success: false,
+      error: error instanceof Error ? error : new Error("Unknown error"),
+    };
+  }
+}
+
+/**
+ * Submit paywall decline feedback
+ */
+export async function submitPaywallFeedback(
+  userId: string | null,
+  userEmail: string | null,
+  reason: string
+): Promise<FeedbackSubmitResult> {
+  return submitFeedback({
+    userId,
+    userEmail,
+    type: "paywall_declined",
+    title: "Paywall Declined",
+    description: reason,
+  });
+}
+
+/**
+ * Submit general settings feedback
+ */
+export async function submitSettingsFeedback(
+  userId: string | null,
+  userEmail: string | null,
+  data: {
+    type?: string;
+    title?: string;
+    description: string;
+    rating?: number;
+  }
+): Promise<FeedbackSubmitResult> {
+  return submitFeedback({
+    userId,
+    userEmail,
+    type: data.type ?? "general",
+    title: data.title ?? "Settings Feedback",
+    description: data.description,
+    rating: data.rating,
+  });
+}

package/src/presentation/hooks/feedback/useFeedbackSubmit.ts

@@ -0,0 +1,105 @@
+/**
+ * Feedback Submit Hooks
+ * React hooks for submitting feedback to Firestore
+ */
+
+import { useCallback } from "react";
+import { useAuth } from "@umituz/react-native-auth";
+import {
+  submitPaywallFeedback,
+  submitSettingsFeedback,
+} from "../../../infrastructure/services/FeedbackService";
+
+export interface UsePaywallFeedbackSubmitOptions {
+  onSuccess?: () => void;
+  onError?: (error: Error) => void;
+  onComplete?: () => void;
+}
+
+/**
+ * Hook for submitting paywall decline feedback
+ */
+export function usePaywallFeedbackSubmit(
+  options: UsePaywallFeedbackSubmitOptions = {}
+) {
+  const { user } = useAuth();
+  const { onSuccess, onError, onComplete } = options;
+
+  const submit = useCallback(
+    async (reason: string) => {
+      if (__DEV__) {
+        console.log("[usePaywallFeedbackSubmit] Submitting:", {
+          userId: user?.uid?.slice(0, 8),
+          reason: reason.slice(0, 20),
+        });
+      }
+
+      const result = await submitPaywallFeedback(
+        user?.uid ?? null,
+        user?.email ?? null,
+        reason
+      );
+
+      if (result.success) {
+        onSuccess?.();
+      } else if (result.error) {
+        onError?.(result.error);
+      }
+
+      onComplete?.();
+    },
+    [user, onSuccess, onError, onComplete]
+  );
+
+  return { submit };
+}
+
+export interface SettingsFeedbackData {
+  type?: string;
+  title?: string;
+  description: string;
+  rating?: number;
+}
+
+export interface UseSettingsFeedbackSubmitOptions {
+  onSuccess?: () => void;
+  onError?: (error: Error) => void;
+}
+
+/**
+ * Hook for submitting general settings feedback
+ */
+export function useSettingsFeedbackSubmit(
+  options: UseSettingsFeedbackSubmitOptions = {}
+) {
+  const { user } = useAuth();
+  const { onSuccess, onError } = options;
+
+  const submit = useCallback(
+    async (data: SettingsFeedbackData) => {
+      if (__DEV__) {
+        console.log("[useSettingsFeedbackSubmit] Submitting:", {
+          userId: user?.uid?.slice(0, 8),
+          type: data.type,
+        });
+      }
+
+      const result = await submitSettingsFeedback(
+        user?.uid ?? null,
+        user?.email ?? null,
+        data
+      );
+
+      if (result.success) {
+        onSuccess?.();
+      } else if (result.error) {
+        onError?.(result.error);
+      }
+
+      return result;
+    },
+    [user, onSuccess, onError]
+  );
+
+  return { submit };
+}

package/src/presentation/hooks/index.ts

@@ -21,3 +21,4 @@ export * from "./useSubscriptionStatus";
 export * from "./useUserTier";
 export * from "./useUserTierWithRepository";
 export * from "./feedback/usePaywallFeedback";
+export * from "./feedback/useFeedbackSubmit";

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

@@ -1,9 +1,13 @@
 /**
  * Purchase Handler
  * Handles RevenueCat purchase operations for both subscriptions and consumables
+ *
+ * IMPORTANT: Uses race condition with CustomerInfo listener to handle
+ * known RevenueCat bug where purchasePackage can hang indefinitely.
+ * @see https://github.com/RevenueCat/react-native-purchases/issues/1082
  */
 
-import Purchases, { type PurchasesPackage } from "react-native-purchases";
+import Purchases, { type PurchasesPackage, type CustomerInfo } from "react-native-purchases";
 import type { PurchaseResult } from "../../application/ports/IRevenueCatService";
 import {
     RevenueCatPurchaseError,
@@ -20,6 +24,50 @@ import {
 } from "../utils/PremiumStatusSyncer";
 import { getSavedPurchase, clearSavedPurchase } from "../../../presentation/hooks/useAuthAwarePurchase";
 
+const PURCHASE_LISTENER_TIMEOUT_MS = 30000; // 30 seconds fallback timeout
+
+/**
+ * Creates a promise that resolves when CustomerInfo listener detects premium
+ * This is a workaround for RevenueCat bug where purchasePackage can hang
+ */
+function createPremiumListenerPromise(
+    entitlementId: string
+): { promise: Promise<CustomerInfo>; cleanup: () => void } {
+    let cleanup: () => void = () => {};
+    let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+    const promise = new Promise<CustomerInfo>((resolve, reject) => {
+        const listener = (info: CustomerInfo) => {
+            const isPremium = !!info.entitlements.active[entitlementId];
+            if (isPremium) {
+                if (__DEV__) {
+                    console.log('[DEBUG PurchaseHandler] Listener detected premium!');
+                }
+                cleanup();
+                resolve(info);
+            }
+        };
+
+        Purchases.addCustomerInfoUpdateListener(listener);
+
+        // Fallback timeout - if neither purchasePackage nor listener resolves
+        timeoutId = setTimeout(() => {
+            cleanup();
+            reject(new Error('Purchase timed out. Please try again.'));
+        }, PURCHASE_LISTENER_TIMEOUT_MS);
+
+        cleanup = () => {
+            Purchases.removeCustomerInfoUpdateListener(listener);
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+        };
+    });
+
+    return { promise, cleanup };
+}
+
 export interface PurchaseHandlerDeps {
     config: RevenueCatConfig;
     isInitialized: () => boolean;
@@ -63,9 +111,13 @@ export async function handlePurchase(
     const consumableIds = deps.config.consumableProductIdentifiers || [];
     const isConsumable = isConsumableProduct(pkg, consumableIds);
 
+    // Set up listener-based detection as fallback for purchasePackage bug
+    const entitlementIdentifier = deps.config.entitlementIdentifier;
+    const { promise: listenerPromise, cleanup: cleanupListener } = createPremiumListenerPromise(entitlementIdentifier);
+
     try {
         if (__DEV__) {
-            console.log('[DEBUG PurchaseHandler] Calling Purchases.purchasePackage...', {
+            console.log('[DEBUG PurchaseHandler] Calling Purchases.purchasePackage with listener fallback...', {
                 productId: pkg.product.identifier,
                 packageIdentifier: pkg.identifier,
                 offeringIdentifier: pkg.offeringIdentifier,
@@ -74,12 +126,28 @@ export async function handlePurchase(
         }
 
         const startTime = Date.now();
-        const purchaseResult = await Purchases.purchasePackage(pkg);
+
+        // Race between purchasePackage and listener detection
+        // This handles the known RevenueCat bug where purchasePackage can hang
+        const purchasePromise = Purchases.purchasePackage(pkg).then(result => ({
+            source: 'purchasePackage' as const,
+            customerInfo: result.customerInfo
+        }));
+
+        const listenerWithSource = listenerPromise.then(info => ({
+            source: 'listener' as const,
+            customerInfo: info
+        }));
+
+        const result = await Promise.race([purchasePromise, listenerWithSource]);
+        cleanupListener();
+
         const duration = Date.now() - startTime;
-        const customerInfo = purchaseResult.customerInfo;
+        const customerInfo = result.customerInfo;
 
         if (__DEV__) {
-            console.log('[DEBUG PurchaseHandler] Purchases.purchasePackage returned', {
+            console.log('[DEBUG PurchaseHandler] Purchase resolved via:', {
+                source: result.source,
                 duration: `${duration}ms`,
                 productId: pkg.product.identifier
             });
@@ -118,7 +186,6 @@ export async function handlePurchase(
             };
         }
 
-        const entitlementIdentifier = deps.config.entitlementIdentifier;
         const isPremium = !!customerInfo.entitlements.active[entitlementIdentifier];
 
         if (__DEV__) {
@@ -173,6 +240,9 @@ export async function handlePurchase(
             pkg.product.identifier
         );
     } catch (error) {
+        // Ensure listener cleanup on error
+        cleanupListener();
+
         if (__DEV__) {
             console.error('[DEBUG PurchaseHandler] Purchase error caught', {
                 error,