@stamhoofd/backend 2.135.0 → 2.136.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.135.0",
+    "version": "2.136.1",
     "type": "module",
     "main": "./dist/index.js",
     "exports": {
@@ -40,6 +40,7 @@
         "lint": "eslint",
         "migrations": "yarn -s build:full && node ./dist/migrations.js",
         "start": "yarn -s build && node --enable-source-maps ./dist/index.js",
+        "typecheck": "tsc --build tsconfig.test.json",
         "test": "vitest",
         "test:coverage": "vitest --coverage",
         "test:reset": "yarn -s build:full && yarn -s test"
@@ -57,20 +58,20 @@
         "@simonbackx/simple-endpoints": "1.21.1",
         "@simonbackx/simple-errors": "1.5.0",
         "@simonbackx/simple-logging": "1.0.1",
-        "@stamhoofd/backend-env": "2.135.0",
-        "@stamhoofd/backend-i18n": "2.135.0",
-        "@stamhoofd/backend-middleware": "2.135.0",
-        "@stamhoofd/crons": "2.135.0",
-        "@stamhoofd/email": "2.135.0",
-        "@stamhoofd/excel-writer": "2.135.0",
-        "@stamhoofd/logging": "2.135.0",
-        "@stamhoofd/models": "2.135.0",
-        "@stamhoofd/object-differ": "2.135.0",
-        "@stamhoofd/queues": "2.135.0",
-        "@stamhoofd/sql": "2.135.0",
-        "@stamhoofd/structures": "2.135.0",
-        "@stamhoofd/types": "2.135.0",
-        "@stamhoofd/utility": "2.135.0",
+        "@stamhoofd/backend-env": "2.136.1",
+        "@stamhoofd/backend-i18n": "2.136.1",
+        "@stamhoofd/backend-middleware": "2.136.1",
+        "@stamhoofd/crons": "2.136.1",
+        "@stamhoofd/email": "2.136.1",
+        "@stamhoofd/excel-writer": "2.136.1",
+        "@stamhoofd/logging": "2.136.1",
+        "@stamhoofd/models": "2.136.1",
+        "@stamhoofd/object-differ": "2.136.1",
+        "@stamhoofd/queues": "2.136.1",
+        "@stamhoofd/sql": "2.136.1",
+        "@stamhoofd/structures": "2.136.1",
+        "@stamhoofd/types": "2.136.1",
+        "@stamhoofd/utility": "2.136.1",
         "archiver": "7.0.1",
         "axios": "1.16.0",
         "base-x": "3.0.11",
@@ -91,7 +92,7 @@
         "stripe": "16.12.0"
     },
     "devDependencies": {
-        "@stamhoofd/test-utils": "2.135.0",
+        "@stamhoofd/test-utils": "2.136.1",
         "@types/cookie": "0.6.0",
         "@types/luxon": "3.7.1",
         "@types/mailparser": "3.4.6",
@@ -107,5 +108,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "df20ecb0e4b10af877d2e37e92e39100afe342e8"
+    "gitHead": "8c3886185fd30008018414c73f88aed6c0cb5185"
 }

package/src/crons/cleanup-orphaned-cached-balances.test.ts

