@stamhoofd/backend 2.134.0 → 2.136.0

package/src/endpoints/global/email/GetUserEmailsEndpoint.test.ts

@@ -1,7 +1,8 @@
 import { Request } from '@simonbackx/simple-endpoints';
 import type { Organization, RegistrationPeriod, User } from '@stamhoofd/models';
 import { Email, EmailRecipient, MemberFactory, OrganizationFactory, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
-import { EmailStatus, LimitedFilteredRequest, Replacement } from '@stamhoofd/structures';
+import { EmailContent, EmailStatus, LimitedFilteredRequest, Replacement } from '@stamhoofd/structures';
+import { Language } from '@stamhoofd/types/Language';
 import { TestUtils } from '@stamhoofd/test-utils';
 import { testServer } from '../../../../tests/helpers/TestServer.js';
 import { GetUserEmailsEndpoint } from './GetUserEmailsEndpoint.js';
@@ -753,4 +754,133 @@ describe('Endpoint.GetUserEmails', () => {
 
         await expect(testServer.test(endpoint, request)).rejects.toThrow();
     });
+
+    describe('Language of returned emails', () => {
+        // The web greeting translations looked up in shared/locales/dist/locales/digit/{nl,fr}-BE.json,
+        // hardcoded on purpose so we don't verify $t with the same $t machinery we're testing
+        const dutchGreeting = 'Beste,';
+        const frenchGreeting = 'Bonjour,';
+
+        /**
+         * A sent email with a Dutch default content and a French translation.
+         * The {{greeting}} in the html proves the replacements match the displayed content.
+         */
+        const createTranslatedEmail = async (options: { recipientLanguage?: Language | null } = {}) => {
+            const email = new Email();
+            email.subject = 'Nederlands onderwerp';
+            email.status = EmailStatus.Sent;
+            email.text = 'Nederlandse tekst';
+            email.html = '<p>{{greeting}} Nederlandse inhoud</p>';
+            email.json = {};
+            email.language = Language.Dutch;
+            email.translations = new Map([
+                [Language.French, EmailContent.create({
+                    subject: 'Sujet français',
+                    html: '<p>{{greeting}} Contenu français</p>',
+                    text: 'Texte français',
+                })],
+            ]);
+            email.organizationId = organization.id;
+            email.showInMemberPortal = true;
+            email.sentAt = new Date();
+            await email.save();
+
+            const emailRecipient = new EmailRecipient();
+            emailRecipient.emailId = email.id;
+            emailRecipient.memberId = member.id;
+            emailRecipient.userId = user.id;
+            emailRecipient.email = user.email;
+            emailRecipient.firstName = member.details.firstName;
+            emailRecipient.lastName = member.details.lastName;
+            emailRecipient.language = options.recipientLanguage ?? null;
+            emailRecipient.sentAt = new Date();
+            await emailRecipient.save();
+
+            return email;
+        };
+
+        const getUserEmailsViewedIn = async (language: string | null) => {
+            const request = Request.get({
+                path: baseUrl,
+                host: organization.getApiHost(),
+                query: new LimitedFilteredRequest({ limit: 10 }),
+                headers: {
+                    'authorization': 'Bearer ' + userToken.accessToken,
+                    ...(language ? { 'accept-language': language } : {}),
+                },
+            });
+            const response = await testServer.test(endpoint, request);
+            expect(response.body.results).toHaveLength(1);
+            const result = response.body.results[0];
+            expect(result.recipients).toHaveLength(1);
+            return { result, recipient: result.recipients[0] };
+        };
+
+        test('the email is returned in the language the caller is viewing when a translation exists', async () => {
+            TestUtils.setEnvironment('locales', { BE: [Language.Dutch, Language.French] });
+            // The recipient received the email in Dutch, but views the portal in French
+            await createTranslatedEmail({ recipientLanguage: Language.Dutch });
+
+            const { result, recipient } = await getUserEmailsViewedIn('fr');
+
+            // The recipient language switches to the viewing language, so subject, html, text
+            // and the regenerated replacements all resolve to the French content
+            expect(recipient.language).toBe(Language.French);
+            expect(recipient.replacements.find(r => r.token === 'greeting')?.value).toBe(frenchGreeting);
+            expect(result.getSubjectFor(recipient)).toBe('Sujet français');
+            expect(result.getHtmlFor(recipient)).toBe(`<p>${frenchGreeting} Contenu français</p>`);
+            expect(result.getContentForLanguage(recipient.language).text).toBe('Texte français');
+        });
+
+        test('the language the email was received in is kept when there is no translation for the viewing language', async () => {
+            TestUtils.setEnvironment('locales', { BE: [Language.Dutch, Language.French] });
+            // The recipient received the email in French, but views the portal in English
+            await createTranslatedEmail({ recipientLanguage: Language.French });
+
+            const { result, recipient } = await getUserEmailsViewedIn('en');
+
+            expect(recipient.language).toBe(Language.French);
+            expect(recipient.replacements.find(r => r.token === 'greeting')?.value).toBe(frenchGreeting);
+            expect(result.getSubjectFor(recipient)).toBe('Sujet français');
+            expect(result.getHtmlFor(recipient)).toBe(`<p>${frenchGreeting} Contenu français</p>`);
+            expect(result.getContentForLanguage(recipient.language).text).toBe('Texte français');
+        });
+
+        test('the language the email was received in is kept when the caller has no explicit language', async () => {
+            TestUtils.setEnvironment('locales', { BE: [Language.Dutch, Language.French] });
+            await createTranslatedEmail({ recipientLanguage: Language.French });
+
+            const { result, recipient } = await getUserEmailsViewedIn(null);
+
+            expect(recipient.language).toBe(Language.French);
+            expect(recipient.replacements.find(r => r.token === 'greeting')?.value).toBe(frenchGreeting);
+            expect(result.getSubjectFor(recipient)).toBe('Sujet français');
+            expect(result.getHtmlFor(recipient)).toBe(`<p>${frenchGreeting} Contenu français</p>`);
+        });
+
+        test('a recipient without a stored language is returned in the viewing language when a translation exists', async () => {
+            TestUtils.setEnvironment('locales', { BE: [Language.Dutch, Language.French] });
+            await createTranslatedEmail({ recipientLanguage: null });
+
+            const { result, recipient } = await getUserEmailsViewedIn('fr');
+
+            expect(recipient.language).toBe(Language.French);
+            expect(recipient.replacements.find(r => r.token === 'greeting')?.value).toBe(frenchGreeting);
+            expect(result.getSubjectFor(recipient)).toBe('Sujet français');
+            expect(result.getHtmlFor(recipient)).toBe(`<p>${frenchGreeting} Contenu français</p>`);
+        });
+
+        test('a recipient without a stored language keeps the default content when the viewing language has no translation', async () => {
+            TestUtils.setEnvironment('locales', { BE: [Language.Dutch, Language.French] });
+            await createTranslatedEmail({ recipientLanguage: null });
+
+            const { result, recipient } = await getUserEmailsViewedIn('en');
+
+            expect(recipient.language).toBeNull();
+            expect(recipient.replacements.find(r => r.token === 'greeting')?.value).toBe(dutchGreeting);
+            expect(result.getSubjectFor(recipient)).toBe('Nederlands onderwerp');
+            expect(result.getHtmlFor(recipient)).toBe(`<p>${dutchGreeting} Nederlandse inhoud</p>`);
+            expect(result.getContentForLanguage(recipient.language).text).toBe('Nederlandse tekst');
+        });
+    });
 });

