@umituz/react-native-ai-generation-content 1.48.0 → 1.48.2

package/package.json

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

package/src/domains/creations/domain/repositories/ICreationsRepository.ts

@@ -5,8 +5,17 @@
 
 import type { Creation } from "../entities/Creation";
 
+export type CreationsSubscriptionCallback = (creations: Creation[]) => void;
+export type UnsubscribeFunction = () => void;
+
 export interface ICreationsRepository {
   getAll(userId: string): Promise<Creation[]>;
+  /** Realtime subscription to all creations */
+  subscribeToAll(
+    userId: string,
+    onData: CreationsSubscriptionCallback,
+    onError?: (error: Error) => void,
+  ): UnsubscribeFunction;
   getById(userId: string, id: string): Promise<Creation | null>;
   create(userId: string, creation: Creation): Promise<void>;
   update(

package/src/domains/creations/domain/repositories/index.ts

@@ -2,4 +2,8 @@
  * Domain Repository Interfaces
  */
 
-export type { ICreationsRepository } from "./ICreationsRepository";
+export type {
+  ICreationsRepository,
+  CreationsSubscriptionCallback,
+  UnsubscribeFunction,
+} from "./ICreationsRepository";

package/src/domains/creations/index.ts

@@ -94,7 +94,11 @@ export { DEFAULT_TRANSLATIONS, DEFAULT_CONFIG } from "./domain/value-objects";
 // DOMAIN LAYER - Repository Interface
 // =============================================================================
 
-export type { ICreationsRepository } from "./domain/repositories";
+export type {
+  ICreationsRepository,
+  CreationsSubscriptionCallback,
+  UnsubscribeFunction,
+} from "./domain/repositories";
 
 // =============================================================================
 // INFRASTRUCTURE LAYER

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

@@ -1,7 +1,8 @@
-import { getDocs, getDoc, query, orderBy } from "firebase/firestore";
+import { getDocs, getDoc, query, orderBy, onSnapshot } from "firebase/firestore";
 import { type FirestorePathResolver } from "@umituz/react-native-firebase";
 import type { DocumentMapper } from "../../domain/value-objects/CreationsConfig";
 import type { Creation, CreationDocument } from "../../domain/entities/Creation";
+import type { CreationsSubscriptionCallback, UnsubscribeFunction } from "../../domain/repositories/ICreationsRepository";
 
 declare const __DEV__: boolean;
 
@@ -85,10 +86,66 @@ export class CreationsFetcher {
             return this.documentMapper(docSnap.id, data);
         } catch (error) {
             if (__DEV__) {
-                 
+
                 console.error("[CreationsRepository] getById() ERROR", error);
             }
             return null;
         }
     }
+
+    subscribeToAll(
+        userId: string,
+        onData: CreationsSubscriptionCallback,
+        onError?: (error: Error) => void,
+    ): UnsubscribeFunction {
+        if (__DEV__) {
+            console.log("[CreationsFetcher] subscribeToAll()", { userId });
+        }
+
+        const userCollection = this.pathResolver.getUserCollection(userId);
+        if (!userCollection) {
+            onData([]);
+            return () => {};
+        }
+
+        const q = query(userCollection, orderBy("createdAt", "desc"));
+
+        return onSnapshot(
+            q,
+            (snapshot) => {
+                const allCreations = snapshot.docs.map((docSnap) => {
+                    const data = docSnap.data() as CreationDocument;
+                    const creation = this.documentMapper(docSnap.id, data);
+
+                    if (creation.deletedAt === undefined && data.deletedAt) {
+                        const deletedAt =
+                            data.deletedAt instanceof Date
+                                ? data.deletedAt
+                                : data.deletedAt &&
+                                    typeof data.deletedAt === "object" &&
+                                    "toDate" in data.deletedAt
+                                  ? (data.deletedAt as { toDate: () => Date }).toDate()
+                                  : undefined;
+                        return { ...creation, deletedAt };
+                    }
+
+                    return creation;
+                });
+
+                const filtered = allCreations.filter((c) => !c.deletedAt);
+
+                if (__DEV__) {
+                    console.log("[CreationsFetcher] Realtime update:", filtered.length);
+                }
+
+                onData(filtered);
+            },
+            (error) => {
+                if (__DEV__) {
+                    console.error("[CreationsFetcher] subscribeToAll() ERROR", error);
+                }
+                onError?.(error);
+            },
+        );
+    }
 }

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

