@umituz/react-native-ai-generation-content 1.65.11 → 1.66.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.65.11",
+  "version": "1.66.0",
   "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/utils/creation-display.util.ts

@@ -0,0 +1,67 @@
+/**
+ * Creation Display Utilities
+ * Single Responsibility: UI display helpers (icons, titles, text)
+ */
+
+import type { CreationTypeId } from "../types";
+
+/**
+ * Icon name type for design system
+ */
+export type IconName = "image" | "film" | "mic" | "sparkles" | "color-palette" | "brush";
+
+/**
+ * Get icon name for creation type
+ */
+export function getTypeIcon(type: CreationTypeId): IconName {
+  switch (type) {
+    case "text-to-video":
+    case "image-to-video":
+      return "film";
+    case "style-transfer":
+    case "colorization":
+      return "color-palette";
+    case "ai-brush":
+    case "inpainting":
+      return "brush";
+    default:
+      return "image";
+  }
+}
+
+/**
+ * Get i18n key for creation type
+ */
+export function getTypeTextKey(type: CreationTypeId): string {
+  return `creations.types.${type}`;
+}
+
+/**
+ * Get formatted type text (fallback)
+ */
+export function getTypeText(type: CreationTypeId): string {
+  return type.split("-").map(word =>
+    word.charAt(0).toUpperCase() + word.slice(1)
+  ).join(" ");
+}
+
+/**
+ * Get creation title from prompt or type
+ */
+export function getCreationTitle(
+  prompt?: string,
+  type?: CreationTypeId,
+  maxLength: number = 50
+): string {
+  if (prompt && prompt.length > 0) {
+    return prompt.length > maxLength
+      ? prompt.substring(0, maxLength) + "..."
+      : prompt;
+  }
+
+  if (type) {
+    return getTypeText(type);
+  }
+
+  return "Untitled Creation";
+}

package/src/domains/creations/domain/utils/creation-format.util.ts

@@ -0,0 +1,12 @@
+/**
+ * Creation Format Utilities
+ * Single Responsibility: Text formatting
+ */
+
+/**
+ * Truncate text with ellipsis
+ */
+export function truncateText(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text;
+  return text.substring(0, maxLength - 3) + "...";
+}

package/src/domains/creations/domain/utils/creation-helpers.ts

@@ -1,140 +1,12 @@
 /**
  * Creation Helpers
- * Utility functions for creation data manipulation
+ * Central export point for creation utility functions
+ * @deprecated Individual utilities split into focused modules for better maintainability
  */
 
