@umituz/react-native-ai-fal-provider 1.0.91 → 1.0.93

package/package.json

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

@@ -1,6 +1,6 @@
 /**
- * FAL Provider
- * Implements IAIProvider interface for unified AI generation
+ * FAL Provider - Implements IAIProvider interface
+ * Uses Promise Deduplication Pattern to prevent duplicate requests
  */
 
 import { fal } from "@fal-ai/client";
@@ -25,76 +25,65 @@ import {
   buildImageFeatureInput as buildImageFeatureInputImpl,
   buildVideoFeatureInput as buildVideoFeatureInputImpl,
 } from "../builders";
-import {
-  handleFalSubscription,
-  handleFalRun,
-} from "./fal-provider-subscription";
+import { handleFalSubscription, handleFalRun } from "./fal-provider-subscription";
 import { CostTracker } from "../utils/cost-tracker";
 
 declare const __DEV__: boolean | undefined;
 
+interface ActiveRequest<T = unknown> {
+  promise: Promise<T>;
+  abortController: AbortController;
+  model: string;
+}
+
+/**
+ * Module-level state for Promise Deduplication
+ * Persists across hot reloads (module cache is preserved)
+ */
+let activeRequest: ActiveRequest | null = null;
+
 export class FalProvider implements IAIProvider {
   readonly providerId = "fal";
   readonly providerName = "FAL AI";
 
   private apiKey: string | null = null;
   private initialized = false;
-  private currentAbortController: AbortController | null = null;
   private costTracker: CostTracker | null = null;
   private videoFeatureModels: Record<string, string> = {};
   private imageFeatureModels: Record<string, string> = {};
 
-  initialize(configData: AIProviderConfig): void {
-    this.apiKey = configData.apiKey;
-    this.videoFeatureModels = configData.videoFeatureModels ?? {};
-    this.imageFeatureModels = configData.imageFeatureModels ?? {};
+  initialize(config: AIProviderConfig): void {
+    this.apiKey = config.apiKey;
+    this.videoFeatureModels = config.videoFeatureModels ?? {};
+    this.imageFeatureModels = config.imageFeatureModels ?? {};
 
     fal.config({
-      credentials: configData.apiKey,
+      credentials: config.apiKey,
       retry: {
-        maxRetries: configData.maxRetries ?? DEFAULT_FAL_CONFIG.maxRetries,
-        baseDelay: configData.baseDelay ?? DEFAULT_FAL_CONFIG.baseDelay,
-        maxDelay: configData.maxDelay ?? DEFAULT_FAL_CONFIG.maxDelay,
+        maxRetries: config.maxRetries ?? DEFAULT_FAL_CONFIG.maxRetries,
+        baseDelay: config.baseDelay ?? DEFAULT_FAL_CONFIG.baseDelay,
+        maxDelay: config.maxDelay ?? DEFAULT_FAL_CONFIG.maxDelay,
       },
     });
 
     this.initialized = true;
-
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       console.log("[FalProvider] Initialized");
     }
   }
 
-  /**
-   * Enable cost tracking
-   */
   enableCostTracking(config?: CostTrackerConfig): void {
     this.costTracker = new CostTracker(config);
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[FalProvider] Cost tracking enabled");
-    }
   }
 
-  /**
-   * Disable cost tracking
-   */
   disableCostTracking(): void {
     this.costTracker = null;
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[FalProvider] Cost tracking disabled");
-    }
   }
 
-  /**
-   * Check if cost tracking is enabled
-   */
   isCostTrackingEnabled(): boolean {
     return this.costTracker !== null;
   }
 
-  /**
-   * Get cost tracker instance
-   */
   getCostTracker(): CostTracker | null {
     return this.costTracker;
   }
@@ -108,24 +97,21 @@ export class FalProvider implements IAIProvider {
   }
 
   isFeatureSupported(feature: ImageFeatureType | VideoFeatureType): boolean {
-    const capabilities = this.getCapabilities();
+    const caps = this.getCapabilities();
     return (
-      capabilities.imageFeatures.includes(feature as ImageFeatureType) ||
-      capabilities.videoFeatures.includes(feature as VideoFeatureType)
+      caps.imageFeatures.includes(feature as ImageFeatureType) ||
+      caps.videoFeatures.includes(feature as VideoFeatureType)
     );
   }
 