@@ -2,7 +2,11 @@
 if (typeof __DEV__ !== "undefined" && __DEV__) console.log("📍 [LIFECYCLE] CreationsRepository.ts - Module loading");
 
 import { BaseRepository, FirestorePathResolver } from "@umituz/react-native-firebase";
-import type { ICreationsRepository } from "../../domain/repositories/ICreationsRepository";
+import type {
+  ICreationsRepository,
+  CreationsSubscriptionCallback,
+  UnsubscribeFunction,
+} from "../../domain/repositories/ICreationsRepository";
 import type { Creation } from "../../domain/entities/Creation";
 import { mapDocumentToCreation } from "../../domain/entities/Creation";
 import type { DocumentMapper } from "../../domain/value-objects/CreationsConfig";
@@ -66,6 +70,14 @@ export class CreationsRepository
     return this.fetcher.getById(userId, id);
   }
 
+  subscribeToAll(
+    userId: string,
+    onData: CreationsSubscriptionCallback,
+    onError?: (error: Error) => void,
+  ): UnsubscribeFunction {
+    return this.fetcher.subscribeToAll(userId, onData, onError);
+  }
+
   async create(userId: string, creation: Creation): Promise<void> {
     return this.writer.create(userId, creation);
   }

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

@@ -1,75 +1,44 @@
 /**
  * useCreationPersistence Hook
  * Encapsulates Firestore persistence logic for AI generation features
- * Eliminates boilerplate code in feature screens
+ * Realtime listener handles UI updates automatically
  */
 
 import { useCallback, useMemo } from "react";
-import { useQueryClient } from "@umituz/react-native-design-system";
 import { useAuth } from "@umituz/react-native-auth";
 import { createCreationsRepository } from "../../infrastructure/adapters";
 import type { Creation } from "../../domain/entities/Creation";
 
 declare const __DEV__: boolean;
 
-/**
- * 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;
-  /** Credit cost for this feature (passed to onCreditDeduct) */
   readonly creditCost?: number;
-  /** Callback to deduct credits on successful processing */
   readonly onCreditDeduct?: (cost: number) => Promise<void | boolean>;
 }
 
-/**
- * Base processing start data - all features must have creationId
- */
 export interface BaseProcessingStartData {
   readonly creationId: string;
 }
 
-/**
- * Base processing result - all features should have creationId
- */
 export interface BaseProcessingResult {
   readonly creationId?: string;
   readonly imageUrl?: string;
   readonly videoUrl?: string;
 }
 
-/**
- * Return type for useCreationPersistence - uses generic callbacks
- */
 export interface UseCreationPersistenceReturn {
   readonly onProcessingStart: <T extends BaseProcessingStartData>(data: T) => void;
   readonly onProcessingComplete: <T extends BaseProcessingResult>(result: T) => void;
   readonly onError: (error: string, creationId?: string) => void;
 }
 
