@stamhoofd/backend 2.115.1 → 2.117.0

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,
+            }),
+        );
+    }
+}

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

@@ -0,0 +1,160 @@
+import { Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { BalanceItem } from '@stamhoofd/models';
+import { applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
+import { BalanceItem as BalanceItemStruct, CountFilteredRequest, LimitedFilteredRequest, PaginatedResponse, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
+
+import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures.js';
+import { Context } from '../../../../helpers/Context.js';
+import { balanceItemFilterCompilers } from '../../../../sql-filters/balance-items.js';
+import { balanceItemSorters } from '../../../../sql-sorters/balance-items.js';
+
+type Params = Record<string, never>;
+type Query = LimitedFilteredRequest;
+type Body = undefined;
+type ResponseBody = PaginatedResponse<BalanceItemStruct[], LimitedFilteredRequest>;
+
+const filterCompilers = balanceItemFilterCompilers;
+const sorters = balanceItemSorters;
+
+export class GetBalanceItemsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/balance-items', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+        const organization = Context.organization;
+        let scopeFilter: StamhoofdFilter | undefined = undefined;
+
+        if (!organization) {
+            throw Context.auth.error();
+        }
+
+        if (!await Context.auth.canManagePayments(organization.id)) {
+            throw Context.auth.error();
+        }
+
+        scopeFilter = {
+            organizationId: organization.id,
+        };
+
+        const query = BalanceItem.select()
+            .setMaxExecutionTime(15 * 1000);
+
+        if (scopeFilter) {
+            query.where(await compileToSQLFilter(scopeFilter, filterCompilers));
+        }
+
+        if (q.filter) {
+            query.where(await compileToSQLFilter(q.filter, filterCompilers));
+        }
+
+        if (q.search) {
+            let searchFilter: StamhoofdFilter | null = null;
+            searchFilter = {
+                description: {
+                    $contains: 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);
+        let balanceItems: BalanceItem[];
+
+        try {
+            balanceItems = await query.fetch();
+        }
+        catch (error) {
+            if (error.message.includes('ER_QUERY_TIMEOUT')) {
+                throw new SimpleError({
+                    code: 'timeout',
+                    message: 'Query took too long',
+                    human: $t(`dce51638-6129-448b-8a15-e6d778f3a76a`),
+                });
+            }
+            throw error;
+        }
+
+        let next: LimitedFilteredRequest | undefined;
+
+        if (balanceItems.length >= requestQuery.limit) {
+            const lastObject = balanceItems[balanceItems.length - 1];
+            const nextFilter = getSortFilter(lastObject, sorters, requestQuery.sort);
+
+            next = new LimitedFilteredRequest({
+                filter: requestQuery.filter,
+                pageFilter: nextFilter,
+                sort: requestQuery.sort,
+                limit: requestQuery.limit,
+                search: requestQuery.search,
+            });
+
+            if (JSON.stringify(nextFilter) === JSON.stringify(requestQuery.pageFilter)) {
+                console.error('Found infinite loading loop for', requestQuery);
+                next = undefined;
+            }
+        }
+
+        return new PaginatedResponse<BalanceItemStruct[], LimitedFilteredRequest>({
+            results: await AuthenticatedStructures.balanceItems(balanceItems),
+            next,
+        });
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.setOrganizationScope();
+        await Context.authenticate();
+
+        const maxLimit = Context.auth.hasSomePlatformAccess() ? 1000 : 100;
+
+        if (request.query.limit > maxLimit) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'limit',
+                message: 'Limit can not be more than ' + maxLimit,
+            });
+        }
+
+        if (request.query.limit < 1) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'limit',
+                message: 'Limit can not be less than 1',
+            });
+        }
+
+        return new Response(
+            await GetBalanceItemsEndpoint.buildData(request.query),
+        );
+    }
+}

package/src/endpoints/organization/dashboard/{payments → balance-items}/PatchBalanceItemsEndpoint.ts

