@umituz/react-native-ai-fal-provider 2.0.37 → 2.0.39

package/package.json

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

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

@@ -53,10 +53,13 @@ export function getModelPricing(modelId: string): { freeUserCost: number; premiu
 /**
  * Get credit cost for a model
  * Returns the model's free user cost if available, otherwise returns the default cost for the type
+ * NOTE: Use ?? instead of || to handle 0 values correctly (free models)
  */
 export function getModelCreditCost(modelId: string, modelType: ModelType): number {
   const pricing = getModelPricing(modelId);
-  if (pricing?.freeUserCost) {
+  // CRITICAL: Use !== undefined instead of truthy check
+  // because freeUserCost can be 0 for free models!
+  if (pricing && pricing.freeUserCost !== undefined) {
     return pricing.freeUserCost;
   }
   return DEFAULT_CREDIT_COSTS[modelType];

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

@@ -23,8 +23,11 @@ export async function handleFalSubscription<T = unknown>(
 ): Promise<{ result: T; requestId: string | null }> {
   const timeoutMs = options?.timeoutMs ?? DEFAULT_FAL_CONFIG.defaultTimeoutMs;
 
-  if (timeoutMs <= 0 || timeoutMs > 3600000) {
-    throw new Error(`Invalid timeout: ${timeoutMs}ms. Must be between 1 and 3600000ms (1 hour)`);
+  // Validate timeout is a positive integer within reasonable bounds
+  if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 3600000) {
+    throw new Error(
+      `Invalid timeout: ${timeoutMs}ms. Must be a positive integer between 1 and 3600000ms (1 hour)`
+    );
   }
 
   let timeoutId: ReturnType<typeof setTimeout> | null = null;
@@ -32,13 +35,14 @@ export async function handleFalSubscription<T = unknown>(
   let abortHandler: (() => void) | null = null;
   let listenerAdded = false;
 
-  if (signal?.aborted) {
-    throw new Error("Request cancelled by user");
-  }
-
   let lastStatus = "";
 
   try {
+    // Check if signal is already aborted BEFORE starting any async work
+    if (signal?.aborted) {
+      throw new Error("Request cancelled by user");
+    }
+
     const promises: Promise<unknown>[] = [
       fal.subscribe(model, {
         input,
@@ -77,13 +81,19 @@ export async function handleFalSubscription<T = unknown>(
       }),
     ];
 
-    if (signal && !signal.aborted) {
+    // Set up abort listener BEFORE checking aborted state again to avoid race
+    if (signal) {
       const abortPromise = new Promise<never>((_, reject) => {
         abortHandler = () => {
           reject(new Error("Request cancelled by user"));
         };
         signal.addEventListener("abort", abortHandler);
         listenerAdded = true;
+
+        // Check again after adding listener to catch signals that arrived during setup
+        if (signal.aborted) {
+          abortHandler();
+        }
       });
       promises.push(abortPromise);
     }

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

@@ -153,7 +153,17 @@ export class FalProvider implements IAIProvider {
         rejectPromise!(error);
         throw error;
       })
-      .finally(() => removeRequest(key));
+      .finally(() => {
+        try {
+          removeRequest(key);
+        } catch (cleanupError) {
+          // Log but don't throw - cleanup errors shouldn't affect the operation result
+          console.error(
+            `[fal-provider] Error removing request from store: ${key}`,
+            cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
+          );
+        }
+      });
 
     return promise;
   }

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

@@ -27,6 +27,16 @@ function isValidFalQueueStatus(value: unknown): value is FalQueueStatus {
 
 export async function submitJob(model: string, input: Record<string, unknown>): Promise<JobSubmission> {
   const result = await fal.queue.submit(model, { input });
+
+  // Validate required fields from FAL API response
+  if (!result?.request_id) {
+    throw new Error(`FAL API response missing request_id for model ${model}`);
+  }
+
+  if (!result?.status_url) {
+    throw new Error(`FAL API response missing status_url for model ${model}`);
+  }
+
   return {
     requestId: result.request_id,
     statusUrl: result.status_url,

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

@@ -10,17 +10,37 @@ export interface ActiveRequest<T = unknown> {
 }
 
 const STORE_KEY = "__FAL_PROVIDER_REQUESTS__";
+const LOCK_KEY = "__FAL_PROVIDER_REQUESTS_LOCK__";
 type RequestStore = Map<string, ActiveRequest>;
 
 let cleanupTimer: ReturnType<typeof setInterval> | null = null;
 const CLEANUP_INTERVAL = 60000; // 1 minute
 const MAX_REQUEST_AGE = 300000; // 5 minutes
 
+/**
+ * Simple lock mechanism to prevent concurrent access issues
+ * NOTE: This is not a true mutex but provides basic protection for React Native
+ */
+function acquireLock(): boolean {
+  const globalObj = globalThis as Record<string, unknown>;
+  if (globalObj[LOCK_KEY]) {
+    return false; // Lock already held
+  }
+  globalObj[LOCK_KEY] = true;
+  return true;
+}
+
+function releaseLock(): void {
+  const globalObj = globalThis as Record<string, unknown>;
+  globalObj[LOCK_KEY] = false;
+}
+
 export function getRequestStore(): RequestStore {
-  if (!(globalThis as Record<string, unknown>)[STORE_KEY]) {
-    (globalThis as Record<string, unknown>)[STORE_KEY] = new Map();
+  const globalObj = globalThis as Record<string, unknown>;
+  if (!globalObj[STORE_KEY]) {
+    globalObj[STORE_KEY] = new Map();
   }
-  return (globalThis as Record<string, unknown>)[STORE_KEY] as RequestStore;
+  return globalObj[STORE_KEY] as RequestStore;
 }
 
 /**
@@ -45,14 +65,27 @@ export function getExistingRequest<T>(key: string): ActiveRequest<T> | undefined
 }
 
 export function storeRequest<T>(key: string, request: ActiveRequest<T>): void {
-  const requestWithTimestamp = {
-    ...request,
-    createdAt: request.createdAt ?? Date.now(),
-  };
-  getRequestStore().set(key, requestWithTimestamp);
-
-  // Start automatic cleanup if not already running
-  startAutomaticCleanup();
+  // Acquire lock for thread-safe operation
+  const maxRetries = 3;
+  let retries = 0;
+
+  while (!acquireLock() && retries < maxRetries) {
+    retries++;
+    // Brief spin wait (not ideal, but works for React Native single-threaded model)
+  }
+
+  try {
+    const requestWithTimestamp = {
+      ...request,
+      createdAt: request.createdAt ?? Date.now(),
+    };
+    getRequestStore().set(key, requestWithTimestamp);
+
+    // Start automatic cleanup if not already running
+    startAutomaticCleanup();
+  } finally {
+    releaseLock();
+  }
 }
 
 export function removeRequest(key: string): void {
@@ -138,8 +171,16 @@ function startAutomaticCleanup(): void {
 
   cleanupTimer = setInterval(() => {
     const cleanedCount = cleanupRequestStore(MAX_REQUEST_AGE);
+    const store = getRequestStore();
+
+    // Stop timer if no more requests in store (prevents indefinite timer)
+    if (store.size === 0 && cleanupTimer) {
+      clearInterval(cleanupTimer);
+      cleanupTimer = null;
+    }
+
     if (cleanedCount > 0) {
-      // Cleanup was performed
+      console.log(`[request-store] Cleaned up ${cleanedCount} stale request(s)`);
     }
   }, CLEANUP_INTERVAL);
 }

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

@@ -1,171 +1,9 @@
 /**
  * Collection Filter Utilities
- * Common filter operations for arrays of objects
+ * @deprecated This file is now split into smaller modules for better maintainability.
+ * Import from './collections' submodules instead.
+ *
+ * This file re-exports all functions for backward compatibility.
  */
 
-/**
- * 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)]);
-  }
-  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;
-}
+export * from './collections';

package/src/infrastructure/utils/collections/array-filters.util.ts

@@ -0,0 +1,52 @@
+/**
+ * Array Filter Utilities
+ * 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]));
+}

package/src/infrastructure/utils/collections/array-reducers.util.ts

@@ -0,0 +1,67 @@
+/**
+ * Array Reducer Utilities
+ * Reduce, group, chunk, and aggregation operations
+ */
+
+/**
+ * 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)]);
+  }
+  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/collections/array-sorters.util.ts

@@ -0,0 +1,60 @@
+/**
+ * Array Sorter Utilities
+ * Sort operations for arrays of objects
+ */
+
+/**
+ * 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;
+  });
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Collection Utilities - Centralized Exports
+ * Re-exports all collection utilities from submodules
+ */
+
+export * from './array-filters.util';
+export * from './array-sorters.util';
+export * from './array-reducers.util';

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

@@ -56,9 +56,14 @@ export class CostTracker {
         };
       }
     } catch (error) {
-      // Silently return default cost info on error
+      // Log error but continue with default cost info
+      console.warn(
+        `[cost-tracker] Failed to get model cost info for ${modelId}:`,
+        error instanceof Error ? error.message : String(error)
+      );
     }
 
+    // Return default cost info (0 cost) if model not found or error occurred
     return {
       model: modelId,
       costPerRequest: 0,