@umituz/react-native-ai-fal-provider 1.0.60 → 1.0.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "1.0.60",
+  "version": "1.0.61",
   "description": "FAL AI provider for React Native - implements IAIProvider interface for unified AI generation",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/index.ts

@@ -26,7 +26,9 @@ export type { FeatureModelConfig } from "./domain/constants/feature-models.const
 export {
   FalProvider, falProvider, falModelsService,
   getImageFeatureModel, getVideoFeatureModel, NSFWContentError,
+  cancelCurrentFalRequest, hasRunningFalRequest,
 } from "./infrastructure/services";
+export type { FalProviderType } from "./infrastructure/services";
 
 export {
   categorizeFalError, falErrorMapper, mapFalError, isFalErrorRetryable,
@@ -55,7 +57,12 @@ export {
   sortJobsByCreation, getActiveJobs, getCompletedJobs,
 } from "./infrastructure/utils";
 
-export type { FalJobMetadata } from "./infrastructure/utils";
+export {
+  saveJobMetadata, loadJobMetadata, deleteJobMetadata, loadAllJobs,
+  cleanupOldJobs, getJobsByModel, getJobsByStatus, updateJobStatus,
+} from "./infrastructure/utils";
+
+export type { FalJobMetadata, IJobStorage, InMemoryJobStorage } from "./infrastructure/utils";
 
 export type {
   UpscaleOptions, PhotoRestoreOptions, FaceSwapOptions, ImageToImagePromptConfig,

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

@@ -33,6 +33,7 @@ export class FalProvider implements IAIProvider {
   private apiKey: string | null = null;
   private config: AIProviderConfig | null = null;
   private initialized = false;
+  private currentAbortController: AbortController | null = null;
 
   initialize(configData: AIProviderConfig): void {
     this.apiKey = configData.apiKey;
@@ -104,6 +105,14 @@ export class FalProvider implements IAIProvider {
     options?: SubscribeOptions<T>,
   ): Promise<T> {
     this.validateInitialization();
+
+    // Cancel previous request if exists
+    this.cancelCurrentRequest();
+
+    // Create new abort controller
+    this.currentAbortController = new AbortController();
+    const { signal } = this.currentAbortController;
+
     const timeoutMs = options?.timeoutMs ?? this.config?.defaultTimeoutMs ?? DEFAULT_FAL_CONFIG.defaultTimeoutMs;
     let timeoutId: ReturnType<typeof setTimeout> | null = null;
     let currentRequestId: string | null = null;
@@ -136,7 +145,15 @@ export class FalProvider implements IAIProvider {
           },
         }),
         new Promise<never>((_, reject) => {
-          timeoutId = setTimeout(() => reject(new Error("FAL subscription timeout")), timeoutMs);
+          timeoutId = setTimeout(() => {
+            reject(new Error("FAL subscription timeout"));
+          }, timeoutMs);
+        }),
+        // Abort promise
+        new Promise<never>((_, reject) => {
+          signal.addEventListener("abort", () => {
+            reject(new Error("Request cancelled by user"));
+          });
         }),
       ]);
 
@@ -150,6 +167,7 @@ export class FalProvider implements IAIProvider {
       return result as T;
     } finally {
       if (timeoutId) clearTimeout(timeoutId);
+      this.currentAbortController = null;
     }
   }
 
@@ -176,11 +194,32 @@ export class FalProvider implements IAIProvider {
   }
 
   reset(): void {
+    this.cancelCurrentRequest();
     this.apiKey = null;
     this.config = null;
     this.initialized = false;
   }
 
+  /**
+   * Cancel the current running request
+   */
+  cancelCurrentRequest(): void {
+    if (this.currentAbortController) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[FalProvider] Cancelling current request");
+      }
+      this.currentAbortController.abort();
+      this.currentAbortController = null;
+    }
+  }
+
+  /**
+   * Check if there's a running request
+   */
+  hasRunningRequest(): boolean {
+    return this.currentAbortController !== null;
+  }
+
   getImageFeatureModel(feature: ImageFeatureType): string {
     return FAL_IMAGE_FEATURE_MODELS[feature];
   }

package/src/infrastructure/services/index.ts

@@ -4,8 +4,10 @@
 
 import { FAL_IMAGE_FEATURE_MODELS, FAL_VIDEO_FEATURE_MODELS } from "../../domain/constants/feature-models.constants";
 import type { ImageFeatureType, VideoFeatureType } from "@umituz/react-native-ai-generation-content";
+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 { NSFWContentError } from "./nsfw-content-error";
 
