ztechno_core 0.0.65 → 0.0.66

package/lib/translate_service.js

@@ -6,6 +6,7 @@ var __importDefault =
   };
 Object.defineProperty(exports, '__esModule', { value: true });
 exports.ZTranslateService = void 0;
+const typings_1 = require('./typings');
 const dist_1 = require('./vendor/dom-parser/dist');
 const translate_1 = __importDefault(require('translate'));
 class ZTranslateService {
@@ -30,194 +31,652 @@ class ZTranslateService {
     this.opt = opt;
     this.localCache = {};
     this.surpressErrors = true;
+    this.maxRetries = 3;
+    this.retryDelay = 1000;
+    this.fallbackText = '?';
     this.codes = {
-      [`&#39`]: `'`,
-      [`&#34`]: `"`,
-      [`&#8220`]: `“`,
-      [`&#8221`]: `”`,
-      [`&#169`]: `©`,
-      [`&#174`]: `®`,
-      [`&#8364`]: `€`,
-      [`&#163`]: `£`,
-      [`&#8482`]: `™`,
+      // Quotes and apostrophes
+      [`'`]: `'`,
+      [`"`]: `"`,
+      [`“`]: `"`,
+      [`”`]: `"`,
+      [`‘`]: `'`,
+      [`’`]: `'`,
+      [`‚`]: `‚`,
+      [`„`]: `„`,
+      [`«`]: `«`,
+      [`»`]: `»`,
+      [`‹`]: `‹`,
+      [`›`]: `›`,
+      // Currency symbols
+      [`©`]: `©`,
+      [`®`]: `®`,
+      [`€`]: `€`,
+      [`£`]: `£`,
+      [`¥`]: `¥`,
+      [`¢`]: `¢`,
+      [`™`]: `™`,
+      [`$`]: `$`,
+      // Mathematical and special symbols
+      [`–`]: `–`,
+      [`—`]: `—`,
+      [`…`]: `…`,
+      [`•`]: `•`,
+      [`→`]: `→`,
+      [`←`]: `←`,
+      [`↑`]: `↑`,
+      [`↓`]: `↓`,
+      [`×`]: `×`,
+      [`÷`]: `÷`,
+      [`±`]: `±`,
+      [`≤`]: `≤`,
+      [`≥`]: `≥`,
+      [`≠`]: `≠`,
+      [`∞`]: `∞`,
+      [`°`]: `°`,
+      [`‰`]: `‰`,
+      [`†`]: `†`,
+      [`‡`]: `‡`,
+      [`§`]: `§`,
+      [`¶`]: `¶`,
+      // Accented characters
+      [`À`]: `À`,
+      [`Á`]: `Á`,
+      [`Â`]: `Â`,
+      [`Ã`]: `Ã`,
+      [`Ä`]: `Ä`,
+      [`Å`]: `Å`,
+      [`Æ`]: `Æ`,
+      [`Ç`]: `Ç`,
+      [`È`]: `È`,
+      [`É`]: `É`,
+      [`Ê`]: `Ê`,
+      [`Ë`]: `Ë`,
+      [`Ì`]: `Ì`,
+      [`Í`]: `Í`,
+      [`Î`]: `Î`,
+      [`Ï`]: `Ï`,
+      [`Ð`]: `Ð`,
+      [`Ñ`]: `Ñ`,
+      [`Ò`]: `Ò`,
+      [`Ó`]: `Ó`,
+      [`Ô`]: `Ô`,
+      [`Õ`]: `Õ`,
+      [`Ö`]: `Ö`,
+      [`Ø`]: `Ø`,
+      [`Ù`]: `Ù`,
+      [`Ú`]: `Ú`,
+      [`Û`]: `Û`,
+      [`Ü`]: `Ü`,
+      [`Ý`]: `Ý`,
+      [`Þ`]: `Þ`,
+      [`ß`]: `ß`,
+      [`à`]: `à`,
+      [`á`]: `á`,
+      [`â`]: `â`,
+      [`ã`]: `ã`,
+      [`ä`]: `ä`,
+      [`å`]: `å`,
+      [`æ`]: `æ`,
+      [`ç`]: `ç`,
+      [`è`]: `è`,
+      [`é`]: `é`,
+      [`ê`]: `ê`,
+      [`ë`]: `ë`,
+      [`ì`]: `ì`,
+      [`í`]: `í`,
+      [`î`]: `î`,
+      [`ï`]: `ï`,
+      [`ð`]: `ð`,
+      [`ñ`]: `ñ`,
+      [`ò`]: `ò`,
+      [`ó`]: `ó`,
+      [`ô`]: `ô`,
+      [`õ`]: `õ`,
+      [`ö`]: `ö`,
+      [`ø`]: `ø`,
+      [`ù`]: `ù`,
+      [`ú`]: `ú`,
+      [`û`]: `û`,
+      [`ü`]: `ü`,
+      [`ý`]: `ý`,
+      [`þ`]: `þ`,
+      [`ÿ`]: `ÿ`,
+      // Common spaces and breaks
+      [` `]: ` `,
+      [`­`]: `­`,
+      [`​`]: ``,
+      // Punctuation
+      [`¡`]: `¡`,
+      [`¿`]: `¿`,
+      [`·`]: `·`,
+      [`¸`]: `¸`,
+      // Fractions
+      [`¼`]: `¼`,
+      [`½`]: `½`,
+      [`¾`]: `¾`,
+      [`⅓`]: `⅓`,
+      [`⅔`]: `⅔`,
+      [`⅕`]: `⅕`,
+      [`⅖`]: `⅖`,
+      [`⅗`]: `⅗`,
+      [`⅘`]: `⅘`,
+      [`⅙`]: `⅙`,
+      [`⅚`]: `⅚`,
+      [`⅛`]: `⅛`,
+      [`⅜`]: `⅜`,
+      [`⅝`]: `⅝`,
+      [`⅞`]: `⅞`,
+      // Greek letters (common ones)
+      [`α`]: `α`,
+      [`β`]: `β`,
+      [`γ`]: `γ`,
+      [`δ`]: `δ`,
+      [`ε`]: `ε`,
+      [`ζ`]: `ζ`,
+      [`η`]: `η`,
+      [`θ`]: `θ`,
+      [`ι`]: `ι`,
+      [`κ`]: `κ`,
+      [`λ`]: `λ`,
+      [`μ`]: `μ`,
+      [`ν`]: `ν`,
+      [`ξ`]: `ξ`,
+      [`ο`]: `ο`,
+      [`π`]: `π`,
+      [`ρ`]: `ρ`,
+      [`σ`]: `σ`,
+      [`τ`]: `τ`,
+      [`υ`]: `υ`,
+      [`φ`]: `φ`,
+      [`χ`]: `χ`,
+      [`ψ`]: `ψ`,
+      [`ω`]: `ω`,
+      // Uppercase Greek letters
+      [`Α`]: `Α`,
+      [`Β`]: `Β`,
+      [`Γ`]: `Γ`,
+      [`Δ`]: `Δ`,
+      [`Ε`]: `Ε`,
+      [`Ζ`]: `Ζ`,
+      [`Η`]: `Η`,
+      [`Θ`]: `Θ`,
+      [`Ι`]: `Ι`,
+      [`Κ`]: `Κ`,
+      [`Λ`]: `Λ`,
+      [`Μ`]: `Μ`,
+      [`Ν`]: `Ν`,
+      [`Ξ`]: `Ξ`,
+      [`Ο`]: `Ο`,
+      [`Π`]: `Π`,
+      [`Ρ`]: `Ρ`,
+      [`Σ`]: `Σ`,
+      [`Τ`]: `Τ`,
+      [`Υ`]: `Υ`,
+      [`Φ`]: `Φ`,
+      [`Χ`]: `Χ`,
+      [`Ψ`]: `Ψ`,
+      [`Ω`]: `Ω`,
+      // Additional common symbols
+      [`₺`]: `₪`,
+      [`₽`]: `₽`,
+      [`₹`]: `₹`,
+      [`¤`]: `¤`,
+      [`¦`]: `¦`,
+      [`¨`]: `¨`,
+      [`ª`]: `ª`,
+      [`¬`]: `¬`,
+      [`¯`]: `¯`,
+      [`²`]: `²`,
+      [`³`]: `³`,
+      [`¹`]: `¹`,
+      [`º`]: `º`,
+      // Card suits and misc symbols
+      [`♠`]: `♠`,
+      [`♣`]: `♣`,
+      [`♥`]: `♥`,
+      [`♦`]: `♦`,
+      [`★`]: `★`,
+      [`☆`]: `☆`,
+      [`☎`]: `☎`,
+      [`☕`]: `☕`,
+      [`☺`]: `☺`,
+      [`☻`]: `☻`,
+      [`☼`]: `☼`,
+      [`♀`]: `♀`,
+      [`♂`]: `♂`,
+      [`❤`]: `❤`,
     };
+    if (!opt.googleApiKey) {
+      throw new typings_1.ValidationError('googleApiKey', opt.googleApiKey);
+    }
+    if (!opt.sqlService) {
+      throw new typings_1.ValidationError('sqlService', opt.sqlService);
+    }
     translate_1.default.key = opt.googleApiKey;
     this.surpressErrors = opt.surpressErrors ?? true;
+    this.maxRetries = opt.maxRetries ?? 3;
+    this.retryDelay = opt.retryDelay ?? 1000;
+    this.fallbackText = opt.fallbackText ?? '?';
     this.getLanguages().map((lang) => (this.localCache[lang.lang] = {}));
     setInterval(() => this.clearLocalCache(), 1000 * 60 * 60); // Every Hour
   }
   getLang(cookies) {
-    const defaultLang = this.getDefaultLang();
-    const langKey = (cookies.lang || defaultLang).toLowerCase();
-    const foundLang = this.getLanguages().find((l) => l.lang === langKey);
-    return foundLang === undefined ? defaultLang : foundLang.lang;
+    try {
+      const defaultLang = this.getDefaultLang();
+      const langKey = (cookies?.lang || defaultLang).toLowerCase();
+      const foundLang = this.getLanguages().find((l) => l.lang === langKey);
+      return foundLang === undefined ? defaultLang : foundLang.lang;
+    } catch (error) {
+      this.logError(new typings_1.ValidationError('cookies', cookies), 'getLang');
+      return this.getDefaultLang();
+    }
+  }
+  async sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  logError(error, context) {
+    if (this.opt.log) {
+      this.opt.log(error, { context, timestamp: new Date().toISOString() });
+    }
+  }
+  async retryOperation(operation, operationName, maxRetries = this.maxRetries) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        this.logError(error, `${operationName} - Attempt ${attempt}/${maxRetries}`);
+        if (attempt < maxRetries) {
+          await this.sleep(this.retryDelay * attempt); // Exponential backoff
+        }
+      }
+    }
+    throw lastError;
   }
   async translateText(langOrReq, text) {
-    const lang = typeof langOrReq === 'string' ? langOrReq : this.getLang(langOrReq.cookies);
-    text = text.trim();
-    if (text.length === 1) {
-      return text;
+    try {
+      // Input validation
+      if (!text || typeof text !== 'string') {
+        throw new typings_1.ValidationError('text', text);
+      }
+      const lang = typeof langOrReq === 'string' ? langOrReq : this.getLang(langOrReq.cookies);
+      text = text.trim();
+      if (text.length === 0) {
+        return text;
+      }
+      if (text.length === 1) {
+        return text;
+      }
+      // Process HTML entities with better error handling
+      text = await this.processHtmlEntities(text);
+      // Check local cache
+      const localCached = this.checkLocalCache(text, lang);
+      if (localCached !== false) {
+        return localCached.value;
+      }
+      // Check remote cache
+      const remoteCached = await this.fetch(text, lang);
+      if (remoteCached !== false) {
+        return remoteCached.value;
+      }
+      // Perform translation with retry logic
+      let result;
+      try {
+        result = await this.retryOperation(async () => {
+          return await (0, translate_1.default)(text, {
+            from: this.getSourceLang(),
+            to: lang,
+          });
+        }, 'translateText');
+      } catch (err) {
+        const translationError = new typings_1.ApiTranslationError(err, text, lang);
+        this.logError(translationError, 'translateText');
+        if (!this.surpressErrors) {
+          throw translationError;
+        }
+        result = this.fallbackText;
+      }
+      // Save translation to cache
+      try {
+        await this.insert(text, lang, { value: result });
+      } catch (err) {
+        this.logError(new typings_1.DatabaseError(err, 'insert translation'), 'translateText');
+        // Don't throw here, translation still succeeded
+      }
+      return result;
+    } catch (error) {
+      if (error instanceof typings_1.TranslateError) {
+        throw error;
+      }
+      const wrappedError = new typings_1.TranslateError(
+        `Unexpected error in translateText: ${error.message}`,
+        'UNEXPECTED_ERROR',
+        { originalError: error },
+      );
+      this.logError(wrappedError, 'translateText');
+      if (!this.surpressErrors) {
+        throw wrappedError;
+      }
+      return this.fallbackText;
     }
+  }
+  async processHtmlEntities(text) {
     let replaceCount = 0;
+    const maxReplacements = 1000;
     while (text.includes('&#')) {
       const codeIndexStart = text.indexOf('&#');
       const first = text.substring(codeIndexStart);
-      const codeLength = first.indexOf(';') + 1;
+      const semicolonIndex = first.indexOf(';');
+      if (semicolonIndex === -1) {
+        // No closing semicolon found, break to avoid infinite loop
+        break;
+      }
+      const codeLength = semicolonIndex + 1;
       const code = first.substring(0, codeLength);
       if (this.codes[code] === undefined) {
-        throw new Error(`Cant recognize character code="${code}"\n for text=${text}\n\n`);
-        // return text
+        const entityError = new typings_1.HtmlEntityError(code, text);
+        this.logError(entityError, 'processHtmlEntities');
+        if (!this.surpressErrors) {
+          throw entityError;
+        }
+        // Skip this entity and continue
+        text = text.substring(0, codeIndexStart) + code + text.substring(codeIndexStart + codeLength);
+        break;
       }
       text = text.substring(0, codeIndexStart) + this.codes[code] + text.substring(codeIndexStart + codeLength);
-      // text = text.replace(code, codes[code])
-      if (replaceCount++ > 1000) {
-        throw new Error(`Replace Count > 1000!!! character code="${code}"\n for text=${text}\n\n`);
-        // return text
+      if (replaceCount++ > maxReplacements) {
+        const loopError = new typings_1.TranslateError(
+          `HTML entity replacement exceeded maximum count (${maxReplacements})`,
+          'MAX_REPLACEMENTS_EXCEEDED',
+          { code, text, replaceCount },
+        );
+        this.logError(loopError, 'processHtmlEntities');
+        if (!this.surpressErrors) {
+          throw loopError;
+        }
+        break;
       }
     }
-    const localCached = this.checkLocalCache(text, lang);
-    if (localCached !== false) {
-      return localCached.value;
-    }
-    const remoteCached = await this.fetch(text, lang);
-    if (remoteCached !== false) {
-      return remoteCached.value;
-    }
-    let result;
-    try {
-      result = await (0, translate_1.default)(text, {
-        from: this.getSourceLang(),
-        to: lang,
-      });
-    } catch (err) {
-      result = '?';
-    }
-    await this.insert(text, lang, { value: result });
-    return result;
+    return text;
   }
   async translateHtml(html, cookies) {
-    const lang = this.getLang(cookies);
-    const srcLang = this.getSourceLang();
-    const dom = (0, dist_1.parseFromString)(html);
-    const htmlNodes = dom.getElementsByTagName('html');
-    const mainNodes = dom.getElementsByTagName('main');
-    const isView = htmlNodes.length === 0;
-    const domNode = isView ? mainNodes[0] : htmlNodes[0];
-    if (lang !== srcLang) {
-      const node = isView ? domNode : domNode.getElementsByTagName('body')[0];
-      const promises = [];
-      this.translateHtmlRec(lang, node, promises);
-      await Promise.all(promises);
-    }
-    const output = domNode ? domNode.outerHTML : html;
-    return output.startsWith(`<!DOCTYPE html>`) ? output : `<!DOCTYPE html>\r\n${output}`;
-  }
-  translateHtmlRec(lang, node, promises, skipTranslate = false) {
-    if (this.opt.verbose) this.opt.verbose(node.nodeName, node);
-    if (node.getAttribute('notranslate') != null) {
-      skipTranslate = true;
-    }
-    if (node.nodeName === '#text') {
-      const nodeText = node;
-      const text = nodeText.text.replace(/[\r|\n|\r\n]+/g, ' ').replace(/\s\s+/g, ' ');
-      const value = text.trim();
-      const meta = {
-        prefix: genSpaces(text.length - text.trimStart().length),
-        suffix: genSpaces(text.length - text.trimEnd().length),
-      };
-      if (skipTranslate === true || text.length === 0 || !strContainsLetters(text)) {
-        node.text = meta.prefix + text + meta.suffix;
-        return;
+    try {
+      if (!html || typeof html !== 'string') {
+        throw new typings_1.ValidationError('html', html);
       }
-      promises.push(
-        this.translateText(lang, value)
-          .then((translatedText) => {
-            node.text = meta.prefix + translatedText + meta.suffix;
-          })
-          .catch((err) => {
-            node.text = text;
-            if (this.opt.log) this.opt.log(err, node);
+      if (!cookies) {
+        throw new typings_1.ValidationError('cookies', cookies);
+      }
+      const lang = this.getLang(cookies);
+      const srcLang = this.getSourceLang();
+      let dom;
+      try {
+        dom = (0, dist_1.parseFromString)(html);
+      } catch (error) {
+        const parseError = new typings_1.TranslateError('Failed to parse HTML', 'HTML_PARSE_ERROR', { error, html });
+        this.logError(parseError, 'translateHtml');
+        if (!this.surpressErrors) {
+          throw parseError;
+        }
+        return html;
+      }
+      const htmlNodes = dom.getElementsByTagName('html');
+      const mainNodes = dom.getElementsByTagName('main');
+      const isView = htmlNodes.length === 0;
+      const domNode = isView ? mainNodes[0] : htmlNodes[0];
+      if (lang !== srcLang && domNode) {
+        const node = isView ? domNode : domNode.getElementsByTagName('body')[0];
+        if (node) {
+          const promises = [];
+          this.translateHtmlRec(lang, node, promises);
+          try {
+            await Promise.all(promises);
+          } catch (error) {
+            this.logError(
+              new typings_1.TranslateError('Failed to translate HTML nodes', 'HTML_TRANSLATION_ERROR', { error }),
+              'translateHtml',
+            );
             if (!this.surpressErrors) {
-              throw err; // TODO: Find out if surpressing is better
+              throw error;
             }
-          }),
+          }
+        }
+      }
+      const output = domNode ? domNode.outerHTML : html;
+      return output.startsWith(`<!DOCTYPE html>`) ? output : `<!DOCTYPE html>\r\n${output}`;
+    } catch (error) {
+      if (error instanceof typings_1.TranslateError) {
+        throw error;
+      }
+      const wrappedError = new typings_1.TranslateError(
+        `Unexpected error in translateHtml: ${error.message}`,
+        'UNEXPECTED_ERROR',
+        { originalError: error },
       );
-      return;
+      this.logError(wrappedError, 'translateHtml');
+      if (!this.surpressErrors) {
+        throw wrappedError;
+      }
+      return html;
     }
-    // const hasChildren = node.childNodes !== undefined
-    for (const child of node.childNodes || []) {
-      this.translateHtmlRec(lang, child, promises, skipTranslate);
+  }
+  translateHtmlRec(lang, node, promises, skipTranslate = false) {
+    try {
+      if (this.opt.verbose) this.opt.verbose(node.nodeName, node);
+      if (node.getAttribute && node.getAttribute('notranslate') != null) {
+        skipTranslate = true;
+      }
+      // Skip HTML comments
+      if (node.nodeName === '#comment') {
+        return;
+      }
+      if (node.nodeName === '#text') {
+        const nodeText = node;
+        const text = nodeText.text.replace(/[\r|\n|\r\n]+/g, ' ').replace(/\s\s+/g, ' ');
+        const value = text.trim();
+        const meta = {
+          prefix: genSpaces(text.length - text.trimStart().length),
+          suffix: genSpaces(text.length - text.trimEnd().length),
+        };
+        if (skipTranslate === true || text.length === 0 || !strContainsLetters(text)) {
+          node.text = meta.prefix + text + meta.suffix;
+          return;
+        }
+        promises.push(
+          this.translateText(lang, value)
+            .then((translatedText) => {
+              node.text = meta.prefix + translatedText + meta.suffix;
+            })
+            .catch((err) => {
+              node.text = text;
+              this.logError(err, 'translateHtmlRec');
+              if (!this.surpressErrors) {
+                throw err;
+              }
+            }),
+        );
+        return;
+      }
+      // Process child nodes safely
+      if (node.childNodes && Array.isArray(node.childNodes)) {
+        for (const child of node.childNodes) {
+          this.translateHtmlRec(lang, child, promises, skipTranslate);
+        }
+      }
+    } catch (error) {
+      this.logError(
+        new typings_1.TranslateError(`Error processing HTML node: ${error.message}`, 'HTML_NODE_ERROR', {
+          error,
+          nodeName: node?.nodeName,
+        }),
+        'translateHtmlRec',
+      );
+      if (!this.surpressErrors) {
+        throw error;
+      }
     }
   }
   async update(key, lang, data) {
-    const res = await this.sql.query(
-      `
-      INSERT INTO translations
-        (\`key\`, \`lang\`, \`value\`)
-      VALUES
-        (:key, :lang, :value)
-      ON DUPLICATE KEY UPDATE value=:value
-    `,
-      { key, lang, value: data.value },
-    );
-    if (res.affectedRows) {
-      this.insertLocalCache(key, lang, data);
+    try {
+      if (!key || !lang || !data) {
+        throw new typings_1.ValidationError('update parameters', { key, lang, data });
+      }
+      const res = await this.retryOperation(async () => {
+        return await this.sql.query(
+          `
+          INSERT INTO translations
+            (\`key\`, \`lang\`, \`value\`)
+          VALUES
+            (:key, :lang, :value)
+          ON DUPLICATE KEY UPDATE value=:value
+        `,
+          { key, lang, value: data.value },
+        );
+      }, 'update translation');
+      if (res.affectedRows) {
+        this.insertLocalCache(key, lang, data);
+      }
+      return res;
+    } catch (error) {
+      const dbError = new typings_1.DatabaseError(error, 'update translation');
+      this.logError(dbError, 'update');
+      throw dbError;
     }
-    return res;
   }
   checkLocalCache(key, lang) {
-    const hasLocal = !this.localCache[lang].hasOwnProperty(key);
-    return hasLocal ? false : this.localCache[lang][key];
+    try {
+      if (!key || !lang || !this.localCache[lang]) {
+        return false;
+      }
+      const hasLocal = !this.localCache[lang].hasOwnProperty(key);
+      return hasLocal ? false : this.localCache[lang][key];
+    } catch (error) {
+      this.logError(
+        new typings_1.TranslateError('Local cache check failed', 'CACHE_ERROR', { error, key, lang }),
+        'checkLocalCache',
+      );
+      return false;
+    }
   }
   insertLocalCache(key, lang, data) {
-    this.localCache[lang][key] = data;
+    try {
+      if (!key || !lang || !data) {
+        return;
+      }
+      if (!this.localCache[lang]) {
+        this.localCache[lang] = {};
+      }
+      this.localCache[lang][key] = data;
+    } catch (error) {
+      this.logError(
+        new typings_1.TranslateError('Local cache insertion failed', 'CACHE_ERROR', { error, key, lang }),
+        'insertLocalCache',
+      );
+    }
   }
   clearLocalCache() {
-    Object.keys(this.localCache).map((k) => {
-      this.localCache[k] = {};
-    });
+    try {
+      Object.keys(this.localCache).map((k) => {
+        this.localCache[k] = {};
+      });
+    } catch (error) {
+      this.logError(
+        new typings_1.TranslateError('Failed to clear local cache', 'CACHE_ERROR', { error }),
+        'clearLocalCache',
+      );
+    }
   }
   async fetch(key, lang) {
-    const results = await this.sql.query(
-      `SELECT \`value\` FROM translations WHERE \`lang\`=? AND \`key\`=CONVERT(? USING utf8mb3)`,
-      [lang, key],
-    );
-    if (results.length > 0) {
-      // api.query(`UPDATE translations SET last_used=CURRENT_TIMESTAMP WHERE \`lang\`=? AND \`key\`=?`, [lang, key])
-      //   .catch(err => console.error(err))
-      const { value } = results[0];
-      this.insertLocalCache(key, lang, { value });
-      return { value };
+    try {
+      if (!key || !lang) {
+        return false;
+      }
+      const results = await this.retryOperation(async () => {
+        return await this.sql.query(
+          `SELECT \`value\` FROM translations WHERE \`lang\`=? AND \`key\`=CONVERT(? USING utf8mb3)`,
+          [lang, key],
+        );
+      }, 'fetch translation');
+      if (results.length > 0) {
+        const { value } = results[0];
+        const data = { value };
+        this.insertLocalCache(key, lang, data);
+        return data;
+      }
+      return false;
+    } catch (error) {
+      const dbError = new typings_1.DatabaseError(error, 'fetch translation');
+      this.logError(dbError, 'fetch');
+      return false; // Don't throw, let translation proceed
     }
-    return false;
   }
   async insert(key, lang, data) {
-    await this.sql.query(`INSERT IGNORE INTO translations (\`key\`, \`lang\`, \`value\`) VALUES (?, ?, ?)`, [
-      key,
-      lang,
-      data.value,
-    ]);
-  }
-  fetchLang(lang) {
-    return this.sql.query(
-      `SELECT \`key\`, \`lang\`, \`value\`, \`verified\`, \`created_at\` FROM translations WHERE \`lang\`=?`,
-      [lang],
-    );
+    try {
+      if (!key || !lang || !data) {
+        throw new typings_1.ValidationError('insert parameters', { key, lang, data });
+      }
+      await this.retryOperation(async () => {
+        return await this.sql.query(`INSERT IGNORE INTO translations (\`key\`, \`lang\`, \`value\`) VALUES (?, ?, ?)`, [
+          key,
+          lang,
+          data.value,
+        ]);
+      }, 'insert translation');
+    } catch (error) {
+      const dbError = new typings_1.DatabaseError(error, 'insert translation');
+      this.logError(dbError, 'insert');
+      throw dbError;
+    }
+  }
+  async fetchLang(lang) {
+    try {
+      if (!lang) {
+        throw new typings_1.ValidationError('lang', lang);
+      }
+      return await this.retryOperation(async () => {
+        return await this.sql.query(
+          `SELECT \`key\`, \`lang\`, \`value\`, \`verified\`, \`created_at\` FROM translations WHERE \`lang\`=?`,
+          [lang],
+        );
+      }, 'fetchLang');
+    } catch (error) {
+      const dbError = new typings_1.DatabaseError(error, 'fetch language translations');
+      this.logError(dbError, 'fetchLang');
+      throw dbError;
+    }
   }
   async fetchAllGrouped() {
-    const output = {};
-    const allTranslations = await this.fetchAll();
-    allTranslations.map((translation) => {
-      const { key } = translation;
-      if (!output.hasOwnProperty(key)) {
-        output[key] = [];
-      }
-      output[key].push(translation);
-    });
-    return output;
-  }
-  fetchAll() {
-    return this.sql.query(`SELECT \`key\`, \`lang\`, \`value\`, \`verified\`, \`created_at\` FROM translations`);
+    try {
+      const output = {};
+      const allTranslations = await this.fetchAll();
+      allTranslations.forEach((translation) => {
+        const { key } = translation;
+        if (!output.hasOwnProperty(key)) {
+          output[key] = [];
+        }
+        output[key].push(translation);
+      });
+      return output;
+    } catch (error) {
+      const dbError = new typings_1.DatabaseError(error, 'fetch all grouped translations');
+      this.logError(dbError, 'fetchAllGrouped');
+      throw dbError;
+    }
+  }
+  async fetchAll() {
+    try {
+      return await this.retryOperation(async () => {
+        return await this.sql.query(
+          `SELECT \`key\`, \`lang\`, \`value\`, \`verified\`, \`created_at\` FROM translations`,
+        );
+      }, 'fetchAll');
+    } catch (error) {
+      const dbError = new typings_1.DatabaseError(error, 'fetch all translations');
+      this.logError(dbError, 'fetchAll');
+      throw dbError;
+    }
   }
 }
 exports.ZTranslateService = ZTranslateService;