@umituz/react-native-ai-fal-provider 2.0.19 → 2.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "2.0.19",
+  "version": "2.0.21",
   "description": "FAL AI provider for React Native - implements IAIProvider interface for unified AI generation",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -28,8 +28,8 @@
   },
   "peerDependencies": {
     "@fal-ai/client": ">=0.6.0",
-    "react": ">=18.2.0",
-    "react-native": ">=0.74.0"
+    "react": ">=19.0.0",
+    "react-native": ">=0.81.0"
   },
   "dependencies": {
     "@fal-ai/client": ">=0.6.0"
@@ -46,7 +46,7 @@
     "@tanstack/query-async-storage-persister": "^5.66.7",
     "@tanstack/react-query": "^5.66.7",
     "@tanstack/react-query-persist-client": "^5.66.7",
-    "@types/react": "~18.3.12",
+    "@types/react": "~19.1.0",
     "@typescript-eslint/eslint-plugin": "^7.0.0",
     "@typescript-eslint/parser": "^7.0.0",
     "@umituz/react-native-auth": "*",
@@ -77,8 +77,8 @@
     "expo-video": "^3.0.15",
     "expo-web-browser": "^12.0.0",
     "firebase": "^12.7.0",
-    "react": "18.3.1",
-    "react-native": "0.76.1",
+    "react": "19.1.0",
+    "react-native": "0.81.5",
     "react-native-gesture-handler": "^2.30.0",
     "react-native-purchases": "^9.7.5",
     "react-native-reanimated": "^4.2.1",

package/src/domain/constants/default-models.constants.ts

@@ -80,10 +80,16 @@ export function getDefaultModelsByType(type: FalModelType): FalModelConfig[] {
       return DEFAULT_IMAGE_TO_VIDEO_MODELS;
     case "text-to-text":
       return DEFAULT_TEXT_TO_TEXT_MODELS;
-    case "image-to-image":
+    case "image-to-image": {
+      // eslint-disable-next-line no-console
+      console.warn('Model type "image-to-image" not supported yet');
       return [];
-    default:
+    }
+    default: {
+      // eslint-disable-next-line no-console
+      console.warn('Unknown model type:', type);
       return [];
+    }
   }
 }
 

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

@@ -123,9 +123,14 @@ export async function handleFalSubscription<T = unknown>(
     }
 
     const userMessage = parseFalError(error);
+    if (!userMessage || userMessage.trim().length === 0) {
+      throw new Error("An unknown error occurred. Please try again.");
+    }
     throw new Error(userMessage);
   } finally {
-    if (timeoutId) clearTimeout(timeoutId);
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
     if (listenerAdded && abortHandler && signal) {
       signal.removeEventListener("abort", abortHandler);
     }

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

@@ -134,6 +134,7 @@ export class FalProvider implements IAIProvider {
       getRequestId: (res) => res.requestId ?? undefined,
     }).then((res) => res.result).finally(() => removeRequest(key));
 
+    // Store promise immediately to prevent race condition
     storeRequest(key, { promise, abortController });
     return promise;
   }

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

@@ -19,10 +19,8 @@ export function getRequestStore(): RequestStore {
 }
 
 /**
- * Create a collision-resistant request key using combination of:
- * - Model name
- * - Input hash (for quick comparison)
- * - Unique ID (guarantees uniqueness)
+ * Create a deterministic request key using model and input hash
+ * Same model + input will always produce the same key for deduplication
  */
 export function createRequestKey(model: string, input: Record<string, unknown>): string {
   const inputStr = JSON.stringify(input, Object.keys(input).sort());
@@ -32,11 +30,9 @@ export function createRequestKey(model: string, input: Record<string, unknown>):
     const char = inputStr.charCodeAt(i);
     hash = ((hash << 5) - hash + char) | 0;
   }
