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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.37.13",
+  "version": "1.37.15",
   "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

@@ -1,9 +1,8 @@
 /**
  * Image Generation Strategy
- * Handles image-specific generation logic
+ * Handles image-specific generation logic (execution only)
  */
 
-import { createCreationsRepository } from "../../../../creations/infrastructure/adapters";
 import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
 import type { WizardStrategy } from "./wizard-strategy.types";
 import { DEFAULT_STYLE_VALUE, IMAGE_PROCESSING_PROMPTS } from "./wizard-strategy.constants";
@@ -81,10 +80,7 @@ function applyStyleEnhancements(prompt: string, wizardData: Record<string, unkno
 // ============================================================================
 
 export function createImageStrategy(options: CreateImageStrategyOptions): WizardStrategy {
-  const { scenario, collectionName = "creations" } = options;
-  const repository = createCreationsRepository(collectionName);
-
-  let lastInputRef: WizardImageInput | null = null;
+  const { scenario } = options;
 
   return {
     execute: async (input: unknown) => {
@@ -93,8 +89,6 @@ export function createImageStrategy(options: CreateImageStrategyOptions): Wizard
         throw new Error("Model is required for image generation");
       }
 
-      lastInputRef = imageInput;
-
       const result = await executeImageGeneration(imageInput, scenario.model);
 
       if (!result.success || !result.imageUrl) {
@@ -105,29 +99,5 @@ 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;
-
-      const creation = {
-        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 },
-      };
-
-      await repository.create(uid, creation);
-    },
   };
 }

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

@@ -1,10 +1,9 @@
 /**
  * Video Generation Strategy
- * Handles video-specific generation logic
+ * Handles video-specific generation logic (execution only)
  */
 
 import { executeVideoFeature } from "../../../../../infrastructure/services/video-feature-executor.service";
-import { createCreationsRepository } from "../../../../creations/infrastructure/adapters";
 import { buildUnifiedPrompt } from "./shared/unified-prompt-builder";
 import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
 import type { WizardStrategy } from "./wizard-strategy.types";
@@ -71,16 +70,12 @@ export async function buildVideoInput(
 }
 
 export function createVideoStrategy(options: CreateVideoStrategyOptions): WizardStrategy {
-  const { scenario, collectionName = "creations" } = options;
-  const repository = createCreationsRepository(collectionName);
+  const { scenario } = options;
   const videoFeatureType = getVideoFeatureType(scenario.id);
 
-  let lastInputRef: WizardVideoInput | null = null;
-
   return {
     execute: async (input: unknown) => {
       const videoInput = input as WizardVideoInput;
-      lastInputRef = videoInput;
 
       const result = await executeVideoFeature(videoFeatureType, {
         sourceImageBase64: videoInput.sourceImageBase64,
@@ -101,24 +96,5 @@ 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;
-
-      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

@@ -4,7 +4,8 @@
  */
 
 export interface WizardStrategy {
+  /** Execute the generation - returns result with URLs */
   execute: (input: unknown) => Promise<{ imageUrl?: string; videoUrl?: string }>;
+  /** Get credit cost for this generation */
   getCreditCost: () => number;
-  save?: (result: unknown, userId: string) => Promise<void>;
 }

package/src/domains/generation/wizard/infrastructure/utils/creation-persistence.util.ts

@@ -0,0 +1,109 @@
+/**
+ * Creation Persistence Utility
+ * Handles all Firestore creation operations for wizard generation
+ * Single source of truth for processing → completed flow
+ */
+
+import { createCreationsRepository } from "../../../../creations/infrastructure/adapters";
+
+declare const __DEV__: boolean;
+
+export interface CreationPersistenceConfig {
+  readonly collectionName?: string;
+}
+
+export interface ProcessingCreationData {
+  readonly scenarioId: string;
+  readonly scenarioTitle: string;
+  readonly prompt: string;
+}
+
+export interface CompletedCreationData {
+  readonly uri: string;
+  readonly imageUrl?: string;
+  readonly videoUrl?: string;
+}
+
+/**
+ * Creates a creation persistence handler for a wizard flow
+ */
+export function createCreationPersistence(config: CreationPersistenceConfig = {}) {
+  const { collectionName = "creations" } = config;
+  const repository = createCreationsRepository(collectionName);
+
+  return {
+    /**
+     * Save creation with status="processing" when generation starts
+     * Returns the creation ID for later update
+     */
+    saveAsProcessing: async (
+      userId: string,
+      data: ProcessingCreationData,
+    ): Promise<string> => {
+      const creationId = `${data.scenarioId}_${Date.now()}`;
+
+      await repository.create(userId, {
+        id: creationId,
+        uri: "",
+        type: data.scenarioId,
+        prompt: data.prompt,
+        status: "processing" as const,
+        createdAt: new Date(),
+        isShared: false,
+        isFavorite: false,
+        metadata: {
+          scenarioId: data.scenarioId,
+          scenarioTitle: data.scenarioTitle,
+        },
+      });
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[CreationPersistence] Saved as processing", { creationId });
+      }
+
+      return creationId;
+    },
+
+    /**
+     * Update creation to status="completed" when generation finishes
+     */
+    updateToCompleted: async (
+      userId: string,
+      creationId: string,
+      data: CompletedCreationData,
+    ): Promise<void> => {
+      await repository.update(userId, creationId, {
+        uri: data.uri,
+        status: "completed" as const,
+        output: {
+          imageUrl: data.imageUrl,
+          videoUrl: data.videoUrl,
+        },
+      });
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[CreationPersistence] Updated to completed", { creationId });
+      }
+    },
+
+    /**
+     * Update creation to status="failed" when generation fails
+     */
+    updateToFailed: async (
+      userId: string,
+      creationId: string,
+      error: string,
+    ): Promise<void> => {
+      await repository.update(userId, creationId, {
+        status: "failed" as const,
+        metadata: { error },
+      });
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[CreationPersistence] Updated to failed", { creationId, error });
+      }
+    },
+  };
+}
+
+export type CreationPersistence = ReturnType<typeof createCreationPersistence>;

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

@@ -1,13 +1,15 @@
 /**
  * useWizardGeneration Hook
- * Wizard generation using orchestrator + strategy factory pattern
- * Includes background job tracking for CreationsGallery display
+ * Wizard generation with Firestore persistence
+ * - Saves status="processing" at start
+ * - Updates to status="completed" on success
+ * - Updates to status="failed" on error
  */
 
 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 { createCreationPersistence } from "../../infrastructure/utils/creation-persistence.util";
 import type {
   UseWizardGenerationProps,
   UseWizardGenerationReturn,
@@ -34,63 +36,65 @@ export const useWizardGeneration = (
     onSuccess,
     onError,
     onCreditsExhausted,
-    trackAsBackgroundJob = true,
   } = props;
 
   const hasStarted = useRef(false);
-  const currentJobIdRef = useRef<string | null>(null);
+  const creationIdRef = useRef<string | null>(null);
+  const inputRef = useRef<{ prompt: string } | null>(null);
 
-  const { addJob, updateJob, removeJob } = usePendingJobs();
+  // Persistence utility - separate from strategy
+  const persistence = useMemo(() => createCreationPersistence(), []);
 
-  useEffect(() => {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[useWizardGeneration] Initialized", {
-        scenarioId: scenario.id,
-        outputType: scenario.outputType,
-        trackAsBackgroundJob,
-      });
-    }
-  }, [scenario.id, scenario.outputType, trackAsBackgroundJob]);
-
-  const strategy = useMemo(() => {
-    return createWizardStrategy({
-      scenario,
-      collectionName: "creations",
-    });
-  }, [scenario]);
+  // Strategy - only handles execution
+  const strategy = useMemo(() => createWizardStrategy({ scenario }), [scenario]);
 
   const handleSuccess = useCallback(
-    (result: unknown) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[useWizardGeneration] Success");
-      }
-
-      if (trackAsBackgroundJob && currentJobIdRef.current) {
-        removeJob(currentJobIdRef.current);
-        currentJobIdRef.current = null;
+    async (result: unknown) => {
+      const typedResult = result as { imageUrl?: string; videoUrl?: string };
+      const creationId = creationIdRef.current;
+
+      // Update to completed in Firestore
+      if (creationId && userId) {
+        try {
+          await persistence.updateToCompleted(userId, creationId, {
+            uri: typedResult.imageUrl || typedResult.videoUrl || "",
+            imageUrl: typedResult.imageUrl,
+            videoUrl: typedResult.videoUrl,
+          });
+        } catch (err) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[useWizardGeneration] updateToCompleted error:", err);
+          }
+        }
       }
 
