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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "1.0.59",
+  "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,
@@ -48,6 +50,20 @@ export {
   buildErrorMessage, isDefined, removeNullish, debounce, throttle,
 } from "./infrastructure/utils";
 
+export {
+  createJobMetadata, updateJobMetadata, isJobCompleted, isJobRunning,
+  isJobStale, getJobDuration, formatJobDuration, calculateJobProgress,
+  serializeJobMetadata, deserializeJobMetadata, filterValidJobs,
+  sortJobsByCreation, getActiveJobs, getCompletedJobs,
+} 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,
   RemoveBackgroundOptions, RemoveObjectOptions, ReplaceBackgroundOptions,

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,8 +105,17 @@ 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;
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       console.log("[FalProvider] Subscribe started:", { model, timeoutMs });
@@ -119,24 +129,36 @@ export class FalProvider implements IAIProvider {
           input,
           logs: false,
           pollInterval: DEFAULT_FAL_CONFIG.pollInterval,
-          onQueueUpdate: (update: { status: string; logs?: unknown[] }) => {
-            const jobStatus = mapFalStatusToJobStatus(update as unknown as FalQueueStatus);
+          onQueueUpdate: (update: { status: string; logs?: unknown[]; request_id?: string }) => {
+            currentRequestId = update.request_id ?? null;
+            const jobStatus = mapFalStatusToJobStatus({
+              ...update as unknown as FalQueueStatus,
+              requestId: currentRequestId ?? "",
+            });
             if (jobStatus.status !== lastStatus) {
               lastStatus = jobStatus.status;
               if (typeof __DEV__ !== "undefined" && __DEV__) {
-                console.log("[FalProvider] Status:", jobStatus.status);
+                console.log("[FalProvider] Status:", jobStatus.status, "RequestId:", currentRequestId);
               }
             }
             options?.onQueueUpdate?.(jobStatus);
           },
         }),
         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"));
+          });
         }),
       ]);
 
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[FalProvider] Subscribe completed:", { model });
+        console.log("[FalProvider] Subscribe completed:", { model, requestId: currentRequestId });
       }
 
       validateNSFWContent(result as Record<string, unknown>);
@@ -145,6 +167,7 @@ export class FalProvider implements IAIProvider {
       return result as T;
     } finally {
       if (timeoutId) clearTimeout(timeoutId);
+      this.currentAbortController = null;
     }
   }
 
@@ -171,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

@@ -46,3 +46,35 @@ export {
   debounce,
   throttle,
 } from "./helpers.util";
+
+export {
+  createJobMetadata,
+  updateJobMetadata,
+  isJobCompleted,
+  isJobRunning,
+  isJobStale,
+  getJobDuration,
+  formatJobDuration,
+  calculateJobProgress,
+  serializeJobMetadata,
+  deserializeJobMetadata,
+  filterValidJobs,
+  sortJobsByCreation,
+  getActiveJobs,
+  getCompletedJobs,
+} 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-metadata.util.ts

