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

package/package.json

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

@@ -0,0 +1,46 @@
+/**
+ * FAL Feature Models - Model resolution and input building
+ */
+
+import type {
+  ImageFeatureType,
+  VideoFeatureType,
+  ImageFeatureInputData,
+  VideoFeatureInputData,
+} from "@umituz/react-native-ai-generation-content";
+import {
+  buildImageFeatureInput as buildImageFeatureInputImpl,
+  buildVideoFeatureInput as buildVideoFeatureInputImpl,
+} from "../builders";
+
+export function getImageFeatureModel(
+  imageFeatureModels: Record<string, string>,
+  feature: ImageFeatureType,
+): string {
+  const model = imageFeatureModels[feature];
+  if (!model) throw new Error(`No model for image feature: ${feature}`);
+  return model;
+}
+
+export function getVideoFeatureModel(
+  videoFeatureModels: Record<string, string>,
+  feature: VideoFeatureType,
+): string {
+  const model = videoFeatureModels[feature];
+  if (!model) throw new Error(`No model for video feature: ${feature}`);
+  return model;
+}
+
+export function buildImageFeatureInput(
+  feature: ImageFeatureType,
+  data: ImageFeatureInputData,
+): Record<string, unknown> {
+  return buildImageFeatureInputImpl(feature, data);
+}
+
+export function buildVideoFeatureInput(
+  feature: VideoFeatureType,
+  data: VideoFeatureInputData,
+): Record<string, unknown> {
+  return buildVideoFeatureInputImpl(feature, data);
+}

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

@@ -1,6 +1,6 @@
 /**
  * FAL Provider - Implements IAIProvider interface
- * Uses Promise Deduplication Pattern with globalThis for hot reload persistence
+ * Orchestrates FAL AI operations with Promise Deduplication
  */
 
 import { fal } from "@fal-ai/client";
@@ -9,40 +9,28 @@ import type {
   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";
 import { DEFAULT_FAL_CONFIG, FAL_CAPABILITIES } from "./fal-provider.constants";
-import { mapFalStatusToJobStatus } from "./fal-status-mapper";
+import { handleFalSubscription, handleFalRun } from "./fal-provider-subscription";
+import { CostTracker } from "../utils/cost-tracker";
+import {
+  createRequestKey, getExistingRequest, storeRequest,
+  removeRequest, cancelAllRequests, hasActiveRequests,
+} from "./request-store";
 import {
+  submitJob as submitJobImpl,
+  getJobStatus as getJobStatusImpl,
+  getJobResult as getJobResultImpl,
+} from "./fal-queue-operations";
+import {
+  getImageFeatureModel as getImageFeatureModelImpl,
+  getVideoFeatureModel as getVideoFeatureModelImpl,
   buildImageFeatureInput as buildImageFeatureInputImpl,
   buildVideoFeatureInput as buildVideoFeatureInputImpl,
-} from "../builders";
-import { handleFalSubscription, handleFalRun } from "./fal-provider-subscription";
-import { CostTracker } from "../utils/cost-tracker";
+} from "./fal-feature-models";
 
 declare const __DEV__: boolean | undefined;
 
-interface ActiveRequest<T = unknown> {
-  promise: Promise<T>;
-  abortController: AbortController;
-}
-
-// 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";
   readonly providerName = "FAL AI";
@@ -107,20 +95,17 @@ export class FalProvider implements IAIProvider {
 
   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 submitJobImpl(model, input);
   }
 
   async getJobStatus(model: string, requestId: string): Promise<JobStatus> {
     this.validateInit();
-    const status = await fal.queue.status(model, { requestId, logs: true });
-    return mapFalStatusToJobStatus(status as unknown as FalQueueStatus);
+    return getJobStatusImpl(model, requestId);
   }
 
   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;
+    return getJobResultImpl<T>(model, requestId);
   }
 
   async subscribe<T = unknown>(
@@ -129,16 +114,14 @@ export class FalProvider implements IAIProvider {
     options?: SubscribeOptions<T>,
   ): Promise<T> {
     this.validateInit();
-    const store = getRequestStore();
     const key = createRequestKey(model, input);
 
-    // Return existing promise if same request is in progress
-    const existing = store.get(key);
+    const existing = getExistingRequest<T>(key);
     if (existing) {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log(`[FalProvider] Dedup: returning existing promise for ${model}`);
       }
-      return existing.promise as Promise<T>;
+      return existing.promise;
     }
 
     const abortController = new AbortController();
@@ -151,9 +134,9 @@ export class FalProvider implements IAIProvider {
         }
         return result;
       })