-/**
- * Hook that provides Firestore persistence callbacks for AI features
- *
- * @example
- * const { deductCredit } = useDeductCredit({ userId, onCreditsExhausted: openPaywall });
- * const persistence = useCreationPersistence({
- *   type: "anime-selfie",
- *   creditCost: AI_CREDIT_COST.ANIME_SELFIE,
- *   onCreditDeduct: async (cost) => {
- *     for (let i = 0; i < cost; i++) await deductCredit("image");
- *   },
- * });
- */
 export function useCreationPersistence(
   config: UseCreationPersistenceConfig,
 ): UseCreationPersistenceReturn {
   const { type, collectionName = "creations", creditCost, onCreditDeduct } = config;
   const { userId } = useAuth();
-  const queryClient = useQueryClient();
 
   const repository = useMemo(
     () => createCreationsRepository(collectionName),
@@ -78,12 +47,14 @@ export function useCreationPersistence(
 
   const onProcessingStart = useCallback(
     <T extends BaseProcessingStartData>(data: T) => {
-      if (__DEV__) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[useCreationPersistence] onProcessingStart", { type, userId });
       }
 
       if (!userId) {
-        if (__DEV__) console.log("[useCreationPersistence] No userId, skipping");
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[useCreationPersistence] No userId, skipping");
+        }
         return;
       }
 
@@ -103,19 +74,18 @@ export function useCreationPersistence(
         metadata: cleanMetadata,
       };
 
-      if (__DEV__) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[useCreationPersistence] Creating document", { creationId, type });
       }
 
       repository.create(userId, creation);
-      queryClient.invalidateQueries({ queryKey: ["creations"] });
     },
-    [userId, repository, queryClient, type],
+    [userId, repository, type],
   );
 
   const onProcessingComplete = useCallback(
     <T extends BaseProcessingResult>(result: T) => {
-      if (__DEV__) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[useCreationPersistence] onProcessingComplete", {
           creationId: result.creationId,
           hasImageUrl: !!result.imageUrl,
@@ -124,7 +94,9 @@ export function useCreationPersistence(
       }
 
       if (!userId || !result.creationId) {
-        if (__DEV__) console.log("[useCreationPersistence] Missing userId or creationId");
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[useCreationPersistence] Missing userId or creationId");
+        }
         return;
       }
 
@@ -140,31 +112,31 @@ export function useCreationPersistence(
         status: "completed",
         output,
       });
-      queryClient.invalidateQueries({ queryKey: ["creations"] });
 
-      // Deduct credits via callback (app provides implementation)
       if (creditCost && creditCost > 0 && onCreditDeduct) {
-        if (__DEV__) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.log("[useCreationPersistence] Deducting credits", { cost: creditCost });
         }
         onCreditDeduct(creditCost).catch((err) => {
-          if (__DEV__) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
             console.error("[useCreationPersistence] Credit deduction failed", err);
           }
         });
       }
     },
-    [userId, repository, queryClient, creditCost, onCreditDeduct],
+    [userId, repository, creditCost, onCreditDeduct],
   );
 
   const onError = useCallback(
     (error: string, creationId?: string) => {
-      if (__DEV__) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[useCreationPersistence] onError", { error, creationId });
       }
 
       if (!userId || !creationId) {
-        if (__DEV__) console.log("[useCreationPersistence] Missing userId or creationId");
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[useCreationPersistence] Missing userId or creationId");
+        }
         return;
       }
 
@@ -172,9 +144,8 @@ export function useCreationPersistence(
         status: "failed",
         metadata: { error },
       });
-      queryClient.invalidateQueries({ queryKey: ["creations"] });
     },
