@stamhoofd/backend 2.39.1 → 2.40.1

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

@@ -1,7 +1,7 @@
 import { Decoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError, SimpleErrors } from '@simonbackx/simple-errors';
-import { DNSRecord, DNSRecordType, Organization as OrganizationStruct,OrganizationDomains } from "@stamhoofd/structures";
+import { DNSRecord, DNSRecordType, Organization as OrganizationStruct, OrganizationDomains } from '@stamhoofd/structures';
 import NodeRSA from 'node-rsa';
 
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
@@ -11,21 +11,21 @@ import { Formatter } from '@stamhoofd/utility';
 type Params = Record<string, never>;
 type Query = undefined;
 type Body = OrganizationDomains;
-type ResponseBody = OrganizationStruct
+type ResponseBody = OrganizationStruct;
 
 /**
  * One endpoint to create, patch and delete groups. Usefull because on organization setup, we need to create multiple groups at once. Also, sometimes we need to link values and update multiple groups at once
  */
 
 export class SetOrganizationDomainEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = OrganizationDomains as Decoder<OrganizationDomains>
+    bodyDecoder = OrganizationDomains as Decoder<OrganizationDomains>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/organization/domain", {});
+        const params = Endpoint.parseParameters(request.url, '/organization/domain', {});
 
         if (params) {
             return [true, params as Params];
@@ -35,162 +35,161 @@ export class SetOrganizationDomainEndpoint extends Endpoint<Params, Query, Body,
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
-        await Context.authenticate()
+        await Context.authenticate();
 
         if (!await Context.auth.canManageOrganizationDomain(organization.id)) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
 
-        const errors = new SimpleErrors()
+        const errors = new SimpleErrors();
 
         // check if changed
         if (
-            (organization.privateMeta.pendingRegisterDomain ?? organization.registerDomain) !== request.body.registerDomain  // changed register domain
-            || 
-            (organization.privateMeta.pendingMailDomain ?? organization.privateMeta.mailDomain) !== request.body.mailDomain  // changed pending domain
+            (organization.privateMeta.pendingRegisterDomain ?? organization.registerDomain) !== request.body.registerDomain // changed register domain
+            || (organization.privateMeta.pendingMailDomain ?? organization.privateMeta.mailDomain) !== request.body.mailDomain // changed pending domain
         ) {
-            console.log("Domains changed")
+            console.log('Domains changed');
 
             // Validate domains
-            // eslint-disable-next-line @typescript-eslint/prefer-regexp-exec
+
             if (request.body.registerDomain !== null && !request.body.registerDomain.match(/^([a-zA-Z0-9-]+\.)?[a-zA-Z0-9-]+\.[a-zA-Z]+$/)) {
                 throw new SimpleError({
-                    code: "invalid_domain",
-                    message: "registerDomain is invalid",
-                    human: "De subdomeinnaam voor jouw registratiepagina is ongeldig",
-                    field: "registerDomain"
-                })
+                    code: 'invalid_domain',
+                    message: 'registerDomain is invalid',
+                    human: 'De subdomeinnaam voor jouw registratiepagina is ongeldig',
+                    field: 'registerDomain',
+                });
             }
-            
-            // eslint-disable-next-line @typescript-eslint/prefer-regexp-exec
+
             if (request.body.mailDomain !== null && !request.body.mailDomain.match(/^([a-zA-Z0-9-]+\.)?[a-zA-Z0-9-]+\.[a-zA-Z]+$/)) {
                 throw new SimpleError({
-                    code: "invalid_domain",
-                    message: "mailDomain is invalid",
-                    human: "De domeinnaam voor e-mails is ongeldig",
-                    field: "mailDomain"
-                })
+                    code: 'invalid_domain',
+                    message: 'mailDomain is invalid',
+                    human: 'De domeinnaam voor e-mails is ongeldig',
+                    field: 'mailDomain',
+                });
             }
 
-            const oldMailDomain = organization.privateMeta.mailDomain
+            const oldMailDomain = organization.privateMeta.mailDomain;
 
