@umituz/react-native-ai-gemini-provider 2.1.5 → 2.1.7

package/src/presentation/hooks/use-gemini.ts

@@ -1,10 +1,10 @@
-
-import { useState, useCallback, useRef, useMemo, useEffect } from "react";
+import { useState, useCallback, useMemo } from "react";
 import type { GeminiGenerationConfig } from "../../domain/entities";
 import { DEFAULT_MODELS } from "../../domain/entities";
 import { geminiTextGenerationService, geminiStructuredTextService } from "../../infrastructure/services";
 import { executeWithState, type AsyncStateSetters } from "../../infrastructure/utils/async";
 import { parseJsonResponse } from "../../infrastructure/utils/json-parser.util";
+import { useOperationManager } from "./use-operation-manager";
 
 export interface UseGeminiOptions {
   model?: string;
@@ -28,8 +28,8 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
   const [jsonResult, setJsonResult] = useState<unknown>(null);
   const [isGenerating, setIsGenerating] = useState(false);
   const [error, setError] = useState<string | null>(null);
-  const abortControllerRef = useRef<AbortController | null>(null);
-  const operationIdRef = useRef(0);
+
+  const { executeOperation, abort } = useOperationManager();
 
   const setters: AsyncStateSetters<string, unknown> = useMemo(
     () => ({
@@ -50,63 +50,37 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
 
   const generate = useCallback(
     async (prompt: string) => {
-      if (abortControllerRef.current) {
-        abortControllerRef.current.abort();
-      }
-
-      const controller = new AbortController();
-      abortControllerRef.current = controller;
-      const currentOpId = ++operationIdRef.current;
-
-      try {
+      await executeOperation(async (signal, _operationId) => {
         await executeWithState(
           setters,
           callbacks,
           async () => {
-            if (currentOpId !== operationIdRef.current) {
-              controller.abort();
-              throw new Error("Operation cancelled by newer request");
-            }
             return geminiTextGenerationService.generateText(
               model,
               prompt,
               options.generationConfig,
-              controller.signal
+              signal
             );
           },
           (text: string) => {
-            if (currentOpId === operationIdRef.current) {
-              setResult(text);
-              options.onSuccess?.(text);
-            }
+            setResult(text);
+            options.onSuccess?.(text);
           }
         );
-      } finally {
-        if (currentOpId === operationIdRef.current) {
-          abortControllerRef.current = null;
-        }
-      }
+      });
     },
-    [model, options.generationConfig, setters, callbacks, options.onSuccess]
+    [model, options.generationConfig, setters, callbacks, options.onSuccess, executeOperation]
   );
 
   const generateJSON = useCallback(
     async <T>(prompt: string, schema?: Record<string, unknown>): Promise<T | null> => {
-      if (abortControllerRef.current) {
-        abortControllerRef.current.abort();
-      }
-
-      const controller = new AbortController();
-      abortControllerRef.current = controller;
-      const currentOpId = ++operationIdRef.current;
-
-      try {
-        // Create separate setters for JSON generation with proper types
+      return executeOperation(async (signal, _operationId) => {
         const jsonSetters: AsyncStateSetters<unknown, unknown> = {
           setIsLoading: setIsGenerating,
           setError,
           setResult: setJsonResult,
-          setSecondaryResult: (value) => setResult(typeof value === "string" ? value : JSON.stringify(value)),
+          setSecondaryResult: (value) =>
+            setResult(typeof value === "string" ? value : JSON.stringify(value)),
         };
 
         const jsonCallbacks = {
@@ -120,18 +94,13 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
           jsonSetters,
           jsonCallbacks,
           async () => {
-            if (currentOpId !== operationIdRef.current) {
-              controller.abort();
-              throw new Error("Operation cancelled by newer request");
-            }
-
             if (schema) {
               return geminiStructuredTextService.generateStructuredText<T>(
                 model,
                 prompt,
                 schema,
                 options.generationConfig,
-                controller.signal
+                signal
               );
             }
 
@@ -139,50 +108,30 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
               model,
               prompt,
               { ...options.generationConfig, responseMimeType: "application/json" },
-              controller.signal
+              signal
             );
 
             return parseJsonResponse<T>(text);
           },
           (parsed: unknown) => {
-            if (currentOpId === operationIdRef.current) {
-              setJsonResult(parsed);
-              setResult(JSON.stringify(parsed, null, 2));
-            }
+            setJsonResult(parsed);
+            setResult(JSON.stringify(parsed, null, 2));
           }
         );
 
         return operationResult as T | null;
-      } finally {
-        if (currentOpId === operationIdRef.current) {
-          abortControllerRef.current = null;
-        }
-      }
+      });
     },
-    [model, options.generationConfig, callbacks, options.onSuccess]
+    [model, options.generationConfig, callbacks, options.onSuccess, executeOperation]
   );
 
   const reset = useCallback(() => {
-    if (abortControllerRef.current) {
-      abortControllerRef.current.abort();
-      abortControllerRef.current = null;
-    }
-    operationIdRef.current++;
-
+    abort();
     setResult(null);
     setJsonResult(null);
     setIsGenerating(false);
     setError(null);
-  }, []);
-
-  useEffect(() => {
-    return () => {
-      if (abortControllerRef.current) {
-        abortControllerRef.current.abort();
-      }
-      operationIdRef.current++;
-    };
-  }, []);
+  }, [abort]);
 
   return { generate, generateJSON, result, jsonResult, isGenerating, error, reset };
 }

