@umituz/react-native-ai-generation-content 1.82.9 → 1.83.1

package/package.json

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

@@ -32,18 +32,20 @@ export const CREATION_FIELDS = {
 
   // Timestamps
   CREATED_AT: "createdAt" as const,
+  STARTED_AT: "startedAt" as const,
   UPDATED_AT: "updatedAt" as const,
   DELETED_AT: "deletedAt" as const,
   RATED_AT: "ratedAt" as const,
+  COMPLETED_AT: "completedAt" as const,
+
+  // Duration (ms elapsed from startedAt to completedAt)
+  DURATION_MS: "durationMs" as const,
 
   // User interactions
   IS_FAVORITE: "isFavorite" as const,
   IS_SHARED: "isShared" as const,
   RATING: "rating" as const,
 
-  // Completion timestamp
-  COMPLETED_AT: "completedAt" as const,
-
   // AI provider metadata
   REQUEST_ID: "requestId" as const,
   MODEL: "model" as const,
@@ -73,6 +75,8 @@ export const UPDATABLE_FIELDS: ReadonlyArray<CreationFieldName> = [
   CREATION_FIELDS.MODEL,
   CREATION_FIELDS.PROMPT,
   CREATION_FIELDS.COMPLETED_AT,
+  CREATION_FIELDS.STARTED_AT,
+  CREATION_FIELDS.DURATION_MS,
 ] as const;
 
 /**

package/src/domains/creations/domain/entities/Creation.ts

@@ -39,11 +39,17 @@ export interface Creation {
   readonly requestId?: string;
   readonly model?: string;
   // Timestamps
-  readonly completedAt?: Date;
+  readonly startedAt?: Date;    // When generation was submitted to the queue
+  readonly completedAt?: Date;  // When generation finished (success or failure)
+  readonly durationMs?: number; // Elapsed ms from startedAt to completedAt
   // Soft delete - if set, the creation is considered deleted
   readonly deletedAt?: Date;
 }
 
+interface FirebaseTimestamp {
+  toDate: () => Date;
+}
+
 export interface CreationDocument {
   readonly uri?: string;
   readonly prompt?: string;
@@ -61,30 +67,30 @@ export interface CreationDocument {
   readonly rating?: number;
   readonly ratedAt?: FirebaseTimestamp | Date | null;
   readonly createdAt: FirebaseTimestamp | Date;
+  readonly startedAt?: FirebaseTimestamp | Date | null;
   readonly completedAt?: FirebaseTimestamp | Date | null;
   readonly deletedAt?: FirebaseTimestamp | Date | null;
   readonly updatedAt?: FirebaseTimestamp | Date | null;
+  readonly durationMs?: number;
   // Background job tracking
   readonly requestId?: string;
   readonly model?: string;
 }
 
-interface FirebaseTimestamp {
-  toDate: () => Date;
+function toDate(value: FirebaseTimestamp | Date | null | undefined): Date | undefined {
+  if (!value) return undefined;
+  if (value instanceof Date) return value;
+  if (typeof value === "object" && "toDate" in value && typeof (value as FirebaseTimestamp).toDate === "function") {
+    return (value as FirebaseTimestamp).toDate();
+  }
+  return undefined;
 }
 
 export function mapDocumentToCreation(
   id: string,
   data: CreationDocument,
 ): Creation {
-  let creationDate: Date;
-  if (data.createdAt instanceof Date) {
-    creationDate = data.createdAt;
-  } else if (data.createdAt && typeof data.createdAt === "object" && "toDate" in data.createdAt && typeof data.createdAt.toDate === "function") {
-    creationDate = data.createdAt.toDate();
-  } else {
-    creationDate = new Date();
-  }
+  const creationDate = toDate(data.createdAt) ?? new Date();
 
   // Get URI from output or direct fields
   const uri = data.output?.imageUrl ||
@@ -94,27 +100,6 @@ export function mapDocumentToCreation(
               data.uri ||
               "";
 
-  let ratedAtDate: Date | undefined;
-  if (data.ratedAt instanceof Date) {
-    ratedAtDate = data.ratedAt;
-  } else if (data.ratedAt && typeof data.ratedAt === "object" && "toDate" in data.ratedAt && typeof data.ratedAt.toDate === "function") {
-    ratedAtDate = data.ratedAt.toDate();
-  }
-
-  let deletedAtDate: Date | undefined;
-  if (data.deletedAt instanceof Date) {
-    deletedAtDate = data.deletedAt;
-  } else if (data.deletedAt && typeof data.deletedAt === "object" && "toDate" in data.deletedAt && typeof data.deletedAt.toDate === "function") {
-    deletedAtDate = data.deletedAt.toDate();
-  }
-
-  let completedAtDate: Date | undefined;
-  if (data.completedAt instanceof Date) {
-    completedAtDate = data.completedAt;
-  } else if (data.completedAt && typeof data.completedAt === "object" && "toDate" in data.completedAt && typeof data.completedAt.toDate === "function") {
-    completedAtDate = data.completedAt.toDate();
-  }
-
   return {
     id,
     uri,
@@ -126,12 +111,14 @@ export function mapDocumentToCreation(
     isShared: data.isShared ?? false,
     isFavorite: data.isFavorite ?? false,
     rating: data.rating,
-    ratedAt: ratedAtDate,
+    ratedAt: toDate(data.ratedAt),
     status: data.status as CreationStatus | undefined,
     output: data.output ?? undefined,
     requestId: data.requestId,
     model: data.model,
-    completedAt: completedAtDate,
-    deletedAt: deletedAtDate,
+    startedAt: toDate(data.startedAt),
+    completedAt: toDate(data.completedAt),
+    durationMs: data.durationMs,
+    deletedAt: toDate(data.deletedAt),
   };
 }

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

@@ -27,6 +27,7 @@ export async function createCreation(
     ...(creation.prompt !== undefined && { prompt: creation.prompt }),
     ...(creation.requestId !== undefined && { requestId: creation.requestId }),
     ...(creation.model !== undefined && { model: creation.model }),
+    ...(creation.startedAt !== undefined && { startedAt: creation.startedAt }),
   };
 
   try {

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

@@ -5,27 +5,11 @@
 import { updateDoc } from "firebase/firestore";
 import type { IPathResolver } from "@umituz/react-native-firebase";
 import type { Creation } from "../../domain/entities/Creation";
-import { CREATION_FIELDS, type CreationFieldName } from "../../domain/constants";
+import { UPDATABLE_FIELDS } from "../../domain/constants";
 
 declare const __DEV__: boolean;
 
-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;
+export { UPDATABLE_FIELDS };
 
 export async function updateCreation(
   pathResolver: IPathResolver,

package/src/domains/generation/wizard/infrastructure/utils/creation-persistence.types.ts

@@ -26,4 +26,6 @@ export interface CompletedCreationData {
   readonly imageUrl?: string;
   readonly videoUrl?: string;
   readonly thumbnailUrl?: string;
+  /** Unix timestamp (ms) when generation was submitted; used to compute durationMs */
+  readonly generationStartedAt?: number;
 }

