transduck 0.5.3 → 0.6.0

package/src/shared-store.ts

@@ -0,0 +1,157 @@
+import { createHash } from 'crypto';
+import type { LookupParams, InsertParams, InsertPluralParams } from './storage.js';
+
+const TABLE_NAME = 'transduck_translations';
+
+const CREATE_TABLE = `
+CREATE TABLE IF NOT EXISTS ${TABLE_NAME} (
+    source_lang TEXT NOT NULL,
+    target_lang TEXT NOT NULL,
+    content_hash TEXT NOT NULL,
+    plural_category TEXT NOT NULL DEFAULT '',
+    source_text TEXT NOT NULL,
+    translated_text TEXT NOT NULL,
+    model TEXT NOT NULL,
+    status TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    project_context_hash TEXT NOT NULL,
+    string_context_hash TEXT NOT NULL,
+    string_context TEXT NOT NULL DEFAULT '',
+    PRIMARY KEY (source_lang, target_lang, content_hash, plural_category)
+)`;
+
+function contentHash(sourceText: string, projectContextHash: string, stringContextHash: string): string {
+  return createHash('sha256')
+    .update(sourceText + '\x00' + projectContextHash + '\x00' + stringContextHash)
+    .digest('hex');
+}
+
+export class SharedStore {
+  private pool: any;
+  private url: string;
+
+  constructor(url: string) {
+    this.url = url;
+  }
+
+  async initialize(): Promise<void> {
+    if (!this.pool) {
+      let pg: any;
+      try {
+        pg = await import('pg');
+      } catch {
+        throw new Error(
+          'pg is required for shared Postgres storage. Install it with: npm install pg'
+        );
+      }
+      const Pool = pg.default?.Pool ?? pg.Pool;
+      this.pool = new Pool({ connectionString: this.url });
+    }
+    await this.getPool().query(CREATE_TABLE);
+  }
+
+  private getPool(): any {
+    if (!this.pool) throw new Error('SharedStore not initialized. Call initialize() first.');
+    return this.pool;
+  }
+
+  async lookup(params: LookupParams): Promise<string | null> {
+    const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+    const result = await this.getPool().query(
+      `SELECT translated_text FROM ${TABLE_NAME}
+       WHERE source_lang = $1 AND target_lang = $2 AND content_hash = $3
+       AND plural_category = '' AND status = 'translated'`,
+      [params.sourceLang, params.targetLang, chash],
+    );
+    if (result.rows.length > 0) {
+      return result.rows[0].translated_text;
+    }
+    const altResult = await this.getPool().query(
+      `SELECT 1 FROM ${TABLE_NAME}
+       WHERE source_text = $1 AND source_lang = $2 AND target_lang = $3
+       AND status = 'translated' LIMIT 1`,
+      [params.sourceText, params.sourceLang, params.targetLang],
+    );
+    if (altResult.rows.length > 0) {
+      console.debug(
+        `Translation exists in shared store for '${params.sourceText}' (${params.sourceLang}→${params.targetLang}) but with a different project context hash. Check project.context in transduck.yaml.`,
+      );
+    }
+    return null;
+  }
+
+  async insert(params: InsertParams): Promise<void> {
+    const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+    await this.getPool().query(
+      `INSERT INTO ${TABLE_NAME}
+       (source_lang, target_lang, content_hash, plural_category, source_text,
+        translated_text, model, status, created_at, project_context_hash,
+        string_context_hash, string_context)
+       VALUES ($1, $2, $3, '', $4, $5, $6, $7, $8, $9, $10, $11)
+       ON CONFLICT DO NOTHING`,
+      [
+        params.sourceLang, params.targetLang, chash,
+        params.sourceText, params.translatedText, params.model, params.status,
+        new Date().toISOString(),
+        params.projectContextHash, params.stringContextHash, params.stringContext ?? '',
+      ],
+    );
+  }
+
+  async lookupPlural(params: LookupParams): Promise<Record<string, string>> {
+    const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+    const result = await this.getPool().query(
+      `SELECT plural_category, translated_text FROM ${TABLE_NAME}
+       WHERE source_lang = $1 AND target_lang = $2 AND content_hash = $3
+       AND plural_category != '' AND status = 'translated'`,
+      [params.sourceLang, params.targetLang, chash],
+    );
+    const forms: Record<string, string> = {};
+    for (const row of result.rows) {
+      forms[row.plural_category] = row.translated_text;
+    }
+    return forms;
+  }
+
+  async insertPlural(params: InsertPluralParams): Promise<void> {
+    const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+    await this.getPool().query(
+      `INSERT INTO ${TABLE_NAME}
+       (source_lang, target_lang, content_hash, plural_category, source_text,
+        translated_text, model, status, created_at, project_context_hash,
+        string_context_hash, string_context)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+       ON CONFLICT DO NOTHING`,
+      [
+        params.sourceLang, params.targetLang, chash, params.pluralCategory,
+        params.sourceText, params.translatedText, params.model, params.status,
+        new Date().toISOString(),
+        params.projectContextHash, params.stringContextHash, params.stringContext ?? '',
+      ],
+    );
+  }
+
+  async stats(): Promise<{ totalTranslations: number; totalFailed: number; byLanguage: Record<string, number> }> {
+    const pool = this.getPool();
+    const result = await pool.query(
+      `SELECT target_lang, status, COUNT(*) as count FROM ${TABLE_NAME} GROUP BY target_lang, status`,
+    );
+    let totalTranslations = 0;
+    let totalFailed = 0;
+    const byLanguage: Record<string, number> = {};
+    for (const row of result.rows) {
+      const count = parseInt(row.count, 10);
+      if (row.status === 'translated') {
+        totalTranslations += count;
+        byLanguage[row.target_lang] = (byLanguage[row.target_lang] ?? 0) + count;
+      } else if (row.status === 'failed') {
+        totalFailed += count;
+      }
+    }
+    return { totalTranslations, totalFailed, byLanguage };
+  }
+
+  async close(): Promise<void> {
+    if (this.pool) await this.pool.end();
+  }
+}