package/src/presentation/hooks/use-operation-manager.ts

@@ -0,0 +1,88 @@
+/**
+ * Operation Manager Hook
+ * Reusable abort controller and operation ID management
+ * Eliminates code duplication in hooks
+ */
+
+import { useRef, useCallback, useEffect } from "react";
+
+export interface OperationManager {
+  /**
+   * Execute an operation with abort support and operation ID tracking
+   */
+  executeOperation: <T>(
+    operation: (signal: AbortSignal, operationId: number) => Promise<T>
+  ) => Promise<T>;
+
+  /**
+   * Abort current operation
+   */
+  abort: () => void;
+
+  /**
+   * Check if current operation is active
+   */
+  isOperationActive: (operationId: number) => boolean;
+}
+
+/**
+ * Hook for managing operations with abort control
+ */
+export function useOperationManager(): OperationManager {
+  const abortControllerRef = useRef<AbortController | null>(null);
+  const operationIdRef = useRef(0);
+
+  const abort = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+    operationIdRef.current++;
+  }, []);
+
+  const isOperationActive = useCallback((operationId: number): boolean => {
+    return operationId === operationIdRef.current;
+  }, []);
+
+  const executeOperation = useCallback(
+    async <T>(
+      operation: (signal: AbortSignal, operationId: number) => Promise<T>
+    ): Promise<T> => {
+      // Abort any existing operation
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+
+      // Create new controller and increment operation ID
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+      const currentOpId = ++operationIdRef.current;
+
+      try {
+        return await operation(controller.signal, currentOpId);
+      } finally {
+        // Clean up only if this is still the current operation
+        if (currentOpId === operationIdRef.current) {
+          abortControllerRef.current = null;
+        }
+      }
+    },
+    []
+  );
+
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      operationIdRef.current++;
+    };
+  }, []);
+
+  return {
+    executeOperation,
+    abort,
+    isOperationActive,
+  };
+}

package/src/providers/ConfigBuilder.ts

