@umituz/react-native-ai-generation-content 1.64.0 → 1.65.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.64.0",
+  "version": "1.65.1",
   "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/infrastructure/repositories/creation-create.operations.ts

@@ -0,0 +1,40 @@
+/**
+ * Creation Create Operations
+ */
+
+import { setDoc } from "firebase/firestore";
+import { type FirestorePathResolver } from "@umituz/react-native-firebase";
+import type { Creation, CreationDocument } from "../../domain/entities/Creation";
+
+/**
+ * Creates a new creation document
+ */
+export async function createCreation(
+  pathResolver: FirestorePathResolver,
+  userId: string,
+  creation: Creation
+): Promise<void> {
+  const docRef = pathResolver.getDocRef(userId, creation.id);
+  if (!docRef) throw new Error("Firestore not initialized");
+
+  const data: CreationDocument = {
+    type: creation.type,
+    uri: creation.uri,
+    createdAt: creation.createdAt,
+    metadata: creation.metadata || {},
+    isShared: creation.isShared || false,
+    isFavorite: creation.isFavorite || false,
+    ...(creation.status !== undefined && { status: creation.status }),
+    ...(creation.output !== undefined && { output: creation.output }),
+    ...(creation.prompt !== undefined && { prompt: creation.prompt }),
+    ...(creation.requestId !== undefined && { requestId: creation.requestId }),
+    ...(creation.model !== undefined && { model: creation.model }),
+  };
+
+  try {
+    await setDoc(docRef, data);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to create creation ${creation.id}: ${errorMessage}`);
+  }
+}

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

@@ -0,0 +1,63 @@
+/**
+ * Creation Delete Operations
+ */
+
+import { updateDoc, deleteDoc } from "firebase/firestore";
+import { type FirestorePathResolver } from "@umituz/react-native-firebase";
+
+/**
+ * Soft deletes a creation
+ */
+export async function deleteCreation(
+  pathResolver: FirestorePathResolver,
+  userId: string,
+  creationId: string
+): Promise<boolean> {
+  const docRef = pathResolver.getDocRef(userId, creationId);
+  if (!docRef) return false;
+
+  try {
+    await updateDoc(docRef, { deletedAt: new Date() });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Hard deletes a creation
+ */
+export async function hardDeleteCreation(
+  pathResolver: FirestorePathResolver,
+  userId: string,
+  creationId: string
+): Promise<boolean> {
+  const docRef = pathResolver.getDocRef(userId, creationId);
+  if (!docRef) return false;
+
+  try {
+    await deleteDoc(docRef);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Restores a soft-deleted creation
+ */
+export async function restoreCreation(
+  pathResolver: FirestorePathResolver,
+  userId: string,
+  creationId: string
+): Promise<boolean> {
+  const docRef = pathResolver.getDocRef(userId, creationId);
+  if (!docRef) return false;
+
+  try {
+    await updateDoc(docRef, { deletedAt: null });
+    return true;
+  } catch {
+    return false;
+  }
+}

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

@@ -0,0 +1,77 @@
+/**
+ * Creation Update Operations
+ */
+
+import { updateDoc } from "firebase/firestore";
+import { type FirestorePathResolver } from "@umituz/react-native-firebase";
+import type { Creation } from "../../domain/entities/Creation";
+import { CREATION_FIELDS, type CreationFieldName } from "../../domain/constants";
+
+declare const __DEV__: boolean;
+
+/**
+ * Updatable fields list
+ */
+export const UPDATABLE_FIELDS: ReadonlyArray<CreationFieldName> = [
+  CREATION_FIELDS.URI,
+  CREATION_FIELDS.STATUS,
+  CREATION_FIELDS.OUTPUT,
+  CREATION_FIELDS.IMAGE_URL,
+  CREATION_FIELDS.VIDEO_URL,
+  CREATION_FIELDS.METADATA,
+  CREATION_FIELDS.IS_SHARED,
+  CREATION_FIELDS.IS_FAVORITE,
+  CREATION_FIELDS.RATING,
+  CREATION_FIELDS.RATED_AT,
+  CREATION_FIELDS.DELETED_AT,
+  CREATION_FIELDS.REQUEST_ID,
+  CREATION_FIELDS.MODEL,
+  CREATION_FIELDS.PROMPT,
+  "type" as CreationFieldName,
+] as const;
+
+/**
+ * Updates a creation document
+ */
+export async function updateCreation(
+  pathResolver: FirestorePathResolver,
+  userId: string,
+  id: string,
+  updates: Partial<Creation>
+): Promise<boolean> {
+  const docRef = pathResolver.getDocRef(userId, id);
+
+  if (!docRef) {
+    throw new Error(
+      `Cannot update: Document not found for user ${userId}, creation ${id}`
+    );
+  }
+
+  const updateData: Record<string, unknown> = {};
+  for (const field of UPDATABLE_FIELDS) {
+    if (updates[field as keyof Creation] !== undefined) {
+      updateData[field] = updates[field as keyof Creation];
+    }
+  }
+
+  if (Object.keys(updateData).length === 0) {
+    if (__DEV__) {
+      console.warn("[updateCreation] No fields to update", { id });
+    }
+    return true;
+  }
+
+  try {
+    await updateDoc(docRef, updateData);
+    if (__DEV__) {
+      console.log("[updateCreation] Updated", {
+        id,
+        fields: Object.keys(updateData),
+      });
+    }
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to update creation ${id}: ${message}`);
+  }
+}

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

