@umituz/react-native-ai-generation-content 1.90.2 → 1.90.3

package/src/domains/background/infrastructure/services/job-poller.service.ts

@@ -1,234 +0,0 @@
-/**
- * Job Poller Service
- * Provider-agnostic job polling with exponential backoff
- * Reports only real status - no fake progress
- */
-
-import { DEFAULT_POLLING_CONFIG } from "../../../../domain/entities/polling.types";
-import { calculatePollingInterval } from "../utils/polling-interval.util";
-import { checkStatusForErrors, isJobComplete } from "../utils/status-checker.util";
-import { validateResult } from "../utils/result-validator.util";
-import type { PollJobOptions, PollJobResult } from "./job-poller.types";
-
-
-/**
- * Wraps a promise with abort signal support
- * Rejects if signal is aborted before promise resolves
- */
-function withAbortSignal<T>(
-  promise: Promise<T>,
-  signal: AbortSignal | undefined,
-  timeoutMs?: number,
-): Promise<T> {
-  if (!signal && !timeoutMs) {
-    return promise;
-  }
-
-  return new Promise<T>((resolve, reject) => {
-    // Handle abort signal
-    if (signal?.aborted) {
-      reject(new Error("Operation aborted"));
-      return;
-    }
-
-    let isResolved = false;
-    const abortHandler = () => {
-      if (isResolved) return;
-      isResolved = true;
-      if (timeoutId) clearTimeout(timeoutId);
-      reject(new Error("Operation aborted"));
-    };
-
-    signal?.addEventListener("abort", abortHandler, { once: true });
-
-    // Handle timeout
-    let timeoutId: ReturnType<typeof setTimeout> | undefined;
-    if (timeoutMs) {
-      timeoutId = setTimeout(() => {
-        if (isResolved) return;
-        isResolved = true;
-        signal?.removeEventListener("abort", abortHandler);
-        reject(new Error(`Operation timeout after ${timeoutMs}ms`));
-      }, timeoutMs);
-    }
-
-    promise
-      .then((result) => {
-        if (isResolved) return;
-        isResolved = true;
-        signal?.removeEventListener("abort", abortHandler);
-        if (timeoutId) clearTimeout(timeoutId);
-        resolve(result);
-      })
-      .catch((error) => {
-        if (isResolved) return;
-        isResolved = true;
-        signal?.removeEventListener("abort", abortHandler);
-        if (timeoutId) clearTimeout(timeoutId);
-        reject(error);
-      });
-  });
-}
-
-/**
- * Poll job until completion with exponential backoff
- * Only reports 100% on actual completion
- */
-export async function pollJob<T = unknown>(
-  options: PollJobOptions,
-): Promise<PollJobResult<T>> {
-  const {
-    provider,
-    model,
-    requestId,
-    config,
-    onProgress,
-    onStatusChange,
-    signal,
-  } = options;
-
-  // Validate requestId early
-  if (!requestId || typeof requestId !== "string" || requestId.trim() === "") {
-    return {
-      success: false,
-      error: new Error("Invalid requestId provided"),
-      attempts: 0,
-      elapsedMs: 0,
-    };
-  }
-
-  // Validate model early
-  if (!model || typeof model !== "string" || model.trim() === "") {
-    return {
-      success: false,
-      error: new Error("Invalid model provided"),
-      attempts: 0,
-      elapsedMs: 0,
-    };
-  }
-
-  const pollingConfig = { ...DEFAULT_POLLING_CONFIG, ...config };
-  const { maxAttempts, maxTotalTimeMs, maxConsecutiveErrors } = pollingConfig;
-
-  const startTime = Date.now();
-  let consecutiveTransientErrors = 0;
-
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    // Check total time limit
-    const elapsedMs = Date.now() - startTime;
-    if (maxTotalTimeMs && elapsedMs >= maxTotalTimeMs) {
-      return {
-        success: false,
-        error: new Error(`Polling timeout after ${elapsedMs}ms`),
-        attempts: attempt + 1,
-        elapsedMs,
-      };
-    }
-
-    if (signal?.aborted) {
-      return {
-        success: false,
-        error: new Error("Polling aborted"),
-        attempts: attempt + 1,
-        elapsedMs,
-      };
-    }
-
-    if (attempt > 0) {
-      const interval = calculatePollingInterval({ attempt, config: pollingConfig });
-      await new Promise<void>((resolve) => setTimeout(() => resolve(), interval));
-    }
-
-    try {
-      // Wrap provider calls with abort signal support and timeout (30s default)
-      const status = await withAbortSignal(
-        provider.getJobStatus(model, requestId),
-        signal,
-        30000,
-      );
-      onStatusChange?.(status);
-
-      const statusCheck = checkStatusForErrors(status);
-
-      if (statusCheck.shouldStop && statusCheck.hasError) {
-        return {
-          success: false,
-          error: new Error(statusCheck.errorMessage || "Job failed"),
-          attempts: attempt + 1,
-          elapsedMs: Date.now() - startTime,
-        };
-      }
-
-      consecutiveTransientErrors = 0;
-
-      if (isJobComplete(status)) {
-        // Wrap result retrieval with abort signal support and timeout (60s for larger results)
-        const result = await withAbortSignal(
-          provider.getJobResult<T>(model, requestId),
-          signal,
-          60000,
-        );
-
-        const validation = validateResult(result);
-        if (!validation.isValid) {
-          return {
-            success: false,
-            error: new Error(validation.errorMessage || "Invalid result"),
-            attempts: attempt + 1,
-            elapsedMs: Date.now() - startTime,
-          };
-        }
-
-        onProgress?.(100);
-
-        return {
-          success: true,
-          data: result,
-          attempts: attempt + 1,
-          elapsedMs: Date.now() - startTime,
-        };
-      }
-    } catch (error) {
-      consecutiveTransientErrors++;
-
-      if (__DEV__) {
-        console.warn("[JobPoller] Transient error during polling", {
-          attempt: attempt + 1,
-          requestId,
-          model,
-          consecutiveErrors: consecutiveTransientErrors,
-          error: error instanceof Error ? error.message : String(error),
-          code: (error as { code?: string })?.code,
-        });
-      }
-
-      // Check if we've hit max consecutive transient errors
-      if (maxConsecutiveErrors && consecutiveTransientErrors >= maxConsecutiveErrors) {
-        if (__DEV__) {
-          console.error("[JobPoller] Max consecutive errors reached", {
-            maxConsecutiveErrors,
-            requestId,
-            model,
-          });
-        }
-        return {
-          success: false,
-          error: new Error(`Too many consecutive errors (${consecutiveTransientErrors})`),
-          attempts: attempt + 1,
-          elapsedMs: Date.now() - startTime,
-        };
-      }
-
-      // Continue polling on transient errors
-      continue;
-    }
-  }
-
-  return {
-    success: false,
-    error: new Error(`Polling timeout after ${maxAttempts} attempts`),
-    attempts: maxAttempts,
-    elapsedMs: Date.now() - startTime,
-  };
-}
-

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

