@stamhoofd/backend 2.39.1 → 2.40.0

package/src/endpoints/auth/VerifyEmailEndpoint.ts

@@ -1,8 +1,8 @@
 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 } from '@simonbackx/simple-errors';
 import { EmailVerificationCode, Token, User } from '@stamhoofd/models';
-import { Token as TokenStruct, VerifyEmailRequest } from "@stamhoofd/structures";
+import { Token as TokenStruct, VerifyEmailRequest } from '@stamhoofd/structures';
 
 import { Context } from '../../helpers/Context';
 
@@ -15,11 +15,11 @@ export class VerifyEmailEndpoint extends Endpoint<Params, Query, Body, ResponseB
     bodyDecoder = VerifyEmailRequest as Decoder<VerifyEmailRequest>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/verify-email", {});
+        const params = Endpoint.parseParameters(request.url, '/verify-email', {});
 
         if (params) {
             return [true, params as Params];
@@ -30,54 +30,55 @@ export class VerifyEmailEndpoint extends Endpoint<Params, Query, Body, ResponseB
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOptionalOrganizationScope();
 
-        const code = await EmailVerificationCode.verify(organization?.id ?? null, request.body.token, request.body.code)
+        const code = await EmailVerificationCode.verify(organization?.id ?? null, request.body.token, request.body.code);
 
         if (!code) {
             throw new SimpleError({
-                code: "invalid_code",
-                message: "This code is invalid",
-                human: "Deze code is ongeldig of vervallen.",
-                statusCode: 400
-            })
+                code: 'invalid_code',
+                message: 'This code is invalid',
+                human: 'Deze code is ongeldig of vervallen.',
+                statusCode: 400,
+            });
         }
 
-        const user = await User.getByID(code.userId)
+        const user = await User.getByID(code.userId);
 
         if (!user || (user.organizationId !== null && user.organizationId !== (organization?.id ?? null))) {
             throw new SimpleError({
-                code: "invalid_code",
-                message: "This code is invalid",
-                human: "Deze code is ongeldig of vervallen.",
-                statusCode: 400
-            })
+                code: 'invalid_code',
+                message: 'This code is invalid',
+                human: 'Deze code is ongeldig of vervallen.',
+                statusCode: 400,
+            });
         }
 
-        if (user.email != code.email) {
-            const other = await User.getForAuthentication(user.organizationId, code.email, {allowWithoutAccount: true})
+        if (user.email !== code.email) {
+            const other = await User.getForAuthentication(user.organizationId, code.email, { allowWithoutAccount: true });
 
             if (other) {
                 // Delete the other user, but merge data
                 await user.merge(other);
             }
-            
+
             // change user email
-            user.email = code.email
+            user.email = code.email;
 
             // If already in use: will fail, so will verification
         }
 
-        user.verified = true
+        user.verified = true;
 
         try {
-            await user.save()
-        } catch (e) {
+            await user.save();
+        }
+        catch (e) {
             // Duplicate key probably
-            if (e.code && e.code == "ER_DUP_ENTRY") {
+            if (e.code && e.code == 'ER_DUP_ENTRY') {
                 throw new SimpleError({
-                    code: "email_in_use",
-                    message: "This e-mail is already in use, we cannot set it",
-                    human: "We kunnen het e-mailadres van deze gebruiker niet instellen naar "+code.email+", omdat die al in gebruik is. Waarschijnlijk heb je meerdere accounts. Probeer met dat e-mailadres in te loggen of contacteer ons ("+request.$t("59b85264-c4c3-4cf6-8923-9b43282b2787")+") als we de gebruikers moeten combineren tot één gebruiker."
-                })
+                    code: 'email_in_use',
+                    message: 'This e-mail is already in use, we cannot set it',
+                    human: 'We kunnen het e-mailadres van deze gebruiker niet instellen naar ' + code.email + ', omdat die al in gebruik is. Waarschijnlijk heb je meerdere accounts. Probeer met dat e-mailadres in te loggen of contacteer ons (' + request.$t('59b85264-c4c3-4cf6-8923-9b43282b2787') + ') als we de gebruikers moeten combineren tot één gebruiker.',
+                });
             }
             throw e;
         }

package/src/endpoints/global/addresses/SearchRegionsEndpoint.ts