@@ -1,213 +1,12 @@
 /**
- * Creation CRUD Operations
- * Core create, read, update, delete operations for creations
+ * Creation CRUD Operations - Barrel Export
+ * Split into modular files for maintainability
  */
 
-import { setDoc, updateDoc, deleteDoc } from "firebase/firestore";
-import { type FirestorePathResolver } from "@umituz/react-native-firebase";
-import type { Creation, CreationDocument } from "../../domain/entities/Creation";
-import { CREATION_FIELDS, isUpdatableField, type CreationFieldName } from "../../domain/constants";
-
-declare const __DEV__: boolean;
-
-/**
- * Updatable fields derived from domain constants
- * Following DDD principle: Single source of truth
- */
-const UPDATABLE_FIELDS: ReadonlyArray<CreationFieldName> = [
-  CREATION_FIELDS.URI,
-  CREATION_FIELDS.STATUS,
-  CREATION_FIELDS.OUTPUT,
-  CREATION_FIELDS.IMAGE_URL,
-  CREATION_FIELDS.VIDEO_URL,
-  CREATION_FIELDS.METADATA,
-  CREATION_FIELDS.IS_SHARED,
-  CREATION_FIELDS.IS_FAVORITE,
-  CREATION_FIELDS.RATING,
-  CREATION_FIELDS.RATED_AT,
-  CREATION_FIELDS.DELETED_AT,
-  CREATION_FIELDS.REQUEST_ID,
-  CREATION_FIELDS.MODEL,
-  CREATION_FIELDS.PROMPT,
-  "type", // Legacy field, keeping for backwards compatibility
-] as const;
-
-/**
- * Creates a new creation document
- */
-export async function createCreation(
-  pathResolver: FirestorePathResolver,
-  userId: string,
-  creation: Creation
-): Promise<void> {
-  const docRef = pathResolver.getDocRef(userId, creation.id);
-  if (!docRef) throw new Error("Firestore not initialized");
-
-  const data: CreationDocument = {
-    type: creation.type,
-    uri: creation.uri,
-    createdAt: creation.createdAt,
-    metadata: creation.metadata || {},
-    isShared: creation.isShared || false,
-    isFavorite: creation.isFavorite || false,
-    ...(creation.status !== undefined && { status: creation.status }),
-    ...(creation.output !== undefined && { output: creation.output }),
-    ...(creation.prompt !== undefined && { prompt: creation.prompt }),
-    ...(creation.requestId !== undefined && { requestId: creation.requestId }),
-    ...(creation.model !== undefined && { model: creation.model }),
-  };
-
-  try {
-    await setDoc(docRef, data);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to create creation ${creation.id}: ${errorMessage}`);
-  }
-}
-
-/**
- * Updates a creation document with comprehensive error handling
- *
- * @param pathResolver - Firestore path resolver
- * @param userId - User ID owning the creation
- * @param id - Creation ID to update
- * @param updates - Partial creation updates
- * @returns Promise resolving to true on success
- * @throws Error with context if update fails
- *
- * @example
- * ```typescript
- * await updateCreation(resolver, "user123", "creation456", {
- *   status: CREATION_STATUS.COMPLETED,
- *   uri: "https://example.com/image.jpg"
- * });
- * ```
- */
-export async function updateCreation(
-  pathResolver: FirestorePathResolver,
-  userId: string,
-  id: string,
-  updates: Partial<Creation>
-): Promise<boolean> {
-  const docRef = pathResolver.getDocRef(userId, id);
-
-  if (!docRef) {
-    const error = new Error(
-      `Cannot update creation: Document reference not found for user ${userId}, creation ${id}`
-    );
-    if (__DEV__) {
-      console.error("[updateCreation] Document reference not found", {
-        userId,
-        creationId: id,
-      });
-    }
-    throw error;
-  }
-
-  try {
-    // Filter to only updatable fields
-    const updateData: Record<string, unknown> = {};
-    for (const field of UPDATABLE_FIELDS) {
-      if (updates[field as keyof Creation] !== undefined) {
-        updateData[field] = updates[field as keyof Creation];
-      }
-    }
-
-    // Validate that we have fields to update
-    if (Object.keys(updateData).length === 0) {
-      if (__DEV__) {
-        console.warn("[updateCreation] No updatable fields provided", {
-          userId,
-          creationId: id,
-          attemptedFields: Object.keys(updates),
-        });
-      }
-      return true; // No-op, but not an error
-    }
-
-    // Perform update
-    await updateDoc(docRef, updateData);
-
-    if (__DEV__) {
-      console.log("[updateCreation] Successfully updated", {
-        creationId: id,
-        fieldsUpdated: Object.keys(updateData),
-      });
-    }
-
-    return true;
-  } catch (error) {
-    const errorContext = {
-      userId,
-      creationId: id,
-      fieldsAttempted: Object.keys(updates),
-      originalError: error instanceof Error ? error.message : String(error),
-    };
-
-    if (__DEV__) {
-      console.error("[updateCreation] Update failed", errorContext);
-    }
-
-    // Wrap with context
-    throw new Error(
-      `Failed to update creation ${id}: ${errorContext.originalError}`
-    );
-  }
-}
-
-/**
- * Soft deletes a creation (marks as deleted)
- */
-export async function deleteCreation(
-  pathResolver: FirestorePathResolver,
-  userId: string,
-  creationId: string
-): Promise<boolean> {
-  const docRef = pathResolver.getDocRef(userId, creationId);
-  if (!docRef) return false;
-
-  try {
-    await updateDoc(docRef, { deletedAt: new Date() });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Hard deletes a creation (removes from database)
- */
-export async function hardDeleteCreation(
-  pathResolver: FirestorePathResolver,
-  userId: string,
-  creationId: string
-): Promise<boolean> {
-  const docRef = pathResolver.getDocRef(userId, creationId);
-  if (!docRef) return false;
-
-  try {
-    await deleteDoc(docRef);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Restores a soft-deleted creation
- */
-export async function restoreCreation(
-  pathResolver: FirestorePathResolver,
-  userId: string,
-  creationId: string
-): Promise<boolean> {
-  const docRef = pathResolver.getDocRef(userId, creationId);
-  if (!docRef) return false;
-
-  try {
-    await updateDoc(docRef, { deletedAt: null });
-    return true;
-  } catch {
-    return false;
-  }
-}
+export { createCreation } from "./creation-create.operations";
+export { updateCreation, UPDATABLE_FIELDS } from "./creation-update.operations";
+export {
+  deleteCreation,
+  hardDeleteCreation,
+  restoreCreation,
+} from "./creation-delete.operations";

package/src/domains/creations/presentation/hooks/creation-persistence.types.ts

@@ -0,0 +1,27 @@
+/**
+ * Creation Persistence Types
+ * Type definitions for persistence hook
+ */
+
+export interface UseCreationPersistenceConfig {
+  readonly type: string;
+  readonly collectionName?: string;
+  readonly creditCost?: number;
+  readonly onCreditDeduct?: (cost: number) => Promise<void | boolean>;
+}
+
+export interface BaseProcessingStartData {
+  readonly creationId: string;
+}
+
+export interface BaseProcessingResult {
+  readonly creationId?: string;
+  readonly imageUrl?: string;
+  readonly videoUrl?: string;
+}
+
+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;
+}

package/src/domains/creations/presentation/hooks/creation-validators.ts

@@ -0,0 +1,102 @@
+/**
+ * Creation Validation Utilities
+ *
+ * Centralized validation logic for creation persistence.
+ * Keeps validation rules separate from hook logic.
+ *
+ * @module CreationValidators
+ */
+
+import {
+  CREATION_VALIDATION,
+  CREATION_STATUS,
+  CREATION_FIELDS,
+} from "../../domain/constants";
+import type { ICreationsRepository } from "../../domain/repositories/ICreationsRepository";
+
+declare const __DEV__: boolean;
+
+export interface ValidationResult {
+  isValid: boolean;
+  error?: string;
+}
+
+/**
+ * Validates that at least one URL is present
+ */
+export function validateHasUrl(
+  imageUrl?: string,
+  videoUrl?: string
+): ValidationResult {
+  if (!imageUrl && !videoUrl) {
+    return {
+      isValid: false,
+      error: "No output URL provided",
+    };
+  }
+  return { isValid: true };
+}
+
+/**
+ * Validates URI protocol
+ */
+export function validateUriProtocol(uri: string): ValidationResult {
+  const hasValidProtocol = CREATION_VALIDATION.VALID_URI_PROTOCOLS.some(
+    (protocol) => uri.startsWith(protocol)
+  );
+
+  if (!hasValidProtocol) {
+    return {
+      isValid: false,
+      error: `Invalid URI protocol. Expected one of: ${CREATION_VALIDATION.VALID_URI_PROTOCOLS.join(", ")}`,
+    };
+  }
+
+  return { isValid: true };
+}
+
+/**
+ * Validates URI length
+ */
+export function validateUriLength(uri: string): ValidationResult {
+  if (uri.length > CREATION_VALIDATION.MAX_URI_LENGTH) {
+    return {
+      isValid: false,
+      error: `URI length (${uri.length}) exceeds maximum (${CREATION_VALIDATION.MAX_URI_LENGTH})`,
+    };
+  }
+
+  return { isValid: true };
+}
+
+/**
+ * Runs all validations and returns first error
+ */
+export function runAllValidations(
+  imageUrl?: string,
+  videoUrl?: string
+): ValidationResult {
+  const urlCheck = validateHasUrl(imageUrl, videoUrl);
+  if (!urlCheck.isValid) return urlCheck;
+
+  const uri = imageUrl || videoUrl || "";
+  const protocolCheck = validateUriProtocol(uri);
+  if (!protocolCheck.isValid) return protocolCheck;
+
+  return validateUriLength(uri);
+}
+
+/**
+ * Marks creation as failed
+ */
+export function markCreationAsFailed(
+  repository: ICreationsRepository,
+  userId: string,
+  creationId: string,
+  error: string
+): void {
+  repository.update(userId, creationId, {
+    [CREATION_FIELDS.STATUS]: CREATION_STATUS.FAILED,
+    [CREATION_FIELDS.METADATA]: { error, failedAt: new Date().toISOString() },
+  });
+}

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

@@ -1,73 +1,36 @@
 /**
  * useCreationPersistence Hook
- * Encapsulates Firestore persistence logic for AI generation features
- * Realtime listener handles UI updates automatically
  */
 
 import { useCallback, useMemo } from "react";
 import { useAuth } from "@umituz/react-native-auth";
 import { createCreationsRepository } from "../../infrastructure/adapters";
 import type { Creation } from "../../domain/entities/Creation";
-import {
-  CREATION_STATUS,
-  CREATION_VALIDATION,
-  CREATION_FIELDS,
-} from "../../domain/constants";
+import { CREATION_STATUS, CREATION_FIELDS } from "../../domain/constants";
+import { runAllValidations, markCreationAsFailed } from "./creation-validators";
+import type {
+  UseCreationPersistenceConfig,
+  UseCreationPersistenceReturn,
+  BaseProcessingStartData,
+  BaseProcessingResult,
+} from "./creation-persistence.types";
 
-declare const __DEV__: boolean;
-
-export interface UseCreationPersistenceConfig {
-  readonly type: string;
-  readonly collectionName?: string;
-  readonly creditCost?: number;
-  readonly onCreditDeduct?: (cost: number) => Promise<void | boolean>;
-}
-
-export interface BaseProcessingStartData {
-  readonly creationId: string;
-}
-
-export interface BaseProcessingResult {
-  readonly creationId?: string;
-  readonly imageUrl?: string;
-  readonly videoUrl?: string;
-}
-
-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;
-}
+export type * from "./creation-persistence.types";
 
 export function useCreationPersistence(
-  config: UseCreationPersistenceConfig,
+  config: UseCreationPersistenceConfig
 ): UseCreationPersistenceReturn {
   const { type, collectionName = "creations", creditCost, onCreditDeduct } = config;
   const { userId } = useAuth();
-
-  const repository = useMemo(
-    () => createCreationsRepository(collectionName),
-    [collectionName],
-  );
+  const repository = useMemo(() => createCreationsRepository(collectionName), [collectionName]);
 
   const onProcessingStart = useCallback(
     <T extends BaseProcessingStartData>(data: T) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[useCreationPersistence] onProcessingStart", { type, userId });
-      }
-
-      if (!userId) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[useCreationPersistence] No userId, skipping");
-        }
-        return;
-      }
-
+      if (!userId) return;
       const { creationId, ...rest } = data;
       const cleanMetadata = Object.fromEntries(
-        Object.entries(rest).filter(([, v]) => v !== undefined && v !== null),
+        Object.entries(rest).filter(([, v]) => v !== undefined && v !== null)
       );
-
       const creation: Creation = {
         id: creationId,
         uri: "",
@@ -78,199 +41,49 @@ export function useCreationPersistence(
         isFavorite: false,
         metadata: cleanMetadata,
       };
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[useCreationPersistence] Creating document", { creationId, type });
-      }
-
       repository.create(userId, creation);
     },
-    [userId, repository, type],
+    [userId, repository, type]
   );
 
-  /**
-   * Handles generation completion with comprehensive validation
-   *
-   * VALIDATION RULES:
-   * 1. At least one URL (imageUrl or videoUrl) must be present
-   * 2. URI must start with valid protocol (http/https/data:)
-   * 3. URI length must not exceed limit
-   *
-   * If validation fails, marks creation as FAILED instead of silently succeeding
-   */
   const onProcessingComplete = useCallback(
     <T extends BaseProcessingResult>(result: T) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[useCreationPersistence] onProcessingComplete", {
-          creationId: result.creationId,
-          hasImageUrl: !!result.imageUrl,
-          hasVideoUrl: !!result.videoUrl,
-        });
-      }
-
-      // Validation: User ID and Creation ID
-      if (!userId || !result.creationId) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.warn("[useCreationPersistence] Missing required fields", {
-            hasUserId: !!userId,
-            hasCreationId: !!result.creationId,
-          });
-        }
-        return;
-      }
-
-      // Validation: At least one URL must be present
-      if (!result.imageUrl && !result.videoUrl) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error("[useCreationPersistence] No output URL provided", {
-            creationId: result.creationId,
-          });
-        }
+      if (!userId || !result.creationId) return;
 
-        // Mark as failed instead of silently succeeding
-        repository.update(userId, result.creationId, {
-          [CREATION_FIELDS.STATUS]: CREATION_STATUS.FAILED,
-          [CREATION_FIELDS.METADATA]: {
-            error: "No output URL provided",
-            failedAt: new Date().toISOString(),
-          },
-        });
+      const validation = runAllValidations(result.imageUrl, result.videoUrl);
+      if (!validation.isValid) {
+        markCreationAsFailed(repository, userId, result.creationId, validation.error!);
         return;
       }
 
       const uri = result.imageUrl || result.videoUrl || "";
-
-      // Validation: URI format
-      const hasValidProtocol = CREATION_VALIDATION.VALID_URI_PROTOCOLS.some((protocol) =>
-        uri.startsWith(protocol)
-      );
-
-      if (!hasValidProtocol) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error("[useCreationPersistence] Invalid URI protocol", {
-            creationId: result.creationId,
-            uri: uri.substring(0, 50) + "...",
-            validProtocols: CREATION_VALIDATION.VALID_URI_PROTOCOLS,
-          });
-        }
-
-        // Mark as failed
-        repository.update(userId, result.creationId, {
-          [CREATION_FIELDS.STATUS]: CREATION_STATUS.FAILED,
-          [CREATION_FIELDS.METADATA]: {
-            error: `Invalid URI protocol. Expected one of: ${CREATION_VALIDATION.VALID_URI_PROTOCOLS.join(", ")}`,
-            failedAt: new Date().toISOString(),
-          },
-        });
-        return;
-      }
-
-      // Validation: URI length
-      if (uri.length > CREATION_VALIDATION.MAX_URI_LENGTH) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error("[useCreationPersistence] URI exceeds maximum length", {
-            creationId: result.creationId,
-            uriLength: uri.length,
-            maxLength: CREATION_VALIDATION.MAX_URI_LENGTH,
-          });
-        }
-
-        // Mark as failed
-        repository.update(userId, result.creationId, {
-          [CREATION_FIELDS.STATUS]: CREATION_STATUS.FAILED,
-          [CREATION_FIELDS.METADATA]: {
-            error: `URI length (${uri.length}) exceeds maximum (${CREATION_VALIDATION.MAX_URI_LENGTH})`,
-            failedAt: new Date().toISOString(),
-          },
-        });
-        return;
-      }
-
-      // Create output object
-      const output = result.imageUrl
-        ? { imageUrl: result.imageUrl }
-        : result.videoUrl
-          ? { videoUrl: result.videoUrl }
-          : undefined;
-
-      // Update with both nested (output) and flat (imageUrl/videoUrl) fields
-      // This ensures compatibility with different document mappers
-      const updates: Record<string, unknown> = {
+      repository.update(userId, result.creationId, {
         [CREATION_FIELDS.URI]: uri,
         [CREATION_FIELDS.STATUS]: CREATION_STATUS.COMPLETED,
-        [CREATION_FIELDS.OUTPUT]: output,
-      };
-
-      // Add flat fields for backwards compatibility
-      if (result.imageUrl) {
-        updates[CREATION_FIELDS.IMAGE_URL] = result.imageUrl;
-      }
-      if (result.videoUrl) {
-        updates[CREATION_FIELDS.VIDEO_URL] = result.videoUrl;
-      }
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[useCreationPersistence] Updating creation", {
-          creationId: result.creationId,
-          fieldsUpdating: Object.keys(updates),
-          uriLength: uri.length,
-        });
-      }
-
-      repository.update(userId, result.creationId, updates);
+        [CREATION_FIELDS.OUTPUT]: result.imageUrl
+          ? { imageUrl: result.imageUrl }
+          : { videoUrl: result.videoUrl },
+        ...(result.imageUrl && { [CREATION_FIELDS.IMAGE_URL]: result.imageUrl }),
+        ...(result.videoUrl && { [CREATION_FIELDS.VIDEO_URL]: result.videoUrl }),
+      });
 
-      // Credit deduction
-      if (creditCost && creditCost > 0 && onCreditDeduct) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[useCreationPersistence] Deducting credits", { cost: creditCost });
-        }
-        onCreditDeduct(creditCost).catch((err) => {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error("[useCreationPersistence] Credit deduction failed", err);
-          }
-        });
+      if (creditCost && onCreditDeduct) {
+        onCreditDeduct(creditCost).catch(() => {});
       }
     },
-    [userId, repository, creditCost, onCreditDeduct],
+    [userId, repository, creditCost, onCreditDeduct]
   );
 
-  /**
-   * Handles generation errors
-   * Marks creation as FAILED with error context
-   */
   const onError = useCallback(
     (error: string, creationId?: string) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.error("[useCreationPersistence] Generation error", {
-          error,
-          creationId,
-          timestamp: new Date().toISOString(),
-        });
-      }
-
-      if (!userId || !creationId) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.warn("[useCreationPersistence] Cannot mark error - missing required fields", {
-            hasUserId: !!userId,
-            hasCreationId: !!creationId,
-          });
-        }
-        return;
-      }
-
-      repository.update(userId, creationId, {
-        [CREATION_FIELDS.STATUS]: CREATION_STATUS.FAILED,
-        [CREATION_FIELDS.METADATA]: {
-          error,
-          failedAt: new Date().toISOString(),
-        },
-      });
+      if (!userId || !creationId) return;
+      markCreationAsFailed(repository, userId, creationId, error);
     },
-    [userId, repository],
+    [userId, repository]
   );
 
   return useMemo(
     () => ({ onProcessingStart, onProcessingComplete, onError }),
-    [onProcessingStart, onProcessingComplete, onError],
+    [onProcessingStart, onProcessingComplete, onError]
   );
 }