-    [userId, repository, queryClient],
+    [userId, repository],
   );
 
   return useMemo(

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

@@ -1,11 +1,13 @@
 /**
  * useCreationRating Hook
- * Handles rating of creations with optimistic update
+ * Handles rating of creations
+ * Realtime listener handles UI updates automatically
  */
 
-import { useMutation, useQueryClient } from "@umituz/react-native-design-system";
+import { useState, useCallback } from "react";
 import type { ICreationsRepository } from "../../domain/repositories/ICreationsRepository";
-import type { Creation } from "../../domain/entities/Creation";
+
+declare const __DEV__: boolean;
 
 interface UseCreationRatingProps {
   readonly userId: string | null;
@@ -15,41 +17,53 @@ interface UseCreationRatingProps {
 interface RatingVariables {
   readonly id: string;
   readonly rating: number;
+  readonly description?: string;
+}
+
+interface UseCreationRatingReturn {
+  readonly mutate: (variables: RatingVariables) => void;
+  readonly mutateAsync: (variables: RatingVariables) => Promise<boolean>;
+  readonly isPending: boolean;
 }
 
 export function useCreationRating({
   userId,
   repository,
-}: UseCreationRatingProps) {
-  const queryClient = useQueryClient();
-  const queryKey = ["creations", userId ?? ""];
+}: UseCreationRatingProps): UseCreationRatingReturn {
+  const [isPending, setIsPending] = useState(false);
 
-  return useMutation({
-    mutationFn: async ({ id, rating }: RatingVariables) => {
+  const mutateAsync = useCallback(
+    async ({ id, rating, description }: RatingVariables): Promise<boolean> => {
       if (!userId) return false;
-      return repository.rate(userId, id, rating);
-    },
-    onMutate: async ({ id, rating }: RatingVariables) => {
-      await queryClient.cancelQueries({ queryKey });
-      const previousData = queryClient.getQueryData<Creation[]>(queryKey);
-
-      if (previousData) {
-        queryClient.setQueryData<Creation[]>(queryKey, (old) =>
-          old?.map((c) =>
-            c.id === id ? { ...c, rating, ratedAt: new Date() } : c
-          ) ?? []
-        );
-      }
 
-      return { previousData };
-    },
-    onError: (_error, _variables, context) => {
-      if (context?.previousData) {
-        queryClient.setQueryData(queryKey, context.previousData);
+      setIsPending(true);
+      try {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[useCreationRating] Rating:", { id, rating });
+        }
+        const result = await repository.rate(userId, id, rating, description);
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[useCreationRating] Rate result:", result);
+        }
+        return result;
+      } catch (error) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error("[useCreationRating] Error:", error);
+        }
+        return false;
+      } finally {
+        setIsPending(false);
       }
     },
-    onSettled: () => {
-      void queryClient.invalidateQueries({ queryKey });
+    [userId, repository],
+  );
+
+  const mutate = useCallback(
+    (variables: RatingVariables): void => {
+      void mutateAsync(variables);
     },
-  });
+    [mutateAsync],
+  );
+
+  return { mutate, mutateAsync, isPending };
 }

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

@@ -1,16 +1,14 @@
 /**
  * useCreations Hook
- * Fetches user's creations from repository
+ * Realtime Firestore listener for user's creations
+ * Auto-updates UI when Firestore data changes
  */
 
-import { useQuery } from "@umituz/react-native-design-system";
+import { useState, useEffect, useCallback } from "react";
 import type { ICreationsRepository } from "../../domain/repositories/ICreationsRepository";
 import type { Creation } from "../../domain/entities/Creation";
 
-const CACHE_CONFIG = {
-  staleTime: 5 * 60 * 1000, // 5 minutes - use cache invalidation on mutations
-  gcTime: 30 * 60 * 1000,
-};
+declare const __DEV__: boolean;
 
 interface UseCreationsProps {
   readonly userId: string | null;
@@ -18,21 +16,68 @@ interface UseCreationsProps {
   readonly enabled?: boolean;
 }
 
+interface UseCreationsReturn {
+  readonly data: Creation[] | undefined;
+  readonly isLoading: boolean;
+  readonly error: Error | null;
+  readonly refetch: () => void;
+}
+
 export function useCreations({
   userId,
   repository,
   enabled = true,
-}: UseCreationsProps) {
-  return useQuery<Creation[]>({
-    queryKey: ["creations", userId ?? ""],
-    queryFn: async () => {
-      if (!userId) {
-        return [];
+}: UseCreationsProps): UseCreationsReturn {
+  const [data, setData] = useState<Creation[] | undefined>(undefined);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  const refetch = useCallback(() => {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[useCreations] refetch() - realtime listener handles updates");
+    }
+  }, []);
+
+  useEffect(() => {
+    if (!userId || !enabled) {
+      setData([]);
+      setIsLoading(false);
+      return;
+    }
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[useCreations] Setting up realtime listener", { userId });
+    }
+
+    setIsLoading(true);
+    setError(null);
+
+    const unsubscribe = repository.subscribeToAll(
+      userId,
+      (creations) => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[useCreations] Realtime update:", creations.length);
+        }
+        setData(creations);
+        setIsLoading(false);
+        setError(null);
+      },
+      (err) => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error("[useCreations] Realtime listener error:", err);
+        }
+        setError(err);
+        setIsLoading(false);
+      },
+    );
+
+    return () => {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[useCreations] Cleaning up realtime listener");
       }
-      return repository.getAll(userId);
-    },
-    enabled: !!userId && enabled,
-    staleTime: CACHE_CONFIG.staleTime,
-    gcTime: CACHE_CONFIG.gcTime,
-  });
+      unsubscribe();
+    };
+  }, [userId, repository, enabled]);
+
+  return { data, isLoading, error, refetch };
 }

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

