@umituz/react-native-ai-generation-content 1.61.32 → 1.61.34

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

@@ -10,8 +10,7 @@ import { useEffect, useRef, useCallback, useState } from "react";
 import { providerRegistry } from "../../../../../infrastructure/services/provider-registry.service";
 import { extractResultUrl, type FalResult, type GenerationUrls } from "./generation-result.utils";
 import { QUEUE_STATUS } from "../../../../../domain/constants/queue-status.constants";
-
-const POLL_INTERVAL_MS = 3000;
+import { DEFAULT_POLL_INTERVAL_MS } from "../../../../../infrastructure/constants/polling.constants";
 import type { CreationPersistence } from "../../infrastructure/utils/creation-persistence.util";
 import type { WizardStrategy } from "../../infrastructure/strategies/wizard-strategy.types";
 import type { WizardScenarioData } from "./wizard-generation.types";
@@ -179,7 +178,7 @@ export function useVideoQueueGeneration(
         }
       }
 
-      pollingRef.current = setInterval(() => void pollQueueStatus(), POLL_INTERVAL_MS);
+      pollingRef.current = setInterval(() => void pollQueueStatus(), DEFAULT_POLL_INTERVAL_MS);
       void pollQueueStatus();
     },
     [userId, scenario, persistence, strategy, pollQueueStatus, onError],

package/src/exports/infrastructure.ts