-import { generateUUID } from "@umituz/react-native-design-system";
-import type { CreationTypeId } from "../types";
-
-/**
- * Generate a unique creation ID using UUID v4
- */
-export function generateCreationId(): string {
-  return generateUUID();
-}
-
-/**
- * Icon name type for design system
- */
-export type IconName = "image" | "film" | "mic" | "sparkles" | "color-palette" | "brush";
-
-/**
- * Get icon name for creation type
- */
-export function getTypeIcon(type: CreationTypeId): IconName {
-  switch (type) {
-    case "text-to-video":
-    case "image-to-video":
-      return "film";
-    case "style-transfer":
-    case "colorization":
-      return "color-palette";
-    case "ai-brush":
-    case "inpainting":
-      return "brush";
-    default:
-      return "image";
-  }
-}
-
-/**
- * Get i18n key for creation type
- */
-export function getTypeTextKey(type: CreationTypeId): string {
-  return `creations.types.${type}`;
-}
-
-/**
- * Get formatted type text (fallback)
- */
-export function getTypeText(type: CreationTypeId): string {
-  return type.split("-").map(word =>
-    word.charAt(0).toUpperCase() + word.slice(1)
-  ).join(" ");
-}
-
-/**
- * Get creation title from prompt or type
- */
-export function getCreationTitle(
-  prompt?: string,
-  type?: CreationTypeId,
-  maxLength: number = 50
-): string {
-  if (prompt && prompt.length > 0) {
-    return prompt.length > maxLength
-      ? prompt.substring(0, maxLength) + "..."
-      : prompt;
-  }
-
-  if (type) {
-    return getTypeText(type);
-  }
-
-  return "Untitled Creation";
-}
-
-/**
- * Filter creations by search query (client-side)
- */
-export function filterBySearch<T extends { prompt?: string; type?: string; provider?: string }>(
-  items: T[],
-  searchQuery?: string,
-): T[] {
-  if (!searchQuery || searchQuery.trim().length === 0) {
-    return items;
-  }
-
-  const query = searchQuery.toLowerCase().trim();
-
-  return items.filter((item) =>
-    item.prompt?.toLowerCase().includes(query) ||
-    item.type?.toLowerCase().includes(query) ||
-    item.provider?.toLowerCase().includes(query)
-  );
-}
-
-/**
- * Sort creations by field
- */
-export function sortCreations<T extends Record<string, unknown>>(
-  items: T[],
-  field: keyof T,
-  order: "asc" | "desc" = "desc"
-): T[] {
-  return [...items].sort((a, b) => {
-    const aVal = a[field] as unknown;
-    const bVal = b[field] as unknown;
-
-    if (aVal === undefined && bVal === undefined) return 0;
-    if (aVal === undefined) return 1;
-    if (bVal === undefined) return -1;
-
-    if (typeof aVal === "string" && typeof bVal === "string") {
-      return order === "desc"
-        ? bVal.localeCompare(aVal)
-        : aVal.localeCompare(bVal);
-    }
-
-    if (typeof aVal === "number" && typeof bVal === "number") {
-      return order === "desc" ? bVal - aVal : aVal - bVal;
-    }
-
-    // Handle Date objects
-    if (aVal instanceof Date && bVal instanceof Date) {
-      return order === "desc"
-        ? bVal.getTime() - aVal.getTime()
-        : aVal.getTime() - bVal.getTime();
-    }
-
-    return 0;
-  });
-}
-
-/**
- * Truncate text with ellipsis
- */
-export function truncateText(text: string, maxLength: number): string {
-  if (text.length <= maxLength) return text;
-  return text.substring(0, maxLength - 3) + "...";
-}
+// Re-export all utilities for backward compatibility
+export * from "./creation-id.util";
+export * from "./creation-display.util";
+export * from "./creation-search.util";
+export * from "./creation-sort.util";
+export * from "./creation-format.util";

package/src/domains/creations/domain/utils/creation-id.util.ts

@@ -0,0 +1,13 @@
+/**
+ * Creation ID Utilities
+ * Single Responsibility: ID generation
+ */
+
+import { generateUUID } from "@umituz/react-native-design-system";
+
+/**
+ * Generate a unique creation ID using UUID v4
+ */
+export function generateCreationId(): string {
+  return generateUUID();
+}

package/src/domains/creations/domain/utils/creation-search.util.ts

@@ -0,0 +1,24 @@
+/**
+ * Creation Search Utilities
+ * Single Responsibility: Filtering and searching
+ */
+
+/**
+ * Filter creations by search query (client-side)
+ */
+export function filterBySearch<T extends { prompt?: string; type?: string; provider?: string }>(
+  items: T[],
+  searchQuery?: string,
+): T[] {
+  if (!searchQuery || searchQuery.trim().length === 0) {
+    return items;
+  }
+
+  const query = searchQuery.toLowerCase().trim();
+
+  return items.filter((item) =>
+    item.prompt?.toLowerCase().includes(query) ||
+    item.type?.toLowerCase().includes(query) ||
+    item.provider?.toLowerCase().includes(query)
+  );
+}

package/src/domains/creations/domain/utils/creation-sort.util.ts

@@ -0,0 +1,41 @@
+/**
+ * Creation Sort Utilities
+ * Single Responsibility: Sorting operations
+ */
+
+/**
+ * Sort creations by field
+ */
+export function sortCreations<T extends Record<string, unknown>>(
+  items: T[],
+  field: keyof T,
+  order: "asc" | "desc" = "desc"
+): T[] {
+  return [...items].sort((a, b) => {
+    const aVal = a[field] as unknown;
+    const bVal = b[field] as unknown;
+
+    if (aVal === undefined && bVal === undefined) return 0;
+    if (aVal === undefined) return 1;
+    if (bVal === undefined) return -1;
+
+    if (typeof aVal === "string" && typeof bVal === "string") {
+      return order === "desc"
+        ? bVal.localeCompare(aVal)
+        : aVal.localeCompare(bVal);
+    }
+
+    if (typeof aVal === "number" && typeof bVal === "number") {
+      return order === "desc" ? bVal - aVal : aVal - bVal;
+    }
+
+    // Handle Date objects
+    if (aVal instanceof Date && bVal instanceof Date) {
+      return order === "desc"
+        ? bVal.getTime() - aVal.getTime()
+        : aVal.getTime() - bVal.getTime();
+    }
+
+    return 0;
+  });
+}

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

