@stamhoofd/backend 2.134.0 → 2.136.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.134.0",
+    "version": "2.136.0",
     "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.134.0",
-        "@stamhoofd/backend-i18n": "2.134.0",
-        "@stamhoofd/backend-middleware": "2.134.0",
-        "@stamhoofd/crons": "2.134.0",
-        "@stamhoofd/email": "2.134.0",
-        "@stamhoofd/excel-writer": "2.134.0",
-        "@stamhoofd/logging": "2.134.0",
-        "@stamhoofd/models": "2.134.0",
-        "@stamhoofd/object-differ": "2.134.0",
-        "@stamhoofd/queues": "2.134.0",
-        "@stamhoofd/sql": "2.134.0",
-        "@stamhoofd/structures": "2.134.0",
-        "@stamhoofd/types": "2.134.0",
-        "@stamhoofd/utility": "2.134.0",
+        "@stamhoofd/backend-env": "2.136.0",
+        "@stamhoofd/backend-i18n": "2.136.0",
+        "@stamhoofd/backend-middleware": "2.136.0",
+        "@stamhoofd/crons": "2.136.0",
+        "@stamhoofd/email": "2.136.0",
+        "@stamhoofd/excel-writer": "2.136.0",
+        "@stamhoofd/logging": "2.136.0",
+        "@stamhoofd/models": "2.136.0",
+        "@stamhoofd/object-differ": "2.136.0",
+        "@stamhoofd/queues": "2.136.0",
+        "@stamhoofd/sql": "2.136.0",
+        "@stamhoofd/structures": "2.136.0",
+        "@stamhoofd/types": "2.136.0",
+        "@stamhoofd/utility": "2.136.0",
         "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.134.0",
+        "@stamhoofd/test-utils": "2.136.0",
         "@types/cookie": "0.6.0",
         "@types/luxon": "3.7.1",
         "@types/mailparser": "3.4.6",
@@ -107,5 +108,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "42955365bcf0bcfd0815998c1039e23d6ee1d6c6"
+    "gitHead": "0adab3f0a2aac8470c58ac717c3d96a824e5f935"
 }

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/auth/VerifyEmailEndpoint.test.ts