package/src/endpoints/global/email/GetUserEmailsEndpoint.ts

@@ -5,7 +5,9 @@ import { assertSort, EmailStatus, getSortFilter, LimitedFilteredRequest, mergeFi
 
 import type { Decoder } from '@simonbackx/simple-encoding';
 import { SimpleError } from '@simonbackx/simple-errors';
+import { I18n } from '@stamhoofd/backend-i18n/I18n';
 import { Email, Member } from '@stamhoofd/models';
+import type { Language } from '@stamhoofd/types/Language';
 import type { SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
 import { applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
 import { Context } from '../../../helpers/Context.js';
@@ -103,7 +105,7 @@ export class GetUserEmailsEndpoint extends Endpoint<Params, Query, Body, Respons
         return query;
     }
 
-    static async buildData(requestQuery: LimitedFilteredRequest) {
+    static async buildData(requestQuery: LimitedFilteredRequest, options: { language?: Language | null } = {}) {
         const user = Context.user;
         if (!user) {
             throw new Error('Not authenticated');
@@ -133,7 +135,7 @@ export class GetUserEmailsEndpoint extends Endpoint<Params, Query, Body, Respons
         }
 
         return new PaginatedResponse<EmailWithRecipients[], LimitedFilteredRequest>({
-            results: await Promise.all(emails.map(email => email.getStructureForUser(user, memberIds))),
+            results: await Promise.all(emails.map(email => email.getStructureForUser(user, memberIds, options))),
             next,
         });
     }
@@ -161,7 +163,10 @@ export class GetUserEmailsEndpoint extends Endpoint<Params, Query, Body, Respons
         }
 
         return new Response(
-            await GetUserEmailsEndpoint.buildData(request.query),
+            await GetUserEmailsEndpoint.buildData(request.query, {
+                // The language the caller is viewing in: emails are returned in this language when possible
+                language: I18n.getLanguageFromRequest(request),
+            }),
         );
     }
 }

