@stamhoofd/backend 2.133.0 → 2.135.0

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/StripeInvoicer.ts

@@ -235,7 +235,7 @@ export class StripeReportInvoicer {
                 sellingOrganization,
                 type: 'services',
             });
-            item.VATIncluded = true;
+            item.VATIncluded = !item.VATExcempt; // Makes sure price with VAT always matches the charged amount
             item.quantity = 1;
             item.unitPrice = applicationFee.serviceFee;
             item.createdAt = new Date();
@@ -265,7 +265,7 @@ export class StripeReportInvoicer {
                 sellingOrganization,
                 type: 'services',
             });
-            item.VATIncluded = true;
+            item.VATIncluded = !item.VATExcempt; // Makes sure price with VAT always matches the charged amount
             item.quantity = 1;
             item.unitPrice = applicationFee.transferFee;
             item.createdAt = new Date();
@@ -276,6 +276,17 @@ export class StripeReportInvoicer {
             balanceItems.push(item);
         }
 
+        let total = 0;
+        for (const balanceItem of balanceItems) {
+            total += balanceItem.priceWithVAT;
+        }
+        if (total !== applicationFee.amount) {
+            throw new SimpleError({
+                code: 'price_mismatched',
+                message: 'The charged amount does not match the total application fee for the payment',
+            });
+        }
+
         const systemUser = await User.getSystem();
 
         // Done validation

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

package/src/services/uitpas/UitpasService.ts

@@ -368,14 +368,13 @@ export class UitpasService {
     }
 
     /**
-     * Store the uitpas client credentials if they are valid
+     * Store the uitpas client credentials if they are valid, throws otherwise
      * @param organizationId null for platform
      * @param clientId
      * @param clientSecret
-     * @returns wether the credentials were valid and thus stored successfully
      */
-    static async storeIfValid(organizationId: string | null, clientId: string, clientSecret: string): Promise<boolean> {
-        return await UitpasTokenRepository.storeIfValid(organizationId, clientId, clientSecret);
+    static async storeIfValid(organizationId: string | null, clientId: string, clientSecret: string): Promise<void> {
+        await UitpasTokenRepository.storeIfValid(organizationId, clientId, clientSecret);
     }
 
     static async clearClientCredentialsFor(organizationId: string | null) {

package/src/services/uitpas/checkPermissionsFor.ts

@@ -74,7 +74,7 @@ export async function checkPermissionsFor(access_token: string, organizationId:
         });
     });
     assertIsPermissionsResponse(json);
-    const neededPermissions = organizationId
+    const neededPermissions = !organizationId
         ? [{
                 permission: 'PASSES_READ',
                 human: 'Basis UiTPAS informatie ophalen met UiTPAS nummer',

package/src/sql-filters/balance-item-payments.ts

@@ -1,5 +1,6 @@
 import type { SQLFilterDefinitions } from '@stamhoofd/sql';
-import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLValueType } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLValueType } from '@stamhoofd/sql';
+import { balanceItemFilterCompilers } from './balance-items.js';
 
 export const balanceItemPaymentsCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
@@ -13,59 +14,6 @@ export const balanceItemPaymentsCompilers: SQLFilterDefinitions = {
         type: SQLValueType.Number,
         nullable: false,
     }),
-    balanceItem: {
-        ...baseSQLFilterCompilers,
-        id: createColumnFilter({
-            expression: SQL.column('balance_items', 'id'),
-            type: SQLValueType.String,
-            nullable: false,
-        }),
-        description: createColumnFilter({
-            expression: SQL.column('balance_items', 'description'),
-            type: SQLValueType.String,
-            nullable: false,
-        }),
-        payingOrganizationId: createColumnFilter({
-            expression: SQL.column('balance_items', 'payingOrganizationId'),
-            type: SQLValueType.String,
-            nullable: true,
-        }),
-        type: createColumnFilter({
-            expression: SQL.column('balance_items', 'type'),
-            type: SQLValueType.String,
-            nullable: false,
-        }),
-        registration: createExistsFilter(
-            SQL.select()
-                .from(SQL.table('registrations'))
-                .where(
-                    SQL.column('registrations', 'id'),
-                    SQL.column('balance_items', 'registrationId'),
-                ),
-            {
-                ...baseSQLFilterCompilers,
-                groupId: createColumnFilter({
-                    expression: SQL.column('registrations', 'groupId'),
-                    type: SQLValueType.String,
-                    nullable: false,
-                }),
-            },
-        ),
-        order: createExistsFilter(
-            SQL.select()
-                .from(SQL.table('webshop_orders'))
-                .where(
-                    SQL.column('webshop_orders', 'id'),
-                    SQL.column('balance_items', 'orderId'),
-                ),
-            {
-                ...baseSQLFilterCompilers,
-                webshopId: createColumnFilter({
-                    expression: SQL.column('webshop_orders', 'webshopId'),
-                    type: SQLValueType.String,
-                    nullable: false,
-                }),
-            },
-        ),
-    },
+    // Reuse the shared balance item filters (type, webshop, group, membership type, ...)
+    balanceItem: balanceItemFilterCompilers,
 };

