hugo/bDS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Feature/post media translations (#42)

Browse Source 
* chore: updated todo with translation ideas

* feat: first take at the implementation of translations

* fix: small addition for the translation feature

* feat: support language switching in the editor and preview

* feat: better handling of long bodies by not running them through a json envelope

* fix: unknown macros have better fallback

* feat: api for python to get translations

* fix: strip dumb prefix of content in translation

* feat: extend meta diff for translations

* feat: hook up translations to rebuild-from-disk

* feat: generation of the website prefers project language, falling back to canonical language

* fix: crashes during rendering

* feat: translation validation report

* fix: made the translation validation actually work

* chore: reorganization of menu

* fix: some topics cleanup

* chore: updated doc

* feat: translations for media

* feat: more aligned in UI/UX

* feat: edit translations possible

* chore: added full multi-language todo

* chore: updated todo for clarity

* feat: implementation of full multi-linguality

* fix: page creation creates pages

* fix: flags on every page

* fix: better prompt

* feat: made MCP server aware of language content

* feat: python tools for translations

* fix: better fill-in-translations

* fix: better prompt for translation. maybe.

* fix: losing posts from search due to translation process

* fix: translation validation handles in-db content and fill-in of missing translations fixed to flush

* fix: faster scanning for infilling of missing translations

* chore: updated agent instructions

* feat: calendar and tag cloud respect current language now

* fix: retries going up

* fix: got metadata-diff and rebuild into sync

* fix: extended meta-diff for timestamps

* fix: made website validation look at translated content, too

* fix: multi-lingual search

* chore: refactor Editor.tsx into two separate editors

* feat: do language detection when no explicit language given

---------

Co-authored-by: hugo <hugoms@me.com>
This commit is contained in:
Georg Bauer
2026-03-09 14:43:18 +01:00
committed by GitHub
parent f1c9038803
commit b855d61524
116 changed files with 19954 additions and 2094 deletions
Download Patch File Download Diff File Expand all files Collapse all files

257
tests/ipc/handlers.test.ts
View File

@@ -44,6 +44,9 @@ const mockPostEngine = {
on: vi.fn(),
setProjectContext: vi.fn(),
setSearchLanguage: vi.fn(),
setMainLanguage: vi.fn(),
validateTranslations: vi.fn(),
fixInvalidTranslations: vi.fn(),
reconcilePublishedPostsFromGitChanges: vi.fn(),
createPost: vi.fn(),
updatePost: vi.fn(),
@@ -67,6 +70,7 @@ const mockPostEngine = {
getLinksTo: vi.fn(),
getLinkedBy: vi.fn(),
rebuildLinks: vi.fn(),
getPostTranslations: vi.fn().mockResolvedValue([]),
};
const mockMediaEngine = {
@@ -88,6 +92,7 @@ const mockMediaEngine = {
getThumbnailDataUrl: vi.fn(),
regenerateMissingThumbnails: vi.fn(),
getRelativePath: vi.fn(),
getMediaTranslations: vi.fn(),
};
const mockProjectEngine = {
@@ -911,6 +916,7 @@ describe('IPC Handlers', () => {
expect(mockPostEngine.setSearchLanguage).toHaveBeenCalledWith('german');
expect(mockMediaEngine.setSearchLanguage).toHaveBeenCalledWith('german');
expect(mockPostEngine.setMainLanguage).toHaveBeenCalledWith('de');
});
});
@@ -1025,6 +1031,19 @@ describe('IPC Handlers', () => {
expect(mockPostEngine.getPost).toHaveBeenCalledWith('post-1');
expect(result).toBe('http://127.0.0.1:4123/2026/02/16/my-post?draft=true&postId=post-1');
});
it('should include lang in draft preview URL when provided', async () => {
mockPostEngine.getPost.mockResolvedValue(createMockPost({
id: 'post-1',
slug: 'my-post',
createdAt: new Date('2026-02-16T12:00:00.000Z'),
}));
const result = await invokeHandler('posts:getPreviewUrl', 'post-1', { draft: true, lang: 'fr' });
expect(mockPostEngine.getPost).toHaveBeenCalledWith('post-1');
expect(result).toBe('http://127.0.0.1:4123/2026/02/16/my-post?draft=true&postId=post-1&lang=fr');
});
});
describe('posts:getAll', () => {
@@ -2767,6 +2786,244 @@ describe('IPC Handlers', () => {
});
});
describe('blog:validateTranslations', () => {
it('should run translation validation via taskManager.runTask', async () => {
const mockProject = createMockProject({ id: 'test-project', dataPath: '/mock/data' });
mockProjectEngine.getActiveProject.mockResolvedValue(mockProject);
mockProjectEngine.getDataDir.mockReturnValue('/mock/data/dir');
mockMetaEngine.getProjectMetadata.mockResolvedValue({
name: 'Test Project',
publicUrl: 'https://blog.example.com',
});
mockPostEngine.validateTranslations.mockResolvedValue({
checkedDatabaseRowCount: 1,
checkedFilesystemFileCount: 1,
invalidDatabaseRows: [],
invalidFilesystemFiles: [],
});
mockTaskManager.runTask.mockImplementation(async (task: any) => {
return task.execute(vi.fn());
});
const result = await invokeHandler('blog:validateTranslations');
expect(result).toEqual(expect.objectContaining({
checkedDatabaseRowCount: 1,
checkedFilesystemFileCount: 1,
}));
expect(mockTaskManager.runTask).toHaveBeenCalledWith(
expect.objectContaining({
name: 'Validate Translations',
execute: expect.any(Function),
}),
);
expect(mockPostEngine.validateTranslations).toHaveBeenCalled();
});
});
describe('blog:fixInvalidTranslations', () => {
it('should run fix via taskManager.runTask', async () => {
const mockProject = createMockProject({ id: 'test-project', dataPath: '/mock/data' });
mockProjectEngine.getActiveProject.mockResolvedValue(mockProject);
mockProjectEngine.getDataDir.mockReturnValue('/mock/data/dir');
mockMetaEngine.getProjectMetadata.mockResolvedValue({
name: 'Test Project',
publicUrl: 'https://blog.example.com',
});
mockPostEngine.fixInvalidTranslations.mockResolvedValue({
deletedDatabaseRows: 2,
deletedFiles: 1,
flushedTranslations: 0,
});
mockTaskManager.runTask.mockImplementation(async (task: any) => {
return task.execute(vi.fn());
});
const report = {
checkedDatabaseRowCount: 5,
checkedFilesystemFileCount: 3,
invalidDatabaseRows: [
{ issue: 'same-language-as-canonical', translationFor: 'post-1', translationLanguage: 'de', translationId: 'tr-1' },
{ issue: 'same-language-as-canonical', translationFor: 'post-2', translationLanguage: 'de', translationId: 'tr-2' },
],
invalidFilesystemFiles: [
{ issue: 'same-language-as-canonical', translationFor: 'post-1', translationLanguage: 'de', filePath: '/tmp/file.de.md' },
],
};
const result = await invokeHandler('blog:fixInvalidTranslations', report);
expect(result).toEqual({ deletedDatabaseRows: 2, deletedFiles: 1, flushedTranslations: 0 });
expect(mockTaskManager.runTask).toHaveBeenCalledWith(
expect.objectContaining({
name: 'Fix Invalid Translations',
execute: expect.any(Function),
}),
);
expect(mockPostEngine.fixInvalidTranslations).toHaveBeenCalledWith(report);
});
});
describe('blog:fillMissingTranslations', () => {
it('should return taskStarted false when only main language is configured', async () => {
const mockProject = createMockProject({ id: 'test-project', dataPath: '/mock/data' });
mockProjectEngine.getActiveProject.mockResolvedValue(mockProject);
mockProjectEngine.getDataDir.mockReturnValue('/mock/data/dir');
mockMetaEngine.getProjectMetadata.mockResolvedValue({
mainLanguage: 'en',
blogLanguages: ['en'],
});
const result = await invokeHandler('blog:fillMissingTranslations');
expect(result).toEqual({ taskStarted: false });
expect(mockPostEngine.getPostsFiltered).not.toHaveBeenCalled();
});
it('should return taskStarted false when no blog languages configured', async () => {
const mockProject = createMockProject({ id: 'test-project', dataPath: '/mock/data' });
mockProjectEngine.getActiveProject.mockResolvedValue(mockProject);
mockProjectEngine.getDataDir.mockReturnValue('/mock/data/dir');
mockMetaEngine.getProjectMetadata.mockResolvedValue({
mainLanguage: 'en',
blogLanguages: [],
});
const result = await invokeHandler('blog:fillMissingTranslations');
expect(result).toEqual({ taskStarted: false });
expect(mockPostEngine.getPostsFiltered).not.toHaveBeenCalled();
});
it('should return taskStarted false when metadata has no blogLanguages', async () => {
const mockProject = createMockProject({ id: 'test-project', dataPath: '/mock/data' });
mockProjectEngine.getActiveProject.mockResolvedValue(mockProject);
mockProjectEngine.getDataDir.mockReturnValue('/mock/data/dir');
mockMetaEngine.getProjectMetadata.mockResolvedValue({
mainLanguage: 'en',
});
const result = await invokeHandler('blog:fillMissingTranslations');
expect(result).toEqual({ taskStarted: false });
expect(mockPostEngine.getPostsFiltered).not.toHaveBeenCalled();
});
it('should start task immediately and scan inside the task', async () => {
const mockProject = createMockProject({ id: 'test-project', dataPath: '/mock/data' });
mockProjectEngine.getActiveProject.mockResolvedValue(mockProject);
mockProjectEngine.getDataDir.mockReturnValue('/mock/data/dir');
mockMetaEngine.getProjectMetadata.mockResolvedValue({
mainLanguage: 'en',
blogLanguages: ['en', 'fr', 'de'],
});
mockTaskManager.runTask.mockResolvedValue(undefined);
const result = await invokeHandler('blog:fillMissingTranslations');
expect(result).toEqual({ taskStarted: true });
expect(mockTaskManager.runTask).toHaveBeenCalledTimes(1);
expect(mockTaskManager.runTask).toHaveBeenCalledWith(
expect.objectContaining({
name: 'Fill missing translations',
}),
);
});
it('should include media scanning inside the task', async () => {
const mockProject = createMockProject({ id: 'test-project', dataPath: '/mock/data' });
mockProjectEngine.getActiveProject.mockResolvedValue(mockProject);
mockProjectEngine.getDataDir.mockReturnValue('/mock/data/dir');
mockMetaEngine.getProjectMetadata.mockResolvedValue({
mainLanguage: 'en',
blogLanguages: ['en', 'fr'],
});
mockTaskManager.runTask.mockResolvedValue(undefined);
const result = await invokeHandler('blog:fillMissingTranslations');
expect(result).toEqual({ taskStarted: true });
expect(mockTaskManager.runTask).toHaveBeenCalledTimes(1);
expect(mockTaskManager.runTask).toHaveBeenCalledWith(
expect.objectContaining({
name: 'Fill missing translations',
}),
);
});
it('should skip posts marked as doNotTranslate', async () => {
const mockProject = createMockProject({ id: 'test-project', dataPath: '/mock/data' });
mockProjectEngine.getActiveProject.mockResolvedValue(mockProject);
mockProjectEngine.getDataDir.mockReturnValue('/mock/data/dir');
mockMetaEngine.getProjectMetadata.mockResolvedValue({
mainLanguage: 'en',
blogLanguages: ['en', 'fr'],
});
const post1 = createMockPost({ id: 'post-1', title: 'Test Post', language: 'en', doNotTranslate: true });
// missingTranslationLanguage queries return the post (it IS missing fr),
// but the handler filters it out due to doNotTranslate
mockPostEngine.getPostsFiltered.mockImplementation(async (filter: any) => {
if (filter.missingTranslationLanguage) {
return filter.missingTranslationLanguage === 'fr' ? [post1] : [];
}
return [post1]; // all published (for media scanning)
});
mockPostMediaEngine.getLinkedMediaForPost.mockResolvedValue([]);
const onProgress = vi.fn();
let taskDone: Promise<void> | undefined;
mockTaskManager.runTask.mockImplementation((task: any) => {
taskDone = task.execute(onProgress);
return taskDone;
});
const result = await invokeHandler('blog:fillMissingTranslations');
await taskDone;
expect(result).toEqual({ taskStarted: true });
// Task completes with "up to date" since doNotTranslate posts are skipped
expect(onProgress).toHaveBeenCalledWith(100, 'All translations are up to date');
});
it('should complete with nothing to do when all translations exist', async () => {
const mockProject = createMockProject({ id: 'test-project', dataPath: '/mock/data' });
mockProjectEngine.getActiveProject.mockResolvedValue(mockProject);
mockProjectEngine.getDataDir.mockReturnValue('/mock/data/dir');
mockMetaEngine.getProjectMetadata.mockResolvedValue({
mainLanguage: 'en',
blogLanguages: ['en', 'fr'],
});
const post1 = createMockPost({ id: 'post-1', title: 'Test Post', language: 'en' });
// missingTranslationLanguage queries return empty (all translations exist)
mockPostEngine.getPostsFiltered.mockImplementation(async (filter: any) => {
if (filter.missingTranslationLanguage) {
return [];
}
return [post1]; // all published (for media scanning)
});
mockPostMediaEngine.getLinkedMediaForPost.mockResolvedValue([]);
const onProgress = vi.fn();
let taskDone: Promise<void> | undefined;
mockTaskManager.runTask.mockImplementation((task: any) => {
taskDone = task.execute(onProgress);
return taskDone;
});
const result = await invokeHandler('blog:fillMissingTranslations');
await taskDone;
expect(result).toEqual({ taskStarted: true });
expect(onProgress).toHaveBeenCalledWith(100, 'All translations are up to date');
});
});
describe('blog:applyValidation', () => {
it('should run apply via taskManager.runTask', async () => {
const mockProject = createMockProject({ id: 'test-project', dataPath: '/mock/data' });