@stamhoofd/backend 2.134.0 → 2.135.0

package/src/endpoints/organization/dashboard/organization/SetUitpasClientCredentialsEndpoint.ts

@@ -84,14 +84,7 @@ export class SetUitpasClientCredentialsEndpoint extends Endpoint<Params, Query,
 
         // store the client credentials and store new status in one operation
         if (!reEvaluation) {
-            const valid = await UitpasService.storeIfValid(organization.id, request.body.clientId, request.body.clientSecret);
-            if (!valid) {
-                throw new SimpleError({
-                    message: 'The provided client credentials are not valid',
-                    code: 'invalid_client_credentials',
-                    human: $t('%1BG'),
-                });
-            }
+            await UitpasService.storeIfValid(organization.id, request.body.clientId, request.body.clientSecret);
         }
         organization.meta.uitpasClientCredentialsStatus = UitpasClientCredentialsStatus.NotChecked;
         await organization.save();

package/src/endpoints/organization/dashboard/webshops/PatchWebshopEndpoint.test.ts

@@ -0,0 +1,49 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import { OrganizationFactory, Token, UserFactory, Webshop, WebshopFactory } from '@stamhoofd/models';
+import { PermissionLevel, Permissions, PrivateWebshop, WebshopMetaData } from '@stamhoofd/structures';
+import { Language } from '@stamhoofd/types/Language';
+import { TestUtils } from '@stamhoofd/test-utils';
+
+import { testServer } from '../../../../../tests/helpers/TestServer.js';
+import { PatchWebshopEndpoint } from './PatchWebshopEndpoint.js';
+
+describe('Endpoint.PatchWebshop', () => {
+    const endpoint = new PatchWebshopEndpoint();
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    async function createAdminContext() {
+        const organization = await new OrganizationFactory({}).create();
+        const user = await new UserFactory({
+            organization,
+            permissions: Permissions.create({
+                level: PermissionLevel.Full,
+            }),
+        }).create();
+        const token = await Token.createToken(user);
+
+        return { organization, token };
+    }
+
+    test('defaultLanguage can be updated', async () => {
+        const { organization, token } = await createAdminContext();
+        const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
+
+        const patch = PrivateWebshop.patch({
+            meta: WebshopMetaData.patch({
+                defaultLanguage: Language.French,
+            }),
+        });
+        const request = Request.buildJson('PATCH', '/webshop/' + webshop.id, organization.getApiHost(), patch);
+        request.headers.authorization = 'Bearer ' + token.accessToken;
+
+        const response = await testServer.test(endpoint, request);
+        expect(response.body.meta.defaultLanguage).toBe(Language.French);
+
+        // Persisted in the database
+        const reloaded = await Webshop.getByID(webshop.id);
+        expect(reloaded?.meta.defaultLanguage).toBe(Language.French);
+    });
+});

package/src/endpoints/organization/dashboard/webshops/PatchWebshopOrdersEndpoint.test.ts