package/src/domains/generation/wizard/infrastructure/utils/creation-save-operations.ts

@@ -16,9 +16,11 @@ export async function saveAsProcessing(
   repository: ICreationsRepository,
   userId: string,
   data: ProcessingCreationData
-): Promise<string> {
+): Promise<{ creationId: string; startedAt: Date }> {
   const creationId = `${data.scenarioId}_${Date.now()}`;
 
+  const startedAt = new Date();
+
   await repository.create(userId, {
     id: creationId,
     uri: "",
@@ -26,6 +28,7 @@ export async function saveAsProcessing(
     prompt: data.prompt,
     status: "processing" as const,
     createdAt: new Date(),
+    startedAt,
     isShared: false,
     isFavorite: false,
     requestId: data.requestId,
@@ -39,7 +42,6 @@ export async function saveAsProcessing(
       ...(data.aspectRatio && { aspectRatio: data.aspectRatio }),
       ...(data.provider && { provider: data.provider }),
       ...(data.outputType && { outputType: data.outputType }),
-      startedAt: new Date().toISOString(),
     },
   });
 
@@ -51,5 +53,5 @@ export async function saveAsProcessing(
     });
   }
 
-  return creationId;
+  return { creationId, startedAt };
 }

package/src/domains/generation/wizard/infrastructure/utils/creation-update-operations.ts