@@ -0,0 +1,154 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import { AuditLog, EmailVerificationCode, OrganizationFactory, Token, User, UserFactory } from '@stamhoofd/models';
+import type { Organization } from '@stamhoofd/models';
+import { AuditLogType, PermissionLevel, PermissionRole, Permissions, Token as TokenStruct } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+
+import { testServer } from '../../../tests/helpers/TestServer.js';
+import { VerifyEmailEndpoint } from './VerifyEmailEndpoint.js';
+
+describe('Endpoint.VerifyEmail', () => {
+    const endpoint = new VerifyEmailEndpoint();
+
+    beforeEach(() => {
+        TestUtils.setEnvironment('userMode', 'organization');
+    });
+
+    /**
+     * Create a user with permissions for the given organization.
+     */
+    async function createUserWithPermissions(organization: Organization, email: string, permissions?: Permissions) {
+        return await new UserFactory({
+            organization,
+            email,
+            permissions,
+        }).create();
+    }
+
+    /**
+     * Build a verification code for the given user that will change the user's email to `newEmail`
+     * on verification, and run the endpoint with it.
+     */
+    async function verifyEmail(organization: Organization, user: User, newEmail: string) {
+        const code = await EmailVerificationCode.createFor(user, newEmail);
+
+        const request = Request.buildJson('POST', '/verify-email', organization.getApiHost(), {
+            token: code.token,
+            code: code.code,
+        });
+
+        return await testServer.test(endpoint, request);
+    }
+
+    test('merges the permissions of the deleted user into the kept user', async () => {
+        const organization = await new OrganizationFactory({}).create();
+
+        // The user that keeps existing and changes its email to the other user's email
+        const keptUser = await createUserWithPermissions(organization, 'kept@example.com', Permissions.create({
+            roles: [PermissionRole.create({ id: 'role-a', name: 'Role A' })],
+        }));
+
+        // The user that will be found by its email and merged into (and deleted)
+        const otherUser = await createUserWithPermissions(organization, 'other@example.com', Permissions.create({
+            level: PermissionLevel.Full,
+            roles: [PermissionRole.create({ id: 'role-b', name: 'Role B' })],
+        }));
+
+        const response = await verifyEmail(organization, keptUser, otherUser.email);
+        expect(response.status).toBe(200);
+
+        // The other user is deleted
+        expect(await User.getByID(otherUser.id)).toBeUndefined();
+
+        // The kept user now holds both users' permissions for the organization
+        const refreshed = await User.getByID(keptUser.id);
+        expect(refreshed).toBeDefined();
+        expect(refreshed!.email).toBe('other@example.com');
+
+        const merged = refreshed!.permissions!.organizationPermissions.get(organization.id);
+        expect(merged).toBeDefined();
+        expect(merged!.level).toBe(PermissionLevel.Full);
+        expect(merged!.roles.map(r => r.id).sort()).toEqual(['role-a', 'role-b']);
+    });
+
+    test('adopts the permissions of the deleted user when the kept user has none', async () => {
+        const organization = await new OrganizationFactory({}).create();
+
+        // The kept user has no permissions
+        const keptUser = await createUserWithPermissions(organization, 'kept@example.com');
+        expect(keptUser.permissions).toBeNull();
+
+        const otherUser = await createUserWithPermissions(organization, 'other@example.com', Permissions.create({
+            roles: [PermissionRole.create({ id: 'role-b', name: 'Role B' })],
+        }));
+
+        const response = await verifyEmail(organization, keptUser, otherUser.email);
+        expect(response.status).toBe(200);
+
+        expect(await User.getByID(otherUser.id)).toBeUndefined();
+
+        const refreshed = await User.getByID(keptUser.id);
+        const merged = refreshed!.permissions?.organizationPermissions.get(organization.id);
+        expect(merged).toBeDefined();
+        expect(merged!.roles.map(r => r.id)).toEqual(['role-b']);
+    });
+
+    test('reassigns audit logs of the deleted user to the kept user', async () => {
+        const organization = await new OrganizationFactory({}).create();
+
+        const keptUser = await createUserWithPermissions(organization, 'kept@example.com');
+        const otherUser = await createUserWithPermissions(organization, 'other@example.com');
+
+        // An audit log performed by the user that will be deleted
+        const auditLog = new AuditLog();
+        auditLog.type = AuditLogType.Unknown;
+        auditLog.userId = otherUser.id;
+        auditLog.organizationId = organization.id;
+        auditLog.description = 'Performed by the other user';
+        await auditLog.save();
+
+        const response = await verifyEmail(organization, keptUser, otherUser.email);
+        expect(response.status).toBe(200);
+
+        expect(await User.getByID(otherUser.id)).toBeUndefined();
+
+        // The audit log is now attributed to the kept user
+        const refreshedLog = await AuditLog.getByID(auditLog.id);
+        expect(refreshedLog).toBeDefined();
+        expect(refreshedLog!.userId).toBe(keptUser.id);
+    });
+
+    test('verifies the email and returns a valid token when merging without throwing', async () => {
+        const organization = await new OrganizationFactory({}).create();
+
+        const keptUser = await createUserWithPermissions(organization, 'kept@example.com', Permissions.create({
+            roles: [PermissionRole.create({ id: 'role-a', name: 'Role A' })],
+        }));
+        const otherUser = await createUserWithPermissions(organization, 'other@example.com', Permissions.create({
+            roles: [PermissionRole.create({ id: 'role-b', name: 'Role B' })],
+        }));
+
+        // Also add an audit log to exercise all merge branches together
+        const auditLog = new AuditLog();
+        auditLog.type = AuditLogType.Unknown;
+        auditLog.userId = otherUser.id;
+        auditLog.organizationId = organization.id;
+        await auditLog.save();
+
+        const response = await verifyEmail(organization, keptUser, otherUser.email);
+
+        expect(response.body).toBeInstanceOf(TokenStruct);
+        if (!(response.body instanceof TokenStruct)) {
+            throw new Error('Expected TokenStruct');
+        }
+
+        // The returned token belongs to the kept user
+        const token = await Token.getByAccessToken(response.body.accessToken);
+        expect(token).toBeDefined();
+        expect(token!.user.id).toBe(keptUser.id);
+
+        const refreshed = await User.getByID(keptUser.id);
+        expect(refreshed!.verified).toBe(true);
+        expect(refreshed!.email).toBe('other@example.com');
+    });
+});

package/src/endpoints/auth/VerifyEmailEndpoint.ts

@@ -6,6 +6,7 @@ import { EmailVerificationCode, Token, User } from '@stamhoofd/models';
 import { Token as TokenStruct, VerifyEmailRequest } from '@stamhoofd/structures';
 
 import { Context } from '../../helpers/Context.js';
+import { BalanceItemService } from '../../services/BalanceItemService.js';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -77,6 +78,9 @@ export class VerifyEmailEndpoint extends Endpoint<Params, Query, Body, ResponseB
             if (other) {
                 // Delete the other user, but merge data
                 await user.merge(other);
+                if (user.organizationId) {
+                    BalanceItemService.scheduleUserUpdate(user.organizationId, user.id);
+                }
             }
 
             // change user email

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