package/src/endpoints/global/email/PatchEmailEndpoint.test.ts

@@ -1,8 +1,10 @@
 import type { AutoEncoderPatchType } from '@simonbackx/simple-encoding';
+import { PatchMap } from '@simonbackx/simple-encoding';
 import { Request } from '@simonbackx/simple-endpoints';
 import type { Organization, RegistrationPeriod, User } from '@stamhoofd/models';
 import { Email, EmailRecipient, GroupFactory, MemberFactory, OrganizationFactory, RegistrationFactory, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
-import { AccessRight, EmailRecipientFilter, EmailRecipientSubfilter, EmailStatus, Email as EmailStruct, OrganizationEmail, Parent, PermissionLevel, Permissions, PermissionsResourceType, ResourcePermissions, UserPermissions, Version } from '@stamhoofd/structures';
+import { AccessRight, EmailContent, EmailRecipientFilter, EmailRecipientSubfilter, EmailStatus, Email as EmailStruct, OrganizationEmail, Parent, PermissionLevel, Permissions, PermissionsResourceType, ResourcePermissions, UserPermissions, Version } from '@stamhoofd/structures';
+import { Language } from '@stamhoofd/types/Language';
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { testServer } from '../../../../tests/helpers/TestServer.js';
 import { PatchEmailEndpoint } from './PatchEmailEndpoint.js';
@@ -1199,4 +1201,349 @@ describe('Endpoint.PatchEmailEndpoint', () => {
             expect(sentEmail.html).toContain('Identical Email');
         }
     });