-            organization.privateMeta.pendingRegisterDomain = request.body.registerDomain?.toLowerCase() ?? null
-            organization.privateMeta.pendingMailDomain = request.body.mailDomain?.toLowerCase() ?? null
+            organization.privateMeta.pendingRegisterDomain = request.body.registerDomain?.toLowerCase() ?? null;
+            organization.privateMeta.pendingMailDomain = request.body.mailDomain?.toLowerCase() ?? null;
 
             // We don't keep the current register domain because we have no way to validate the old DNS-records
             if (organization.privateMeta.pendingRegisterDomain === null || organization.registerDomain !== organization.privateMeta.pendingRegisterDomain) {
-                organization.registerDomain = null
+                organization.registerDomain = null;
             }
 
             // We don't keep the current mail domain because we have no way to validate the old DNS-records
             if (organization.privateMeta.pendingMailDomain === null || organization.privateMeta.mailDomain !== organization.privateMeta.pendingMailDomain) {
-                organization.privateMeta.mailDomain = null
+                organization.privateMeta.mailDomain = null;
             }
 
             // Always temporary disable mail domain until validated
-            organization.privateMeta.mailDomainActive = false
+            organization.privateMeta.mailDomainActive = false;
 
             // Reset notification counters
-            organization.serverMeta.DNSRecordWarningCount = 0
-            organization.serverMeta.firstInvalidDNSRecords = undefined
-            organization.serverMeta.didSendDomainSetupMail = false
+            organization.serverMeta.DNSRecordWarningCount = 0;
+            organization.serverMeta.firstInvalidDNSRecords = undefined;
+            organization.serverMeta.didSendDomainSetupMail = false;
 
             // Generate new DNS-records
-            organization.privateMeta.dnsRecords = []
+            organization.privateMeta.dnsRecords = [];
 
             if (organization.privateMeta.pendingMailDomain !== null) {
-                const defaultFromDomain = Formatter.slug(STAMHOOFD.platformName) + "." + organization.privateMeta.pendingMailDomain;
+                const defaultFromDomain = Formatter.slug(STAMHOOFD.platformName) + '.' + organization.privateMeta.pendingMailDomain;
                 if (organization.privateMeta.pendingRegisterDomain === null || !organization.privateMeta.pendingRegisterDomain.endsWith('.' + organization.privateMeta.pendingMailDomain)) {
                     // We set a custom domainname for webshops already
                     // This is not used at this moment
                     organization.privateMeta.mailFromDomain = defaultFromDomain;
-                } else {
+                }
+                else {
                     // CNAME domain: for SPF + MX + A record
                     organization.privateMeta.mailFromDomain = organization.privateMeta.pendingRegisterDomain;
                 }
 
                 if (organization.privateMeta.mailFromDomain !== organization.privateMeta.pendingRegisterDomain) {
+                    organization.privateMeta.dnsRecords.push(DNSRecord.create({
+                        type: DNSRecordType.CNAME,
+                        name: organization.privateMeta.mailFromDomain + '.',
+                        // Use shops for mail domain, to allow reuse
+                        value: STAMHOOFD.domains.webshopCname + '.',
+                    }));
+
+                    if (STAMHOOFD.domains.registration && organization.privateMeta.pendingRegisterDomain) {
                         organization.privateMeta.dnsRecords.push(DNSRecord.create({
                             type: DNSRecordType.CNAME,
-                            name: organization.privateMeta.mailFromDomain + ".",
-                            // Use shops for mail domain, to allow reuse
-                            value: STAMHOOFD.domains.webshopCname + "."
-                        }))
-
-                        if (STAMHOOFD.domains.registration && organization.privateMeta.pendingRegisterDomain) {
-                            organization.privateMeta.dnsRecords.push(DNSRecord.create({
-                                type: DNSRecordType.CNAME,
-                                name: organization.privateMeta.pendingRegisterDomain+".",
-                                // Use registration domain
-                                value: STAMHOOFD.domains.registrationCname + "."
-                            }))
-                        }
-                } else {
+                            name: organization.privateMeta.pendingRegisterDomain + '.',
+                            // Use registration domain
+                            value: STAMHOOFD.domains.registrationCname + '.',
+                        }));
+                    }
+                }
+                else {
                     organization.privateMeta.dnsRecords.push(DNSRecord.create({
                         type: DNSRecordType.CNAME,
-                        name: organization.privateMeta.mailFromDomain+".",
+                        name: organization.privateMeta.mailFromDomain + '.',
                         // Use registration domain
-                        value: STAMHOOFD.domains.registrationCname + "."
-                    }))
+                        value: STAMHOOFD.domains.registrationCname + '.',
+                    }));
                 }
             }
 
             if (request.body.mailDomain !== null) {
+                let priv: string;
+                let pub: string;
 
-                let priv: string
-                let pub: string
-
-                if (!organization.serverMeta.privateDKIMKey || !organization.serverMeta.publicDKIMKey ) {
+                if (!organization.serverMeta.privateDKIMKey || !organization.serverMeta.publicDKIMKey) {
                     const key = new NodeRSA({ b: request.body.useDkim1024bit ? 1024 : 2048 });
-                    const privArr = (key.exportKey('private') as string).split("\n")
-                    priv = privArr.splice(1, privArr.length - 2).join("");
+                    const privArr = (key.exportKey('private') as string).split('\n');
+                    priv = privArr.splice(1, privArr.length - 2).join('');
 
-                    const pubArr = (key.exportKey('public') as string).split("\n")
-                    pub = pubArr.splice(1, pubArr.length - 2).join("");
+                    const pubArr = (key.exportKey('public') as string).split('\n');
+                    pub = pubArr.splice(1, pubArr.length - 2).join('');
 
-                    organization.serverMeta.privateDKIMKey = priv
-                    organization.serverMeta.publicDKIMKey = pub
-                } else {
-                    priv = organization.serverMeta.privateDKIMKey
-                    pub = organization.serverMeta.publicDKIMKey
+                    organization.serverMeta.privateDKIMKey = priv;
+                    organization.serverMeta.publicDKIMKey = pub;
+                }
+                else {
+                    priv = organization.serverMeta.privateDKIMKey;
+                    pub = organization.serverMeta.publicDKIMKey;
                 }
 
                 // DKIM records
                 organization.privateMeta.dnsRecords.push(DNSRecord.create({
                     type: DNSRecordType.TXT,
-                    name: "stamhoofd._domainkey." + request.body.mailDomain + ".",
-                    value: "v=DKIM1; k=rsa; p=" + pub + ""
-                }))
-            } else {
+                    name: 'stamhoofd._domainkey.' + request.body.mailDomain + '.',
+                    value: 'v=DKIM1; k=rsa; p=' + pub + '',
+                }));
+            }
+            else {
                 if (oldMailDomain) {
-                    organization.deleteAWSMailIdenitity(oldMailDomain).catch(console.error)
+                    organization.deleteAWSMailIdenitity(oldMailDomain).catch(console.error);
                 }
 
-                if (organization.serverMeta.privateDKIMKey && organization.serverMeta.publicDKIMKey ) {
+                if (organization.serverMeta.privateDKIMKey && organization.serverMeta.publicDKIMKey) {
                     // Allow creation of new keys for new domains
-                    console.log("Backup DKIM keys for "+organization.id)
-                    console.log("Private: "+organization.serverMeta.privateDKIMKey)
-                    console.log("Public: "+organization.serverMeta.publicDKIMKey)
+                    console.log('Backup DKIM keys for ' + organization.id);
+                    console.log('Private: ' + organization.serverMeta.privateDKIMKey);
+                    console.log('Public: ' + organization.serverMeta.publicDKIMKey);
 
                     // Delete keys if mail domain is deleted -> to allow new keys
-                    organization.serverMeta.privateDKIMKey = undefined
-                    organization.serverMeta.publicDKIMKey = undefined
+                    organization.serverMeta.privateDKIMKey = undefined;
+                    organization.serverMeta.publicDKIMKey = undefined;
                 }
             }
 
-            await organization.save()
-
-        } else {
+            await organization.save();
+        }
+        else {
             // Validate DNS-records if not empty
-            console.log("Validating domains")
-            await organization.updateDNSRecords()
+            console.log('Validating domains');
+            await organization.updateDNSRecords();
         }
 