@@ -0,0 +1,176 @@
+/**
+ * Job Metadata Utilities
+ * Helper functions for job metadata and management
+ */
+
+import type { JobStatus } from "@umituz/react-native-ai-generation-content";
+
+/**
+ * Job metadata for tracking and persistence
+ */
+export interface FalJobMetadata {
+  readonly requestId: string;
+  readonly model: string;
+  readonly status: JobStatus["status"];
+  readonly createdAt: string;
+  readonly updatedAt: string;
+  readonly completedAt?: string;
+  readonly timeout?: number;
+  readonly error?: string;
+}
+
+/**
+ * Create job metadata
+ */
+export function createJobMetadata(
+  requestId: string,
+  model: string,
+  timeout?: number
+): FalJobMetadata {
+  const now = new Date().toISOString();
+  return {
+    requestId,
+    model,
+    status: "IN_QUEUE",
+    createdAt: now,
+    updatedAt: now,
+    timeout,
+  };
+}
+
+/**
+ * Update job metadata status
+ */
+export function updateJobMetadata(
+  metadata: FalJobMetadata,
+  status: JobStatus["status"],
+  error?: string
+): FalJobMetadata {
+  return {
+    ...metadata,
+    status,
+    updatedAt: new Date().toISOString(),
+    ...(status === "COMPLETED" || status === "FAILED" ? { completedAt: new Date().toISOString() } : {}),
+    ...(error ? { error } : {}),
+  };
+}
+
+/**
+ * Check if job is completed (success or failure)
+ */
+export function isJobCompleted(metadata: FalJobMetadata): boolean {
+  return metadata.status === "COMPLETED" || metadata.status === "FAILED";
+}
+
+/**
+ * Check if job is running
+ */
+export function isJobRunning(metadata: FalJobMetadata): boolean {
+  return metadata.status === "IN_QUEUE" || metadata.status === "IN_PROGRESS";
+}
+
+/**
+ * Check if job is stale (older than specified minutes)
+ */
+export function isJobStale(metadata: FalJobMetadata, maxAgeMinutes: number = 60): boolean {
+  const age = Date.now() - new Date(metadata.createdAt).getTime();
+  const maxAgeMs = maxAgeMinutes * 60 * 1000;
+  return age > maxAgeMs;
+}
+
+/**
+ * Get job duration in milliseconds
+ */
+export function getJobDuration(metadata: FalJobMetadata): number | null {
+  if (!metadata.completedAt) {
+    return null;
+  }
+  return new Date(metadata.completedAt).getTime() - new Date(metadata.createdAt).getTime();
+}
+
+/**
+ * Format job duration for display
+ */
+export function formatJobDuration(metadata: FalJobMetadata): string {
+  const duration = getJobDuration(metadata);
+  if (!duration) {
+    return "In progress";
+  }
+
+  const seconds = Math.floor(duration / 1000);
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
+}
+
+/**
+ * Calculate job progress percentage
+ */
+export function calculateJobProgress(metadata: FalJobMetadata): number {
+  switch (metadata.status) {
+    case "IN_QUEUE":
+      return 10;
+    case "IN_PROGRESS":
+      return 50;
+    case "COMPLETED":
+      return 100;
+    case "FAILED":
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+/**
+ * Serialize job metadata for storage
+ */
+export function serializeJobMetadata(metadata: FalJobMetadata): string {
+  return JSON.stringify(metadata);
+}
+
+/**
+ * Deserialize job metadata from storage
+ */
+export function deserializeJobMetadata(data: string): FalJobMetadata | null {
+  try {
+    return JSON.parse(data) as FalJobMetadata;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Filter valid job metadata from array
+ */
+export function filterValidJobs(jobs: FalJobMetadata[]): FalJobMetadata[] {
+  return jobs.filter((job) => !isJobStale(job));
+}
+
+/**
+ * Sort jobs by creation time (newest first)
+ */
+export function sortJobsByCreation(jobs: FalJobMetadata[]): FalJobMetadata[] {
+  return [...jobs].sort((a, b) => {
+    const timeA = new Date(a.createdAt).getTime();
+    const timeB = new Date(b.createdAt).getTime();
+    return timeB - timeA;
+  });
+}
+
+/**
+ * Get active jobs (not completed and not stale)
+ */
+export function getActiveJobs(jobs: FalJobMetadata[]): FalJobMetadata[] {
+  return jobs.filter((job) => isJobRunning(job) && !isJobStale(job));
+}
+
+/**
+ * Get completed jobs
+ */
+export function getCompletedJobs(jobs: FalJobMetadata[]): FalJobMetadata[] {
+  return jobs.filter((job) => isJobCompleted(job));
+}

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

@@ -20,8 +20,11 @@ export interface UseFalGenerationResult<T> {
   error: FalErrorInfo | null;
   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;
 }
 
@@ -31,8 +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> => {
@@ -40,15 +46,23 @@ export function useFalGeneration<T = unknown>(
       setIsLoading(true);
       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, {
           timeoutMs: options?.timeoutMs,
           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: "",
+              requestId: currentRequestId,
               logs: status.logs?.map((log: FalLogEntry) => ({
                 message: log.message,
                 level: log.level,
@@ -68,6 +82,8 @@ export function useFalGeneration<T = unknown>(
         return null;
       } finally {
         setIsLoading(false);
+        setIsCancelling(false);
+        abortControllerRef.current = null;
       }
     },
     [options]
@@ -79,20 +95,36 @@ 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,
     error,
     isLoading,
     isRetryable: error ? isFalErrorRetryable(error.originalError) : false,
+    requestId: currentRequestIdRef.current,
+    isCancelling,
     generate,
     retry,
+    cancel,
     reset,
   };
 }