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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.63.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/domain/constants/creation-errors.constants.ts

@@ -0,0 +1,27 @@
+/**
+ * Creation Error Codes
+ *
+ * Domain exception codes for client-side error handling.
+ * Each code represents a specific error scenario.
+ *
+ * @module CreationErrorsConstants
+ */
+
+/**
+ * Error codes for domain exceptions
+ */
+export const CREATION_ERROR_CODES = {
+  NOT_FOUND: "CREATION_NOT_FOUND" as const,
+  VALIDATION_FAILED: "CREATION_VALIDATION_FAILED" as const,
+  INVALID_STATE_TRANSITION: "CREATION_INVALID_STATE_TRANSITION" as const,
+  PERSISTENCE_FAILED: "CREATION_PERSISTENCE_FAILED" as const,
+  INVALID_URI: "CREATION_INVALID_URI" as const,
+  INVALID_OUTPUT: "CREATION_INVALID_OUTPUT" as const,
+} as const;
+
+/** Union type of all error codes */
+export type CreationErrorCode =
+  typeof CREATION_ERROR_CODES[keyof typeof CREATION_ERROR_CODES];
+
+// Freeze to prevent mutations
+Object.freeze(CREATION_ERROR_CODES);

package/src/domains/creations/domain/constants/creation-fields.constants.ts

@@ -0,0 +1,85 @@
+/**
+ * Creation Field Names
+ *
+ * Central registry of all Firestore document field names.
+ * Prevents magic strings throughout the codebase.
+ *
+ * @module CreationFieldsConstants
+ */
+
+/**
+ * Firestore document field names
+ * Single source of truth for field naming
+ */
+export const CREATION_FIELDS = {
+  // Core identification
+  ID: "id" as const,
+  TYPE: "type" as const,
+
+  // Media URLs
+  URI: "uri" as const,
+  IMAGE_URL: "imageUrl" as const,
+  VIDEO_URL: "videoUrl" as const,
+  ORIGINAL_URI: "originalUri" as const,
+
+  // Structured output
+  OUTPUT: "output" as const,
+
+  // Status and metadata
+  STATUS: "status" as const,
+  METADATA: "metadata" as const,
+  PROMPT: "prompt" as const,
+
+  // Timestamps
+  CREATED_AT: "createdAt" as const,
+  UPDATED_AT: "updatedAt" as const,
+  DELETED_AT: "deletedAt" as const,
+  RATED_AT: "ratedAt" as const,
+
+  // User interactions
+  IS_FAVORITE: "isFavorite" as const,
+  IS_SHARED: "isShared" as const,
+  RATING: "rating" as const,
+
+  // AI provider metadata
+  REQUEST_ID: "requestId" as const,
+  MODEL: "model" as const,
+} as const;
+
+/** Union type of all field names */
+export type CreationFieldName =
+  typeof CREATION_FIELDS[keyof typeof CREATION_FIELDS];
+
+/**
+ * Updatable fields list
+ * Fields that can be modified after creation
+ */
+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,
+] as const;
+
+/**
+ * Type guard for updatable fields
+ */
+export function isUpdatableField(
+  field: string
+): field is CreationFieldName {
+  return UPDATABLE_FIELDS.includes(field as CreationFieldName);
+}
+
+// Freeze to prevent mutations
+Object.freeze(CREATION_FIELDS);
+Object.freeze(UPDATABLE_FIELDS);

package/src/domains/creations/domain/constants/creation-query.constants.ts

@@ -0,0 +1,37 @@
+/**
+ * Creation Query Configuration
+ *
+ * Firestore query optimization settings.
+ * Controls pagination, caching, and performance.
+ *
+ * @module CreationQueryConstants
+ */
+
+/**
+ * Firestore query configuration
+ */
+export const CREATION_QUERY_CONFIG = {
+  /** Default page size for pagination */
+  DEFAULT_PAGE_SIZE: 20,
+
+  /** Maximum page size (prevent memory issues) */
+  MAX_PAGE_SIZE: 100,
+
+  /** Cache TTL in milliseconds (5 minutes) */
+  CACHE_TTL_MS: 5 * 60 * 1000,
+
+  /** Include metadata changes in snapshots */
+  INCLUDE_METADATA_CHANGES: false,
+} as const;
+
+/**
+ * Collection names
+ */
+export const CREATION_COLLECTIONS = {
+  ROOT: "creations" as const,
+  USERS: "users" as const,
+} as const;
+
+// Freeze to prevent mutations
+Object.freeze(CREATION_QUERY_CONFIG);
+Object.freeze(CREATION_COLLECTIONS);

package/src/domains/creations/domain/constants/creation-status.constants.ts