@@ -22,11 +22,18 @@ export async function updateToCompleted(
   if (data.videoUrl) output.videoUrl = data.videoUrl;
   if (data.thumbnailUrl) output.thumbnailUrl = data.thumbnailUrl;
 
+  const completedAt = new Date();
+  const durationMs =
+    data.generationStartedAt !== undefined
+      ? completedAt.getTime() - data.generationStartedAt
+      : undefined;
+
   await repository.update(userId, creationId, {
     uri: data.uri,
     status: "completed" as const,
     output,
-    completedAt: new Date(),
+    completedAt,
+    ...(durationMs !== undefined && { durationMs }),
   } as Partial<import("../../../../creations/domain/entities/Creation").Creation>);
 
   if (typeof __DEV__ !== "undefined" && __DEV__) {

package/src/domains/generation/wizard/presentation/hooks/useVideoQueueGeneration.ts

@@ -6,7 +6,10 @@ import { useEffect, useRef, useCallback, useState } from "react";
 
 declare const __DEV__: boolean;
 import { pollQueueStatus } from "./videoQueuePoller";
-import { DEFAULT_POLL_INTERVAL_MS } from "../../../../../infrastructure/constants/polling.constants";
+import {
+  DEFAULT_POLL_INTERVAL_MS,
+  DEFAULT_MAX_POLL_TIME_MS,
+} from "../../../../../infrastructure/constants/polling.constants";
 import type { GenerationUrls } from "./generation-result.utils";
 import type {
   UseVideoQueueGenerationProps,
@@ -23,6 +26,7 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
   const isGeneratingRef = useRef(false);
   const isPollingRef = useRef(false);
   const consecutiveErrorsRef = useRef(0);
+  const pollStartTimeRef = useRef<number | null>(null);
   const [isGenerating, setIsGenerating] = useState(false);
 
   const clearPolling = useCallback(() => {
@@ -38,6 +42,7 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
       isGeneratingRef.current = false;
       isPollingRef.current = false;
       consecutiveErrorsRef.current = 0;
+      pollStartTimeRef.current = null;
       creationIdRef.current = null;
       requestIdRef.current = null;
       modelRef.current = null;
@@ -53,12 +58,12 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
     isGeneratingRef.current = false;
     isPollingRef.current = false;
     consecutiveErrorsRef.current = 0;
+    pollStartTimeRef.current = null;
     setIsGenerating(false);
   }, [clearPolling]);
 
   const handleComplete = useCallback(
     async (urls: GenerationUrls) => {
-      // Stop polling immediately on completion
       clearPolling();
 
       const creationId = creationIdRef.current;
@@ -74,7 +79,6 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
         });
       }
 
-      // Validate non-empty URI
       if (!creationId || !userId || !uri || uri.trim() === "") {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.error("[VideoQueue] ❌ Invalid completion data:", { creationId, userId, uri });
@@ -92,6 +96,7 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
             imageUrl: urls.imageUrl,
             videoUrl: urls.videoUrl,
             thumbnailUrl: urls.thumbnailUrl,
+            generationStartedAt: pollStartTimeRef.current ?? undefined,
           });
           if (typeof __DEV__ !== "undefined" && __DEV__) {
             console.log("[VideoQueue] ✅ Updated completion status in Firestore");
@@ -106,8 +111,6 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
 
       resetRefs();
 
-      // Still call onSuccess even if persistence failed - the generation itself succeeded
-      // The video/image URL is valid, user should still see the result
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[VideoQueue] 🎯 Calling onSuccess callback now...", { persistenceSucceeded });
       }
@@ -139,11 +142,30 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
     [userId, persistence, onError, resetRefs, clearPolling],
   );
 
