transduck 0.0.5 → 0.1.2

package/tests/handler.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { mkdtempSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+// We test the handler logic directly, not via HTTP
+import { handleTranslationRequest, _resetHandlerStore } from '../src/handler.js';
+
+function makeTmpDir(): string {
+  return mkdtempSync(join(tmpdir(), 'transduck-handler-test-'));
+}
+
+function writeConfig(dir: string): string {
+  const configPath = join(dir, 'transduck.yaml');
+  writeFileSync(configPath, `
+project:
+  name: test-project
+  context: "A test site"
+languages:
+  source: EN
+  targets:
+    - DE
+storage:
+  path: ./translations.duckdb
+backend:
+  api_key_env: OPENAI_API_KEY
+  model: gpt-4.1-mini
+  timeout_seconds: 10
+  max_retries: 2
+`);
+  return configPath;
+}
+
+describe('handleTranslationRequest', () => {
+  let tmpDir: string;
+  let configPath: string;
+
+  beforeEach(() => {
+    _resetHandlerStore();
+    tmpDir = makeTmpDir();
+    configPath = writeConfig(tmpDir);
+    process.env.OPENAI_API_KEY = 'test-key';
+  });
+
+  it('returns translations for strings from cache', async () => {
+    // Pre-populate cache via storage directly
+    const { TranslationStore } = await import('../src/storage.js');
+    const { createHash } = await import('crypto');
+    const hash = (t: string) => createHash('sha256').update(t).digest('hex');
+
+    const store = new TranslationStore(join(tmpDir, 'translations.duckdb'));
+    await store.initialize();
+    await store.insert({
+      sourceText: 'Hello', sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('A test site'), stringContextHash: hash(''),
+      translatedText: 'Hallo', model: 'gpt-4.1-mini', status: 'translated',
+    });
+    store.close();
+
+    const result = await handleTranslationRequest({
+      language: 'DE',
+      strings: [{ text: 'Hello' }],
+      plurals: [],
+    }, configPath);
+
+    expect(result.translations['Hello||']).toBe('Hallo');
+  });
+
+  it('returns empty translations for uncached strings without API key', async () => {
+    delete process.env.OPENAI_API_KEY;
+    const result = await handleTranslationRequest({
+      language: 'DE',
+      strings: [{ text: 'Unknown' }],
+      plurals: [],
+    }, configPath);
+
+    // Without API key, backend will fail, should return source text
+    expect(result.translations['Unknown||']).toBe('Unknown');
+  });
+
+  it('handles context in cache key', async () => {
+    const { TranslationStore } = await import('../src/storage.js');
+    const { createHash } = await import('crypto');
+    const hash = (t: string) => createHash('sha256').update(t).digest('hex');
+
+    const store = new TranslationStore(join(tmpDir, 'translations.duckdb'));
+    await store.initialize();
+    await store.insert({
+      sourceText: 'Book', sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('A test site'), stringContextHash: hash('Hotel booking'),
+      translatedText: 'Buchen', model: 'gpt-4.1-mini', status: 'translated',
+    });
+    store.close();
+
+    const result = await handleTranslationRequest({
+      language: 'DE',
+      strings: [{ text: 'Book', context: 'Hotel booking' }],
+      plurals: [],
+    }, configPath);
+
+    expect(result.translations['Book||Hotel booking']).toBe('Buchen');
+  });
+
+  it('returns plural forms from cache', async () => {
+    const { TranslationStore } = await import('../src/storage.js');
+    const { createHash } = await import('crypto');
+    const hash = (t: string) => createHash('sha256').update(t).digest('hex');
+
+    const store = new TranslationStore(join(tmpDir, 'translations.duckdb'));
+    await store.initialize();
+    const sourceKey = '{count} item\x00{count} items';
+    await store.insertPlural({
+      sourceText: sourceKey, sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('A test site'), stringContextHash: hash(''),
+      pluralCategory: 'one', translatedText: '{count} Artikel',
+      model: 'gpt-4.1-mini', status: 'translated',
+    });
+    await store.insertPlural({
+      sourceText: sourceKey, sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('A test site'), stringContextHash: hash(''),
+      pluralCategory: 'other', translatedText: '{count} Artikel',
+      model: 'gpt-4.1-mini', status: 'translated',
+    });
+    store.close();
+
+    const result = await handleTranslationRequest({
+      language: 'DE',
+      strings: [],
+      plurals: [{ one: '{count} item', other: '{count} items' }],
+    }, configPath);
+
+    const pluralKey = '{count} item\x00{count} items||';
+    expect(result.plurals[pluralKey]).toBeDefined();
+    expect(result.plurals[pluralKey].one).toBe('{count} Artikel');
+  });
+});

package/tests/react-provider.test.tsx

@@ -0,0 +1,162 @@
+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';
+
+// Mock fetch globally
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+// Mock localStorage
+const localStorageStore: Record<string, string> = {};
+const mockLocalStorage = {
+  getItem: vi.fn((key: string) => localStorageStore[key] ?? null),
+  setItem: vi.fn((key: string, value: string) => { localStorageStore[key] = value; }),
+  removeItem: vi.fn((key: string) => { delete localStorageStore[key]; }),
+  clear: vi.fn(() => { for (const k in localStorageStore) delete localStorageStore[k]; }),
+};
+Object.defineProperty(globalThis, 'localStorage', { value: mockLocalStorage, writable: true });
+
+describe('TransDuckProvider + t()', () => {
+  beforeEach(() => {
+    _resetReactState();
+    mockFetch.mockReset();
+    mockLocalStorage.clear();
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  it('t() returns source text before translation loads', () => {
+    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>
+    );
+
+    // Before fetch resolves, shows source text
+    expect(screen.getByTestId('text').textContent).toBe('Hello');
+  });
+
+  it('t() and ait() are the same function', () => {
+    expect(t).toBe(ait);
+  });
+
+  it('tPlural() and aitPlural() are the same function', () => {
+    expect(tPlural).toBe(aitPlural);
+  });
+
+  it('t() returns source text when language matches source', () => {
+    function TestComp() {
+      useTransDuck();
+      return <span data-testid="text">{t('Hello')}</span>;
+    }
+
+    render(
+      <TransDuckProvider language="EN" sourceLang="EN">
+        <TestComp />
+      </TransDuckProvider>
+    );
+
+    expect(screen.getByTestId('text').textContent).toBe('Hello');
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('t() interpolates vars', () => {
+    function TestComp() {
+      useTransDuck();
+      return <span data-testid="text">{t('Hello {name}', undefined, { name: 'Tim' })}</span>;
+    }
+
+    render(
+      <TransDuckProvider language="EN" sourceLang="EN">
+        <TestComp />
+      </TransDuckProvider>
+    );
+
+    expect(screen.getByTestId('text').textContent).toBe('Hello Tim');
+  });
+
+  it('t() batches and fetches translations after render', async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        translations: { 'Hello||': 'Hallo', 'World||': 'Welt' },
+        plurals: {},
+      }),
+    });
+
+    function TestComp() {
+      useTransDuck();
+      return (
+        <div>
+          <span data-testid="a">{t('Hello')}</span>
+          <span data-testid="b">{t('World')}</span>
+        </div>
+      );
+    }
+
+    render(
+      <TransDuckProvider language="DE">
+        <TestComp />
+      </TransDuckProvider>
+    );
+
+    // After useEffect fires and fetch resolves
+    await waitFor(() => {
+      expect(screen.getByTestId('a').textContent).toBe('Hallo');
+      expect(screen.getByTestId('b').textContent).toBe('Welt');
+    });
+
+    // Should have made exactly one fetch call (batched)
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+  });
+
+  it('t() does not refetch cached strings', async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        translations: { 'Hello||': 'Hallo' },
+        plurals: {},
+      }),
+    });
+
+    function TestComp() {
+      useTransDuck();
+      return <span data-testid="text">{t('Hello')}</span>;
+    }
+
+    const { rerender } = render(
+      <TransDuckProvider language="DE">
+        <TestComp />
+      </TransDuckProvider>
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('text').textContent).toBe('Hallo');
+    });
+
+    mockFetch.mockClear();
+
+    // Re-render — should not fetch again
+    rerender(
+      <TransDuckProvider language="DE">
+        <TestComp />
+      </TransDuckProvider>
+    );
+
+    expect(mockFetch).not.toHaveBeenCalled();
+    expect(screen.getByTestId('text').textContent).toBe('Hallo');
+  });
+});