@@ -1,155 +1,53 @@
-import { getDocs, getDoc, query, orderBy, onSnapshot, where } 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 { Creation } from "../../domain/entities/Creation";
 import type { CreationsSubscriptionCallback, UnsubscribeFunction } from "../../domain/repositories/ICreationsRepository";
-import { CREATION_FIELDS } from "../../domain/constants";
-
-declare const __DEV__: boolean;
+import { CreationsQuery } from "./CreationsQuery";
+import { CreationsSubscription } from "./CreationsSubscription";
 
 /**
- * Handles fetching creations from Firestore
- * Single Responsibility: Read operations
+ * CreationsFetcher
+ * Orchestrates read operations for creations
+ * Delegates to specialized classes for queries and subscriptions
+ *
+ * Architecture: Facade pattern
+ * - Query operations → CreationsQuery
+ * - Subscription operations → CreationsSubscription
  */
 export class CreationsFetcher {
+    private readonly query: CreationsQuery;
+    private readonly subscription: CreationsSubscription;
+
     constructor(
-        private readonly pathResolver: FirestorePathResolver,
-        private readonly documentMapper: DocumentMapper,
-    ) { }
+        pathResolver: FirestorePathResolver,
+        documentMapper: DocumentMapper,
+    ) {
+        this.query = new CreationsQuery(pathResolver, documentMapper);
+        this.subscription = new CreationsSubscription(pathResolver, documentMapper);
+    }
 
+    /**
+     * Get all creations for a user
+     */
     async getAll(userId: string): Promise<Creation[]> {
-        const userCollection = this.pathResolver.getUserCollection(userId);
-        if (!userCollection) return [];
-
-        try {
-            // Optimized query: Server-side filtering for non-deleted items
-            // Requires composite index: (deletedAt ASC, createdAt DESC)
-            const q = query(
-                userCollection,
-                where(CREATION_FIELDS.DELETED_AT, "==", null),
-                orderBy(CREATION_FIELDS.CREATED_AT, "desc")
-            );
-            const snapshot = await getDocs(q);
-
-            // Map documents to domain entities
-            // No client-side filtering needed - server already filtered deleted items
-            const creations = snapshot.docs.map((docSnap) => {
-                const data = docSnap.data() as CreationDocument;
-                return this.documentMapper(docSnap.id, data);
-            });
-
-            if (__DEV__) {
-                console.log("[CreationsFetcher] Fetched creations:", {
-                    count: creations.length,
-                    hasDeletedFilter: true,
-                });
-            }
-
-            return creations;
-        } catch (error) {
-            if (__DEV__) {
-                console.error("[CreationsFetcher] getAll() error:", error);
-            }
-            return [];
-        }
+        return this.query.getAll(userId);
     }
 
