@umituz/react-native-ai-generation-content 1.65.1 → 1.65.3

package/src/domain/interfaces/ai-provider.interface.ts

@@ -1,158 +1,48 @@
 /**
- * AI Provider Interface
+ * AI Provider Interface - Barrel Export
  * Provider-agnostic interface for AI generation services
+ *
+ * Architecture:
+ * - Feature Types: ImageFeatureType, VideoFeatureType enums
+ * - Configuration: AIProviderConfig for initialization
+ * - Status: Job status tracking types
+ * - Progress: Progress tracking and callback options
+ * - Capabilities: Provider feature support definition
+ * - Input: Input data structures for features
+ * - Main Interface: Composed IAIProvider using Interface Segregation Principle
  */
 
-// =============================================================================
-// Feature Types (must be defined first for use in other interfaces)
-// =============================================================================
+// Feature Types
+export type { ImageFeatureType, VideoFeatureType } from "./ai-provider-feature-types";
 
-/**
- * Feature types for image processing (output: image)
- */
-export type ImageFeatureType =
-  | "upscale"
-  | "photo-restore"
-  | "face-swap"
-  | "anime-selfie"
-  | "remove-background"
-  | "remove-object"
-  | "hd-touch-up"
-  | "replace-background";
-
-/**
- * Feature types for video generation (output: video)
- */
-export type VideoFeatureType =
-  | "image-to-video"
-  | "text-to-video";
-
-// =============================================================================
-// Provider Configuration
-// =============================================================================
-
-export interface AIProviderConfig {
-  apiKey: string;
-  maxRetries?: number;
-  baseDelay?: number;
-  maxDelay?: number;
-  defaultTimeoutMs?: number;
-  /** Text generation model ID */
-  textModel?: string;
-  /** Text-to-image generation model ID */
-  textToImageModel?: string;
-  /** Image editing model ID */
-  imageEditModel?: string;
-  /** Video generation model ID */
-  videoGenerationModel?: string;
-  /** Video feature model mapping - app provides models for each feature */
-  videoFeatureModels?: Partial<Record<VideoFeatureType, string>>;
-  /** Image feature model mapping - app provides models for each feature */
-  imageFeatureModels?: Partial<Record<ImageFeatureType, string>>;
-}
+// Configuration
+export type { AIProviderConfig } from "./ai-provider-config.types";
 
-// =============================================================================
 // Status Types
-// =============================================================================
-
-export type AIJobStatusType =
-  | "IN_QUEUE"
-  | "IN_PROGRESS"
-  | "COMPLETED"
-  | "FAILED";
-
-export interface AILogEntry {
-  message: string;
-  level: "info" | "warn" | "error";
-  timestamp?: string;
-}
-
-export interface JobSubmission {
-  requestId: string;
-  statusUrl?: string;
-  responseUrl?: string;
-}
-
-export interface JobStatus {
-  status: AIJobStatusType;
-  logs?: AILogEntry[];
-  queuePosition?: number;
-  eta?: number;
-}
+export type {
+  AIJobStatusType,
+  AILogEntry,
+  JobSubmission,
+  JobStatus,
+} from "./ai-provider-status.types";
 
-// =============================================================================
 // Progress & Options
-// =============================================================================
-
-export interface ProviderProgressInfo {
-  /** Progress percentage (0-100) */
-  progress: number;
-  /** Current job status */
-  status?: AIJobStatusType;
-  /** Human-readable message */
-  message?: string;
-  /** Estimated time remaining in ms */
-  estimatedTimeRemaining?: number;
-}
-
-export interface SubscribeOptions<T = unknown> {
-  timeoutMs?: number;
-  onQueueUpdate?: (status: JobStatus) => void;
-  onProgress?: (progress: ProviderProgressInfo) => void;
-  onResult?: (result: T) => void;
-}
-
-export interface RunOptions {
-  onProgress?: (progress: ProviderProgressInfo) => void;
-}
+export type {
+  ProviderProgressInfo,
+  SubscribeOptions,
+  RunOptions,
+} from "./ai-provider-progress.types";
 
-// =============================================================================
 // Capabilities