-  // Use crypto.randomUUID() for guaranteed uniqueness without race conditions
-  const uniqueId = typeof crypto !== 'undefined' && crypto.randomUUID
-    ? crypto.randomUUID()
-    : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  return `${model}:${hash.toString(36)}:${uniqueId}`;
+  // Return deterministic key without unique ID
+  // This allows proper deduplication: same model + input = same key
+  return `${model}:${hash.toString(36)}`;
 }
 
 export function getExistingRequest<T>(key: string): ActiveRequest<T> | undefined {

package/src/infrastructure/utils/collection-filters.util.ts

@@ -0,0 +1,171 @@
+/**
+ * Collection Filter Utilities
+ * Common filter operations for arrays of objects
+ */
+
+/**
+ * Filter array by property value
+ */
+export function filterByProperty<T>(
+  items: readonly T[],
+  property: keyof T,
+  value: unknown
+): T[] {
+  return items.filter((item) => item[property] === value);
+}
+
+/**
+ * Filter array by predicate function
+ */
+export function filterByPredicate<T>(
+  items: readonly T[],
+  predicate: (item: T) => boolean
+): T[] {
+  return items.filter(predicate);
+}
+
+/**
+ * Filter array by time range (timestamp property)
+ */
+export function filterByTimeRange<T>(
+  items: readonly T[],
+  timestampProperty: keyof T,
+  startTime: number,
+  endTime: number
+): T[] {
+  return items.filter((item) => {
+    const timestamp = item[timestampProperty] as unknown as number;
+    return timestamp >= startTime && timestamp <= endTime;
+  });
+}
+
+/**
+ * Filter array by multiple property values (OR logic)
+ */
+export function filterByAnyProperty<T>(
+  items: readonly T[],
+  property: keyof T,
+  values: readonly unknown[]
+): T[] {
+  const valueSet = new Set(values);
+  return items.filter((item) => valueSet.has(item[property]));
+}
+
+/**
+ * Sort array by date property (descending - newest first)
+ */
+export function sortByDateDescending<T>(
+  items: readonly T[],
+  dateProperty: keyof T
+): T[] {
+  return [...items].sort((a, b) => {
+    const timeA = new Date(a[dateProperty] as unknown as string).getTime();
+    const timeB = new Date(b[dateProperty] as unknown as string).getTime();
+    return timeB - timeA;
+  });
+}
+
+/**
+ * Sort array by date property (ascending - oldest first)
+ */
+export function sortByDateAscending<T>(
+  items: readonly T[],
+  dateProperty: keyof T
+): T[] {
+  return [...items].sort((a, b) => {
+    const timeA = new Date(a[dateProperty] as unknown as string).getTime();
+    const timeB = new Date(b[dateProperty] as unknown as string).getTime();
+    return timeA - timeB;
+  });
+}
+
+/**
+ * Sort array by number property (descending)
+ */
+export function sortByNumberDescending<T>(
+  items: readonly T[],
+  numberProperty: keyof T
+): T[] {
+  return [...items].sort((a, b) => {
+    const numA = a[numberProperty] as unknown as number;
+    const numB = b[numberProperty] as unknown as number;
+    return numB - numA;
+  });
+}
+
+/**
+ * Sort array by number property (ascending)
+ */
+export function sortByNumberAscending<T>(
+  items: readonly T[],
+  numberProperty: keyof T
+): T[] {
+  return [...items].sort((a, b) => {
+    const numA = a[numberProperty] as unknown as number;
+    const numB = b[numberProperty] as unknown as number;
+    return numA - numB;
+  });
+}
+
+/**
+ * Reduce array to sum of number property
+ */
+export function sumByProperty<T>(
+  items: readonly T[],
+  numberProperty: keyof T
+): number {
+  return items.reduce((sum, item) => {
+    const value = item[numberProperty] as unknown as number;
+    return sum + (typeof value === "number" ? value : 0);
+  }, 0);
+}
+
+/**
+ * Group array by property value
+ */
+export function groupByProperty<T>(
+  items: readonly T[],
+  property: keyof T
+): Map<unknown, T[]> {
+  const groups = new Map<unknown, T[]>();
+  for (const item of items) {
+    const key = item[property];
+    const existing = groups.get(key);
+    if (existing) {
+      existing.push(item);
+    } else {
+      groups.set(key, [item]);
+    }
+  }
+  return groups;
+}
+
+/**
+ * Chunk array into smaller arrays of specified size
+ */
+export function chunkArray<T>(items: readonly T[], chunkSize: number): T[][] {
+  const result: T[][] = [];
+  for (let i = 0; i < items.length; i += chunkSize) {
+    result.push(items.slice(i, i + chunkSize) as T[]);
+  }
+  return result;
+}
+
+/**
+ * Get distinct values of a property from array
+ */
+export function distinctByProperty<T>(
+  items: readonly T[],
+  property: keyof T
+): unknown[] {
+  const seen = new Set<unknown>();
+  const result: unknown[] = [];
+  for (const item of items) {
+    const value = item[property];
+    if (!seen.has(value)) {
+      seen.add(value);
+      result.push(value);
+    }
+  }
+  return result;
+}

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

@@ -45,7 +45,6 @@ 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 = {
@@ -84,11 +83,14 @@ export class CostTracker {
   }
 
   startOperation(modelId: string, operation: string): string {
-    // Use counter + timestamp for guaranteed unique operation IDs
-    const operationId = `${Date.now()}-${this.operationCounter++}-${operation}`;
+    // Use crypto.randomUUID() for guaranteed uniqueness without overflow
+    const uniqueId = typeof crypto !== 'undefined' && crypto.randomUUID
+      ? crypto.randomUUID()
+      : `${Date.now()}-${Math.random().toString(36).slice(2)}-${operation}`;
+
     const estimatedCost = this.calculateEstimatedCost(modelId);
 
-    this.currentOperationCosts.set(operationId, estimatedCost);
+    this.currentOperationCosts.set(uniqueId, estimatedCost);
 
     if (this.config.trackEstimatedCost) {
       const cost: GenerationCost = {
@@ -104,7 +106,7 @@ export class CostTracker {
       this.config.onCostUpdate(cost);
     }
 
-    return operationId;
+    return uniqueId;
   }
 
   completeOperation(
@@ -156,7 +158,6 @@ export class CostTracker {
   clearHistory(): void {
     this.costHistory = [];
     this.currentOperationCosts.clear();
-    this.operationCounter = 0;
   }
 
   getCostsByModel(modelId: string): GenerationCost[] {

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

@@ -27,8 +27,10 @@ export async function uploadToFalStorage(base64: string): Promise<string> {
       try {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call
         await deleteTempFile(tempUri);
-      } catch {
-        // Silently ignore cleanup failures
+      } catch (cleanupError) {
+        // Log cleanup failure but don't throw
+        // eslint-disable-next-line no-console
+        console.warn(`Failed to cleanup temp file ${tempUri}:`, cleanupError);
       }
     }
   }

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

@@ -20,8 +20,18 @@ export function extractBase64(dataUri: string): string {
   if (!dataUri.startsWith("data:")) {
     return dataUri;
   }
+
   const parts = dataUri.split(",");
-  return parts.length > 1 ? parts[1] : dataUri;
+  if (parts.length < 2) {
+    throw new Error(`Invalid data URI format: ${dataUri}`);
+  }
+
+  const base64Part = parts[1];
+  if (!base64Part || base64Part.length === 0) {
+    throw new Error(`Empty base64 data in URI: ${dataUri}`);
+  }
+
+  return base64Part;
 }
 
 /**

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

@@ -51,9 +51,16 @@ export async function preprocessInput(
   if (Array.isArray(result.image_urls) && result.image_urls.length > 0) {
     const imageUrls = result.image_urls as unknown[];
     const processedUrls: string[] = [];
+    const errors: string[] = [];
 
     for (let i = 0; i < imageUrls.length; i++) {
       const imageUrl = imageUrls[i];
+
+      if (!imageUrl) {
+        errors.push(`image_urls[${i}] is null or undefined`);
+        continue;
+      }
+
       if (isBase64DataUri(imageUrl)) {
         const index = i;
         const uploadPromise = uploadToFalStorage(imageUrl)
@@ -61,6 +68,7 @@ export async function preprocessInput(
             processedUrls[index] = url;
           })
           .catch((error) => {
+            errors.push(`Failed to upload image_urls[${index}]: ${error instanceof Error ? error.message : "Unknown error"}`);
             throw new Error(`Failed to upload image_urls[${index}]: ${error instanceof Error ? error.message : "Unknown error"}`);
           });
 
@@ -68,10 +76,14 @@ export async function preprocessInput(
       } else if (typeof imageUrl === "string") {
         processedUrls[i] = imageUrl;
       } else {
-        processedUrls[i] = "";
+        errors.push(`image_urls[${i}] has invalid type: ${typeof imageUrl}`);
       }
     }
 
+    if (errors.length > 0) {
+      throw new Error(`Image URL validation failed:\n${errors.join('\n')}`);
+    }
+
     result.image_urls = processedUrls;
   }
 

package/src/infrastructure/utils/job-metadata/job-metadata-queries.util.ts

@@ -18,8 +18,22 @@ export function serializeJobMetadata(metadata: FalJobMetadata): string {
  */
 export function deserializeJobMetadata(data: string): FalJobMetadata | null {
   try {
-    return JSON.parse(data) as FalJobMetadata;
-  } catch {
+    const parsed = JSON.parse(data) as Record<string, unknown>;
+    // Validate structure
+    if (!parsed || typeof parsed !== 'object') {
+      // eslint-disable-next-line no-console
+      console.warn('Invalid job metadata: not an object', data);
+      return null;
+    }
+    if (!parsed.requestId || !parsed.model || !parsed.status) {
+      // eslint-disable-next-line no-console
+      console.warn('Invalid job metadata: missing required fields', data);
+      return null;
+    }
+    return parsed as unknown as FalJobMetadata;
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error('Failed to deserialize job metadata:', error, 'Data:', data);
     return null;
   }
 }

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

@@ -14,8 +14,14 @@ export function truncatePrompt(prompt: string, maxLength: number = 5000): string
 }
 
 /**
- * Sanitize prompt by removing excessive whitespace
+ * Sanitize prompt by removing excessive whitespace and control characters
  */
 export function sanitizePrompt(prompt: string): string {
-  return prompt.trim().replace(/\s+/g, " ");
+  return prompt
+    .trim()
+    .replace(/\s+/g, " ")
+    // Remove control characters except tab, newline, carriage return
+    // eslint-disable-next-line no-control-regex
+    .replace(/[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F]/g, '')
+    .slice(0, 5000);
 }

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

@@ -87,15 +87,14 @@ export function isValidApiKey(value: unknown): boolean {
 /**
  * Validate model ID format
  */
+const MODEL_ID_PATTERN = /^[a-zA-Z0-9-_]+\/[a-zA-Z0-9-_.]+(\/[a-zA-Z0-9-_.]+)?$/;
+
 export function isValidModelId(value: unknown): boolean {
   if (typeof value !== "string") {
     return false;
   }
 
-  // FAL model IDs follow pattern: "owner/model-name" or "owner/model/version"
-  // Allow uppercase, dots, underscores, hyphens
-  const modelIdPattern = /^[a-zA-Z0-9-_]+\/[a-zA-Z0-9-_.]+(\/[a-zA-Z0-9-_.]+)?$/;
-  return modelIdPattern.test(value) && value.length >= 3;
+  return MODEL_ID_PATTERN.test(value) && value.length >= 3;
 }
 
 /**
@@ -109,12 +108,12 @@ export function isValidPrompt(value: unknown): boolean {
  * Validate timeout value
  */
 export function isValidTimeout(value: unknown): boolean {
-  return typeof value === "number" && value > 0 && value <= 600000; // Max 10 minutes
+  return typeof value === "number" && !isNaN(value) && isFinite(value) && value > 0 && value <= 600000; // Max 10 minutes
 }
 
 /**
  * Validate retry count
  */
 export function isValidRetryCount(value: unknown): boolean {
-  return typeof value === "number" && value >= 0 && value <= 10;
+  return typeof value === "number" && !isNaN(value) && isFinite(value) && Number.isInteger(value) && value >= 0 && value <= 10;
 }

package/src/presentation/hooks/use-fal-generation.ts

@@ -3,7 +3,7 @@
  * React hook for FAL AI generation operations
  */
 
-import { useState, useCallback, useRef } from "react";
+import { useState, useCallback, useRef, useEffect } from "react";
 import { falProvider } from "../../infrastructure/services/fal-provider";
 import { mapFalError } from "../../infrastructure/utils/error-mapper";
 import type { FalJobInput, FalQueueStatus, FalLogEntry } from "../../domain/entities/fal.types";
@@ -38,9 +38,23 @@ export function useFalGeneration<T = unknown>(
 
   const lastRequestRef = useRef<{ endpoint: string; input: FalJobInput } | null>(null);
   const currentRequestIdRef = useRef<string | null>(null);
+  const isMountedRef = useRef(true);
+
+  // Cleanup on unmount
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+      if (falProvider.hasRunningRequest()) {
+        falProvider.cancelCurrentRequest();
+      }
+    };
+  }, []);
 
   const generate = useCallback(
     async (modelEndpoint: string, input: FalJobInput): Promise<T | null> => {
+      if (!isMountedRef.current) return null;
+
       lastRequestRef.current = { endpoint: modelEndpoint, input };
       setIsLoading(true);
       setError(null);
@@ -52,6 +66,7 @@ export function useFalGeneration<T = unknown>(
         const result = await falProvider.subscribe<T>(modelEndpoint, input, {
           timeoutMs: options?.timeoutMs,
           onQueueUpdate: (status) => {
+            if (!isMountedRef.current) return;
             if (status.requestId) {
               currentRequestIdRef.current = status.requestId;
             }
@@ -68,16 +83,20 @@ export function useFalGeneration<T = unknown>(
           },
         });
 
+        if (!isMountedRef.current) return null;
         setData(result);
         return result;
       } catch (err) {
+        if (!isMountedRef.current) return null;
         const errorInfo = mapFalError(err);
         setError(errorInfo);
         options?.onError?.(errorInfo);
         return null;
       } finally {
-        setIsLoading(false);
-        setIsCancelling(false);
+        if (isMountedRef.current) {
+          setIsLoading(false);
+          setIsCancelling(false);
+        }
       }
     },
     [options]

package/src/presentation/hooks/use-models.ts

@@ -68,6 +68,9 @@ export function useModels(props: UseModelsProps): UseModelsReturn {
       const model = models.find((m) => m.id === modelId);
       if (model) {
         setSelectedModel(model);
+      } else {
+        // eslint-disable-next-line no-console
+        console.warn(`Model not found: ${modelId}. Available models:`, models.map(m => m.id));
       }
     },
     [models],