@@ -242,7 +242,7 @@ export class PatchBalanceItemsEndpoint extends Endpoint<Params, Query, Body, Res
     }
 
     async validateMemberId(memberId: string) {
-        const member = (await Member.getWithRegistrations(memberId));
+        const member = (await Member.getByIdWithUsersAndRegistrations(memberId));
 
         if (!member || !(await Context.auth.canLinkBalanceItemToMember(member))) {
             throw new SimpleError({

package/src/endpoints/organization/dashboard/billing/GetOrganizationDetailedPayableBalanceEndpoint.ts

@@ -3,8 +3,8 @@ import { DetailedPayableBalanceCollection, PaymentStatus } from '@stamhoofd/stru
 
 import { BalanceItem, Payment } from '@stamhoofd/models';
 import { SQL } from '@stamhoofd/sql';
-import { Context } from '../../../../helpers/Context';
-import { GetUserDetailedPayableBalanceEndpoint } from '../../../global/registration/GetUserDetailedPayableBalanceEndpoint';
+import { Context } from '../../../../helpers/Context.js';
+import { GetUserDetailedPayableBalanceEndpoint } from '../../../global/registration/GetUserDetailedPayableBalanceEndpoint.js';
 
 type Params = Record<string, never>;
 type Query = undefined;

package/src/endpoints/organization/dashboard/billing/GetOrganizationPayableBalanceEndpoint.ts

@@ -1,8 +1,8 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { PayableBalanceCollection, ReceivableBalanceType } from '@stamhoofd/structures';
 
-import { Context } from '../../../../helpers/Context';
-import { GetUserPayableBalanceEndpoint } from '../../../global/registration/GetUserPayableBalanceEndpoint';
+import { Context } from '../../../../helpers/Context.js';
+import { GetUserPayableBalanceEndpoint } from '../../../global/registration/GetUserPayableBalanceEndpoint.js';
 
 type Params = Record<string, never>;
 type Query = undefined;

package/src/endpoints/organization/dashboard/billing/GetPackagesEndpoint.test.ts

@@ -2,9 +2,9 @@ import { Request } from '@simonbackx/simple-endpoints';
 import { OrganizationFactory, STPackageFactory } from '@stamhoofd/models';
 import { AccessRight, LimitedFilteredRequest, STPackageBundle, STPackageType } from '@stamhoofd/structures';
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';
-import { testServer } from '../../../../../tests/helpers/TestServer';
-import { initAdmin } from '../../../../../tests/init';
-import { GetPackagesEndpoint } from './GetPackagesEndpoint';
+import { testServer } from '../../../../../tests/helpers/TestServer.js';
+import { initAdmin } from '../../../../../tests/init/index.js';
+import { GetPackagesEndpoint } from './GetPackagesEndpoint.js';
 
 const baseUrl = `/organization/packages`;
 const endpoint = new GetPackagesEndpoint();

package/src/endpoints/organization/dashboard/billing/GetPackagesEndpoint.ts

@@ -1,7 +1,7 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { STPackage } from '@stamhoofd/models';
 import { OrganizationPackagesStatus, STPackage as STPackageStruct } from '@stamhoofd/structures';
-import { Context } from '../../../../helpers/Context';
+import { Context } from '../../../../helpers/Context.js';
+import { STPackageService } from '../../../../services/STPackageService.js';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -31,7 +31,7 @@ export class GetPackagesEndpoint extends Endpoint<Params, Query, Body, ResponseB
             throw Context.auth.error();
         }
 
-        const packages = await STPackage.getForOrganization(organization.id);
+        const packages = await STPackageService.getActivePackages(organization.id);
 
         return new Response(OrganizationPackagesStatus.create({
             packages: packages.map(p => STPackageStruct.create(p)),

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

@@ -2,7 +2,7 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import { SimpleError } from '@simonbackx/simple-errors';
 import { DocumentTemplate } from '@stamhoofd/models';
 
-import { Context } from '../../../../helpers/Context';
+import { Context } from '../../../../helpers/Context.js';
 
 type Params = { id: string };
 type Query = undefined;

package/src/endpoints/organization/dashboard/documents/GetDocumentsCountEndpoint.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 { GetDocumentsEndpoint } from './GetDocumentsEndpoint';
+import { Context } from '../../../../helpers/Context.js';
+import { GetDocumentsEndpoint } from './GetDocumentsEndpoint.js';
 
 type Params = Record<string, never>;
 type Query = CountFilteredRequest;

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

@@ -4,7 +4,7 @@ import { SimpleError } from '@simonbackx/simple-errors';
 import { Document, DocumentTemplate, Member, Registration } from '@stamhoofd/models';
 import { DocumentStatus, Document as DocumentStruct, PermissionLevel } from '@stamhoofd/structures';
 
-import { Context } from '../../../../helpers/Context';
+import { Context } from '../../../../helpers/Context.js';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -104,7 +104,7 @@ export class PatchDocumentEndpoint extends Endpoint<Params, Query, Body, Respons
                 put.memberId = registration.memberId;
             }
             if (put.memberId) {
-                const member = await Member.getWithRegistrations(put.memberId);
+                const member = await Member.getByIdWithUsersAndRegistrations(put.memberId);
                 if (!member || !await Context.auth.canAccessMember(member, PermissionLevel.Read)) {
                     throw new SimpleError({
                         code: 'not_found',

package/src/endpoints/organization/dashboard/email/CheckEmailBouncesEndpoint.ts

@@ -4,7 +4,7 @@ import { SimpleError } from '@simonbackx/simple-errors';
 import { EmailAddress } from '@stamhoofd/email';
 import { EmailInformation } from '@stamhoofd/structures';
 
-import { Context } from '../../../../helpers/Context';
+import { Context } from '../../../../helpers/Context.js';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -28,14 +28,17 @@ export class CheckEmailBouncesEndpoint extends Endpoint<Params, Query, Body, Res
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope();
+        const organization = await Context.setOptionalOrganizationScope();
         await Context.authenticate();
 
-        if (!await Context.auth.canAccessEmailBounces(organization.id)) {
+        // null if platform
+        const organizationId: string | null = organization ? organization.id : null;
+
+        if (!await Context.auth.canAccessEmailBounces(organizationId)) {
             throw Context.auth.error();
         }
 
-        if (request.body.length > 10000) {
+        if (request.body.length > 1000) {
             throw new SimpleError({
                 code: 'too_many_recipients',
                 message: 'Too many recipients',
@@ -44,7 +47,35 @@ export class CheckEmailBouncesEndpoint extends Endpoint<Params, Query, Body, Res
             });
         }
 
-        const emails = await EmailAddress.getByEmails(request.body, organization.id);
-        return new Response(emails.map(e => EmailInformation.create(e)));
+        const emails = await EmailAddress.getByEmails(request.body, organizationId);
+
+        // Remove duplicates + remove emails where all values are false
+        const cleaned: EmailInformation[] = [];
+        for (const email of emails) {
+            const c = EmailInformation.create(email);
+            const existing = cleaned.find(cc => cc.email === email.email);
+            if (existing) {
+                existing.markedAsSpam = existing.markedAsSpam || c.markedAsSpam;
+                existing.hardBounce = existing.hardBounce || c.hardBounce;
+
+                if (email.organizationId === null && organizationId === null) {
+                    // Only show unsubscribe status of platform
+                    existing.unsubscribedAll = c.unsubscribedAll;
+                    existing.unsubscribedMarketing = c.unsubscribedMarketing;
+                }
+                continue;
+            }
+
+            if (email.organizationId !== null && organizationId === null) {
+                // Only show unsubscribe status of platform
+                c.unsubscribedAll = false;
+                c.unsubscribedMarketing = false;
+            }
+
+            cleaned.push(c);
+        }
+
+        // We don't return empty ones to increase privacy a bit - admins should not know what email addresses are in the system unless they have bounced
+        return new Response(cleaned.filter(c => c.markedAsSpam || c.hardBounce || c.unsubscribedAll || c.unsubscribedMarketing));
     }
 }

package/src/endpoints/organization/dashboard/email-templates/GetEmailTemplatesEndpoint.test.ts

@@ -2,8 +2,8 @@ import { Request } from '@simonbackx/simple-endpoints';
 import { EmailTemplate, GroupFactory, Organization, OrganizationFactory, Platform, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
 import { EmailTemplateType, PermissionLevel, PermissionRoleDetailed, Permissions, PermissionsResourceType, ResourcePermissions, Version } from '@stamhoofd/structures';
 import { TestUtils } from '@stamhoofd/test-utils';
-import { testServer } from '../../../../../tests/helpers/TestServer';
-import { GetEmailTemplatesEndpoint } from './GetEmailTemplatesEndpoint';
+import { testServer } from '../../../../../tests/helpers/TestServer.js';
+import { GetEmailTemplatesEndpoint } from './GetEmailTemplatesEndpoint.js';
 
 const baseUrl = `/v${Version}/email-templates`;
 

package/src/endpoints/organization/dashboard/email-templates/GetEmailTemplatesEndpoint.ts

@@ -4,9 +4,9 @@ import { EmailTemplate } from '@stamhoofd/models';
 import { EmailTemplate as EmailTemplateStruct, EmailTemplateType } from '@stamhoofd/structures';
 
 import { SimpleError } from '@simonbackx/simple-errors';
-import { StringArrayDecoder } from '../../../../decoders/StringArrayDecoder';
-import { StringNullableDecoder } from '../../../../decoders/StringNullableDecoder';
-import { Context } from '../../../../helpers/Context';
+import { StringArrayDecoder } from '../../../../decoders/StringArrayDecoder.js';
+import { StringNullableDecoder } from '../../../../decoders/StringNullableDecoder.js';
+import { Context } from '../../../../helpers/Context.js';
 
 type Params = Record<string, never>;
 type Body = undefined;

package/src/endpoints/organization/dashboard/email-templates/PatchEmailTemplatesEndpoint.test.ts

@@ -3,8 +3,8 @@ import { Request } from '@simonbackx/simple-endpoints';
 import { EmailTemplate, GroupFactory, Organization, OrganizationFactory, Platform, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
 import { EmailTemplate as EmailTemplateStruct, EmailTemplateType, PermissionLevel, PermissionRoleDetailed, Permissions, PermissionsResourceType, ResourcePermissions, Version } from '@stamhoofd/structures';
 import { TestUtils } from '@stamhoofd/test-utils';
-import { testServer } from '../../../../../tests/helpers/TestServer';
-import { PatchEmailTemplatesEndpoint } from './PatchEmailTemplatesEndpoint';
+import { testServer } from '../../../../../tests/helpers/TestServer.js';
+import { PatchEmailTemplatesEndpoint } from './PatchEmailTemplatesEndpoint.js';
 
 const baseUrl = `/v${Version}/email-templates`;
 

package/src/endpoints/organization/dashboard/email-templates/PatchEmailTemplatesEndpoint.ts

@@ -3,7 +3,7 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import { EmailTemplate, Group, Webshop } from '@stamhoofd/models';
 import { EmailTemplate as EmailTemplateStruct, PermissionLevel } from '@stamhoofd/structures';
 
-import { Context } from '../../../../helpers/Context';
+import { Context } from '../../../../helpers/Context.js';
 
 type Params = Record<string, never>;
 type Body = PatchableArrayAutoEncoder<EmailTemplateStruct>;

package/src/endpoints/organization/dashboard/invoices/PatchInvoicesEndpoint.ts

@@ -0,0 +1,53 @@
+import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { Invoice as InvoiceStruct } from '@stamhoofd/structures';
+
+import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures.js';
+import { Context } from '../../../../helpers/Context.js';
+import { Invoice } from '@stamhoofd/models';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { ViesHelper } from '../../../../helpers/ViesHelper.js';
+import { InvoiceService } from '../../../../services/InvoiceService.js';
+
+type Params = Record<string, never>;
+type Query = undefined;
+type Body = PatchableArrayAutoEncoder<InvoiceStruct>;
+type ResponseBody = InvoiceStruct[];
+
+export class PatchInvoicesEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    bodyDecoder = new PatchableArrayDecoder(InvoiceStruct as Decoder<InvoiceStruct>, InvoiceStruct.patchType() as Decoder<AutoEncoderPatchType<InvoiceStruct>>, StringDecoder);
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'PATCH') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/invoices', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope();
+        await Context.authenticate();
+
+        // Fast throw first (more in depth checking for patches later)
+        if (!await Context.auth.hasFullAccess(organization.id)) {
+            throw Context.auth.error();
+        }
+
+        const invoices: Invoice[] = [];
+
+        for (const { put } of request.body.getPuts()) {
+            const model = await InvoiceService.createFrom(organization, put);
+            invoices.push(model);
+        }
+
+        return new Response(
+            await AuthenticatedStructures.invoices(invoices),
+        );
+    }
+}

package/src/endpoints/organization/dashboard/mollie/CheckMollieEndpoint.ts

@@ -2,8 +2,8 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import { MollieToken } from '@stamhoofd/models';
 import { CheckMollieResponse, Organization as OrganizationStruct, PermissionLevel } from '@stamhoofd/structures';
 
-import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
-import { Context } from '../../../../helpers/Context';
+import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures.js';
+import { Context } from '../../../../helpers/Context.js';
 
 type Params = Record<string, never>;
 type Body = undefined;

package/src/endpoints/organization/dashboard/mollie/ConnectMollieEndpoint.ts

@@ -3,9 +3,9 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import { MollieToken } from '@stamhoofd/models';
 import { Organization as OrganizationStruct, PermissionLevel } from '@stamhoofd/structures';
 
-import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
-import { checkMollieSettlementsFor } from '../../../../helpers/CheckSettlements';
-import { Context } from '../../../../helpers/Context';
+import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures.js';
+import { checkMollieSettlementsFor } from '../../../../helpers/CheckSettlements.js';
+import { Context } from '../../../../helpers/Context.js';
 
 type Params = Record<string, never>;
 

package/src/endpoints/organization/dashboard/mollie/DisconnectMollieEndpoint.ts

@@ -2,8 +2,8 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import { MollieToken } from '@stamhoofd/models';
 import { Organization as OrganizationStruct, PermissionLevel } from '@stamhoofd/structures';
 
-import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
-import { Context } from '../../../../helpers/Context';
+import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures.js';
+import { Context } from '../../../../helpers/Context.js';
 
 type Params = Record<string, never>;
 type Body = undefined;

package/src/endpoints/organization/dashboard/mollie/GetMollieDashboardEndpoint.ts

@@ -3,7 +3,7 @@ import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-e
 import { MollieToken } from '@stamhoofd/models';
 import { PermissionLevel } from '@stamhoofd/structures';
 
-import { Context } from '../../../../helpers/Context';
+import { Context } from '../../../../helpers/Context.js';
 
 type Params = Record<string, never>;
 type Body = undefined;

package/src/endpoints/organization/dashboard/nolt/CreateNoltTokenEndpoint.ts

@@ -2,7 +2,7 @@ import { AutoEncoder, field, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import jwt from 'jsonwebtoken';
 
-import { Context } from '../../../../helpers/Context';
+import { Context } from '../../../../helpers/Context.js';
 import { SimpleError } from '@simonbackx/simple-errors';
 
 type Params = Record<string, never>;

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

@@ -3,8 +3,8 @@ import { SimpleError } from '@simonbackx/simple-errors';
 import { Group, Token } from '@stamhoofd/models';
 import { Group as GroupStruct, GroupStatus } from '@stamhoofd/structures';
 
-import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
-import { Context } from '../../../../helpers/Context';
+import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures.js';
+import { Context } from '../../../../helpers/Context.js';
 type Params = Record<string, never>;
 type Query = undefined;
 type Body = undefined;