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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.64.0",
+  "version": "1.65.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/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]
   );
 }