@umituz/web-ai-groq-provider 1.1.13 → 2.0.0

package/src/domains/groq/utils/request-deduplicator.util.ts

@@ -1,123 +0,0 @@
-/**
- * Request Deduplicator Utility
- * @description Prevents duplicate API calls for the same request
- */
-
-interface PendingRequest<T> {
-  promise: Promise<T>;
-  timestamp: number;
-}
-
-interface DeduplicatorOptions {
-  /** Time-to-live for pending requests in milliseconds */
-  ttl?: number;
-  /** Custom key generator for requests */
-  keyGenerator?: (request: unknown) => string;
-}
-
-class RequestDeduplicator {
-  private pendingRequests = new Map<string, PendingRequest<unknown>>();
-  private readonly defaultTTL: number;
-
-  constructor(options: DeduplicatorOptions = {}) {
-    this.defaultTTL = options.ttl || 30000; // 30 seconds default
-  }
-
-  /**
-   * Execute a request with deduplication
-   * If a similar request is pending, return its promise instead of creating a new one
-   */
-  async execute<T>(
-    key: string,
-    requestFn: () => Promise<T>
-  ): Promise<T> {
-    // Clean up expired requests
-    this.cleanup();
-
-    // Check if there's a pending request with the same key
-    const existing = this.pendingRequests.get(key);
-    if (existing) {
-      return existing.promise as Promise<T>;
-    }
-
-    // Create new request
-    const promise = requestFn();
-
-    // Store pending request
-    this.pendingRequests.set(key, {
-      promise,
-      timestamp: Date.now(),
-    });
-
-    // Clean up after completion (success or failure)
-    promise.finally(() => {
-      this.pendingRequests.delete(key);
-    });
-
-    return promise;
-  }
-
-  /**
-   * Generate a default key from request parameters
-   */
-  generateKey(params: Record<string, unknown>): string {
-    return JSON.stringify(params, Object.keys(params).sort());
-  }
-
-  /**
-   * Check if a request is currently pending
-   */
-  isPending(key: string): boolean {
-    this.cleanup();
-    return this.pendingRequests.has(key);
-  }
-
-  /**
-   * Cancel a pending request by key
-   */
-  cancel(key: string): boolean {
-    const request = this.pendingRequests.get(key);
-    if (request) {
-      this.pendingRequests.delete(key);
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Cancel all pending requests
-   */
-  cancelAll(): void {
-    this.pendingRequests.clear();
-  }
-
-  /**
-   * Get count of pending requests
-   */
-  getPendingCount(): number {
-    this.cleanup();
-    return this.pendingRequests.size;
-  }
-
-  /**
-   * Clean up expired pending requests
-   */
-  private cleanup(): void {
-    const now = Date.now();
-    for (const [key, request] of this.pendingRequests.entries()) {
-      if (now - request.timestamp > this.defaultTTL) {
-        this.pendingRequests.delete(key);
-      }
-    }
-  }
-
-  /**
-   * Clear all pending requests and reset state
-   */
-  reset(): void {
-    this.pendingRequests.clear();
-  }
-}
-
-export const requestDeduplicator = new RequestDeduplicator();
-export { RequestDeduplicator };

package/src/domains/groq/utils/request-queue.util.ts

@@ -1,178 +0,0 @@
-/**
- * Request Queue Manager Utility
- * @description Manages concurrent requests with priority and limits
- */
-
-interface QueuedRequest<T> {
-  id: string;
-  priority: number;
-  requestFn: () => Promise<T>;
-  resolve: (value: T) => void;
-  reject: (reason?: unknown) => void;
-  timestamp: number;
-}
-
-interface QueueOptions {
-  /** Maximum concurrent requests */
-  maxConcurrent?: number;
-  /** Default priority for requests (higher = more important) */
-  defaultPriority?: number;
-  /** Request timeout in milliseconds */
-  requestTimeout?: number;
-}
-
-class RequestQueue {
-  private queue: QueuedRequest<unknown>[] = [];
-  private activeRequests = new Set<string>();
-  private readonly maxConcurrent: number;
-  private readonly defaultPriority: number;
-  private readonly requestTimeout: number;
-  private requestIdCounter = 0;
-
-  constructor(options: QueueOptions = {}) {
-    this.maxConcurrent = options.maxConcurrent || 3;
-    this.defaultPriority = options.defaultPriority || 0;
-    this.requestTimeout = options.requestTimeout || 30000; // 30 seconds
-  }
-
-  /**
-   * Add a request to the queue
-   */
-  async add<T>(
-    requestFn: () => Promise<T>,
-    priority?: number
-  ): Promise<T> {
-    return new Promise((resolve, reject) => {
-      const id = `req-${++this.requestIdCounter}`;
-
-      const queuedRequest: QueuedRequest<T> = {
-        id,
-        priority: priority ?? this.defaultPriority,
-        requestFn,
-        resolve: resolve as (value: unknown) => void,
-        reject,
-        timestamp: Date.now(),
-      };
-
-      this.queue.push(queuedRequest as QueuedRequest<unknown>);
-      this.sortQueue();
-      this.process();
-    });
-  }
-
-  /**
-   * Sort queue by priority (higher priority first) and timestamp
-   */
-  private sortQueue(): void {
-    this.queue.sort((a, b) => {
-      if (a.priority !== b.priority) {
-        return b.priority - a.priority; // Higher priority first
-      }
-      return a.timestamp - b.timestamp; // Earlier requests first
-    });
-  }
-
-  /**
-   * Process queued requests
-   */
-  private process(): void {
-    // Process as many requests as we can concurrently
-    while (
-      this.queue.length > 0 &&
-      this.activeRequests.size < this.maxConcurrent
-    ) {
-      const request = this.queue.shift();
-      if (!request) break;
-
-      this.executeRequest(request);
-    }
-  }
-
-  /**
-   * Execute a single request
-   */
-  private async executeRequest<T>(request: QueuedRequest<T>): Promise<void> {
-    this.activeRequests.add(request.id);
-
-    // Add timeout
-    const timeoutId = setTimeout(() => {
-      this.activeRequests.delete(request.id);
-      request.reject(new Error(`Request ${request.id} timed out`));
-      this.process();
-    }, this.requestTimeout);
-
-    try {
-      const result = await request.requestFn();
-      clearTimeout(timeoutId);
-      request.resolve(result);
-    } catch (error) {
-      clearTimeout(timeoutId);
-      request.reject(error);
-    } finally {
-      this.activeRequests.delete(request.id);
-      // Process next request
-      this.process();
-    }
-  }
-
-  /**
-   * Cancel a specific request by ID
-   */
-  cancel(requestId: string): boolean {
-    // Check if it's in the queue
-    const queueIndex = this.queue.findIndex(r => r.id === requestId);
-    if (queueIndex !== -1) {
-      const request = this.queue[queueIndex];
-      this.queue.splice(queueIndex, 1);
-      request.reject(new Error(`Request ${requestId} was cancelled`));
-      return true;
-    }
-
-    // Check if it's active (we can't cancel active requests, but we can track)
-    return this.activeRequests.has(requestId);
-  }
-
-  /**
-   * Cancel all queued requests
-   */
-  cancelAll(): void {
-    // Reject all queued requests
-    for (const request of this.queue) {
-      request.reject(new Error('Request was cancelled'));
-    }
-    this.queue = [];
-  }
-
-  /**
-   * Get queue statistics
-   */
-  getStats(): {
-    queued: number;
-    active: number;
-    maxConcurrent: number;
-  } {
-    return {
-      queued: this.queue.length,
-      active: this.activeRequests.size,
-      maxConcurrent: this.maxConcurrent,
-    };
-  }
-
-  /**
-   * Check if queue is at capacity
-   */
-  isAtCapacity(): boolean {
-    return this.activeRequests.size >= this.maxConcurrent;
-  }
-
-  /**
-   * Clear queue and reset state
-   */
-  reset(): void {
-    this.cancelAll();
-    this.activeRequests.clear();
-  }
-}
-
-export const requestQueue = new RequestQueue();
-export { RequestQueue };

package/src/domains/groq/utils/retry.util.ts

@@ -1,207 +0,0 @@
-/**
- * Retry Logic Utility
- * @description Exponential backoff retry mechanism for failed requests
- */
-
-import { GroqError } from "./groq-error.util";
-import { isRetryableError } from "../constants/error.constants";
-
-interface RetryOptions {
-  /** Maximum number of retry attempts */
-  maxAttempts?: number;
-  /** Initial delay in milliseconds */
-  initialDelay?: number;
-  /** Maximum delay between retries */
-  maxDelay?: number;
-  /** Backoff multiplier */
-  backoffMultiplier?: number;
-  /** Jitter factor to prevent thundering herd (0-1) */
-  jitterFactor?: number;
-  /** Custom retry condition */
-  shouldRetry?: (error: Error) => boolean;
-}
-
-interface RetryResult<T> {
-  success: boolean;
-  data?: T;
-  error?: Error;
-  attempts: number;
-  totalDelay: number;
-}
-
-class RetryManager {
-  private readonly defaultMaxAttempts: number;
-  private readonly defaultInitialDelay: number;
-  private readonly defaultMaxDelay: number;
-  private readonly defaultBackoffMultiplier: number;
-  private readonly defaultJitterFactor: number;
-
-  constructor() {
-    this.defaultMaxAttempts = 3;
-    this.defaultInitialDelay = 1000; // 1 second
-    this.defaultMaxDelay = 10000; // 10 seconds
-    this.defaultBackoffMultiplier = 2;
-    this.defaultJitterFactor = 0.1; // 10% jitter
-  }
-
-  /**
-   * Execute a function with retry logic
-   */
-  async execute<T>(
-    fn: () => Promise<T>,
-    options: RetryOptions = {}
-  ): Promise<T> {
-    const maxAttempts = options.maxAttempts ?? this.defaultMaxAttempts;
-    let lastError: Error | null = null;
-    let _totalDelay = 0;
-
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        const result = await fn();
-        return result;
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-
-        // Check if we should retry
-        if (attempt >= maxAttempts || !this.shouldRetry(lastError, options)) {
-          throw lastError;
-        }
-
-        // Calculate delay for next attempt
-        const delay = this.calculateDelay(attempt, options);
-        _totalDelay += delay;
-
-        // Wait before retrying
-        await this.delay(delay);
-      }
-    }
-
-    throw lastError;
-  }
-
-  /**
-   * Execute with detailed retry result
-   */
-  async executeWithDetails<T>(
-    fn: () => Promise<T>,
-    options: RetryOptions = {}
-  ): Promise<RetryResult<T>> {
-    const maxAttempts = options.maxAttempts ?? this.defaultMaxAttempts;
-    let lastError: Error | null = null;
-    let totalDelay = 0;
-
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        const data = await fn();
-        return {
-          success: true,
-          data,
-          attempts: attempt,
-          totalDelay,
-        };
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-
-        if (attempt >= maxAttempts || !this.shouldRetry(lastError, options)) {
-          return {
-            success: false,
-            error: lastError,
-            attempts: attempt,
-            totalDelay,
-          };
-        }
-
-        const delay = this.calculateDelay(attempt, options);
-        totalDelay += delay;
-        await this.delay(delay);
-      }
-    }
-
-    return {
-      success: false,
-      error: lastError || new Error("Unknown error"),
-      attempts: maxAttempts,
-      totalDelay,
-    };
-  }
-
-  /**
-   * Calculate delay with exponential backoff and jitter
-   */
-  private calculateDelay(attempt: number, options: RetryOptions): number {
-    const initialDelay = options.initialDelay ?? this.defaultInitialDelay;
-    const maxDelay = options.maxDelay ?? this.defaultMaxDelay;
-    const backoffMultiplier = options.backoffMultiplier ?? this.defaultBackoffMultiplier;
-    const jitterFactor = options.jitterFactor ?? this.defaultJitterFactor;
-
-    // Exponential backoff
-    let delay = initialDelay * Math.pow(backoffMultiplier, attempt - 1);
-
-    // Cap at max delay
-    delay = Math.min(delay, maxDelay);
-
-    // Add jitter to prevent thundering herd
-    const jitter = delay * jitterFactor * (Math.random() * 2 - 1);
-    delay = delay + jitter;
-
-    // Ensure delay is not negative
-    return Math.max(0, delay);
-  }
-
-  /**
-   * Check if error should trigger a retry
-   */
-  private shouldRetry(error: Error, options: RetryOptions): boolean {
-    // Use custom retry condition if provided
-    if (options.shouldRetry) {
-      return options.shouldRetry(error);
-    }
-
-    // Check if it's a GroqError
-    if (error instanceof GroqError) {
-      return isRetryableError(error.type);
-    }
-
-    // Default: retry on network errors
-    const errorMessage = error.message.toLowerCase();
-    return (
-      errorMessage.includes("network") ||
-      errorMessage.includes("timeout") ||
-      errorMessage.includes("econnrefused") ||
-      errorMessage.includes("enotfound") ||
-      errorMessage.includes("etimedout")
-    );
-  }
-
-  /**
-   * Delay helper
-   */
-  private delay(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  /**
-   * Create a retryable function wrapper
-   */
-  wrap<T extends (...args: unknown[]) => Promise<unknown>>(
-    fn: T,
-    options?: RetryOptions
-  ): T {
-    return (async (...args: unknown[]) => {
-      return this.execute(() => fn(...args), options);
-    }) as T;
-  }
-}
-
-export const retryManager = new RetryManager();
-export { RetryManager };
-
-/**
- * Convenience function to execute with retry
- */
-export async function withRetry<T>(
-  fn: () => Promise<T>,
-  options?: RetryOptions
-): Promise<T> {
-  return retryManager.execute(fn, options);
-}

package/src/index.ts

@@ -1,15 +0,0 @@
-/**
- * @umituz/web-ai-groq-provider
- * Groq AI text generation and chat provider for React web applications
- *
- * @author umituz
- * @license MIT
- *
- * For better tree-shaking, use subpath imports:
- * - @umituz/web-ai-groq-provider/groq - Groq API client
- * - @umituz/web-ai-groq-provider/chat - Chat functionality
- */
-
-// Re-export all domains
-export * from "./domains/groq/index";
-export * from "./domains/chat/index";