+  // Use a ref to hold the latest handleComplete/handleError to avoid stale closures
+  // in the setInterval callback
+  const handleCompleteRef = useRef(handleComplete);
+  const handleErrorRef = useRef(handleError);
+  useEffect(() => { handleCompleteRef.current = handleComplete; }, [handleComplete]);
+  useEffect(() => { handleErrorRef.current = handleError; }, [handleError]);
+
   const pollStatus = useCallback(async () => {
     const requestId = requestIdRef.current;
     const model = modelRef.current;
     if (!requestId || !model) return;
 
+    // Check max poll time
+    if (pollStartTimeRef.current !== null) {
+      const elapsed = Date.now() - pollStartTimeRef.current;
+      if (elapsed >= DEFAULT_MAX_POLL_TIME_MS) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.warn("[VideoQueue] ⏰ Max poll time exceeded, aborting");
+        }
+        await handleErrorRef.current("Generation timed out. Please try again.");
+        return;
+      }
+    }
+
     try {
       await pollQueueStatus({
         requestId,
@@ -151,15 +173,19 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
         isPollingRef,
         pollingRef,
         consecutiveErrorsRef,
-        onComplete: handleComplete,
-        onError: handleError,
+        onComplete: handleCompleteRef.current,
+        onError: handleErrorRef.current,
       });
     } catch (error) {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.error("[VideoQueue] Unexpected poll error:", error);
       }
     }