-      .finally(() => store.delete(key));
+      .finally(() => removeRequest(key));
 
-    store.set(key, { promise, abortController });
+    storeRequest(key, { promise, abortController });
     return promise;
   }
 
@@ -174,24 +157,15 @@ export class FalProvider implements IAIProvider {
   }
 
   cancelCurrentRequest(): void {
-    const store = getRequestStore();
-    store.forEach((req, key) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log(`[FalProvider] Cancelling request: ${key}`);
-      }
-      req.abortController.abort();
-    });
-    store.clear();
+    cancelAllRequests();
   }
 
   hasRunningRequest(): boolean {
-    return getRequestStore().size > 0;
+    return hasActiveRequests();
   }
 
   getImageFeatureModel(feature: ImageFeatureType): string {
-    const model = this.imageFeatureModels[feature];
-    if (!model) throw new Error(`No model for image feature: ${feature}`);
-    return model;
+    return getImageFeatureModelImpl(this.imageFeatureModels, feature);
   }
 
   buildImageFeatureInput(feature: ImageFeatureType, data: ImageFeatureInputData): Record<string, unknown> {
@@ -199,9 +173,7 @@ export class FalProvider implements IAIProvider {
   }
 
   getVideoFeatureModel(feature: VideoFeatureType): string {
-    const model = this.videoFeatureModels[feature];
-    if (!model) throw new Error(`No model for video feature: ${feature}`);
-    return model;
+    return getVideoFeatureModelImpl(this.videoFeatureModels, feature);
   }
 
   buildVideoFeatureInput(feature: VideoFeatureType, data: VideoFeatureInputData): Record<string, unknown> {

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

@@ -0,0 +1,27 @@
+/**
+ * FAL Queue Operations - Direct FAL API queue interactions
+ */
+
+import { fal } from "@fal-ai/client";
+import type { JobSubmission, JobStatus } from "@umituz/react-native-ai-generation-content";
+import type { FalQueueStatus } from "../../domain/entities/fal.types";
+import { mapFalStatusToJobStatus } from "./fal-status-mapper";
+
+export async function submitJob(model: string, input: Record<string, unknown>): Promise<JobSubmission> {
+  const result = await fal.queue.submit(model, { input });
+  return {
+    requestId: result.request_id,
+    statusUrl: result.status_url,
+    responseUrl: result.response_url,
+  };
+}
+
+export async function getJobStatus(model: string, requestId: string): Promise<JobStatus> {
+  const status = await fal.queue.status(model, { requestId, logs: true });
+  return mapFalStatusToJobStatus(status as unknown as FalQueueStatus);
+}
+
+export async function getJobResult<T = unknown>(model: string, requestId: string): Promise<T> {
+  const result = await fal.queue.result(model, { requestId });
+  return result.data as T;
+}

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

@@ -0,0 +1,53 @@
+/**
+ * Request Store - Promise Deduplication with globalThis
+ * Survives hot reloads for React Native development
+ */
+
+declare const __DEV__: boolean | undefined;
+
+export interface ActiveRequest<T = unknown> {
+  promise: Promise<T>;
+  abortController: AbortController;
+}
+
+const STORE_KEY = "__FAL_PROVIDER_REQUESTS__";
+type RequestStore = Map<string, ActiveRequest>;
+
+export 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;
+}
+
+export function createRequestKey(model: string, input: Record<string, unknown>): string {
+  const inputStr = JSON.stringify(input, Object.keys(input).sort());
+  return `${model}:${inputStr.slice(0, 100)}`;
+}
+
+export function getExistingRequest<T>(key: string): ActiveRequest<T> | undefined {
+  return getRequestStore().get(key) as ActiveRequest<T> | undefined;
+}
+
+export function storeRequest<T>(key: string, request: ActiveRequest<T>): void {
+  getRequestStore().set(key, request);
+}
+
+export function removeRequest(key: string): void {
+  getRequestStore().delete(key);
+}
+
+export function cancelAllRequests(): void {
+  const store = getRequestStore();
+  store.forEach((req, key) => {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log(`[RequestStore] Cancelling: ${key}`);
+    }
+    req.abortController.abort();
+  });
+  store.clear();
+}
+
+export function hasActiveRequests(): boolean {
+  return getRequestStore().size > 0;
+}