@umituz/react-native-ai-fal-provider 3.2.51 → 3.2.53

package/src/infrastructure/utils/fal-error-handler.util.ts

@@ -1,174 +1,42 @@
 /**
- * FAL Error Handler
- * Uses @fal-ai/client error types (ApiError, ValidationError) for proper error handling
- * No silent fallbacks - errors are categorized explicitly
+ * FAL Error Handler (Infrastructure Layer)
+ * Delegates to domain ErrorClassificationService for error handling logic
+ *
+ * This file now serves as a thin adapter layer for backward compatibility.
+ * The actual error handling logic has been moved to the domain layer.
  */
 
-import { ApiError, ValidationError } from "@fal-ai/client";
+import { ErrorClassificationService } from "../../domain/services/ErrorClassificationService";
 import type { FalErrorInfo, FalErrorCategory } from "../../domain/entities/error.types";
-import { FalErrorType } from "../../domain/entities/error.types";
-
-/**
- * HTTP status code to error type mapping
- */
-const STATUS_TO_ERROR_TYPE: Record<number, FalErrorType> = {
-  400: FalErrorType.VALIDATION,
-  401: FalErrorType.AUTHENTICATION,
-  402: FalErrorType.QUOTA_EXCEEDED,
-  403: FalErrorType.AUTHENTICATION,
-  404: FalErrorType.MODEL_NOT_FOUND,
-  422: FalErrorType.VALIDATION,
-  429: FalErrorType.RATE_LIMIT,
-  500: FalErrorType.API_ERROR,
-  502: FalErrorType.API_ERROR,
-  503: FalErrorType.API_ERROR,
-  504: FalErrorType.API_ERROR,
-};
-
-const RETRYABLE_TYPES = new Set<FalErrorType>([
-  FalErrorType.NETWORK,
-  FalErrorType.TIMEOUT,
-  FalErrorType.RATE_LIMIT,
-]);
-
-/**
- * Message-based error type detection (for non-ApiError errors)
- */
-const MESSAGE_PATTERNS: Array<{ type: FalErrorType; patterns: string[] }> = [
-  { type: FalErrorType.NETWORK, patterns: ["network", "fetch", "econnrefused", "enotfound", "etimedout"] },
-  { type: FalErrorType.TIMEOUT, patterns: ["timeout", "timed out"] },
-  { type: FalErrorType.CONTENT_POLICY, patterns: ["nsfw", "content_policy", "content policy", "policy violation"] },
-  { type: FalErrorType.IMAGE_TOO_SMALL, patterns: ["image_too_small", "image dimensions are too small", "minimum dimensions"] },
-];
-
-/**
- * Categorize error using @fal-ai/client error types
- * Priority: ApiError status code > message pattern matching
- */
-function categorizeError(error: unknown): FalErrorCategory {
-  // 1. ApiError (includes ValidationError) - use HTTP status code
-  if (error instanceof ApiError) {
-    const typeFromStatus = STATUS_TO_ERROR_TYPE[error.status];
-    if (typeFromStatus) {
-      return {
-        type: typeFromStatus,
-        messageKey: typeFromStatus,
-        retryable: RETRYABLE_TYPES.has(typeFromStatus),
-      };
-    }
-    // Unknown status code - still an API error
-    return { type: FalErrorType.API_ERROR, messageKey: "api_error", retryable: false };
-  }
-
-  // 2. Standard Error - match message patterns
-  const message = (error instanceof Error ? error.message : error != null ? String(error) : "unknown").toLowerCase();
-
-  for (const { type, patterns } of MESSAGE_PATTERNS) {
-    if (patterns.some((p) => message.includes(p))) {
-      return { type, messageKey: type, retryable: RETRYABLE_TYPES.has(type) };
-    }
-  }
-
-  // 3. No match - UNKNOWN, not retryable
-  return { type: FalErrorType.UNKNOWN, messageKey: "unknown", retryable: false };
-}
-
-/**
- * Extract user-readable message from error
- * Uses @fal-ai/client types for structured extraction
- */
-function extractMessage(error: unknown): string {
-  // ValidationError - extract field-level messages
-  if (error instanceof ValidationError) {
-    const fieldErrors = error.fieldErrors;
-    if (Array.isArray(fieldErrors) && fieldErrors.length > 0) {
-      // Safely extract messages from field errors with validation
-      const messages = fieldErrors
-        .map((e) => (e && typeof e === 'object' && 'msg' in e && typeof e.msg === 'string' ? e.msg : null))
-        .filter((msg): msg is string => msg !== null);
-      if (messages.length > 0) return messages.join("; ");
-    }
-    return error.message;
-  }
-
-  // ApiError - extract from body or message
-  if (error instanceof ApiError) {
-    // body may contain detail array - validate structure before access
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const body = error.body;
-
-    // Type guard for detail array structure
-    interface DetailItem {
-      msg?: string;
-    }
-    interface BodyWithDetail {
-      detail?: DetailItem[];
-    }
-
-    const validatedBody = body as BodyWithDetail | undefined;
-
-    if (
-      validatedBody &&
-      validatedBody.detail &&
-      Array.isArray(validatedBody.detail) &&
-      validatedBody.detail.length > 0
-    ) {
-      const firstItem = validatedBody.detail[0];
-      if (
-        firstItem &&
-        typeof firstItem === "object" &&
-        typeof firstItem.msg === "string" &&
-        firstItem.msg
-      ) {
-        return firstItem.msg;
-      }
-    }
-    return error.message;
-  }
-
-  // Standard Error
-  if (error instanceof Error) {
-    return error.message;
-  }
-
-  return error != null ? String(error) : "Unknown error";
-}
 
 /**
  * Map error to FalErrorInfo with full categorization
+ * Delegates to domain ErrorClassificationService
  */
 export function mapFalError(error: unknown): FalErrorInfo {
-  const category = categorizeError(error);
-  const message = extractMessage(error);
-
-  return {
-    type: category.type,
-    messageKey: `fal.errors.${category.messageKey}`,
-    retryable: category.retryable,
-    originalError: message,
-    originalErrorName: error instanceof Error ? error.name : undefined,
-    stack: error instanceof Error ? error.stack : undefined,
-    statusCode: error instanceof ApiError ? error.status : undefined,
-  };
+  return ErrorClassificationService.mapError(error);
 }
 
 /**
  * Parse FAL error and return user-friendly message
+ * Delegates to domain ErrorClassificationService
  */
 export function parseFalError(error: unknown): string {
-  return extractMessage(error);
+  return ErrorClassificationService.extractMessage(error);
 }
 
 /**
  * Categorize FAL error
+ * Delegates to domain ErrorClassificationService
  */
 export function categorizeFalError(error: unknown): FalErrorCategory {
-  return categorizeError(error);
+  return ErrorClassificationService.categorizeError(error);
 }
 
 /**
  * Check if FAL error is retryable
+ * Delegates to domain ErrorClassificationService
  */
 export function isFalErrorRetryable(error: unknown): boolean {
-  return categorizeError(error).retryable;
+  return ErrorClassificationService.isRetryable(error);
 }