@@ -0,0 +1,88 @@
+import { BalanceItemFactory, CachedBalance, MemberFactory, OrganizationFactory, UserFactory } from '@stamhoofd/models';
+import { ReceivableBalanceType } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { v4 as uuidv4 } from 'uuid';
+
+describe('cron.cleanup-orphaned-cached-balances', () => {
+    beforeEach(() => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    test('deletes cached balances without any balance item and keeps the ones that still have balance items', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const memberWithItem = await new MemberFactory({ organization }).create();
+        const orphanMember = await new MemberFactory({ organization }).create();
+
+        await new BalanceItemFactory({
+            organizationId: organization.id,
+            memberId: memberWithItem.id,
+            amount: 1,
+            unitPrice: 25_00,
+        }).create();
+
+        // Seed cached balances for both members. The orphan member gets a (zero) row even though
+        // it has no balance items.
+        await CachedBalance.updateForMembers(organization.id, [memberWithItem.id, orphanMember.id]);
+
+        // A cached balance of a registration that no longer has balance items
+        const orphanRegistration = new CachedBalance();
+        orphanRegistration.organizationId = organization.id;
+        orphanRegistration.objectId = uuidv4();
+        orphanRegistration.objectType = ReceivableBalanceType.registration;
+        await orphanRegistration.save();
+
+        // A cached balance of a paying organization that no longer has balance items
+        const orphanOrganization = new CachedBalance();
+        orphanOrganization.organizationId = organization.id;
+        orphanOrganization.objectId = uuidv4();
+        orphanOrganization.objectType = ReceivableBalanceType.organization;
+        await orphanOrganization.save();
+
+        // Sanity check: all rows exist before cleanup
+        expect(await CachedBalance.getForObjects([orphanMember.id], organization.id, ReceivableBalanceType.member)).toHaveLength(1);
+
+        await CachedBalance.deleteOrphaned();
+
+        // The member with a balance item is kept
+        const remainingMembers = await CachedBalance.getForObjects(
+            [memberWithItem.id, orphanMember.id],
+            organization.id,
+            ReceivableBalanceType.member,
+        );
+        expect(remainingMembers.map(b => b.objectId)).toEqual([memberWithItem.id]);
+
+        // The orphaned registration and organization cached balances are deleted
+        expect(await CachedBalance.getByID(orphanRegistration.id)).toBeUndefined();
+        expect(await CachedBalance.getByID(orphanOrganization.id)).toBeUndefined();
+    });
+
+    test('keeps a user cached balance when a linked member still has balance items, but removes the user-without-members row', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const user = await new UserFactory({ organization }).create();
+        const member = await new MemberFactory({ organization, user }).create();
+
+        // The balance item belongs to the member, not directly to the user
+        await new BalanceItemFactory({
+            organizationId: organization.id,
+            memberId: member.id,
+            amount: 1,
+            unitPrice: 40_00,
+        }).create();
+
+        await CachedBalance.updateForMembers(organization.id, [member.id]);
+        await CachedBalance.updateForUsers(organization.id, [user.id]);
+
+        // Both a 'user' and a 'userWithoutMembers' row are created for the user
+        const before = await CachedBalance.getForObjects([user.id], organization.id);
+        expect(before.map(b => b.objectType).sort()).toEqual(
+            [ReceivableBalanceType.user, ReceivableBalanceType.userWithoutMembers].sort(),
+        );
+
+        await CachedBalance.deleteOrphaned();
+
+        // The 'user' row is kept (the linked member still has balance items), the
+        // 'userWithoutMembers' row is deleted (the user has no direct balance items)
+        const after = await CachedBalance.getForObjects([user.id], organization.id);
+        expect(after.map(b => b.objectType)).toEqual([ReceivableBalanceType.user]);
+    });
+});

package/src/crons/cleanup-orphaned-cached-balances.ts

@@ -0,0 +1,44 @@
+/**
+ * Cached balances are only recalculated for objects that still have balance items. When all the
+ * balance items of an object are moved or removed (for example when a member is merged into
+ * another member), its cached balance is left behind. This cron cleans up those orphaned rows.
+ */
+
+import { registerCron } from '@stamhoofd/crons';
+import { CachedBalance } from '@stamhoofd/models';
+
+let lastRunDate: number | null = null;
+
+registerCron('cleanupOrphanedCachedBalances', cleanupOrphanedCachedBalances);
+
+function shouldRun() {
+    const now = new Date();
+
+    if (now.getDate() === lastRunDate) {
+        return false;
+    }
+
+    const hour = now.getHours();
+
+    // between 3 and 4 AM - except in development
+    if (hour !== 3 && STAMHOOFD.environment !== 'development') {
+        return false;
+    }
+
+    return true;
+}
+
+/**
+ * Delete cached balances that no longer have any balance item attached to them.
+ * Runs once a day between 3 and 4 AM.
+ */
+async function cleanupOrphanedCachedBalances() {
+    if (!shouldRun()) {
+        return;
+    }
+
+    lastRunDate = new Date().getDate();
+
+    const deleted = await CachedBalance.deleteOrphaned();
+    console.log(`Deleted ${deleted} orphaned cached balances.`);
+}

package/src/crons/index.ts

@@ -2,6 +2,7 @@ import './amazon-ses.js';
 import './clearExcelCache.js';
 import './endFunctionsOfUsersWithoutRegistration.js';
 import './update-cached-balances.js';
+import './cleanup-orphaned-cached-balances.js';
 import './balance-emails.js';
 import './delete-old-email-drafts.js';
 import './delete-archived-data.js';

package/src/email-recipient-loaders/orders.ts