@@ -28,7 +28,7 @@ export type {
 
 // Utils
 export {
-  classifyError, isTransientError, isPermanentError, isResultNotReady, calculatePollingInterval,
+  classifyError, isPermanentError, isResultNotReady, calculatePollingInterval,
   checkStatusForErrors, isJobComplete, isJobProcessing, isJobFailed,
   validateResult, extractOutputUrl, extractOutputUrls, extractVideoUrl, extractThumbnailUrl,
   extractAudioUrl, extractImageUrls, cleanBase64, addBase64Prefix, preparePhoto, preparePhotos,
@@ -41,6 +41,29 @@ export type {
   PhotoInput, PreparedImage, ImageSelector, VideoSaver, AlertFunction, FeatureUtilsConfig, VideoAlertFunction,
 } from "../infrastructure/utils";
 
+// Validation
+export {
+  sanitizeString,
+  validateString,
+  validateNumber,
+  validateURL,
+  validateEmail,
+  validateBase64,
+  validateObject,
+  validateArray,
+  combineValidationResults,
+  sanitizeAndValidate,
+  validateAIPrompt,
+  validateImageData,
+  validateUserId,
+  validateCreationId,
+} from "../infrastructure/validation/input-validator";
+export type {
+  ValidationResult,
+  StringValidationOptions,
+  NumericValidationOptions,
+} from "../infrastructure/validation/input-validator";
+
 // Orchestration
 export type {
   CreditService, PaywallService, NetworkService, AuthService,

package/src/exports/presentation.ts

@@ -35,7 +35,7 @@ export {
   GenerateButton, ResultDisplay, AIGenerationResult, ErrorDisplay, FeatureHeader,
   AIGenScreenHeader, CreditBadge, PhotoUploadCard, SettingsSheet, StyleSelector,
   AspectRatioSelector, DurationSelector, GridSelector, StylePresetsGrid, AIGenerationForm,
-  AIGenerationConfig, ModelSelector,
+  AIGenerationConfig, ModelSelector, ErrorBoundary, withErrorBoundary,
   createAspectRatioOptions, createDurationOptions, createStyleOptions, createStyleOptionsFromConfig,
   ASPECT_RATIO_IDS, COMMON_DURATIONS,
 } from "../presentation/components";

package/src/features/image-to-video/presentation/components/index.ts

@@ -21,10 +21,6 @@ export type {
   ImageSelectionGridTranslations as ImageToVideoSelectionGridTranslations,
 } from "./ImageSelectionGrid";
 
-// Hero Section - Using AIGenerationHero from common components
-// export { HeroSection as ImageToVideoHeroSection } from "./HeroSection";
-// export type { HeroSectionProps as ImageToVideoHeroSectionProps } from "./HeroSection";
-
 // Action Components
 export { GenerateButton as ImageToVideoGenerateButton } from "../../../../presentation/components/buttons";
 export type { GenerateButtonProps as ImageToVideoGenerateButtonProps } from "../../../../presentation/components/buttons";

package/src/index.ts

@@ -3,10 +3,6 @@
  * Provider-agnostic AI generation orchestration
  */
 
-if (typeof __DEV__ !== "undefined" && __DEV__) {
-  console.log("📍 [LIFECYCLE] @umituz/react-native-ai-generation-content/index.ts - Module loading");
-}
-
 // Domain Layer
 export * from "./exports/domain";
 

package/src/infrastructure/constants/index.ts

@@ -2,8 +2,20 @@
  * Infrastructure Constants
  */
 
-/** Video generation timeout in milliseconds (5 minutes) */
+// Polling Constants
+export * from "./polling.constants";
+
+// Validation Constants
+export * from "./validation.constants";
+
+// Content Moderation Constants
+export * from "./content.constants";
+
+// Storage Constants
+export * from "./storage.constants";
+
+/** Video generation timeout in milliseconds (5 minutes) - @deprecated Use DEFAULT_MAX_POLL_TIME_MS instead */
 export const VIDEO_TIMEOUT_MS = 300000;
 
-/** Maximum consecutive transient errors before failing */
+/** Maximum consecutive transient errors before failing - @deprecated Use DEFAULT_MAX_CONSECUTIVE_ERRORS instead */
 export const MAX_TRANSIENT_ERRORS = 5;

package/src/infrastructure/constants/polling.constants.ts

@@ -0,0 +1,34 @@
+/**
+ * Polling Constants
+ * All timeout, interval, and retry related constants
+ */
+
+/** Default polling interval for job status checks (milliseconds) */
+export const DEFAULT_POLL_INTERVAL_MS = 3000;
+
+/** Gallery polling interval (slower than wizard) */
+export const GALLERY_POLL_INTERVAL_MS = 5000;
+
+/** Maximum number of polling attempts before timeout */
+export const DEFAULT_MAX_POLL_ATTEMPTS = 100;
+
+/** Maximum consecutive transient errors before aborting */
+export const DEFAULT_MAX_CONSECUTIVE_ERRORS = 5;
+
+/** Maximum total time for polling (milliseconds) - ~5 minutes */
+export const DEFAULT_MAX_POLL_TIME_MS = 5 * 60 * 1000;
+
+/** Minimum backoff delay (milliseconds) */
+export const MIN_BACKOFF_DELAY_MS = 1000;
+
+/** Maximum backoff delay (milliseconds) */
+export const MAX_BACKOFF_DELAY_MS = 30000;
+
+/** Exponential backoff base multiplier */
+export const BACKOFF_MULTIPLIER = 1.5;
+
+/** Progress percentage to report when job completes */
+export const COMPLETION_PROGRESS = 100;
+
+/** Initial progress percentage */
+export const INITIAL_PROGRESS = 0;

package/src/infrastructure/constants/storage.constants.ts

@@ -0,0 +1,25 @@
+/**
+ * Storage Constants
+ * Database and storage related constants
+ */
+
+/** Maximum number of creations to fetch in one query */
+export const MAX_CREATIONS_FETCH_LIMIT = 100;
+
+/** Default number of creations per page */
+export const DEFAULT_CREATIONS_PAGE_SIZE = 20;
+
+/** Maximum number of logs to keep in memory */
+export const MAX_LOG_ENTRIES = 1000;
+
+/** Timeout for database operations (milliseconds) */
+export const DB_OPERATION_TIMEOUT_MS = 10000;
+
+/** Maximum cache size for frequently accessed data */
+export const MAX_CACHE_SIZE = 100;
+
+/** Cache TTL for creations (milliseconds) - 5 minutes */
+export const CREATIONS_CACHE_TTL_MS = 5 * 60 * 1000;
+
+/** Cache TTL for user data (milliseconds) - 10 minutes */
+export const USER_DATA_CACHE_TTL_MS = 10 * 60 * 1000;

package/src/infrastructure/constants/validation.constants.ts

@@ -0,0 +1,40 @@
+/**
+ * Validation Constants
+ * All validation limits and constraints
+ */
+
+/** Maximum length for AI prompt text */
+export const MAX_PROMPT_LENGTH = 10000;
+
+/** Minimum length for AI prompt text */
+export const MIN_PROMPT_LENGTH = 1;
+
+/** Maximum length for user ID */
+export const MAX_USER_ID_LENGTH = 128;
+
+/** Maximum length for creation ID */
+export const MAX_CREATION_ID_LENGTH = 128;
+
+/** Maximum base64 string length (before encoding) */
+export const MAX_BASE64_SIZE_MB = 20;
+
+/** Maximum regex pattern length for validation */
+export const MAX_PATTERN_LENGTH = 1000;
+
+/** Maximum duration for video generation (seconds) */
+export const MAX_VIDEO_DURATION_SECONDS = 60;
+
+/** Minimum duration for video generation (seconds) */
+export const MIN_VIDEO_DURATION_SECONDS = 3;
+
+/** Maximum image file size (MB) */
+export const MAX_IMAGE_SIZE_MB = 10;
+
+/** Maximum URL length */
+export const MAX_URL_LENGTH = 2048;
+
+/** Maximum number of images in multi-image generation */
+export const MAX_MULTI_IMAGE_COUNT = 10;
+
+/** Minimum number of images for multi-image generation */
+export const MIN_MULTI_IMAGE_COUNT = 2;

package/src/infrastructure/logging/logger.ts

@@ -0,0 +1,185 @@
+/**
+ * Production-Ready Logging Utility
+ * Provides structured logging with levels and context
+ */
+
+declare const __DEV__: boolean;
+
+export enum LogLevel {
+  DEBUG = 0,
+  INFO = 1,
+  WARN = 2,
+  ERROR = 3,
+  NONE = 4,
+}
+
+export interface LogContext {
+  readonly [key: string]: unknown;
+}
+
+export interface LogEntry {
+  readonly level: LogLevel;
+  readonly timestamp: number;
+  readonly message: string;
+  readonly context?: LogContext;
+  readonly error?: Error;
+}
+
+class Logger {
+  private minLevel: LogLevel;
+  private logs: LogEntry[] = [];
+  private maxLogs = 1000;
+
+  constructor() {
+    // In production, only log WARN and ERROR
+    this.minLevel =
+      typeof __DEV__ !== "undefined" && __DEV__ ? LogLevel.DEBUG : LogLevel.WARN;
+  }
+
+  setMinLevel(level: LogLevel): void {
+    this.minLevel = level;
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    return level >= this.minLevel;
+  }
+
+  private addLog(entry: LogEntry): void {
+    this.logs.push(entry);
+    // Keep only last maxLogs entries
+    if (this.logs.length > this.maxLogs) {
+      this.logs.shift();
+    }
+  }
+
+  private formatMessage(entry: LogEntry): string {
+    const levelName = LogLevel[entry.level];
+    const timestamp = new Date(entry.timestamp).toISOString();
+    const contextStr = entry.context
+      ? ` ${JSON.stringify(entry.context)}`
+      : "";
+    const errorStr = entry.error ? ` ${entry.error.message}` : "";
+    return `[${timestamp}] [${levelName}] ${entry.message}${contextStr}${errorStr}`;
+  }
+
+  debug(message: string, context?: LogContext): void {
+    if (!this.shouldLog(LogLevel.DEBUG)) return;
+
+    const entry: LogEntry = {
+      level: LogLevel.DEBUG,
+      timestamp: Date.now(),
+      message,
+      context,
+    };
+
+    this.addLog(entry);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log(`[DEBUG] ${message}`, context || "");
+    }
+  }
+
+  info(message: string, context?: LogContext): void {
+    if (!this.shouldLog(LogLevel.INFO)) return;
+
+    const entry: LogEntry = {
+      level: LogLevel.INFO,
+      timestamp: Date.now(),
+      message,
+      context,
+    };
+
+    this.addLog(entry);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.info(`[INFO] ${message}`, context || "");
+    }
+  }
+
+  warn(message: string, context?: LogContext): void {
+    if (!this.shouldLog(LogLevel.WARN)) return;
+
+    const entry: LogEntry = {
+      level: LogLevel.WARN,
+      timestamp: Date.now(),
+      message,
+      context,
+    };
+
+    this.addLog(entry);
+    console.warn(`[WARN] ${message}`, context || "");
+  }
+
+  error(message: string, error?: Error | unknown, context?: LogContext): void {
+    if (!this.shouldLog(LogLevel.ERROR)) return;
+
+    const errorObj =
+      error instanceof Error ? error : error ? new Error(String(error)) : undefined;
+
+    const entry: LogEntry = {
+      level: LogLevel.ERROR,
+      timestamp: Date.now(),
+      message,
+      context,
+      error: errorObj,
+    };
+
+    this.addLog(entry);
+    console.error(`[ERROR] ${message}`, errorObj || "", context || "");
+  }
+
+  getLogs(level?: LogLevel): readonly LogEntry[] {
+    if (level !== undefined) {
+      return this.logs.filter((log) => log.level >= level);
+    }
+    return this.logs;
+  }
+
+  clearLogs(): void {
+    this.logs = [];
+  }
+
+  // Convenience methods for specific domains
+  processing(message: string, context?: LogContext): void {
+    this.debug(`[Processing] ${message}`, context);
+  }
+
+  generation(message: string, context?: LogContext): void {
+    this.debug(`[Generation] ${message}`, context);
+  }
+
+  polling(message: string, context?: LogContext): void {
+    this.debug(`[Polling] ${message}`, context);
+  }
+
+  moderation(message: string, context?: LogContext): void {
+    this.info(`[Moderation] ${message}`, context);
+  }
+
+  network(message: string, context?: LogContext): void {
+    this.info(`[Network] ${message}`, context);
+  }
+
+  storage(message: string, context?: LogContext): void {
+    this.debug(`[Storage] ${message}`, context);
+  }
+
+  validation(message: string, context?: LogContext): void {
+    this.warn(`[Validation] ${message}`, context);
+  }
+}
+
+// Singleton instance
+export const logger = new Logger();
+
+// Development helper
+export function setDevelopmentMode(): void {
+  logger.setMinLevel(LogLevel.DEBUG);
+}
+
+// Production helper
+export function setProductionMode(): void {
+  logger.setMinLevel(LogLevel.WARN);
+}
+
+export type { LogEntry, LogContext };

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

@@ -8,11 +8,8 @@ import { DEFAULT_POLLING_CONFIG } from "../../domain/entities";
 import { calculatePollingInterval } from "../utils/polling-interval.util";
 import { checkStatusForErrors, isJobComplete } from "../utils/status-checker.util";
 import { validateResult } from "../utils/result-validator.util";
-import { isTransientError } from "../utils/error-classifier.util";
 import type { PollJobOptions, PollJobResult } from "./job-poller.types";
 
-declare const __DEV__: boolean;
-
 /**
  * Poll job until completion with exponential backoff
  * Only reports 100% on actual completion
@@ -31,18 +28,28 @@ export async function pollJob<T = unknown>(
   } = options;
 
   const pollingConfig = { ...DEFAULT_POLLING_CONFIG, ...config };
-  const { maxAttempts, maxConsecutiveErrors } = pollingConfig;
+  const { maxAttempts, maxTotalTimeMs } = 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: Date.now() - startTime,
+        elapsedMs,
       };
     }
 
@@ -91,28 +98,6 @@ export async function pollJob<T = unknown>(
         };
       }
     } catch (error) {
-      if (isTransientError(error)) {
-        consecutiveTransientErrors++;
-
-        if (consecutiveTransientErrors >= maxConsecutiveErrors) {
-          return {
-            success: false,
-            error: error instanceof Error ? error : new Error(String(error)),
-            attempts: attempt + 1,
-            elapsedMs: Date.now() - startTime,
-          };
-        }
-
-        if (attempt < maxAttempts - 1) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log(
-              `[JobPoller] Transient error, retrying (${attempt + 1}/${maxAttempts})`,
-            );
-          }
-          continue;
-        }
-      }
-
       return {
         success: false,
         error: error instanceof Error ? error : new Error(String(error)),

package/src/infrastructure/utils/status-checker.util.ts

@@ -12,6 +12,27 @@ export interface StatusCheckResult {
   shouldStop: boolean;
 }
 
+/**
+ * Type guard to check if object has a property
+ */
+function hasProperty<K extends PropertyKey>(
+  obj: unknown,
+  prop: K
+): obj is Record<K, unknown> {
+  return typeof obj === "object" && obj !== null && prop in obj;
+}
+
+/**
+ * Safely get a string property from an object
+ */
+function safeString(obj: unknown, key: PropertyKey): string {
+  if (hasProperty(obj, key)) {
+    const value = obj[key];
+    return typeof value === "string" ? value : String(value ?? "");
+  }
+  return "";
+}
+
 /**
  * Check job status response for errors
  * Detects errors even if status is not explicitly FAILED
@@ -19,16 +40,15 @@ export interface StatusCheckResult {
 export function checkStatusForErrors(
   status: JobStatus | Record<string, unknown>,
 ): StatusCheckResult {
-  const statusString = String(
-    (status as Record<string, unknown>)?.status || "",
-  ).toUpperCase();
+  // Safely extract status string
+  const statusString = safeString(status, "status").toUpperCase();
 
   // Check for error in status response fields
   const statusError =
-    (status as Record<string, unknown>)?.error ||
-    (status as Record<string, unknown>)?.detail ||
-    (status as Record<string, unknown>)?.message;
-  const hasStatusError = !!statusError;
+    safeString(status, "error") ||
+    safeString(status, "detail") ||
+    safeString(status, "message");
+  const hasStatusError = statusError.length > 0;
 
   // Check logs array for ERROR/FATAL level logs
   const rawLogs = (status as JobStatus)?.logs;