@stamhoofd/backend 2.116.0 → 2.117.0

package/src/endpoints/global/registration/RegisterMembersEndpoint.ts

@@ -205,6 +205,8 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
 
         const platformMembers: PlatformMember[] = [];
 
+        let payingOrganization: Organization | null = null;
+
         if (request.body.asOrganizationId) {
             const memberIds = Formatter.uniqueArray(
                 [...request.body.memberIds, ...deleteRegistrationModels.map(i => i.memberId), ...balanceItemsModels.map(i => i.memberId).filter(m => m !== null)],
@@ -233,6 +235,7 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                 platformMembers.push(platformMember);
             }
 
+            payingOrganization = await Context.auth.getOrganization(request.body.asOrganizationId);
             if (memberIds.length > 0 && request.body.asOrganizationId && request.body.asOrganizationId !== organization.id) {
                 // For registering members at a different organization, you need full permissions
                 if (!await Context.auth.hasFullAccess(request.body.asOrganizationId)) {
@@ -288,6 +291,7 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             if (whoWillPayNow === 'nobody') {
                 // Safe and important to ignore: we are only updating the outstanding amounts
                 // If we would throw here, that could leak personal data (e.g. that the user uses financial support)
+                request.body.totalPrice = totalPrice;
             }
             else {
                 // when whoWillPay = organization/member, we should throw or the payment amount could be different / incorrect.
@@ -450,37 +454,10 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             registrations.push(registration);
         }
 
-        // Validate payment method
-        if (totalPrice > 0 && whoWillPayNow !== 'nobody') {
-            const allowedPaymentMethods = organization.meta.registrationPaymentConfiguration.getAvailablePaymentMethods({
-                amount: totalPrice,
-                customer: checkout.customer,
-            });
-
-            if (!checkout.paymentMethod || !allowedPaymentMethods.includes(checkout.paymentMethod)) {
-                throw new SimpleError({
-                    code: 'invalid_payment_method',
-                    message: $t(`2b1ca6a0-662e-4326-ada1-10239b6ddc6f`),
-                });
-            }
-
-            if ((checkout.paymentMethod !== PaymentMethod.Transfer && checkout.paymentMethod !== PaymentMethod.PointOfSale) && (!request.body.redirectUrl || !request.body.cancelUrl)) {
-                throw new SimpleError({
-                    code: 'missing_fields',
-                    message: 'redirectUrl or cancelUrl is missing and is required for non-zero online payments',
-                    human: $t(`ebe54b63-2de6-4f22-a5ed-d3fe65194562`),
-                });
-            }
-        }
-        else {
-            checkout.paymentMethod = PaymentMethod.Unknown;
-        }
-
         console.log('Registering members using whoWillPayNow', whoWillPayNow, checkout.paymentMethod, totalPrice);
 
         const createdBalanceItems: BalanceItem[] = [];
         const deletedBalanceItems: BalanceItem[] = [];
-        const shouldMarkValid = whoWillPayNow === 'nobody' || checkout.paymentMethod === PaymentMethod.Transfer || checkout.paymentMethod === PaymentMethod.PointOfSale || checkout.paymentMethod === PaymentMethod.Unknown;
 
         // Create negative balance items
         for (const { registration: registrationStruct, deleted } of [
@@ -834,21 +811,6 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
         // Keep a copy because createdBalanceItems will be altered - and we don't want to mark added items as valid
         const markValidList = [...createdBalanceItems];
 
-        async function markValidIfNeeded() {
-            if (shouldMarkValid) {
-                for (const balanceItem of markValidList) {
-                    // Mark valid
-                    await BalanceItemService.markPaid(balanceItem, payment, organization);
-                }
-
-                // Flush balance caches so we return an up-to-date balance
-                await BalanceItemService.flushRegistrationDiscountsCache();
-
-                // We'll need to update the returned registrations as their values will have changed by marking the registration as valid
-                await Registration.refreshAll(registrations);
-            }
-        }
-
         if (whoWillPayNow !== 'nobody') {
             const mappedBalanceItems = new Map<BalanceItem, number>();
 
@@ -868,14 +830,15 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             }
 
             try {
-                const response = await this.createPayment({
+                const response = await PaymentService.createPayment({
                     balanceItems: mappedBalanceItems,
                     organization,
                     user,
                     checkout: request.body,
                     members,
+                    serviceFeeType: 'members',
+                    payingOrganization,
                 });
-                await markValidIfNeeded();
 
                 if (response) {
                     paymentUrl = response.paymentUrl;
@@ -889,7 +852,10 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             }
         }
         else {
-            await markValidIfNeeded();
+            // Mark as paid/valid without creating a payment
+            for (const balanceItem of markValidList) {
+                await BalanceItemService.markPaid(balanceItem, null, organization);
+            }
         }
 
         // Update occupancy
@@ -903,6 +869,9 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
         // Flush caches so data is up to date in response
         await BalanceItemService.flushCaches(organization.id);
 
+        // We'll need to update the returned registrations as their values will have changed by marking the registration as valid
+        await Registration.refreshAll(registrations);
+
         // Force reload registrations and group data
         Member.unloadRegistrations(members);
         await Member.loadRegistrations(members, true);
@@ -915,343 +884,4 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             paymentQRCode,
         }));
     }
-
-    async createPayment({ balanceItems, organization, user, checkout, members }: { balanceItems: Map<BalanceItem, number>; organization: Organization; user: User; checkout: IDRegisterCheckout; members: MemberWithUsersRegistrationsAndGroups[] }) {
-        // Calculate total price to pay
-        let totalPrice = 0;
-        const payMembers: MemberWithUsersRegistrationsAndGroups[] = [];
-        let hasNegative = false;
-
-        for (const [balanceItem, price] of balanceItems) {
-            if (organization.id !== balanceItem.organizationId) {
-                throw new Error('Unexpected balance item from other organization');
-            }
-
-            if (price > 0 && price > Math.max(balanceItem.priceOpen, balanceItem.price - balanceItem.pricePaid)) {
-                throw new SimpleError({
-                    code: 'invalid_data',
-                    message: $t(`38ddccb2-7cf6-4b47-aa71-d11ad73386d8`),
-                });
-            }
-
-            if (price < 0 && price < Math.min(balanceItem.priceOpen, balanceItem.price - balanceItem.pricePaid)) {
-                throw new SimpleError({
-                    code: 'invalid_data',
-                    message: $t(`dd14a1d9-c569-4d5e-bb26-569ecede4c52`),
-                });
-            }
-
-            if (price < 0) {
-                hasNegative = true;
-            }
-
-            totalPrice += price;
-
-            if (price > 0 && balanceItem.memberId) {
-                const member = members.find(m => m.id === balanceItem.memberId);
-                if (!member) {
-                    throw new SimpleError({
-                        code: 'invalid_data',
-                        message: $t(`e64b8269-1cda-434d-8d6f-35be23a9d6e9`),
-                    });
-                }
-                payMembers.push(member);
-            }
-        }
-
-        if (totalPrice < 0) {
-            // todo: try to make it non-negative by reducing some balance items
-            throw new SimpleError({
-                code: 'negative_price',
-                message: $t(`725715e5-b0ac-43c1-adef-dd42b8907327`),
-            });
-        }
-
-        if (totalPrice !== checkout.totalPrice) {
-            // Changed!
-            throw new SimpleError({
-                code: 'changed_price',
-                message: $t(`e424d549-2bb8-4103-9a14-ac4063d7d454`, { total: Formatter.price(totalPrice) }),
-            });
-        }
-
-        const payment = new Payment();
-        payment.method = checkout.paymentMethod ?? PaymentMethod.Unknown;
-
-        if (totalPrice === 0) {
-            if (balanceItems.size === 0) {
-                return;
-            }
-            // Create an egalizing payment
-            payment.method = PaymentMethod.Unknown;
-
-            if (hasNegative) {
-                payment.type = PaymentType.Reallocation;
-            }
-        }
-        else if (payment.method === PaymentMethod.Unknown) {
-            throw new SimpleError({
-                code: 'invalid_data',
-                message: $t(`86c7b6f7-3ec9-4af3-a5e6-b5de6de80d73`),
-            });
-        }
-
-        // Who will receive this money?
-        payment.organizationId = organization.id;
-
-        // Who paid
-        payment.payingUserId = user.id;
-        payment.payingOrganizationId = checkout.asOrganizationId ?? null;
-
-        // Fill in customer:
-        payment.customer = PaymentCustomer.create({
-            firstName: user.firstName,
-            lastName: user.lastName,
-            email: user.email,
-        });
-
-        // Use structured transfer description prefix
-        let prefix = '';
-
-        if (checkout.asOrganizationId) {
-            if (!checkout.customer) {
-                throw new SimpleError({
-                    code: 'missing_fields',
-                    message: 'customer is required when paying as an organization',
-                    human: $t(`d483aa9a-289c-4c59-955f-d2f99ec533ab`),
-                });
-            }
-
-            if (!checkout.customer.company) {
-                throw new SimpleError({
-                    code: 'missing_fields',
-                    message: 'customer.company is required when paying as an organization',
-                    human: $t(`bc89861d-a799-4100-b06c-29d6808ba8d2`),
-                });
-            }
-
-            const payingOrganization = await Organization.getByID(checkout.asOrganizationId);
-            if (!payingOrganization) {
-                throw new SimpleError({
-                    code: 'invalid_data',
-                    message: $t(`492117ce-4d5f-4cff-8f3f-8fa56bbb0fee`),
-                });
-            }
-
-            // Search company id
-            // this avoids needing to check the VAT number every time
-            const id = checkout.customer.company.id;
-            const foundCompany = payingOrganization.meta.companies.find(c => c.id === id);
-
-            if (!foundCompany) {
-                throw new SimpleError({
-                    code: 'invalid_data',
-                    message: $t(`0ab71307-8f4f-4701-b120-b552a1b6bdd0`),
-                });
-            }
-
-            payment.customer.company = foundCompany;
-
-            const orgNumber = parseInt(payingOrganization.uri);
-
-            if (orgNumber !== 0 && !isNaN(orgNumber)) {
-                prefix = orgNumber + '';
-            }
-        }
-
-        payment.status = PaymentStatus.Created;
-        payment.paidAt = null;
-        payment.price = totalPrice;
-        PaymentService.round(payment);
-        totalPrice = payment.price;
-
-        if (totalPrice === 0) {
-            payment.status = PaymentStatus.Succeeded;
-            payment.paidAt = new Date();
-        }
-
-        if (payment.method === PaymentMethod.Transfer) {
-            // remark: we cannot add the lastnames, these will get added in the frontend when it is decrypted
-            payment.transferSettings = organization.mappedTransferSettings;
-
-            if (!payment.transferSettings.iban) {
-                throw new SimpleError({
-                    code: 'no_iban',
-                    message: 'No IBAN',
-                    human: $t(`cc8b5066-a7e4-4eae-b556-f56de5d3502c`),
-                });
-            }
-
-            const m = payMembers.map(r => r.details);
-            payment.generateDescription(
-                organization,
-                Formatter.groupNamesByFamily(m),
-                {
-                    name: Formatter.groupNamesByFamily(m),
-                    naam: Formatter.groupNamesByFamily(m),
-                    email: user.email,
-                    prefix,
-                },
-            );
-        }
-
-        // Determine the payment provider
-        // Throws if invalid
-        const { provider, stripeAccount } = await organization.getPaymentProviderFor(payment.method, organization.privateMeta.registrationPaymentConfiguration);
-        payment.provider = provider;
-        payment.stripeAccountId = stripeAccount?.id ?? null;
-        ServiceFeeHelper.setServiceFee(payment, organization, 'members', [...balanceItems.entries()].map(([_, p]) => p));
-
-        await payment.save();
-
-        // Create balance item payments
-        const balanceItemPayments: (BalanceItemPayment & { balanceItem: BalanceItem })[] = [];
-
-        for (const [balanceItem, price] of balanceItems) {
-            // Create one balance item payment to pay it in one payment
-            const balanceItemPayment = new BalanceItemPayment();
-            balanceItemPayment.balanceItemId = balanceItem.id;
-            balanceItemPayment.paymentId = payment.id;
-            balanceItemPayment.organizationId = organization.id;
-            balanceItemPayment.price = price;
-            await balanceItemPayment.save();
-
-            balanceItemPayments.push(balanceItemPayment.setRelation(BalanceItemPayment.balanceItem, balanceItem));
-        }
-
-        const description = $t(`33a926ea-9bc7-444e-becc-c0f2f70e1f0e`) + ' ' + organization.name;
-
-        let paymentUrl: string | null = null;
-        let paymentQRCode: string | null = null;
-
-        try {
-            // Update balance items
-            if (payment.method === PaymentMethod.Transfer) {
-                // Send a small reminder email
-                try {
-                    await Registration.sendTransferEmail(user, organization, payment);
-                }
-                catch (e) {
-                    console.error('Failed to send transfer email');
-                    console.error(e);
-                }
-            }
-            else if (payment.method !== PaymentMethod.PointOfSale && payment.method !== PaymentMethod.Unknown) {
-                if (!checkout.redirectUrl || !checkout.cancelUrl) {
-                    throw new Error('Should have been caught earlier');
-                }
-
-                const _redirectUrl = new URL(checkout.redirectUrl);
-                _redirectUrl.searchParams.set('paymentId', payment.id);
-                _redirectUrl.searchParams.set('organizationId', organization.id); // makes sure the client uses the token associated with this organization when fetching payment polling status
-
-                const _cancelUrl = new URL(checkout.cancelUrl);
-                _cancelUrl.searchParams.set('paymentId', payment.id);
-                _cancelUrl.searchParams.set('cancel', 'true');
-                _cancelUrl.searchParams.set('organizationId', organization.id); // makes sure the client uses the token associated with this organization when fetching payment polling status
-
-                const redirectUrl = _redirectUrl.href;
-                const cancelUrl = _cancelUrl.href;
-
-                const webhookUrl = 'https://' + organization.getApiHost() + '/v' + Version + '/payments/' + encodeURIComponent(payment.id) + '?exchange=true';
-
-                if (payment.provider === PaymentProvider.Stripe) {
-                    const stripeResult = await StripeHelper.createPayment({
-                        payment,
-                        stripeAccount,
-                        redirectUrl,
-                        cancelUrl,
-                        statementDescriptor: organization.name,
-                        metadata: {
-                            organization: organization.id,
-                            user: user.id,
-                            payment: payment.id,
-                        },
-                        i18n: Context.i18n,
-                        lineItems: balanceItemPayments,
-                        organization,
-                        customer: {
-                            name: user.name ?? payMembers[0]?.details.name ?? $t(`bd1e59c8-3d4c-4097-ab35-0ce7b20d0e50`),
-                            email: user.email,
-                        },
-                    });
-                    paymentUrl = stripeResult.paymentUrl;
-                }
-                else if (payment.provider === PaymentProvider.Mollie) {
-                    // Mollie payment
-                    const token = await MollieToken.getTokenFor(organization.id);
-                    if (!token) {
-                        throw new SimpleError({
-                            code: '',
-                            message: $t(`b77e1f68-8928-42a2-802b-059fa73bedc3`, { method: PaymentMethodHelper.getName(payment.method) }),
-                        });
-                    }
-                    const profileId = organization.privateMeta.mollieProfile?.id ?? await token.getProfileId(organization.getHost());
-                    if (!profileId) {
-                        throw new SimpleError({
-                            code: '',
-                            message: $t(`5574469f-8eee-47fe-9fb6-1b097142ac75`, { method: PaymentMethodHelper.getName(payment.method) }),
-                        });
-                    }
-                    const mollieClient = createMollieClient({ accessToken: await token.getAccessToken() });
-                    const locale = Context.i18n.locale.replace('-', '_');
-                    const molliePayment = await mollieClient.payments.create({
-                        amount: {
-                            currency: 'EUR',
-                            value: (totalPrice / 100).toFixed(2),
-                        },
-                        method: payment.method == PaymentMethod.Bancontact ? molliePaymentMethod.bancontact : (payment.method == PaymentMethod.iDEAL ? molliePaymentMethod.ideal : molliePaymentMethod.creditcard),
-                        testmode: organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production',
-                        profileId,
-                        description,
-                        redirectUrl,
-                        webhookUrl,
-                        metadata: {
-                            paymentId: payment.id,
-                        },
-                        locale: ['en_US', 'en_GB', 'nl_NL', 'nl_BE', 'fr_FR', 'fr_BE', 'de_DE', 'de_AT', 'de_CH', 'es_ES', 'ca_ES', 'pt_PT', 'it_IT', 'nb_NO', 'sv_SE', 'fi_FI', 'da_DK', 'is_IS', 'hu_HU', 'pl_PL', 'lv_LV', 'lt_LT'].includes(locale) ? (locale as any) : null,
-                    });
-                    paymentUrl = molliePayment.getCheckoutUrl();
-
-                    // Save payment
-                    const dbPayment = new MolliePayment();
-                    dbPayment.paymentId = payment.id;
-                    dbPayment.mollieId = molliePayment.id;
-                    await dbPayment.save();
-                }
-                else if (payment.provider === PaymentProvider.Payconiq) {
-                    ({ paymentUrl, paymentQRCode } = await PayconiqPayment.createPayment(payment, organization, description, redirectUrl, webhookUrl));
-                }
-                else if (payment.provider == PaymentProvider.Buckaroo) {
-                    // Increase request timeout because buckaroo is super slow (in development)
-                    Context.request.request?.setTimeout(60 * 1000);
-                    const buckaroo = new BuckarooHelper(organization.privateMeta?.buckarooSettings?.key ?? '', organization.privateMeta?.buckarooSettings?.secret ?? '', organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production');
-                    const ip = Context.request.getIP();
-                    paymentUrl = await buckaroo.createPayment(payment, ip, description, redirectUrl, webhookUrl);
-                    await payment.save();
-
-                    // TypeScript doesn't understand that the status can change and isn't a const....
-                    if ((payment.status as any) === PaymentStatus.Failed) {
-                        throw new SimpleError({
-                            code: 'payment_failed',
-                            message: $t(`b77e1f68-8928-42a2-802b-059fa73bedc3`, { method: PaymentMethodHelper.getName(payment.method) }),
-                        });
-                    }
-                }
-            }
-        }
-        catch (e) {
-            await PaymentService.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
-            throw e;
-        }
-
-        return {
-            payment,
-            balanceItemPayments,
-            provider,
-            stripeAccount,
-            paymentUrl,
-            paymentQRCode,
-        };
-    }
 }

package/src/endpoints/global/registration-periods/GetRegistrationPeriodsEndpoint.ts

@@ -5,9 +5,9 @@ import { Decoder } from '@simonbackx/simple-encoding';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { RegistrationPeriod } from '@stamhoofd/models';
 import { applySQLSorter, compileToSQLFilter, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
-import { Context } from '../../../helpers/Context';
-import { registrationPeriodFilterCompilers } from '../../../sql-filters/registration-periods';
-import { registrationPeriodSorters } from '../../../sql-sorters/registration-periods';
+import { Context } from '../../../helpers/Context.js';
+import { registrationPeriodFilterCompilers } from '../../../sql-filters/registration-periods.js';
+import { registrationPeriodSorters } from '../../../sql-sorters/registration-periods.js';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;

package/src/endpoints/global/registration-periods/PatchRegistrationPeriodsEndpoint.ts

@@ -4,8 +4,8 @@ import { RegistrationPeriod as RegistrationPeriodStruct } from '@stamhoofd/struc
 
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Organization, Platform, RegistrationPeriod } from '@stamhoofd/models';
-import { Context } from '../../../helpers/Context';
-import { PeriodHelper } from '../../../helpers/PeriodHelper';
+import { Context } from '../../../helpers/Context.js';
+import { PeriodHelper } from '../../../helpers/PeriodHelper.js';
 
 type Params = Record<string, never>;
 type Query = undefined;

package/src/endpoints/global/sso/GetSSOEndpoint.ts

@@ -1,10 +1,10 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { LoginProviderType, OpenIDClientConfiguration } from '@stamhoofd/structures';
 
-import { Context } from '../../../helpers/Context';
+import { Context } from '../../../helpers/Context.js';
 import { Platform } from '@stamhoofd/models';
 import { AutoEncoder, Decoder, EnumDecoder, field } from '@simonbackx/simple-encoding';
-import { SSOService } from '../../../services/SSOService';
+import { SSOService } from '../../../services/SSOService.js';
 
 type Params = Record<string, never>;
 export class SSOQuery extends AutoEncoder {

package/src/endpoints/global/sso/SetSSOEndpoint.ts

@@ -2,9 +2,9 @@ import { AutoEncoderPatchType, Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { OpenIDClientConfiguration } from '@stamhoofd/structures';
 
-import { Context } from '../../../helpers/Context';
-import { SSOService } from '../../../services/SSOService';
-import { SSOQuery } from './GetSSOEndpoint';
+import { Context } from '../../../helpers/Context.js';
+import { SSOService } from '../../../services/SSOService.js';
+import { SSOQuery } from './GetSSOEndpoint.js';
 
 type Params = Record<string, never>;
 type Query = SSOQuery;

package/src/endpoints/organization/dashboard/balance-items/GetBalanceItemEndpoint.ts

@@ -0,0 +1,55 @@
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { BalanceItem } from '@stamhoofd/models';
+import { BalanceItemWithPayments } from '@stamhoofd/structures';
+
+import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures.js';
+import { Context } from '../../../../helpers/Context.js';
+
+type Params = { id: string };
+type Query = undefined;
+type Body = undefined;
+type ResponseBody = BalanceItemWithPayments;
+
+export class GetBalanceItemEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/balance-items/@id', { id: String });
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope();
+        await Context.authenticate();
+
+        if (!await Context.auth.hasSomeAccess(organization.id)) {
+            throw Context.auth.error();
+        }
+
+        const balanceItem = await BalanceItem.getByID(request.params.id);
+
+        if (!balanceItem || balanceItem.organizationId !== organization.id) {
+            throw new SimpleError({
+                code: 'not_found',
+                statusCode: 404,
+                message: 'Balance item not found',
+                human: $t('7bc08947-2409-4a7c-b597-2d6d43884a96'),
+            });
+        }
+
+        if (!await Context.auth.canAccessBalanceItems([balanceItem])) {
+            throw Context.auth.error();
+        }
+
+        return new Response(
+            (await AuthenticatedStructures.balanceItemsWithPayments([balanceItem]))[0],
+        );
+    }
+}

package/src/endpoints/organization/dashboard/balance-items/GetBalanceItemsCountEndpoint.ts

@@ -0,0 +1,43 @@
+import { Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { CountFilteredRequest, CountResponse } from '@stamhoofd/structures';
+
+import { Context } from '../../../../helpers/Context.js';
+import { GetBalanceItemsEndpoint } from './GetBalanceItemsEndpoint.js';
+
+type Params = Record<string, never>;
+type Query = CountFilteredRequest;
+type Body = undefined;
+type ResponseBody = CountResponse;
+
+export class GetBalanceItemsCountEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = CountFilteredRequest as Decoder<CountFilteredRequest>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/balance-items/count', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.setOrganizationScope();
+        await Context.authenticate();
+        const query = await GetBalanceItemsEndpoint.buildQuery(request.query);
+
+        const count = await query
+            .count();
+
+        return new Response(
+            CountResponse.create({
+                count,
+            }),
+        );
+    }
+}