-  private validateInitialization(): void {
+  private validateInit(): void {
     if (!this.apiKey || !this.initialized) {
-      throw new Error("FAL provider not initialized. Call initialize() first.");
+      throw new Error("FAL provider not initialized");
     }
   }
 
-  async submitJob(
-    model: string,
-    input: Record<string, unknown>,
-  ): Promise<JobSubmission> {
-    this.validateInitialization();
+  async submitJob(model: string, input: Record<string, unknown>): Promise<JobSubmission> {
+    this.validateInit();
     const result = await fal.queue.submit(model, { input });
     return {
       requestId: result.request_id,
@@ -135,63 +121,50 @@ export class FalProvider implements IAIProvider {
   }
 
   async getJobStatus(model: string, requestId: string): Promise<JobStatus> {
-    this.validateInitialization();
+    this.validateInit();
     const status = await fal.queue.status(model, { requestId, logs: true });
     return mapFalStatusToJobStatus(status as unknown as FalQueueStatus);
   }
 
-  async getJobResult<T = unknown>(
-    model: string,
-    requestId: string,
-  ): Promise<T> {
-    this.validateInitialization();
+  async getJobResult<T = unknown>(model: string, requestId: string): Promise<T> {
+    this.validateInit();
     const result = await fal.queue.result(model, { requestId });
     return result.data as T;
   }
 
+  /**
+   * Promise Deduplication: If request in progress, return existing promise
+   * Prevents duplicate API calls from React re-renders
+   */
   async subscribe<T = unknown>(
     model: string,
     input: Record<string, unknown>,
     options?: SubscribeOptions<T>,
   ): Promise<T> {
-    this.validateInitialization();
+    this.validateInit();
 
-    // If there's already a running request, skip starting a new one
-    // This prevents React re-renders from cancelling ongoing generations
-    if (this.currentAbortController) {
+    if (activeRequest) {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[FalProvider] Request already in progress, skipping duplicate");
+        console.log(`[FalProvider] Returning existing promise for ${activeRequest.model}`);
       }
-      // Wait for the existing request by throwing a specific error
-      throw new Error("Generation already in progress");
+      return activeRequest.promise as Promise<T>;
     }
 
-    this.currentAbortController = new AbortController();
-
+    const abortController = new AbortController();
     const operationId = this.costTracker?.startOperation(model, "subscribe");
 
-    try {
-      const { result, requestId } = await handleFalSubscription<T>(
-        model,
-        input,
-        options,
-        this.currentAbortController.signal,
-      );
-
-      if (operationId && this.costTracker) {
-        this.costTracker.completeOperation(
-          operationId,
-          model,
-          "subscribe",
-          requestId ?? undefined,
-        );
-      }
+    const promise = handleFalSubscription<T>(model, input, options, abortController.signal)
+      .then(({ result, requestId }) => {
+        if (operationId && this.costTracker) {
+          this.costTracker.completeOperation(operationId, model, "subscribe", requestId ?? undefined);
+        }
+        return result;
+      });
 
-      return result;
-    } finally {
-      // Clear the abort controller when done (success or error)
-      this.currentAbortController = null;
-    }
+    activeRequest = { promise, abortController, model };
+    promise.finally(() => { activeRequest = null; });
+
+    return promise;
   }
 
   async run<T = unknown>(
@@ -199,16 +172,12 @@ export class FalProvider implements IAIProvider {
     input: Record<string, unknown>,
     options?: RunOptions,
   ): Promise<T> {
-    this.validateInitialization();
-
+    this.validateInit();
     const operationId = this.costTracker?.startOperation(model, "run");
-
     const result = await handleFalRun<T>(model, input, options);
-
     if (operationId && this.costTracker) {
       this.costTracker.completeOperation(operationId, model, "run");
     }
-
     return result;
   }
 
@@ -219,46 +188,36 @@ export class FalProvider implements IAIProvider {
   }
 
   cancelCurrentRequest(): void {
-    if (this.currentAbortController) {
+    if (activeRequest) {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[FalProvider] Cancelling current request");
       }
-      this.currentAbortController.abort();
-      this.currentAbortController = null;
+      activeRequest.abortController.abort();
+      activeRequest = null;
     }
   }
 
   hasRunningRequest(): boolean {
-    return this.currentAbortController !== null;
+    return activeRequest !== null;
   }
 
   getImageFeatureModel(feature: ImageFeatureType): string {
     const model = this.imageFeatureModels[feature];
-    if (!model) {
-      throw new Error(`No model configured for image feature: ${feature}`);
-    }
+    if (!model) throw new Error(`No model for image feature: ${feature}`);
     return model;
   }
 
-  buildImageFeatureInput(
-    feature: ImageFeatureType,
-    data: ImageFeatureInputData,
-  ): Record<string, unknown> {
+  buildImageFeatureInput(feature: ImageFeatureType, data: ImageFeatureInputData): Record<string, unknown> {
     return buildImageFeatureInputImpl(feature, data);
   }
 
   getVideoFeatureModel(feature: VideoFeatureType): string {
     const model = this.videoFeatureModels[feature];
-    if (!model) {
-      throw new Error(`No model configured for video feature: ${feature}`);
-    }
+    if (!model) throw new Error(`No model for video feature: ${feature}`);
     return model;
   }
 
-  buildVideoFeatureInput(
-    feature: VideoFeatureType,
-    data: VideoFeatureInputData,
-  ): Record<string, unknown> {
+  buildVideoFeatureInput(feature: VideoFeatureType, data: VideoFeatureInputData): Record<string, unknown> {
     return buildVideoFeatureInputImpl(feature, data);
   }
 }