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

package/src/infrastructure/utils/env.util.ts

@@ -1,175 +0,0 @@
-/**
- * Environment Configuration Utilities
- * Safe loading and validation of environment variables
- */
-
-/**
- * Get environment variable with type safety
- */
-function getEnvVar(key: string): string | undefined {
-  // Check for React Native environment
-  if (typeof process !== "undefined" && process.env) {
-    return process.env[key];
-  }
-
-  // For React Native, apps typically use a config file
-  // This returns undefined if not available - app should provide config directly
-  return undefined;
-}
-
-/**
- * Get required environment variable
- * @throws Error if variable is not set
- */
-export function getRequiredEnv(key: string): string {
-  const value = getEnvVar(key);
-
-  if (!value || value.trim().length === 0) {
-    throw new Error(`Required environment variable "${key}" is not set`);
-  }
-
-  return value.trim();
-}
-
-/**
- * Get optional environment variable with fallback
- */
-export function getOptionalEnv(
-  key: string,
-  fallback: string,
-): string {
-  const value = getEnvVar(key);
-  return value?.trim() || fallback;
-}
-
-/**
- * Get environment variable as number
- */
-export function getEnvNumber(key: string, fallback: number): number {
-  const value = getEnvVar(key);
-
-  if (!value) {
-    return fallback;
-  }
-
-  const parsed = parseInt(value, 10);
-
-  if (isNaN(parsed)) {
-    return fallback;
-  }
-
-  return parsed;
-}
-
-/**
- * Get environment variable as boolean
- */
-export function getEnvBoolean(key: string, fallback: boolean): boolean {
-  const value = getEnvVar(key);
-
-  if (!value) {
-    return fallback;
-  }
-
-  return value.toLowerCase() === "true" || value === "1";
-}
-
-/**
- * Environment configuration interface
- */
-export interface EnvConfig {
-  /** Gemini API key */
-  GEMINI_API_KEY?: string;
-  /** Default timeout in milliseconds */
-  GEMINI_TIMEOUT?: number;
-  /** Enable debug logging */
-  GEMINI_DEBUG?: boolean;
-  /** Max retry attempts */
-  GEMINI_MAX_RETRIES?: number;
-}
-
-/**
- * Load all Gemini-related environment variables
- */
-export function loadGeminiEnv(): EnvConfig {
-  return {
-    GEMINI_API_KEY: getEnvVar("GEMINI_API_KEY"),
-    GEMINI_TIMEOUT: getEnvNumber("GEMINI_TIMEOUT", 30000),
-    GEMINI_DEBUG: getEnvBoolean("GEMINI_DEBUG", false),
-    GEMINI_MAX_RETRIES: getEnvNumber("GEMINI_MAX_RETRIES", 3),
-  };
-}
-
-/**
- * Get API key from environment with validation
- * @throws Error if API key is not set or invalid
- */
-export function getApiKeyFromEnv(): string {
-  const apiKey = getRequiredEnv("GEMINI_API_KEY");
-
-  if (apiKey.length < 10) {
-    throw new Error("GEMINI_API_KEY appears to be invalid (too short)");
-  }
-
-  return apiKey;
-}
-
-/**
- * Check if running in development mode
- */
-export function isDevelopment(): boolean {
-  return getEnvBoolean("NODE_ENV", false) === false ||
-    getEnvVar("NODE_ENV") === "development";
-}
-
-/**
- * Check if debug mode is enabled
- */
-export function isDebugEnabled(): boolean {
-  return getEnvBoolean("GEMINI_DEBUG", false) ||
-    getEnvBoolean("DEBUG", false);
-}
-
-/**
- * Validate that required environment variables are set
- * @returns Array of missing variable names
- */
-export function validateEnv(requiredVars: string[]): string[] {
-  const missing: string[] = [];
-
-  for (const varName of requiredVars) {
-    if (!getEnvVar(varName)) {
-      missing.push(varName);
-    }
-  }
-
-  return missing;
-}
-
-/**
- * Get configuration from environment or use provided fallback
- * @throws Error if API key is not configured in either env or fallback
- */
-export function getGeminiConfigFromEnv(fallback?: {
-  apiKey?: string;
-  timeout?: number;
-}): {
-  apiKey: string;
-  timeout?: number;
-} {
-  const env = loadGeminiEnv();
-
-  const apiKey = env.GEMINI_API_KEY || fallback?.apiKey;
-
-  if (!apiKey || apiKey.trim().length === 0) {
-    throw new Error(
-      "GEMINI_API_KEY must be set either in environment variables or provided as fallback. " +
-      "Set the GEMINI_API_KEY environment variable or pass apiKey in the fallback config."
-    );
-  }
-
-  return {
-    apiKey,
-    timeout: env.GEMINI_TIMEOUT || fallback?.timeout,
-  };
-}