+
+    describe('Translations', () => {
+        const createDraftEmail = async (options: { language?: Language } = {}) => {
+            const email = new Email();
+            email.subject = 'Default subject';
+            email.status = EmailStatus.Draft;
+            email.text = 'Default text';
+            email.html = '<p>Default html</p>';
+            email.json = {};
+            email.language = options.language ?? null;
+            email.userId = user.id;
+            email.organizationId = organization.id;
+            email.senderId = sender.id;
+            await email.save();
+            return email;
+        };
+
+        test('the first language can be set without creating a translation', async () => {
+            const email = await createDraftEmail();
+
+            const body = EmailStruct.patch({
+                id: email.id,
+                language: Language.Dutch,
+            });
+
+            const response = await patchEmail(body, token, organization);
+            expect(response.body.language).toBe(Language.Dutch);
+            expect(response.body.translations.size).toBe(0);
+
+            const saved = await Email.getByID(email.id);
+            expect(saved!.language).toBe(Language.Dutch);
+            expect(saved!.translations.size).toBe(0);
+            expect(saved!.subject).toBe('Default subject');
+        });
+
+        test('a translation can be added to a draft email', async () => {
+            const email = await createDraftEmail({ language: Language.Dutch });
+
+            const body = EmailStruct.patch({
+                id: email.id,
+                translations: new PatchMap([[Language.French, EmailContent.create({ subject: 'Sujet français', html: '<p>Français</p>', text: 'Français' })]]),
+            });
+
+            const response = await patchEmail(body, token, organization);
+            expect(response.body.translations.get(Language.French)!.subject).toBe('Sujet français');
+
+            const saved = await Email.getByID(email.id);
+            expect(saved!.translations.get(Language.French)!.subject).toBe('Sujet français');
+            expect(saved!.subject).toBe('Default subject');
+            expect(saved!.language).toBe(Language.Dutch);
+        });
+
+        test('a translation can be removed from a draft email', async () => {
+            const email = await createDraftEmail({ language: Language.Dutch });
+            email.translations = new Map([
+                [Language.French, EmailContent.create({ subject: 'Sujet français' })],
+                [Language.English, EmailContent.create({ subject: 'English subject' })],
+            ]);
+            await email.save();
+
+            const body = EmailStruct.patch({
+                id: email.id,
+                translations: new PatchMap([[Language.French, null]]),
+            });
+
+            await patchEmail(body, token, organization);
+
+            const saved = await Email.getByID(email.id);
+            expect(saved!.translations.size).toBe(1);
+            expect(saved!.translations.get(Language.English)!.subject).toBe('English subject');
+            expect(saved!.language).toBe(Language.Dutch);
+        });
+
+        test('removing the default language applies the move-over patch atomically', async () => {
+            const email = await createDraftEmail({ language: Language.Dutch });
+            email.translations = new Map([
+                [Language.French, EmailContent.create({ subject: 'Sujet français', html: '<p>Français</p>', text: 'Français' })],
+            ]);
+            await email.save();
+
+            // The UI removes the default language by moving the first remaining translation
+            // into the default content in a single patch
+            const body = EmailStruct.patch({
+                id: email.id,
+                language: Language.French,
+                subject: 'Sujet français',
+                html: '<p>Français</p>',
+                text: 'Français',
+                translations: new PatchMap([[Language.French, null]]),
+            });
+
+            await patchEmail(body, token, organization);
+
+            const saved = await Email.getByID(email.id);
+            expect(saved!.language).toBe(Language.French);
+            expect(saved!.subject).toBe('Sujet français');
+            expect(saved!.html).toBe('<p>Français</p>');
+            expect(saved!.translations.size).toBe(0);
+        });
+
+        test('removing the last language keeps the content', async () => {
+            const email = await createDraftEmail({ language: Language.Dutch });
+
+            const body = EmailStruct.patch({
+                id: email.id,
+                language: null,
+            });
+
+            await patchEmail(body, token, organization);
+
+            const saved = await Email.getByID(email.id);
+            expect(saved!.language).toBeNull();
+            expect(saved!.subject).toBe('Default subject');
+            expect(saved!.html).toBe('<p>Default html</p>');
+        });
+
+        test('patching the subject keeps the translations', async () => {
+            const email = await createDraftEmail({ language: Language.Dutch });
+            email.translations = new Map([
+                [Language.French, EmailContent.create({ subject: 'Sujet français' })],
+            ]);
+            await email.save();
+
+            const body = EmailStruct.patch({
+                id: email.id,
+                subject: 'New default subject',
+            });
+
+            await patchEmail(body, token, organization);
+
+            const saved = await Email.getByID(email.id);
+            expect(saved!.subject).toBe('New default subject');
+            expect(saved!.language).toBe(Language.Dutch);
+            expect(saved!.translations.get(Language.French)!.subject).toBe('Sujet français');
+        });
+
+        test('rejects a translation without a default language', async () => {
+            const email = await createDraftEmail();
+
+            const body = EmailStruct.patch({
+                id: email.id,
+                translations: new PatchMap([[Language.French, EmailContent.create({ subject: 'Sujet français' })]]),
+            });
+
+            await expect(patchEmail(body, token, organization))
+                .rejects
+                .toThrow(STExpect.errorWithCode('invalid_translations'));
+        });
+
+        test('rejects a translation for the default language itself', async () => {
+            const email = await createDraftEmail({ language: Language.Dutch });
+
+            const body = EmailStruct.patch({
+                id: email.id,
+                translations: new PatchMap([[Language.Dutch, EmailContent.create({ subject: 'Nederlands onderwerp' })]]),
+            });
+
+            await expect(patchEmail(body, token, organization))
+                .rejects
+                .toThrow(STExpect.errorWithCode('invalid_translations'));
+        });
+
+        test('rejects clearing the default language while translations remain', async () => {
+            const email = await createDraftEmail({ language: Language.Dutch });
+            email.translations = new Map([
+                [Language.French, EmailContent.create({ subject: 'Sujet français' })],
+            ]);
+            await email.save();
+
+            const body = EmailStruct.patch({
+                id: email.id,
+                language: null,
+            });
+
+            await expect(patchEmail(body, token, organization))
+                .rejects
+                .toThrow(STExpect.errorWithCode('invalid_translations'));
+        });
+
+        const createSendableEmail = async () => {
+            const email = new Email();
+            email.subject = 'Default subject';
+            email.status = EmailStatus.Draft;
+            email.text = 'Default text {{unsubscribeUrl}}';
+            email.html = '<!DOCTYPE html><html><body><p>Default html</p>{{unsubscribeUrl}}</body></html>';
+            email.json = {};
+            email.language = Language.Dutch;
+            email.userId = user.id;
+            email.organizationId = organization.id;
+            email.senderId = sender.id;
+            return email;
+        };
+
+        test('cannot send an email with an incomplete translation', async () => {
+            const email = await createSendableEmail();
+            email.translations = new Map([
+                [Language.French, EmailContent.create({ subject: 'Sujet français', text: '', html: '' })],
+            ]);
+            await email.save();
+
+            const body = EmailStruct.patch({ id: email.id, status: EmailStatus.Sending });
+
+            await expect(patchEmail(body, token, organization))
+                .rejects
+                .toThrow(STExpect.errorWithCode('invalid_field'));
+        });
+
+        test('cannot send an email when a translation misses the unsubscribe button', async () => {
+            const email = await createSendableEmail();
+            email.translations = new Map([
+                [Language.French, EmailContent.create({
+                    subject: 'Sujet français',
+                    text: 'Texte français',
+                    html: '<!DOCTYPE html><html><body><p>Français</p></body></html>',
+                })],
+            ]);
+            await email.save();
+
+            const body = EmailStruct.patch({ id: email.id, status: EmailStatus.Sending });
+
+            await expect(patchEmail(body, token, organization))
+                .rejects
+                .toThrow(STExpect.errorWithCode('missing_unsubscribe_button'));
+        });
+    });
+
+    describe('Example recipients per language', () => {
+        // The greeting translations looked up in shared/locales/dist/locales/digit/{nl,fr}-BE.json,
+        // hardcoded on purpose so we don't verify $t with the same $t machinery we're testing
+        const dutchGreeting = 'Dag';
+        const frenchGreeting = 'Bonjour';
+
+        const createDraftEmail = async (options: { language?: Language; translations?: Map<Language, EmailContent> } = {}) => {
+            const email = new Email();
+            email.subject = 'Default subject';
+            email.status = EmailStatus.Draft;
+            email.text = 'Default text';
+            email.html = '<p>Default html</p>';
+            email.json = {};
+            email.language = options.language ?? null;
+            email.translations = options.translations ?? new Map();
+            email.userId = user.id;
+            email.organizationId = organization.id;
+            email.senderId = sender.id;
+            await email.save();
+            return email;
+        };
+
+        const greetingOf = (recipient: { replacements: { token: string; value: string }[] }) => {
+            return recipient.replacements.find(r => r.token === 'greeting')?.value;
+        };
+
+        test('the same example recipient is returned with replacements in every supported language', async () => {
+            TestUtils.setEnvironment('locales', { BE: [Language.Dutch, Language.French] });
+            const email = await createDraftEmail();
+
+            const response = await patchEmail(EmailStruct.patch({ id: email.id }), token, organization);
+            const preview = response.body;
+
+            expect([...preview.exampleRecipients.keys()].sort()).toEqual([Language.Dutch, Language.French].sort());
+
+            const dutch = preview.exampleRecipients.get(Language.Dutch)!;
+            const french = preview.exampleRecipients.get(Language.French)!;
+            expect(dutch.language).toBe(Language.Dutch);
+            expect(french.language).toBe(Language.French);
+
+            // The same recipient in every language: only the replacements differ
+            expect(french.firstName).toBe(dutch.firstName);
+            expect(french.lastName).toBe(dutch.lastName);
+            expect(french.email).toBe(dutch.email);
+
+            expect(greetingOf(dutch)).toBe(`${dutchGreeting} ${dutch.firstName},`);
+            expect(greetingOf(french)).toBe(`${frenchGreeting} ${french.firstName},`);
+
+            // The deprecated single example recipient is still returned
+            expect(preview.exampleRecipient).not.toBeNull();
+            expect(greetingOf(preview.exampleRecipient!)).toBe(`${dutchGreeting} ${dutch.firstName},`);
+        });
+
+        test('every language the email has content for is included when it is supported', async () => {
+            TestUtils.setEnvironment('locales', { BE: [Language.Dutch, Language.French, Language.English] });
+            const email = await createDraftEmail({
+                language: Language.Dutch,
+                translations: new Map([[Language.English, EmailContent.create({ subject: 'English subject', html: '<p>English</p>', text: 'English' })]]),
+            });
+
+            const response = await patchEmail(EmailStruct.patch({ id: email.id }), token, organization);
+            const preview = response.body;
+
+            expect([...preview.exampleRecipients.keys()].sort()).toEqual([Language.Dutch, Language.English, Language.French].sort());
+            const english = preview.exampleRecipients.get(Language.English)!;
+            expect(english.language).toBe(Language.English);
+
+            // The exact English text is machine-generated and can change between locale builds:
+            // assert it was generated in its own language (not in one of the other languages)
+            expect(greetingOf(english)).toBeDefined();
+            expect(greetingOf(english)).not.toBe(greetingOf(preview.exampleRecipients.get(Language.Dutch)!));
+            expect(greetingOf(english)).not.toBe(greetingOf(preview.exampleRecipients.get(Language.French)!));
+        });
+
+        test('a translation in a language the platform no longer supports gets no example recipient', async () => {
+            // Generating it anyway would silently produce values in the corrected (supported)
+            // language, which is more misleading than the frontend falling back
+            TestUtils.setEnvironment('locales', { BE: [Language.Dutch, Language.French] });
+            const email = await createDraftEmail({
+                language: Language.Dutch,
+                translations: new Map([[Language.English, EmailContent.create({ subject: 'English subject', html: '<p>English</p>', text: 'English' })]]),
+            });
+
+            const response = await patchEmail(EmailStruct.patch({ id: email.id }), token, organization);
+            const preview = response.body;
+
+            expect([...preview.exampleRecipients.keys()].sort()).toEqual([Language.Dutch, Language.French].sort());
+        });
+
+        test('the own language of a real example recipient is ignored', async () => {
+            TestUtils.setEnvironment('locales', { BE: [Language.Dutch, Language.French] });
+            const email = await createDraftEmail();
+
+            // A real recipient that received (or will receive) the email in French
+            const recipient = new EmailRecipient();
+            recipient.emailId = email.id;
+            recipient.email = 'jean@example.com';
+            recipient.firstName = 'Jean';
+            recipient.lastName = 'Dupont';
+            recipient.language = Language.French;
+            recipient.organizationId = organization.id;
+            await recipient.save();
+
+            const response = await patchEmail(EmailStruct.patch({ id: email.id }), token, organization);
+            const preview = response.body;
+
+            // The per-language examples ignore the recipient's own language
+            const dutch = preview.exampleRecipients.get(Language.Dutch)!;
+            const french = preview.exampleRecipients.get(Language.French)!;
+            expect(dutch.firstName).toBe('Jean');
+            expect(dutch.language).toBe(Language.Dutch);
+            expect(greetingOf(dutch)).toBe(`${dutchGreeting} Jean,`);
+            expect(greetingOf(french)).toBe(`${frenchGreeting} Jean,`);
+
+            // The deprecated single example recipient still uses its own language
+            expect(preview.exampleRecipient!.language).toBe(Language.French);
+            expect(greetingOf(preview.exampleRecipient!)).toBe(`${frenchGreeting} Jean,`);
+        });
+    });
 });

