@umituz/react-native-ai-generation-content 1.37.13 → 1.37.14

package/package.json

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

package/src/domains/generation/wizard/infrastructure/strategies/image-generation.strategy.ts

@@ -80,11 +80,14 @@ function applyStyleEnhancements(prompt: string, wizardData: Record<string, unkno
 // Strategy Factory
 // ============================================================================
 
+declare const __DEV__: boolean;
+
 export function createImageStrategy(options: CreateImageStrategyOptions): WizardStrategy {
   const { scenario, collectionName = "creations" } = options;
   const repository = createCreationsRepository(collectionName);
 
   let lastInputRef: WizardImageInput | null = null;
+  let processingCreationId: string | null = null;
 
   return {
     execute: async (input: unknown) => {
@@ -106,28 +109,63 @@ export function createImageStrategy(options: CreateImageStrategyOptions): Wizard
 
     getCreditCost: () => 1,
 
-    save: async (result: unknown, uid) => {
-      const input = lastInputRef;
-      const imageResult = result as { imageUrl?: string };
-      if (!input || !scenario?.id || !imageResult.imageUrl) return;
+    saveAsProcessing: async (uid: string, input: unknown) => {
+      const imageInput = input as WizardImageInput;
+      const creationId = `${scenario.id}_${Date.now()}`;
+      processingCreationId = creationId;
 
-      const creation = {
-        id: `${scenario.id}_${Date.now()}`,
-        uri: imageResult.imageUrl,
+      await repository.create(uid, {
+        id: creationId,
+        uri: "",
         type: scenario.id,
-        prompt: input.prompt,
-        status: "completed" as const,
+        prompt: imageInput.prompt,
+        status: "processing" as const,
         createdAt: new Date(),
         isShared: false,
         isFavorite: false,
-        metadata: {
-          scenarioId: scenario.id,
-          scenarioTitle: scenario.title,
-        },
-        output: { imageUrl: imageResult.imageUrl },
-      };
-
-      await repository.create(uid, creation);
+        metadata: { scenarioId: scenario.id, scenarioTitle: scenario.title },
+      });
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[ImageStrategy] Saved as processing", { creationId });
+      }
+
+      return creationId;
+    },
+
+    save: async (result: unknown, uid: string, creationId?: string) => {
+      const input = lastInputRef;
+      const imageResult = result as { imageUrl?: string };
+      if (!input || !scenario?.id || !imageResult.imageUrl) return;
+
+      const idToUpdate = creationId || processingCreationId;
+
+      if (idToUpdate) {
+        // Update existing processing creation to completed
+        await repository.update(uid, idToUpdate, {
+          uri: imageResult.imageUrl,
+          status: "completed" as const,
+          output: { imageUrl: imageResult.imageUrl },
+        });
+
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[ImageStrategy] Updated to completed", { creationId: idToUpdate });
+        }
+      } else {
+        // Fallback: create new (shouldn't happen normally)
+        await repository.create(uid, {
+          id: `${scenario.id}_${Date.now()}`,
+          uri: imageResult.imageUrl,
+          type: scenario.id,
+          prompt: input.prompt,
+          status: "completed" as const,
+          createdAt: new Date(),
+          isShared: false,
+          isFavorite: false,
+          metadata: { scenarioId: scenario.id, scenarioTitle: scenario.title },
+          output: { imageUrl: imageResult.imageUrl },
+        });
+      }
     },
   };
 }

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.strategy.ts

@@ -76,6 +76,7 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
   const videoFeatureType = getVideoFeatureType(scenario.id);
 
   let lastInputRef: WizardVideoInput | null = null;
+  let processingCreationId: string | null = null;
 
   return {
     execute: async (input: unknown) => {
@@ -102,23 +103,63 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
 
     getCreditCost: () => 1,
 
-    save: async (result: unknown, uid) => {
-      const input = lastInputRef;
-      const videoResult = result as { videoUrl?: string };
-      if (!input || !scenario?.id || !videoResult.videoUrl) return;
+    saveAsProcessing: async (uid: string, input: unknown) => {
+      const videoInput = input as WizardVideoInput;
+      const creationId = `${scenario.id}_${Date.now()}`;
+      processingCreationId = creationId;
 
       await repository.create(uid, {
-        id: `${scenario.id}_${Date.now()}`,
-        uri: videoResult.videoUrl,
+        id: creationId,
+        uri: "",
         type: scenario.id,
-        prompt: input.prompt,
-        status: "completed" as const,
+        prompt: videoInput.prompt,
+        status: "processing" as const,
         createdAt: new Date(),
         isShared: false,
         isFavorite: false,
         metadata: { scenarioId: scenario.id, scenarioTitle: scenario.title },
-        output: { videoUrl: videoResult.videoUrl },
       });
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[VideoStrategy] Saved as processing", { creationId });
+      }
+
+      return creationId;
+    },
+
+    save: async (result: unknown, uid: string, creationId?: string) => {
+      const input = lastInputRef;
+      const videoResult = result as { videoUrl?: string };
+      if (!input || !scenario?.id || !videoResult.videoUrl) return;
+
+      const idToUpdate = creationId || processingCreationId;
+
+      if (idToUpdate) {
+        // Update existing processing creation to completed
+        await repository.update(uid, idToUpdate, {
+          uri: videoResult.videoUrl,
+          status: "completed" as const,
+          output: { videoUrl: videoResult.videoUrl },
+        });
+
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[VideoStrategy] Updated to completed", { creationId: idToUpdate });
+        }
+      } else {
+        // Fallback: create new (shouldn't happen normally)
+        await repository.create(uid, {
+          id: `${scenario.id}_${Date.now()}`,
+          uri: videoResult.videoUrl,
+          type: scenario.id,
+          prompt: input.prompt,
+          status: "completed" as const,
+          createdAt: new Date(),
+          isShared: false,
+          isFavorite: false,
+          metadata: { scenarioId: scenario.id, scenarioTitle: scenario.title },
+          output: { videoUrl: videoResult.videoUrl },
+        });
+      }
     },
   };
 }