-  }, [handleComplete, handleError]);
+  }, []);
+
+  // Keep a stable ref to pollStatus for the setInterval closure
+  const pollStatusRef = useRef(pollStatus);
+  useEffect(() => { pollStatusRef.current = pollStatus; }, [pollStatus]);
 
   const startGeneration = useCallback(
     async (input: unknown, prompt: string) => {
@@ -175,13 +201,12 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
       let creationId: string | null = null;
       if (userId && prompt) {
         try {
-          // Extract generation parameters from input
           const inputData = input as Record<string, unknown>;
           const duration = typeof inputData?.duration === "number" ? inputData.duration : undefined;
           const resolution = typeof inputData?.resolution === "string" ? inputData.resolution : undefined;
           const aspectRatio = typeof inputData?.aspectRatio === "string" ? inputData.aspectRatio : undefined;
 
-          creationId = await persistence.saveAsProcessing(userId, {
+          const result = await persistence.saveAsProcessing(userId, {
             scenarioId: scenario.id,
             scenarioTitle: scenario.title || scenario.id,
             prompt,
@@ -192,13 +217,14 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
             provider: "fal",
             outputType: scenario.outputType,
           });
+          creationId = result.creationId;
           creationIdRef.current = creationId;
+          // Record the actual DB-level start time for accurate durationMs
+          pollStartTimeRef.current = result.startedAt.getTime();
         } catch (error) {
           if (typeof __DEV__ !== "undefined" && __DEV__) {
             console.error("[VideoQueue] Failed to save processing creation:", error);
           }
-          // Continue without creation tracking - generation can still proceed
-          // The video will be generated but won't appear in gallery history
         }
       }
 
@@ -206,7 +232,6 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
       try {
         queueResult = await strategy.submitToQueue(input);
       } catch (error) {
-        // Queue submission threw - reset state and report error
         if (creationId && userId) {
           try {
             await persistence.updateToFailed(userId, creationId, error instanceof Error ? error.message : "Queue submission failed");
@@ -243,10 +268,14 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
         }
       }
 
-      pollingRef.current = setInterval(() => void pollStatus(), DEFAULT_POLL_INTERVAL_MS);
-      void pollStatus();
+      // Start polling: use DB-level startedAt if available, otherwise fallback to now
+      if (pollStartTimeRef.current === null) {
+        pollStartTimeRef.current = Date.now();
+      }
+      pollingRef.current = setInterval(() => void pollStatusRef.current(), DEFAULT_POLL_INTERVAL_MS);
+      void pollStatusRef.current();
     },
-    [userId, scenario, persistence, strategy, creditCost, pollStatus, onError],
+    [userId, scenario, persistence, strategy, creditCost, onError],
   );
 
   return { isGenerating, startGeneration };

package/src/domains/generation/wizard/presentation/hooks/videoQueuePoller.ts

@@ -1,12 +1,10 @@
 import { providerRegistry } from "../../../../../infrastructure/services/provider-registry.service";
 import { extractResultUrl, type GenerationUrls, type GenerationResult } from "./generation-result.utils";
 import { QUEUE_STATUS } from "../../../../../domain/constants/queue-status.constants";
+import { DEFAULT_MAX_CONSECUTIVE_ERRORS } from "../../../../../infrastructure/constants/polling.constants";
 
 declare const __DEV__: boolean;
 
-/** Max consecutive transient errors before aborting */
-const MAX_CONSECUTIVE_ERRORS = 5;
-
 /**
  * Extract meaningful error message from various error formats.
  * Fal AI client throws ValidationError with empty .message but details in .body/.detail
@@ -14,12 +12,8 @@ const MAX_CONSECUTIVE_ERRORS = 5;
 function extractErrorMessage(err: unknown): string {
   if (!err) return "Generation failed";
 
-  // Standard Error with message
-  if (err instanceof Error && err.message && err.message.length > 0) {
-    return err.message;
-  }
-
-  // Fal AI ValidationError - has .body.detail array
+  // Fal AI ValidationError - has .body.detail array (check before instanceof Error
+  // because ValidationError may extend Error with empty .message)
   const errObj = err as Record<string, unknown>;
   if (errObj.body && typeof errObj.body === "object") {
     const body = errObj.body as Record<string, unknown>;
@@ -35,6 +29,11 @@ function extractErrorMessage(err: unknown): string {
     if (first?.msg) return first.msg;
   }
 
+  // Standard Error with message
+  if (err instanceof Error && err.message && err.message.length > 0) {
+    return err.message;
+  }
+
   // Fallback to string conversion
   const str = String(err);
   return str.length > 0 && str !== "[object Object]" ? str : "Generation failed";
@@ -96,15 +95,21 @@ export const pollQueueStatus = async (params: PollParams): Promise<void> => {
           await onError(errorMessage);
         }
       } else {
-        await onError("Generation failed");
+        // Try to extract error from FAL job logs (error-level log takes priority)
+        const logs = status.logs ?? [];
+        const errorLog = logs.findLast?.((l) => l.level === "error") ?? logs[logs.length - 1];
+        const failMessage =
+          errorLog?.message && errorLog.message !== "[object Object]"
+            ? errorLog.message
+            : "Generation failed";
+        await onError(failMessage);
       }
     }
   } catch (err) {
     consecutiveErrorsRef.current += 1;
-    const errorMessage = err instanceof Error ? err.message : "Generation failed";
+    const errorMessage = extractErrorMessage(err);
 
-    if (consecutiveErrorsRef.current >= MAX_CONSECUTIVE_ERRORS) {
-      // Too many consecutive errors - abort
+    if (consecutiveErrorsRef.current >= DEFAULT_MAX_CONSECUTIVE_ERRORS) {
       if (pollingRef.current) {
         clearInterval(pollingRef.current);
         pollingRef.current = null;
@@ -112,10 +117,9 @@ export const pollQueueStatus = async (params: PollParams): Promise<void> => {
       if (__DEV__) console.error("[VideoQueueGeneration] Max consecutive errors reached, aborting:", errorMessage);
       await onError(errorMessage);
     } else {
-      // Transient error - continue polling
       if (__DEV__) {
         console.warn(
-          `[VideoQueueGeneration] Transient poll error (${consecutiveErrorsRef.current}/${MAX_CONSECUTIVE_ERRORS}):`,
+          `[VideoQueueGeneration] Transient poll error (${consecutiveErrorsRef.current}/${DEFAULT_MAX_CONSECUTIVE_ERRORS}):`,
           errorMessage,
         );
       }