@@ -0,0 +1,46 @@
+/**
+ * Creation Status Constants
+ *
+ * Defines the lifecycle states of a creation.
+ * Follows state machine pattern for valid transitions.
+ *
+ * @module CreationStatusConstants
+ */
+
+/**
+ * Creation lifecycle status values
+ * Represents the aggregate root's state machine
+ */
+export const CREATION_STATUS = {
+  /** Initial state: AI generation in progress */
+  PROCESSING: "processing" as const,
+
+  /** Success state: Generation completed with result */
+  COMPLETED: "completed" as const,
+
+  /** Error state: Generation failed */
+  FAILED: "failed" as const,
+} as const;
+
+/** Union type of all valid status values */
+export type CreationStatusValue =
+  typeof CREATION_STATUS[keyof typeof CREATION_STATUS];
+
+/**
+ * Type guard for creation status values
+ * @param value - Value to check
+ * @returns True if value is a valid creation status
+ */
+export function isCreationStatus(
+  value: unknown
+): value is CreationStatusValue {
+  return (
+    typeof value === "string" &&
+    Object.values(CREATION_STATUS).includes(
+      value as CreationStatusValue
+    )
+  );
+}
+
+// Freeze to prevent mutations
+Object.freeze(CREATION_STATUS);

package/src/domains/creations/domain/constants/creation-types.constants.ts

@@ -0,0 +1,45 @@
+/**
+ * Creation Type Discriminators
+ *
+ * Used for polymorphic behavior based on creation type.
+ * Each type may have different metadata structure.
+ *
+ * @module CreationTypesConstants
+ */
+
+/**
+ * Creation type discriminators
+ */
+export const CREATION_TYPES = {
+  /** Baby face prediction generation */
+  BABY_PREDICTION: "baby-prediction" as const,
+
+  /** Text-to-video generation */
+  TEXT_TO_VIDEO: "text-to-video" as const,
+
+  /** Image generation */
+  IMAGE_GENERATION: "image-generation" as const,
+} as const;
+
+/** Union type of all creation types */
+export type CreationTypeValue =
+  typeof CREATION_TYPES[keyof typeof CREATION_TYPES];
+
+/**
+ * Type guard for creation type values
+ * @param value - Value to check
+ * @returns True if value is a valid creation type
+ */
+export function isCreationType(
+  value: unknown
+): value is CreationTypeValue {
+  return (
+    typeof value === "string" &&
+    Object.values(CREATION_TYPES).includes(
+      value as CreationTypeValue
+    )
+  );
+}
+
+// Freeze to prevent mutations
+Object.freeze(CREATION_TYPES);

package/src/domains/creations/domain/constants/creation-validation.constants.ts

@@ -0,0 +1,60 @@
+/**
+ * Creation Validation Rules
+ *
+ * Business invariants and constraints enforced at domain boundaries.
+ * All validation rules centralized here for consistency.
+ *
+ * @module CreationValidationConstants
+ */
+
+/**
+ * Validation rules and constraints
+ */
+export const CREATION_VALIDATION = {
+  /** Maximum URI length (Firestore: 1MB, reasonable: 2KB) */
+  MAX_URI_LENGTH: 2048,
+
+  /** Maximum metadata size in bytes (JSON stringified) */
+  MAX_METADATA_SIZE: 10240, // 10KB
+
+  /** Rating constraints (1-5 stars) */
+  MIN_RATING: 1,
+  MAX_RATING: 5,
+
+  /** Prompt length constraints */
+  MIN_PROMPT_LENGTH: 1,
+  MAX_PROMPT_LENGTH: 500,
+
+  /** Valid URI protocols */
+  VALID_URI_PROTOCOLS: ["http:", "https:", "data:"] as const,
+
+  /** Valid image MIME types */
+  VALID_IMAGE_MIMES: [
+    "image/jpeg",
+    "image/png",
+    "image/webp",
+    "image/gif",
+  ] as const,
+
+  /** Valid video MIME types */
+  VALID_VIDEO_MIMES: [
+    "video/mp4",
+    "video/webm",
+    "video/quicktime",
+  ] as const,
+} as const;
+
+/** Union type of valid URI protocols */
+export type ValidUriProtocol =
+  typeof CREATION_VALIDATION.VALID_URI_PROTOCOLS[number];
+
+/** Union type of valid image MIME types */
+export type ValidImageMime =
+  typeof CREATION_VALIDATION.VALID_IMAGE_MIMES[number];
+
+/** Union type of valid video MIME types */
+export type ValidVideoMime =
+  typeof CREATION_VALIDATION.VALID_VIDEO_MIMES[number];
+
+// Freeze to prevent mutations
+Object.freeze(CREATION_VALIDATION);

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

@@ -1,5 +1,24 @@
 /**
- * Creation Domain Constants Exports
+ * Creation Domain Constants - Modular Exports
+ *
+ * All constants follow 100-line rule for maintainability.
+ * Each module has single responsibility.
  */
 