-// =============================================================================
-
-export interface ProviderCapabilities {
-  /** Supported image features */
-  imageFeatures: readonly ImageFeatureType[];
-  /** Supported video features */
-  videoFeatures: readonly VideoFeatureType[];
-  /** Supports text-to-image generation */
-  textToImage: boolean;
-  /** Supports text-to-video generation */
-  textToVideo: boolean;
-  /** Supports image-to-video generation */
-  imageToVideo: boolean;
-  /** Supports text-to-voice generation */
-  textToVoice: boolean;
-  /** Supports text-to-text (LLM) generation */
-  textToText: boolean;
-}
-
-// =============================================================================
-// Feature Input Data
-// =============================================================================
-
-export interface ImageFeatureInputData {
-  imageBase64: string;
-  targetImageBase64?: string;
-  prompt?: string;
-  options?: Record<string, unknown>;
-}
-
-export interface VideoFeatureInputData {
-  /** Source image (required for image-to-video, optional for text-to-video) */
-  sourceImageBase64?: string;
-  /** Target image (optional, used for dual-image features) */
-  targetImageBase64?: string;
-  /** Generation prompt (required for text-to-video) */
-  prompt?: string;
-  /** Additional generation options */
-  options?: Record<string, unknown>;
-}
+export type { ProviderCapabilities } from "./ai-provider-capabilities.types";
 
-// =============================================================================
-// Provider Interface (Composition using Interface Segregation Principle)
-// =============================================================================
+// Input Data
+export type {
+  ImageFeatureInputData,
+  VideoFeatureInputData,
+} from "./ai-provider-input.types";
 
+// Main Interface Composition (Interface Segregation Principle)
 import type { IAIProviderLifecycle } from "./provider-lifecycle.interface";
 import type { IAIProviderCapabilities } from "./provider-capabilities.interface";
 import type { IAIProviderJobManager } from "../../domains/background/domain/interfaces/provider-job-manager.interface";

package/src/domain/types/result-constructors.ts

@@ -0,0 +1,20 @@
+/**
+ * Result Constructors
+ * Domain Service: Factory functions for creating Result types
+ */
+
+import type { Success, Failure } from "./result-type-definitions";
+
+/**
+ * Create a successful result
+ */
+export function success<T>(value: T): Success<T> {
+  return { success: true, value };
+}
+
+/**
+ * Create a failed result
+ */
+export function failure<E>(error: E): Failure<E> {
+  return { success: false, error };
+}

package/src/domain/types/result-guards.ts

@@ -0,0 +1,20 @@
+/**
+ * Result Type Guards
+ * Domain Service: Type guards for Result pattern
+ */
+
+import type { Result, Success, Failure } from "./result-type-definitions";
+
+/**
+ * Type guard to check if result is successful
+ */
+export function isSuccess<T, E>(result: Result<T, E>): result is Success<T> {
+  return result.success === true;
+}
+
+/**
+ * Type guard to check if result is a failure
+ */
+export function isFailure<T, E>(result: Result<T, E>): result is Failure<E> {
+  return result.success === false;
+}

package/src/domain/types/result-transformers.ts

@@ -0,0 +1,36 @@
+/**
+ * Result Transformers
+ * Domain Service: Transform and chain Result types
+ */
+
+import type { Result } from "./result-type-definitions";
+import { isSuccess } from "./result-guards";
+import { success } from "./result-constructors";
+
+/**
+ * Map a successful result to a new value
+ * If result is failure, returns the failure unchanged
+ */
+export function mapResult<T, U, E>(
+  result: Result<T, E>,
+  fn: (value: T) => U
+): Result<U, E> {
+  if (isSuccess(result)) {
+    return success(fn(result.value));
+  }
+  return result;
+}
+
+/**
+ * Chain async operations on Result types
+ * Similar to Promise.then() but for Result
+ */
+export async function andThen<T, U, E>(
+  result: Result<T, E>,
+  fn: (value: T) => Promise<Result<U, E>>
+): Promise<Result<U, E>> {
+  if (isSuccess(result)) {
+    return fn(result.value);
+  }
+  return result;
+}

package/src/domain/types/result-type-definitions.ts

@@ -0,0 +1,27 @@
+/**
+ * Result Type Definitions
+ * Domain: Core types for functional error handling
+ * Inspired by Rust's Result<T, E> type
+ */
+
+/**
+ * Success result containing a value of type T
+ */
+export interface Success<T> {
+  success: true;
+  value: T;
+}
+
+/**
+ * Failure result containing an error of type E
+ */
+export interface Failure<E> {
+  success: false;
+  error: E;
+}
+
+/**
+ * Result type that can be either Success or Failure
+ * Forces explicit error handling at compile time
+ */
+export type Result<T, E = string> = Success<T> | Failure<E>;

