@umituz/react-native-ai-fal-provider 2.0.29 → 2.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "2.0.29",
+  "version": "2.0.31",
   "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

@@ -80,14 +80,9 @@ 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": {
-      // eslint-disable-next-line no-console
-      console.warn('Model type "image-to-image" not supported yet');
+    case "image-to-image":
       return [];
-    }
     default: {
-      // eslint-disable-next-line no-console
-      console.warn('Unknown model type:', type);
       return [];
     }
   }

package/src/exports/infrastructure.ts

@@ -9,8 +9,10 @@ export {
   NSFWContentError,
   cancelCurrentFalRequest,
   hasRunningFalRequest,
+  cleanupRequestStore,
+  stopAutomaticCleanup,
 } from "../infrastructure/services";
-export type { FalProviderType } from "../infrastructure/services";
+export type { FalProviderType, ActiveRequest } from "../infrastructure/services";
 
 export {
   categorizeFalError,

package/src/exports/presentation.ts

@@ -12,3 +12,12 @@ export type {
   UseFalGenerationResult,
   UseModelsProps,
 } from "../presentation/hooks";
+
+// Export state manager for advanced use cases
+export {
+  FalGenerationStateManager,
+} from "../infrastructure/utils/fal-generation-state-manager.util";
+export type {
+  GenerationState,
+  GenerationStateOptions,
+} from "../infrastructure/utils/fal-generation-state-manager.util";

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

@@ -1,8 +1,10 @@
 /**
- * FAL Models Service - Simple model retrieval functions
+ * FAL Models Service - Model retrieval and selection logic
  */
 
 import type { FalModelType } from "../../domain/entities/fal.types";
+import type { ModelType, ModelSelectionConfig } from "../../domain/types/model-selection.types";
+import { DEFAULT_CREDIT_COSTS, DEFAULT_MODEL_IDS } from "../../domain/constants/default-models.constants";
 import {
   type FalModelConfig,
   getDefaultModelsByType,
@@ -12,6 +14,16 @@ import {
 
 export type { FalModelConfig };
 
+/**
+ * Model selection result
+ */
+export interface ModelSelectionResult {
+  models: FalModelConfig[];
+  selectedModel: FalModelConfig | null;
+  defaultCreditCost: number;
+  defaultModelId: string;
+}
+
 function sortModels(models: FalModelConfig[]): FalModelConfig[] {
   return [...models].sort((a, b) => {
     if (a.order !== b.order) {
@@ -38,12 +50,87 @@ export function getModelPricing(modelId: string): { freeUserCost: number; premiu
   return model?.pricing ?? null;
 }
 
+/**
+ * Get credit cost for a model
+ * Returns the model's free user cost if available, otherwise returns the default cost for the type
+ */
+export function getModelCreditCost(modelId: string, modelType: ModelType): number {
+  const pricing = getModelPricing(modelId);
+  if (pricing?.freeUserCost) {
+    return pricing.freeUserCost;
+  }
+  return DEFAULT_CREDIT_COSTS[modelType];
+}
+
+/**
+ * Get default credit cost for a model type
+ */
+export function getDefaultCreditCost(modelType: ModelType): number {
+  return DEFAULT_CREDIT_COSTS[modelType];
+}
+
+/**
+ * Get default model ID for a model type
+ */
+export function getDefaultModelId(modelType: ModelType): string {
+  return DEFAULT_MODEL_IDS[modelType];
+}
+
+/**
+ * Select initial model based on configuration
+ * Returns the model matching initialModelId, or the default model, or the first model
+ */
+export function selectInitialModel(
+  models: FalModelConfig[],
+  config: ModelSelectionConfig | undefined,
+  modelType: ModelType
+): FalModelConfig | null {
+  if (models.length === 0) {
+    return null;
+  }
+
+  const defaultModelId = getDefaultModelId(modelType);
+  const targetId = config?.initialModelId ?? defaultModelId;
+
+  return (
+    models.find((m) => m.id === targetId) ??
+    models.find((m) => m.isDefault) ??
+    models[0]
+  );
+}
+
+/**
+ * Get model selection data for a model type
+ * Returns models, selected model, and default configuration
+ */
+export function getModelSelectionData(
+  modelType: ModelType,
+  config?: ModelSelectionConfig
+): ModelSelectionResult {
+  const models = getModels(modelType as FalModelType);
+  const defaultCreditCost = config?.defaultCreditCost ?? getDefaultCreditCost(modelType);
+  const defaultModelId = config?.defaultModelId ?? getDefaultModelId(modelType);
+  const selectedModel = selectInitialModel(models, config, modelType);
+
+  return {
+    models,
+    selectedModel,
+    defaultCreditCost,
+    defaultModelId,
+  };
+}
+
 // Singleton service export
 export const falModelsService = {
   getModels,
   getDefaultModel,
   findById: findModelById,
   getModelPricing,
+  getModelCreditCost,
+  getDefaultCreditCost,
+  getDefaultModelId,
+  selectInitialModel,
+  getModelSelectionData,
   getTextToImageModels: () => getModels("text-to-image"),
   getTextToVoiceModels: () => getModels("text-to-voice"),
   getTextToVideoModels: () => getModels("text-to-video"),

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

@@ -126,16 +126,35 @@ export class FalProvider implements IAIProvider {
     const abortController = new AbortController();
     const tracker = this.costTracker;
 
-    const promise = executeWithCostTracking({
+    // 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;
+    const promise = new Promise<T>((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+    });
+
+    storeRequest(key, { promise, abortController, createdAt: Date.now() });
+
+    // Execute the actual operation and resolve/reject the stored promise
+    executeWithCostTracking({
       tracker,
       model,
       operation: "subscribe",
       execute: () => handleFalSubscription<T>(model, processedInput, options, abortController.signal),
       getRequestId: (res) => res.requestId ?? undefined,
-    }).then((res) => res.result).finally(() => removeRequest(key));
+    })
+      .then((res) => {
+        resolvePromise!(res.result);
+        return res.result;
+      })
+      .catch((error) => {
+        rejectPromise!(error);
+        throw error;
+      })
+      .finally(() => removeRequest(key));
 
-    // Store promise immediately to prevent race condition
-    storeRequest(key, { promise, abortController, createdAt: Date.now() });
     return promise;
   }
 
@@ -161,6 +180,7 @@ export class FalProvider implements IAIProvider {
     this.cancelCurrentRequest();
     this.apiKey = null;
     this.initialized = false;
+    this.costTracker = null;
   }
 
   cancelCurrentRequest(): void {

package/src/infrastructure/services/index.ts

@@ -6,9 +6,22 @@ import { falProvider } from "./fal-provider";
 
 export { FalProvider, falProvider } from "./fal-provider";
 export type { FalProvider as FalProviderType } from "./fal-provider";
-export { falModelsService, type FalModelConfig } from "./fal-models.service";
+export { falModelsService, type FalModelConfig, type ModelSelectionResult } from "./fal-models.service";
 export { NSFWContentError } from "./nsfw-content-error";
 
+// Request store exports for advanced use cases
+export {
+  createRequestKey,
+  getExistingRequest,
+  storeRequest,
+  removeRequest,
+  cancelAllRequests,
+  hasActiveRequests,
+  cleanupRequestStore,
+  stopAutomaticCleanup,
+} from "./request-store";
+export type { ActiveRequest } from "./request-store";
+
 /**
  * Cancel the current running FAL request
  */

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

@@ -12,6 +12,10 @@ export interface ActiveRequest<T = unknown> {
 const STORE_KEY = "__FAL_PROVIDER_REQUESTS__";
 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
+
 export function getRequestStore(): RequestStore {
   if (!(globalThis as Record<string, unknown>)[STORE_KEY]) {
     (globalThis as Record<string, unknown>)[STORE_KEY] = new Map();
@@ -46,10 +50,20 @@ export function storeRequest<T>(key: string, request: ActiveRequest<T>): void {
     createdAt: request.createdAt ?? Date.now(),
   };
   getRequestStore().set(key, requestWithTimestamp);
+
+  // Start automatic cleanup if not already running
+  startAutomaticCleanup();
 }
 
 export function removeRequest(key: string): void {
-  getRequestStore().delete(key);
+  const store = getRequestStore();
+  store.delete(key);
+
+  // Stop cleanup timer if store is empty
+  if (store.size === 0 && cleanupTimer) {
+    clearInterval(cleanupTimer);
+    cleanupTimer = null;
+  }
 }
 
 export function cancelAllRequests(): void {
@@ -58,6 +72,12 @@ export function cancelAllRequests(): void {
     req.abortController.abort();
   });
   store.clear();
+
+  // Stop cleanup timer
+  if (cleanupTimer) {
+    clearInterval(cleanupTimer);
+    cleanupTimer = null;
+  }
 }
 
 export function hasActiveRequests(): boolean {
@@ -71,7 +91,7 @@ export function hasActiveRequests(): boolean {
  * @param maxAge - Maximum age in milliseconds (default: 5 minutes)
  * @returns Number of requests cleaned up
  */
-export function cleanupRequestStore(maxAge: number = 300000): number {
+export function cleanupRequestStore(maxAge: number = MAX_REQUEST_AGE): number {
   const store = getRequestStore();
   const now = Date.now();
   let cleanedCount = 0;
@@ -98,11 +118,38 @@ export function cleanupRequestStore(maxAge: number = 300000): number {
     }
   }
 
-  // Log warning if store size is still large after cleanup
-  if (store.size > 50) {
-    // eslint-disable-next-line no-console
-    console.warn(`Request store size (${store.size}) exceeds threshold, potential memory leak detected`);
+  // Stop cleanup timer if store is empty
+  if (store.size === 0 && cleanupTimer) {
+    clearInterval(cleanupTimer);
+    cleanupTimer = null;
   }
 
   return cleanedCount;
 }
+
+/**
+ * Start automatic cleanup of stale requests
+ * Runs periodically to prevent memory leaks
+ */
+function startAutomaticCleanup(): void {
+  if (cleanupTimer) {
+    return; // Already running
+  }
+
+  cleanupTimer = setInterval(() => {
+    const cleanedCount = cleanupRequestStore(MAX_REQUEST_AGE);
+    if (cleanedCount > 0) {
+      // Cleanup was performed
+    }
+  }, CLEANUP_INTERVAL);
+}
+
+/**
+ * Stop automatic cleanup (typically on app shutdown)
+ */
+export function stopAutomaticCleanup(): void {
+  if (cleanupTimer) {
+    clearInterval(cleanupTimer);
+    cleanupTimer = null;
+  }
+}

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

@@ -72,10 +72,18 @@ export class CostTracker {
   }
 
   startOperation(modelId: string, operation: string): string {
-    // 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}`;
+    // Generate unique operation ID
+    let uniqueId: string;
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+      uniqueId = crypto.randomUUID();
+    } else {
+      // Fallback: Use timestamp with random component and counter
+      // Format: timestamp-randomCounter-operationHash
+      const timestamp = Date.now().toString(36);
+      const random = Math.random().toString(36).substring(2, 11);
+      const operationHash = operation.split('').reduce((acc, char) => acc + char.charCodeAt(0), 0).toString(36);
+      uniqueId = `${timestamp}-${random}-${operationHash}`;
+    }
 
     const estimatedCost = this.calculateEstimatedCost(modelId);
 

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

@@ -0,0 +1,64 @@
+/**
+ * Date Formatting Utilities
+ * Functions for formatting dates and times
+ */
+
+/**
+ * Format date to locale string
+ */
+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",
+  });
+}
+
+/**
+ * Format date and time to locale string
+ */
+export function formatDateTime(date: Date | string, locale: string = "en-US"): string {
+  const dateObj = typeof date === "string" ? new Date(date) : date;
+  return dateObj.toLocaleString(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");
+}

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

@@ -1,47 +1,9 @@
 /**
  * FAL Error Categorizer - Classifies FAL AI errors
+ *
+ * This module re-exports error categorization functions from the unified
+ * fal-error-handler.util module for backward compatibility.
  */
 
-import { FalErrorType, type FalErrorCategory } from "../../domain/entities/error.types";
-
-const PATTERNS: Record<FalErrorType, string[]> = {
-  [FalErrorType.NETWORK]: ["network", "fetch", "connection", "econnrefused", "enotfound", "etimedout"],
-  [FalErrorType.TIMEOUT]: ["timeout", "timed out"],
-  [FalErrorType.IMAGE_TOO_SMALL]: ["image_too_small", "image dimensions are too small", "minimum dimensions"],
-  [FalErrorType.VALIDATION]: ["validation", "invalid", "unprocessable", "422", "bad request", "400"],
-  [FalErrorType.CONTENT_POLICY]: ["content_policy", "content policy", "policy violation", "nsfw", "inappropriate"],
-  [FalErrorType.RATE_LIMIT]: ["rate limit", "too many requests", "429"],
-  [FalErrorType.AUTHENTICATION]: ["unauthorized", "401", "forbidden", "403", "api key", "authentication"],
-  [FalErrorType.QUOTA_EXCEEDED]: ["quota exceeded", "insufficient credits", "billing", "payment required", "402"],
-  [FalErrorType.MODEL_NOT_FOUND]: ["model not found", "endpoint not found", "404", "not found"],
-  [FalErrorType.API_ERROR]: ["api error", "502", "503", "504", "500", "internal server error"],
-  [FalErrorType.UNKNOWN]: [],
-};
-
-const RETRYABLE_TYPES = new Set([
-  FalErrorType.NETWORK,
-  FalErrorType.TIMEOUT,
-  FalErrorType.RATE_LIMIT,
-]);
-
-function matchesPatterns(errorString: string, patterns: string[]): boolean {
-  return patterns.some((pattern) => errorString.includes(pattern));
-}
-
-export function categorizeFalError(error: unknown): FalErrorCategory {
-  const message = error instanceof Error ? error.message : String(error);
-  const errorString = message.toLowerCase();
-
-  for (const [type, patterns] of Object.entries(PATTERNS)) {
-    if (patterns.length > 0 && matchesPatterns(errorString, patterns)) {
-      const errorType = type as FalErrorType;
-      return {
-        type: errorType,
-        messageKey: errorType,
-        retryable: RETRYABLE_TYPES.has(errorType),
-      };
-    }
-  }
-
-  return { type: FalErrorType.UNKNOWN, messageKey: "unknown", retryable: false };
-}
+export { categorizeFalError } from "./fal-error-handler.util";
+export type { FalErrorCategory } from "../../domain/entities/error.types";

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

@@ -1,73 +1,14 @@
 /**
  * FAL Error Mapper - Maps errors to user-friendly info
+ *
+ * This module re-exports error handling functions from the unified
+ * fal-error-handler.util module for backward compatibility.
  */
 
-import type { FalErrorInfo } from "../../domain/entities/error.types";
-import { categorizeFalError } from "./error-categorizer";
-import { safeJsonParseOrNull } from "./data-parsers.util";
-
-const STATUS_CODES = ["400", "401", "402", "403", "404", "422", "429", "500", "502", "503", "504"];
-
-interface FalApiErrorDetail {
-  msg?: string;
-  type?: string;
-  loc?: string[];
-}
-
-interface FalApiError {
-  body?: { detail?: FalApiErrorDetail[] } | string;
-  message?: string;
-}
-
-function extractStatusCode(errorString: string): number | undefined {
-  const code = STATUS_CODES.find((c) => errorString.includes(c));
-  return code ? parseInt(code, 10) : undefined;
-}
-
-/**
- * Parse FAL API error and extract user-friendly message
- */
-export function parseFalError(error: unknown): string {
-  const fallback = error instanceof Error ? error.message : String(error);
-
-  const falError = error as FalApiError;
-  if (!falError?.body) return fallback;
-
-  const body = typeof falError.body === "string"
-    ? safeJsonParseOrNull<{ detail?: FalApiErrorDetail[] }>(falError.body)
-    : falError.body;
-
-  const detail = body?.detail?.[0];
-  return detail?.msg ?? falError.message ?? fallback;
-}
-
-export function mapFalError(error: unknown): FalErrorInfo {
-  const category = categorizeFalError(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: errorString,
-    statusCode: extractStatusCode(errorString),
-  };
-}
-
-export function isFalErrorRetryable(error: unknown): boolean {
-  return categorizeFalError(error).retryable;
-}
+export {
+  mapFalError,
+  parseFalError,
+  isFalErrorRetryable,
+  categorizeFalError,
+  extractStatusCode,
+} from "./fal-error-handler.util";