@@ -0,0 +1,71 @@
+import type { PatchableArrayAutoEncoder } from '@simonbackx/simple-encoding';
+import { PatchableArray } from '@simonbackx/simple-encoding';
+import { Request } from '@simonbackx/simple-endpoints';
+import { Order, OrganizationFactory, Token, UserFactory, WebshopFactory } from '@stamhoofd/models';
+import { Cart, CartItem, Customer, OrderData, PaymentMethod, PermissionLevel, Permissions, PrivateOrder, Product, ProductPrice, WebshopMetaData } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { Language } from '@stamhoofd/types/Language';
+import { v4 as uuidv4 } from 'uuid';
+
+import { testServer } from '../../../../../tests/helpers/TestServer.js';
+import { PatchWebshopOrdersEndpoint } from './PatchWebshopOrdersEndpoint.js';
+
+describe('Endpoint.PatchWebshopOrders', () => {
+    const endpoint = new PatchWebshopOrdersEndpoint();
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    test('Manually created orders use the webshop default language', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const user = await new UserFactory({
+            organization,
+            permissions: Permissions.create({
+                level: PermissionLevel.Full,
+            }),
+        }).create();
+        const token = await Token.createToken(user);
+
+        const freeProductPrice = ProductPrice.create({ name: 'Free', price: 0, stock: 100 });
+        const product = Product.create({ name: 'Product', stock: 100, prices: [freeProductPrice] });
+
+        const webshop = await new WebshopFactory({
+            organizationId: organization.id,
+            meta: WebshopMetaData.patch({ defaultLanguage: Language.French }),
+            products: [product],
+        }).create();
+
+        const orderData = OrderData.create({
+            paymentMethod: PaymentMethod.Unknown,
+            cart: Cart.create({
+                items: [
+                    CartItem.create({ product, productPrice: freeProductPrice, amount: 1 }),
+                ],
+            }),
+            customer: Customer.create({
+                firstName: 'John',
+                lastName: 'Doe',
+                email: 'john@example.com',
+            }),
+        });
+
+        const patchArray: PatchableArrayAutoEncoder<PrivateOrder> = new PatchableArray();
+        patchArray.addPut(PrivateOrder.create({
+            id: uuidv4(),
+            data: orderData,
+            webshopId: webshop.id,
+        }));
+
+        const r = Request.buildJson('PATCH', `/webshop/${webshop.id}/orders`, organization.getApiHost(), patchArray);
+        r.headers.authorization = 'Bearer ' + token.accessToken;
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toHaveLength(1);
+        expect(response.body[0].consumerLanguage).toEqual(Language.French);
+
+        // Persisted in the dedicated column
+        const orderModel = (await Order.getByID(response.body[0].id))!;
+        expect(orderModel.consumerLanguage).toEqual(Language.French);
+    });
+});

package/src/endpoints/organization/dashboard/webshops/PatchWebshopOrdersEndpoint.ts

@@ -123,6 +123,10 @@ export class PatchWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Re
                 model.status = struct.status;
                 model.data = struct.data;
 
+                // Manually created orders have no customer request language, so use the webshop's
+                // default language for any future emails to this order.
+                model.consumerLanguage = webshop.meta.defaultLanguage;
+
                 // For now, we don't invalidate tickets, because they will get invalidated at scan time (the order status is checked)
                 // This allows you to revalidate a ticket without needing to generate a new one (e.g. when accidentally canceling an order)
                 // -> the user doesn't need to download the ticket again

package/src/endpoints/organization/webshops/GetWebshopEndpoint.test.ts

@@ -1,6 +1,7 @@
 import { Request } from '@simonbackx/simple-endpoints';
 import { OrganizationFactory, Token, UserFactory, WebshopFactory } from '@stamhoofd/models';
 import { PermissionLevel, Permissions, WebshopAuthType, WebshopMetaData } from '@stamhoofd/structures';
+import { Language } from '@stamhoofd/types/Language';
 
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { testServer } from '../../../../tests/helpers/TestServer.js';
@@ -30,6 +31,16 @@ describe('Endpoint.GetWebshop', () => {
         expect((response.body as any).privateMeta).toBeUndefined();
     });
 