package/src/domain/types/result-unwrappers.ts

@@ -0,0 +1,28 @@
+/**
+ * Result Unwrappers
+ * Domain Service: Unwrap Result types to values
+ */
+
+import type { Result } from "./result-type-definitions";
+import { isSuccess } from "./result-guards";
+
+/**
+ * Unwrap a result, throwing if it's a failure
+ * Use only when you're certain the result is successful
+ */
+export function unwrap<T, E>(result: Result<T, E>): T {
+  if (isSuccess(result)) {
+    return result.value;
+  }
+  throw new Error(`Called unwrap on a failure: ${String(result.error)}`);
+}
+
+/**
+ * Unwrap a result or return a default value
+ */
+export function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {
+  if (isSuccess(result)) {
+    return result.value;
+  }
+  return defaultValue;
+}

package/src/domain/types/result.types.ts

@@ -1,105 +1,16 @@
 /**
- * Result Type Pattern for Functional Error Handling
- * Inspired by Rust's Result<T, E> type
+ * Result Type Pattern - Barrel Export
+ * Functional error handling inspired by Rust's Result<T, E>
+ *
+ * Architecture:
+ * - Domain: Type definitions (Success, Failure, Result)
+ * - Domain Services: Constructors, guards, transformers, unwrappers
  *
  * @see https://arg-software.medium.com/functional-error-handling-in-typescript-with-the-result-pattern-5b96a5abb6d3
  */
 
-/**
- * Success result containing a value of type T
- */
-export interface Success<T> {
-  success: true;
-  value: T;
-}
-
-/**
- * Failure result containing an error of type E
- */
-export interface Failure<E> {
-  success: false;
-  error: E;
-}
-
-/**
- * Result type that can be either Success or Failure
- * Forces explicit error handling at compile time
- */
-export type Result<T, E = string> = Success<T> | Failure<E>;
-
-/**
- * Create a successful result
- */
-export function success<T>(value: T): Success<T> {
-  return { success: true, value };
-}
-
-/**
- * Create a failed result
- */
-export function failure<E>(error: E): Failure<E> {
-  return { success: false, error };
-}
-
-/**
- * Type guard to check if result is successful
- */
-export function isSuccess<T, E>(result: Result<T, E>): result is Success<T> {
-  return result.success === true;
-}
-
-/**
- * Type guard to check if result is a failure
- */
-export function isFailure<T, E>(result: Result<T, E>): result is Failure<E> {
-  return result.success === false;
-}
-
-/**
- * Map a successful result to a new value
- * If result is failure, returns the failure unchanged
- */
-export function mapResult<T, U, E>(
-  result: Result<T, E>,
-  fn: (value: T) => U,
-): Result<U, E> {
-  if (isSuccess(result)) {
-    return success(fn(result.value));
-  }
-  return result;
-}
-
-/**
- * Chain async operations on Result types
- * Similar to Promise.then() but for Result
- */
-export async function andThen<T, U, E>(
-  result: Result<T, E>,
-  fn: (value: T) => Promise<Result<U, E>>,
-): Promise<Result<U, E>> {
-  if (isSuccess(result)) {
-    return fn(result.value);
-  }
-  return result;
-}
-
-/**
- * Unwrap a result, throwing if it's a failure
- * Use only when you're certain the result is successful
- */
-export function unwrap<T, E>(result: Result<T, E>): T {
-  if (isSuccess(result)) {
-    return result.value;
-  }
-  throw new Error(`Called unwrap on a failure: ${String(result.error)}`);
-}
-
-/**
- * Unwrap a result or return a default value
- */
-export function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {
-  if (isSuccess(result)) {
-    return result.value;
-  }
-  return defaultValue;
-}
+export type { Success, Failure, Result } from "./result-type-definitions";
+export { success, failure } from "./result-constructors";
+export { isSuccess, isFailure } from "./result-guards";
+export { mapResult, andThen } from "./result-transformers";
+export { unwrap, unwrapOr } from "./result-unwrappers";

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

