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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.90.2",
+  "version": "1.90.4",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -73,8 +73,8 @@
     "@tanstack/react-query": "^5.66.7",
     "@tanstack/react-query-persist-client": "^5.66.7",
     "@types/react": "~19.1.10",
-    "@typescript-eslint/eslint-plugin": "^8.54.0",
-    "@typescript-eslint/parser": "^8.54.0",
+    "@typescript-eslint/eslint-plugin": "^8.57.1",
+    "@typescript-eslint/parser": "^8.57.1",
     "@umituz/react-native-ai-fal-provider": "*",
     "@umituz/react-native-design-system": "*",
     "@umituz/react-native-firebase": "*",

package/src/domain/interfaces/app-services-auth.interface.ts

@@ -0,0 +1,27 @@
+/**
+ * App Services - Auth Interface
+ * Authentication service interface
+ */
+
+/**
+ * Auth service interface
+ * Handles user authentication
+ */
+export interface IAuthService {
+  /**
+   * Get current user ID
+   * @returns User ID or null if not authenticated
+   */
+  getUserId: () => string | null;
+
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated: () => boolean;
+
+  /**
+   * Require authenticated user - throws if not authenticated
+   * @returns User ID
+   */
+  requireAuth: () => string;
+}

package/src/domain/interfaces/app-services-composite.interface.ts

@@ -0,0 +1,29 @@
+/**
+ * App Services - Composite Interface
+ * Combined app services interface
+ */
+
+import type { INetworkService } from "./app-services.interface";
+import type { ICreditService } from "./app-services.interface";
+import type { IPaywallService } from "./app-services.interface";
+import type { IAuthService } from "./app-services-auth.interface";
+import type { IAnalyticsService } from "./app-services-optional.interface";
+import type { IFeatureUtils } from "./app-services-optional.interface";
+
+/**
+ * Combined app services interface
+ * Apps implement this to provide all required services
+ */
+export interface IAppServices {
+  readonly network: INetworkService;
+  readonly credits: ICreditService;
+  readonly paywall: IPaywallService;
+  readonly auth: IAuthService;
+  readonly analytics?: IAnalyticsService;
+  readonly featureUtils?: IFeatureUtils;
+}
+
+/**
+ * Partial app services for optional configuration
+ */
+export type PartialAppServices = Partial<IAppServices>;

package/src/domain/interfaces/app-services-optional.interface.ts

@@ -0,0 +1,42 @@
+/**
+ * App Services - Optional Interfaces
+ * Optional service interfaces (analytics, feature utils)
+ */
+
+/**
+ * Analytics event data
+ */
+interface AnalyticsEventData {
+  readonly [key: string]: string | number | boolean | null | undefined;
+}
+
+/**
+ * Analytics service interface (optional)
+ * Tracks events for analytics
+ */
+export interface IAnalyticsService {
+  /**
+   * Track an event
+   * @param event - Event name
+   * @param data - Event data
+   */
+  track: (event: string, data: AnalyticsEventData) => void;
+}
+
+/**
+ * Feature utils interface (optional)
+ * Provides utility functions for AI features
+ */
+export interface IFeatureUtils {
+  /**
+   * Select image from gallery
+   * @returns Image URI or null if cancelled
+   */
+  selectImage: () => Promise<string | null>;
+
+  /**
+   * Save video to device library
+   * @param uri - Video URI to save
+   */
+  saveVideo: (uri: string) => Promise<void>;
+}

package/src/domain/interfaces/app-services.interface.ts

@@ -78,82 +78,3 @@ export interface IPaywallService {
    */
   showPaywall: (requiredCredits: number) => void;
 }