+    /**
+     * Get a single creation by ID
+     */
     async getById(userId: string, id: string): Promise<Creation | null> {
-        const docRef = this.pathResolver.getDocRef(userId, id);
-        if (!docRef) return null;
-
-        try {
-            const docSnap = await getDoc(docRef);
-
-            if (!docSnap.exists()) {
-                return null;
-            }
-
-            const data = docSnap.data() as CreationDocument;
-            return this.documentMapper(docSnap.id, data);
-        } catch (error) {
-            if (__DEV__) {
-                console.error("[CreationsFetcher] getById() error:", error);
-            }
-            return null;
-        }
+        return this.query.getById(userId, id);
     }
 
     /**
-     * Subscribes to realtime updates for user's creations
-     *
-     * PERFORMANCE OPTIMIZATION:
-     * - Server-side filtering with where clause (80% data reduction)
-     * - No client-side filtering needed
-     * - Requires Firestore composite index: (deletedAt ASC, createdAt DESC)
-     *
-     * @param userId - User ID to query
-     * @param onData - Callback for data updates
-     * @param onError - Optional error callback
-     * @returns Unsubscribe function
+     * Subscribe to realtime updates for user's creations
      */
     subscribeToAll(
         userId: string,
         onData: CreationsSubscriptionCallback,
         onError?: (error: Error) => void,
     ): UnsubscribeFunction {
-        const userCollection = this.pathResolver.getUserCollection(userId);
-        if (!userCollection) {
-            const error = new Error(`[CreationsFetcher] Cannot subscribe: Invalid user collection for userId: ${userId}`);
-            if (__DEV__) {
-                console.error(error.message);
-            }
-            // Return empty array immediately
-            onData([]);
-            // Report error to callback
-            onError?.(error);
-            // Return no-op unsubscribe function (no listener was created)
-            return () => {
-                if (__DEV__) {
-                    console.log("[CreationsFetcher] No-op unsubscribe called (no listener was created)");
-                }
-            };
-        }
-
-        // Optimized query with server-side filtering
-        // This prevents downloading deleted items entirely
-        const q = query(
-            userCollection,
-            where(CREATION_FIELDS.DELETED_AT, "==", null),
-            orderBy(CREATION_FIELDS.CREATED_AT, "desc")
-        );
-
-        return onSnapshot(
-            q,
-            { includeMetadataChanges: false }, // Ignore metadata-only changes for performance
-            (snapshot) => {
-                // Map documents to domain entities
-                // Server already filtered - no client filtering needed
-                const creations = snapshot.docs.map((docSnap) => {
-                    const data = docSnap.data() as CreationDocument;
-                    return this.documentMapper(docSnap.id, data);
-                });
-
-                if (__DEV__) {
-                    console.log("[CreationsFetcher] Realtime sync:", {
-                        count: creations.length,
-                        serverFiltered: true,
-                        hasChanges: snapshot.docChanges().length,
-                    });
-                }
-
-                onData(creations);
-            },
-            (error: Error) => {
-                if (__DEV__) {
-                    console.error("[CreationsFetcher] Realtime subscription error:", {
-                        error: error.message,
-                        code: (error as { code?: string }).code,
-                        userId,
-                    });
-                }
-                onError?.(error);
-            },
-        );
+        return this.subscription.subscribeToAll(userId, onData, onError);
     }
 }

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