@@ -1,256 +0,0 @@
-/**
- * useProcessingJobsPoller Hook
- * Polls queue status for "processing" creations and updates Firestore when complete
- * Enables true background generation - works even after wizard is dismissed
- * Uses provider registry internally - no need to pass provider functions
- */
-
-import { useEffect, useRef, useMemo } from "react";
-import { providerRegistry } from "../../../../infrastructure/services/provider-registry.service";
-import { QUEUE_STATUS, CREATION_STATUS } from "../../../../domain/constants/queue-status.constants";
-import { DEFAULT_POLL_INTERVAL_MS, DEFAULT_MAX_POLL_TIME_MS } from "../../../../infrastructure/constants/polling.constants";
-import {
-  extractResultUrl,
-  type GenerationResult,
-} from "../../../generation/wizard/presentation/hooks/generation-result.utils";
-import type { Creation } from "../../domain/entities/Creation";
-import type { ICreationsRepository } from "../../domain/repositories/ICreationsRepository";
-import { isOlderThan, calculateAgeMs } from "../../../../shared/utils/calculations.util";
-
-
-export interface UseProcessingJobsPollerConfig {
-  readonly userId?: string | null;
-  readonly creations: Creation[];
-  readonly repository: ICreationsRepository;
-  readonly enabled?: boolean;
-}
-
-export interface UseProcessingJobsPollerReturn {
-  readonly processingCount: number;
-}
-
-export function useProcessingJobsPoller(
-  config: UseProcessingJobsPollerConfig,
-): UseProcessingJobsPollerReturn {
-  const {
-    userId,
-    creations,
-    repository,
-    enabled = true,
-  } = config;
-
-  const pollingRef = useRef<Set<string>>(new Set());
-  const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
-
-  // Convert to IDs to prevent re-creating array on every render
-  const processingJobIds = useMemo(
-    () => creations
-      .filter((c) => c.status === CREATION_STATUS.PROCESSING && c.requestId && c.model)
-      .map((c) => c.id),
-    [creations],
-  );
-
-  const processingJobs = useMemo(
-    () => creations.filter(
-      (c) => c.status === CREATION_STATUS.PROCESSING && c.requestId && c.model,
-    ),
-    [creations],
-  );
-
-  // Orphan jobs: processing but no requestId/model (e.g. blocking image jobs that got stuck)
-  const orphanJobs = useMemo(
-    () => creations.filter(
-      (c) => c.status === CREATION_STATUS.PROCESSING && !c.requestId && !c.model,
-    ),
-    [creations],
-  );
-
-  // Use ref for stable function reference to prevent effect re-runs
-  const pollJobRef = useRef<((creation: Creation) => Promise<void>) | undefined>(undefined);
-
-  // Use mounted ref to prevent operations after unmount
-  const isMountedRef = useRef(true);
-
-  useEffect(() => {
-    isMountedRef.current = true;
-    return () => {
-      isMountedRef.current = false;
-    };
-  }, []);
-
-  pollJobRef.current = async (creation: Creation) => {
-    if (!isMountedRef.current || !userId || !creation.requestId || !creation.model) return;
-
-    if (pollingRef.current.has(creation.id)) return;
-    pollingRef.current.add(creation.id);
-
-    // Stale detection: if creation is older than max poll time, mark as failed
-    if (isOlderThan(creation.createdAt, DEFAULT_MAX_POLL_TIME_MS)) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[ProcessingJobsPoller] Stale job detected, marking as failed:", creation.id, {
-          ageMs: calculateAgeMs(creation.createdAt),
-        });
-      }
-      try {
-        await repository.update(userId, creation.id, {
-          status: CREATION_STATUS.FAILED,
-          metadata: { ...creation.metadata, error: "Generation timed out" },
-          completedAt: new Date(),
-        });
-      } catch (e) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error("[ProcessingJobsPoller] Failed to mark stale job:", e);
-        }
-      }
-      pollingRef.current.delete(creation.id);
-      return;
-    }
-
-    const provider = providerRegistry.getActiveProvider();
-    if (!provider || !provider.isInitialized()) {
-      pollingRef.current.delete(creation.id);
-      return;
-    }
-
-    try {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[ProcessingJobsPoller] Checking status:", creation.id);
-      }
-
-      const status = await provider.getJobStatus(creation.model, creation.requestId);
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[ProcessingJobsPoller] Status:", creation.id, status.status);
-      }
-
-      if (status.status === QUEUE_STATUS.COMPLETED) {
-        const result = await provider.getJobResult<GenerationResult>(creation.model, creation.requestId);
-        const urls = extractResultUrl(result);
-        if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[ProcessingJobsPoller] Completed:", creation.id, urls);
-
-        if (!isMountedRef.current) return;
-
-        const uri = urls.videoUrl || urls.imageUrl || "";
-
-        // Validate that we have a valid URI before marking as completed
-        if (!uri || uri.trim() === "") {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error("[ProcessingJobsPoller] No valid URI in result:", creation.id);
-          }
-          await repository.update(userId, creation.id, {
-            status: CREATION_STATUS.FAILED,
-            metadata: { ...creation.metadata, error: "No valid result URL received" },
-            completedAt: new Date(),
-          });
-          return;
-        }
-
-        const output: Record<string, string | undefined> = {};
-        if (urls.imageUrl) output.imageUrl = urls.imageUrl;
-        if (urls.videoUrl) output.videoUrl = urls.videoUrl;
-        if (urls.thumbnailUrl) output.thumbnailUrl = urls.thumbnailUrl;
-
-        await repository.update(userId, creation.id, {
-          status: CREATION_STATUS.COMPLETED,
-          uri,
-          output,
-          completedAt: new Date(),
-        });
-      } else if (status.status === QUEUE_STATUS.FAILED) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[ProcessingJobsPoller] Failed:", creation.id);
-
-        if (!isMountedRef.current) return;
-
-        await repository.update(userId, creation.id, {
-          status: CREATION_STATUS.FAILED,
-          metadata: { ...creation.metadata, error: "Generation failed" },
-          completedAt: new Date(),
-        });
-      }
-    } catch (error) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.error("[ProcessingJobsPoller] Poll error:", creation.id, error);
-      }
-    } finally {
-      pollingRef.current.delete(creation.id);
-    }
-  };
-
-  // Clean up orphan processing creations (no requestId/model) older than max poll time
-  useEffect(() => {
-    if (!enabled || !userId || orphanJobs.length === 0) return;
-
-    const cleanupOrphans = async () => {
-      const staleOrphans = orphanJobs.filter((creation) =>
-        isOlderThan(creation.createdAt, DEFAULT_MAX_POLL_TIME_MS)
-      );
-
-      if (staleOrphans.length === 0) return;
-
-      await Promise.allSettled(
-        staleOrphans.map(async (creation) => {
-          if (!isMountedRef.current) return;
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[ProcessingJobsPoller] Orphan job timed out, marking as failed:", creation.id);
-          }
-          await repository.update(userId, creation.id, {
-            status: CREATION_STATUS.FAILED,
-            metadata: { ...creation.metadata, error: "Generation timed out" },
-            completedAt: new Date(),
-          });
-        }),
-      );
-    };
-
-    void cleanupOrphans().catch((e) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.error("[ProcessingJobsPoller] Failed to clean up orphan jobs:", e);
-      }
-    });
-  }, [enabled, userId, orphanJobs, repository]);
-
-  // Use ref to always get latest creations
-  const creationsRef = useRef(creations);
-  useEffect(() => {
-    creationsRef.current = creations;
-  }, [creations]);
-
-  useEffect(() => {
-    if (!enabled || !userId || processingJobIds.length === 0) {
-      if (intervalRef.current) {
-        clearInterval(intervalRef.current);
-        intervalRef.current = null;
-      }
-      return;
-    }
-
-    // Get current jobs at poll time from ref to avoid stale closures
-    const pollCurrentJobs = () => {
-      const currentJobs = creationsRef.current.filter(
-        (c) => c.status === CREATION_STATUS.PROCESSING && c.requestId && c.model,
-      );
-      currentJobs.forEach((job) => pollJobRef.current?.(job));
-    };
-
-    // Initial poll
-    pollCurrentJobs();
-
-    // Set up interval polling
-    intervalRef.current = setInterval(pollCurrentJobs, DEFAULT_POLL_INTERVAL_MS);
-
-    return () => {
-      // Clear polling set first to prevent new operations
-      pollingRef.current.clear();
-
-      // Then clear interval
-      if (intervalRef.current) {
-        clearInterval(intervalRef.current);
-        intervalRef.current = null;
-      }
-    };
-  }, [enabled, userId, processingJobIds]);
-
-  return {
-    processingCount: processingJobs.length,
-  };
-}