-
-/**
- * Auth service interface
- * Handles user authentication
- */
-export interface IAuthService {
-  /**
-   * Get current user ID
-   * @returns User ID or null if not authenticated
-   */
-  getUserId: () => string | null;
-
-  /**
-   * Check if user is authenticated
-   */
-  isAuthenticated: () => boolean;
-
-  /**
-   * Require authenticated user - throws if not authenticated
-   * @returns User ID
-   */
-  requireAuth: () => string;
-}
-
-/**
- * Analytics event data
- */
-interface AnalyticsEventData {
-  readonly [key: string]: string | number | boolean | null | undefined;
-}
-
-/**
- * Analytics service interface (optional)
- * Tracks events for analytics
- */
-export interface IAnalyticsService {
-  /**
-   * Track an event
-   * @param event - Event name
-   * @param data - Event data
-   */
-  track: (event: string, data: AnalyticsEventData) => void;
-}
-
-/**
- * Feature utils interface (optional)
- * Provides utility functions for AI features
- */
-export interface IFeatureUtils {
-  /**
-   * Select image from gallery
-   * @returns Image URI or null if cancelled
-   */
-  selectImage: () => Promise<string | null>;
-
-  /**
-   * Save video to device library
-   * @param uri - Video URI to save
-   */
-  saveVideo: (uri: string) => Promise<void>;
-}
-
-/**
- * Combined app services interface
- * Apps implement this to provide all required services
- */
-export interface IAppServices {
-  readonly network: INetworkService;
-  readonly credits: ICreditService;
-  readonly paywall: IPaywallService;
-  readonly auth: IAuthService;
-  readonly analytics?: IAnalyticsService;
-  readonly featureUtils?: IFeatureUtils;
-}
-
-/**
- * Partial app services for optional configuration
- */
-export type PartialAppServices = Partial<IAppServices>;

package/src/domain/interfaces/index.ts

@@ -5,6 +5,9 @@
 
 export * from "./ai-provider.interface";
 export * from "./app-services.interface";
+export * from "./app-services-auth.interface";
+export * from "./app-services-composite.interface";
+export * from "./app-services-optional.interface";
 
 // Video Model Configuration
 export type { VideoModelConfig, ModelCapabilityOption } from "./video-model-config.types";

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

@@ -0,0 +1,7 @@
+/**
+ * Job Poller Service
+ * Provider-agnostic job polling with exponential backoff
+ */
+
+export { pollJob } from "./job-poller.service";
+export type { PollJobOptions, PollJobResult } from "./job-poller.service";

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

@@ -0,0 +1,127 @@
+/**
+ * Job Poller Service - Utility Functions
+ */
+
+/**
+ * Wrap a promise with abort signal support
+ * Rejects if signal is aborted before promise resolves
+ */
+export 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);
+      });
+  });
+}
+
+/**
+ * Validate request ID
+ */
+export function validateRequestId(requestId: string | undefined): { valid: boolean; error?: string } {
+  if (!requestId || typeof requestId !== "string" || requestId.trim() === "") {
+    return {
+      valid: false,
+      error: "Invalid requestId provided",
+    };
+  }
+  return { valid: true };
+}
+
+/**
+ * Validate model
+ */
+export function validateModel(model: string | undefined): { valid: boolean; error?: string } {
+  if (!model || typeof model !== "string" || model.trim() === "") {
+    return {
+      valid: false,
+      error: "Invalid model provided",
+    };
+  }
+  return { valid: true };
+}
+
+/**
+ * Log transient error during polling
+ */
+export function logTransientError(
+  attempt: number,
+  requestId: string,
+  model: string,
+  consecutiveErrors: number,
+  error: unknown
+): void {
+  if (__DEV__) {
+    console.warn("[JobPoller] Transient error during polling", {
+      attempt: attempt + 1,
+      requestId,
+      model,
+      consecutiveErrors,
+      error: error instanceof Error ? error.message : String(error),
+      code: (error as { code?: string })?.code,
+    });
+  }
+}
+
+/**
+ * Log max consecutive errors reached
+ */
+export function logMaxConsecutiveErrors(
+  maxConsecutiveErrors: number,
+  requestId: string,
+  model: string
+): void {
+  if (__DEV__) {
+    console.error("[JobPoller] Max consecutive errors reached", {
+      maxConsecutiveErrors,
+      requestId,
+      model,
+    });
+  }
+}

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