@@ -0,0 +1,84 @@
+/**
+ * CreationsQuery
+ * Handles read operations (getAll, getById) for creations
+ * Single Responsibility: Firestore query operations
+ */
+
+import { getDocs, getDoc, query, orderBy, where } 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 { CREATION_FIELDS } from "../../domain/constants";
+
+declare const __DEV__: boolean;
+
+/**
+ * Handles query operations for creations
+ */
+export class CreationsQuery {
+    constructor(
+        private readonly pathResolver: FirestorePathResolver,
+        private readonly documentMapper: DocumentMapper,
+    ) { }
+
+    /**
+     * Get all creations for a user
+     * Optimized query: Server-side filtering for non-deleted items
+     */
+    async getAll(userId: string): Promise<Creation[]> {
+        const userCollection = this.pathResolver.getUserCollection(userId);
+        if (!userCollection) return [];
+
+        try {
+            const q = query(
+                userCollection,
+                where(CREATION_FIELDS.DELETED_AT, "==", null),
+                orderBy(CREATION_FIELDS.CREATED_AT, "desc")
+            );
+            const snapshot = await getDocs(q);
+
+            const creations = snapshot.docs.map((docSnap) => {
+                const data = docSnap.data() as CreationDocument;
+                return this.documentMapper(docSnap.id, data);
+            });
+
+            if (__DEV__) {
+                console.log("[CreationsQuery] Fetched creations:", {
+                    count: creations.length,
+                    hasDeletedFilter: true,
+                });
+            }
+
+            return creations;
+        } catch (error) {
+            if (__DEV__) {
+                console.error("[CreationsQuery] getAll() error:", error);
+            }
+            return [];
+        }
+    }
+
+    /**
+     * Get a single creation by ID
+     */
+    async getById(userId: string, id: string): Promise<Creation | null> {
+        const docRef = this.pathResolver.getDocRef(userId, id);
+        if (!docRef) return null;
+
+        try {
+            const docSnap = await getDoc(docRef);
+
+            if (!docSnap.exists()) {
+                return null;
+            }
+
+            const data = docSnap.data() as CreationDocument;
+            return this.documentMapper(docSnap.id, data);
+        } catch (error) {
+            if (__DEV__) {
+                console.error("[CreationsQuery] getById() error:", error);
+            }
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,70 @@
+/**
+ * CreationsSubscription
+ * Handles realtime subscription operations for creations
+ * Single Responsibility: Firestore realtime listeners
+ */
+
+import { query, orderBy, onSnapshot, where } 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";
+import { CREATION_FIELDS } from "../../domain/constants";
+
+declare const __DEV__: boolean;
+
+/**
+ * Handles realtime subscriptions for creations
+ * Optimized with server-side filtering (80% data reduction)
+ */
+export class CreationsSubscription {
+    constructor(
+        private readonly pathResolver: FirestorePathResolver,
+        private readonly documentMapper: DocumentMapper,
+    ) { }
+
+    subscribeToAll(
+        userId: string,
+        onData: CreationsSubscriptionCallback,
+        onError?: (error: Error) => void,
+    ): UnsubscribeFunction {
+        const userCollection = this.pathResolver.getUserCollection(userId);
+
+        if (!userCollection) {
+            const error = new Error(`[CreationsSubscription] Invalid user collection: ${userId}`);
+            if (__DEV__) console.error(error.message);
+            onData([]);
+            onError?.(error);
+            return () => { if (__DEV__) console.log("[CreationsSubscription] No-op unsubscribe"); };
+        }
+
+        const q = query(
+            userCollection,
+            where(CREATION_FIELDS.DELETED_AT, "==", null),
+            orderBy(CREATION_FIELDS.CREATED_AT, "desc")
+        );
+
+        return onSnapshot(
+            q,
+            { includeMetadataChanges: false },
+            (snapshot) => {
+                const creations = snapshot.docs.map((docSnap) => {
+                    const data = docSnap.data() as CreationDocument;
+                    return this.documentMapper(docSnap.id, data);
+                });
+
+                if (__DEV__) {
+                    console.log("[CreationsSubscription] Sync:", creations.length, "items");
+                }
+
+                onData(creations);
+            },
+            (error: Error) => {
+                if (__DEV__) {
+                    console.error("[CreationsSubscription] Error:", error.message);
+                }
+                onError?.(error);
+            },
+        );
+    }
+}

package/src/domains/creations/infrastructure/repositories/creation-delete.operations.ts

@@ -1,14 +1,14 @@
 /**
  * Creation Delete Operations
+ * Single Responsibility: Delete/restore operations with centralized error handling
  */
 
 import { updateDoc, deleteDoc } from "firebase/firestore";
 import { type FirestorePathResolver } from "@umituz/react-native-firebase";
-
-declare const __DEV__: boolean;
+import { logOperationError, logOperationSuccess, logInvalidRef } from "./creation-error-handler.util";
 
 /**
- * Soft deletes a creation
+ * Soft deletes a creation by setting deletedAt timestamp
  */
 export async function deleteCreation(
   pathResolver: FirestorePathResolver,
@@ -16,37 +16,25 @@ export async function deleteCreation(
   creationId: string
 ): Promise<boolean> {
   const docRef = pathResolver.getDocRef(userId, creationId);
+  const context = { userId, creationId };
+
   if (!docRef) {
-    if (__DEV__) {
-      console.error("[CreationDelete] Cannot delete: Invalid document reference", {
-        userId,
-        creationId,
-      });
-    }
+    logInvalidRef("Delete", context);
     return false;
   }
 
   try {
     await updateDoc(docRef, { deletedAt: new Date() });
-    if (__DEV__) {
-      console.log("[CreationDelete] Soft deleted successfully", { userId, creationId });
-    }
+    logOperationSuccess("Delete", context);
     return true;
   } catch (error) {
-    if (__DEV__) {
-      console.error("[CreationDelete] Soft delete failed", {
-        userId,
-        creationId,
-        error: error instanceof Error ? error.message : String(error),
-        code: (error as { code?: string })?.code,
-      });
-    }
+    logOperationError("Delete", context, error);
     return false;
   }
 }
 
 /**
- * Hard deletes a creation
+ * Permanently deletes a creation from Firestore
  */
 export async function hardDeleteCreation(
   pathResolver: FirestorePathResolver,
@@ -54,37 +42,25 @@ export async function hardDeleteCreation(
   creationId: string
 ): Promise<boolean> {
   const docRef = pathResolver.getDocRef(userId, creationId);
+  const context = { userId, creationId };
+
   if (!docRef) {
-    if (__DEV__) {
-      console.error("[CreationDelete] Cannot hard delete: Invalid document reference", {
-        userId,
-        creationId,
-      });
-    }
+    logInvalidRef("HardDelete", context);
     return false;
   }
 
   try {
     await deleteDoc(docRef);
-    if (__DEV__) {
-      console.log("[CreationDelete] Hard deleted successfully", { userId, creationId });
-    }
+    logOperationSuccess("HardDelete", context);
     return true;
   } catch (error) {
-    if (__DEV__) {
-      console.error("[CreationDelete] Hard delete failed", {
-        userId,
-        creationId,
-        error: error instanceof Error ? error.message : String(error),
-        code: (error as { code?: string })?.code,
-      });
-    }
+    logOperationError("HardDelete", context, error);
     return false;
   }
 }
 
 /**
- * Restores a soft-deleted creation
+ * Restores a soft-deleted creation by clearing deletedAt
  */
 export async function restoreCreation(
   pathResolver: FirestorePathResolver,
@@ -92,31 +68,19 @@ export async function restoreCreation(
   creationId: string
 ): Promise<boolean> {
   const docRef = pathResolver.getDocRef(userId, creationId);
+  const context = { userId, creationId };
+
   if (!docRef) {
-    if (__DEV__) {
-      console.error("[CreationDelete] Cannot restore: Invalid document reference", {
-        userId,
-        creationId,
-      });
-    }
+    logInvalidRef("Restore", context);
     return false;
   }
 
   try {
     await updateDoc(docRef, { deletedAt: null });
-    if (__DEV__) {
-      console.log("[CreationDelete] Restored successfully", { userId, creationId });
-    }
+    logOperationSuccess("Restore", context);
     return true;
   } catch (error) {
-    if (__DEV__) {
-      console.error("[CreationDelete] Restore failed", {
-        userId,
-        creationId,
-        error: error instanceof Error ? error.message : String(error),
-        code: (error as { code?: string })?.code,
-      });
-    }
+    logOperationError("Restore", context, error);
     return false;
   }
 }

package/src/domains/creations/infrastructure/repositories/creation-error-handler.util.ts

@@ -0,0 +1,36 @@
+/**
+ * Creation Error Handler Utility
+ * Single Responsibility: Centralized error logging
+ */
+
+declare const __DEV__: boolean;
+
+export function logOperationError(
+  operation: string,
+  context: { userId: string; creationId: string },
+  error: unknown
+): void {
+  if (!__DEV__) return;
+
+  console.error(`[Creation${operation}] Failed:`, {
+    ...context,
+    error: error instanceof Error ? error.message : String(error),
+    code: (error as { code?: string })?.code,
+  });
+}
+
+export function logOperationSuccess(
+  operation: string,
+  context: { userId: string; creationId: string }
+): void {
+  if (!__DEV__) return;
+  console.log(`[Creation${operation}] Success:`, context);
+}
+
+export function logInvalidRef(
+  operation: string,
+  context: { userId: string; creationId: string }
+): void {
+  if (!__DEV__) return;
+  console.error(`[Creation${operation}] Invalid document reference:`, context);
+}

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

@@ -49,57 +49,56 @@ export function useProcessingJobsPoller(
     [creations],
   );
 
-  const pollJob = useCallback(
-    async (creation: Creation) => {
-      if (!userId || !creation.requestId || !creation.model) return;
-      if (pollingRef.current.has(creation.id)) return;
-
-      const provider = providerRegistry.getActiveProvider();
-      if (!provider || !provider.isInitialized()) return;
-
-      pollingRef.current.add(creation.id);
-
-      try {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[ProcessingJobsPoller] Checking status:", creation.id);
-        }
-
-        const status = await provider.getJobStatus(creation.model, creation.requestId);
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[ProcessingJobsPoller] Status:", creation.id, status.status);
-        }
-
-        if (status.status === QUEUE_STATUS.COMPLETED) {
-          const result = await provider.getJobResult<FalResult>(creation.model, creation.requestId);
-          const urls = extractResultUrl(result);
-          if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[ProcessingJobsPoller] Completed:", creation.id, urls);
-
-          const uri = urls.videoUrl || urls.imageUrl || "";
-          await repository.update(userId, creation.id, {
-            status: CREATION_STATUS.COMPLETED,
-            uri,
-            output: urls,
-          });
-        } else if (status.status === QUEUE_STATUS.FAILED) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[ProcessingJobsPoller] Failed:", creation.id);
-
-          await repository.update(userId, creation.id, {
-            status: CREATION_STATUS.FAILED,
-            metadata: { error: "Generation failed" },
-          });
-        }
-        // If still IN_PROGRESS or IN_QUEUE, we'll check again next interval
-      } catch (error) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error("[ProcessingJobsPoller] Poll error:", creation.id, error);
-        }
-      } finally {
-        pollingRef.current.delete(creation.id);
+  // Use ref for stable function reference to prevent effect re-runs
+  const pollJobRef = useRef<(creation: Creation) => Promise<void>>();
+
+  pollJobRef.current = async (creation: Creation) => {
+    if (!userId || !creation.requestId || !creation.model) return;
+    if (pollingRef.current.has(creation.id)) return;
+
+    const provider = providerRegistry.getActiveProvider();
+    if (!provider || !provider.isInitialized()) return;
+
+    pollingRef.current.add(creation.id);
+
+    try {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[ProcessingJobsPoller] Checking status:", creation.id);
       }
-    },
-    [userId, repository],
-  );
+
+      const status = await provider.getJobStatus(creation.model, creation.requestId);
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[ProcessingJobsPoller] Status:", creation.id, status.status);
+      }
+
+      if (status.status === QUEUE_STATUS.COMPLETED) {
+        const result = await provider.getJobResult<FalResult>(creation.model, creation.requestId);
+        const urls = extractResultUrl(result);
+        if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[ProcessingJobsPoller] Completed:", creation.id, urls);
+
+        const uri = urls.videoUrl || urls.imageUrl || "";
+        await repository.update(userId, creation.id, {
+          status: CREATION_STATUS.COMPLETED,
+          uri,
+          output: urls,
+        });
+      } else if (status.status === QUEUE_STATUS.FAILED) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[ProcessingJobsPoller] Failed:", creation.id);
+
+        await repository.update(userId, creation.id, {
+          status: CREATION_STATUS.FAILED,
+          metadata: { error: "Generation failed" },
+        });
+      }
+    } catch (error) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[ProcessingJobsPoller] Poll error:", creation.id, error);
+      }
+    } finally {
+      pollingRef.current.delete(creation.id);
+    }
+  };
 
   useEffect(() => {
     if (!enabled || !userId || processingJobs.length === 0) {
@@ -111,11 +110,11 @@ export function useProcessingJobsPoller(
     }
 
     // Initial poll
-    processingJobs.forEach((job) => void pollJob(job));
+    processingJobs.forEach((job) => pollJobRef.current?.(job));
 
     // Set up interval polling
     intervalRef.current = setInterval(() => {
-      processingJobs.forEach((job) => void pollJob(job));
+      processingJobs.forEach((job) => pollJobRef.current?.(job));
     }, DEFAULT_POLL_INTERVAL_MS);
 
     return () => {
@@ -128,7 +127,7 @@ export function useProcessingJobsPoller(
         intervalRef.current = null;
       }
     };
-  }, [enabled, userId, processingJobs, pollJob]);
+  }, [enabled, userId, processingJobs]);
 
   return {
     processingCount: processingJobs.length,