@umituz/react-native-ai-fal-provider 2.1.3 → 2.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "2.1.3",
+  "version": "2.1.5",
   "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/constants/default-models.constants.ts

@@ -4,7 +4,6 @@
  */
 
 import type { FalModelType } from "../entities/fal.types";
-import type { ModelType } from "../types/model-selection.types";
 import { DEFAULT_TEXT_TO_IMAGE_MODELS } from "./models/text-to-image.models";
 import { DEFAULT_TEXT_TO_VOICE_MODELS } from "./models/text-to-voice.models";
 import { DEFAULT_TEXT_TO_VIDEO_MODELS } from "./models/text-to-video.models";
@@ -34,22 +33,28 @@ export interface FalModelConfig {
 
 /**
  * Default credit costs for each model type
+ * Supports all FalModelType values
  */
-export const DEFAULT_CREDIT_COSTS: Record<ModelType, number> = {
+export const DEFAULT_CREDIT_COSTS: Record<FalModelType, number> = {
   "text-to-image": 2,
   "text-to-video": 20,
   "image-to-video": 20,
   "text-to-voice": 3,
+  "image-to-image": 2,
+  "text-to-text": 1,
 } as const;
 
 /**
  * Default model IDs for each model type
+ * Supports all FalModelType values
  */
-export const DEFAULT_MODEL_IDS: Record<ModelType, string> = {
+export const DEFAULT_MODEL_IDS: Record<FalModelType, string> = {
   "text-to-image": "fal-ai/flux/schnell",
   "text-to-video": "fal-ai/minimax-video",
   "image-to-video": "fal-ai/kling-video/v1.5/pro/image-to-video",
   "text-to-voice": "fal-ai/playai/tts/v3",
+  "image-to-image": "fal-ai/flux/schnell",
+  "text-to-text": "fal-ai/flux/schnell",
 } as const;
 
 /**
@@ -90,10 +95,14 @@ export function getDefaultModelsByType(type: FalModelType): FalModelConfig[] {
 
 /**
  * Get default model for a type
+ * Returns the model marked as default, or the first model, or undefined if no models exist
  */
 export function getDefaultModel(type: FalModelType): FalModelConfig | undefined {
   const models = getDefaultModelsByType(type);
-  return models.find((m) => m.isDefault) || models[0];
+  if (models.length === 0) {
+    return undefined;
+  }
+  return models.find((m) => m.isDefault) ?? models[0];
 }
 
 /**

package/src/domain/types/model-selection.types.ts

@@ -4,12 +4,16 @@
  */
 
 import type { FalModelConfig } from "../constants/default-models.constants";
+import type { FalModelType } from "../entities/fal.types";
 
-export type ModelType =
-  | "text-to-image"
-  | "text-to-video"
-  | "image-to-video"
-  | "text-to-voice";
+/**
+ * Public API model types (subset of FalModelType)
+ * UI components support these core model types
+ */
+export type ModelType = Extract<
+  FalModelType,
+  "text-to-image" | "text-to-video" | "image-to-video" | "text-to-voice"
+>;
 
 /**
  * Configuration for model selection behavior

package/src/exports/infrastructure.ts

@@ -45,7 +45,6 @@ export {
   uploadToFalStorage,
   uploadMultipleToFalStorage,
   formatNumber,
-  formatCurrency,
   formatBytes,
   formatDuration,
   truncateText,
@@ -55,10 +54,7 @@ export {
   isDefined,
   removeNullish,
   generateUniqueId,
-  debounce,
-  throttle,
   sleep,
-  retry,
 } from "../infrastructure/utils";
 
 export {
@@ -89,8 +85,5 @@ export {
   updateJobStatus,
 } from "../infrastructure/utils";
 
-export type {
-  FalJobMetadata,
-  IJobStorage,
-  InMemoryJobStorage,
-} from "../infrastructure/utils";
+export type { FalJobMetadata, IJobStorage } from "../infrastructure/utils";
+export { InMemoryJobStorage } from "../infrastructure/utils";

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

@@ -55,28 +55,28 @@ export function getModelPricing(modelId: string): { freeUserCost: number; premiu
  * 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 {
+export function getModelCreditCost(modelId: string, modelType: FalModelType): number {
   const pricing = getModelPricing(modelId);
   // 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];
+  return DEFAULT_CREDIT_COSTS[modelType] ?? 0;
 }
 
 /**
  * Get default credit cost for a model type
  */
-export function getDefaultCreditCost(modelType: ModelType): number {
-  return DEFAULT_CREDIT_COSTS[modelType];
+export function getDefaultCreditCost(modelType: FalModelType): number {
+  return DEFAULT_CREDIT_COSTS[modelType] ?? 0;
 }
 
 /**
  * Get default model ID for a model type
  */
-export function getDefaultModelId(modelType: ModelType): string {
-  return DEFAULT_MODEL_IDS[modelType];
+export function getDefaultModelId(modelType: FalModelType): string {
+  return DEFAULT_MODEL_IDS[modelType] ?? "";
 }
 
 /**
@@ -110,7 +110,8 @@ export function getModelSelectionData(
   modelType: ModelType,
   config?: ModelSelectionConfig
 ): ModelSelectionResult {
-  const models = getModels(modelType as FalModelType);
+  // ModelType is now a subset of FalModelType, so this cast is safe
+  const models = getModels(modelType);
   const defaultCreditCost = config?.defaultCreditCost ?? getDefaultCreditCost(modelType);
   const defaultModelId = config?.defaultModelId ?? getDefaultModelId(modelType);
   const selectedModel = selectInitialModel(models, config, modelType);

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

@@ -126,18 +126,21 @@ export class FalProvider implements IAIProvider {
     const abortController = new AbortController();
     const tracker = this.costTracker;
 
-    // Store promise immediately BEFORE creating it to prevent race condition
-    // Multiple simultaneous calls with same params will get the same promise
-    let resolvePromise: (value: T) => void;
-    let rejectPromise: (error: unknown) => void;
+    // Create promise with resolvers using definite assignment
+    // This prevents race conditions and ensures type safety
+    let resolvePromise!: (value: T) => void;
+    let rejectPromise!: (error: unknown) => void;
     const promise = new Promise<T>((resolve, reject) => {
       resolvePromise = resolve;
       rejectPromise = reject;
     });
 
+    // Store promise immediately to enable request deduplication
+    // Multiple simultaneous calls with same params will get the same promise
     storeRequest(key, { promise, abortController, createdAt: Date.now() });
 
     // Execute the actual operation and resolve/reject the stored promise
+    // Note: This promise chain is not awaited - it runs independently
     executeWithCostTracking({
       tracker,
       model,
@@ -146,12 +149,10 @@ export class FalProvider implements IAIProvider {
       getRequestId: (res) => res.requestId ?? undefined,
     })
       .then((res) => {
-        resolvePromise!(res.result);
-        return res.result;
+        resolvePromise(res.result);
       })
       .catch((error) => {
-        rejectPromise!(error);
-        throw error;
+        rejectPromise(error);
       })
       .finally(() => {
         try {

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

@@ -61,7 +61,14 @@ export async function getJobResult<T = unknown>(model: string, requestId: string
 
   if (!result || typeof result !== 'object') {
     throw new Error(
-      `Invalid FAL queue result for model ${model}, requestId ${requestId}`
+      `Invalid FAL queue result for model ${model}, requestId ${requestId}: Result is not an object`
+    );
+  }
+
+  // Type guard: ensure result.data exists before casting
+  if (!('data' in result)) {
+    throw new Error(
+      `Invalid FAL queue result for model ${model}, requestId ${requestId}: Missing 'data' property`
     );
   }
 

package/src/infrastructure/services/nsfw-content-error.ts

@@ -12,7 +12,7 @@ export class NSFWContentError extends Error {
 
   constructor(message?: string) {
     super(
-      message ||
+      message ??
         "The generated content was flagged as inappropriate. Please try a different prompt."
     );
     this.name = "NSFWContentError";

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

@@ -11,12 +11,28 @@ export interface ActiveRequest<T = unknown> {
 
 const STORE_KEY = "__FAL_PROVIDER_REQUESTS__";
 const LOCK_KEY = "__FAL_PROVIDER_REQUESTS_LOCK__";
+const TIMER_KEY = "__FAL_PROVIDER_CLEANUP_TIMER__";
 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
 
+/**
+ * Get cleanup timer from globalThis to survive hot reloads
+ */
+function getCleanupTimer(): ReturnType<typeof setInterval> | null {
+  const globalObj = globalThis as Record<string, unknown>;
+  return (globalObj[TIMER_KEY] as ReturnType<typeof setInterval>) ?? null;
+}
+
+/**
+ * Set cleanup timer in globalThis to survive hot reloads
+ */
+function setCleanupTimer(timer: ReturnType<typeof setInterval> | null): void {
+  const globalObj = globalThis as Record<string, unknown>;
+  globalObj[TIMER_KEY] = timer;
+}
+
 /**
  * Simple lock mechanism to prevent concurrent access issues
  * NOTE: This is not a true mutex but provides basic protection for React Native
@@ -65,13 +81,25 @@ export function getExistingRequest<T>(key: string): ActiveRequest<T> | undefined
 }
 
 export function storeRequest<T>(key: string, request: ActiveRequest<T>): void {
-  // Acquire lock for thread-safe operation
-  const maxRetries = 3;
+  // Acquire lock for consistent operation
+  // React Native is single-threaded, but this prevents re-entrancy issues
+  const maxRetries = 10;
   let retries = 0;
 
+  // Spin-wait loop (synchronous)
+  // Note: Does NOT yield to event loop - tight loop
+  // In practice, this rarely loops due to single-threaded nature of React Native
   while (!acquireLock() && retries < maxRetries) {
     retries++;
-    // Brief spin wait (not ideal, but works for React Native single-threaded model)
+  }
+
+  if (retries >= maxRetries) {
+    // Lock acquisition failed - this shouldn't happen in normal operation
+    // Log warning but proceed anyway since RN is single-threaded
+    console.warn(
+      `[request-store] Failed to acquire lock after ${maxRetries} attempts for key: ${key}. ` +
+      'Proceeding anyway (safe in single-threaded environment)'
+    );
   }
 
   try {
@@ -84,6 +112,8 @@ export function storeRequest<T>(key: string, request: ActiveRequest<T>): void {
     // Start automatic cleanup if not already running
     startAutomaticCleanup();
   } finally {
+    // Always release lock, even if we didn't successfully acquire it
+    // to prevent deadlocks
     releaseLock();
   }
 }
@@ -93,9 +123,12 @@ export function removeRequest(key: string): void {
   store.delete(key);
 
   // Stop cleanup timer if store is empty
-  if (store.size === 0 && cleanupTimer) {
-    clearInterval(cleanupTimer);
-    cleanupTimer = null;
+  if (store.size === 0) {
+    const timer = getCleanupTimer();
+    if (timer) {
+      clearInterval(timer);
+      setCleanupTimer(null);
+    }
   }
 }
 
@@ -107,9 +140,10 @@ export function cancelAllRequests(): void {
   store.clear();
 
   // Stop cleanup timer
-  if (cleanupTimer) {
-    clearInterval(cleanupTimer);
-    cleanupTimer = null;
+  const timer = getCleanupTimer();
+  if (timer) {
+    clearInterval(timer);
+    setCleanupTimer(null);
   }
 }
 
@@ -152,9 +186,12 @@ export function cleanupRequestStore(maxAge: number = MAX_REQUEST_AGE): number {
   }
 
   // Stop cleanup timer if store is empty
-  if (store.size === 0 && cleanupTimer) {
-    clearInterval(cleanupTimer);
-    cleanupTimer = null;
+  if (store.size === 0) {
+    const timer = getCleanupTimer();
+    if (timer) {
+      clearInterval(timer);
+      setCleanupTimer(null);
+    }
   }
 
   return cleanedCount;
@@ -163,34 +200,53 @@ export function cleanupRequestStore(maxAge: number = MAX_REQUEST_AGE): number {
 /**
  * Start automatic cleanup of stale requests
  * Runs periodically to prevent memory leaks
+ * Uses globalThis to survive hot reloads in React Native
  */
 function startAutomaticCleanup(): void {
-  if (cleanupTimer) {
+  const existingTimer = getCleanupTimer();
+  if (existingTimer) {
     return; // Already running
   }
 
-  cleanupTimer = setInterval(() => {
+  const timer = 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 (store.size === 0) {
+      const currentTimer = getCleanupTimer();
+      if (currentTimer) {
+        clearInterval(currentTimer);
+        setCleanupTimer(null);
+      }
     }
 
     if (cleanedCount > 0) {
       console.log(`[request-store] Cleaned up ${cleanedCount} stale request(s)`);
     }
   }, CLEANUP_INTERVAL);
+
+  setCleanupTimer(timer);
 }
 
 /**
- * Stop automatic cleanup (typically on app shutdown)
+ * Stop automatic cleanup (typically on app shutdown or hot reload)
+ * Clears the global timer to prevent memory leaks
  */
 export function stopAutomaticCleanup(): void {
-  if (cleanupTimer) {
-    clearInterval(cleanupTimer);
-    cleanupTimer = null;
+  const timer = getCleanupTimer();
+  if (timer) {
+    clearInterval(timer);
+    setCleanupTimer(null);
+  }
+}
+
+// Clean up any existing timer on module load to prevent leaks during hot reload
+// This ensures old timers are cleared when the module is reloaded in development
+if (typeof globalThis !== "undefined") {
+  const existingTimer = getCleanupTimer();
+  if (existingTimer) {
+    clearInterval(existingTimer);
+    setCleanupTimer(null);
   }
 }

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

@@ -26,6 +26,7 @@ export function filterByPredicate<T>(
 
 /**
  * Filter array by time range (timestamp property)
+ * Validates that the timestamp property is actually a number before comparison
  */
 export function filterByTimeRange<T>(
   items: readonly T[],
@@ -34,7 +35,17 @@ export function filterByTimeRange<T>(
   endTime: number
 ): T[] {
   return items.filter((item) => {
-    const timestamp = item[timestampProperty] as unknown as number;
+    const timestamp = item[timestampProperty];
+
+    // Type guard: ensure timestamp is actually a number
+    if (typeof timestamp !== 'number') {
+      console.warn(
+        `[array-filters] Skipping item with non-numeric timestamp property '${String(timestampProperty)}':`,
+        typeof timestamp
+      );
+      return false;
+    }
+
     return timestamp >= startTime && timestamp <= endTime;
   });
 }

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

@@ -5,6 +5,7 @@
 
 /**
  * Sort array by date property (descending - newest first)
+ * Invalid dates are sorted to the end
  */
 export function sortByDateDescending<T>(
   items: readonly T[],
@@ -13,12 +14,19 @@ export function sortByDateDescending<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();
+
+    // Handle invalid dates - NaN should sort to end
+    if (isNaN(timeA) && isNaN(timeB)) return 0;
+    if (isNaN(timeA)) return 1; // a goes to end
+    if (isNaN(timeB)) return -1; // b goes to end
+
     return timeB - timeA;
   });
 }
 
 /**
  * Sort array by date property (ascending - oldest first)
+ * Invalid dates are sorted to the end
  */
 export function sortByDateAscending<T>(
   items: readonly T[],
@@ -27,12 +35,19 @@ export function sortByDateAscending<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();
+
+    // Handle invalid dates - NaN should sort to end
+    if (isNaN(timeA) && isNaN(timeB)) return 0;
+    if (isNaN(timeA)) return 1; // a goes to end
+    if (isNaN(timeB)) return -1; // b goes to end
+
     return timeA - timeB;
   });
 }
 
 /**
  * Sort array by number property (descending)
+ * NaN and Infinity values are sorted to the end
  */
 export function sortByNumberDescending<T>(
   items: readonly T[],
@@ -41,12 +56,22 @@ export function sortByNumberDescending<T>(
   return [...items].sort((a, b) => {
     const numA = a[numberProperty] as unknown as number;
     const numB = b[numberProperty] as unknown as number;
+
+    // Handle NaN and Infinity
+    const isAValid = isFinite(numA);
+    const isBValid = isFinite(numB);
+
+    if (!isAValid && !isBValid) return 0;
+    if (!isAValid) return 1; // a goes to end
+    if (!isBValid) return -1; // b goes to end
+
     return numB - numA;
   });
 }
 
 /**
  * Sort array by number property (ascending)
+ * NaN and Infinity values are sorted to the end
  */
 export function sortByNumberAscending<T>(
   items: readonly T[],
@@ -55,6 +80,15 @@ export function sortByNumberAscending<T>(
   return [...items].sort((a, b) => {
     const numA = a[numberProperty] as unknown as number;
     const numB = b[numberProperty] as unknown as number;
+
+    // Handle NaN and Infinity
+    const isAValid = isFinite(numA);
+    const isBValid = isFinite(numB);
+
+    if (!isAValid && !isBValid) return 0;
+    if (!isAValid) return 1; // a goes to end
+    if (!isBValid) return -1; // b goes to end
+
     return numA - numB;
   });
 }

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

@@ -5,4 +5,3 @@
 
 export * from './array-filters.util';
 export * from './array-sorters.util';
-export * from './array-reducers.util';

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

@@ -11,7 +11,9 @@ import type {
 import { findModelById } from "../../domain/constants/default-models.constants";
 import { filterByProperty, filterByTimeRange } from "./collection-filters.util";
 
-interface CostSummary {
+export type { GenerationCost } from "../../domain/entities/cost-tracking.types";
+
+export interface CostSummary {
   totalEstimatedCost: number;
   totalActualCost: number;
   currency: string;

package/src/infrastructure/utils/cost-tracking-executor.util.ts

@@ -36,15 +36,26 @@ export async function executeWithCostTracking<T>(
       tracker.completeOperation(operationId, model, operation, requestId);
     } catch (costError) {
       // Cost tracking failure shouldn't break the operation
-      // Log for debugging but don't throw
+      // Log for debugging and audit trail
+      console.error(
+        `[cost-tracking] Failed to complete cost tracking for ${operation} on ${model}:`,
+        costError instanceof Error ? costError.message : String(costError),
+        { operationId, model, operation }
+      );
     }
 
     return result;
   } catch (error) {
     try {
       tracker.failOperation(operationId);
-    } catch {
-      // Cost tracking cleanup failure on error path - ignore
+    } catch (failError) {
+      // Cost tracking cleanup failure on error path
+      // Log for debugging and audit trail
+      console.error(
+        `[cost-tracking] Failed to mark operation as failed for ${operation} on ${model}:`,
+        failError instanceof Error ? failError.message : String(failError),
+        { operationId, model, operation }
+      );
     }
     throw error;
   }

package/src/infrastructure/utils/date-format.util.ts

@@ -4,61 +4,27 @@
  */
 
 /**
- * Format date to locale string
+ * Validate that a date is valid
  */
-export function formatDate(date: Date | string, locale: string = "en-US"): string {
-  const dateObj = typeof date === "string" ? new Date(date) : date;
-  return dateObj.toLocaleDateString(locale, {
-    year: "numeric",
-    month: "short",
-    day: "numeric",
-  });
+function isValidDate(date: Date): boolean {
+  return date instanceof Date && !isNaN(date.getTime());
 }
 
 /**
- * Format date and time to locale string
+ * Format date to locale string
+ * @throws {Error} if date is invalid
  */
-export function formatDateTime(date: Date | string, locale: string = "en-US"): string {
+export function formatDate(date: Date | string, locale: string = "en-US"): string {
   const dateObj = typeof date === "string" ? new Date(date) : date;
-  return dateObj.toLocaleString(locale, {
+
+  if (!isValidDate(dateObj)) {
+    const dateStr = typeof date === "string" ? date : date.toISOString();
+    throw new Error(`Invalid date: ${dateStr}`);
+  }
+
+  return dateObj.toLocaleDateString(locale, {
     year: "numeric",
     month: "short",
     day: "numeric",
-    hour: "2-digit",
-    minute: "2-digit",
   });
 }
-
-/**
- * Format relative time (e.g., "2 hours ago")
- */
-export function formatRelativeTime(date: Date | string, locale: string = "en-US"): string {
-  const dateObj = typeof date === "string" ? new Date(date) : date;
-  const now = new Date();
-  const diffMs = now.getTime() - dateObj.getTime();
-  const diffSec = Math.floor(diffMs / 1000);
-  const diffMin = Math.floor(diffSec / 60);
-  const diffHour = Math.floor(diffMin / 60);
-  const diffDay = Math.floor(diffHour / 24);
-
-  const rtf = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
-
-  if (diffSec < 60) {
-    return rtf.format(-diffSec, "second");
-  }
-  if (diffMin < 60) {
-    return rtf.format(-diffMin, "minute");
-  }
-  if (diffHour < 24) {
-    return rtf.format(-diffHour, "hour");
-  }
-  if (diffDay < 30) {
-    return rtf.format(-diffDay, "day");
-  }
-  if (diffDay < 365) {
-    const months = Math.floor(diffDay / 30);
-    return rtf.format(-months, "month");
-  }
-  const years = Math.floor(diffDay / 365);
-  return rtf.format(-years, "year");
-}