+    test('Webshop defaults to Dutch as its default language', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
+
+        const r = Request.buildJson('GET', '/webshop/' + webshop.id, organization.getApiHost());
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body.meta.defaultLanguage).toBe(Language.Dutch);
+    });
+
     test('Allow access without organization scope', async () => {
         const organization = await new OrganizationFactory({}).create();
         const webshop = await new WebshopFactory({ organizationId: organization.id }).create();

package/src/endpoints/organization/webshops/OrderConfirmationEmailLanguage.test.ts

@@ -0,0 +1,70 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import { EmailMocker } from '@stamhoofd/email';
+import { EmailTemplateFactory, OrganizationFactory, WebshopFactory } from '@stamhoofd/models';
+import { Cart, CartItem, Customer, EmailTemplateType, OrderData, PaymentMethod, Product, ProductPrice } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { Country } from '@stamhoofd/types/Country';
+import { Language } from '@stamhoofd/types/Language';
+
+import { testServer } from '../../../../tests/helpers/TestServer.js';
+import { PlaceOrderEndpoint } from './PlaceOrderEndpoint.js';
+
+describe('Order confirmation email language', () => {
+    const endpoint = new PlaceOrderEndpoint();
+
+    test('renders $t in the language the customer used while ordering', async () => {
+        // Make French a valid locale so its real translations (loaded from disk) are actually used.
+        TestUtils.setEnvironment('locales', { [Country.Belgium]: [Language.Dutch, Language.French] });
+
+        const organization = await new OrganizationFactory({}).create();
+        const freeProductPrice = ProductPrice.create({ name: 'Free', price: 0, stock: 100 });
+        const product = Product.create({ name: 'Product', stock: 100, prices: [freeProductPrice] });
+        const webshop = await new WebshopFactory({
+            organizationId: organization.id,
+            products: [product],
+        }).create();
+
+        // Confirmation email template for this webshop (auto-includes {{orderStatus}} etc.)
+        await new EmailTemplateFactory({
+            organization,
+            webshopId: webshop.id,
+            type: EmailTemplateType.OrderConfirmationOnline,
+        }).create();
+
+        // The order status label (OrderStatus.Created) is rendered via $t inside the confirmation
+        // email. These are the 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 dutchStatusName = 'Nieuw';
+        const frenchStatusName = 'Nouveau';
+
+        const placeFreeOrderInLanguage = async (language: string) => {
+            EmailMocker.transactional.reset();
+
+            const orderData = OrderData.create({
+                paymentMethod: PaymentMethod.Unknown,
+                cart: Cart.create({
+                    items: [CartItem.create({ product, productPrice: freeProductPrice, amount: 1 })],
+                }),
+                customer: Customer.create({ firstName: 'John', lastName: 'Doe', email: 'john@example.com', phone: '+32412345678' }),
+            });
+
+            const r = Request.buildJson('POST', `/webshop/${webshop.id}/order`, organization.getApiHost(), orderData);
+            r.headers['accept-language'] = language;
+            await testServer.test(endpoint, r);
+
+            const emails = await EmailMocker.transactional.getSucceededEmails();
+            expect(emails).toHaveLength(1);
+            return emails[0];
+        };
+
+        // French order → the $t status label is rendered in French, without Dutch leaking in
+        const frenchEmail = await placeFreeOrderInLanguage('fr');
+        expect(frenchEmail.html).toContain(frenchStatusName);
+        expect(frenchEmail.html).not.toContain(dutchStatusName);
+
+        // Dutch order → rendered in Dutch, without French leaking in
+        const dutchEmail = await placeFreeOrderInLanguage('nl');
+        expect(dutchEmail.html).toContain(dutchStatusName);
+        expect(dutchEmail.html).not.toContain(frenchStatusName);
+    });
+});

package/src/endpoints/organization/webshops/PlaceOrderEndpoint.test.ts

@@ -6,8 +6,10 @@ import type { Organization, StripeAccount, User } from '@stamhoofd/models';
 import { Order, OrganizationFactory, Payment, Token, UserFactory, Webshop, WebshopFactory } from '@stamhoofd/models';
 import type { OrderResponse } from '@stamhoofd/structures';
 import { Address, Cart, CartItem, CartItemOption, Customer, Option, OptionMenu, OrderData, PaymentConfiguration, PaymentMethod, PermissionLevel, Permissions, PrivateOrder, PrivatePaymentConfiguration, Product, ProductPrice, ProductType, SeatingPlan, SeatingPlanRow, SeatingPlanSeat, SeatingPlanSection, TransferSettings, WebshopAuthType, WebshopDeliveryMethod, WebshopMetaData, WebshopOnSiteMethod, WebshopPrivateMetaData, WebshopTakeoutMethod, WebshopTimeSlot } from '@stamhoofd/structures';
-import { STExpect } from '@stamhoofd/test-utils';
+import { I18n } from '@stamhoofd/backend-i18n';
+import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { Country } from '@stamhoofd/types/Country';
+import { Language } from '@stamhoofd/types/Language';
 import sinon from 'sinon';
 import { v4 as uuidv4 } from 'uuid';
 
@@ -573,4 +575,69 @@ describe('Endpoint.PlaceOrderEndpoint', () => {
             expect(payment.customer!.equals(orderModel.data.customer.toPaymentCustomer())).toBe(true);
         });
     });
