@umituz/react-native-ai-generation-content 1.72.7 → 1.72.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.72.7",
+  "version": "1.72.9",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -71,7 +71,7 @@
     "@typescript-eslint/parser": "^8.54.0",
     "@umituz/react-native-design-system": "latest",
     "@umituz/react-native-firebase": "latest",
-    "@umituz/react-native-subscription": "latest",
+    "@umituz/react-native-subscription": "^2.35.3",
     "eslint": "^9.39.2",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^7.0.1",

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

@@ -79,7 +79,7 @@ export function useAIFeatureGate(options: AIFeatureGateOptions): AIFeatureGateRe
   );
 
   const requireFeature = useCallback(
-    (action: () => void | Promise<void>): void => {
+    (action: () => void | Promise<void>): boolean => {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[AIFeatureGate] requireFeature called:", {
           isOffline,
@@ -97,26 +97,28 @@ export function useAIFeatureGate(options: AIFeatureGateOptions): AIFeatureGateRe
           console.log("[AIFeatureGate] BLOCKED: User is offline");
         }
         onNetworkError?.();
-        return;
+        return false;
       }
 
       if (isAuthenticated && !isCreditsLoaded) {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.log("[AIFeatureGate] BLOCKED: User authenticated but credits not loaded yet");
         }
-        return;
+        return false;
       }
 
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[AIFeatureGate] Calling requireFeatureFromPackage");
       }
 
-      requireFeatureFromPackage(() => {
+      const executed = requireFeatureFromPackage(() => {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.log("[AIFeatureGate] Inside requireFeatureFromPackage callback - executing action");
         }
         handlePromiseResult(action(), onSuccess, onError);
       });
+
+      return executed;
     },
     [isOffline, isAuthenticated, isCreditsLoaded, isPremium, creditBalance, creditCost, hasCredits, onNetworkError, requireFeatureFromPackage, onSuccess, onError],
   );

package/src/domains/access-control/types/access-control.types.ts