package/src/infrastructure/utils/fal-storage.util.ts

@@ -9,8 +9,7 @@ import {
   base64ToTempFile,
   deleteTempFile,
 } from "@umituz/react-native-design-system/filesystem";
-import { getErrorMessage } from './helpers/error-helpers.util';
-import { getElapsedTime, getActualSizeKB } from './helpers';
+import { getErrorMessage, getElapsedTime, getActualSizeKB, sleep } from "../../shared/helpers";
 import { generationLogCollector } from './log-collector';
 import { UPLOAD_CONFIG } from '../services/fal-provider.constants';
 
@@ -43,7 +42,7 @@ async function withRetry<T>(
       if (attempt > 0) {
         const delay = baseDelay * Math.pow(2, attempt - 1);
         generationLogCollector.warn(sessionId, TAG, `Retry ${attempt}/${maxRetries} for ${label} after ${delay}ms`);
-        await new Promise(resolve => setTimeout(resolve, delay));
+        await sleep(delay);
       }
       return await fn();
     } catch (error) {

package/src/infrastructure/utils/helpers/index.ts

@@ -1,8 +1,6 @@
 /**
  * Helper Utilities - Centralized Exports
+ * Re-exports from shared utilities layer for backward compatibility
  */
 
-export * from './timing-helpers.util';
-export * from './object-helpers.util';
-export * from './calculation-helpers.util';
-export * from './error-helpers.util';
+export * from '../../../shared/helpers';

package/src/infrastructure/utils/image-helpers.util.ts

@@ -1,47 +1,33 @@
 /**
- * Image Helper Utilities
- * Functions for image data URI manipulation
+ * Image Helper Utilities (Infrastructure Layer)
+ * Delegates to domain ImageProcessingService for image data manipulation
+ *
+ * This file now serves as a thin adapter layer for backward compatibility.
+ * The actual image processing logic has been moved to the domain layer.
  */
 
+import { ImageProcessingService } from "../../domain/services/ImageProcessingService";
+
 /**
  * Format image as data URI if not already formatted
+ * Delegates to domain ImageProcessingService
  */
 export function formatImageDataUri(base64: string): string {
-  if (base64.startsWith("data:")) {
-    return base64;
-  }
-  return `data:image/jpeg;base64,${base64}`;
+  return ImageProcessingService.formatImageDataUri(base64);
 }
 
 /**
  * Extract base64 from data URI
- * Uses indexOf instead of split to handle edge cases where comma might appear in base64
+ * Delegates to domain ImageProcessingService
  */
 export function extractBase64(dataUri: string): string {
-  if (!dataUri.startsWith("data:")) {
-    return dataUri;
-  }
-
-  // Find the first comma which separates header from data
-  const commaIndex = dataUri.indexOf(",");
-  if (commaIndex === -1) {
-    throw new Error(`Invalid data URI format (no comma separator): ${dataUri.substring(0, 50)}...`);
-  }
-
-  // Extract everything after the first comma
-  const base64Part = dataUri.substring(commaIndex + 1);
-
-  if (!base64Part || base64Part.length === 0) {
-    throw new Error(`Empty base64 data in URI: ${dataUri.substring(0, 50)}...`);
-  }
-
-  return base64Part;
+  return ImageProcessingService.extractBase64(dataUri);
 }
 
 /**
  * Get file extension from data URI
+ * Delegates to domain ImageProcessingService
  */
 export function getDataUriExtension(dataUri: string): string | null {
-  const match = dataUri.match(/^data:image\/(\w+);base64/);
-  return match ? match[1] : null;
+  return ImageProcessingService.getDataUriExtension(dataUri);
 }

package/src/infrastructure/utils/input-preprocessor.util.ts

@@ -8,19 +8,13 @@
  */
 
 import { uploadToFalStorage, uploadLocalFileToFalStorage } from "./fal-storage.util";
-import { getErrorMessage } from './helpers/error-helpers.util';
+import { getErrorMessage, getElapsedTime } from "../../shared/helpers";
 import { IMAGE_URL_FIELDS } from './constants/image-fields.constants';
-import { isImageDataUri as isBase64DataUri } from './validators/data-uri-validator.util';
+import { isLocalFileUri, isImageDataUri as isBase64DataUri } from "../../shared/type-guards";
 import { generationLogCollector } from './log-collector';
 
 const TAG = 'preprocessor';
 
-function isLocalFileUri(value: unknown): value is string {
-  return typeof value === "string" && (
-    value.startsWith("file://") || value.startsWith("content://")
-  );
-}
-
 /**
  * Classify a network error into a user-friendly message.
  * Technical details are preserved in Firestore logs/session subcollection.
@@ -130,7 +124,7 @@ export async function preprocessInput(
             processedUrls.push(url);
             generationLogCollector.log(sessionId, TAG, `${arrayField}[${i}/${imageUrls.length}]: upload OK`);
           } catch (error) {
-            const elapsed = Date.now() - arrayStartTime;
+            const elapsed = getElapsedTime(arrayStartTime);
             const technicalMsg = getErrorMessage(error);
             generationLogCollector.error(sessionId, TAG, `${arrayField}[${i}] upload FAILED after ${elapsed}ms: ${technicalMsg}`);
             throw new Error(classifyUploadError(technicalMsg));
@@ -143,7 +137,7 @@ export async function preprocessInput(
             processedUrls.push(url);
             generationLogCollector.log(sessionId, TAG, `${arrayField}[${i}/${imageUrls.length}]: local file upload OK`);
           } catch (error) {
-            const elapsed = Date.now() - arrayStartTime;
+            const elapsed = getElapsedTime(arrayStartTime);
             const technicalMsg = getErrorMessage(error);
             generationLogCollector.error(sessionId, TAG, `${arrayField}[${i}] local file upload FAILED after ${elapsed}ms: ${technicalMsg}`);
             throw new Error(classifyUploadError(technicalMsg));
@@ -156,7 +150,7 @@ export async function preprocessInput(
         }
       }
 
-      const arrayElapsed = Date.now() - arrayStartTime;
+      const arrayElapsed = getElapsedTime(arrayStartTime);
       generationLogCollector.log(sessionId, TAG, `${arrayField}: all ${processedUrls.length} upload(s) succeeded in ${arrayElapsed}ms`);
       result[arrayField] = processedUrls;
     }
@@ -179,7 +173,7 @@ export async function preprocessInput(
     }
   }
 
-  const totalElapsed = Date.now() - startTime;
+  const totalElapsed = getElapsedTime(startTime);
   generationLogCollector.log(sessionId, TAG, `Preprocessing complete in ${totalElapsed}ms`);
   return result;
 }

package/src/infrastructure/utils/input-validator.util.ts

@@ -1,168 +1,29 @@
 /**
- * Input Validator Utility
- * Validates input parameters before API calls
+ * Input Validator Utility (Infrastructure Layer)
+ * Delegates to domain ValidationService for actual validation logic
+ *
+ * This file now serves as a thin adapter layer for backward compatibility.
+ * The actual validation logic has been moved to the domain layer.
  */
 
-import { isValidPrompt } from "./type-guards";
-import { IMAGE_URL_FIELDS } from './constants/image-fields.constants';
-import { isImageDataUri } from './validators/data-uri-validator.util';
-import { isNonEmptyString } from './validators/string-validator.util';
+import { ValidationService } from "../../domain/services";
+import type { ValidationError } from "../../domain/services/ValidationService";
 
-const SUSPICIOUS_PATTERNS = [
-  /<script/i,
-  /javascript:/i,
-  /on\w+\s*=/i,
-  /<iframe/i,
-  /<embed/i,
-  /<object/i,
-  /data:(?!image\/)/i,
-  /vbscript:/i,
-] as const;
-
-function hasSuspiciousContent(value: string): boolean {
-  return SUSPICIOUS_PATTERNS.some(pattern => pattern.test(value));
-}
-
-/**
- * Validate URL format and protocol
- * Rejects malicious URLs and unsafe protocols
- */
-function isValidAndSafeUrl(value: string): boolean {
-  // Allow http/https URLs
-  if (value.startsWith('http://') || value.startsWith('https://')) {
-    try {
-      const url = new URL(value);
-      // Reject URLs with @ (potential auth bypass: http://attacker.com@internal.server/)
-      if (url.href.includes('@') && url.username) {
-        return false;
-      }
-      // Ensure domain exists
-      if (!url.hostname || url.hostname.length === 0) {
-        return false;
-      }
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  // Allow local file URIs (file://, content://) — preprocessInput uploads them to FAL storage
-  if (value.startsWith('file://') || value.startsWith('content://')) {
-    return true;
-  }
-
-  // Allow base64 image data URIs only
-  if (isImageDataUri(value)) {
-    // Check for suspicious content in data URI
-    const dataContent = value.substring(0, 200); // Check first 200 chars
-    if (hasSuspiciousContent(dataContent)) {
-      return false;
-    }
-    return true;
-  }
-
-  return false;
-}
-
-export interface ValidationError {
-  field: string;
-  message: string;
-}
-
-export class InputValidationError extends Error {
-  public readonly errors: readonly ValidationError[];
-
-  constructor(errors: ValidationError[]) {
-    const message = errors.map((e) => `${e.field}: ${e.message}`).join("; ");
-    super(`Input validation failed: ${message}`);
-    this.name = "InputValidationError";
-    this.errors = errors;
-  }
-}
+// Re-export for backward compatibility
+export { InputValidationError } from "../../domain/services/ValidationService";
+export type { ValidationError };
 
 /**
  * Validate model and input parameters
+ * Delegates to domain ValidationService
+ *
+ * @param model - Model ID
+ * @param input - Input parameters to validate
+ * @throws InputValidationError if validation fails
  */
 export function validateInput(
-  _model: string,
+  model: string,
   input: Record<string, unknown>
 ): void {
-  const errors: ValidationError[] = [];
-
-  // Validate input is not empty
-  if (!input || typeof input !== "object" || Object.keys(input).length === 0) {
-    errors.push({ field: "input", message: "Input must be a non-empty object" });
-  }
-
-  // BLOCK sync_mode:true — it causes FAL to return base64 data URIs instead of CDN URLs
-  if (input.sync_mode === true) {
-    errors.push({
-      field: "sync_mode",
-      message: "sync_mode:true is forbidden. It returns base64 data URIs instead of HTTPS CDN URLs, which breaks Firestore persistence (2048 char limit). Use falProvider.subscribe() for CDN URLs.",
-    });
-  }
-
-  // Validate and check prompt for malicious content
-  if (input.prompt !== undefined) {
-    if (!isValidPrompt(input.prompt)) {
-      errors.push({
-        field: "prompt",
-        message: "Prompt must be a non-empty string (max 5000 characters)",
-      });
-    } else if (typeof input.prompt === "string") {
-      // Check for suspicious content (defense in depth)
-      if (hasSuspiciousContent(input.prompt)) {
-        errors.push({
-          field: "prompt",
-          message: "Prompt contains potentially unsafe content (script tags, event handlers, or suspicious protocols)",
-        });
-      }
-    }
-  }
-
-  // Validate and check negative_prompt for malicious content
-  if (input.negative_prompt !== undefined) {
-    if (!isValidPrompt(input.negative_prompt)) {
-      errors.push({
-        field: "negative_prompt",
-        message: "Negative prompt must be a non-empty string (max 5000 characters)",
-      });
-    } else if (typeof input.negative_prompt === "string") {
-      // Check for suspicious content (defense in depth)
-      if (hasSuspiciousContent(input.negative_prompt)) {
-        errors.push({
-          field: "negative_prompt",
-          message: "Negative prompt contains potentially unsafe content (script tags, event handlers, or suspicious protocols)",
-        });
-      }
-    }
-  }
-
-  // Validate all image_url fields
-  for (const field of IMAGE_URL_FIELDS) {
-    const value = input[field];
-    if (value !== undefined) {
-      if (typeof value !== "string") {
-        errors.push({
-          field,
-          message: `${field} must be a string`,
-        });
-      } else if (!isNonEmptyString(value)) {
-        // Explicitly check for empty/whitespace-only strings
-        errors.push({
-          field,
-          message: `${field} cannot be empty`,
-        });
-      } else if (!isValidAndSafeUrl(value)) {
-        errors.push({
-          field,
-          message: `${field} must be a valid and safe URL (http/https) or image data URI. Suspicious content or unsafe protocols detected.`,
-        });
-      }
-    }
-  }
-
-  if (errors.length > 0) {
-    throw new InputValidationError(errors);
-  }
+  ValidationService.validateInput(model, input);
 }

package/src/infrastructure/utils/pricing/fal-pricing.util.ts

@@ -1,71 +1,44 @@
-import type { VideoModelConfig } from "@umituz/react-native-ai-generation-content";
-
 /**
- * FAL AI Pricing Utilities
- * Single Responsibility: Credit calculations for FAL AI generation
+ * FAL AI Pricing Utilities (Infrastructure Layer)
+ * Delegates to domain PricingService for credit calculation logic
  *
- * Pricing:
- * - 480p video: $0.05/sec
- * - 720p video: $0.07/sec
- * - Image with input: +$0.002
- * - Image generation: $0.03
- * Markup: 3.5x, Credit price: $0.10
+ * This file now serves as a thin adapter layer for backward compatibility.
+ * The actual pricing logic has been moved to the domain layer.
  */
 
-const COSTS = {
-  VIDEO_480P_PER_SECOND: 0.05,
-  VIDEO_720P_PER_SECOND: 0.07,
-  IMAGE_INPUT: 0.002,
-  IMAGE: 0.03,
-} as const;
-
-const MARKUP = 3.5;
-const CREDIT_PRICE = 0.1;
+import { PricingService } from "../../../domain/services/PricingService";
 
-export type GenerationResolution = "480p" | "720p";
+// Re-export types for backward compatibility
+export type { GenerationResolution } from "../../../domain/services/PricingService";
 
+/**
+ * Calculate credits for video generation
+ * Delegates to domain PricingService
+ */
 export function calculateVideoCredits(
   duration: number,
-  resolution: GenerationResolution,
-  hasImageInput: boolean = false,
+  resolution: "480p" | "720p",
+  hasImageInput?: boolean
 ): number {
-  const costPerSec =
-    resolution === "480p"
-      ? COSTS.VIDEO_480P_PER_SECOND
-      : COSTS.VIDEO_720P_PER_SECOND;
-  let cost = costPerSec * duration;
-  if (hasImageInput) cost += COSTS.IMAGE_INPUT;
-  return Math.max(1, Math.ceil((cost * MARKUP) / CREDIT_PRICE));
+  return PricingService.calculateVideoCredits(duration, resolution, hasImageInput);
 }
 
+/**
+ * Calculate credits for image generation
+ * Delegates to domain PricingService
+ */
 export function calculateImageCredits(): number {
-  return Math.max(1, Math.ceil((COSTS.IMAGE * MARKUP) / CREDIT_PRICE));
+  return PricingService.calculateImageCredits();
 }
 
+/**
+ * Calculate credits from video model config
+ * Delegates to domain PricingService
+ */
 export function calculateCreditsFromConfig(
-  config: VideoModelConfig,
+  config: import("@umituz/react-native-ai-generation-content").VideoModelConfig,
   duration: number,
-  resolution: string,
+  resolution: string
 ): number {
-  // Validate config structure before accessing nested properties
-  if (
-    !config ||
-    typeof config !== "object" ||
-    !config.pricing ||
-    typeof config.pricing !== "object" ||
-    !config.pricing.costPerSecond ||
-    typeof config.pricing.costPerSecond !== "object"
-  ) {
-    throw new Error("Invalid VideoModelConfig: pricing structure is missing or invalid");
-  }
-
-  const costPerSecondMap = config.pricing.costPerSecond;
-  const costPerSec = costPerSecondMap[resolution] ?? 0;
-
-  if (typeof costPerSec !== "number" || costPerSec < 0) {
-    throw new Error(`Invalid cost per second for resolution "${resolution}": must be a non-negative number`);
-  }
-
-  const cost = costPerSec * duration;
-  return Math.max(1, Math.ceil((cost * MARKUP) / CREDIT_PRICE));
+  return PricingService.calculateCreditsFromConfig(config, duration, resolution);
 }

package/src/infrastructure/utils/type-guards/index.ts

@@ -1,6 +1,6 @@
 /**
  * Type Guards - Centralized Exports
+ * Re-exports from shared utilities layer for backward compatibility
  */
 
-export * from './model-type-guards.util';
-export * from './validation-guards.util';
+export * from '../../../shared/type-guards';