package/src/domains/generation/wizard/infrastructure/strategies/wizard-strategy.types.ts

@@ -6,5 +6,8 @@
 export interface WizardStrategy {
   execute: (input: unknown) => Promise<{ imageUrl?: string; videoUrl?: string }>;
   getCreditCost: () => number;
-  save?: (result: unknown, userId: string) => Promise<void>;
+  /** Save as processing when generation starts - returns creation ID */
+  saveAsProcessing?: (userId: string, input: unknown) => Promise<string>;
+  /** Update to completed when generation finishes */
+  save?: (result: unknown, userId: string, creationId?: string) => Promise<void>;
 }

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

@@ -1,12 +1,11 @@
 /**
  * useWizardGeneration Hook
  * Wizard generation using orchestrator + strategy factory pattern
- * Includes background job tracking for CreationsGallery display
+ * Saves to Firestore with status="processing" at start for gallery display
  */
 
 import { useEffect, useRef, useMemo, useCallback } from "react";
 import { useGenerationOrchestrator } from "../../../../../presentation/hooks/generation";
-import { usePendingJobs } from "../../../../../presentation/hooks/use-pending-jobs";
 import { createWizardStrategy, buildWizardInput } from "../../infrastructure/strategies";
 import type {
   UseWizardGenerationProps,
@@ -34,23 +33,19 @@ export const useWizardGeneration = (
     onSuccess,
     onError,
     onCreditsExhausted,
-    trackAsBackgroundJob = true,
   } = props;
 
   const hasStarted = useRef(false);
-  const currentJobIdRef = useRef<string | null>(null);
-
-  const { addJob, updateJob, removeJob } = usePendingJobs();
+  const currentCreationIdRef = useRef<string | null>(null);
 
   useEffect(() => {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       console.log("[useWizardGeneration] Initialized", {
         scenarioId: scenario.id,
         outputType: scenario.outputType,
-        trackAsBackgroundJob,
       });
     }
-  }, [scenario.id, scenario.outputType, trackAsBackgroundJob]);
+  }, [scenario.id, scenario.outputType]);
 
   const strategy = useMemo(() => {
     return createWizardStrategy({
@@ -62,17 +57,14 @@ export const useWizardGeneration = (
   const handleSuccess = useCallback(
     (result: unknown) => {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[useWizardGeneration] Success");
-      }
-
-      if (trackAsBackgroundJob && currentJobIdRef.current) {
-        removeJob(currentJobIdRef.current);
-        currentJobIdRef.current = null;
+        console.log("[useWizardGeneration] Success", {
+          creationId: currentCreationIdRef.current,
+        });
       }
-
+      currentCreationIdRef.current = null;
       onSuccess?.(result);
     },
-    [trackAsBackgroundJob, removeJob, onSuccess],
+    [onSuccess],
   );
 
   const handleError = useCallback(
@@ -80,17 +72,11 @@ export const useWizardGeneration = (
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[useWizardGeneration] Error:", err.message);
       }
-
-      if (trackAsBackgroundJob && currentJobIdRef.current) {
-        updateJob({
-          id: currentJobIdRef.current,
-          updates: { status: "failed", error: err.message, progress: 0 },
-        });
-      }
-
+      // Note: Failed status update is handled by orchestrator via strategy
+      currentCreationIdRef.current = null;
       onError?.(err.message);
     },
-    [trackAsBackgroundJob, updateJob, onError],
+    [onError],
   );
 
   const { generate, isGenerating } = useGenerationOrchestrator(strategy, {
@@ -113,31 +99,27 @@ export const useWizardGeneration = (
       hasStarted.current = true;
 
       buildWizardInput(wizardData, scenario)
-        .then((input) => {
+        .then(async (input) => {
           if (!input) {
             hasStarted.current = false;
             onError?.("Failed to build generation input");
             return;
           }
 
-          if (trackAsBackgroundJob && scenario.outputType) {
-            const jobId = `wizard-${scenario.id}-${Date.now()}`;
-            currentJobIdRef.current = jobId;
-
-            addJob({
-              id: jobId,
-              input: {
-                scenarioId: scenario.id,
-                scenarioTitle: scenario.title,
-                outputType: scenario.outputType,
-              },
-              type: scenario.outputType,
-              status: "processing",
-              progress: 10,
-            });
-
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-              console.log("[useWizardGeneration] Created background job:", jobId);
+          // Save to Firestore with status="processing" BEFORE starting generation
+          if (strategy.saveAsProcessing && userId) {
+            try {
+              const creationId = await strategy.saveAsProcessing(userId, input);
+              currentCreationIdRef.current = creationId;
+
+              if (typeof __DEV__ !== "undefined" && __DEV__) {
+                console.log("[useWizardGeneration] Saved as processing:", creationId);
+              }
+            } catch (err) {
+              if (typeof __DEV__ !== "undefined" && __DEV__) {
+                console.error("[useWizardGeneration] saveAsProcessing error:", err);
+              }
+              // Continue with generation even if save fails
             }
           }
 
@@ -162,8 +144,8 @@ export const useWizardGeneration = (
     isGenerating,
     generate,
     onError,
-    trackAsBackgroundJob,
-    addJob,
+    strategy,
+    userId,
   ]);
 
   return { isGenerating };