@@ -1,234 +1,179 @@
 /**
  * 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 type { JobStatus } from "../../../../domain/interfaces/ai-provider.interface";
+import type { PollingConfig } from "../../../../domain/entities/polling.types";
+import type { PollJobOptions, PollJobResult } from "./job-poller.types";
+import { withAbortSignal, validateRequestId, validateModel, logTransientError, logMaxConsecutiveErrors } from "./job-poller-utils";
 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
+ * Default polling configuration
  */
-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);
-      });
-  });
-}
+const DEFAULT_CONFIG: Partial<PollingConfig> = {
+  maxAttempts: 40,
+  initialIntervalMs: 1500,
+  maxIntervalMs: 5000,
+  backoffMultiplier: 1.3,
+  maxConsecutiveErrors: 5,
+};
 
 /**
- * Poll job until completion with exponential backoff
- * Only reports 100% on actual completion
+ * Poll a job until completion or timeout
  */
 export async function pollJob<T = unknown>(
-  options: PollJobOptions,
+  options: PollJobOptions
 ): Promise<PollJobResult<T>> {
   const {
     provider,
     model,
     requestId,
-    config,
+    config = DEFAULT_CONFIG,
     onProgress,
     onStatusChange,
     signal,
   } = options;
 
-  // Validate requestId early
-  if (!requestId || typeof requestId !== "string" || requestId.trim() === "") {
+  // Validate inputs
+  const requestIdValidation = validateRequestId(requestId);
+  if (!requestIdValidation.valid) {
     return {
       success: false,
-      error: new Error("Invalid requestId provided"),
+      error: new Error(requestIdValidation.error!),
       attempts: 0,
       elapsedMs: 0,
     };
   }
 
-  // Validate model early
-  if (!model || typeof model !== "string" || model.trim() === "") {
+  const modelValidation = validateModel(model);
+  if (!modelValidation.valid) {
     return {
       success: false,
-      error: new Error("Invalid model provided"),
+      error: new Error(modelValidation.error!),
       attempts: 0,
       elapsedMs: 0,
     };
   }
 
-  const pollingConfig = { ...DEFAULT_POLLING_CONFIG, ...config };
-  const { maxAttempts, maxTotalTimeMs, maxConsecutiveErrors } = pollingConfig;
-
   const startTime = Date.now();
-  let consecutiveTransientErrors = 0;
+  let currentInterval = config.initialIntervalMs || DEFAULT_CONFIG.initialIntervalMs!;
+  const maxInterval = config.maxIntervalMs || DEFAULT_CONFIG.maxIntervalMs!;
+  const maxAttempts = config.maxAttempts || DEFAULT_CONFIG.maxAttempts!;
+  const backoffMultiplier = config.backoffMultiplier || DEFAULT_CONFIG.backoffMultiplier!;
+  const maxConsecutiveErrors = config.maxConsecutiveErrors || DEFAULT_CONFIG.maxConsecutiveErrors!;
 
-  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,
-      };
-    }
+  let consecutiveErrors = 0;
 
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    // Check for abort signal
     if (signal?.aborted) {
       return {
         success: false,
-        error: new Error("Polling aborted"),
+        error: new Error("Operation aborted"),
         attempts: attempt + 1,
-        elapsedMs,
+        elapsedMs: Date.now() - startTime,
       };
     }
 
-    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),
+      // Check job status
+      const statusResult = await withAbortSignal(
+        provider.checkStatus(requestId, model),
         signal,
-        30000,
+        config.maxTotalTimeMs ? config.maxTotalTimeMs - (Date.now() - startTime) : undefined
       );
-      onStatusChange?.(status);
 
-      const statusCheck = checkStatusForErrors(status);
+      // Notify status change
+      if (onStatusChange && typeof statusResult === 'object' && 'status' in statusResult) {
+        onStatusChange(statusResult as JobStatus);
+      }
 