+
+    describe('Order language', () => {
+        function buildFreeOrderData() {
+            return OrderData.create({
+                paymentMethod: PaymentMethod.Unknown,
+                checkoutMethod: onSiteMethod,
+                timeSlot: slot4,
+                cart: Cart.create({
+                    items: [
+                        CartItem.create({
+                            product,
+                            productPrice: freeProductPrice,
+                            amount: 1,
+                        }),
+                    ],
+                }),
+                customer,
+            });
+        }
+
+        test('Stores the request language on a placed order', async () => {
+            const r = Request.buildJson('POST', `/webshop/${webshop.id}/order`, organization.getApiHost(), buildFreeOrderData());
+            r.headers['accept-language'] = 'en';
+
+            const response = await testServer.test(endpoint, r);
+            expect(response.body.order.consumerLanguage).toEqual('en');
+
+            // Persisted in the dedicated column
+            const orderModel = (await Order.getByID(response.body.order.id))!;
+            expect(orderModel.consumerLanguage).toEqual('en');
+        });
+
+        test('Falls back to the webshop default language when the request language is unknown', async () => {
+            webshop.meta.defaultLanguage = Language.French;
+            await webshop.save();
+
+            // The struct default is Dutch, so the server-side fallback to the webshop default is observable.
+            const r = Request.buildJson('POST', `/webshop/${webshop.id}/order`, organization.getApiHost(), buildFreeOrderData());
+
+            const response = await testServer.test(endpoint, r);
+            expect(response.body.order.consumerLanguage).toEqual(Language.French);
+
+            const orderModel = (await Order.getByID(response.body.order.id))!;
+            expect(orderModel.consumerLanguage).toEqual(Language.French);
+        });
+
+        test('runWithLocale overrides the global language used for $t evaluation', async () => {
+            // Allow French to be a valid locale for this test (test env has no locales configured).
+            TestUtils.setEnvironment('locales', { [Country.Belgium]: [Language.Dutch, Language.French] });
+
+            const i18n = new I18n(Language.French, Country.Belgium);
+
+            expect(I18n.override).toBeNull();
+            expect((global as any).$getLanguage()).toEqual(Language.Dutch);
+
+            await I18n.runWithLocale(i18n, async () => {
+                expect(I18n.override).toBe(i18n);
+                expect((global as any).$getLanguage()).toEqual(Language.French);
+            });
+
+            // Restored afterwards
+            expect(I18n.override).toBeNull();
+            expect((global as any).$getLanguage()).toEqual(Language.Dutch);
+        });
+    });
 });

package/src/endpoints/organization/webshops/PlaceOrderEndpoint.ts

@@ -3,6 +3,7 @@ import type { Decoder } from '@simonbackx/simple-encoding';
 import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
+import { I18n } from '@stamhoofd/backend-i18n';
 import { Email } from '@stamhoofd/email';
 import { BalanceItem, BalanceItemPayment, MolliePayment, Order, PayconiqPayment, Payment, RateLimiter, Webshop, WebshopDiscountCode } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
@@ -132,6 +133,13 @@ export class PlaceOrderEndpoint extends Endpoint<Params, Query, Body, ResponseBo
 
             const order = new Order().setRelation(Order.webshop, webshop);
             order.data = request.body; // TODO: validate
+
+            // Store the language the customer used while placing the order, so future emails to
+            // this order are rendered in the same language. Fall back to the webshop's default
+            // language when it can't be determined from the request.
+            const consumerLanguage = I18n.getLanguageFromRequest(request) ?? webshop.meta.defaultLanguage;
+            order.consumerLanguage = consumerLanguage;
+
             order.organizationId = organization.id;
             order.createdAt = new Date();
             order.createdAt.setMilliseconds(0);

package/src/helpers/GlobalHelper.ts