package/src/infrastructure/utils/performance.util.ts

@@ -1,139 +0,0 @@
-
-export interface PerformanceMetrics {
-  duration: number;
-  timestamp: number;
-  metadata?: Record<string, unknown>;
-}
-
-export class PerformanceTimer {
-  private startTime: number;
-  private endTime?: number;
-  private metadata?: Record<string, unknown>;
-
-  constructor(metadata?: Record<string, unknown>) {
-    // Use performance.now() for higher precision when available
-    this.startTime = typeof performance !== "undefined" && performance.now
-      ? performance.now()
-      : Date.now();
-    this.metadata = metadata;
-  }
-
-  stop(): number {
-    this.endTime = typeof performance !== "undefined" && performance.now
-      ? performance.now()
-      : Date.now();
-    return this.duration;
-  }
-
-  get duration(): number {
-    const end = this.endTime ?? (typeof performance !== "undefined" && performance.now
-      ? performance.now()
-      : Date.now());
-    return end - this.startTime;
-  }
-
-  getMetrics(): PerformanceMetrics {
-    return { duration: this.duration, timestamp: this.startTime, metadata: this.metadata };
-  }
-
-  get isRunning(): boolean {
-    return this.endTime === undefined;
-  }
-}
-
-export async function measureAsync<T>(
-  operation: () => Promise<T>,
-  metadata?: Record<string, unknown>,
-): Promise<{ result: T; duration: number }> {
-  const timer = new PerformanceTimer(metadata);
-  try {
-    const result = await operation();
-    timer.stop();
-    return { result, duration: timer.duration };
-  } catch (error) {
-    timer.stop();
-    throw error;
-  }
-}
-
-export function measureSync<T>(
-  operation: () => T,
-  metadata?: Record<string, unknown>,
-): { result: T; duration: number } {
-  const timer = new PerformanceTimer(metadata);
-  try {
-    const result = operation();
-    timer.stop();
-    return { result, duration: timer.duration };
-  } catch (error) {
-    timer.stop();
-    throw error;
-  }
-}
-
-interface DebouncedFunction<T extends (...args: never[]) => unknown> {
-  (...args: Parameters<T>): void;
-  cancel: () => void;
-}
-
-export function debounce<T extends (...args: never[]) => unknown>(
-  func: T,
-  wait: number,
-): DebouncedFunction<T> {
-  let timeout: ReturnType<typeof setTimeout> | undefined;
-
-  const debounced = (...args: Parameters<T>) => {
-    const later = () => {
-      timeout = undefined;
-      func(...args);
-    };
-    if (timeout) {
-      clearTimeout(timeout);
-    }
-    timeout = setTimeout(later, wait);
-  };
-
-  debounced.cancel = () => {
-    if (timeout) {
-      clearTimeout(timeout);
-      timeout = undefined;
-    }
-  };
-
-  return debounced;
-}
-
-interface ThrottledFunction<T extends (...args: never[]) => unknown> {
-  (...args: Parameters<T>): void;
-  cancel: () => void;
-}
-
-export function throttle<T extends (...args: never[]) => unknown>(
-  func: T,
-  limit: number,
-): ThrottledFunction<T> {
-  let inThrottle = false;
-  let timeout: ReturnType<typeof setTimeout> | undefined;
-
-  const throttled = (...args: Parameters<T>) => {
-    if (!inThrottle) {
-      func(...args);
-      inThrottle = true;
-      timeout = setTimeout(() => {
-        inThrottle = false;
-        timeout = undefined;
-      }, limit);
-    }
-  };
-
-  throttled.cancel = () => {
-    if (timeout) {
-      clearTimeout(timeout);
-      timeout = undefined;
-      inThrottle = false;
-    }
-  };
-
-  return throttled;
-}
-