@@ -1,4 +1,4 @@
-import { Email, Webshop } from '@stamhoofd/models';
+import { Email, runWithRecipientLocale, Webshop } from '@stamhoofd/models';
 import type { EmailRecipient, LimitedFilteredRequest, WebshopPreview } from '@stamhoofd/structures';
 import { mergeFilters, PaginatedResponse } from '@stamhoofd/structures';
 import { GetWebshopOrdersEndpoint } from '../endpoints/organization/dashboard/webshops/GetWebshopOrdersEndpoint.js';
@@ -7,14 +7,12 @@ import { Context } from '../helpers/Context.js';
 import { EmailRecipientFilterType } from '@stamhoofd/structures/email/EmailRecipientFilterType.js';
 
 Email.recipientLoaders.set(EmailRecipientFilterType.Orders, {
-    fetch: async (query: LimitedFilteredRequest) => {
-        // #region get organization struct
+    fetch: async (query: LimitedFilteredRequest, _subfilter, _beforeFetchAllResult, options) => {
         const organization = Context.organization;
         if (organization === undefined) {
             throw new Error('Organization is undefined');
         }
         const organizationStruct = organization.getBaseStructure();
-        // #endregion
 
         const result = await GetWebshopOrdersEndpoint.buildData(query);
 
@@ -32,17 +30,17 @@ Email.recipientLoaders.set(EmailRecipientFilterType.Orders, {
 
             webshopPreviewMap.set(webshopId, AuthenticatedStructures.webshopPreview(webshop));
         }
-        // #endregion
 
-        // #region get recipients
         const recipients: EmailRecipient[] = [];
 
         for (const order of result.results) {
-            // todo: filter double emails? => should probably happen in query?
             const webshopPreview = webshopPreviewMap.get(order.webshopId)!;
-            recipients.push(order.getEmailRecipient(organizationStruct, webshopPreview));
+            runWithRecipientLocale({ language: order.consumerLanguage }, organization, (i18n) => {
+                const r = order.getEmailRecipient(organizationStruct, webshopPreview);
+                r.language = i18n.language;
+                recipients.push(r);
+            }, options);
         }
-        // #endregion
 
         return new PaginatedResponse({
             results: recipients,

package/src/endpoints/admin/memberships/GetChargeMembershipsSummaryEndpoint.test.ts

@@ -0,0 +1,95 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import type { Member, Organization, RegistrationPeriod, Token } from '@stamhoofd/models';
+import { MemberFactory, MemberPlatformMembership, OrganizationFactory, Platform, RegistrationPeriodFactory } from '@stamhoofd/models';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { v4 as uuidv4 } from 'uuid';
+import { testServer } from '../../../../tests/helpers/TestServer.js';
+import { initPlatformAdmin } from '../../../../tests/init/index.js';
+import { GetChargeMembershipsSummaryEndpoint } from './GetChargeMembershipsSummaryEndpoint.js';
+
+describe('Endpoint.GetChargeMembershipsSummary', () => {
+    const endpoint = new GetChargeMembershipsSummaryEndpoint();
+    const membershipPrice = 25_00;
+
+    let currentPeriod: RegistrationPeriod;
+    let nextPeriod: RegistrationPeriod;
+    let membershipOrganization: Organization;
+    let payingOrganization: Organization;
+
+    const getSummary = async (token: Token) => {
+        const request = Request.get({
+            path: '/admin/charge-memberships/summary',
+            // Platform admins are not scoped to an organization, so no host is required
+            host: '',
+            headers: {
+                authorization: 'Bearer ' + token.accessToken,
+            },
+        });
+        const response = await testServer.test(endpoint, request);
+        return response.body;
+    };
+
+    // Creates an uncharged (not yet invoiced) membership that should show up in the summary
+    const createUnchargedMembership = async (period: RegistrationPeriod, organization: Organization, member: Member) => {
+        const membership = new MemberPlatformMembership();
+        membership.memberId = member.id;
+        membership.membershipTypeId = uuidv4();
+        membership.organizationId = organization.id;
+        membership.periodId = period.id;
+        membership.startDate = period.startDate;
+        membership.endDate = period.endDate;
+        membership.price = membershipPrice;
+        await membership.save();
+        return membership;
+    };
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    beforeAll(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+
+        currentPeriod = await new RegistrationPeriodFactory({
+            startDate: new Date(2024, 0, 1, 0, 0, 0, 0),
+            endDate: new Date(2024, 11, 31, 23, 59, 59, 0),
+        }).create();
+
+        nextPeriod = await new RegistrationPeriodFactory({
+            startDate: new Date(2025, 0, 1, 0, 0, 0, 0),
+            endDate: new Date(2025, 11, 31, 23, 59, 59, 0),
+        }).create();
+
+        membershipOrganization = await new OrganizationFactory({}).create();
+        payingOrganization = await new OrganizationFactory({}).create();
+
+        const platform = await Platform.getForEditing();
+        platform.periodId = currentPeriod.id;
+        platform.nextPeriodId = nextPeriod.id;
+        platform.membershipOrganizationId = membershipOrganization.id;
+        await platform.save();
+    });
+
+    test('Excludes next period memberships from the charge summary total', async () => {
+        const { adminToken } = await initPlatformAdmin();
+
+        // Use deltas relative to a baseline, so the test is robust to memberships created elsewhere
+        const before = await getSummary(adminToken);
+
+        // A membership in the next period should not be counted
+        const nextMember = await new MemberFactory({}).create();
+        await createUnchargedMembership(nextPeriod, payingOrganization, nextMember);
+
+        const afterNextPeriod = await getSummary(adminToken);
+        expect(afterNextPeriod.memberships).toBe(before.memberships);
+        expect(afterNextPeriod.price).toBe(before.price);
+
+        // A membership in the current period should be counted
+        const currentMember = await new MemberFactory({}).create();
+        await createUnchargedMembership(currentPeriod, payingOrganization, currentMember);
+
+        const afterCurrentPeriod = await getSummary(adminToken);
+        expect(afterCurrentPeriod.memberships).toBe(before.memberships + 1);
+        expect(afterCurrentPeriod.price).toBe(before.price + membershipPrice);
+    });
+});

package/src/endpoints/admin/memberships/GetChargeMembershipsSummaryEndpoint.ts

@@ -111,6 +111,13 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
             query.whereNot(noTrial);
         }
 
+        const platform = await Platform.getShared();
+        const nextPeriodId = platform.nextPeriodId;
+
+        if (nextPeriodId) {
+            query.where('periodId', '!=', nextPeriodId);
+        }
+
         const result = await query.fetch();
         const members = result[0]['data']['members'] as number;
         const memberships = result[0]['data']['memberships'] as number;

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

@@ -3,7 +3,7 @@ import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { Email, Platform, RateLimiter } from '@stamhoofd/models';
 import type { EmailPreview } from '@stamhoofd/structures';
-import { EmailStatus, Email as EmailStruct, EmailTemplate as EmailTemplateStruct } from '@stamhoofd/structures';
+import { EmailStatus, Email as EmailStruct, EmailTemplate as EmailTemplateStruct, validateEmailTranslations } from '@stamhoofd/structures';
 
 import { Context } from '../../../helpers/Context.js';
 import { SimpleError } from '@simonbackx/simple-errors';
@@ -83,6 +83,9 @@ export class CreateEmailEndpoint extends Endpoint<Params, Query, Body, ResponseB
         model.html = request.body.html;
         model.text = request.body.text;
         model.json = request.body.json;
+        model.translations = request.body.translations;
+        model.language = request.body.language;
+        validateEmailTranslations(model);
         model.status = request.body.status;
         model.attachments = request.body.attachments;
         model.sendAsEmail = request.body.sendAsEmail ?? true;
@@ -159,6 +162,6 @@ export class CreateEmailEndpoint extends Endpoint<Params, Query, Body, ResponseB
             await duplicate.save();
         }
 
-        return new Response(await model.getPreviewStructure());
+        return new Response(await model.getPreviewStructure({ allLanguages: true }));
     }
 }

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

@@ -158,7 +158,7 @@ export class GetAdminEmailsEndpoint extends Endpoint<Params, Query, Body, Respon
         }
 
         return new PaginatedResponse<EmailPreview[], LimitedFilteredRequest>({
-            results: await Promise.all(emails.map(email => email.getPreviewStructure())),
+            results: await Promise.all(emails.map(email => email.getPreviewStructure({ allLanguages: true }))),
             next,
         });
     }

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

@@ -51,6 +51,6 @@ export class GetEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBody
             throw Context.auth.error();
         }
 
-        return new Response(await model.getPreviewStructure());
+        return new Response(await model.getPreviewStructure({ allLanguages: true }));
     }
 }

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),
+            }),
         );
     }
 }