package/src/endpoints/global/email/PatchEmailEndpoint.ts

@@ -2,7 +2,7 @@ import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { Email, Platform } from '@stamhoofd/models';
 import type { EmailPreview } from '@stamhoofd/structures';
-import { EmailRecipientsStatus, EmailStatus, Email as EmailStruct, PermissionLevel } from '@stamhoofd/structures';
+import { EmailRecipientsStatus, EmailStatus, Email as EmailStruct, PermissionLevel, validateEmailTranslations } from '@stamhoofd/structures';
 
 import type { AutoEncoderPatchType, Decoder } from '@simonbackx/simple-encoding';
 import { patchObject } from '@simonbackx/simple-encoding';
@@ -114,6 +114,25 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             model.json = request.body.json;
         }
 
+        if (request.body.translations !== undefined) {
+            const lang = [...model.translations.keys()];
+            model.translations = patchObject(model.translations, request.body.translations);
+            const after = [...model.translations.keys()];
+
+            if (JSON.stringify(lang.sort()) && JSON.stringify(after.sort())) {
+                rebuild = true;
+            }
+        }
+
+        if (request.body.language !== undefined) {
+            model.language = request.body.language;
+            rebuild = true;
+        }
+
+        if (request.body.translations !== undefined || request.body.language !== undefined) {
+            validateEmailTranslations(model);
+        }
+
         if (request.body.recipientFilter) {
             if (model.status !== EmailStatus.Draft) {
                 throw new SimpleError({
@@ -192,6 +211,6 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             await model.queueForSending();
         }
 
-        return new Response(await model.getPreviewStructure());
+        return new Response(await model.getPreviewStructure({ allLanguages: true }));
     }
 }