package/src/infrastructure/utils/rate-limiter.util.ts

@@ -1,86 +0,0 @@
-
-export interface RateLimiterOptions {
-  minInterval?: number; // Minimum milliseconds between requests
-  maxQueueSize?: number; // Maximum number of pending requests
-}
-
-export class RateLimiter {
-  private queue: Array<() => Promise<void>> = [];
-  private processing = false;
-  private lastRequest = 0;
-  private minInterval: number;
-  private maxQueueSize: number;
-
-  constructor(options: RateLimiterOptions = {}) {
-    this.minInterval = options.minInterval ?? 100; // 100ms minimum interval
-    this.maxQueueSize = options.maxQueueSize ?? 100;
-  }
-
-  async execute<T>(fn: () => Promise<T>): Promise<T> {
-    if (this.queue.length >= this.maxQueueSize) {
-      // Calculate estimated wait time to help users understand delay
-      const estimatedWait = this.queue.length * this.minInterval;
-      const waitSeconds = (estimatedWait / 1000).toFixed(1);
-      throw new Error(
-        `Rate limiter queue is full (${this.maxQueueSize} requests pending). ` +
-        `Estimated wait: ~${waitSeconds}s. Please wait before retrying.`
-      );
-    }
-
-    return new Promise((resolve, reject) => {
-      this.queue.push(async () => {
-        try {
-          const result = await fn();
-          resolve(result);
-        } catch (error) {
-          reject(error);
-        }
-      });
-
-      // Start queue processing if not already running
-      this.processQueue().catch(() => {
-        // Individual task errors are handled above, ignore queue processing errors
-      });
-    });
-  }
-
-  private async processQueue(): Promise<void> {
-    // Only one processQueue can run at a time
-    if (this.processing) {
-      return;
-    }
-
-    this.processing = true;
-
-    try {
-      while (this.queue.length > 0) {
-        const elapsed = Date.now() - this.lastRequest;
-        if (elapsed < this.minInterval) {
-          await new Promise((r) => setTimeout(r, this.minInterval - elapsed));
-        }
-
-        const task = this.queue.shift();
-        if (task) {
-          this.lastRequest = Date.now();
-          await task();
-        }
-      }
-    } finally {
-      this.processing = false;
-    }
-  }
-
-  getQueueSize(): number {
-    return this.queue.length;
-  }
-
-  clear(): void {
-    this.queue = [];
-    this.processing = false;
-  }
-
-  reset(): void {
-    this.clear();
-    this.lastRequest = 0;
-  }
-}

package/src/infrastructure/utils/retry.util.ts

