@umituz/react-native-ai-generation-content 1.17.160 → 1.17.162

package/package.json

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

package/src/domains/creations/index.ts

@@ -116,6 +116,13 @@ export { useCreations } from "./presentation/hooks/useCreations";
 export { useDeleteCreation } from "./presentation/hooks/useDeleteCreation";
 export { useCreationsFilter } from "./presentation/hooks/useCreationsFilter";
 export { useAdvancedFilter } from "./presentation/hooks/useAdvancedFilter";
+export { useCreationPersistence } from "./presentation/hooks/useCreationPersistence";
+export type {
+  UseCreationPersistenceConfig,
+  UseCreationPersistenceReturn,
+  ProcessingStartData,
+  ProcessingResult,
+} from "./presentation/hooks/useCreationPersistence";
 
 // =============================================================================
 // PRESENTATION LAYER - Components

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

@@ -14,3 +14,10 @@ export type {
 export { useFilter, useStatusFilter, useMediaFilter } from "./useFilter";
 export type { UseFilterProps, UseFilterReturn } from "./useFilter";
 export { useGalleryFilters } from "./useGalleryFilters";
+export { useCreationPersistence } from "./useCreationPersistence";
+export type {
+  UseCreationPersistenceConfig,
+  UseCreationPersistenceReturn,
+  ProcessingStartData,
+  ProcessingResult,
+} from "./useCreationPersistence";

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

@@ -0,0 +1,133 @@
+/**
+ * useCreationPersistence Hook
+ * Encapsulates Firestore persistence logic for AI generation features
+ * Eliminates boilerplate code in feature screens
+ */
+
+import { useCallback, useMemo } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { useAuth } from "@umituz/react-native-auth";
+import { createCreationsRepository } from "../../infrastructure/adapters";
+import type { Creation } from "../../domain/entities/Creation";
+
+/**
+ * Configuration for creation persistence
+ */
+export interface UseCreationPersistenceConfig {
+  /** Creation type identifier (e.g., "anime-selfie", "ai-kiss") */
+  readonly type: string;
+  /** Collection name in Firestore (defaults to "creations") */
+  readonly collectionName?: string;
+}
+
+/**
+ * Generic processing start data - all features must have creationId
+ */
+export interface ProcessingStartData {
+  readonly creationId: string;
+  readonly [key: string]: unknown;
+}
+
+/**
+ * Generic processing result - all features should have creationId
+ */
+export interface ProcessingResult {
+  readonly creationId?: string;
+  readonly imageUrl?: string;
+  readonly videoUrl?: string;
+  readonly [key: string]: unknown;
+}
+
+/**
+ * Return type for useCreationPersistence
+ */
+export interface UseCreationPersistenceReturn {
+  readonly onProcessingStart: (data: ProcessingStartData) => void;
+  readonly onProcessingComplete: (result: ProcessingResult) => void;
+  readonly onError: (error: string, creationId?: string) => void;
+}
+
+/**
+ * Hook that provides Firestore persistence callbacks for AI features
+ *
+ * @example
+ * // In AnimeSelfieScreen:
+ * const persistence = useCreationPersistence({ type: "anime-selfie" });
+ * const config = useMemo(() => ({
+ *   prepareImage,
+ *   ...persistence,
+ * }), [persistence]);
+ */
+export function useCreationPersistence(
+  config: UseCreationPersistenceConfig,
+): UseCreationPersistenceReturn {
+  const { type, collectionName = "creations" } = config;
+  const { userId } = useAuth();
+  const queryClient = useQueryClient();
+
+  const repository = useMemo(
+    () => createCreationsRepository(collectionName),
+    [collectionName],
+  );
+
+  const onProcessingStart = useCallback(
+    (data: ProcessingStartData) => {
+      if (!userId) return;
+
+      const { creationId, ...rest } = data;
+      const creation: Creation = {
+        id: creationId,
+        uri: "",
+        type,
+        status: "processing",
+        createdAt: new Date(),
+        isShared: false,
+        isFavorite: false,
+        metadata: rest,
+      };
+
+      repository.create(userId, creation);
+      queryClient.invalidateQueries({ queryKey: ["creations"] });
+    },
+    [userId, repository, queryClient, type],
+  );
+
+  const onProcessingComplete = useCallback(
+    (result: ProcessingResult) => {
+      if (!userId || !result.creationId) return;
+
+      const uri = result.imageUrl || result.videoUrl || "";
+      const output = result.imageUrl
+        ? { imageUrl: result.imageUrl }
+        : result.videoUrl
+          ? { videoUrl: result.videoUrl }
+          : undefined;
+
+      repository.update(userId, result.creationId, {
+        uri,
+        status: "completed",
+        output,
+      });
+      queryClient.invalidateQueries({ queryKey: ["creations"] });
+    },
+    [userId, repository, queryClient],
+  );
+
+  const onError = useCallback(
+    (error: string, creationId?: string) => {
+      if (!userId || !creationId) return;
+
+      repository.update(userId, creationId, {
+        status: "failed",
+        metadata: { error },
+      });
+      queryClient.invalidateQueries({ queryKey: ["creations"] });
+    },
+    [userId, repository, queryClient],
+  );
+
+  return useMemo(
+    () => ({ onProcessingStart, onProcessingComplete, onError }),
+    [onProcessingStart, onProcessingComplete, onError],
+  );
+}

package/src/features/anime-selfie/domain/types/anime-selfie.types.ts

@@ -24,6 +24,12 @@ export interface AnimeSelfieResult {
   imageBase64?: string;
   error?: string;
   requestId?: string;
+  creationId?: string;
+}
+
+export interface AnimeSelfieProcessingStartData {
+  creationId: string;
+  imageUri: string;
 }
 
 export interface AnimeSelfieFeatureState {
@@ -58,7 +64,7 @@ export interface AnimeSelfieFeatureConfig {
   extractResult?: AnimeSelfieResultExtractor;
   prepareImage: (imageUri: string) => Promise<string>;
   onImageSelect?: (uri: string) => void;
-  onProcessingStart?: () => void;
+  onProcessingStart?: (data: AnimeSelfieProcessingStartData) => void;
   onProcessingComplete?: (result: AnimeSelfieResult) => void;
-  onError?: (error: string) => void;
+  onError?: (error: string, creationId?: string) => void;
 }

package/src/features/anime-selfie/domain/types/index.ts

@@ -7,6 +7,7 @@ export type {
   AnimeSelfieOptions,
   AnimeSelfieRequest,
   AnimeSelfieResult,
+  AnimeSelfieProcessingStartData,
   AnimeSelfieFeatureState,
   AnimeSelfieTranslations,
   AnimeSelfieResultExtractor,

package/src/features/anime-selfie/index.ts

@@ -9,6 +9,7 @@ export type {
   AnimeSelfieOptions,
   AnimeSelfieRequest,
   AnimeSelfieResult,
+  AnimeSelfieProcessingStartData,
   AnimeSelfieFeatureState,
   AnimeSelfieTranslations,
   AnimeSelfieFeatureConfig,

package/src/features/anime-selfie/presentation/hooks/useAnimeSelfieFeature.ts

@@ -3,7 +3,8 @@
  * Manages anime selfie feature state and actions
  */
 
-import { useState, useCallback } from "react";
+import { useState, useCallback, useRef } from "react";
+import { generateUUID } from "@umituz/react-native-uuid";
 import { executeImageFeature } from "../../../../infrastructure/services";
 import type {
   AnimeSelfieFeatureState,
@@ -38,6 +39,7 @@ export function useAnimeSelfieFeature(
 ): UseAnimeSelfieFeatureReturn {
   const { config, onSelectImage, onSaveImage, onBeforeProcess } = props;
   const [state, setState] = useState<AnimeSelfieFeatureState>(initialState);
+  const creationIdRef = useRef<string | null>(null);
 
   const selectImage = useCallback(async () => {
     try {
@@ -64,6 +66,9 @@ export function useAnimeSelfieFeature(
       if (!canProceed) return;
     }
 
+    const creationId = generateUUID();
+    creationIdRef.current = creationId;
+
     setState((prev) => ({
       ...prev,
       isProcessing: true,
@@ -71,7 +76,7 @@ export function useAnimeSelfieFeature(
       error: null,
     }));
 
-    config.onProcessingStart?.();
+    config.onProcessingStart?.({ creationId, imageUri: state.imageUri });
 
     try {
       const imageBase64 = await config.prepareImage(state.imageUri);
@@ -89,7 +94,7 @@ export function useAnimeSelfieFeature(
           processedUrl: result.imageUrl!,
           progress: 100,
         }));
-        config.onProcessingComplete?.(result as AnimeSelfieResult);
+        config.onProcessingComplete?.({ ...result, creationId } as AnimeSelfieResult);
       } else {
         const errorMessage = result.error || "Processing failed";
         setState((prev) => ({
@@ -98,7 +103,7 @@ export function useAnimeSelfieFeature(
           error: errorMessage,
           progress: 0,
         }));
-        config.onError?.(errorMessage);
+        config.onError?.(errorMessage, creationId);
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -108,7 +113,7 @@ export function useAnimeSelfieFeature(
         error: errorMessage,
         progress: 0,
       }));
-      config.onError?.(errorMessage);
+      config.onError?.(errorMessage, creationIdRef.current ?? undefined);
     }
   }, [state.imageUri, config, handleProgress, onBeforeProcess]);