package/tests/scanner.test.ts

@@ -100,6 +100,30 @@ ait_plural("{count} item", "{count} items", count=n)
     const result = extractStrings('line1\nait("Hello")\nline3', 'test.py');
     expect(result[0].line).toBe(2);
   });
+
+  it('extracts t() from files with transduck/react import', () => {
+    const code = `import { t } from 'transduck/react';\nt("Hello")\nt("Book", "Hotel booking")`;
+    const result = extractStrings(code, 'test.tsx');
+    expect(result.length).toBe(2);
+    expect(result[0].text).toBe('Hello');
+    expect(result[1].text).toBe('Book');
+    expect(result[1].context).toBe('Hotel booking');
+  });
+
+  it('does not extract t() from files without transduck/react import', () => {
+    const code = `import { t } from 'i18next';\nt("Hello")`;
+    const result = extractStrings(code, 'test.tsx');
+    expect(result.length).toBe(0);
+  });
+
+  it('extracts tPlural() from files with transduck/react import', () => {
+    const code = `import { tPlural } from 'transduck/react';\ntPlural("{count} item", "{count} items", 5)`;
+    const result = extractStrings(code, 'test.tsx');
+    expect(result.length).toBe(1);
+    expect(result[0].plural).toBe(true);
+    expect(result[0].one).toBe('{count} item');
+    expect(result[0].other).toBe('{count} items');
+  });
 });
 
 describe('scanDirectory', () => {

package/tsconfig.json

@@ -10,7 +10,8 @@
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true
+    "resolveJsonModule": true,
+    "jsx": "react-jsx"
   },
   "include": ["src/**/*"]
 }

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environmentMatchGlobs: [
+      ['tests/react-*.test.tsx', 'jsdom'],
+    ],
+  },
+});