@umituz/react-native-ai-fal-provider 2.0.14 → 2.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "2.0.14",
+  "version": "2.0.16",
   "description": "FAL AI provider for React Native - implements IAIProvider interface for unified AI generation",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domain/entities/error.types.ts

@@ -28,6 +28,8 @@ export interface FalErrorInfo {
   readonly messageKey: string;
   readonly retryable: boolean;
   readonly originalError: string;
+  readonly originalErrorName?: string;
+  readonly stack?: string;
   readonly statusCode?: number;
 }
 

package/src/domain/types/provider.types.ts

@@ -70,6 +70,7 @@ export interface JobStatus {
   logs?: AILogEntry[];
   queuePosition?: number;
   eta?: number;
+  requestId?: string;
 }
 
 // =============================================================================

package/src/exports/infrastructure.ts

@@ -51,15 +51,12 @@ export {
   isImageDataUri,
   uploadToFalStorage,
   uploadMultipleToFalStorage,
-  calculateTimeoutWithJitter,
   formatCreditCost,
   truncatePrompt,
   sanitizePrompt,
   buildErrorMessage,
   isDefined,
   removeNullish,
-  debounce,
-  throttle,
 } from "../infrastructure/utils";
 
 export {

package/src/exports/presentation.ts

@@ -5,19 +5,10 @@
 export {
   useFalGeneration,
   useModels,
-  useModelCapabilities,
-  useVideoDurations,
-  useVideoResolutions,
-  useAspectRatios,
 } from "../presentation/hooks";
 
 export type {
   UseFalGenerationOptions,
   UseFalGenerationResult,
   UseModelsProps,
-  UseModelCapabilitiesOptions,
-  UseModelCapabilitiesReturn,
-  UseVideoDurationsReturn,
-  UseVideoResolutionsReturn,
-  UseAspectRatiosReturn,
 } from "../presentation/hooks";

package/src/index.ts

@@ -12,9 +12,6 @@ export * from "./exports/infrastructure";
 // Presentation Layer
 export * from "./exports/presentation";
 
-// Model Registry
-export * from "./exports/registry";
-
 // Init Module Factory
 export {
   createAiProviderInitModule,

package/src/infrastructure/services/fal-feature-models.ts

@@ -10,8 +10,10 @@ import type {
 } from "../../domain/types";
 import {
   buildImageFeatureInput as buildImageFeatureInputImpl,
+} from "../builders/image-feature-builder";
+import {
   buildVideoFeatureInput as buildVideoFeatureInputImpl,
-} from "../builders";
+} from "../builders/video-feature-builder";
 
 export function getImageFeatureModel(
   imageFeatureModels: Record<string, string>,

package/src/infrastructure/services/fal-provider-subscription.ts

@@ -9,6 +9,7 @@ import type { FalQueueStatus } from "../../domain/entities/fal.types";
 import { DEFAULT_FAL_CONFIG } from "./fal-provider.constants";
 import { mapFalStatusToJobStatus } from "./fal-status-mapper";
 import { validateNSFWContent } from "../validators/nsfw-validator";
+import { NSFWContentError } from "./nsfw-content-error";
 
 declare const __DEV__: boolean | undefined;
 
@@ -81,7 +82,8 @@ export async function handleFalSubscription<T = unknown>(
   let lastStatus = "";
 
   try {
-    const result = await Promise.race([
+    // Create promises array conditionally to avoid unnecessary abort promise creation
+    const promises: Promise<unknown>[] = [
       fal.subscribe(model, {
         input,
         logs: false,
@@ -106,16 +108,20 @@ export async function handleFalSubscription<T = unknown>(
           reject(new Error("FAL subscription timeout"));
         }, timeoutMs);
       }),
-      // Abort promise with cleanup
-      ...(signal ? [
-        new Promise<never>((_, reject) => {
-          abortHandler = () => {
-            reject(new Error("Request cancelled by user"));
-          };
-          signal.addEventListener("abort", abortHandler);
-        }),
-      ] as const : []),
-    ]);
+    ];
+
+    // Add abort promise only if signal is provided and not already aborted
+    if (signal && !signal.aborted) {
+      const abortPromise = new Promise<never>((_, reject) => {
+        abortHandler = () => {
+          reject(new Error("Request cancelled by user"));
+        };
+        signal.addEventListener("abort", abortHandler);
+      });
+      promises.push(abortPromise);
+    }
+
+    const result = await Promise.race(promises);
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       console.log("[FalProvider] Subscribe completed:", {
@@ -135,6 +141,14 @@ export async function handleFalSubscription<T = unknown>(
     options?.onResult?.(result as T);
     return { result: result as T, requestId: currentRequestId };
   } catch (error) {
+    // Preserve NSFWContentError type
+    if (error instanceof NSFWContentError) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[FalProvider] NSFW content detected");
+      }
+      throw error;
+    }
+
     // Parse FAL error and throw with user-friendly message
     const userMessage = parseFalError(error);
     if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -143,8 +157,8 @@ export async function handleFalSubscription<T = unknown>(
     throw new Error(userMessage);
   } finally {
     if (timeoutId) clearTimeout(timeoutId);
-    // Clean up abort listener to prevent memory leak
-    if (signal && abortHandler) {
+    // Clean up abort listener to prevent memory leak (only if it was added)
+    if (abortHandler && signal && !signal.aborted) {
       signal.removeEventListener("abort", abortHandler);
     }
   }
@@ -178,6 +192,14 @@ export async function handleFalRun<T = unknown>(
     options?.onProgress?.({ progress: 100, status: "COMPLETED" as const });
     return result as T;
   } catch (error) {
+    // Preserve NSFWContentError type
+    if (error instanceof NSFWContentError) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[FalProvider] run() NSFW content detected");
+      }
+      throw error;
+    }
+
     const userMessage = parseFalError(error);
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       console.error("[FalProvider] run() Error:", userMessage);

package/src/infrastructure/services/fal-provider.ts

@@ -19,6 +19,7 @@ import {
 } from "./request-store";
 import * as queueOps from "./fal-queue-operations";
 import * as featureModels from "./fal-feature-models";
+import { validateInput } from "../utils/input-validator.util";
 
 declare const __DEV__: boolean | undefined;
 
@@ -86,16 +87,19 @@ export class FalProvider implements IAIProvider {
 
   async submitJob(model: string, input: Record<string, unknown>): Promise<JobSubmission> {
     this.validateInit();
+    validateInput(model, input);
     return queueOps.submitJob(model, input);
   }
 
   async getJobStatus(model: string, requestId: string): Promise<JobStatus> {
     this.validateInit();
+    validateInput(model, {}); // Validate model ID only
     return queueOps.getJobStatus(model, requestId);
   }
 
   async getJobResult<T = unknown>(model: string, requestId: string): Promise<T> {
     this.validateInit();
+    validateInput(model, {}); // Validate model ID only
     return queueOps.getJobResult<T>(model, requestId);
   }
 
@@ -105,6 +109,7 @@ export class FalProvider implements IAIProvider {
     options?: SubscribeOptions<T>,
   ): Promise<T> {
     this.validateInit();
+    validateInput(model, input);
 
     const processedInput = await preprocessInput(input);
     const key = createRequestKey(model, processedInput);
@@ -134,6 +139,7 @@ export class FalProvider implements IAIProvider {
 
   async run<T = unknown>(model: string, input: Record<string, unknown>, options?: RunOptions): Promise<T> {
     this.validateInit();
+    validateInput(model, input);
     const processedInput = await preprocessInput(input);
 
     return executeWithCostTracking({

package/src/infrastructure/services/fal-queue-operations.ts

@@ -7,6 +7,24 @@ import type { JobSubmission, JobStatus } from "../../domain/types";
 import type { FalQueueStatus } from "../../domain/entities/fal.types";
 import { mapFalStatusToJobStatus } from "./fal-status-mapper";
 
+/**
+ * Validate and cast FAL queue status response
+ */
+function isValidFalQueueStatus(value: unknown): value is FalQueueStatus {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+
+  const status = value as Partial<FalQueueStatus>;
+  const validStatuses = ["IN_QUEUE", "IN_PROGRESS", "COMPLETED", "FAILED"];
+
+  return (
+    typeof status.status === "string" &&
+    validStatuses.includes(status.status) &&
+    typeof status.requestId === "string"
+  );
+}
+
 export async function submitJob(model: string, input: Record<string, unknown>): Promise<JobSubmission> {
   const result = await fal.queue.submit(model, { input });
   return {
@@ -18,7 +36,18 @@ export async function submitJob(model: string, input: Record<string, unknown>):
 
 export async function getJobStatus(model: string, requestId: string): Promise<JobStatus> {
   const status = await fal.queue.status(model, { requestId, logs: true });
-  return mapFalStatusToJobStatus(status as unknown as FalQueueStatus);
+
+  // Validate the response structure before mapping
+  if (!isValidFalQueueStatus(status)) {
+    // Fallback to default status if validation fails
+    return {
+      status: "IN_PROGRESS",
+      logs: [],
+      queuePosition: undefined,
+    };
+  }
+
+  return mapFalStatusToJobStatus(status);
 }
 
 export async function getJobResult<T = unknown>(model: string, requestId: string): Promise<T> {

package/src/infrastructure/services/fal-status-mapper.ts

@@ -30,5 +30,7 @@ export function mapFalStatusToJobStatus(status: FalQueueStatus): JobStatus {
       timestamp: log.timestamp ?? new Date().toISOString(),
     })) ?? [],
     queuePosition: status.queuePosition ?? undefined,
+    // Preserve requestId from FalQueueStatus for use in hooks
+    requestId: status.requestId,
   };
 }

package/src/infrastructure/services/request-store.ts

@@ -13,6 +13,9 @@ export interface ActiveRequest<T = unknown> {
 const STORE_KEY = "__FAL_PROVIDER_REQUESTS__";
 type RequestStore = Map<string, ActiveRequest>;
 
+// Counter for generating unique request IDs
+let requestCounter = 0;
+
 export function getRequestStore(): RequestStore {
   if (!(globalThis as Record<string, unknown>)[STORE_KEY]) {
     (globalThis as Record<string, unknown>)[STORE_KEY] = new Map();
@@ -20,15 +23,23 @@ export function getRequestStore(): RequestStore {
   return (globalThis as Record<string, unknown>)[STORE_KEY] as RequestStore;
 }
 
+/**
+ * Create a collision-resistant request key using combination of:
+ * - Model name
+ * - Input hash (for quick comparison)
+ * - Unique counter (guarantees uniqueness)
+ */
 export function createRequestKey(model: string, input: Record<string, unknown>): string {
   const inputStr = JSON.stringify(input, Object.keys(input).sort());
-  // Simple hash to avoid collisions from truncation
+  // Use DJB2 hash for input fingerprinting (faster than crypto for dedup check)
   let hash = 0;
   for (let i = 0; i < inputStr.length; i++) {
     const char = inputStr.charCodeAt(i);
     hash = ((hash << 5) - hash + char) | 0;
   }
-  return `${model}:${hash.toString(36)}`;
+  // Add counter to guarantee uniqueness even with hash collisions
+  const uniqueId = `${requestCounter++}`;
+  return `${model}:${hash.toString(36)}:${uniqueId}`;
 }
 
 export function getExistingRequest<T>(key: string): ActiveRequest<T> | undefined {
@@ -57,3 +68,20 @@ export function cancelAllRequests(): void {
 export function hasActiveRequests(): boolean {
   return getRequestStore().size > 0;
 }
+
+/**
+ * Clean up completed/stale requests from the store
+ * Should be called periodically to prevent memory leaks
+ *
+ * Note: This is a placeholder for future implementation.
+ * Currently, requests are cleaned up automatically when they complete.
+ */
+export function cleanupRequestStore(_maxAge: number = 300000): void {
+  const store = getRequestStore();
+
+  // Requests are automatically removed when they complete (via finally block)
+  // This function exists for future enhancements like time-based cleanup
+  if (store.size > 50 && typeof __DEV__ !== "undefined" && __DEV__) {
+    console.warn(`[RequestStore] Large request store size: ${store.size}. Consider investigating potential leaks.`);
+  }
+}

package/src/infrastructure/utils/cost-tracker.ts

@@ -6,23 +6,48 @@
 import type {
   GenerationCost,
   CostTrackerConfig,
-  CostSummary,
   ModelCostInfo,
 } from "../../domain/entities/cost-tracking.types";
 import { findModelById } from "../../domain/constants/default-models.constants";
-import {
-  calculateCostSummary,
-  filterCostsByModel,
-  filterCostsByOperation,
-  filterCostsByTimeRange,
-} from "./cost-tracker-queries";
 
 declare const __DEV__: boolean | undefined;
 
+interface CostSummary {
+  totalEstimatedCost: number;
+  totalActualCost: number;
+  currency: string;
+  operationCount: number;
+}
+
+function calculateCostSummary(costs: GenerationCost[], currency: string): CostSummary {
+  return costs.reduce(
+    (summary, cost) => ({
+      totalEstimatedCost: summary.totalEstimatedCost + cost.estimatedCost,
+      totalActualCost: summary.totalActualCost + cost.actualCost,
+      currency,
+      operationCount: summary.operationCount + 1,
+    }),
+    { totalEstimatedCost: 0, totalActualCost: 0, currency, operationCount: 0 }
+  );
+}
+
+function filterCostsByModel(costs: GenerationCost[], modelId: string): GenerationCost[] {
+  return costs.filter((cost) => cost.model === modelId);
+}
+
+function filterCostsByOperation(costs: GenerationCost[], operation: string): GenerationCost[] {
+  return costs.filter((cost) => cost.operation === operation);
+}
+
+function filterCostsByTimeRange(costs: GenerationCost[], startTime: number, endTime: number): GenerationCost[] {
+  return costs.filter((cost) => cost.timestamp >= startTime && cost.timestamp <= endTime);
+}
+
 export class CostTracker {
   private config: Required<CostTrackerConfig>;
   private costHistory: GenerationCost[] = [];
   private currentOperationCosts: Map<string, number> = new Map();
+  private operationCounter = 0;
 
   constructor(config?: CostTrackerConfig) {
     this.config = {
@@ -67,7 +92,8 @@ export class CostTracker {
   }
 
   startOperation(modelId: string, operation: string): string {
-    const operationId = `${Date.now()}-${operation}`;
+    // Use counter + timestamp for guaranteed unique operation IDs
+    const operationId = `${Date.now()}-${this.operationCounter++}-${operation}`;
     const estimatedCost = this.calculateEstimatedCost(modelId);
 
     this.currentOperationCosts.set(operationId, estimatedCost);

package/src/infrastructure/utils/error-mapper.ts

@@ -14,14 +14,28 @@ function extractStatusCode(errorString: string): number | undefined {
 
 export function mapFalError(error: unknown): FalErrorInfo {
   const category = categorizeFalError(error);
-  const originalError = error instanceof Error ? error.message : String(error);
+
+  // Preserve full error information including stack trace
+  if (error instanceof Error) {
+    return {
+      type: category.type,
+      messageKey: `fal.errors.${category.messageKey}`,
+      retryable: category.retryable,
+      originalError: error.message,
+      originalErrorName: error.name,
+      stack: error.stack,
+      statusCode: extractStatusCode(error.message),
+    };
+  }
+
+  const errorString = String(error);
 
   return {
     type: category.type,
     messageKey: `fal.errors.${category.messageKey}`,
     retryable: category.retryable,
-    originalError,
-    statusCode: extractStatusCode(originalError),
+    originalError: errorString,
+    statusCode: extractStatusCode(errorString),
   };
 }
 

package/src/infrastructure/utils/image-feature-builders.util.ts

@@ -46,13 +46,18 @@ export function buildFaceSwapInput(
 
 export function buildRemoveBackgroundInput(
   base64: string,
-  _options?: RemoveBackgroundOptions,
+  options?: RemoveBackgroundOptions & {
+    model?: string;
+    operating_resolution?: string;
+    output_format?: string;
+    refine_foreground?: boolean;
+  },
 ): Record<string, unknown> {
   return buildSingleImageInput(base64, {
-    model: "General Use (Light)",
-    operating_resolution: "1024x1024",
-    output_format: "png",
-    refine_foreground: true,
+    model: options?.model ?? "General Use (Light)",
+    operating_resolution: options?.operating_resolution ?? "1024x1024",
+    output_format: options?.output_format ?? "png",
+    refine_foreground: options?.refine_foreground ?? true,
   });
 }
 

package/src/infrastructure/utils/index.ts

@@ -52,12 +52,6 @@ export {
   sanitizePrompt,
 } from "./prompt-helpers.util";
 
-export {
-  calculateTimeoutWithJitter,
-  debounce,
-  throttle,
-} from "./timing-helpers.util";
-
 export {
   formatCreditCost,
   buildErrorMessage,
@@ -102,3 +96,10 @@ export { CostTracker } from "./cost-tracker";
 export { executeWithCostTracking } from "./cost-tracking-executor.util";
 
 export { preprocessInput } from "./input-preprocessor.util";
+
+export {
+  validateInput,
+  type InputValidationError,
+  type ValidationError,
+} from "./input-validator.util";
+

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

@@ -0,0 +1,92 @@
+/**
+ * Input Validator Utility
+ * Validates input parameters before API calls
+ */
+
+import { isValidModelId, isValidPrompt } from "./type-guards.util";
+
+declare const __DEV__: boolean | undefined;
+
+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;
+  }
+}
+
+/**
+ * Validate model and input parameters
+ */
+export function validateInput(
+  model: string,
+  input: Record<string, unknown>
+): void {
+  const errors: ValidationError[] = [];
+
+  // Validate model ID
+  if (!model || typeof model !== "string") {
+    errors.push({ field: "model", message: "Model ID is required and must be a string" });
+  } else if (!isValidModelId(model)) {
+    errors.push({ field: "model", message: `Invalid model ID format: ${model}` });
+  }
+
+  // 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" });
+  }
+
+  // Validate prompt if present
+  if (input.prompt !== undefined) {
+    if (!isValidPrompt(input.prompt)) {
+      errors.push({
+        field: "prompt",
+        message: "Prompt must be a non-empty string (max 5000 characters)",
+      });
+    }
+  }
+
+  // Validate negative_prompt if present
+  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)",
+      });
+    }
+  }
+
+  // Validate image_url fields if present
+  const imageFields = [
+    "image_url",
+    "second_image_url",
+    "base_image_url",
+    "swap_image_url",
+    "mask_url",
+  ];
+
+  for (const field of imageFields) {
+    const value = input[field];
+    if (value !== undefined && typeof value !== "string") {
+      errors.push({
+        field,
+        message: `${field} must be a string`,
+      });
+    }
+  }
+
+  if (errors.length > 0) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.warn("[InputValidator] Validation errors:", errors);
+    }
+    throw new InputValidationError(errors);
+  }
+}

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

@@ -65,12 +65,16 @@ export function isValidBase64Image(value: unknown): boolean {
 
   // Check data URI prefix
   if (value.startsWith("data:image/")) {
-    return value.includes("base64,");
+    const base64Part = value.split("base64,")[1];
+    if (!base64Part) return false;
+    // Base64 should be at least 100 chars (meaningful image data)
+    return base64Part.length >= 100;
   }
 
-  // Check if it's a valid base64 string
+  // Check if it's a valid base64 string with minimum length
   const base64Pattern = /^[A-Za-z0-9+/]+=*$/;
-  return base64Pattern.test(value) && value.length > 0;
+  // Minimum 100 characters for meaningful base64 image data
+  return base64Pattern.test(value) && value.length >= 100;
 }
 
 /**

package/src/infrastructure/utils/video-feature-builders.util.ts

@@ -26,12 +26,15 @@ export function buildImageToImageInput(
 
 export function buildVideoFromImageInput(
   base64: string,
-  options?: VideoFromImageOptions,
+  options?: VideoFromImageOptions & {
+    enable_safety_checker?: boolean;
+    default_prompt?: string;
+  },
 ): Record<string, unknown> {
   return {
-    prompt: options?.prompt || "Generate natural motion video",
+    prompt: options?.prompt || options?.default_prompt || "Generate natural motion video",
     image_url: formatImageDataUri(base64),
-    enable_safety_checker: false,
+    enable_safety_checker: options?.enable_safety_checker ?? false,
     ...(options?.duration && { duration: options.duration }),
     ...(options?.resolution && { resolution: options.resolution }),
   };