@@ -1,48 +1,63 @@
 /**
  * useDeleteCreation Hook
- * Handles deletion of user creations with optimistic update
+ * Handles deletion of user creations
+ * Realtime listener handles UI updates automatically
  */
 
-import { useMutation, useQueryClient } from "@umituz/react-native-design-system";
+import { useState, useCallback } from "react";
 import type { ICreationsRepository } from "../../domain/repositories/ICreationsRepository";
-import type { Creation } from "../../domain/entities/Creation";
+
+declare const __DEV__: boolean;
 
 interface UseDeleteCreationProps {
   readonly userId: string | null;
   readonly repository: ICreationsRepository;
 }
 
+interface UseDeleteCreationReturn {
+  readonly mutate: (creationId: string) => void;
+  readonly mutateAsync: (creationId: string) => Promise<boolean>;
+  readonly isPending: boolean;
+}
+
 export function useDeleteCreation({
   userId,
   repository,
-}: UseDeleteCreationProps) {
-  const queryClient = useQueryClient();
-  const queryKey = ["creations", userId ?? ""];
+}: UseDeleteCreationProps): UseDeleteCreationReturn {
+  const [isPending, setIsPending] = useState(false);
 
-  return useMutation({
-    mutationFn: async (creationId: string) => {
+  const mutateAsync = useCallback(
+    async (creationId: string): Promise<boolean> => {
       if (!userId) return false;
-      return repository.delete(userId, creationId);
-    },
-    onMutate: async (creationId: string) => {
-      await queryClient.cancelQueries({ queryKey });
-      const previousData = queryClient.getQueryData<Creation[]>(queryKey);
-
-      if (previousData) {
-        queryClient.setQueryData<Creation[]>(queryKey, (old: Creation[] | undefined) =>
-          old?.filter((c: Creation) => c.id !== creationId) ?? []
-        );
-      }
 
-      return { previousData };
-    },
-    onError: (_error: Error, _variables: string, context: { previousData?: Creation[] } | undefined) => {
-      if (context?.previousData) {
-        queryClient.setQueryData(queryKey, context.previousData);
+      setIsPending(true);
+      try {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[useDeleteCreation] Deleting:", creationId);
+        }
+        const result = await repository.delete(userId, creationId);
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[useDeleteCreation] Delete result:", result);
+        }
+        return result;
+      } catch (error) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error("[useDeleteCreation] Error:", error);
+        }
+        return false;
+      } finally {
+        setIsPending(false);
       }
     },
-    onSettled: () => {
-      void queryClient.invalidateQueries({ queryKey });
+    [userId, repository],
+  );
+
+  const mutate = useCallback(
+    (creationId: string): void => {
+      void mutateAsync(creationId);
     },
-  });
+    [mutateAsync],
+  );
+
+  return { mutate, mutateAsync, isPending };
 }