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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.37.14",
+  "version": "1.37.16",
   "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";
@@ -80,14 +79,8 @@ 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;
+  const { scenario } = options;
 
   return {
     execute: async (input: unknown) => {
@@ -96,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) {
@@ -108,64 +99,5 @@ export function createImageStrategy(options: CreateImageStrategyOptions): Wizard
     },
 
     getCreditCost: () => 1,
-
-    saveAsProcessing: async (uid: string, input: unknown) => {
-      const imageInput = input as WizardImageInput;
-      const creationId = `${scenario.id}_${Date.now()}`;
-      processingCreationId = creationId;
-
-      await repository.create(uid, {
-        id: creationId,
-        uri: "",
-        type: scenario.id,
-        prompt: imageInput.prompt,
-        status: "processing" as const,
-        createdAt: new Date(),
-        isShared: false,
-        isFavorite: false,
-        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

@@ -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,17 +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;
-  let processingCreationId: string | null = null;
-
   return {
     execute: async (input: unknown) => {
       const videoInput = input as WizardVideoInput;
-      lastInputRef = videoInput;
 
       const result = await executeVideoFeature(videoFeatureType, {
         sourceImageBase64: videoInput.sourceImageBase64,
@@ -102,64 +96,5 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
     },
 
     getCreditCost: () => 1,
-
-    saveAsProcessing: async (uid: string, input: unknown) => {
-      const videoInput = input as WizardVideoInput;
-      const creationId = `${scenario.id}_${Date.now()}`;
-      processingCreationId = creationId;
-
-      await repository.create(uid, {
-        id: creationId,
-        uri: "",
-        type: scenario.id,
-        prompt: videoInput.prompt,
-        status: "processing" as const,
-        createdAt: new Date(),
-        isShared: false,
-        isFavorite: false,
-        metadata: { scenarioId: scenario.id, scenarioTitle: scenario.title },
-      });
-
-      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

@@ -4,10 +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 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/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,12 +1,15 @@
 /**
  * useWizardGeneration Hook
- * Wizard generation using orchestrator + strategy factory pattern
- * Saves to Firestore with status="processing" at start for gallery 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 { createWizardStrategy, buildWizardInput } from "../../infrastructure/strategies";
+import { createCreationPersistence } from "../../infrastructure/utils/creation-persistence.util";
 import type {
   UseWizardGenerationProps,
   UseWizardGenerationReturn,
@@ -36,47 +39,62 @@ export const useWizardGeneration = (
   } = props;
 
   const hasStarted = useRef(false);
-  const currentCreationIdRef = useRef<string | null>(null);
+  const creationIdRef = useRef<string | null>(null);
+  const inputRef = useRef<{ prompt: string } | null>(null);
 
-  useEffect(() => {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[useWizardGeneration] Initialized", {
-        scenarioId: scenario.id,
-        outputType: scenario.outputType,
-      });
-    }
-  }, [scenario.id, scenario.outputType]);
+  // Persistence utility - separate from strategy
+  const persistence = useMemo(() => createCreationPersistence(), []);
 
-  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", {
-          creationId: currentCreationIdRef.current,
-        });
+    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);
+          }
+        }
       }
-      currentCreationIdRef.current = null;
+
+      creationIdRef.current = null;
+      inputRef.current = null;
       onSuccess?.(result);
     },
-    [onSuccess],
+    [userId, persistence, onSuccess],
   );
 
   const handleError = useCallback(
-    (err: { message: string }) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[useWizardGeneration] Error:", err.message);
+    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);
+          }
+        }
       }
-      // Note: Failed status update is handled by orchestrator via strategy
-      currentCreationIdRef.current = null;
+
+      creationIdRef.current = null;
+      inputRef.current = null;
       onError?.(err.message);
     },
-    [onError],
+    [userId, persistence, onError],
   );
 
   const { generate, isGenerating } = useGenerationOrchestrator(strategy, {
@@ -89,13 +107,6 @@ 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)
@@ -106,11 +117,18 @@ export const useWizardGeneration = (
             return;
           }
 
-          // Save to Firestore with status="processing" BEFORE starting generation
-          if (strategy.saveAsProcessing && userId) {
+          inputRef.current = input as { prompt: string };
+
+          // Save to Firestore with status="processing"
+          const typedInput = input as { prompt?: string };
+          if (userId && typedInput.prompt) {
             try {
-              const creationId = await strategy.saveAsProcessing(userId, input);
-              currentCreationIdRef.current = creationId;
+              const creationId = await persistence.saveAsProcessing(userId, {
+                scenarioId: scenario.id,
+                scenarioTitle: scenario.title || scenario.id,
+                prompt: typedInput.prompt,
+              });
+              creationIdRef.current = creationId;
 
               if (typeof __DEV__ !== "undefined" && __DEV__) {
                 console.log("[useWizardGeneration] Saved as processing:", creationId);
@@ -119,16 +137,12 @@ export const useWizardGeneration = (
               if (typeof __DEV__ !== "undefined" && __DEV__) {
                 console.error("[useWizardGeneration] saveAsProcessing error:", err);
               }
-              // Continue with generation even if save fails
             }
           }
 
           generate(input);
         })
         .catch((error) => {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error("[useWizardGeneration] Input build error:", error);
-          }
           hasStarted.current = false;
           onError?.(error.message);
         });
@@ -137,16 +151,7 @@ export const useWizardGeneration = (
     if (!isGeneratingStep && hasStarted.current) {
       hasStarted.current = false;
     }
-  }, [
-    isGeneratingStep,
-    scenario,
-    wizardData,
-    isGenerating,
-    generate,
-    onError,
-    strategy,
-    userId,
-  ]);
+  }, [isGeneratingStep, scenario, wizardData, isGenerating, generate, onError, userId, persistence]);
 
   return { isGenerating };
 };

package/src/domains/scenarios/index.ts

@@ -16,6 +16,7 @@ export {
   createScenariosForApp,
   filterScenariosByOutputType,
   filterScenariosByCategory,
+  filterScenariosByWizardInputType,
   getScenarioCategories,
   findScenarioById,
 } from "./infrastructure/scenario-helpers";

package/src/domains/scenarios/infrastructure/scenario-helpers.ts

@@ -4,6 +4,8 @@
  */
 
 import type { Scenario, ScenarioOutputType } from "../domain/Scenario";
+import { WizardInputType } from "../configs/wizard-input.types";
+import { detectWizardInputType } from "../configs/wizard-input-detector";
 
 /**
  * Configuration for creating app-specific scenarios
@@ -17,6 +19,8 @@ export interface AppScenarioConfig {
   readonly excludeIds?: readonly string[];
   /** Optional filter to include only certain category IDs */
   readonly includeCategories?: readonly string[];
+  /** Optional filter to exclude wizard input types (uses pattern detection) */
+  readonly excludeWizardInputTypes?: readonly WizardInputType[];
 }
 
 /**
@@ -24,25 +28,24 @@ export interface AppScenarioConfig {
  * Apps use this to set their desired outputType and model
  *
  * @example
- * // Video generation app
+ * // Video generation app - exclude dual image scenarios
  * const scenarios = createScenariosForApp(SCENARIOS, {
  *   outputType: "video",
- *   model: "fal-ai/veo3/image-to-video"
- * });
- *
- * @example
- * // Image generation app
- * const scenarios = createScenariosForApp(SCENARIOS, {
- *   outputType: "image",
- *   model: "fal-ai/nano-banana/edit",
- *   excludeIds: ["custom"]
+ *   model: "fal-ai/veo3/image-to-video",
+ *   excludeWizardInputTypes: [WizardInputType.DUAL_IMAGE]
  * });
  */
 export const createScenariosForApp = (
   scenarios: readonly Scenario[],
   config: AppScenarioConfig,
 ): Scenario[] => {
-  const { outputType, model, excludeIds, includeCategories } = config;
+  const {
+    outputType,
+    model,
+    excludeIds,
+    includeCategories,
+    excludeWizardInputTypes,
+  } = config;
 
   return scenarios
     .filter((scenario) => {
@@ -59,6 +62,13 @@ export const createScenariosForApp = (
       ) {
         return false;
       }
+      // Filter by wizard input types using pattern detection
+      if (excludeWizardInputTypes && excludeWizardInputTypes.length > 0) {
+        const detectedType = detectWizardInputType(scenario.id);
+        if (excludeWizardInputTypes.includes(detectedType)) {
+          return false;
+        }
+      }
       return true;
     })
     .map((scenario) => ({
@@ -70,7 +80,6 @@ export const createScenariosForApp = (
 
 /**
  * Filters scenarios by output type (if they have one set)
- * Useful for apps that have mixed scenarios with different output types
  *
  * @example
  * const videoScenarios = filterScenariosByOutputType(scenarios, "video");
@@ -91,12 +100,26 @@ export const filterScenariosByCategory = (
   category: string,
 ): Scenario[] => scenarios.filter((s) => s.category === category);
 
+/**
+ * Filters scenarios by wizard input type using pattern detection
+ *
+ * @example
+ * const singleImageScenarios = filterScenariosByWizardInputType(
+ *   scenarios,
+ *   [WizardInputType.SINGLE_IMAGE]
+ * );
+ */
+export const filterScenariosByWizardInputType = (
+  scenarios: readonly Scenario[],
+  inputTypes: readonly WizardInputType[],
+): Scenario[] =>
+  scenarios.filter((s) => inputTypes.includes(detectWizardInputType(s.id)));
+
 /**
  * Gets unique categories from scenarios
  *
  * @example
  * const categories = getScenarioCategories(scenarios);
- * // ["wedding", "fantasy", "adventure", ...]
  */
 export const getScenarioCategories = (
   scenarios: readonly Scenario[],