package/tests/ait.test.ts

@@ -9,7 +9,7 @@ function hash(text: string): string {
   return createHash('sha256').update(text).digest('hex');
 }
 
-function makeConfig(tmpDir: string): TransduckConfig {
+function makeConfig(tmpDir: string, overrides?: Partial<TransduckConfig>): TransduckConfig {
   return {
     projectName: 'test',
     projectContext: 'A test site',
@@ -22,7 +22,9 @@ function makeConfig(tmpDir: string): TransduckConfig {
     backendModel: 'gpt-4.1-mini',
     backendTimeout: 10,
     backendMaxRetries: 2,
+    sharedUrl: null,
     readOnly: false,
+    ...overrides,
   };
 }
 
@@ -42,7 +44,10 @@ describe('ait', () => {
     await initialize(makeConfig(tmpDir));
     setLanguage('EN');
     const result = await ait('Hello');
-    expect(result).toBe('Hello');
+    expect(result.toString()).toBe('Hello');
+    expect(result.pending).toBe(false);
+    expect(result.sourceLang).toBe('EN');
+    expect(result.lang).toBe('EN');
   });
 
   it('returns cached translation', async () => {
@@ -60,7 +65,9 @@ describe('ait', () => {
     });
 
     const result = await ait('Hello');
-    expect(result).toBe('Hallo');
+    expect(result.toString()).toBe('Hallo');
+    expect(result.pending).toBe(false);
+    expect(result.lang).toBe('DE');
   });
 
   it('throws if not initialized', async () => {
@@ -81,7 +88,7 @@ describe('ait', () => {
     await initialize(makeConfig(tmpDir));
     setLanguage('EN');
     const result = await ait('Welcome {name}', undefined, { name: 'Tim' });
-    expect(result).toBe('Welcome Tim');
+    expect(result.toString()).toBe('Welcome Tim');
   });
 
   it('interpolates vars in cached translation', async () => {
@@ -98,7 +105,7 @@ describe('ait', () => {
     });
 
     const result = await ait('Welcome {name}', undefined, { name: 'Tim' });
-    expect(result).toBe('Willkommen Tim');
+    expect(result.toString()).toBe('Willkommen Tim');
   });
 
   it('returns text with placeholders when no vars provided', async () => {
@@ -106,7 +113,72 @@ describe('ait', () => {
     await initialize(makeConfig(tmpDir));
     setLanguage('EN');
     const result = await ait('Welcome {name}');
-    expect(result).toBe('Welcome {name}');
+    expect(result.toString()).toBe('Welcome {name}');
+  });
+
+  // --- sourceLang override ---
+
+  it('uses custom sourceLang when provided', async () => {
+    const { ait, setLanguage, initialize, _getStore } = await import('../src/index.js');
+    const cfg = makeConfig(tmpDir);
+    await initialize(cfg);
+    setLanguage('DE');
+
+    const store = _getStore();
+    await store!.insert({
+      sourceText: 'Hola', sourceLang: 'ES', targetLang: 'DE',
+      projectContextHash: hash('A test site'), stringContextHash: hash(''),
+      translatedText: 'Hallo', model: 'gpt-4.1-mini', status: 'translated', stringContext: '',
+    });
+
+    const result = await ait('Hola', { sourceLang: 'ES' });
+    expect(result.toString()).toBe('Hallo');
+    expect(result.sourceLang).toBe('ES');
+  });
+
+  // --- background mode ---
+
+  it('background mode returns immediately with pending=true', async () => {
+    const { ait, setLanguage, initialize } = await import('../src/index.js');
+    await initialize(makeConfig(tmpDir));
+    setLanguage('DE');
+
+    const result = await ait('Hello', { background: true });
+    expect(result.pending).toBe(true);
+    expect(result.toString()).toBe('Hello'); // returns source text
+    expect(result.sourceLang).toBe('EN');
+    expect(result.lang).toBe('DE');
+  });
+
+  // --- two-tier lookup ---
+
+  it('falls back to shared store on local miss', async () => {
+    const { ait, setLanguage, initialize, _setSharedStore, _getStore } = await import('../src/index.js');
+    await initialize(makeConfig(tmpDir));
+    setLanguage('DE');
+
+    // Create a mock shared store
+    const mockShared = {
+      lookup: vi.fn().mockResolvedValue('Hallo von shared'),
+      lookupPlural: vi.fn().mockResolvedValue({}),
+      insert: vi.fn().mockResolvedValue(undefined),
+      insertPlural: vi.fn().mockResolvedValue(undefined),
+      initialize: vi.fn().mockResolvedValue(undefined),
+      close: vi.fn().mockResolvedValue(undefined),
+      stats: vi.fn().mockResolvedValue({ totalTranslations: 0, totalFailed: 0, byLanguage: {} }),
+    };
+    _setSharedStore(mockShared as any);
+
+    const result = await ait('Hello');
+    expect(result.toString()).toBe('Hallo von shared');
+    expect(result.pending).toBe(false);
+    // Should have propagated to local store
+    const local = _getStore();
+    const localResult = await local!.lookup({
+      sourceText: 'Hello', sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('A test site'), stringContextHash: hash(''),
+    });
+    expect(localResult).toBe('Hallo von shared');
   });
 });
 
@@ -130,7 +202,8 @@ describe('aitPlural', () => {
     await initialize(makeConfig(tmpDir));
     setLanguage('EN');
     const result = await aitPlural('{count} message', '{count} messages', 1);
-    expect(result).toBe('1 message');
+    expect(result.toString()).toBe('1 message');
+    expect(result.pending).toBe(false);
   });
 
   it('same-language 2-form: selects other for count=5', async () => {
@@ -138,7 +211,7 @@ describe('aitPlural', () => {
     await initialize(makeConfig(tmpDir));
     setLanguage('EN');
     const result = await aitPlural('{count} message', '{count} messages', 5);
-    expect(result).toBe('5 messages');
+    expect(result.toString()).toBe('5 messages');
   });
 
   it('same-language 2-form: selects other for count=0', async () => {
@@ -146,7 +219,7 @@ describe('aitPlural', () => {
     await initialize(makeConfig(tmpDir));
     setLanguage('EN');
     const result = await aitPlural('{count} message', '{count} messages', 0);
-    expect(result).toBe('0 messages');
+    expect(result.toString()).toBe('0 messages');
   });
 
   it('same-language: includes custom vars', async () => {
@@ -159,7 +232,7 @@ describe('aitPlural', () => {
       3,
       { vars: { name: 'Tim' } },
     );
-    expect(result).toBe("3 items in Tim's cart");
+    expect(result.toString()).toBe("3 items in Tim's cart");
   });
 
   it('returns cached plural form', async () => {
@@ -189,10 +262,10 @@ describe('aitPlural', () => {
     });
 
     const result1 = await aitPlural('{count} message', '{count} messages', 1);
-    expect(result1).toBe('1 Nachricht');
+    expect(result1.toString()).toBe('1 Nachricht');
 
     const result5 = await aitPlural('{count} message', '{count} messages', 5);
-    expect(result5).toBe('5 Nachrichten');
+    expect(result5.toString()).toBe('5 Nachrichten');
   });
 
   it('auto-includes count in vars', async () => {
@@ -201,7 +274,7 @@ describe('aitPlural', () => {
     setLanguage('EN');
     // count is auto-added even without explicit vars
     const result = await aitPlural('{count} message', '{count} messages', 42);
-    expect(result).toBe('42 messages');
+    expect(result.toString()).toBe('42 messages');
   });
 
   it('does not override explicit count in vars', async () => {
@@ -211,6 +284,71 @@ describe('aitPlural', () => {
     // If user provides count in vars, that value should be used
     const result = await aitPlural('{count} message', '{count} messages', 1, { vars: { count: 99 } });
     // count=1 selects "one" form, but the {count} var is 99 from explicit vars
-    expect(result).toBe('99 message');
+    expect(result.toString()).toBe('99 message');
+  });
+
+  // --- sourceLang override for plural ---
+
+  it('uses custom sourceLang for plural', async () => {
+    const { aitPlural, setLanguage, initialize, _getStore } = await import('../src/index.js');
+    const cfg = makeConfig(tmpDir);
+    await initialize(cfg);
+    setLanguage('DE');
+
+    const store = _getStore();
+    const sourceKey = '{count} mensaje\x00{count} mensajes';
+    await store!.insertPlural({
+      sourceText: sourceKey, sourceLang: 'ES', targetLang: 'DE',
+      projectContextHash: hash('A test site'), stringContextHash: hash(''),
+      pluralCategory: 'other',
+      translatedText: '{count} Nachrichten',
+      model: 'gpt-4.1-mini', status: 'translated', stringContext: '',
+    });
+
+    const result = await aitPlural('{count} mensaje', '{count} mensajes', 5, { sourceLang: 'ES' });
+    expect(result.toString()).toBe('5 Nachrichten');
+    expect(result.sourceLang).toBe('ES');
+  });
+
+  // --- background mode for plural ---
+
+  it('background mode returns immediately with pending=true for plural', async () => {
+    const { aitPlural, setLanguage, initialize } = await import('../src/index.js');
+    await initialize(makeConfig(tmpDir));
+    setLanguage('DE');
+
+    const result = await aitPlural('{count} message', '{count} messages', 5, { background: true });
+    expect(result.pending).toBe(true);
+    expect(result.toString()).toBe('5 messages'); // source fallback
+  });
+});
+
+describe('detectLanguage', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    const mod = await import('../src/index.js');
+    mod._resetState();
+    tmpDir = mkdtempSync(join(tmpdir(), 'transduck-detect-test-'));
+    process.env.OPENAI_API_KEY = 'test-key';
+  });
+
+  it('throws if not initialized', async () => {
+    const { detectLanguage } = await import('../src/index.js');
+    await expect(detectLanguage('Hola')).rejects.toThrow('transduck not initialized');
+  });
+
+  it('delegates to backend detectLanguage with stored config', async () => {
+    const backendMod = await import('../src/backend.js');
+    const spy = vi.spyOn(backendMod, 'detectLanguage').mockResolvedValue('ES');
+
+    const { detectLanguage, initialize } = await import('../src/index.js');
+    await initialize(makeConfig(tmpDir));
+
+    const result = await detectLanguage('Hola, como estas?');
+    expect(result).toBe('ES');
+    expect(spy).toHaveBeenCalledWith('Hola, como estas?', expect.objectContaining({ projectName: 'test' }));
+
+    spy.mockRestore();
   });
 });

package/tests/backend.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
-import { buildMessages, buildPluralMessages, translate, translatePlural } from '../src/backend.js';
+import { buildMessages, buildPluralMessages, translate, translatePlural, detectLanguage } from '../src/backend.js';
 import type { TransduckConfig } from '../src/config.js';
 
 function makeConfig(): TransduckConfig {
@@ -15,6 +15,7 @@ function makeConfig(): TransduckConfig {
     backendModel: 'gpt-4.1-mini',
     backendTimeout: 10,
     backendMaxRetries: 2,
+    sharedUrl: null,
     readOnly: false,
   };
 }
@@ -184,3 +185,35 @@ describe('translatePlural', () => {
     expect(result.other).toBe('{count} \u0441\u043e\u043e\u0431\u0449\u0435\u043d\u0438\u0439');
   });
 });
+
+describe('detectLanguage', () => {
+  it('calls OpenAI and returns language code', async () => {
+    const mockCreate = vi.fn().mockResolvedValue({
+      choices: [{ message: { content: 'ES' } }],
+    });
+
+    const cfg = makeConfig();
+    process.env.OPENAI_API_KEY = 'test-key';
+
+    const result = await detectLanguage(
+      'Hola, como estas?', cfg,
+      { chat: { completions: { create: mockCreate } } } as any,
+    );
+    expect(result).toBe('ES');
+  });
+
+  it('normalizes response to uppercase and trims whitespace', async () => {
+    const mockCreate = vi.fn().mockResolvedValue({
+      choices: [{ message: { content: '  fr  \n' } }],
+    });
+
+    const cfg = makeConfig();
+    process.env.OPENAI_API_KEY = 'test-key';
+
+    const result = await detectLanguage(
+      'Bonjour le monde', cfg,
+      { chat: { completions: { create: mockCreate } } } as any,
+    );
+    expect(result).toBe('FR');
+  });
+});

package/tests/cli.test.ts

@@ -220,4 +220,37 @@ describe('CLI functions', () => {
     });
     expect(output).toContain('Skipped: 1');
   });
+
+  it('init includes shared_url in config when provided', async () => {
+    await runInit({
+      dir: tmpDir,
+      name: 'test-project',
+      context: 'A test site',
+      sourceLang: 'EN',
+      targetLangs: ['DE'],
+      sharedUrl: 'postgres://localhost/transduck',
+    });
+    const configContent = readFileSync(join(tmpDir, 'transduck.yaml'), 'utf-8');
+    expect(configContent).toContain('shared_url');
+    expect(configContent).toContain('postgres://localhost/transduck');
+  });
+
+  it('init omits shared_url when not provided', async () => {
+    await runInit({
+      dir: tmpDir,
+      name: 'test-project',
+      context: 'A test site',
+      sourceLang: 'EN',
+      targetLangs: ['DE'],
+    });
+    const configContent = readFileSync(join(tmpDir, 'transduck.yaml'), 'utf-8');
+    expect(configContent).not.toContain('shared_url');
+  });
+
+  it('stats shows local store header', async () => {
+    const configPath = writeConfig(tmpDir);
+    const output = await runStats({ configPath });
+    expect(output).toContain('Local store:');
+    expect(output).toContain('Total translations: 0');
+  });
 });

package/tests/config.test.ts

@@ -72,6 +72,46 @@ describe('loadConfig', () => {
     delete process.env.TRANSDUCK_CONFIG;
   });
 
+  it('defaults shared_url to null', () => {
+    const configPath = join(tmpDir, 'transduck.yaml');
+    writeFileSync(configPath, VALID_YAML);
+    const cfg = loadConfig(configPath);
+    expect(cfg.sharedUrl).toBeNull();
+  });
+
+  it('reads shared_url from yaml', () => {
+    const configPath = join(tmpDir, 'transduck.yaml');
+    const yaml = VALID_YAML.replace(
+      '  path: ./translations.db',
+      '  path: ./translations.db\n  shared_url: postgres://localhost/transduck'
+    );
+    writeFileSync(configPath, yaml);
+    const cfg = loadConfig(configPath);
+    expect(cfg.sharedUrl).toBe('postgres://localhost/transduck');
+  });
+
+  it('env var TRANSDUCK_SHARED_URL overrides yaml shared_url', () => {
+    const configPath = join(tmpDir, 'transduck.yaml');
+    const yaml = VALID_YAML.replace(
+      '  path: ./translations.db',
+      '  path: ./translations.db\n  shared_url: postgres://localhost/from-yaml'
+    );
+    writeFileSync(configPath, yaml);
+    process.env.TRANSDUCK_SHARED_URL = 'postgres://localhost/from-env';
+    const cfg = loadConfig(configPath);
+    expect(cfg.sharedUrl).toBe('postgres://localhost/from-env');
+    delete process.env.TRANSDUCK_SHARED_URL;
+  });
+
+  it('reads shared_url from env var when not in yaml', () => {
+    const configPath = join(tmpDir, 'transduck.yaml');
+    writeFileSync(configPath, VALID_YAML);
+    process.env.TRANSDUCK_SHARED_URL = 'postgres://localhost/env-only';
+    const cfg = loadConfig(configPath);
+    expect(cfg.sharedUrl).toBe('postgres://localhost/env-only');
+    delete process.env.TRANSDUCK_SHARED_URL;
+  });
+
   it('throws if config not found', () => {
     delete process.env.TRANSDUCK_CONFIG;
     expect(() => loadConfig(join(tmpDir, 'nonexistent.yaml'))).toThrow();

package/tests/result.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest';
+import { TranslationResult } from '../src/result.js';
+
+describe('TranslationResult', () => {
+  it('stores the translated text', () => {
+    const r = new TranslationResult('Hallo', { pending: false, sourceLang: 'EN', lang: 'DE' });
+    expect(r.toString()).toBe('Hallo');
+    expect(r.valueOf()).toBe('Hallo');
+  });
+
+  it('exposes metadata properties', () => {
+    const r = new TranslationResult('Hallo', { pending: false, sourceLang: 'EN', lang: 'DE' });
+    expect(r.pending).toBe(false);
+    expect(r.sourceLang).toBe('EN');
+    expect(r.lang).toBe('DE');
+  });
+
+  it('works in template literals', () => {
+    const r = new TranslationResult('Hallo', { pending: false, sourceLang: 'EN', lang: 'DE' });
+    expect(`Say ${r}`).toBe('Say Hallo');
+  });
+
+  it('works with string concatenation', () => {
+    const r = new TranslationResult('Hallo', { pending: false, sourceLang: 'EN', lang: 'DE' });
+    expect(r + ' Welt').toBe('Hallo Welt');
+    expect('Sag ' + r).toBe('Sag Hallo');
+  });
+
+  it('supports loose equality with plain strings', () => {
+    const r = new TranslationResult('Hallo', { pending: false, sourceLang: 'EN', lang: 'DE' });
+    expect(r == 'Hallo').toBe(true);
+    expect(r == 'Other').toBe(false);
+  });
+
+  it('has correct length and indexing', () => {
+    const r = new TranslationResult('Hallo', { pending: false, sourceLang: 'EN', lang: 'DE' });
+    expect(r.length).toBe(5);
+    expect(r[0]).toBe('H');
+  });
+
+  it('supports string methods', () => {
+    const r = new TranslationResult('Hallo Welt', { pending: false, sourceLang: 'EN', lang: 'DE' });
+    expect(r.includes('Welt')).toBe(true);
+    expect(r.toUpperCase()).toBe('HALLO WELT');
+    expect(r.slice(0, 5)).toBe('Hallo');
+  });
+
+  it('tracks pending state', () => {
+    const pending = new TranslationResult('Hello', { pending: true, sourceLang: 'EN', lang: 'DE' });
+    expect(pending.pending).toBe(true);
+    expect(pending.toString()).toBe('Hello');
+
+    const done = new TranslationResult('Hallo', { pending: false, sourceLang: 'EN', lang: 'DE' });
+    expect(done.pending).toBe(false);
+  });
+
+  it('is an instance of String and TranslationResult', () => {
+    const r = new TranslationResult('Hallo', { pending: false, sourceLang: 'EN', lang: 'DE' });
+    expect(r instanceof String).toBe(true);
+    expect(r instanceof TranslationResult).toBe(true);
+  });
+});