@@ -1,27 +1,27 @@
 import { AutoEncoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { City } from '@stamhoofd/models';
 import { Province } from '@stamhoofd/models';
-import { City as CityStruct, Country, Province as ProvinceStruct,SearchRegions } from "@stamhoofd/structures";
+import { City as CityStruct, Country, Province as ProvinceStruct, SearchRegions } from '@stamhoofd/structures';
 import { StringCompare } from '@stamhoofd/utility';
 
 type Params = Record<string, never>;
 class Query extends AutoEncoder {
     @field({ decoder: StringDecoder })
-    query: string
+    query: string;
 }
 type Body = undefined;
 type ResponseBody = SearchRegions;
 
 export class SearchRegionsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = Query as Decoder<Query>
-    
+    queryDecoder = Query as Decoder<Query>;
+
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
+        if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/address/search", {});
+        const params = Endpoint.parseParameters(request.url, '/address/search', {});
 
         if (params) {
             return [true, params as Params];
@@ -30,8 +30,8 @@ export class SearchRegionsEndpoint extends Endpoint<Params, Query, Body, Respons
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-         // Escape query
-        const query = request.query.query.replace(/([-+><()~*"@\s]+)/g, " ").replace(/[^\w\d]+$/, "")
+        // Escape query
+        const query = request.query.query.replace(/([-+><()~*"@\s]+)/g, ' ').replace(/[^\w\d]+$/, '');
         if (query.length == 0) {
             // Do not try searching...
             return new Response(SearchRegions.create({
@@ -42,9 +42,9 @@ export class SearchRegionsEndpoint extends Endpoint<Params, Query, Body, Respons
         }
 
         const match = {
-            sign: "MATCH",
-            value: query + "*", // We replace special operators in boolean mode with spaces since special characters aren't indexed anyway
-            mode: "BOOLEAN"
+            sign: 'MATCH',
+            value: query + '*', // We replace special operators in boolean mode with spaces since special characters aren't indexed anyway
+            mode: 'BOOLEAN',
         };
 
         // We had to add an order by in the query to fix the limit. MySQL doesn't want to limit the results correctly if we don't explicitly sort the results on their relevance
@@ -53,11 +53,11 @@ export class SearchRegionsEndpoint extends Endpoint<Params, Query, Body, Respons
             sort: [
                 {
                     column: { name: match },
-                    direction: "DESC"
-                }
-            ]
+                    direction: 'DESC',
+                },
+            ],
         });
-        const loadedCities: (City & { province: Province })[] = []
+        const loadedCities: (City & { province: Province })[] = [];
 
         // We had to add an order by in the query to fix the limit. MySQL doesn't want to limit the results correctly if we don't explicitly sort the results on their relevance
         const allProvinces = await Province.all();
@@ -67,41 +67,41 @@ export class SearchRegionsEndpoint extends Endpoint<Params, Query, Body, Respons
             if (!province) {
                 continue;
             }
-            loadedCities.push(city.setRelation(City.province, province))
+            loadedCities.push(city.setRelation(City.province, province));
         }
 
-        const provinces: Province[] = []
+        const provinces: Province[] = [];
         for (const province of allProvinces) {
             if (StringCompare.typoCount(request.query.query, province.name) < 3) {
-                provinces.push(province)
+                provinces.push(province);
             }
         }
 
-        const countries: Country[] = []
-        if (StringCompare.typoCount(request.query.query, "België") < 3) {
-            countries.push(Country.Belgium)
+        const countries: Country[] = [];
+        if (StringCompare.typoCount(request.query.query, 'België') < 3) {
+            countries.push(Country.Belgium);
         }
 
-        if (StringCompare.typoCount(request.query.query, "Nederland") < 3) {
-            countries.push(Country.Netherlands)
+        if (StringCompare.typoCount(request.query.query, 'Nederland') < 3) {
+            countries.push(Country.Netherlands);
         }
 
-        if (StringCompare.typoCount(request.query.query, "Luxemburg") < 3) {
-            countries.push(Country.Luxembourg)
+        if (StringCompare.typoCount(request.query.query, 'Luxemburg') < 3) {
+            countries.push(Country.Luxembourg);
         }
 
-        if (StringCompare.typoCount(request.query.query, "Duitsland") < 3) {
-            countries.push(Country.Germany)
+        if (StringCompare.typoCount(request.query.query, 'Duitsland') < 3) {
+            countries.push(Country.Germany);
         }
 
-        if (StringCompare.typoCount(request.query.query, "Frankrijk") < 3) {
-            countries.push(Country.France)
+        if (StringCompare.typoCount(request.query.query, 'Frankrijk') < 3) {
+            countries.push(Country.France);
         }
-        
+
         return new Response(SearchRegions.create({
-            cities: loadedCities.map(c => CityStruct.create(Object.assign({...c}, { province: ProvinceStruct.create(c.province) }))),
+            cities: loadedCities.map(c => CityStruct.create(Object.assign({ ...c }, { province: ProvinceStruct.create(c.province) }))),
             provinces: provinces.map(c => ProvinceStruct.create(c)),
-            countries: countries
+            countries: countries,
         }));
     }
 }

package/src/endpoints/global/addresses/ValidateAddressEndpoint.ts

@@ -1,23 +1,23 @@
 import { Decoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { Address, ValidatedAddress } from "@stamhoofd/structures";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { Address, ValidatedAddress } from '@stamhoofd/structures';
 
 import { AddressValidator } from '../../../helpers/AddressValidator';
 
 type Params = Record<string, never>;
 type Query = undefined;
-type Body = Address
+type Body = Address;
 type ResponseBody = ValidatedAddress;
 
 export class ValidateAddressEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = Address as Decoder<Address>
-    
+    bodyDecoder = Address as Decoder<Address>;
+
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/address/validate", {});
+        const params = Endpoint.parseParameters(request.url, '/address/validate', {});
 
         if (params) {
             return [true, params as Params];

package/src/endpoints/global/caddy/CheckDomainCertEndpoint.ts

@@ -1,5 +1,5 @@
-import { AutoEncoder, Decoder, field, StringDecoder } from "@simonbackx/simple-encoding";
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { AutoEncoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Organization, Webshop } from '@stamhoofd/models';
 type Params = Record<string, never>;
@@ -9,20 +9,20 @@ class Query extends AutoEncoder {
     domain: string;
 }
 
-type Body = undefined
+type Body = undefined;
 type ResponseBody = undefined;
 
 export class CheckDomainCertEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     queryDecoder = Query as Decoder<Query>;
 
-    registrationDomains = [... new Set(Object.values(STAMHOOFD.domains.registration ?? {}))]
+    registrationDomains = [...new Set(Object.values(STAMHOOFD.domains.registration ?? {}))];
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
+        if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/check-domain-cert", {});
+        const params = Endpoint.parseParameters(request.url, '/check-domain-cert', {});
 
         if (params) {
             return [true, params as Params];
@@ -33,69 +33,69 @@ export class CheckDomainCertEndpoint extends Endpoint<Params, Query, Body, Respo
     async handle(request: DecodedRequest<Params, Query, Body>) {
         // check if the domain ends on one of our localized registration domains
         for (const domain of this.registrationDomains) {
-            if (request.query.domain.endsWith("." + domain)) {
-                const strippped = request.query.domain.substr(0, request.query.domain.length - ("." + domain).length )
-                if (strippped.includes(".")) {
+            if (request.query.domain.endsWith('.' + domain)) {
+                const strippped = request.query.domain.substr(0, request.query.domain.length - ('.' + domain).length);
+                if (strippped.includes('.')) {
                     throw new SimpleError({
-                        code: "invalid_domain",
-                        message: "This domain format is not supported",
-                        statusCode: 404
-                    })
+                        code: 'invalid_domain',
+                        message: 'This domain format is not supported',
+                        statusCode: 404,
+                    });
                 }
 
                 // Search for the URI
-                const organization = await Organization.getByURI(strippped)
+                const organization = await Organization.getByURI(strippped);
 
                 if (!organization) {
                     throw new SimpleError({
-                        code: "unknown_domain",
-                        message: "Not known",
-                        statusCode: 404
-                    })
+                        code: 'unknown_domain',
+                        message: 'Not known',
+                        statusCode: 404,
+                    });
                 }
                 return new Response(undefined);
             }
         }
-        
-        if (STAMHOOFD.domains.legacyWebshop && request.query.domain.endsWith("." + STAMHOOFD.domains.legacyWebshop)) {
-            const strippped = request.query.domain.substr(0, request.query.domain.length - ("." + STAMHOOFD.domains.legacyWebshop).length )
-            if (strippped.includes(".")) {
+
+        if (STAMHOOFD.domains.legacyWebshop && request.query.domain.endsWith('.' + STAMHOOFD.domains.legacyWebshop)) {
+            const strippped = request.query.domain.substr(0, request.query.domain.length - ('.' + STAMHOOFD.domains.legacyWebshop).length);
+            if (strippped.includes('.')) {
                 throw new SimpleError({
-                    code: "invalid_domain",
-                    message: "This domain format is not supported",
-                    statusCode: 404
-                })
+                    code: 'invalid_domain',
+                    message: 'This domain format is not supported',
+                    statusCode: 404,
+                });
             }
 
             // Search for the URI
-            const organization = await Organization.getByURI(strippped)
+            const organization = await Organization.getByURI(strippped);
 
             if (!organization) {
                 throw new SimpleError({
-                    code: "unknown_domain",
-                    message: "Not known",
-                    statusCode: 404
-                })
+                    code: 'unknown_domain',
+                    message: 'Not known',
+                    statusCode: 404,
+                });
             }
             return new Response(undefined);
         }
 
         // Check if we have an organization with a custom domain name
-        const organization = await Organization.getByRegisterDomain(request.query.domain)
+        const organization = await Organization.getByRegisterDomain(request.query.domain);
 
         if (organization) {
             return new Response(undefined);
         }
 
-        const webshops = await Webshop.getByDomainOnly(request.query.domain)
+        const webshops = await Webshop.getByDomainOnly(request.query.domain);
         if (webshops.length > 0) {
             return new Response(undefined);
         }
 
         throw new SimpleError({
-            code: "unknown_domain",
-            message: "Not known",
-            statusCode: 404
-        })
+            code: 'unknown_domain',
+            message: 'Not known',
+            statusCode: 404,
+        });
     }
 }

package/src/endpoints/global/email/CreateEmailEndpoint.ts

@@ -1,44 +1,44 @@
 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 { Email, EmailTemplate, RateLimiter } from '@stamhoofd/models';
-import { EmailPreview, EmailStatus, Email as EmailStruct, Version, EmailTemplate as EmailTemplateStruct } from "@stamhoofd/structures";
+import { EmailPreview, EmailStatus, Email as EmailStruct, Version, EmailTemplate as EmailTemplateStruct } from '@stamhoofd/structures';
 
 import { Context } from '../../../helpers/Context';
 import { SQL } from '@stamhoofd/sql';
 
 type Params = Record<string, never>;
 type Query = undefined;
-type Body = EmailStruct
+type Body = EmailStruct;
 type ResponseBody = EmailPreview;
 
 export const paidEmailRateLimiter = new RateLimiter({
     limits: [
-        {   
+        {
             // Max 5.000 emails a day
             limit: 5000,
-            duration: 24 * 60 * 1000 * 60
+            duration: 24 * 60 * 1000 * 60,
         },
-        {   
+        {
             // 10.000 requests per week
             limit: 10000,
-            duration: 24 * 60 * 1000 * 60 * 7
-        }
-    ]
+            duration: 24 * 60 * 1000 * 60 * 7,
+        },
+    ],
 });
 
 export const freeEmailRateLimiter = new RateLimiter({
     limits: [
-        {   
+        {
             // Max 100 a day
             limit: 100,
-            duration: 24 * 60 * 1000 * 60
+            duration: 24 * 60 * 1000 * 60,
         },
-        {   
+        {
             // Max 200 a week
             limit: 200,
-            duration: 7 * 24 * 60 * 1000 * 60
-        }
-    ]
+            duration: 7 * 24 * 60 * 1000 * 60,
+        },
+    ],
 });
 
 /**
@@ -46,14 +46,14 @@ export const freeEmailRateLimiter = new RateLimiter({
  */
 
 export class CreateEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = EmailStruct as Decoder<EmailStruct>
+    bodyDecoder = EmailStruct as Decoder<EmailStruct>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/email", {});
+        const params = Endpoint.parseParameters(request.url, '/email', {});
 
         if (params) {
             return [true, params as Params];
@@ -63,10 +63,10 @@ export class CreateEmailEndpoint extends Endpoint<Params, Query, Body, ResponseB
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOptionalOrganizationScope();
-        const {user} = await Context.authenticate()
+        const { user } = await Context.authenticate();
 
         if (!Context.auth.canSendEmails()) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
 
         const model = new Email();
@@ -83,24 +83,25 @@ export class CreateEmailEndpoint extends Endpoint<Params, Query, Body, ResponseB
         model.fromAddress = request.body.fromAddress;
         model.fromName = request.body.fromName;
 
-        model.validateAttachments()
+        model.validateAttachments();
 
         // Check default
         if (JSON.stringify(model.json).length < 3 && model.recipientFilter.filters[0].type && EmailTemplateStruct.getDefaultForRecipient(model.recipientFilter.filters[0].type)) {
-            const type = EmailTemplateStruct.getDefaultForRecipient(model.recipientFilter.filters[0].type)
-             
+            const type = EmailTemplateStruct.getDefaultForRecipient(model.recipientFilter.filters[0].type);
+
             // Most specific template: for specific group
-            let templates = (await EmailTemplate.where({ type, organizationId: organization?.id ?? null, groupId: null }))
+            let templates = (await EmailTemplate.where({ type, organizationId: organization?.id ?? null, groupId: null }));
 
             // Then default
             if (templates.length == 0 && organization) {
-                templates = (await EmailTemplate.where({ type, organizationId: null, groupId: null }))
+                templates = (await EmailTemplate.where({ type, organizationId: null, groupId: null }));
             }
 
             if (templates.length == 0) {
                 // No default
-            } else {
-                const defaultTemplate = templates[0]
+            }
+            else {
+                const defaultTemplate = templates[0];
                 model.html = defaultTemplate.html;
                 model.text = defaultTemplate.text;
                 model.subject = defaultTemplate.subject;
@@ -109,14 +110,13 @@ export class CreateEmailEndpoint extends Endpoint<Params, Query, Body, ResponseB
         }
 
         await model.save();
-        await model.buildExampleRecipient()
+        await model.buildExampleRecipient();
         model.updateCount();
 
         if (request.body.status === EmailStatus.Sending || request.body.status === EmailStatus.Sent) {
-            model.send().catch(console.error)
+            model.send().catch(console.error);
         }
 
-
         return new Response(await model.getPreviewStructure());
     }
 }

package/src/endpoints/global/email/GetEmailAddressEndpoint.ts

@@ -1,5 +1,5 @@
 import { AutoEncoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { EmailAddress } from '@stamhoofd/email';
 import { Organization } from '@stamhoofd/models';
@@ -10,10 +10,10 @@ type Body = undefined;
 
 class Query extends AutoEncoder {
     @field({ decoder: StringDecoder })
-    id: string
+    id: string;
 
     @field({ decoder: StringDecoder })
-    token: string
+    token: string;
 }
 
 type ResponseBody = EmailAddressSettings;
@@ -22,11 +22,11 @@ export class ManageEmailAddressEndpoint extends Endpoint<Params, Query, Body, Re
     queryDecoder = Query as Decoder<Query>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
+        if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/email/manage", {});
+        const params = Endpoint.parseParameters(request.url, '/email/manage', {});
 
         if (params) {
             return [true, params as Params];
@@ -35,19 +35,19 @@ export class ManageEmailAddressEndpoint extends Endpoint<Params, Query, Body, Re
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const email = await EmailAddress.getByID(request.query.id)
+        const email = await EmailAddress.getByID(request.query.id);
         if (!email || email.token !== request.query.token || request.query.token.length < 10 || request.query.id.length < 10) {
             throw new SimpleError({
-                code: "invalid_fields",
-                message: "Invalid token or id",
-                human: "Deze link is vervallen. Probeer het opnieuw in een recentere e-mail"
-            })
+                code: 'invalid_fields',
+                message: 'Invalid token or id',
+                human: 'Deze link is vervallen. Probeer het opnieuw in een recentere e-mail',
+            });
         }
 
-        const organization = email.organizationId ? (await Organization.getByID(email.organizationId)) : undefined
+        const organization = email.organizationId ? (await Organization.getByID(email.organizationId)) : undefined;
         return new Response(EmailAddressSettings.create({
             ...email,
-            organization: organization ? OrganizationSimple.create(organization) : null
+            organization: organization ? OrganizationSimple.create(organization) : null,
         }));
     }
-}
+}