transduck 0.2.5 → 0.4.0

package/tests/cli.test.ts

@@ -27,7 +27,7 @@ languages:
   targets:
     - DE
 storage:
-  path: ./translations.duckdb
+  path: ./translations.lmdb
 backend:
   api_key_env: OPENAI_API_KEY
   model: gpt-4.1-mini
@@ -55,7 +55,7 @@ describe('CLI functions', () => {
     });
     const { existsSync } = await import('fs');
     expect(existsSync(join(tmpDir, 'transduck.yaml'))).toBe(true);
-    expect(existsSync(join(tmpDir, 'translations.duckdb'))).toBe(true);
+    expect(existsSync(join(tmpDir, 'translations.lmdb'))).toBe(true);
   });
 
   it('stats on empty db shows zero', async () => {
@@ -68,7 +68,7 @@ describe('CLI functions', () => {
 
   it('translate returns cached with vars interpolated', async () => {
     const configPath = writeConfig(tmpDir);
-    const dbPath = join(tmpDir, 'translations.duckdb');
+    const dbPath = join(tmpDir, 'translations.lmdb');
 
     // Pre-populate the DB
     const store = new TranslationStore(dbPath);
@@ -91,7 +91,7 @@ describe('CLI functions', () => {
 
   it('translate-plural returns cached plural form', async () => {
     const configPath = writeConfig(tmpDir);
-    const dbPath = join(tmpDir, 'translations.duckdb');
+    const dbPath = join(tmpDir, 'translations.lmdb');
 
     // Pre-populate the DB with plural forms
     const store = new TranslationStore(dbPath);
@@ -132,7 +132,7 @@ describe('CLI functions', () => {
 
   it('warm handles plural entries', async () => {
     const configPath = writeConfig(tmpDir);
-    const dbPath = join(tmpDir, 'translations.duckdb');
+    const dbPath = join(tmpDir, 'translations.lmdb');
 
     // Pre-populate some plural forms so warm skips them
     const store = new TranslationStore(dbPath);
@@ -202,7 +202,7 @@ describe('CLI functions', () => {
     writeFileSync(join(srcDir, 'app.py'), 'ait("Hello")\n');
 
     // Pre-populate the DB so warm skips
-    const dbPath = join(tmpDir, 'translations.duckdb');
+    const dbPath = join(tmpDir, 'translations.lmdb');
     const store = new TranslationStore(dbPath);
     await store.initialize();
     await store.insert({

package/tests/config.test.ts

@@ -19,7 +19,7 @@ languages:
     - DE
     - ES
 storage:
-  path: ./translations.duckdb
+  path: ./translations.lmdb
 backend:
   api_key_env: OPENAI_API_KEY
   model: gpt-4.1-mini
@@ -60,7 +60,7 @@ describe('loadConfig', () => {
     const configPath = join(tmpDir, 'transduck.yaml');
     writeFileSync(configPath, VALID_YAML);
     const cfg = loadConfig(configPath);
-    expect(cfg.storagePath).toBe(join(tmpDir, 'translations.duckdb'));
+    expect(cfg.storagePath).toBe(join(tmpDir, 'translations.lmdb'));
   });
 
   it('discovers config from TRANSDUCK_CONFIG env var', () => {

package/tests/handler.test.ts

@@ -21,7 +21,7 @@ languages:
   targets:
     - DE
 storage:
-  path: ./translations.duckdb
+  path: ./translations.lmdb
 backend:
   api_key_env: OPENAI_API_KEY
   model: gpt-4.1-mini
@@ -48,7 +48,7 @@ describe('handleTranslationRequest', () => {
     const { createHash } = await import('crypto');
     const hash = (t: string) => createHash('sha256').update(t).digest('hex');
 
-    const store = new TranslationStore(join(tmpDir, 'translations.duckdb'));
+    const store = new TranslationStore(join(tmpDir, 'translations.lmdb'));
     await store.initialize();
     await store.insert({
       sourceText: 'Hello', sourceLang: 'EN', targetLang: 'DE',
@@ -83,7 +83,7 @@ describe('handleTranslationRequest', () => {
     const { createHash } = await import('crypto');
     const hash = (t: string) => createHash('sha256').update(t).digest('hex');
 
-    const store = new TranslationStore(join(tmpDir, 'translations.duckdb'));
+    const store = new TranslationStore(join(tmpDir, 'translations.lmdb'));
     await store.initialize();
     await store.insert({
       sourceText: 'Book', sourceLang: 'EN', targetLang: 'DE',
@@ -106,7 +106,7 @@ describe('handleTranslationRequest', () => {
     const { createHash } = await import('crypto');
     const hash = (t: string) => createHash('sha256').update(t).digest('hex');
 
-    const store = new TranslationStore(join(tmpDir, 'translations.duckdb'));
+    const store = new TranslationStore(join(tmpDir, 'translations.lmdb'));
     await store.initialize();
     const sourceKey = '{count} item\x00{count} items';
     await store.insertPlural({

package/tests/providers.test.ts

@@ -20,7 +20,7 @@ function makeConfig(overrides: Partial<TransduckConfig> = {}): TransduckConfig {
     projectContext: 'A test site',
     sourceLang: 'EN',
     targetLangs: ['DE'],
-    storagePath: '/tmp/test.duckdb',
+    storagePath: '/tmp/test.lmdb',
     provider: 'openai',
     apiKeyEnv: 'OPENAI_API_KEY',
     tokenEnv: 'CLAUDE_CODE_OAUTH_TOKEN',
@@ -207,7 +207,7 @@ languages:
   source: EN
   targets: [DE]
 storage:
-  path: ./translations.duckdb
+  path: ./translations.lmdb
 backend:
   api_key_env: OPENAI_API_KEY
   model: gpt-4.1-mini
@@ -230,7 +230,7 @@ languages:
   source: EN
   targets: [DE]
 storage:
-  path: ./translations.duckdb
+  path: ./translations.lmdb
 backend:
   provider: claude_api
   api_key_env: ANTHROPIC_API_KEY
@@ -255,7 +255,7 @@ languages:
   source: EN
   targets: [DE]
 storage:
-  path: ./translations.duckdb
+  path: ./translations.lmdb
 backend:
   provider: claude_code
   token_env: CLAUDE_CODE_OAUTH_TOKEN
@@ -277,7 +277,7 @@ languages:
   source: EN
   targets: [DE]
 storage:
-  path: ./translations.duckdb
+  path: ./translations.lmdb
 backend:
   provider: claude_code
 `);

package/tests/react-provider.test.tsx

@@ -1,7 +1,8 @@
 import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
 import React from 'react';
-import { render, screen, cleanup, waitFor } from '@testing-library/react';
-import { TransDuckProvider, t, ait, tPlural, aitPlural, useTransDuck, _resetReactState } from '../src/react/index.js';
+import { render, screen, cleanup, waitFor, act } from '@testing-library/react';
+import { TransDuckProvider, t, ait, tPlural, aitPlural, useTransDuck, _resetReactState, _getReactState } from '../src/react/index.js';
+import type { UseTransDuckReturn } from '../src/react/index.js';
 
 // Mock fetch globally
 const mockFetch = vi.fn();
@@ -159,4 +160,364 @@ describe('TransDuckProvider + t()', () => {
     expect(mockFetch).not.toHaveBeenCalled();
     expect(screen.getByTestId('text').textContent).toBe('Hallo');
   });
+
+  it('t() tracks called keys in _state.knownKeys', async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({ translations: { 'Hello||': 'Hallo' }, plurals: {} }),
+    });
+
+    function TestComp() {
+      useTransDuck();
+      return <span>{t('Hello')}</span>;
+    }
+
+    render(
+      <TransDuckProvider language="DE">
+        <TestComp />
+      </TransDuckProvider>
+    );
+
+    const state = _getReactState();
+    expect(state.knownKeys.has('Hello||')).toBe(true);
+  });
+
+  it('useTransDuck() returns t, tPlural, ait, aitPlural, language, setLanguage, isLoading', () => {
+    let hookResult: ReturnType<typeof useTransDuck> | null = null;
+
+    function TestComp() {
+      hookResult = useTransDuck();
+      return <span>test</span>;
+    }
+
+    render(
+      <TransDuckProvider language="DE">
+        <TestComp />
+      </TransDuckProvider>
+    );
+
+    expect(hookResult).not.toBeNull();
+    expect(hookResult!.t).toBe(t);
+    expect(hookResult!.tPlural).toBe(tPlural);
+    expect(hookResult!.ait).toBe(ait);
+    expect(hookResult!.aitPlural).toBe(aitPlural);
+    expect(hookResult!.language).toBe('DE');
+    expect(typeof hookResult!.setLanguage).toBe('function');
+    expect(hookResult!.isLoading).toBe(false);
+  });
+
+  it('setLanguage() switches language, clears cache, and re-fetches', async () => {
+    // First render in DE
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ translations: { 'Hello||': 'Hallo' }, plurals: {} }),
+    });
+    // After switch to ES
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ translations: { 'Hello||': 'Hola' }, plurals: {} }),
+    });
+
+    let hookRef: UseTransDuckReturn | null = null;
+
+    function TestComp() {
+      const hook = useTransDuck();
+      hookRef = hook;
+      return <span data-testid="text">{hook.t('Hello')}</span>;
+    }
+
+    render(
+      <TransDuckProvider language="DE">
+        <TestComp />
+      </TransDuckProvider>
+    );
+
+    // Wait for DE translations
+    await waitFor(() => {
+      expect(screen.getByTestId('text').textContent).toBe('Hallo');
+    });
+
+    // Switch to ES
+    await act(async () => {
+      hookRef!.setLanguage('ES');
+    });
+
+    // Wait for ES translations
+    await waitFor(() => {
+      expect(screen.getByTestId('text').textContent).toBe('Hola');
+    });
+
+    expect(hookRef!.language).toBe('ES');
+  });
+
+  it('setLanguage() with current language is a no-op', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ translations: { 'Hello||': 'Hallo' }, plurals: {} }),
+    });
+
+    let hookRef: UseTransDuckReturn | null = null;
+
+    function TestComp() {
+      const hook = useTransDuck();
+      hookRef = hook;
+      return <span data-testid="text">{hook.t('Hello')}</span>;
+    }
+
+    render(
+      <TransDuckProvider language="DE">
+        <TestComp />
+      </TransDuckProvider>
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('text').textContent).toBe('Hallo');
+    });
+
+    mockFetch.mockClear();
+
+    await act(async () => {
+      hookRef!.setLanguage('DE');
+    });
+
+    expect(mockFetch).not.toHaveBeenCalled();
+    expect(screen.getByTestId('text').textContent).toBe('Hallo');
+  });
+
+  it('setLanguage() to source language skips fetch', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ translations: { 'Hello||': 'Hallo' }, plurals: {} }),
+    });
+
+    let hookRef: UseTransDuckReturn | null = null;
+
+    function TestComp() {
+      const hook = useTransDuck();
+      hookRef = hook;
+      return <span data-testid="text">{hook.t('Hello')}</span>;
+    }
+
+    render(
+      <TransDuckProvider language="DE" sourceLang="EN">
+        <TestComp />
+      </TransDuckProvider>
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('text').textContent).toBe('Hallo');
+    });
+
+    mockFetch.mockClear();
+
+    await act(async () => {
+      hookRef!.setLanguage('EN');
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId('text').textContent).toBe('Hello');
+    });
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('isLoading is true during language switch fetch', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ translations: { 'Hello||': 'Hallo' }, plurals: {} }),
+    });
+
+    let resolveSecondFetch: ((value: unknown) => void) | null = null;
+    mockFetch.mockImplementationOnce(() => new Promise(resolve => {
+      resolveSecondFetch = resolve;
+    }));
+
+    let hookRef: UseTransDuckReturn | null = null;
+
+    function TestComp() {
+      const hook = useTransDuck();
+      hookRef = hook;
+      return <span data-testid="text">{hook.t('Hello')}</span>;
+    }
+
+    render(
+      <TransDuckProvider language="DE">
+        <TestComp />
+      </TransDuckProvider>
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('text').textContent).toBe('Hallo');
+    });
+
+    await act(async () => {
+      hookRef!.setLanguage('ES');
+    });
+
+    expect(hookRef!.isLoading).toBe(true);
+
+    await act(async () => {
+      resolveSecondFetch!({
+        ok: true,
+        json: async () => ({ translations: { 'Hello||': 'Hola' }, plurals: {} }),
+      });
+    });
+
+    await waitFor(() => {
+      expect(hookRef!.isLoading).toBe(false);
+      expect(screen.getByTestId('text').textContent).toBe('Hola');
+    });
+  });
+
+  it('isLoading clears on fetch error during language switch', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ translations: { 'Hello||': 'Hallo' }, plurals: {} }),
+    });
+    mockFetch.mockRejectedValueOnce(new Error('Network error'));
+
+    let hookRef: UseTransDuckReturn | null = null;
+
+    function TestComp() {
+      const hook = useTransDuck();
+      hookRef = hook;
+      return <span data-testid="text">{hook.t('Hello')}</span>;
+    }
+
+    render(
+      <TransDuckProvider language="DE">
+        <TestComp />
+      </TransDuckProvider>
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('text').textContent).toBe('Hallo');
+    });
+
+    await act(async () => {
+      hookRef!.setLanguage('ES');
+    });
+
+    await waitFor(() => {
+      expect(hookRef!.isLoading).toBe(false);
+    });
+  });
+
+  it('discards stale fetch response when language changes during fetch', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ translations: { 'Hello||': 'Hallo' }, plurals: {} }),
+    });
+
+    let resolveFRFetch: ((value: unknown) => void) | null = null;
+    mockFetch.mockImplementationOnce(() => new Promise(resolve => {
+      resolveFRFetch = resolve;
+    }));
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ translations: { 'Hello||': 'Hola' }, plurals: {} }),
+    });
+
+    let hookRef: UseTransDuckReturn | null = null;
+
+    function TestComp() {
+      const hook = useTransDuck();
+      hookRef = hook;
+      return <span data-testid="text">{hook.t('Hello')}</span>;
+    }
+
+    render(
+      <TransDuckProvider language="DE">
+        <TestComp />
+      </TransDuckProvider>
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('text').textContent).toBe('Hallo');
+    });
+
+    await act(async () => {
+      hookRef!.setLanguage('FR');
+    });
+
+    await act(async () => {
+      hookRef!.setLanguage('ES');
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId('text').textContent).toBe('Hola');
+    });
+
+    await act(async () => {
+      resolveFRFetch!({
+        ok: true,
+        json: async () => ({ translations: { 'Hello||': 'Bonjour' }, plurals: {} }),
+      });
+    });
+
+    expect(screen.getByTestId('text').textContent).toBe('Hola');
+    expect(hookRef!.language).toBe('ES');
+  });
+
+  it('changing language prop triggers switchLanguage with isLoading', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ translations: { 'Hello||': 'Hallo' }, plurals: {} }),
+    });
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ translations: { 'Hello||': 'Hola' }, plurals: {} }),
+    });
+
+    let hookRef: UseTransDuckReturn | null = null;
+
+    function TestComp() {
+      const hook = useTransDuck();
+      hookRef = hook;
+      return <span data-testid="text">{hook.t('Hello')}</span>;
+    }
+
+    const { rerender } = render(
+      <TransDuckProvider language="DE">
+        <TestComp />
+      </TransDuckProvider>
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('text').textContent).toBe('Hallo');
+    });
+
+    rerender(
+      <TransDuckProvider language="ES">
+        <TestComp />
+      </TransDuckProvider>
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('text').textContent).toBe('Hola');
+      expect(hookRef!.language).toBe('ES');
+    });
+  });
+
+  it('useTransDuck() still works without destructuring (backward compat)', async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({ translations: { 'Hello||': 'Hallo' }, plurals: {} }),
+    });
+
+    function TestComp() {
+      useTransDuck();
+      return <span data-testid="text">{t('Hello')}</span>;
+    }
+
+    render(
+      <TransDuckProvider language="DE">
+        <TestComp />
+      </TransDuckProvider>
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('text').textContent).toBe('Hallo');
+    });
+  });
 });

package/tests/storage.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { createHash } from 'crypto';
 import { join } from 'path';
 import { mkdtempSync } from 'fs';
@@ -14,13 +14,17 @@ describe('TranslationStore', () => {
 
   beforeEach(async () => {
     const tmpDir = mkdtempSync(join(tmpdir(), 'transduck-test-'));
-    store = new TranslationStore(join(tmpDir, 'test.duckdb'));
+    store = new TranslationStore(join(tmpDir, 'test.lmdb'));
     await store.initialize();
   });
 
-  it('creates table on initialize', async () => {
-    const result = await store.query('SELECT count(*) as c FROM translations');
-    expect(result[0].c).toBe(0);
+  afterEach(() => {
+    store.close();
+  });
+
+  it('starts empty', async () => {
+    const stats = await store.stats();
+    expect(stats.totalTranslations).toBe(0);
   });
 
   it('inserts and looks up translation', async () => {
@@ -195,68 +199,32 @@ describe('TranslationStore', () => {
     await store.insertPlural(entry); // should not throw
   });
 
-  // --- Migration ---
-
-  it('migrates v1 schema to v2', async () => {
-    // Create a fresh store with v1 schema
-    const tmpDir = mkdtempSync(join(tmpdir(), 'transduck-migration-'));
-    const dbPath = join(tmpDir, 'migrate.duckdb');
-
-    // Manually create v1 schema (no plural_category column)
-    const { DuckDBInstance } = await import('@duckdb/node-api');
-    const instance = await DuckDBInstance.create(dbPath);
-    const conn = await instance.connect();
-    await conn.run(`
-      CREATE TABLE translations (
-        source_text          TEXT NOT NULL,
-        source_lang          TEXT NOT NULL,
-        target_lang          TEXT NOT NULL,
-        project_context_hash TEXT NOT NULL,
-        string_context_hash  TEXT NOT NULL,
-        translated_text      TEXT NOT NULL,
-        model                TEXT NOT NULL,
-        status               TEXT NOT NULL DEFAULT 'translated',
-        created_at           TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        PRIMARY KEY(source_text, source_lang, target_lang, project_context_hash, string_context_hash)
-      )
-    `);
-    // Insert a v1 row
-    await conn.run(`
-      INSERT INTO translations (source_text, source_lang, target_lang, project_context_hash, string_context_hash, translated_text, model, status)
-      VALUES ('Hello', 'EN', 'DE', '${hash('ctx')}', '${hash('')}', 'Hallo', 'gpt-4.1-mini', 'translated')
-    `);
-
-    // Close the raw connection
-    // (DuckDB node-api handles cleanup via GC, just null out)
+  // --- Count and clear ---
 
-    // Now open with TranslationStore — should migrate
-    const migratedStore = new TranslationStore(dbPath);
-    await migratedStore.initialize();
-
-    // Old data should still be accessible
-    const result = await migratedStore.lookup({
+  it('counts and clears entries', async () => {
+    await store.insert({
       sourceText: 'Hello', sourceLang: 'EN', targetLang: 'DE',
       projectContextHash: hash('ctx'), stringContextHash: hash(''),
+      translatedText: 'Hallo', model: 'gpt-4.1-mini', status: 'translated',
     });
-    expect(result).toBe('Hallo');
-
-    // Plural methods should work
-    await migratedStore.insertPlural({
-      sourceText: 'test\x00tests',
-      sourceLang: 'EN', targetLang: 'DE',
+    await store.insert({
+      sourceText: 'Bad', sourceLang: 'EN', targetLang: 'DE',
       projectContextHash: hash('ctx'), stringContextHash: hash(''),
-      pluralCategory: 'other',
-      translatedText: 'Tests',
-      model: 'gpt-4.1-mini', status: 'translated',
+      translatedText: 'schlecht', model: 'gpt-4.1-mini', status: 'failed',
     });
-
-    const pluralResult = await migratedStore.lookupPlural({
-      sourceText: 'test\x00tests',
-      sourceLang: 'EN', targetLang: 'DE',
+    await store.insert({
+      sourceText: 'Hello', sourceLang: 'EN', targetLang: 'ES',
       projectContextHash: hash('ctx'), stringContextHash: hash(''),
+      translatedText: 'Hola', model: 'gpt-4.1-mini', status: 'translated',
     });
-    expect(pluralResult).toEqual({ other: 'Tests' });
 
-    migratedStore.close();
+    expect(store.count()).toBe(3);
+    expect(store.count('DE')).toBe(2);
+    expect(store.count(undefined, true)).toBe(1);
+    expect(store.count('DE', true)).toBe(1);
+
+    const deleted = await store.clear('DE', true);
+    expect(deleted).toBe(1);
+    expect(store.count()).toBe(2);
   });
 });