@@ -0,0 +1,121 @@
+/**
+ * Config Builder Pattern
+ * Fluent API for building provider configuration
+ */
+
+import { DEFAULT_MODELS } from "../domain/entities";
+import type { GeminiConfig } from "../domain/entities";
+
+export interface ProviderConfig {
+  apiKey: string;
+  textModel: string;
+  timeout: number;
+  strategy?: "cost" | "quality";
+}
+
+/**
+ * Builder for constructing provider configuration
+ * Provides a fluent API with validation and defaults
+ */
+export class ConfigBuilder {
+  private config: Partial<ProviderConfig> = {
+    textModel: DEFAULT_MODELS.TEXT,
+    timeout: 30000,
+  };
+
+  /**
+   * Set API key (required)
+   */
+  withApiKey(apiKey: string): this {
+    if (!apiKey || typeof apiKey !== "string" || apiKey.trim().length === 0) {
+      throw new Error("API key must be a non-empty string");
+    }
+    this.config.apiKey = apiKey.trim();
+    return this;
+  }
+
+  /**
+   * Set text model
+   */
+  withTextModel(model: string): this {
+    if (!model || !model.startsWith("gemini-")) {
+      throw new Error("Invalid model name");
+    }
+    this.config.textModel = model;
+    return this;
+  }
+
+  /**
+   * Set request timeout (ms)
+   */
+  withTimeout(timeout: number): this {
+    if (timeout <= 0 || timeout > 300000) {
+      throw new Error("Timeout must be between 1ms and 300000ms (5 minutes)");
+    }
+    this.config.timeout = timeout;
+    return this;
+  }
+
+  /**
+   * Set strategy (applies preset timeout)
+   */
+  withStrategy(strategy: "cost" | "quality"): this {
+    this.config.strategy = strategy;
+
+    // Apply strategy-based defaults
+    if (strategy === "quality") {
+      this.config.timeout = 60000;
+    } else {
+      this.config.timeout = 30000;
+    }
+
+    return this;
+  }
+
+  /**
+   * Build final configuration
+   */
+  build(): ProviderConfig {
+    if (!this.config.apiKey) {
+      throw new Error("API key is required. Call withApiKey() before build()");
+    }
+
+    return {
+      apiKey: this.config.apiKey,
+      textModel: this.config.textModel!,
+      timeout: this.config.timeout!,
+      strategy: this.config.strategy,
+    };
+  }
+
+  /**
+   * Convert to GeminiConfig format
+   */
+  toGeminiConfig(): GeminiConfig {
+    const config = this.build();
+    return {
+      apiKey: config.apiKey,
+      textModel: config.textModel,
+      defaultTimeoutMs: config.timeout,
+    };
+  }
+
+  /**
+   * Create a new builder instance
+   */
+  static create(): ConfigBuilder {
+    return new ConfigBuilder();
+  }
+
+  /**
+   * Create from existing config (for updates)
+   */
+  static from(config: Partial<ProviderConfig>): ConfigBuilder {
+    const builder = new ConfigBuilder();
+    if (config.apiKey) builder.withApiKey(config.apiKey);
+    if (config.textModel) builder.withTextModel(config.textModel);
+    if (config.timeout) builder.withTimeout(config.timeout);
+    if (config.strategy) builder.withStrategy(config.strategy);
+    return builder;
+  }
+}

package/src/providers/ProviderFactory.ts

@@ -1,49 +1,52 @@
-
 import { geminiClientCoreService } from "../infrastructure/services/gemini-client-core.service";
-import type { GeminiConfig } from "../domain/entities";
-import type {
-  ProviderConfigInput,
-  ResolvedProviderConfig,
-} from "./ProviderConfig";
-import { resolveProviderConfig } from "./ProviderConfig";
+import { ConfigBuilder, type ProviderConfig } from "./ConfigBuilder";
+
+// Re-export for public API
+export { ConfigBuilder } from "./ConfigBuilder";
+export type { ProviderConfig } from "./ConfigBuilder";
 
