@stamhoofd/backend 2.107.3 → 2.109.0

package/index.ts

@@ -5,10 +5,10 @@ backendEnv.load({ service: 'api' }).catch((error) => {
     process.exit(1);
 }).then(async () => {
     if (STAMHOOFD.environment === 'development') {
-        const { run } = await import('./src/migrate');
+        const { run } = await import('./src/migrate.js');
         await run();
     }
-    const { boot } = await import('./src/boot');
+    const { boot } = await import('./src/boot.js');
 
     boot({ killProcess: true }).catch((error) => {
         console.error('unhandledRejection', error);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.107.3",
+    "version": "2.109.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -32,7 +32,7 @@
     "devDependencies": {
         "@types/cookie": "^0.6.0",
         "@types/luxon": "3.4.2",
-        "@types/mailparser": "3.4.4",
+        "@types/mailparser": "^3",
         "@types/mysql": "^2.15.20",
         "@types/node": "^22",
         "nock": "^13.5.1",
@@ -40,33 +40,33 @@
         "sinon": "^18.0.0"
     },
     "dependencies": {
-        "@aws-sdk/client-s3": "3.823.0",
-        "@aws-sdk/client-ses": "3.823.0",
-        "@aws-sdk/client-sesv2": "3.823.0",
-        "@aws-sdk/client-sqs": "3.823.0",
-        "@aws-sdk/s3-request-presigner": "3.823.0",
+        "@aws-sdk/client-s3": "^3.839.0",
+        "@aws-sdk/client-ses": "^3.839.0",
+        "@aws-sdk/client-sesv2": "^3.839.0",
+        "@aws-sdk/client-sqs": "^3.839.0",
+        "@aws-sdk/s3-request-presigner": "^3.839.0",
         "@bwip-js/node": "^4.5.1",
-        "@mollie/api-client": "3.7.0",
+        "@mollie/api-client": "4.3.3",
         "@simonbackx/simple-database": "1.34.0",
         "@simonbackx/simple-encoding": "2.22.0",
         "@simonbackx/simple-endpoints": "1.20.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.107.3",
-        "@stamhoofd/backend-middleware": "2.107.3",
-        "@stamhoofd/email": "2.107.3",
-        "@stamhoofd/models": "2.107.3",
-        "@stamhoofd/queues": "2.107.3",
-        "@stamhoofd/sql": "2.107.3",
-        "@stamhoofd/structures": "2.107.3",
-        "@stamhoofd/utility": "2.107.3",
+        "@stamhoofd/backend-i18n": "2.109.0",
+        "@stamhoofd/backend-middleware": "2.109.0",
+        "@stamhoofd/email": "2.109.0",
+        "@stamhoofd/models": "2.109.0",
+        "@stamhoofd/queues": "2.109.0",
+        "@stamhoofd/sql": "2.109.0",
+        "@stamhoofd/structures": "2.109.0",
+        "@stamhoofd/utility": "2.109.0",
         "archiver": "^7.0.1",
-        "axios": "^1.8.2",
+        "axios": "^1.13.2",
         "cookie": "^0.7.0",
         "formidable": "3.5.4",
         "handlebars": "^4.7.7",
-        "jsonwebtoken": "9.0.0",
+        "jsonwebtoken": "9.0.3",
         "luxon": "3.4.4",
-        "mailparser": "3.7.0",
+        "mailparser": "^3.9.1",
         "mockdate": "^3.0.2",
         "mysql2": "^3.14.1",
         "node-rsa": "1.1.1",
@@ -76,5 +76,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "2827f3e8dbc9046fe6f71b42c608cda407da3a2d"
+    "gitHead": "9a987df4a751f24aabd56e1480dfb9239fb8e019"
 }

package/src/crons/disable-auto-update-documents.test.ts

@@ -0,0 +1,164 @@
+import { DocumentTemplate, DocumentTemplateFactory } from '@stamhoofd/models';
+import { DocumentStatus } from '@stamhoofd/structures';
+import { disableAutoUpdateForFiscalDocuments, disableAutoUpdateForOtherDocuments } from './disable-auto-update-documents.js';
+
+describe('cron.disable-auto-update-documents', () => {
+    describe('disableAutoUpdateForFiscalDocuments', () => {
+        it('should only run on the 1st of March', async () => {
+            // arrange
+            const firstOfMarch2025 = new Date(2025, 2, 1);
+
+            const cases: { now: Date; expected: boolean }[] = [
+                { now: new Date(firstOfMarch2025.getTime() - 1), expected: false },
+                { now: new Date(firstOfMarch2025), expected: true },
+                { now: new Date(2025, 2, 2), expected: false },
+                { now: new Date(new Date(2026, 2, 1)), expected: true },
+            ];
+
+            for (const { now, expected } of cases) {
+                // act
+                const result = await disableAutoUpdateForFiscalDocuments(now);
+                // assert
+                expect(result).toBe(expected);
+            }
+        });
+
+        it('should disable auto-update for fiscal documents of the previous year', async () => {
+            // // arrange
+            const firstOfMarch2025 = new Date(2025, 2, 1);
+
+            const document1 = await createDocument({
+                status: DocumentStatus.Published,
+                publishedAt: new Date(2025, 0, 1),
+                createdAt: new Date(2024, 11, 15),
+                year: 2024,
+                type: 'fiscal',
+                updatesEnabled: true,
+            });
+
+            // old year
+            const document2 = await createDocument({
+                status: DocumentStatus.Published,
+                publishedAt: new Date(2025, 0, 1),
+                createdAt: new Date(2024, 11, 15),
+                year: 2023,
+                type: 'fiscal',
+                updatesEnabled: true,
+            });
+
+            // current year
+            const document3 = await createDocument({
+                status: DocumentStatus.Published,
+                publishedAt: new Date(2025, 0, 1),
+                createdAt: new Date(2024, 11, 15),
+                year: 2025,
+                type: 'fiscal',
+                updatesEnabled: true,
+            });
+
+            // type participation
+            const document4 = await createDocument({
+                status: DocumentStatus.Published,
+                publishedAt: new Date(2025, 0, 1),
+                createdAt: new Date(2024, 11, 15),
+                year: 2024,
+                type: 'participation',
+                updatesEnabled: true,
+            });
+
+            // act
+            const didRun = await disableAutoUpdateForFiscalDocuments(firstOfMarch2025);
+
+            // assert
+            const updatedDocument1 = (await DocumentTemplate.getByID(document1.id))!;
+            const updatedDocument2 = (await DocumentTemplate.getByID(document2.id))!;
+            const updatedDocument3 = (await DocumentTemplate.getByID(document3.id))!;
+            const updatedDocument4 = (await DocumentTemplate.getByID(document4.id))!;
+
+            expect(didRun).toBe(true);
+
+            // should update because previous year, type is fiscal and updates enabled
+            expect(updatedDocument1.updatesEnabled).toBe(false);
+            // should not update because not previous year
+            expect(updatedDocument2.updatesEnabled).toBe(true);
+            // should not update because not previous year
+            expect(updatedDocument3.updatesEnabled).toBe(true);
+            // should not update because type is not fiscal
+            expect(updatedDocument4.updatesEnabled).toBe(true);
+        });
+    });
+
+    describe('disableAutoUpdateForOtherDocuments', () => {
+        it('should disable auto-update for documents, other than fiscal documents, that have been published 90 days ago', async () => {
+            // // arrange
+            const today = new Date(2025, 5, 15);
+            const ninetyDaysAgo = new Date(2025, 2, 17);
+
+            const cases: { document: DocumentTemplate; expected: boolean }[] = [
+                // should update because 90 days ago and type is not fiscal
+                {
+                    document: await createDocument({
+                        status: DocumentStatus.Published,
+                        publishedAt: new Date(ninetyDaysAgo),
+                        createdAt: new Date(2024, 11, 15),
+                        year: 2024,
+                        type: 'participation',
+                        updatesEnabled: true,
+                    }),
+                    expected: false,
+                },
+                // day after
+                {
+                    document: await createDocument({
+                        status: DocumentStatus.Published,
+                        publishedAt: new Date(2025, 2, 18),
+                        createdAt: new Date(2024, 11, 15),
+                        year: 2024,
+                        type: 'participation',
+                        updatesEnabled: true,
+                    }),
+                    expected: true,
+                },
+                // day before
+                {
+                    document: await createDocument({
+                        status: DocumentStatus.Published,
+                        publishedAt: new Date(ninetyDaysAgo.getTime() - 1),
+                        createdAt: new Date(2024, 11, 15),
+                        year: 2024,
+                        type: 'participation',
+                        updatesEnabled: true,
+                    }),
+                    expected: true,
+                },
+                // type fiscal
+                {
+                    document: await createDocument({
+                        status: DocumentStatus.Published,
+                        publishedAt: new Date(ninetyDaysAgo),
+                        createdAt: new Date(2024, 11, 15),
+                        year: 2024,
+                        type: 'fiscal',
+                        updatesEnabled: true,
+                    }),
+                    expected: true,
+                },
+            ];
+
+            // act
+            await disableAutoUpdateForOtherDocuments(today);
+
+            // assert
+            for (const { document, expected } of cases) {
+                const updatedDocument = (await DocumentTemplate.getByID(document.id))!;
+                expect(updatedDocument.updatesEnabled).toBe(expected);
+            }
+        });
+    });
+});
+
+async function createDocument({ year, status, createdAt, updatesEnabled, type, publishedAt }: { year: number; status: DocumentStatus; createdAt: Date; updatesEnabled: boolean; type: 'fiscal' | 'participation'; publishedAt: Date | null }) {
+    const document = await new DocumentTemplateFactory({ year, groups: [], status, updatesEnabled, publishedAt, createdAt, type }).create();
+
+    return document;
+};

package/src/crons/disable-auto-update-documents.ts

@@ -0,0 +1,82 @@
+import { registerCron } from '@stamhoofd/crons';
+import { DocumentTemplate } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+
+let lastRunDate: number | null = null;
+
+registerCron('disableAutoUpdateDocuments', disableAutoUpdateDocuments);
+
+function shouldRun() {
+    const now = new Date();
+
+    if (now.getDate() === lastRunDate) {
+        return false;
+    }
+
+    const hour = now.getHours();
+
+    // between 5 and 6 AM
+    if (hour !== 5 && STAMHOOFD.environment !== 'development') {
+        return false;
+    }
+
+    return true;
+}
+
+async function disableAutoUpdateDocuments() {
+    if (!shouldRun()) {
+        return;
+    }
+
+    const now = new Date();
+    lastRunDate = now.getDate();
+
+    await disableAutoUpdateForFiscalDocuments(now);
+    await disableAutoUpdateForOtherDocuments(now);
+}
+
+/**
+ * Disable auto-update for fiscal documents on the 1st of March.
+ * @returns if query was run
+ */
+export async function disableAutoUpdateForFiscalDocuments(now: Date): Promise<boolean> {
+    // only run on 1st of march
+    const isFirstOfMarch = now.getMonth() === 2 && now.getDate() === 1;
+    if (!isFirstOfMarch) {
+        return false;
+    }
+
+    // set updates enabled to false
+    await SQL.update(DocumentTemplate.table).set('updatesEnabled', false)
+        // where previous year
+        .where('year', now.getFullYear() - 1)
+        // where updates enabled
+        .andWhere('updatesEnabled', true)
+        // where type is fiscal
+        .andWhere(SQL.jsonExtract(SQL.column('privateSettings'), '$.value.templateDefinition.type'), 'fiscal')
+        .update();
+
+    return true;
+}
+
+/**
+ * Disable auto-update for documents, other then fiscal, that have been published 90 days ago.
+ */
+export async function disableAutoUpdateForOtherDocuments(now: Date) {
+    const min = new Date(now);
+    min.setDate(min.getDate() - 90);
+
+    const max = new Date(now);
+    max.setDate(max.getDate() - 89);
+
+    // set updates enabled to false
+    await SQL.update(DocumentTemplate.table).set('updatesEnabled', false)
+        // where updates enabled
+        .where('updatesEnabled', true)
+        // where published 90 days ago
+        .andWhere('publishedAt', '>=', min)
+        .andWhere('publishedAt', '<', max)
+        // where type is not fiscal
+        .whereNot(SQL.jsonExtract(SQL.column('privateSettings'), '$.value.templateDefinition.type'), 'fiscal')
+        .update();
+}

package/src/endpoints/admin/members/ChargeMembersEndpoint.ts

@@ -4,10 +4,10 @@ import { SimpleError } from '@simonbackx/simple-errors';
 import { ChargeMembersRequest, LimitedFilteredRequest, PermissionLevel } from '@stamhoofd/structures';
 
 import { QueueHandler } from '@stamhoofd/queues';
-import { Context } from '../../../helpers/Context';
-import { fetchToAsyncIterator } from '../../../helpers/fetchToAsyncIterator';
-import { MemberCharger } from '../../../helpers/MemberCharger';
-import { GetMembersEndpoint } from '../../global/members/GetMembersEndpoint';
+import { Context } from '../../../helpers/Context.js';
+import { fetchToAsyncIterator } from '../../../helpers/fetchToAsyncIterator.js';
+import { MemberCharger } from '../../../helpers/MemberCharger.js';
+import { GetMembersEndpoint } from '../../global/members/GetMembersEndpoint.js';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
@@ -31,7 +31,7 @@ export class ChargeMembersEndpoint extends Endpoint<Params, Query, Body, Respons
         return [false];
     }
 
-    private static throwIfInvalidBody(body: Body) {
+    static throwIfInvalidBody(body: Body) {
         if (!body.description?.trim()?.length) {
             throw new SimpleError({
                 code: 'invalid_field',

package/src/endpoints/admin/registrations/ChargeRegistrationsEndpoint.ts

@@ -0,0 +1,87 @@
+import { Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { ChargeMembersRequest, LimitedFilteredRequest, PermissionLevel } from '@stamhoofd/structures';
+
+import { QueueHandler } from '@stamhoofd/queues';
+import { Context } from '../../../helpers/Context.js';
+import { fetchToAsyncIterator } from '../../../helpers/fetchToAsyncIterator.js';
+import { MemberCharger } from '../../../helpers/MemberCharger.js';
+import { GetRegistrationsEndpoint } from '../../global/registration/GetRegistrationsEndpoint.js';
+import { ChargeMembersEndpoint } from '../members/ChargeMembersEndpoint.js';
+
+type Params = Record<string, never>;
+type Query = LimitedFilteredRequest;
+type Body = ChargeMembersRequest;
+type ResponseBody = undefined;
+
+export class ChargeRegistrationsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
+    bodyDecoder = ChargeMembersRequest as Decoder<ChargeMembersRequest>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'POST') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/admin/charge-registrations', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope();
+        const body = request.body;
+
+        await Context.authenticate();
+
+        if (!await Context.auth.canManagePayments(organization.id)) {
+            throw Context.auth.error();
+        }
+
+        ChargeMembersEndpoint.throwIfInvalidBody(body);
+
+        const queueId = 'charge-registrations';
+
+        if (QueueHandler.isRunning(queueId)) {
+            throw new SimpleError({
+                code: 'charge_pending',
+                message: 'Charge registrations already pending',
+                human: $t(`d2b84fdd-035b-4307-a897-000081aa814f`),
+            });
+        }
+
+        await QueueHandler.schedule(queueId, async () => {
+            const dataGenerator = fetchToAsyncIterator(request.query, {
+                fetch: request => GetRegistrationsEndpoint.buildData(request, PermissionLevel.Write),
+            });
+
+            const chargedMemberIds = new Set<string>();
+
+            for await (const data of dataGenerator) {
+                for (const registration of data.registrations) {
+                    const memberId = registration.member.id;
+
+                    // only charge members once
+                    if (!chargedMemberIds.has(memberId)) {
+                        chargedMemberIds.add(memberId);
+                        await MemberCharger.charge({
+                            chargingOrganizationId: organization.id,
+                            memberToCharge: registration.member,
+                            price: body.price,
+                            amount: body.amount ?? 1,
+                            description: body.description,
+                            dueAt: body.dueAt,
+                            createdAt: body.createdAt,
+                        });
+                    }
+                }
+            }
+        });
+
+        return new Response(undefined);
+    }
+}

package/src/endpoints/global/members/GetMembersCountEndpoint.ts

@@ -2,8 +2,8 @@ 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';
-import { GetMembersEndpoint } from './GetMembersEndpoint';
+import { Context } from '../../../helpers/Context.js';
+import { GetMembersEndpoint } from './GetMembersEndpoint.js';
 
 type Params = Record<string, never>;
 type Query = CountFilteredRequest;

package/src/endpoints/global/members/GetMembersEndpoint.ts

@@ -8,11 +8,11 @@ import { DataValidator } from '@stamhoofd/utility';
 
 import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
 import parsePhoneNumber from 'libphonenumber-js/max';
-import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
-import { Context } from '../../../helpers/Context';
-import { memberFilterCompilers } from '../../../sql-filters/members';
-import { memberSorters } from '../../../sql-sorters/members';
-import { validateGroupFilter } from './helpers/validateGroupFilter';
+import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures.js';
+import { Context } from '../../../helpers/Context.js';
+import { memberFilterCompilers } from '../../../sql-filters/members.js';
+import { memberSorters } from '../../../sql-sorters/members.js';
+import { validateGroupFilter } from './helpers/validateGroupFilter.js';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;

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

@@ -2,8 +2,8 @@ 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';
-import { GetRegistrationsEndpoint } from './GetRegistrationsEndpoint';
+import { Context } from '../../../helpers/Context.js';
+import { GetRegistrationsEndpoint } from './GetRegistrationsEndpoint.js';
 
 type Params = Record<string, never>;
 type Query = CountFilteredRequest;

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

@@ -3,25 +3,24 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Group, Member, Platform, Registration } from '@stamhoofd/models';
 import { SQL, SQLExpression, SQLSelect, SQLSortDefinitions, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
-import { CountFilteredRequest, GroupType, LimitedFilteredRequest, PaginatedResponse, PermissionLevel, StamhoofdFilter, assertSort } from '@stamhoofd/structures';
+import { CountFilteredRequest, GroupType, LimitedFilteredRequest, PaginatedResponse, PermissionLevel, RegistrationWithMemberBlob, StamhoofdFilter, assertSort } from '@stamhoofd/structures';
 
 import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
 import { RegistrationsBlob } from '@stamhoofd/structures/dist/src/members/RegistrationsBlob';
-import { RegistrationWithMemberBlob } from '@stamhoofd/structures/dist/src/members/RegistrationWithMemberBlob';
-import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
-import { Context } from '../../../helpers/Context';
-import { LimitedFilteredRequestHelper } from '../../../helpers/LimitedFilteredRequestHelper';
-import { groupJoin, registrationFilterCompilers } from '../../../sql-filters/registrations';
-import { registrationSorters } from '../../../sql-sorters/registrations';
-import { GetMembersEndpoint } from '../members/GetMembersEndpoint';
-import { validateGroupFilter } from '../members/helpers/validateGroupFilter';
+import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures.js';
+import { Context } from '../../../helpers/Context.js';
+import { LimitedFilteredRequestHelper } from '../../../helpers/LimitedFilteredRequestHelper.js';
+import { groupJoin, registrationFilterCompilers } from '../../../sql-filters/registrations.js';
+import { RegistrationSortData, registrationSorters } from '../../../sql-sorters/registrations.js';
+import { GetMembersEndpoint } from '../members/GetMembersEndpoint.js';
+import { validateGroupFilter } from '../members/helpers/validateGroupFilter.js';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
 type Body = undefined;
 type ResponseBody = PaginatedResponse<RegistrationsBlob, LimitedFilteredRequest>;
 
-const sorters: SQLSortDefinitions<RegistrationWithMemberBlob> = registrationSorters;
+const sorters: SQLSortDefinitions<RegistrationSortData> = registrationSorters;
 const filterCompilers = registrationFilterCompilers;
 
 export class GetRegistrationsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
@@ -234,9 +233,13 @@ export class GetRegistrationsEndpoint extends Endpoint<Params, Query, Body, Resp
 
         const registrationsBlob = await AuthenticatedStructures.registrationsBlob(data, members);
 
-        const next = LimitedFilteredRequestHelper.fixInfiniteLoadingLoop({
+        const next = LimitedFilteredRequestHelper.fixInfiniteLoadingLoopWithTransform<RegistrationWithMemberBlob, RegistrationSortData>({
             request: requestQuery,
             results: registrationsBlob.registrations,
+            transformer: registration => new RegistrationSortData({
+                registration,
+                organizations: registrationsBlob.organizations,
+            }),
             sorters,
         });
 

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

@@ -8,14 +8,14 @@ import { BalanceItem, BalanceItemPayment, CachedBalance, Group, Member, MemberWi
 import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItem as BalanceItemStruct, BalanceItemType, IDRegisterCheckout, PaymentCustomer, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, Payment as PaymentStruct, PaymentType, PermissionLevel, PlatformFamily, PlatformMember, ReceivableBalanceType, RegisterItem, RegisterResponse, TranslatedString, Version } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 
-import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
-import { BuckarooHelper } from '../../../helpers/BuckarooHelper';
-import { Context } from '../../../helpers/Context';
-import { StripeHelper } from '../../../helpers/StripeHelper';
-import { BalanceItemService } from '../../../services/BalanceItemService';
-import { RegistrationService } from '../../../services/RegistrationService';
-import { PaymentService } from '../../../services/PaymentService';
-import { ServiceFeeHelper } from '../../../helpers/ServiceFeeHelper';
+import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures.js';
+import { BuckarooHelper } from '../../../helpers/BuckarooHelper.js';
+import { Context } from '../../../helpers/Context.js';
+import { ServiceFeeHelper } from '../../../helpers/ServiceFeeHelper.js';
+import { StripeHelper } from '../../../helpers/StripeHelper.js';
+import { BalanceItemService } from '../../../services/BalanceItemService.js';
+import { PaymentService } from '../../../services/PaymentService.js';
+import { RegistrationService } from '../../../services/RegistrationService.js';
 type Params = Record<string, never>;
 type Query = undefined;
 type Body = IDRegisterCheckout;
@@ -381,6 +381,7 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             registration.options = item.options;
             registration.recordAnswers = item.recordAnswers;
             registration.startDate = startDate;
+            registration.endDate = item.calculatedEndDate;
 
             // Clear if we are reusing an existing registration
             registration.trialUntil = null;

package/src/endpoints/organization/dashboard/documents/GetDocumentTemplatesCountEndpoint.ts

@@ -0,0 +1,48 @@
+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 { GetDocumentTemplatesEndpoint } from './GetDocumentTemplatesEndpoint.js';
+
+type Params = Record<string, never>;
+type Query = CountFilteredRequest;
+type Body = undefined;
+type ResponseBody = CountResponse;
+
+export class GetDocumentTemplatesCountEndpoint 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, '/organization/document-templates/count', {});
+
+        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.canManageDocuments(organization.id)) {
+            throw Context.auth.error();
+        }
+
+        const query = await GetDocumentTemplatesEndpoint.buildQuery(request.query);
+
+        const count = await query
+            .count();
+
+        return new Response(
+            CountResponse.create({
+                count,
+            }),
+        );
+    }
+}