@umituz/react-native-ai-generation-content 1.65.6 → 1.65.7

package/package.json

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

package/src/domains/background/infrastructure/executors/backgroundJobExecutor.ts

@@ -43,7 +43,8 @@ interface QueuedExecutionParams<TInput, TResult> {
   input: TInput;
   executor: JobExecutorConfig<TInput, TResult>;
   updateJob: (params: { id: string; updates: Partial<BackgroundJob<TInput, TResult>> }) => void;
-  removeJob: (id: string) => void;
+  updateJobAsync: (params: { id: string; updates: Partial<BackgroundJob<TInput, TResult>> }) => Promise<{ id: string; updates: Partial<BackgroundJob<TInput, TResult>> }>;
+  removeJobAsync: (id: string) => Promise<string>;
   getJob: (id: string) => BackgroundJob<TInput, TResult> | undefined;
   activeJobsRef: React.MutableRefObject<Set<string>>;
   onJobComplete?: (job: BackgroundJob<TInput, TResult>) => void;
@@ -59,7 +60,8 @@ export const executeQueuedJob = async <TInput, TResult>(
     input,
     executor,
     updateJob,
-    removeJob,
+    updateJobAsync,
+    removeJobAsync,
     getJob,
     activeJobsRef,
     onJobComplete,
@@ -68,13 +70,17 @@ export const executeQueuedJob = async <TInput, TResult>(
   } = params;
 
   try {
-    updateJob({ id: jobId, updates: { status: "processing", progress: 10 } });
+    // Critical status update - await to ensure state consistency
+    await updateJobAsync({ id: jobId, updates: { status: "processing", progress: 10 } });
 
     const result = await executor.execute(input, (p) => {
+      // Progress updates use non-async version for performance
+      // Progress updates are frequent and eventual consistency is acceptable
       updateJob({ id: jobId, updates: { progress: p } });
     });
 
-    updateJob({
+    // Critical status update - await to ensure state consistency
+    await updateJobAsync({
       id: jobId,
       updates: { status: "completed", progress: 100, result, completedAt: new Date() },
     });
@@ -85,11 +91,13 @@ export const executeQueuedJob = async <TInput, TResult>(
       onJobComplete?.(completedJob);
     }
 
-    removeJob(jobId);
+    // Await removal to ensure cleanup happens before checking activeJobs
+    await removeJobAsync(jobId);
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : String(error);
 
-    updateJob({ id: jobId, updates: { status: "failed", error: errorMsg, progress: 0 } });
+    // Critical error status update - await for consistency
+    await updateJobAsync({ id: jobId, updates: { status: "failed", error: errorMsg, progress: 0 } });
 
     const failedJob = getJob(jobId);
     if (failedJob) {
@@ -97,7 +105,10 @@ export const executeQueuedJob = async <TInput, TResult>(
       onJobError?.(failedJob);
     }
   } finally {
+    // Use atomic Set operation to prevent race conditions
     activeJobsRef.current.delete(jobId);
+
+    // Check size after deletion to prevent multiple onAllComplete calls
     if (activeJobsRef.current.size === 0) {
       onAllComplete?.();
     }

package/src/domains/background/presentation/hooks/use-background-generation.ts

@@ -21,7 +21,7 @@ export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
   const [isProcessing, setIsProcessing] = useState(false);
   const [progress, setProgress] = useState(0);
 
-  const { jobs, addJobAsync, updateJob, removeJob, getJob } = usePendingJobs<
+  const { jobs, addJobAsync, updateJob, updateJobAsync, removeJob, removeJobAsync, getJob } = usePendingJobs<
     TInput,
     TResult
   >({
@@ -43,14 +43,15 @@ export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
         input,
         executor,
         updateJob,
-        removeJob,
+        updateJobAsync,
+        removeJobAsync,
         getJob,
         activeJobsRef,
         onJobComplete,
         onJobError,
         onAllComplete,
       }),
-    [executor, onJobComplete, onJobError, onAllComplete, updateJob, removeJob, getJob],
+    [executor, onJobComplete, onJobError, onAllComplete, updateJob, updateJobAsync, removeJobAsync, getJob],
   );
 
   const startJob = useCallback(

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

@@ -22,7 +22,9 @@ export interface UsePendingJobsReturn<TInput = unknown, TResult = unknown> {
   readonly addJob: (input: AddJobInput<TInput>) => void;
   readonly addJobAsync: (input: AddJobInput<TInput>) => Promise<BackgroundJob<TInput, TResult>>;
   readonly updateJob: (input: UpdateJobInput) => void;
+  readonly updateJobAsync: (input: UpdateJobInput) => Promise<{ id: string; updates: Partial<BackgroundJob<TInput, TResult>> }>;
   readonly removeJob: (id: string) => void;
+  readonly removeJobAsync: (id: string) => Promise<string>;
   readonly clearCompleted: () => void;
   readonly clearFailed: () => void;
   readonly getJob: (id: string) => BackgroundJob<TInput, TResult> | undefined;
@@ -116,7 +118,9 @@ export function usePendingJobs<TInput = unknown, TResult = unknown>(
     addJob: addJobMutation.mutate,
     addJobAsync: addJobMutation.mutateAsync,
     updateJob: updateJobMutation.mutate,
+    updateJobAsync: updateJobMutation.mutateAsync,
     removeJob: removeJobMutation.mutate,
+    removeJobAsync: removeJobMutation.mutateAsync,
     clearCompleted: clearCompletedMutation.mutate,
     clearFailed: clearFailedMutation.mutate,
     getJob,

package/src/domains/creations/infrastructure/repositories/CreationsFetcher.ts

@@ -95,8 +95,20 @@ export class CreationsFetcher {
     ): UnsubscribeFunction {
         const userCollection = this.pathResolver.getUserCollection(userId);
         if (!userCollection) {
+            const error = new Error(`[CreationsFetcher] Cannot subscribe: Invalid user collection for userId: ${userId}`);
+            if (__DEV__) {
+                console.error(error.message);
+            }
+            // Return empty array immediately
             onData([]);
-            return () => {};
+            // Report error to callback
+            onError?.(error);
+            // Return no-op unsubscribe function (no listener was created)
+            return () => {
+                if (__DEV__) {
+                    console.log("[CreationsFetcher] No-op unsubscribe called (no listener was created)");
+                }
+            };
         }
 
         // Optimized query with server-side filtering

package/src/domains/generation/infrastructure/flow/useFlow.ts

@@ -25,12 +25,9 @@ interface UseFlowReturn extends FlowState, FlowActions {
   getPartnerName: (partnerId: string) => string;
 }
 
-let flowStoreInstance: FlowStoreType | null = null;
-
 export const useFlow = (config: UseFlowConfig): UseFlowReturn => {
   const storeRef = useRef<FlowStoreType | null>(null);
   const prevConfigRef = useRef<{ initialStepIndex?: number; initialStepId?: string; stepsCount: number } | undefined>(undefined);
-  const isResettingRef = useRef(false);
 
   // Detect config changes (initialStepIndex, initialStepId, or steps changed)
   const configChanged =
@@ -39,27 +36,19 @@ export const useFlow = (config: UseFlowConfig): UseFlowReturn => {
       prevConfigRef.current.initialStepId !== config.initialStepId ||
       prevConfigRef.current.stepsCount !== config.steps.length);
 
-  // If config changed, reset and recreate store (with guard against multiple resets)
-  if (configChanged && !isResettingRef.current) {
-    isResettingRef.current = true;
-    if (flowStoreInstance) {
-      flowStoreInstance.getState().reset();
-    }
-    flowStoreInstance = null;
+  // If config changed, reset and recreate store (per-component instance)
+  if (configChanged && storeRef.current) {
+    storeRef.current.getState().reset();
     storeRef.current = null;
-    isResettingRef.current = false;
   }
 
-  // Initialize store if needed
-  if (!storeRef.current && !isResettingRef.current) {
-    if (!flowStoreInstance) {
-      flowStoreInstance = createFlowStore({
-        steps: config.steps,
-        initialStepId: config.initialStepId,
-        initialStepIndex: config.initialStepIndex,
-      });
-    }
-    storeRef.current = flowStoreInstance;
+  // Initialize store if needed (per-component instance)
+  if (!storeRef.current) {
+    storeRef.current = createFlowStore({
+      steps: config.steps,
+      initialStepId: config.initialStepId,
+      initialStepIndex: config.initialStepIndex,
+    });
   }
 
   // Store current config for next render comparison
@@ -115,9 +104,8 @@ export const useFlow = (config: UseFlowConfig): UseFlowReturn => {
   };
 };
 
+// Note: resetFlowStore is no longer needed as each component instance maintains its own store
+// If you need to reset flow state, use the reset() action from the useFlow hook
 export const resetFlowStore = () => {
-  if (flowStoreInstance) {
-    flowStoreInstance.getState().reset();
-  }
-  flowStoreInstance = null;
+  console.warn('resetFlowStore is deprecated. Each component now maintains its own flow store instance.');
 };

package/src/index.ts

@@ -7,3 +7,6 @@ export * from "./exports/domain";
 export * from "./exports/infrastructure";
 export * from "./exports/presentation";
 export * from "./exports/features";
+
+// Creations Domain
+export * from "./domains/creations";

package/src/presentation/hooks/use-generation.ts

@@ -37,27 +37,40 @@ export function useGeneration<T = unknown>(
   const [isGenerating, setIsGenerating] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
+  const abortControllerRef = useRef<AbortController | null>(null);
   const abortRef = useRef(false);
 
   // Abort on unmount to prevent state updates after unmount
   useEffect(() => {
     return () => {
       abortRef.current = true;
+      abortControllerRef.current?.abort();
     };
   }, []);
 
-  const handleProgress = useCallback(
-    (prog: GenerationProgress) => {
-      if (abortRef.current) return;
-      setProgress(prog);
-      options.onProgress?.(prog);
-    },
-    [options],
-  );
+  // Stabilize callbacks to prevent unnecessary re-renders
+  const onSuccessRef = useRef(options.onSuccess);
+  const onErrorRef = useRef(options.onError);
+  const onProgressRef = useRef(options.onProgress);
+
+  useEffect(() => {
+    onSuccessRef.current = options.onSuccess;
+    onErrorRef.current = options.onError;
+    onProgressRef.current = options.onProgress;
+  }, [options.onSuccess, options.onError, options.onProgress]);
+
+  const handleProgress = useCallback((prog: GenerationProgress) => {
+    if (abortRef.current) return;
+    setProgress(prog);
+    onProgressRef.current?.(prog);
+  }, []);
 
   const generate = useCallback(
     async (input: Record<string, unknown>, userId?: string) => {
+      // Create new AbortController for this generation
+      abortControllerRef.current = new AbortController();
       abortRef.current = false;
+
       setIsGenerating(true);
       setError(null);
       setResult(null);
@@ -70,38 +83,42 @@ export function useGeneration<T = unknown>(
           userId,
           capability: options.capability,
           onProgress: handleProgress,
+          signal: abortControllerRef.current.signal,
         };
 
         const genResult = await generationOrchestrator.generate<T>(request);
 
-        if (abortRef.current) return;
+        if (abortRef.current || abortControllerRef.current.signal.aborted) return;
 
         setResult(genResult);
 
         if (genResult.success) {
-          options.onSuccess?.(genResult);
+          onSuccessRef.current?.(genResult);
         } else if (genResult.error) {
           setError(genResult.error);
-          options.onError?.(genResult.error);
+          onErrorRef.current?.(genResult.error);
         }
       } catch (err) {
-        if (abortRef.current) return;
+        if (abortRef.current || abortControllerRef.current?.signal.aborted) return;
 
         const errorMessage =
           err instanceof Error ? err.message : "error.unknown";
         setError(errorMessage);
-        options.onError?.(errorMessage);
+        onErrorRef.current?.(errorMessage);
       } finally {
-        if (!abortRef.current) {
+        if (!abortRef.current && !abortControllerRef.current?.signal.aborted) {
           setIsGenerating(false);
         }
+        abortControllerRef.current = null;
       }
     },
-    [options, handleProgress],
+    [options.model, options.capability, handleProgress],
   );
 
   const reset = useCallback(() => {
     abortRef.current = true;
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = null;
     setResult(null);
     setProgress(null);
     setIsGenerating(false);