@@ -1,158 +0,0 @@
-/**
- * Retry Utilities
- * Implements retry logic with exponential backoff for resilient API calls
- */
-
-import { measureAsync } from "./performance.util";
-
-export interface RetryOptions {
-  /** Maximum number of retry attempts */
-  maxAttempts?: number;
-  /** Initial delay in milliseconds */
-  initialDelay?: number;
-  /** Maximum delay in milliseconds */
-  maxDelay?: number;
-  /** Exponential backoff multiplier */
-  backoffMultiplier?: number;
-  /** Jitter factor to add randomness (0-1) */
-  jitterFactor?: number;
-  /** Whether to retry on specific error types */
-  shouldRetry?: (error: unknown) => boolean;
-}
-
-export interface RetryResult<T> {
-  result: T;
-  attempts: number;
-  totalDuration: number;
-}
-
-const DEFAULT_RETRY_OPTIONS: Required<RetryOptions> = {
-  maxAttempts: 3,
-  initialDelay: 1000,
-  maxDelay: 10000,
-  backoffMultiplier: 2,
-  jitterFactor: 0.1,
-  shouldRetry: () => true,
-};
-
-/**
- * Calculate delay with exponential backoff and jitter
- */
-function calculateDelay(
-  attempt: number,
-  options: Required<RetryOptions>
-): number {
-  const exponentialDelay = options.initialDelay * Math.pow(options.backoffMultiplier, attempt);
-
-  // Apply jitter to prevent thundering herd
-  const jitter = exponentialDelay * options.jitterFactor * (Math.random() * 2 - 1);
-
-  return Math.min(
-    Math.max(exponentialDelay + jitter, options.initialDelay),
-    options.maxDelay
-  );
-}
-
-/**
- * Sleep for a specified duration
- */
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-/**
- * Execute operation with retry logic and exponential backoff
- */
-export async function retryWithBackoff<T>(
-  operation: () => Promise<T>,
-  options: RetryOptions = {}
-): Promise<RetryResult<T>> {
-  const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };
-
-  let lastError: unknown;
-
-  for (let attempt = 0; attempt < opts.maxAttempts; attempt++) {
-    try {
-      const { result, duration } = await measureAsync(operation);
-
-      return {
-        result,
-        attempts: attempt + 1,
-        totalDuration: duration,
-      };
-    } catch (error) {
-      lastError = error;
-
-      // Check if we should retry this error
-      if (!opts.shouldRetry(error)) {
-        throw error;
-      }
-
-      // Don't delay after the last attempt
-      if (attempt < opts.maxAttempts - 1) {
-        const delay = calculateDelay(attempt, opts);
-        await sleep(delay);
-      }
-    }
-  }
-
-  throw lastError;
-}
-
-/**
- * Create a retry predicate based on error type/message
- */
-export function createRetryPredicate(
-  retryablePatterns: string[]
-): (error: unknown) => boolean {
-  return (error: unknown) => {
-    const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
-    return retryablePatterns.some((pattern) => message.includes(pattern.toLowerCase()));
-  };
-}
-
-/**
- * Default retry predicate for common retryable errors
- */
-export const shouldRetryNetworkError = createRetryPredicate([
-  "network",
-  "timeout",
-  "rate limit",
-  "too many requests",
-  "500",
-  "502",
-  "503",
-  "504",
-  "econnreset",
-  "etimedout",
-]);
-
-/**
- * Retry only on specific conditions
- */
-export async function retryIf<T>(
-  operation: () => Promise<T>,
-  shouldRetryFn: (error: unknown) => boolean,
-  options?: Omit<RetryOptions, "shouldRetry">
-): Promise<RetryResult<T>> {
-  return retryWithBackoff(operation, {
-    ...options,
-    shouldRetry: shouldRetryFn,
-  });
-}
-
-/**
- * Execute with fixed delay between attempts (no exponential backoff)
- */
-export async function retryWithFixedDelay<T>(
-  operation: () => Promise<T>,
-  delay: number = 1000,
-  maxAttempts: number = 3
-): Promise<RetryResult<T>> {
-  return retryWithBackoff(operation, {
-    maxAttempts,
-    initialDelay: delay,
-    backoffMultiplier: 1,
-    jitterFactor: 0,
-  });
-}

package/src/providers/ProviderConfig.ts

@@ -1,36 +0,0 @@
-
-import { DEFAULT_MODELS } from "../domain/entities";
-
-export interface ProviderPreferences {
-  /** Request timeout (ms) */
-  timeout?: number;
-}
-
-export interface ProviderConfigInput {
-  /** API key for authentication */
-  apiKey: string;
-  /** Optional user preferences */
-  preferences?: ProviderPreferences;
-}
-
-export interface ResolvedProviderConfig {
-  apiKey: string;
-  textModel: string;
-  timeout: number;
-}
-
-const DEFAULTS = {
-  timeout: 30000,
-};
-
-export function resolveProviderConfig(
-  input: ProviderConfigInput,
-): ResolvedProviderConfig {
-  const preferences = input.preferences || {};
-
-  return {
-    apiKey: input.apiKey,
-    textModel: DEFAULT_MODELS.TEXT,
-    timeout: preferences.timeout ?? DEFAULTS.timeout,
-  };
-}