@@ -17,7 +17,7 @@ export class GlobalHelper {
 
     static loadGlobalTranslateFunction() {
         function getI18n() {
-            return ContextInstance.optional?.i18n ?? new I18n(I18n.defaultLanguage, STAMHOOFD.fixedCountry ?? I18n.defaultCountry);
+            return I18n.override ?? ContextInstance.optional?.i18n ?? new I18n(I18n.defaultLanguage, STAMHOOFD.fixedCountry ?? I18n.defaultCountry);
         }
         (global as any).$t = (key: string, replace?: Record<string, string>) => getI18n().$t(key, replace);
         (global as any).$getLanguage = () => getI18n().language;

package/src/helpers/MembershipCharger.ts

@@ -2,7 +2,7 @@ import { SimpleError } from '@simonbackx/simple-errors';
 import { BalanceItem, Member, MemberPlatformMembership, Platform, RegistrationPeriod } from '@stamhoofd/models';
 import { SQL, SQLOrderBy, SQLWhereSign } from '@stamhoofd/sql';
 import { BalanceItemRelation, BalanceItemRelationType, BalanceItemType, TranslatedString } from '@stamhoofd/structures';
-import { Formatter } from '@stamhoofd/utility';
+import { Formatter, sleep } from '@stamhoofd/utility';
 
 export const MembershipCharger = {
     async charge() {
@@ -178,6 +178,7 @@ export const MembershipCharger = {
         const chunkSize = 100;
 
         while (true) {
+            await sleep(200);
             const q = MemberPlatformMembership.select()
                 .where('id', SQLWhereSign.Greater, lastId)
                 .where('balanceItemId', null)

package/src/helpers/UitpasTokenRepository.ts

@@ -39,26 +39,27 @@ export class UitpasTokenRepository {
         return await QueueHandler.schedule('uitpas/token-' + (organizationId ?? 'platform'), handler);
     }
 
-    static async storeIfValid(organizationId: string | null, clientId: string, clientSecret: string): Promise<boolean> {
+    static async storeIfValid(organizationId: string | null, clientId: string, clientSecret: string): Promise<void> {
         if (!clientId || !clientSecret) { // empty strings
-            return false; // not valid
+            throw new SimpleError({
+                statusCode: 400,
+                code: 'invalid_uitpas_client_credentials',
+                message: `Empty UiTPAS client credentials`,
+                human: $t(`%ZdU`),
+            });
         }
+
         let model = new UitpasClientCredential();
         model.organizationId = organizationId;
         model.clientId = clientId;
         model.clientSecret = clientSecret;
-        return await UitpasTokenRepository.handleInQueue(organizationId, async () => {
-            let repo = new UitpasTokenRepository(model);
-            try {
-                await repo.getNewAccessToken();
-            } catch (e) {
-                return false; // not valid
-            }
+        await UitpasTokenRepository.handleInQueue(organizationId, async () => {
+            const repo = new UitpasTokenRepository(model);
+            await repo.getNewAccessToken();
             // valid -> store
             model = await UitpasTokenRepository.setModelInDb(organizationId, model);
             repo.uitpasClientCredential = model; // update the uitpasClientCredential in the repo
-            repo = UitpasTokenRepository.setRepoInMemory(organizationId, repo);
-            return true;
+            UitpasTokenRepository.setRepoInMemory(organizationId, repo);
         });
     }
 

package/src/seeds/1783097277-update-member-last-registered.sql

@@ -0,0 +1,6 @@
+UPDATE `members` m
+SET m.lastRegisteredAt = (
+    SELECT MAX(r.registeredAt)
+    FROM registrations r
+    WHERE r.memberId = m.id
+);

package/src/seeds/1783939632-mark-zero-price-payments-succeeded.ts

@@ -0,0 +1,90 @@
+import { Migration } from '@simonbackx/simple-database';
+import { Organization, Payment } from '@stamhoofd/models';
+import { QueryableModel } from '@stamhoofd/sql';
+import { PaymentStatus } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { SeedTools } from '../helpers/SeedTools.js';
+import { PaymentService } from '../services/PaymentService.js';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment === 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    console.log('Start marking zero-price payments as succeeded.');
+
+    let succeeded = 0;
+
+    const result = await SeedTools.loopBatched({
+        // Keyset pagination on id: marking a payment as succeeded drops it from this filter,
+        // but rows are never skipped because each next batch is fetched by id > lastId.
+        query: Payment.select()
+            .where('price', 0)
+            .where('status', [PaymentStatus.Created, PaymentStatus.Pending]),
+        batchSize: 100,
+        batchAction: async (payments: Payment[]) => {
+            // Load the organizations of this batch in bulk
+            const organizationIds = Formatter.uniqueArray(
+                payments.map(p => p.organizationId).filter((id): id is string => id !== null),
+            );
+            const organizations = organizationIds.length ? await Organization.getByIDs(...organizationIds) : [];
+
+            // Load the attached balance item payments of this batch in bulk, and collect the ids of
+            // the payments that move money on at least one balance item. Those need the PaymentService
+            // side effects (marking balance items as paid, flushing caches, ...); the rest can be
+            // updated directly.
+            const { balanceItemPayments } = await Payment.loadBalanceItems(payments);
+            const paymentIdsWithNonZeroBalanceItemPayment = new Set(
+                balanceItemPayments.filter(bip => bip.price !== 0).map(bip => bip.paymentId),
+            );
+
+            for (const payment of payments) {
+                // Only route through the PaymentService when the payment moves money on at least one
+                // balance item. When all attached balance item payments are zero (or there are none),
+                // update the status directly to avoid those side effects.
+                const hasNonZeroBalanceItemPayment = paymentIdsWithNonZeroBalanceItemPayment.has(payment.id);
+
+                try {
+                    if (hasNonZeroBalanceItemPayment) {
+                        if (!payment.organizationId) {
+                            console.warn('Payment without organizationId, skipping', payment.id);
+                            continue;
+                        }
+
+                        const organization = organizations.find(o => o.id === payment.organizationId);
+                        if (!organization) {
+                            console.warn('Organization not found for payment, skipping', payment.id, payment.organizationId);
+                            continue;
+                        }
+
+                        // Attribute the payment to its original date instead of the migration run date.
+                        await PaymentService.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Succeeded, payment.createdAt);
+                    } else {
+                        // No side effects needed: update the status directly.
+                        payment.status = PaymentStatus.Succeeded;
+                        payment.paidAt = payment.createdAt;
+                        await payment.save({
+                            skipMarkSaved: true,
+                            skipSendEvents: true,
+                        });
+                    }
+                    succeeded++;
+                } catch (e) {
+                    // Isolate failures per payment: one bad row should not abort (and wedge) the whole migration.
+                    console.error('Failed to mark payment as succeeded, skipping', payment.id, e);
+                }
+
+                if (QueryableModel.shutdownMigrations) {
+                    break;
+                }
+            }
+
+            if (QueryableModel.shutdownMigrations) {
+                throw new Error('Stopping migration gracefully');
+            }
+        },
+    });
+
+    console.log(`Finished marking zero-price payments as succeeded: ${succeeded} of ${result.total} payments.`);
+});

package/src/services/PaymentService.ts

@@ -1208,16 +1208,38 @@ export class PaymentService {
         privatePaymentConfiguration: PrivatePaymentConfiguration;
         adminUserId?: string | null;
     }) {
-        if (balanceItems.size === 0) {
+        // Balance items that aren't due yet and that aren't being paid now (amount 0) are not part of
+        // this payment: a registration in its trial period is the main example, nothing is due during
+        // the trial. They still have to be marked due and valid, so the registration is activated and
+        // the amount is billed once the trial ends. Marking them via markPaid means the 'paid' side
+        // effects run exactly once (guarded by the paidAt column), also when they are really paid later.
+        //
+        // Items that the caller does pay (a non-zero amount) are always part of the payment, even when
+        // they have a dueAt: balance items that are due soon are part of the outstanding balance and
+        // can be paid before their due date (and are charged by direct debit).
+        const notDueYetBalanceItems = [...balanceItems.keys()].filter(item => item.dueAt !== null && item.dueAt > new Date() && (balanceItems.get(item) ?? 0) === 0);
+        const payableBalanceItems = new Map([...balanceItems].filter(([item]) => !notDueYetBalanceItems.includes(item)));
+
+        // Passing no payment keeps paid: false, so a trial period isn't shortened.
+        const markNotDueYetValid = async () => {
+            for (const balanceItem of notDueYetBalanceItems) {
+                await BalanceItemService.markPaid(balanceItem, null, organization);
+            }
+        };
+
+        if (payableBalanceItems.size === 0) {
+            // Nothing to pay now, so no payment is created. The not-due-yet items still need to be
+            // marked valid, otherwise their registration stays invisible.
+            await markNotDueYetValid();
             return null;
         }
 
         // Calculate total price to pay
-        const { price, roundingAmount, hasNegative, names } = this.calculateTotalPrice({ balanceItems, organization, members });
+        const { price, roundingAmount, hasNegative, names } = this.calculateTotalPrice({ balanceItems: payableBalanceItems, organization, members });
         PaymentService.validateTotalPrice({ price, roundingAmount, checkout });
 
         const { customer, prefix } = await this.validateCustomer({ user, checkout, payingOrganization });
-        this.validateVATRates({ customer, sellingOrganization: organization, balanceItems });
+        this.validateVATRates({ customer, sellingOrganization: organization, balanceItems: payableBalanceItems });
 
         const { method, type, mandate } = await this.validatePaymentMethod({
             method: checkout.paymentMethod ?? PaymentMethod.Unknown,
@@ -1226,7 +1248,7 @@ export class PaymentService {
             customer,
             price,
             hasNegative,
-            balanceItems,
+            balanceItems: payableBalanceItems,
             paymentConfiguration,
             user,
             payingOrganization: payingOrganization ?? null,
@@ -1283,7 +1305,7 @@ export class PaymentService {
 
         payment.provider = provider;
         payment.stripeAccountId = stripeAccount?.id ?? null;
-        await ServiceFeeHelper.setServiceFee(payment, organization, serviceFeeType, [...balanceItems.entries()].map(([_, p]) => p));
+        await ServiceFeeHelper.setServiceFee(payment, organization, serviceFeeType, [...payableBalanceItems.entries()].map(([_, p]) => p));
         await ServiceFeeHelper.setTransferFee({ payment, organization, stripeAccount });
 
         // Add transfer description
@@ -1320,7 +1342,7 @@ export class PaymentService {
         const description = organization.name + ' ' + payment.id;
 
         try {
-            for (const [balanceItem, price] of balanceItems) {
+            for (const [balanceItem, price] of payableBalanceItems) {
                 // Create one balance item payment to pay it in one payment
                 const balanceItemPayment = new BalanceItemPayment();
                 balanceItemPayment.balanceItemId = balanceItem.id;
@@ -1332,7 +1354,7 @@ export class PaymentService {
             }
 
             // Update cached balance items pending amount (only created balance items, because those are involved in the payment)
-            await BalanceItemService.updatePaidAndPending([...balanceItems.keys()]);
+            await BalanceItemService.updatePaidAndPending([...payableBalanceItems.keys()]);
 
             // Update balance items
             if (payment.method === PaymentMethod.Transfer) {
@@ -1445,6 +1467,9 @@ export class PaymentService {
             throw e;
         }
 
+        // The items that aren't due yet are not paid by this payment, so they are marked valid separately
+        await markNotDueYetValid();
+
         // TypeScript thinks status cannot change to Failed, but it can.
         if (payment.status === PaymentStatus.Succeeded || (payment.status as PaymentStatus) === PaymentStatus.Failed) {
             // force update
@@ -1454,7 +1479,7 @@ export class PaymentService {
         } else if (payment.method === PaymentMethod.Transfer || payment.method === PaymentMethod.PointOfSale || payment.method === PaymentMethod.Unknown || (payment.method === PaymentMethod.DirectDebit && mandate)) {
             // Mark valid (not same as paid) if needed
             let hasBundleDiscount = false;
-            for (const [balanceItem] of balanceItems) {
+            for (const [balanceItem] of payableBalanceItems) {
                 // Mark valid
                 await BalanceItemService.markPaid(balanceItem, payment, organization);
 

package/src/services/PlatformMembershipService.ts

@@ -4,7 +4,7 @@ import { Group, Member, MemberPlatformMembership, Organization, Platform, Regist
 import { QueueHandler } from '@stamhoofd/queues';
 import { SQL, SQLWhereSign } from '@stamhoofd/sql';
 import { AuditLogSource, PlatformMembershipTypeBehaviour } from '@stamhoofd/structures';
-import { Formatter, Sorter } from '@stamhoofd/utility';
+import { Formatter, sleep, Sorter } from '@stamhoofd/utility';
 import { AuditLogService } from './AuditLogService.js';
 import { MemberNumberService } from './MemberNumberService.js';
 
@@ -50,6 +50,7 @@ export class PlatformMembershipService {
             console.log('Starting updateAllMemberships');
             await logger.setContext({ tags: ['silent-seed', 'seed'] }, async () => {
                 while (true) {
+                    await sleep(200);
                     const rawMembers = await Member.where({
                         id: {
                             value: id,

package/src/services/RegistrationService.ts

@@ -70,6 +70,11 @@ export const RegistrationService = {
             const registrationMemberRelation = new ManyToOneRelation(Member, 'member');
             registrationMemberRelation.foreignKey = Member.registrations.foreignKey;
             await Document.updateForRegistration(registration.setRelation(registrationMemberRelation, member));
+
+            // update lastRegisteredAt (should not be awaited)
+            member.tryUpdateLastRegisteredAt(registration)
+                // errors should never stop other logic, lastRegisteredAt is only used for sorting
+                .catch(console.error);
         }
 
         // Update group occupancy