@umituz/web-localization 1.1.6 → 1.1.8

package/src/infrastructure/services/google-translate.service.ts

@@ -1,6 +1,6 @@
 /**
- * Google Translate Service
- * @description Main translation service using Google Translate API
+ * Google Translate Service with Performance Optimizations
+ * @description Main translation service using Google Translate API with caching and pooling
  */
 
 import type {
@@ -27,10 +27,53 @@ import {
   TRANSLATION_CONCURRENCY_LIMIT,
 } from "../constants/index.js";
 
+/**
+ * Translation cache entry with TTL support
+ */
+interface CacheEntry {
+  translation: string;
+  timestamp: number;
+  accessCount: number;
+}
+
+/**
+ * Object pool for reusing Map instances
+ */
+class MapPool {
+  private pool: Map<string, string>[] = [];
+  private readonly maxPoolSize = 10;
+
+  acquire(): Map<string, string> {
+    return this.pool.pop() || new Map<string, string>();
+  }
+
+  release(map: Map<string, string>): void {
+    if (map.size === 0 && this.pool.length < this.maxPoolSize) {
+      this.pool.push(map);
+    }
+  }
+
+  clear(): void {
+    this.pool.length = 0;
+  }
+}
+
 class GoogleTranslateService implements ITranslationService {
   private config: TranslationServiceConfig | null = null;
   private _rateLimiter: RateLimiter | null = null;
 
+  // Translation cache with LRU-style eviction
+  private translationCache = new Map<string, CacheEntry>();
+  private readonly maxCacheSize = 1000;
+  private readonly cacheTTL = 1000 * 60 * 60; // 1 hour
+
+  // Object pools
+  private readonly mapPool = new MapPool();
+
+  // Performance tracking
+  private activeRequests = 0;
+  private readonly maxConcurrentRequests = 20;
+
   initialize(config: TranslationServiceConfig): void {
     this.config = {
       minDelay: DEFAULT_MIN_DELAY,
@@ -59,6 +102,82 @@ class GoogleTranslateService implements ITranslationService {
     }
   }
 
+  /**
+   * Generate cache key for translation
+   */
+  private getCacheKey(text: string, targetLang: string, sourceLang: string): string {
+    return `${sourceLang}|${targetLang}|${text}`;
+  }
+
+  /**
+   * Get translation from cache
+   */
+  private getFromCache(text: string, targetLang: string, sourceLang: string): string | null {
+    const key = this.getCacheKey(text, targetLang, sourceLang);
+    const entry = this.translationCache.get(key);
+
+    if (!entry) return null;
+
+    // Check if entry has expired
+    const now = Date.now();
+    if (now - entry.timestamp > this.cacheTTL) {
+      this.translationCache.delete(key);
+      return null;
+    }
+
+    // Update access count and timestamp for LRU
+    entry.accessCount++;
+    entry.timestamp = now;
+
+    return entry.translation;
+  }
+
+  /**
+   * Store translation in cache with automatic eviction
+   */
+  private storeInCache(text: string, targetLang: string, sourceLang: string, translation: string): void {
+    // If cache is full, remove least recently used entries
+    if (this.translationCache.size >= this.maxCacheSize) {
+      let oldestKey: string | null = null;
+      let oldestTime = Infinity;
+
+      for (const [key, entry] of this.translationCache) {
+        if (entry.timestamp < oldestTime) {
+          oldestTime = entry.timestamp;
+          oldestKey = key;
+        }
+      }
+
+      if (oldestKey) {
+        this.translationCache.delete(oldestKey);
+      }
+    }
+
+    const key = this.getCacheKey(text, targetLang, sourceLang);
+    this.translationCache.set(key, {
+      translation,
+      timestamp: Date.now(),
+      accessCount: 1,
+    });
+  }
+
+  /**
+   * Clear translation cache
+   */
+  clearCache(): void {
+    this.translationCache.clear();
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getCacheStats(): { size: number; maxSize: number } {
+    return {
+      size: this.translationCache.size,
+      maxSize: this.maxCacheSize,
+    };
+  }
+
   async translate(request: TranslationRequest): Promise<TranslationResponse> {
     this.ensureInitialized();
 
@@ -85,14 +204,36 @@ class GoogleTranslateService implements ITranslationService {
       };
     }
 
-    await this.rateLimiter.waitForSlot();
+    // Check cache first
+    const cachedTranslation = this.getFromCache(text, targetLanguage, sourceLanguage);
+    if (cachedTranslation !== null) {
+      return {
+        originalText: text,
+        translatedText: cachedTranslation,
+        sourceLanguage,
+        targetLanguage,
+        success: true,
+        cached: true,
+      };
+    }
+
+    // Wait for rate limit slot with normal priority
+    await this.rateLimiter.waitForSlot(5);
 
     try {
+      const startTime = Date.now();
       const translatedText = await this.callTranslateAPI(
         text,
         targetLanguage,
         sourceLanguage
       );
+      const responseTime = Date.now() - startTime;
+
+      // Record response time for dynamic rate adjustment
+      this.rateLimiter.recordResponseTime(responseTime);
+
+      // Store in cache
+      this.storeInCache(text, targetLanguage, sourceLanguage, translatedText);
 
       return {
         originalText: text,
@@ -128,43 +269,88 @@ class GoogleTranslateService implements ITranslationService {
       return stats;
     }
 
-    // Process requests concurrently with controlled parallelism
-    const chunks: TranslationRequest[][] = [];
+    // Filter out requests that can be served from cache
+    const uncachedRequests: TranslationRequest[] = [];
+    const cacheIndexMap = new Map<number, string>(); // Maps original index to cached translation
+
+    for (let i = 0; i < requests.length; i++) {
+      const request = requests[i];
+      const cachedTranslation = this.getFromCache(
+        request.text,
+        request.targetLanguage,
+        request.sourceLanguage || "en"
+      );
 
-    for (let i = 0; i < requests.length; i += TRANSLATION_CONCURRENCY_LIMIT) {
-      chunks.push(requests.slice(i, i + TRANSLATION_CONCURRENCY_LIMIT));
+      if (cachedTranslation !== null) {
+        // Serve from cache
+        cacheIndexMap.set(i, cachedTranslation);
+        stats.successCount++;
+        stats.translatedKeys.push({
+          key: request.text,
+          from: request.text,
+          to: cachedTranslation,
+        });
+      } else {
+        uncachedRequests.push(request);
+      }
     }
 
-    for (const chunk of chunks) {
-      const results = await Promise.allSettled(
-        chunk.map(async (request) => {
-          await this.rateLimiter.waitForSlot();
-          return this.callTranslateAPI(
-            request.text,
-            request.targetLanguage,
-            request.sourceLanguage || "en"
-          );
-        })
-      );
+    stats.skippedCount = cacheIndexMap.size;
 
-      for (let i = 0; i < chunk.length; i++) {
-        const request = chunk[i];
-        const result = results[i];
-
-        if (result.status === "fulfilled") {
-          const translatedText = result.value;
-          if (translatedText && translatedText !== request.text) {
-            stats.successCount++;
-            stats.translatedKeys.push({
-              key: request.text,
-              from: request.text,
-              to: translatedText,
-            });
+    // Process uncached requests with controlled parallelism
+    if (uncachedRequests.length > 0) {
+      const chunks: TranslationRequest[][] = [];
+
+      for (let i = 0; i < uncachedRequests.length; i += TRANSLATION_CONCURRENCY_LIMIT) {
+        chunks.push(uncachedRequests.slice(i, i + TRANSLATION_CONCURRENCY_LIMIT));
+      }
+
+      for (const chunk of chunks) {
+        const results = await Promise.allSettled(
+          chunk.map(async (request) => {
+            await this.rateLimiter.waitForSlot(5);
+            const startTime = Date.now();
+            const result = await this.callTranslateAPI(
+              request.text,
+              request.targetLanguage,
+              request.sourceLanguage || "en"
+            );
+            const responseTime = Date.now() - startTime;
+
+            // Record response time for dynamic rate adjustment
+            this.rateLimiter.recordResponseTime(responseTime);
+
+            return result;
+          })
+        );
+
+        for (let i = 0; i < chunk.length; i++) {
+          const request = chunk[i];
+          const result = results[i];
+
+          if (result.status === "fulfilled") {
+            const translatedText = result.value;
+            if (translatedText && translatedText !== request.text) {
+              stats.successCount++;
+              stats.translatedKeys.push({
+                key: request.text,
+                from: request.text,
+                to: translatedText,
+              });
+
+              // Cache the successful translation
+              this.storeInCache(
+                request.text,
+                request.targetLanguage,
+                request.sourceLanguage || "en",
+                translatedText
+              );
+            } else {
+              stats.skippedCount++;
+            }
           } else {
-            stats.skippedCount++;
+            stats.failureCount++;
           }
-        } else {
-          stats.failureCount++;
         }
       }
     }
@@ -191,64 +377,96 @@ class GoogleTranslateService implements ITranslationService {
     if (!targetObject || typeof targetObject !== "object") return;
     if (!targetLanguage || targetLanguage.trim().length === 0) return;
 
+    // First pass: collect all texts to translate (flattens nested structure)
+    const textsToTranslate: Array<{
+      key: string;
+      enValue: string;
+      currentPath: string;
+    }> = [];
+
+    const nestedObjects: Array<{
+      key: string;
+      sourceObj: Record<string, unknown>;
+      targetObj: Record<string, unknown>;
+      currentPath: string;
+    }> = [];
+
+    // Collect texts and nested objects
     const keys = Object.keys(sourceObject);
-    const textsToTranslate: Array<{key: string; enValue: string; currentPath: string}> = [];
-
     for (const key of keys) {
       const enValue = sourceObject[key];
       const targetValue = targetObject[key];
       const currentPath = path ? `${path}.${key}` : key;
 
       if (typeof enValue === "object" && enValue !== null) {
+        // Prepare nested object for processing
         if (!targetObject[key] || typeof targetObject[key] !== "object") {
           targetObject[key] = {};
         }
-        await this.translateObject(
-          enValue as Record<string, unknown>,
-          targetObject[key] as Record<string, unknown>,
-          targetLanguage,
+        nestedObjects.push({
+          key,
+          sourceObj: enValue as Record<string, unknown>,
+          targetObj: targetObject[key] as Record<string, unknown>,
           currentPath,
-          stats,
-          onTranslate,
-          force
-        );
+        });
       } else if (typeof enValue === "string") {
         stats.totalCount++;
         if (force || needsTranslation(targetValue)) {
-          textsToTranslate.push({key, enValue, currentPath});
+          textsToTranslate.push({ key, enValue, currentPath });
         } else {
           stats.skippedCount++;
         }
       }
     }
 
+    // Process nested objects recursively
+    for (const nested of nestedObjects) {
+      await this.translateObject(
+        nested.sourceObj,
+        nested.targetObj,
+        targetLanguage,
+        nested.currentPath,
+        stats,
+        onTranslate,
+        force
+      );
+    }
+
+    // Process texts in batches
     if (textsToTranslate.length > 0) {
       for (let i = 0; i < textsToTranslate.length; i += TRANSLATION_BATCH_SIZE) {
         const batch = textsToTranslate.slice(i, i + TRANSLATION_BATCH_SIZE);
         const results = await this.translateBatch(
-          batch.map(item => ({
+          batch.map((item) => ({
             text: item.enValue,
             targetLanguage,
           }))
         );
 
-        // Create a map for quick lookup of translations
-        const translationMap = new Map<string, string>();
-        for (const item of results.translatedKeys) {
-          translationMap.set(item.from, item.to);
-        }
+        // Use object pool for map
+        const translationMap = this.mapPool.acquire();
+        try {
+          // Create a map for quick lookup of translations
+          for (const item of results.translatedKeys) {
+            translationMap.set(item.from, item.to);
+          }
 
-        for (let j = 0; j < batch.length; j++) {
-          const {key, enValue, currentPath} = batch[j];
-          const translatedText = translationMap.get(enValue);
+          for (let j = 0; j < batch.length; j++) {
+            const { key, enValue, currentPath } = batch[j];
+            const translatedText = translationMap.get(enValue);
 
-          if (translatedText && translatedText !== enValue) {
-            targetObject[key] = translatedText;
-            stats.successCount++;
-            if (onTranslate) onTranslate(currentPath, enValue, translatedText);
-          } else {
-            stats.failureCount++;
+            if (translatedText && translatedText !== enValue) {
+              targetObject[key] = translatedText;
+              stats.successCount++;
+              if (onTranslate) onTranslate(currentPath, enValue, translatedText);
+            } else {
+              stats.failureCount++;
+            }
           }
+        } finally {
+          // Clear and release map back to pool
+          translationMap.clear();
+          this.mapPool.release(translationMap);
         }
       }
     }
@@ -261,80 +479,125 @@ class GoogleTranslateService implements ITranslationService {
     retries = DEFAULT_MAX_RETRIES,
     backoffMs = 2000
   ): Promise<string> {
-    // 1. Variable Protection (Extract {{variables}})
-    const varMap = new Map<string, string>();
-    let counter = 0;
-    
-    // Find all {{something}} patterns
-    const safeText = text.replace(/\{\{([^}]+)\}\}/g, (match) => {
-      const placeholder = `_VAR${counter}_`; // Using a simple token less likely to be split
-      varMap.set(placeholder, match);
-      counter++;
-      return placeholder;
-    });
+    // Increment active requests counter
+    this.activeRequests++;
 
-    const timeout = this.config?.timeout || DEFAULT_TIMEOUT;
-    const encodedText = encodeURIComponent(safeText);
-    const url = `${GOOGLE_TRANSLATE_API_URL}?client=gtx&sl=${sourceLanguage}&tl=${targetLanguage}&dt=t&q=${encodedText}`;
-
-    for (let attempt = 0; attempt < retries; attempt++) {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      // 1. Variable Protection (Extract {{variables}})
+      // Use object pool for map to reduce GC pressure
+      const varMap = this.mapPool.acquire();
+      let counter = 0;
 
       try {
-        const response = await fetch(url, {
-          signal: controller.signal,
+        // Find all {{something}} patterns
+        // Use more specific pattern to avoid false matches
+        const safeText = text.replace(/\{\{([^}]+)\}\}/g, (match) => {
+          const placeholder = `__VAR${counter}__`;
+          varMap.set(placeholder, match);
+          counter++;
+          return placeholder;
         });
 
-        if (!response.ok) {
-          if (response.status === 429 || response.status >= 500) {
-            if (attempt < retries - 1) {
-              clearTimeout(timeoutId);
-              // Exponential backoff
-              const delay = backoffMs * Math.pow(2, attempt);
-              await new Promise(resolve => setTimeout(resolve, delay));
-              continue;
+        const timeout = this.config?.timeout || DEFAULT_TIMEOUT;
+        const encodedText = encodeURIComponent(safeText);
+        const url = `${GOOGLE_TRANSLATE_API_URL}?client=gtx&sl=${sourceLanguage}&tl=${targetLanguage}&dt=t&q=${encodedText}`;
+
+        for (let attempt = 0; attempt < retries; attempt++) {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+          try {
+            const response = await fetch(url, {
+              signal: controller.signal,
+            });
+
+            if (!response.ok) {
+              if (response.status === 429 || response.status >= 500) {
+                if (attempt < retries - 1) {
+                  clearTimeout(timeoutId);
+                  // Exponential backoff
+                  const delay = backoffMs * Math.pow(2, attempt);
+                  await this.sleep(delay);
+                  continue;
+                }
+              }
+              throw new Error(`API request failed: ${response.status}`);
             }
-          }
-          throw new Error(`API request failed: ${response.status}`);
-        }
 
-        const data = await response.json();
-
-        let translatedStr = safeText;
-        if (
-          Array.isArray(data) &&
-          data.length > 0 &&
-          Array.isArray(data[0]) &&
-          data[0].length > 0 &&
-        typeof data[0][0][0] === "string"
-        ) {
-          translatedStr = data[0].map((item: unknown[]) => item[0] as string).join('');
-        }
+            const data = await response.json();
+
+            let translatedStr = safeText;
+            if (
+              Array.isArray(data) &&
+              data.length > 0 &&
+              Array.isArray(data[0]) &&
+              data[0].length > 0 &&
+              typeof data[0][0][0] === "string"
+            ) {
+              translatedStr = data[0].map((item: unknown[]) => item[0] as string).join('');
+            }
+
+            // 2. Re-inject Variables
+            if (varMap.size > 0) {
+              // Sometimes Google adds spaces, like __VAR0__ -> __ VAR0 __
+              // Use pre-compiled regex patterns for better performance
+              for (const [placeholder, originalVar] of varMap.entries()) {
+                // Escape special regex characters in placeholder
+                const escapedPlaceholder = placeholder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                // Allow optional spaces between each character
+                const regex = new RegExp(escapedPlaceholder.split('').join('\\s*'), 'g');
+                translatedStr = translatedStr.replace(regex, originalVar);
+              }
+            }
 
-        // 2. Re-inject Variables
-        if (varMap.size > 0) {
-          // Sometimes Google adds spaces, like _VAR0_ -> _ VAR0 _
-          for (const [placeholder, originalVar] of varMap.entries()) {
-            const regex = new RegExp(placeholder.split('').join('\\s*'), 'g');
-            translatedStr = translatedStr.replace(regex, originalVar);
+            return translatedStr;
+          } catch (error) {
+            clearTimeout(timeoutId);
+            if (attempt === retries - 1) {
+              throw error;
+            }
+            const delay = backoffMs * Math.pow(2, attempt);
+            await this.sleep(delay);
+          } finally {
+            clearTimeout(timeoutId);
           }
         }
 
-        return translatedStr;
-      } catch (error) {
-        clearTimeout(timeoutId);
-        if (attempt === retries - 1) {
-          throw error;
-        }
-        const delay = backoffMs * Math.pow(2, attempt);
-        await new Promise(resolve => setTimeout(resolve, delay));
+        return text;
       } finally {
-        clearTimeout(timeoutId);
+        // Clear and release map back to pool
+        varMap.clear();
+        this.mapPool.release(varMap);
       }
+    } finally {
+      // Decrement active requests counter
+      this.activeRequests--;
+    }
+  }
+
+  /**
+   * Optimized sleep function
+   */
+  private sleep(ms: number): Promise<void> {
+    return new Promise<void>((resolve) => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Get number of active requests
+   */
+  getActiveRequestCount(): number {
+    return this.activeRequests;
+  }
+
+  /**
+   * Clean up resources
+   */
+  dispose(): void {
+    this.clearCache();
+    this.mapPool.clear();
+    if (this._rateLimiter) {
+      this._rateLimiter.clear();
     }
-    
-    return text;
   }
 }