+      creationIdRef.current = null;
+      inputRef.current = null;
       onSuccess?.(result);
     },
-    [trackAsBackgroundJob, removeJob, onSuccess],
+    [userId, persistence, onSuccess],
   );
 
   const handleError = useCallback(
-    (err: { message: string }) => {
-      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 },
-        });
+    async (err: { message: string }) => {
+      const creationId = creationIdRef.current;
+
+      // Update to failed in Firestore
+      if (creationId && userId) {
+        try {
+          await persistence.updateToFailed(userId, creationId, err.message);
+        } catch (updateErr) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[useWizardGeneration] updateToFailed error:", updateErr);
+          }
+        }
       }
 
+      creationIdRef.current = null;
+      inputRef.current = null;
       onError?.(err.message);
     },
-    [trackAsBackgroundJob, updateJob, onError],
+    [userId, persistence, onError],
   );
 
   const { generate, isGenerating } = useGenerationOrchestrator(strategy, {
@@ -103,50 +107,42 @@ export const useWizardGeneration = (
 
   useEffect(() => {
     if (isGeneratingStep && !hasStarted.current && !isGenerating) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[useWizardGeneration] Starting generation", {
-          scenarioId: scenario.id,
-          wizardDataKeys: Object.keys(wizardData),
-        });
-      }
-
       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;
+          inputRef.current = input as { prompt: string };
 
-            addJob({
-              id: jobId,
-              input: {
+          // Save to Firestore with status="processing"
+          const typedInput = input as { prompt?: string };
+          if (userId && typedInput.prompt) {
+            try {
+              const creationId = await persistence.saveAsProcessing(userId, {
                 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);
+                scenarioTitle: scenario.title || scenario.id,
+                prompt: typedInput.prompt,
+              });
+              creationIdRef.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);
+              }
             }
           }
 
           generate(input);
         })
         .catch((error) => {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error("[useWizardGeneration] Input build error:", error);
-          }
           hasStarted.current = false;
           onError?.(error.message);
         });
@@ -155,16 +151,7 @@ export const useWizardGeneration = (
     if (!isGeneratingStep && hasStarted.current) {
       hasStarted.current = false;
     }
-  }, [
-    isGeneratingStep,
-    scenario,
-    wizardData,
-    isGenerating,
-    generate,
-    onError,
-    trackAsBackgroundJob,
-    addJob,
-  ]);
+  }, [isGeneratingStep, scenario, wizardData, isGenerating, generate, onError, userId, persistence]);
 
   return { isGenerating };
 };