@@ -1,6 +1,5 @@
 /**
  * Polling Interval Calculator
- * Calculates polling intervals with exponential backoff
  */
 
 import {
@@ -10,16 +9,12 @@ import {
 
 export interface IntervalOptions {
   attempt: number;
-  config?: Partial<PollingConfig>;
+  config: PollingConfig;
 }
 
 export function calculatePollingInterval(options: IntervalOptions): number {
   const { attempt, config } = options;
-  const {
-    initialIntervalMs = DEFAULT_POLLING_CONFIG.initialIntervalMs,
-    maxIntervalMs = DEFAULT_POLLING_CONFIG.maxIntervalMs,
-    backoffMultiplier = DEFAULT_POLLING_CONFIG.backoffMultiplier,
-  } = config ?? {};
+  const { initialIntervalMs, maxIntervalMs, backoffMultiplier } = config;
 
   if (attempt === 0) {
     return 0;
@@ -27,4 +22,4 @@ export function calculatePollingInterval(options: IntervalOptions): number {
 
   const interval = initialIntervalMs * Math.pow(backoffMultiplier, attempt - 1);
   return Math.min(interval, maxIntervalMs);
-}
+}

package/src/domains/background/infrastructure/utils/result-validation-logic.ts

@@ -0,0 +1,88 @@
+/**
+ * Result Validation Logic
+ * Infrastructure: Validates job results
+ */
+
+import type { ResultValidation, ValidateResultOptions } from "./result-validator.types";
+import { DEFAULT_OUTPUT_FIELDS } from "./result-validator-constants";
+
+declare const __DEV__: boolean;
+
+/**
+ * Validate job result and detect errors
+ * Checks for error fields even if job status was COMPLETED
+ */
+export function validateResult(
+  result: unknown,
+  options?: ValidateResultOptions
+): ResultValidation {
+  const { outputFields = DEFAULT_OUTPUT_FIELDS, allowEmpty = false } =
+    options ?? {};
+
+  if (result === null || result === undefined) {
+    return {
+      isValid: allowEmpty,
+      hasError: !allowEmpty,
+      errorMessage: allowEmpty ? undefined : "Result is empty",
+      hasOutput: false,
+    };
+  }
+
+  if (typeof result !== "object") {
+    return {
+      isValid: true,
+      hasError: false,
+      hasOutput: true,
+    };
+  }
+
+  const resultObj = result as Record<string, unknown>;
+
+  const errorValue = resultObj.error || resultObj.detail;
+  const errorString = errorValue ? String(errorValue).toLowerCase() : "";
+
+  const hasInternalServerError =
+    errorString.includes("internal server error") ||
+    errorString.includes("500") ||
+    errorString === "internal server error";
+
+  const isEmpty = Object.keys(resultObj).length === 0;
+
+  const hasOutput = outputFields.some((field) => {
+    const value = resultObj[field];
+    if (!value) return false;
+
+    if (typeof value === "object" && value !== null) {
+      const nested = value as Record<string, unknown>;
+      const nestedKeys = Object.keys(nested);
+      return !!(
+        nested.url ||
+        nested.image_url ||
+        nested.video_url ||
+        nestedKeys.length > 0
+      );
+    }
+
+    return true;
+  });
+
+  const hasError =
+    hasInternalServerError || (isEmpty && !hasOutput && !allowEmpty);
+
+  const validation: ResultValidation = {
+    isValid: !hasError && (hasOutput || allowEmpty),
+    hasError,
+    errorMessage: hasError && errorValue ? String(errorValue) : undefined,
+    hasOutput,
+  };
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[ResultValidator] Validation result:", {
+      isValid: validation.isValid,
+      hasOutput: validation.hasOutput,
+      hasError: validation.hasError,
+    });
+  }
+
+  return validation;
+}

package/src/domains/background/infrastructure/utils/result-validator-constants.ts

@@ -0,0 +1,18 @@
+/**
+ * Result Validator Constants
+ * Domain: Known output field names
+ */
+
+export const DEFAULT_OUTPUT_FIELDS = [
+  "data",
+  "output",
+  "image",
+  "image_url",
+  "images",
+  "video",
+  "video_url",
+  "url",
+  "result",
+  "text",
+  "content",
+] as const;

package/src/domains/background/infrastructure/utils/result-validator.types.ts

@@ -0,0 +1,16 @@
+/**
+ * Result Validator Types
+ * Domain: Value objects for result validation
+ */
+
+export interface ResultValidation {
+  isValid: boolean;
+  hasError: boolean;
+  errorMessage?: string;
+  hasOutput: boolean;
+}
+
+export interface ValidateResultOptions {
+  outputFields?: string[];
+  allowEmpty?: boolean;
+}