@stamhoofd/backend 2.108.0 → 2.110.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.108.0",
+    "version": "2.110.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.108.0",
-        "@stamhoofd/backend-middleware": "2.108.0",
-        "@stamhoofd/email": "2.108.0",
-        "@stamhoofd/models": "2.108.0",
-        "@stamhoofd/queues": "2.108.0",
-        "@stamhoofd/sql": "2.108.0",
-        "@stamhoofd/structures": "2.108.0",
-        "@stamhoofd/utility": "2.108.0",
+        "@stamhoofd/backend-i18n": "2.110.0",
+        "@stamhoofd/backend-middleware": "2.110.0",
+        "@stamhoofd/email": "2.110.0",
+        "@stamhoofd/models": "2.110.0",
+        "@stamhoofd/queues": "2.110.0",
+        "@stamhoofd/sql": "2.110.0",
+        "@stamhoofd/structures": "2.110.0",
+        "@stamhoofd/utility": "2.110.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": "c8dd24207c94a4c077448545cdfcb94369a7ef47"
+    "gitHead": "b43604081c29f7d909dac1b47a2d1633b66670e5"
 }

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

@@ -3,16 +3,15 @@ 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.js';
 import { Context } from '../../../helpers/Context.js';
 import { LimitedFilteredRequestHelper } from '../../../helpers/LimitedFilteredRequestHelper.js';
 import { groupJoin, registrationFilterCompilers } from '../../../sql-filters/registrations.js';
-import { registrationSorters } from '../../../sql-sorters/registrations.js';
+import { RegistrationSortData, registrationSorters } from '../../../sql-sorters/registrations.js';
 import { GetMembersEndpoint } from '../members/GetMembersEndpoint.js';
 import { validateGroupFilter } from '../members/helpers/validateGroupFilter.js';
 
@@ -21,7 +20,7 @@ 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> {
@@ -160,8 +159,6 @@ export class GetRegistrationsEndpoint extends Endpoint<Params, Query, Body, Resp
             .setMaxExecutionTime(15 * 1000)
             .where('registeredAt', '!=', null);
 
-        query;
-
         if (scopeFilter) {
             query.where(await compileToSQLFilter(scopeFilter, filterCompilers));
         }
@@ -236,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,
+            }),
+        );
+    }
+}

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

@@ -1,16 +1,25 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { SimpleError } from '@simonbackx/simple-errors';
-import { DocumentTemplate, Token } from '@stamhoofd/models';
-import { DocumentTemplatePrivate } from '@stamhoofd/structures';
+import { DocumentTemplate } from '@stamhoofd/models';
+import { assertSort, CountFilteredRequest, DocumentTemplatePrivate, LimitedFilteredRequest, PaginatedResponse, SearchFilterFactory, StamhoofdFilter } from '@stamhoofd/structures';
 
-import { Context } from '../../../../helpers/Context';
+import { Decoder } from '@simonbackx/simple-encoding';
+import { applySQLSorter, compileToSQLFilter, SQL, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
+import { Context } from '../../../../helpers/Context.js';
+import { LimitedFilteredRequestHelper } from '../../../../helpers/LimitedFilteredRequestHelper.js';
+import { documentTemplateFilterCompilers } from '../../../../sql-filters/document-templates.js';
+import { documentTemplateSorters } from '../../../../sql-sorters/document-templates.js';
 
 type Params = Record<string, never>;
-type Query = undefined;
+type Query = LimitedFilteredRequest;
 type Body = undefined;
-type ResponseBody = DocumentTemplatePrivate[];
+type ResponseBody = PaginatedResponse<DocumentTemplatePrivate[], LimitedFilteredRequest>;
+
+const filterCompilers: SQLFilterDefinitions = documentTemplateFilterCompilers;
+const sorters: SQLSortDefinitions<DocumentTemplate> = documentTemplateSorters;
 
 export class GetDocumentTemplatesEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
+
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method !== 'GET') {
             return [false];
@@ -24,7 +33,60 @@ export class GetDocumentTemplatesEndpoint extends Endpoint<Params, Query, Body,
         return [false];
     }
 
-    async handle(_: DecodedRequest<Params, Query, Body>) {
+    static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+        const organization = Context.organization!;
+
+        const templatesTable: string = DocumentTemplate.table;
+
+        const query = SQL
+            .select(SQL.wildcard(templatesTable))
+            .from(SQL.table(templatesTable))
+            .where('organizationId', organization.id);
+
+        if (q.filter) {
+            query.where(await compileToSQLFilter(q.filter, filterCompilers));
+        }
+
+        if (q.search) {
+            const searchFilter: StamhoofdFilter | null = getDocumentTemplateSearchFilter(q.search);
+
+            if (searchFilter) {
+                query.where(await compileToSQLFilter(searchFilter, filterCompilers));
+            }
+        }
+
+        if (q instanceof LimitedFilteredRequest) {
+            if (q.pageFilter) {
+                query.where(await compileToSQLFilter(q.pageFilter, filterCompilers));
+            }
+
+            q.sort = assertSort(q.sort, [{ key: 'id' }]);
+            applySQLSorter(query, q.sort, sorters);
+            query.limit(q.limit);
+        }
+
+        return query;
+    }
+
+    static async buildData(requestQuery: LimitedFilteredRequest) {
+        const query = await this.buildQuery(requestQuery);
+        const data = await query.fetch();
+
+        const templates: DocumentTemplate[] = DocumentTemplate.fromRows(data, DocumentTemplate.table);
+
+        const next = LimitedFilteredRequestHelper.fixInfiniteLoadingLoop({
+            request: requestQuery,
+            results: templates,
+            sorters,
+        });
+
+        return new PaginatedResponse<DocumentTemplatePrivate[], LimitedFilteredRequest>({
+            results: templates.map(t => t.getPrivateStructure()),
+            next,
+        });
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
         await Context.authenticate();
 
@@ -32,19 +94,33 @@ export class GetDocumentTemplatesEndpoint extends Endpoint<Params, Query, Body,
             throw Context.auth.error();
         }
 
-        const templates = await DocumentTemplate.where(
-            {
-                organizationId: organization.id,
-            },
-            {
-                sort: [{
-                    column: 'createdAt',
-                    direction: 'ASC',
-                }],
-            },
-        );
+        LimitedFilteredRequestHelper.throwIfInvalidLimit({
+            request: request.query,
+            maxLimit: Context.auth.hasSomePlatformAccess() ? 1000 : 100,
+        });
+
         return new Response(
-            templates.map(t => t.getPrivateStructure()),
+            await GetDocumentTemplatesEndpoint.buildData(request.query),
         );
     }
 }
+
+function getDocumentTemplateSearchFilter(search: string | null): StamhoofdFilter | null {
+    if (search === null || search === undefined) {
+        return null;
+    }
+
+    const numberFilter = SearchFilterFactory.getIntegerFilter(search);
+
+    if (numberFilter) {
+        return {
+            year: numberFilter,
+        };
+    }
+
+    return {
+        name: {
+            $contains: search,
+        },
+    };
+}