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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "1.0.93",
+  "version": "1.0.94",
   "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,21 +1,13 @@
 /**
  * FAL Provider - Implements IAIProvider interface
- * Uses Promise Deduplication Pattern to prevent duplicate requests
+ * Uses Promise Deduplication Pattern with globalThis for hot reload persistence
  */
 
 import { fal } from "@fal-ai/client";
 import type {
-  IAIProvider,
-  AIProviderConfig,
-  JobSubmission,
-  JobStatus,
-  SubscribeOptions,
-  RunOptions,
-  ImageFeatureType,
-  VideoFeatureType,
-  ImageFeatureInputData,
-  VideoFeatureInputData,
-  ProviderCapabilities,
+  IAIProvider, AIProviderConfig, JobSubmission, JobStatus, SubscribeOptions,
+  RunOptions, ImageFeatureType, VideoFeatureType, ImageFeatureInputData,
+  VideoFeatureInputData, ProviderCapabilities,
 } from "@umituz/react-native-ai-generation-content";
 import type { FalQueueStatus } from "../../domain/entities/fal.types";
 import type { CostTrackerConfig } from "../../domain/entities/cost-tracking.types";
@@ -33,14 +25,23 @@ 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;
+// Global request store - survives hot reloads via globalThis
+const STORE_KEY = "__FAL_PROVIDER_REQUESTS__";
+type RequestStore = Map<string, ActiveRequest>;
+
+function getRequestStore(): RequestStore {
+  if (!(globalThis as Record<string, unknown>)[STORE_KEY]) {
+    (globalThis as Record<string, unknown>)[STORE_KEY] = new Map();
+  }
+  return (globalThis as Record<string, unknown>)[STORE_KEY] as RequestStore;
+}
+
+function createRequestKey(model: string, input: Record<string, unknown>): string {
+  const inputStr = JSON.stringify(input, Object.keys(input).sort());
+  return `${model}:${inputStr.slice(0, 100)}`; // Limit key length
+}
 
 export class FalProvider implements IAIProvider {
   readonly providerId = "fal";
@@ -56,7 +57,6 @@ export class FalProvider implements IAIProvider {
     this.apiKey = config.apiKey;
     this.videoFeatureModels = config.videoFeatureModels ?? {};
     this.imageFeatureModels = config.imageFeatureModels ?? {};
-
     fal.config({
       credentials: config.apiKey,
       retry: {
@@ -65,7 +65,6 @@ export class FalProvider implements IAIProvider {
         maxDelay: config.maxDelay ?? DEFAULT_FAL_CONFIG.maxDelay,
       },
     });
-
     this.initialized = true;
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       console.log("[FalProvider] Initialized");
@@ -98,26 +97,18 @@ export class FalProvider implements IAIProvider {
 
   isFeatureSupported(feature: ImageFeatureType | VideoFeatureType): boolean {
     const caps = this.getCapabilities();
-    return (
-      caps.imageFeatures.includes(feature as ImageFeatureType) ||
-      caps.videoFeatures.includes(feature as VideoFeatureType)
-    );
+    return caps.imageFeatures.includes(feature as ImageFeatureType) ||
+           caps.videoFeatures.includes(feature as VideoFeatureType);
   }
 
   private validateInit(): void {
-    if (!this.apiKey || !this.initialized) {
-      throw new Error("FAL provider not initialized");
-    }
+    if (!this.apiKey || !this.initialized) throw new Error("FAL provider not initialized");
   }
 
   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,
-      statusUrl: result.status_url,
-      responseUrl: result.response_url,
-    };
+    return { requestId: result.request_id, statusUrl: result.status_url, responseUrl: result.response_url };
   }
 
   async getJobStatus(model: string, requestId: string): Promise<JobStatus> {
@@ -132,22 +123,22 @@ export class FalProvider implements IAIProvider {
     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.validateInit();
+    const store = getRequestStore();
+    const key = createRequestKey(model, input);
 
-    if (activeRequest) {
+    // Return existing promise if same request is in progress
+    const existing = store.get(key);
+    if (existing) {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log(`[FalProvider] Returning existing promise for ${activeRequest.model}`);
+        console.log(`[FalProvider] Dedup: returning existing promise for ${model}`);
       }
-      return activeRequest.promise as Promise<T>;
+      return existing.promise as Promise<T>;
     }
 
     const abortController = new AbortController();
@@ -159,19 +150,14 @@ export class FalProvider implements IAIProvider {
           this.costTracker.completeOperation(operationId, model, "subscribe", requestId ?? undefined);
         }
         return result;
-      });
-
-    activeRequest = { promise, abortController, model };
-    promise.finally(() => { activeRequest = null; });
+      })
+      .finally(() => store.delete(key));
 
+    store.set(key, { promise, abortController });
     return promise;
   }
 
-  async run<T = unknown>(
-    model: string,
-    input: Record<string, unknown>,
-    options?: RunOptions,
-  ): Promise<T> {
+  async run<T = unknown>(model: string, input: Record<string, unknown>, options?: RunOptions): Promise<T> {
     this.validateInit();
     const operationId = this.costTracker?.startOperation(model, "run");
     const result = await handleFalRun<T>(model, input, options);
@@ -188,17 +174,18 @@ export class FalProvider implements IAIProvider {
   }
 
   cancelCurrentRequest(): void {
-    if (activeRequest) {
+    const store = getRequestStore();
+    store.forEach((req, key) => {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[FalProvider] Cancelling current request");
+        console.log(`[FalProvider] Cancelling request: ${key}`);
       }
-      activeRequest.abortController.abort();
-      activeRequest = null;
-    }
+      req.abortController.abort();
+    });
+    store.clear();
   }
 
   hasRunningRequest(): boolean {
-    return activeRequest !== null;
+    return getRequestStore().size > 0;
   }
 
   getImageFeatureModel(feature: ImageFeatureType): string {