-      if (statusCheck.shouldStop && statusCheck.hasError) {
+      // Check for errors in status
+      const statusError = checkStatusForErrors(statusResult as JobStatus | Record<string, unknown>);
+      if (statusError) {
         return {
           success: false,
-          error: new Error(statusCheck.errorMessage || "Job failed"),
+          error: statusError,
           attempts: attempt + 1,
           elapsedMs: Date.now() - startTime,
         };
       }
 
-      consecutiveTransientErrors = 0;
+      // Reset consecutive errors on success
+      consecutiveErrors = 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) {
+      // Check if job is complete
+      if (isJobComplete(statusResult as JobStatus | Record<string, unknown>)) {
+        // Validate result
+        const validationResult = validateResult(statusResult);
+        if (!validationResult.isValid) {
           return {
             success: false,
-            error: new Error(validation.errorMessage || "Invalid result"),
+            error: new Error(validationResult.errorMessage || "Result validation failed"),
             attempts: attempt + 1,
             elapsedMs: Date.now() - startTime,
           };
         }
 
+        // Report progress
         onProgress?.(100);
 
+        // Extract result data if available
+        let data: T | undefined = undefined;
+        if (typeof statusResult === 'object' && statusResult !== null && 'result' in statusResult) {
+          data = statusResult.result as T;
+        } else {
+          data = statusResult as T;
+        }
+
         return {
           success: true,
-          data: result,
+          data,
           attempts: attempt + 1,
           elapsedMs: Date.now() - startTime,
         };
       }
+
+      // Report progress based on attempt number
+      const progress = Math.min((attempt / maxAttempts) * 100, 90);
+      onProgress?.(progress);
+
     } 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,
-        });
-      }
+      consecutiveErrors++;
+      logTransientError(attempt, requestId, model, consecutiveErrors, error);
 
-      // 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,
-          });
-        }
+      // Check if we've hit max consecutive errors
+      if (consecutiveErrors >= maxConsecutiveErrors) {
+        logMaxConsecutiveErrors(maxConsecutiveErrors, requestId, model);
         return {
           success: false,
-          error: new Error(`Too many consecutive errors (${consecutiveTransientErrors})`),
+          error: error instanceof Error ? error : new Error(String(error)),
           attempts: attempt + 1,
           elapsedMs: Date.now() - startTime,
         };
       }
-
-      // Continue polling on transient errors
-      continue;
     }
+
+    // Wait before next attempt with exponential backoff
+    await withAbortSignal(
+      new Promise(resolve => setTimeout(resolve, currentInterval)),
+      signal
+    );
+
+    // Increase interval for next attempt (exponential backoff)
+    currentInterval = Math.min(currentInterval * backoffMultiplier, maxInterval);
   }
 
+  // Max attempts reached
   return {
     success: false,
-    error: new Error(`Polling timeout after ${maxAttempts} attempts`),
+    error: new Error(`Job did not complete after ${maxAttempts} attempts`),
     attempts: maxAttempts,
     elapsedMs: Date.now() - startTime,
   };
 }
 
+export type { PollJobOptions, PollJobResult } from './job-poller.types';

package/src/domains/background/infrastructure/utils/polling-interval.util.ts

@@ -4,7 +4,7 @@
  */
 
 import type { PollingConfig } from "../../../../domain/entities/polling.types";
-import { calculatePollingInterval as calculateInterval } from "../../../../shared/utils/calculations.util";
+import { calculatePollingInterval as calculateInterval } from "../../../../shared/utils/calculations";
 
 export interface IntervalOptions {
   attempt: number;

package/src/domains/background/presentation/hooks/use-background-generation.ts

@@ -2,7 +2,7 @@ import { useCallback, useRef, useState, useMemo } from "react";
 import { usePendingJobs } from "./use-pending-jobs";
 import { executeDirectGeneration, executeQueuedJob } from "../../infrastructure/executors/backgroundJobExecutor";
 import { DEFAULT_QUEUE_CONFIG } from "../../domain/entities/job.types";
-import { calculateFilteredCount } from "../../../../shared/utils/calculations.util";
+import { calculateFilteredCount } from "../../../../shared/utils/calculations";
 import type {
   UseBackgroundGenerationOptions,
   UseBackgroundGenerationReturn,