@umituz/react-native-ai-generation-content 1.72.3 → 1.72.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.72.3",
+  "version": "1.72.5",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/domains/access-control/hooks/useAIFeatureGate.ts

@@ -17,16 +17,34 @@ import type {
   AIFeatureGateReturn,
 } from "../types/access-control.types";
 
+declare const __DEV__: boolean;
+
 const handlePromiseResult = (
   result: void | Promise<void>,
   onSuccess?: () => void,
   onError?: (error: Error) => void,
 ): void => {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[AIFeatureGate] handlePromiseResult - isPromise:", result instanceof Promise);
+  }
   if (result instanceof Promise) {
     result
-      .then(() => onSuccess?.())
-      .catch((err) => onError?.(err instanceof Error ? err : new Error(String(err))));
+      .then(() => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[AIFeatureGate] Promise resolved, calling onSuccess");
+        }
+        onSuccess?.();
+      })
+      .catch((err) => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[AIFeatureGate] Promise rejected:", err);
+        }
+        onError?.(err instanceof Error ? err : new Error(String(err)));
+      });
   } else {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[AIFeatureGate] Sync result, calling onSuccess");
+    }
     onSuccess?.();
   }
 };
@@ -62,18 +80,45 @@ export function useAIFeatureGate(options: AIFeatureGateOptions): AIFeatureGateRe
 
   const requireFeature = useCallback(
     (action: () => void | Promise<void>): void => {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[AIFeatureGate] requireFeature called:", {
+          isOffline,
+          isAuthenticated,
+          isCreditsLoaded,
+          isPremium,
+          creditBalance,
+          creditCost,
+          hasCredits,
+        });
+      }
+
       if (isOffline) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[AIFeatureGate] BLOCKED: User is offline");
+        }
         onNetworkError?.();
         return;
       }
 
-      if (isAuthenticated && !isCreditsLoaded) return;
+      if (isAuthenticated && !isCreditsLoaded) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[AIFeatureGate] BLOCKED: User authenticated but credits not loaded yet");
+        }
+        return;
+      }
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[AIFeatureGate] Calling requireFeatureFromPackage");
+      }
 
       requireFeatureFromPackage(() => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[AIFeatureGate] Inside requireFeatureFromPackage callback - executing action");
+        }
         handlePromiseResult(action(), onSuccess, onError);
       });
     },
-    [isOffline, isAuthenticated, isCreditsLoaded, onNetworkError, requireFeatureFromPackage, onSuccess, onError],
+    [isOffline, isAuthenticated, isCreditsLoaded, isPremium, creditBalance, creditCost, hasCredits, onNetworkError, requireFeatureFromPackage, onSuccess, onError],
   );
 
   return {

package/src/presentation/hooks/generation/orchestrator.ts

@@ -62,25 +62,61 @@ export const useGenerationOrchestrator = <TInput, TResult>(
 
   const executeGeneration = useCallback(
     async (input: TInput) => {
-      const creditDeducted = await deductCredit(strategy.getCreditCost());
-      if (!creditDeducted) throw createGenerationError("credits", alertMessages.creditFailed);
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] ----------------------------------------");
+        console.log("[Orchestrator] executeGeneration() called");
+      }
+
+      const creditCost = strategy.getCreditCost();
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] Deducting credits:", creditCost);
+      }
+
+      const creditDeducted = await deductCredit(creditCost);
+      if (!creditDeducted) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] ERROR: Credit deduction failed");
+        }
+        throw createGenerationError("credits", alertMessages.creditFailed);
+      }
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] Credits deducted successfully");
+      }
 
       setState((prev) => ({ ...prev, status: "generating" }));
-      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[Orchestrator] Starting generation");
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] State: generating - calling strategy.execute()");
+      }
 
       const result = await strategy.execute(input);
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] strategy.execute() completed");
+      }
 
       if (strategy.save && userId) {
         if (isMountedRef.current) setState((prev) => ({ ...prev, status: "saving" }));
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] Saving result to Firestore");
+        }
         try {
           await strategy.save(result, userId);
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] Result saved successfully");
+          }
         } catch (saveErr) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] ERROR: Save failed:", saveErr);
+          }
           throw createGenerationError("save", alertMessages.saveFailed, saveErr instanceof Error ? saveErr : undefined);
         }
       }
 
       if (isMountedRef.current) setState({ status: "success", isGenerating: false, result, error: null });
-      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[Orchestrator] Generation SUCCESS");
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] ✅ Generation SUCCESS");
+        console.log("[Orchestrator] ========================================");
+      }
 
       if (alertMessages.success) showSuccess("Success", alertMessages.success);
       onSuccess?.(result);
@@ -92,41 +128,81 @@ export const useGenerationOrchestrator = <TInput, TResult>(
 
   const generate = useCallback(
     async (input: TInput) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[Orchestrator] generate() called");
-      if (isGeneratingRef.current) return;
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] ========================================");
+        console.log("[Orchestrator] generate() called with input:", JSON.stringify(input).substring(0, 200));
+        console.log("[Orchestrator] isGenerating:", isGeneratingRef.current);
+        console.log("[Orchestrator] userId:", userId);
+      }
+
+      if (isGeneratingRef.current) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] BLOCKED: Already generating");
+        }
+        return;
+      }
 
       // Create new AbortController for this generation
       abortControllerRef.current = new AbortController();
       isGeneratingRef.current = true;
       setState({ ...INITIAL_STATE, status: "checking", isGenerating: true });
 
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] State set to 'checking', isGenerating: true");
+      }
+
       try {
         // Check online status inside the try block to avoid dependency on offlineStore.isOnline
         if (!offlineStore.isOnline) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] ERROR: User is offline");
+          }
           throw createGenerationError("network", alertMessages.networkError);
         }
 
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] Online check passed");
+        }
+
         // Check if aborted
         if (abortControllerRef.current.signal.aborted) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] ERROR: Generation aborted (1)");
+          }
           throw new Error("Generation aborted");
         }
 
         // Pre-validate credits before generation to catch concurrent consumption
         const creditCost = strategy.getCreditCost();
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] Checking credits - cost:", creditCost);
+        }
+
         const hasEnoughCredits = await checkCredits(creditCost);
         if (!hasEnoughCredits) {
           if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[Orchestrator] Pre-validation: insufficient credits");
+            console.log("[Orchestrator] ERROR: Pre-validation failed - insufficient credits");
           }
           onCreditsExhausted?.();
           throw createGenerationError("credits", alertMessages.creditFailed);
         }
 
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] Credit check passed");
+        }
+
         // Check if aborted before moderation
         if (abortControllerRef.current.signal.aborted) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] ERROR: Generation aborted (2)");
+          }
           throw new Error("Generation aborted");
         }
 
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] Starting moderation check");
+        }
+
         return await handleModeration({
           input,
           moderation,