@@ -16,3 +18,17 @@ export function getImageFeatureModel(feature: ImageFeatureType): string {
 export function getVideoFeatureModel(feature: VideoFeatureType): string {
   return FAL_VIDEO_FEATURE_MODELS[feature];
 }
+
+/**
+ * Cancel the current running FAL request
+ */
+export function cancelCurrentFalRequest(): void {
+  falProvider.cancelCurrentRequest();
+}
+
+/**
+ * Check if there's a running FAL request
+ */
+export function hasRunningFalRequest(): boolean {
+  return falProvider.hasRunningRequest();
+}

package/src/infrastructure/utils/index.ts

@@ -65,3 +65,16 @@ export {
 } from "./job-metadata.util";
 
 export type { FalJobMetadata } from "./job-metadata.util";
+
+export {
+  saveJobMetadata,
+  loadJobMetadata,
+  deleteJobMetadata,
+  loadAllJobs,
+  cleanupOldJobs,
+  getJobsByModel,
+  getJobsByStatus,
+  updateJobStatus,
+} from "./job-storage.util";
+
+export type { IJobStorage, InMemoryJobStorage } from "./job-storage.util";

package/src/infrastructure/utils/job-storage.util.ts

@@ -0,0 +1,187 @@
+/**
+ * Job Storage Utilities
+ * Helper functions for job persistence and storage integration
+ */
+
+import type { FalJobMetadata } from "./job-metadata.util";
+
+/**
+ * Generic storage interface for job persistence
+ * Implement this interface with your preferred storage backend
+ */
+export interface IJobStorage {
+  setItem(key: string, value: string): Promise<void>;
+  getItem(key: string): Promise<string | null>;
+  removeItem(key: string): Promise<void>;
+  getAllKeys?(): Promise<readonly string[]>;
+}
+
+/**
+ * Save job metadata to storage
+ */
+export async function saveJobMetadata(
+  storage: IJobStorage,
+  metadata: FalJobMetadata
+): Promise<void> {
+  const key = `fal_job:${metadata.requestId}`;
+  const value = JSON.stringify(metadata);
+  await storage.setItem(key, value);
+}
+
+/**
+ * Load job metadata from storage
+ */
+export async function loadJobMetadata(
+  storage: IJobStorage,
+  requestId: string
+): Promise<FalJobMetadata | null> {
+  const key = `fal_job:${requestId}`;
+  const value = await storage.getItem(key);
+  if (!value) return null;
+
+  try {
+    return JSON.parse(value) as FalJobMetadata;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Delete job metadata from storage
+ */
+export async function deleteJobMetadata(
+  storage: IJobStorage,
+  requestId: string
+): Promise<void> {
+  const key = `fal_job:${requestId}`;
+  await storage.removeItem(key);
+}
+
+/**
+ * Load all jobs from storage
+ */
+export async function loadAllJobs(
+  storage: IJobStorage
+): Promise<FalJobMetadata[]> {
+  if (!storage.getAllKeys) {
+    return [];
+  }
+
+  const keys = await storage.getAllKeys();
+  const jobKeys = keys.filter((key) => key.startsWith("fal_job:"));
+
+  const jobs: FalJobMetadata[] = [];
+  for (const key of jobKeys) {
+    const value = await storage.getItem(key);
+    if (value) {
+      try {
+        const metadata = JSON.parse(value) as FalJobMetadata;
+        jobs.push(metadata);
+      } catch {
+        // Skip invalid entries
+        continue;
+      }
+    }
+  }
+
+  return jobs;
+}
+
+/**
+ * Clean up old jobs from storage
+ */
+export async function cleanupOldJobs(
+  storage: IJobStorage,
+  maxAgeMinutes: number = 60
+): Promise<number> {
+  const jobs = await loadAllJobs(storage);
+  const now = Date.now();
+  const maxAgeMs = maxAgeMinutes * 60 * 1000;
+  let cleanedCount = 0;
+
+  for (const job of jobs) {
+    const jobAge = now - new Date(job.createdAt).getTime();
+    if (jobAge > maxAgeMs) {
+      await deleteJobMetadata(storage, job.requestId);
+      cleanedCount++;
+    }
+  }
+
+  return cleanedCount;
+}
+
+/**
+ * Get jobs by model
+ */
+export async function getJobsByModel(
+  storage: IJobStorage,
+  model: string
+): Promise<FalJobMetadata[]> {
+  const jobs = await loadAllJobs(storage);
+  return jobs.filter((job) => job.model === model);
+}
+
+/**
+ * Get jobs by status
+ */
+export async function getJobsByStatus(
+  storage: IJobStorage,
+  status: FalJobMetadata["status"]
+): Promise<FalJobMetadata[]> {
+  const jobs = await loadAllJobs(storage);
+  return jobs.filter((job) => job.status === status);
+}
+
+/**
+ * Update job status in storage
+ */
+export async function updateJobStatus(
+  storage: IJobStorage,
+  requestId: string,
+  status: FalJobMetadata["status"],
+  error?: string
+): Promise<void> {
+  const metadata = await loadJobMetadata(storage, requestId);
+  if (!metadata) {
+    throw new Error(`Job not found: ${requestId}`);
+  }
+
+  const updated: FalJobMetadata = {
+    ...metadata,
+    status,
+    updatedAt: new Date().toISOString(),
+    ...(status === "COMPLETED" || status === "FAILED" ? { completedAt: new Date().toISOString() } : {}),
+    ...(error ? { error } : {}),
+  };
+
+  await saveJobMetadata(storage, updated);
+}
+
+/**
+ * Create a simple in-memory storage for testing
+ */
+export class InMemoryJobStorage implements IJobStorage {
+  private store = new Map<string, string>();
+
+  setItem(key: string, value: string): Promise<void> {
+    this.store.set(key, value);
+    return Promise.resolve();
+  }
+
+  getItem(key: string): Promise<string | null> {
+    return Promise.resolve(this.store.get(key) ?? null);
+  }
+
+  removeItem(key: string): Promise<void> {
+    this.store.delete(key);
+    return Promise.resolve();
+  }
+
+  getAllKeys(): Promise<readonly string[]> {
+    return Promise.resolve(Array.from(this.store.keys()));
+  }
+
+  clear(): void {
+    this.store.clear();
+  }
+}

package/src/presentation/hooks/use-fal-generation.ts

@@ -21,8 +21,10 @@ export interface UseFalGenerationResult<T> {
   isLoading: boolean;
   isRetryable: boolean;
   requestId: string | null;
+  isCancelling: boolean;
   generate: (modelEndpoint: string, input: FalJobInput) => Promise<T | null>;
   retry: () => Promise<T | null>;
+  cancel: () => void;
   reset: () => void;
 }
 
@@ -32,9 +34,11 @@ export function useFalGeneration<T = unknown>(
   const [data, setData] = useState<T | null>(null);
   const [error, setError] = useState<FalErrorInfo | null>(null);
   const [isLoading, setIsLoading] = useState(false);
+  const [isCancelling, setIsCancelling] = useState(false);
 
   const lastRequestRef = useRef<{ endpoint: string; input: FalJobInput } | null>(null);
   const currentRequestIdRef = useRef<string | null>(null);
+  const abortControllerRef = useRef<AbortController | null>(null);
 
   const generate = useCallback(
     async (modelEndpoint: string, input: FalJobInput): Promise<T | null> => {
@@ -43,6 +47,10 @@ export function useFalGeneration<T = unknown>(
       setError(null);
       setData(null);
       currentRequestIdRef.current = null;
+      setIsCancelling(false);
+
+      // Create abort controller for this request
+      abortControllerRef.current = new AbortController();
 
       try {
         const result = await falProvider.subscribe<T>(modelEndpoint, input, {
@@ -50,10 +58,11 @@ export function useFalGeneration<T = unknown>(
           onQueueUpdate: (status) => {
             // Note: requestId is tracked internally by falProvider subscribe
             // and exposed via the requestId ref, not from status object
+            const currentRequestId = currentRequestIdRef.current ?? "";
             // Map JobStatus to FalQueueStatus for backward compatibility
             options?.onProgress?.({
               status: status.status,
-              requestId: currentRequestIdRef.current ?? "",
+              requestId: currentRequestId,
               logs: status.logs?.map((log: FalLogEntry) => ({
                 message: log.message,
                 level: log.level,
@@ -73,6 +82,8 @@ export function useFalGeneration<T = unknown>(
         return null;
       } finally {
         setIsLoading(false);
+        setIsCancelling(false);
+        abortControllerRef.current = null;
       }
     },
     [options]
@@ -84,13 +95,25 @@ export function useFalGeneration<T = unknown>(
     return generate(endpoint, input);
   }, [generate]);
 
+  const cancel = useCallback(() => {
+    if (abortControllerRef.current) {
+      setIsCancelling(true);
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[useFalGeneration] Request cancelled");
+      }
+    }
+  }, []);
+
   const reset = useCallback(() => {
+    cancel();
     setData(null);
     setError(null);
     setIsLoading(false);
     lastRequestRef.current = null;
     currentRequestIdRef.current = null;
-  }, []);
+  }, [cancel]);
 
   return {
     data,
@@ -98,8 +121,10 @@ export function useFalGeneration<T = unknown>(
     isLoading,
     isRetryable: error ? isFalErrorRetryable(error.originalError) : false,
     requestId: currentRequestIdRef.current,
+    isCancelling,
     generate,
     retry,
+    cancel,
     reset,
   };
 }