@@ -34,8 +34,9 @@ export interface AIFeatureGateReturn {
   /**
    * Function to execute protected feature
    * Handles all access control checks (auth, premium, credits, paywall)
+   * @returns true if action was executed, false if blocked by gate
    */
-  requireFeature: (action: () => void | Promise<void>) => void;
+  requireFeature: (action: () => void | Promise<void>) => boolean;
 
   /**
    * Whether user can access this feature (all checks passed)

package/src/domains/background/presentation/hooks/use-pending-jobs.ts

@@ -59,7 +59,14 @@ export function usePendingJobs<TInput = unknown, TResult = unknown>(
     onSuccess: (newJob: BackgroundJob<TInput, TResult>) => {
       queryClient.setQueryData<BackgroundJob<TInput, TResult>[]>(
         queryKey,
-        (old: BackgroundJob<TInput, TResult>[] | undefined) => [newJob, ...(old ?? [])],
+        (old: BackgroundJob<TInput, TResult>[] | undefined) => {
+          // Check if job already exists to prevent duplicates
+          const exists = old?.some((job) => job.id === newJob.id);
+          if (exists) {
+            return old ?? [];
+          }
+          return [newJob, ...(old ?? [])];
+        },
       );
     },
   });

package/src/domains/creations/presentation/hooks/useCreations.ts

@@ -38,6 +38,23 @@ export function useCreations({
     }
   }, []);
 
+  const onDataCallback = useCallback((creations: Creation[]) => {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[useCreations] Realtime update:", creations.length);
+    }
+    setData(creations);
+    setIsLoading(false);
+    setError(null);
+  }, []);
+
+  const onErrorCallback = useCallback((err: Error) => {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[useCreations] Realtime listener error:", err);
+    }
+    setError(err);
+    setIsLoading(false);
+  }, []);
+
   useEffect(() => {
     if (!userId || !enabled) {
       setData([]);
@@ -52,24 +69,7 @@ export function useCreations({
     setIsLoading(true);
     setError(null);
 
-    const unsubscribe = repository.subscribeToAll(
-      userId,
-      (creations) => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[useCreations] Realtime update:", creations.length);
-        }
-        setData(creations);
-        setIsLoading(false);
-        setError(null);
-      },
-      (err) => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error("[useCreations] Realtime listener error:", err);
-        }
-        setError(err);
-        setIsLoading(false);
-      },
-    );
+    const unsubscribe = repository.subscribeToAll(userId, onDataCallback, onErrorCallback);
 
     return () => {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -77,7 +77,7 @@ export function useCreations({
       }
       unsubscribe();
     };
-  }, [userId, repository, enabled]);
+  }, [userId, repository, enabled, onDataCallback, onErrorCallback]);
 
   return { data, isLoading, error, refetch };
 }

package/src/domains/creations/presentation/hooks/useProcessingJobsPoller.ts

@@ -60,8 +60,18 @@ export function useProcessingJobsPoller(
   // Use ref for stable function reference to prevent effect re-runs
   const pollJobRef = useRef<((creation: Creation) => Promise<void>) | undefined>(undefined);
 
+  // Use mounted ref to prevent operations after unmount
+  const isMountedRef = useRef(true);
+
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+
   pollJobRef.current = async (creation: Creation) => {
-    if (!userId || !creation.requestId || !creation.model) return;
+    if (!isMountedRef.current || !userId || !creation.requestId || !creation.model) return;
 
     if (pollingRef.current.has(creation.id)) return;
     pollingRef.current.add(creation.id);
@@ -88,6 +98,8 @@ export function useProcessingJobsPoller(
         const urls = extractResultUrl(result);
         if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[ProcessingJobsPoller] Completed:", creation.id, urls);
 
+        if (!isMountedRef.current) return;
+
         const uri = urls.videoUrl || urls.imageUrl || "";
 
         // Validate that we have a valid URI before marking as completed
@@ -110,6 +122,8 @@ export function useProcessingJobsPoller(
       } else if (status.status === QUEUE_STATUS.FAILED) {
         if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[ProcessingJobsPoller] Failed:", creation.id);
 
+        if (!isMountedRef.current) return;
+
         await repository.update(userId, creation.id, {
           status: CREATION_STATUS.FAILED,
           metadata: { error: "Generation failed" },

package/src/domains/generation/wizard/presentation/hooks/useGenerationPhase.ts

@@ -28,6 +28,12 @@ export function useGenerationPhase(options?: UseGenerationPhaseOptions): Generat
 
   const [phase, setPhase] = useState<GenerationPhase>("queued");
   const startTimeRef = useRef<number>(Date.now());
+  const queuedDurationRef = useRef(queuedDuration);
+
+  // Only reset if duration changes significantly
+  useEffect(() => {
+    queuedDurationRef.current = queuedDuration;
+  }, [queuedDuration]);
 
   useEffect(() => {
     startTimeRef.current = Date.now();
@@ -36,14 +42,14 @@ export function useGenerationPhase(options?: UseGenerationPhaseOptions): Generat
     const interval = setInterval(() => {
       const elapsed = Date.now() - startTimeRef.current;
 
-      if (elapsed >= queuedDuration) {
+      if (elapsed >= queuedDurationRef.current) {
         setPhase("processing");
         clearInterval(interval);
       }
     }, 1000);
 
     return () => clearInterval(interval);
-  }, [queuedDuration]);
+  }, []); // Empty deps - only run once on mount
 
   return phase;
 }

package/src/domains/generation/wizard/presentation/hooks/useVideoQueueGeneration.ts

@@ -30,6 +30,13 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
         clearInterval(pollingRef.current);
         pollingRef.current = null;
       }
+      // Reset all refs on unmount
+      isGeneratingRef.current = false;
+      isPollingRef.current = false;
+      creationIdRef.current = null;
+      requestIdRef.current = null;
+      modelRef.current = null;
+      setIsGenerating(false);
     };
   }, []);
 
@@ -45,10 +52,20 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
   const handleComplete = useCallback(
     async (urls: GenerationUrls) => {
       const creationId = creationIdRef.current;
-      if (creationId && userId && (urls.videoUrl || urls.imageUrl)) {
+      const uri = (urls.videoUrl || urls.imageUrl) ?? "";
+
+      // Validate non-empty URI
+      if (!creationId || !userId || !uri || uri.trim() === "") {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error("[VideoQueue] Invalid completion data:", { creationId, userId, uri });
+        }
+        return;
+      }
+
+      if (creationId && userId) {
         try {
           await persistence.updateToCompleted(userId, creationId, {
-            uri: (urls.videoUrl || urls.imageUrl) ?? "",
+            uri,
             imageUrl: urls.imageUrl,
             videoUrl: urls.videoUrl,
           });

package/src/domains/generation/wizard/presentation/hooks/useWizardGeneration.ts

@@ -66,6 +66,15 @@ export const useWizardGeneration = (props: UseWizardGenerationProps): UseWizardG
     onCreditsExhausted,
   });
 
+  // Use refs for functions to avoid effect re-runs
+  const videoStartGenerationRef = useRef(videoGeneration.startGeneration);
+  const photoStartGenerationRef = useRef(photoGeneration.startGeneration);
+
+  useEffect(() => {
+    videoStartGenerationRef.current = videoGeneration.startGeneration;
+    photoStartGenerationRef.current = photoGeneration.startGeneration;
+  }, [videoGeneration.startGeneration, photoGeneration.startGeneration]);
+
   useEffect(() => {
     const isAlreadyGenerating = videoGeneration.isGenerating || photoGeneration.isGenerating;
 
@@ -80,8 +89,8 @@ export const useWizardGeneration = (props: UseWizardGenerationProps): UseWizardG
         isMountedRef,
         dispatch,
         onError,
-        videoGenerationFn: videoGeneration.startGeneration,
-        photoGenerationFn: photoGeneration.startGeneration,
+        videoGenerationFn: videoStartGenerationRef.current,
+        photoGenerationFn: photoStartGenerationRef.current,
       }).catch((error) => {
         // Catch any unhandled errors from executeWizardGeneration
         if (isMountedRef.current) {
@@ -102,9 +111,7 @@ export const useWizardGeneration = (props: UseWizardGenerationProps): UseWizardG
     wizardData,
     isVideoMode,
     videoGeneration.isGenerating,
-    videoGeneration.startGeneration,
     photoGeneration.isGenerating,
-    photoGeneration.startGeneration,
     onError,
   ]);
 

package/src/domains/generation/wizard/presentation/hooks/videoQueuePoller.ts

@@ -16,8 +16,12 @@ interface PollParams {
 export const pollQueueStatus = async (params: PollParams): Promise<void> => {
   const { requestId, model, isPollingRef, pollingRef, onComplete, onError } = params;
 
-  // Atomic check-and-set to prevent race condition
-  if (isPollingRef.current) return;
+  // Check-and-set - while not truly atomic in JS, this is best we can do
+  // The ref prevents most race conditions in practice
+  if (isPollingRef.current) {
+    if (__DEV__) console.log("[VideoQueuePoller] Already polling, skipping");
+    return;
+  }
   isPollingRef.current = true;
 
   const provider = providerRegistry.getActiveProvider();