package/src/sql-filters/balance-items.ts

@@ -1,56 +1,115 @@
 import type { SQLFilterDefinitions } from '@stamhoofd/sql';
-import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLValueType } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLValueType } from '@stamhoofd/sql';
+import { BalanceItemRelationType } from '@stamhoofd/structures';
+
+/**
+ * Filters on the relations of a balance item (registration group, webshop order and membership type).
+ *
+ * Grouped separately from the plain column filters because these are JOIN/JSON based rather than simple
+ * columns. They are spread into balanceItemFilterCompilers below, which is the single set consumed both
+ * by the direct balance items endpoint and by the balance items nested inside payments (see
+ * balance-item-payments.ts) — so both automatically expose these relation filters.
+ *
+ * All expressions are qualified with the balance_items table so they keep working when balance_items
+ * is joined into another query (e.g. via balance_item_payments).
+ */
+export const balanceItemRelationFilterCompilers: SQLFilterDefinitions = {
+    registration: createExistsFilter(
+        SQL.select()
+            .from(SQL.table('registrations'))
+            .where(
+                SQL.column('registrations', 'id'),
+                SQL.column('balance_items', 'registrationId'),
+            ),
+        {
+            ...baseSQLFilterCompilers,
+            groupId: createColumnFilter({
+                expression: SQL.column('registrations', 'groupId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+        },
+    ),
+    order: createExistsFilter(
+        SQL.select()
+            .from(SQL.table('webshop_orders'))
+            .where(
+                SQL.column('webshop_orders', 'id'),
+                SQL.column('balance_items', 'orderId'),
+            ),
+        {
+            ...baseSQLFilterCompilers,
+            webshopId: createColumnFilter({
+                expression: SQL.column('webshop_orders', 'webshopId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+        },
+    ),
+    // The membership type is only stored inside the relations JSON, so we read its id from there.
+    membershipType: createColumnFilter({
+        expression: SQL.jsonExtract(SQL.column('balance_items', 'relations'), `$.value.${BalanceItemRelationType.MembershipType}.id`),
+        type: SQLValueType.JSONString,
+        nullable: true,
+    }),
+};
 
 /**
  * Defines how to filter balance items in the database from StamhoofdFilter objects
  */
 export const balanceItemFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
+    ...balanceItemRelationFilterCompilers,
     id: createColumnFilter({
-        expression: SQL.column('id'),
+        expression: SQL.column('balance_items', 'id'),
         type: SQLValueType.String,
         nullable: false,
     }),
     organizationId: createColumnFilter({
-        expression: SQL.column('organizationId'),
+        expression: SQL.column('balance_items', 'organizationId'),
         type: SQLValueType.String,
         nullable: false,
     }),
+    payingOrganizationId: createColumnFilter({
+        expression: SQL.column('balance_items', 'payingOrganizationId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
     type: createColumnFilter({
-        expression: SQL.column('type'),
+        expression: SQL.column('balance_items', 'type'),
         type: SQLValueType.String,
         nullable: false,
     }),
     status: createColumnFilter({
-        expression: SQL.column('status'),
+        expression: SQL.column('balance_items', 'status'),
         type: SQLValueType.String,
         nullable: false,
     }),
     createdAt: createColumnFilter({
-        expression: SQL.column('createdAt'),
+        expression: SQL.column('balance_items', 'createdAt'),
         type: SQLValueType.Datetime,
         nullable: false,
     }),
     updatedAt: createColumnFilter({
-        expression: SQL.column('updatedAt'),
+        expression: SQL.column('balance_items', 'updatedAt'),
         type: SQLValueType.Datetime,
         nullable: false,
     }),
 
     description: createColumnFilter({
-        expression: SQL.column('description'),
+        expression: SQL.column('balance_items', 'description'),
         type: SQLValueType.String,
         nullable: false,
     }),
 
     priceWithVAT: createColumnFilter({
-        expression: SQL.column('priceTotal'),
+        expression: SQL.column('balance_items', 'priceTotal'),
         type: SQLValueType.Number,
         nullable: false,
     }),
 
     priceOpen: createColumnFilter({
-        expression: SQL.column('priceOpen'),
+        expression: SQL.column('balance_items', 'priceOpen'),
         type: SQLValueType.Number,
         nullable: false,
     }),