-export * from "./creation.constants";
+// Status constants (40 lines)
+export * from "./creation-status.constants";
+
+// Field name constants (70 lines)
+export * from "./creation-fields.constants";
+
+// Validation rule constants (60 lines)
+export * from "./creation-validation.constants";
+
+// Type discriminator constants (45 lines)
+export * from "./creation-types.constants";
+
+// Error code constants (35 lines)
+export * from "./creation-errors.constants";
+
+// Query & collection constants (40 lines)
+export * from "./creation-query.constants";

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

@@ -3,7 +3,7 @@ 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/creation.constants";
+import { CREATION_FIELDS } from "../../domain/constants";
 
 declare const __DEV__: boolean;
 

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

@@ -6,7 +6,7 @@
 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/creation.constants";
+import { CREATION_FIELDS, isUpdatableField, type CreationFieldName } from "../../domain/constants";
 
 declare const __DEV__: boolean;
 

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/creation.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]
   );
 }

package/src/domains/creations/domain/constants/creation.constants.ts

@@ -1,251 +0,0 @@
-/**
- * Creation Domain Constants
- *
- * Single source of truth for all creation-related constants.
- * Following DDD principles, these constants define the ubiquitous language
- * of the Creations bounded context.
- *
- * @module CreationConstants
- * @category Domain
- * @see {@link https://martinfowler.com/bliki/UbiquitousLanguage.html}
- */
-
-/**
- * Creation lifecycle status values
- * Represents the aggregate root's state machine transitions
- */
-export const CREATION_STATUS = {
-  /** Initial state: AI generation in progress */
-  PROCESSING: "processing" as const,
-  /** Success state: Generation completed with result */
-  COMPLETED: "completed" as const,
-  /** Error state: Generation failed */
-  FAILED: "failed" as const,
-} as const;
-
-/**
- * Creation type discriminators
- * Used for polymorphic behavior based on creation type
- */
-export const CREATION_TYPES = {
-  BABY_PREDICTION: "baby-prediction" as const,
-  TEXT_TO_VIDEO: "text-to-video" as const,
-  IMAGE_GENERATION: "image-generation" as const,
-} as const;
-
-/**
- * Firestore document field names
- * Central registry preventing magic strings throughout codebase
- */
-export const CREATION_FIELDS = {
-  // Core identification
-  ID: "id" as const,
-  TYPE: "type" as const,
-
-  // Media URLs
-  URI: "uri" as const,
-  IMAGE_URL: "imageUrl" as const,
-  VIDEO_URL: "videoUrl" as const,
-  ORIGINAL_URI: "originalUri" as const,
-
-  // Structured output (new format)
-  OUTPUT: "output" as const,
-
-  // Status and metadata
-  STATUS: "status" as const,
-  METADATA: "metadata" as const,
-  PROMPT: "prompt" as const,
-
-  // Timestamps
-  CREATED_AT: "createdAt" as const,
-  UPDATED_AT: "updatedAt" as const,
-  DELETED_AT: "deletedAt" as const,
-  RATED_AT: "ratedAt" as const,
-
-  // User interactions
-  IS_FAVORITE: "isFavorite" as const,
-  IS_SHARED: "isShared" as const,
-  RATING: "rating" as const,
-
-  // AI provider metadata
-  REQUEST_ID: "requestId" as const,
-  MODEL: "model" as const,
-} as const;
-
-/**
- * Validation rules and constraints
- * Business invariants enforced at domain boundaries
- */
-export const CREATION_VALIDATION = {
-  /** Maximum allowed URI length (Firestore limit: 1MB, reasonable: 2KB) */
-  MAX_URI_LENGTH: 2048,
-
-  /** Maximum metadata size in bytes (JSON stringified) */
-  MAX_METADATA_SIZE: 10240, // 10KB
-
-  /** Rating constraints (1-5 stars) */
-  MIN_RATING: 1,
-  MAX_RATING: 5,
-
-  /** Prompt length constraints */
-  MIN_PROMPT_LENGTH: 1,
-  MAX_PROMPT_LENGTH: 500,
-
-  /** Valid URI protocols */
-  VALID_URI_PROTOCOLS: ["http:", "https:", "data:"] as const,
-
-  /** Valid image MIME types for data URIs */
-  VALID_IMAGE_MIMES: ["image/jpeg", "image/png", "image/webp", "image/gif"] as const,
-
-  /** Valid video MIME types for data URIs */
-  VALID_VIDEO_MIMES: ["video/mp4", "video/webm", "video/quicktime"] as const,
-} as const;
-
-/**
- * Firestore query configuration
- * Optimization settings for efficient queries
- */
-export const CREATION_QUERY_CONFIG = {
-  /** Default page size for pagination */
-  DEFAULT_PAGE_SIZE: 20,
-
-  /** Maximum page size to prevent memory issues */
-  MAX_PAGE_SIZE: 100,
-
-  /** Cache TTL in milliseconds (5 minutes) */
-  CACHE_TTL_MS: 5 * 60 * 1000,
-
-  /** Whether to include metadata changes in snapshots */
-  INCLUDE_METADATA_CHANGES: false,
-} as const;
-
-/**
- * Error codes for domain exceptions
- * Enables client-side error handling logic
- */
-export const CREATION_ERROR_CODES = {
-  NOT_FOUND: "CREATION_NOT_FOUND" as const,
-  VALIDATION_FAILED: "CREATION_VALIDATION_FAILED" as const,
-  INVALID_STATE_TRANSITION: "CREATION_INVALID_STATE_TRANSITION" as const,
-  PERSISTENCE_FAILED: "CREATION_PERSISTENCE_FAILED" as const,
-  INVALID_URI: "CREATION_INVALID_URI" as const,
-  INVALID_OUTPUT: "CREATION_INVALID_OUTPUT" as const,
-} as const;
-
-/**
- * Collection and subcollection names
- */
-export const CREATION_COLLECTIONS = {
-  ROOT: "creations" as const,
-  USERS: "users" as const,
-} as const;
-
-// ============================================================================
-// TYPE EXPORTS - Derived from constants for type safety
-// ============================================================================
-
-/** Union type of all valid status values */
-export type CreationStatusValue = typeof CREATION_STATUS[keyof typeof CREATION_STATUS];
-
-/** Union type of all valid creation types */
-export type CreationTypeValue = typeof CREATION_TYPES[keyof typeof CREATION_TYPES];
-
-/** Union type of all valid field names */
-export type CreationFieldName = typeof CREATION_FIELDS[keyof typeof CREATION_FIELDS];
-
-/** Union type of all valid error codes */
-export type CreationErrorCode = typeof CREATION_ERROR_CODES[keyof typeof CREATION_ERROR_CODES];
-
-/** Union type of all valid URI protocols */
-export type ValidUriProtocol = typeof CREATION_VALIDATION.VALID_URI_PROTOCOLS[number];
-
-/** Union type of all valid image MIME types */
-export type ValidImageMime = typeof CREATION_VALIDATION.VALID_IMAGE_MIMES[number];
-
-/** Union type of all valid video MIME types */
-export type ValidVideoMime = typeof CREATION_VALIDATION.VALID_VIDEO_MIMES[number];
-
-// ============================================================================
-// UTILITY TYPE GUARDS
-// ============================================================================
-
-/**
- * Type guard for creation status values
- * @param value - Value to check
- * @returns True if value is a valid creation status
- */
-export function isCreationStatus(value: unknown): value is CreationStatusValue {
-  return (
-    typeof value === "string" &&
-    Object.values(CREATION_STATUS).includes(value as CreationStatusValue)
-  );
-}
-
-/**
- * Type guard for creation type values
- * @param value - Value to check
- * @returns True if value is a valid creation type
- */
-export function isCreationType(value: unknown): value is CreationTypeValue {
-  return (
-    typeof value === "string" &&
-    Object.values(CREATION_TYPES).includes(value as CreationTypeValue)
-  );
-}
-
-/**
- * Type guard for updatable field names
- * @param field - Field name to check
- * @returns True if field is allowed to be updated
- */
-export function isUpdatableField(field: string): field is CreationFieldName {
-  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,
-  ];
-
-  return UPDATABLE_FIELDS.includes(field as CreationFieldName);
-}
-
-// ============================================================================
-// COMPOSITE OBJECTS - Grouped constants for common use cases
-// ============================================================================
-
-/**
- * All creation-related constants grouped for convenience
- * Use this for imports when you need multiple constant groups
- */
-export const CREATION_CONSTANTS = {
-  STATUS: CREATION_STATUS,
-  TYPES: CREATION_TYPES,
-  FIELDS: CREATION_FIELDS,
-  VALIDATION: CREATION_VALIDATION,
-  QUERY_CONFIG: CREATION_QUERY_CONFIG,
-  ERROR_CODES: CREATION_ERROR_CODES,
-  COLLECTIONS: CREATION_COLLECTIONS,
-} as const;
-
-/**
- * Freeze constants to prevent accidental modification
- * This is a runtime safeguard in addition to TypeScript's readonly
- */
-Object.freeze(CREATION_STATUS);
-Object.freeze(CREATION_TYPES);
-Object.freeze(CREATION_FIELDS);
-Object.freeze(CREATION_VALIDATION);
-Object.freeze(CREATION_QUERY_CONFIG);
-Object.freeze(CREATION_ERROR_CODES);
-Object.freeze(CREATION_COLLECTIONS);
-Object.freeze(CREATION_CONSTANTS);