-export interface ProviderFactoryOptions extends ProviderConfigInput {
-  /** Provider strategy */
+export interface ProviderFactoryOptions {
+  apiKey: string;
+  timeout?: number;
+  textModel?: string;
   strategy?: "cost" | "quality";
 }
 
 class ProviderFactory {
-  private currentConfig: ResolvedProviderConfig | null = null;
-  private currentOptions: ProviderFactoryOptions | null = null;
+  private currentConfig: ProviderConfig | null = null;
+  private builder: ConfigBuilder | null = null;
 
   /**
    * Initialize provider with configuration
    */
   initialize(options: ProviderFactoryOptions): void {
-    const config = resolveProviderConfig(options);
+    // Build configuration using builder pattern
+    this.builder = ConfigBuilder.create()
+      .withApiKey(options.apiKey);
 
-    // Apply strategy-based adjustments
-    if (options.strategy === "quality") {
-      config.timeout = 60000; // Longer timeout for quality
+    if (options.strategy) {
+      this.builder.withStrategy(options.strategy);
     }
 
-    this.currentConfig = config;
-    this.currentOptions = options;
+    if (options.textModel) {
+      this.builder.withTextModel(options.textModel);
+    }
 
-    // Initialize Gemini client with resolved config
-    const geminiConfig: GeminiConfig = {
-      apiKey: config.apiKey,
-      defaultTimeoutMs: config.timeout,
-      textModel: config.textModel,
-    };
+    if (options.timeout) {
+      this.builder.withTimeout(options.timeout);
+    }
 
+    this.currentConfig = this.builder.build();
+
+    // Initialize Gemini client
+    const geminiConfig = this.builder.toGeminiConfig();
     geminiClientCoreService.initialize(geminiConfig);
   }
 
   /**
-   * Get current resolved configuration
+   * Get current configuration
    */
-  getConfig(): ResolvedProviderConfig | null {
+  getConfig(): ProviderConfig | null {
     return this.currentConfig;
   }
 
@@ -55,38 +58,23 @@ class ProviderFactory {
   }
 
   /**
-   * Update configuration without re-initializing
-   * Note: Changing apiKey requires full re-initialization
+   * Update configuration
+   * API key changes require re-initialization
    */
-  updateConfig(updates: Partial<ProviderConfigInput>): void {
-    if (!this.currentConfig || !this.currentOptions) {
+  updateConfig(updates: Partial<ProviderFactoryOptions>): void {
+    if (!this.currentConfig) {
       throw new Error("Provider not initialized. Call initialize() first.");
     }
 
-    // If API key is changing, we need to re-initialize
+    // If API key changes, re-initialize
     if (updates.apiKey && updates.apiKey !== this.currentConfig.apiKey) {
-      const newInput: ProviderFactoryOptions = {
-        apiKey: updates.apiKey,
-        preferences: updates.preferences || this.currentOptions.preferences,
-        strategy: this.currentOptions.strategy,
-      };
-      this.initialize(newInput);
+      this.initialize({ ...this.currentConfig, ...updates });
       return;
     }
 
-    // For other updates, merge with current config
-    const mergedPreferences = {
-      ...this.currentOptions.preferences,
-      ...updates.preferences,
-    };
-
-    this.currentOptions.preferences = mergedPreferences;
-
-    this.currentConfig = {
-      apiKey: this.currentConfig.apiKey,
-      textModel: this.currentConfig.textModel,
-      timeout: mergedPreferences.timeout ?? this.currentConfig.timeout,
-    };
+    // Otherwise, update using builder
+    this.builder = ConfigBuilder.from({ ...this.currentConfig, ...updates });
+    this.currentConfig = this.builder.build();
   }
 }
 

package/src/providers/index.ts

@@ -1,18 +1,9 @@
 /**
- * Provider Configuration & Factory
- * Centralized configuration system for AI provider setup
+ * Provider Configuration & Factory - Public API
  */
 
-export { resolveProviderConfig } from "./ProviderConfig";
-
-export type {
-  ProviderPreferences,
-  ProviderConfigInput,
-  ResolvedProviderConfig,
-} from "./ProviderConfig";
+export { ConfigBuilder } from "./ConfigBuilder";
+export type { ProviderConfig } from "./ConfigBuilder";
 
 export { providerFactory } from "./ProviderFactory";
-
-export type {
-  ProviderFactoryOptions,
-} from "./ProviderFactory";
+export type { ProviderFactoryOptions } from "./ProviderFactory";

package/src/infrastructure/utils/async/debounce.util.ts

@@ -1,100 +0,0 @@
-/**
- * Debounced Async Utilities
- * Creates debounced versions of async functions with proper cancellation
- */
-
-/**
- * Create a debounced async function with state management
- * Fixed to prevent race conditions when cancelled
- *
- * @example
- * ```ts
- * const debouncedFetch = createDebouncedAsync(fetchData, 300);
- * const result = await debouncedFetch.execute(id);
- * ```
- */
-export function createDebouncedAsync<T, Args extends unknown[]>(
-  fn: (...args: Args) => Promise<T>,
-  delay: number,
-): {
-  execute: (...args: Args) => Promise<T | null>;
-  cancel: () => void;
-  flush: () => void;
-} {
-  let timeout: ReturnType<typeof setTimeout> | undefined;
-  let currentResolve: ((result: T | null) => void) | null = null;
-  let isCancelled = false;
-
-  const execute = (...args: Args): Promise<T | null> => {
-    return new Promise((resolve) => {
-      // Cancel any pending operation
-      if (timeout) {
-        clearTimeout(timeout);
-        // Mark previous operation as cancelled
-        isCancelled = true;
-        // Resolve previous promise with null
-        if (currentResolve) {
-          currentResolve(null);
-        }
-      }
-
-      // Store new resolver and reset cancelled flag
-      currentResolve = resolve;
-      isCancelled = false;
-
-      timeout = setTimeout(() => {
-        // Capture current resolve and reset it
-        const resolveFn = currentResolve;
-        currentResolve = null;
-
-        // Check if this operation was cancelled before executing
-        if (isCancelled) {
-          resolveFn?.(null);
-          return;
-        }
-
-        fn(...args)
-          .then((result) => {
-            // Only resolve if not cancelled
-            if (!isCancelled && resolveFn) {
-              resolveFn(result);
-            }
-          })
-          .catch(() => {
-            // Only resolve with null if not cancelled
-            if (!isCancelled && resolveFn) {
-              resolveFn(null);
-            }
-          })
-          .finally(() => {
-            timeout = undefined;
-          });
-      }, delay);
-    });
-  };
-
-  const cancel = (): void => {
-    if (timeout) {
-      clearTimeout(timeout);
-      timeout = undefined;
-    }
-    // Mark as cancelled and resolve pending promise
-    isCancelled = true;
-    if (currentResolve) {
-      currentResolve(null);
-      currentResolve = null;
-    }
-  };
-
-  const flush = (): void => {
-    if (timeout) {
-      clearTimeout(timeout);
-      // Don't resolve - just cancel
-      timeout = undefined;
-    }
-    isCancelled = true;
-    currentResolve = null;
-  };
-
-  return { execute, cancel, flush };
-}

package/src/infrastructure/utils/async/memoize.util.ts

@@ -1,55 +0,0 @@
-/**
- * Memoized Async Utilities
- * Creates memoized versions of async functions with TTL-based caching
- */
-
-/**
- * Create a memoized async function with cache TTL
- *
- * @example
- * ```ts
- * const memoizedFetch = createMemoizedAsync(fetchData, 5000);
- * const result1 = await memoizedFetch.execute(id); // Fetches
- * const result2 = await memoizedFetch.execute(id); // Uses cache
- * memoizedFetch.invalidate(id); // Clears cache for this id
- * ```
- */
-export function createMemoizedAsync<T, Args extends unknown[]>(
-  fn: (...args: Args) => Promise<T>,
-  ttl: number = 5000,
-): {
-  execute: (...args: Args) => Promise<T>;
-  invalidate: (...args: Args) => void;
-  clear: () => void;
-} {
-  const cache = new Map<string, { data: T; timestamp: number }>();
-
-  const generateKey = (args: Args): string => {
-    return JSON.stringify(args);
-  };
-
-  const execute = async (...args: Args): Promise<T> => {
-    const key = generateKey(args);
-    const cached = cache.get(key);
-
-    if (cached && Date.now() - cached.timestamp < ttl) {
-      return cached.data;
-    }
-
-    const result = await fn(...args);
-    cache.set(key, { data: result, timestamp: Date.now() });
-
-    return result;
-  };
-
-  const invalidate = (...args: Args): void => {
-    const key = generateKey(args);
-    cache.delete(key);
-  };
-
-  const clear = (): void => {
-    cache.clear();
-  };
-
-  return { execute, invalidate, clear };
-}