-        console.log("Done.")
-        
-        errors.throwIfNotEmpty()
+        console.log('Done.');
+
+        errors.throwIfNotEmpty();
         return new Response(await AuthenticatedStructures.organization(organization));
     }
-
-    
 }

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

@@ -1,6 +1,6 @@
 import { Decoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { OpenIDClientConfiguration } from "@stamhoofd/structures";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { OpenIDClientConfiguration } from '@stamhoofd/structures';
 
 import { Context } from '../../../../helpers/Context';
 import { OpenIDConnectHelper } from '../../../../helpers/OpenIDConnectHelper';
@@ -8,21 +8,21 @@ import { OpenIDConnectHelper } from '../../../../helpers/OpenIDConnectHelper';
 type Params = Record<string, never>;
 type Query = undefined;
 type Body = OpenIDClientConfiguration;
-type ResponseBody = OpenIDClientConfiguration
+type ResponseBody = OpenIDClientConfiguration;
 
 /**
  * One endpoint to create, patch and delete groups. Usefull because on organization setup, we need to create multiple groups at once. Also, sometimes we need to link values and update multiple groups at once
  */
 
 export class SetOrganizationSSOEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = OpenIDClientConfiguration as Decoder<OpenIDClientConfiguration>
+    bodyDecoder = OpenIDClientConfiguration as Decoder<OpenIDClientConfiguration>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/organization/sso", {});
+        const params = Endpoint.parseParameters(request.url, '/organization/sso', {});
 
         if (params) {
             return [true, params as Params];
@@ -32,18 +32,18 @@ export class SetOrganizationSSOEndpoint extends Endpoint<Params, Query, Body, Re
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
-        await Context.authenticate()
+        await Context.authenticate();
 
         if (!await Context.auth.canManageSSOSettings(organization.id)) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
 
         // Validate configuration
-        const helper = new OpenIDConnectHelper(organization, request.body)
-        await helper.getClient()
+        const helper = new OpenIDConnectHelper(organization, request.body);
+        await helper.getClient();
 
-        organization.serverMeta.ssoConfiguration = request.body
-        await organization.save()
+        organization.serverMeta.ssoConfiguration = request.body;
+        await organization.save();
 
         return new Response(request.body);
     }

package/src/endpoints/organization/dashboard/payments/GetMemberBalanceEndpoint.ts

@@ -1,22 +1,22 @@
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { SimpleError } from "@simonbackx/simple-errors";
-import { BalanceItem, Group, Member } from "@stamhoofd/models";
-import { BalanceItemWithPayments } from "@stamhoofd/structures";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { BalanceItem, Group, Member } from '@stamhoofd/models';
+import { BalanceItemWithPayments } from '@stamhoofd/structures';
 
-import { Context } from "../../../../helpers/Context";
+import { Context } from '../../../../helpers/Context';
 
 type Params = { id: string };
-type Query = undefined
-type Body = undefined
-type ResponseBody = BalanceItemWithPayments[]
+type Query = undefined;
+type Body = undefined;
+type ResponseBody = BalanceItemWithPayments[];
 
 export class GetMemberBalanceEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
+        if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/organization/members/@id/balance", { id: String});
+        const params = Endpoint.parseParameters(request.url, '/organization/members/@id/balance', { id: String });
 
         if (params) {
             return [true, params as Params];
@@ -26,23 +26,23 @@ export class GetMemberBalanceEndpoint extends Endpoint<Params, Query, Body, Resp
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
-        await Context.authenticate()
+        await Context.authenticate();
 
         if (!await Context.auth.hasSomeAccess(organization.id)) {
-            throw Context.auth.error()
-        } 
+            throw Context.auth.error();
+        }
 
-        const member = (await Member.getWithRegistrations(request.params.id))
+        const member = (await Member.getWithRegistrations(request.params.id));
 
         if (!member || !await Context.auth.hasFinancialMemberAccess(member)) {
-            throw Context.auth.notFoundOrNoAccess("Geen lid gevonden, of je hebt geen toegang tot dit lid")
+            throw Context.auth.notFoundOrNoAccess('Geen lid gevonden, of je hebt geen toegang tot dit lid');
         }
 
         // Get all balance items for this member or users
-        const balanceItems = await BalanceItem.balanceItemsForUsersAndMembers(organization.id, member.users.map(u => u.id), [member.id])
+        const balanceItems = await BalanceItem.balanceItemsForUsersAndMembers(organization.id, member.users.map(u => u.id), [member.id]);
 
         return new Response(
-            await BalanceItem.getStructureWithPayments(balanceItems)
+            await BalanceItem.getStructureWithPayments(balanceItems),
         );
     }
 }

package/src/endpoints/organization/dashboard/payments/GetPaymentsCountEndpoint.ts

@@ -11,14 +11,14 @@ type Body = undefined;
 type ResponseBody = CountResponse;
 
 export class GetPaymentsCountEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = CountFilteredRequest as Decoder<CountFilteredRequest>
+    queryDecoder = CountFilteredRequest as Decoder<CountFilteredRequest>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
+        if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/payments/count", {});
+        const params = Endpoint.parseParameters(request.url, '/payments/count', {});
 
         if (params) {
             return [true, params as Params];
@@ -28,16 +28,16 @@ export class GetPaymentsCountEndpoint extends Endpoint<Params, Query, Body, Resp
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         await Context.setOrganizationScope();
-        await Context.authenticate()
-        const query = await GetPaymentsEndpoint.buildQuery(request.query)
-        
+        await Context.authenticate();
+        const query = await GetPaymentsEndpoint.buildQuery(request.query);
+
         const count = await query
             .count();
 
         return new Response(
             CountResponse.create({
-                count
-            })
+                count,
+            }),
         );
     }
 }