@stamhoofd/backend 2.39.1 → 2.40.0

package/src/endpoints/global/organizations/CheckRegisterCodeEndpoint.ts

@@ -1,20 +1,19 @@
-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 { Organization, RegisterCode } from '@stamhoofd/models';
-import {RegisterCode as RegisterCodeStruct } from "@stamhoofd/structures"
+import { RegisterCode as RegisterCodeStruct } from '@stamhoofd/structures';
 type Params = { code: string };
 type Query = undefined;
 type Body = undefined;
 type ResponseBody = RegisterCodeStruct;
 
 export class CheckRegisterCodeEndpoint 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, "/register-code/@code", {code: String});
+        const params = Endpoint.parseParameters(request.url, '/register-code/@code', { code: String });
 
         if (params) {
             return [true, params as Params];
@@ -23,23 +22,22 @@ export class CheckRegisterCodeEndpoint extends Endpoint<Params, Query, Body, Res
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        
-        const code = await RegisterCode.getByID(request.params.code)
+        const code = await RegisterCode.getByID(request.params.code);
         if (code) {
             return new Response(RegisterCodeStruct.create({
                 code: code.code,
                 description: code.description,
                 customMessage: code.customMessage,
                 organizationName: code.organizationId ? ((await Organization.getByID(code.organizationId))!.name) : null,
-                value: code.value
-            }))
+                value: code.value,
+            }));
         }
 
         throw new SimpleError({
-            code: "invalid_code",
-            message: "Invalid code",
-            human: "Deze code is niet geldig",
-            field: "registerCode"
-        })
+            code: 'invalid_code',
+            message: 'Invalid code',
+            human: 'Deze code is niet geldig',
+            field: 'registerCode',
+        });
     }
 }

package/src/endpoints/global/organizations/CreateOrganizationEndpoint.test.ts

@@ -1,57 +1,56 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import { Address, Country, CreateOrganization, NewUser, Organization as OrganizationStruct, Version } from '@stamhoofd/structures';
 
-import { Request } from "@simonbackx/simple-endpoints";
-import { Address, Country, CreateOrganization, NewUser, Organization as OrganizationStruct, Version } from "@stamhoofd/structures";
+import { testServer } from '../../../../tests/helpers/TestServer';
+import { CreateOrganizationEndpoint } from './CreateOrganizationEndpoint';
 
-import { testServer } from "../../../../tests/helpers/TestServer";
-import { CreateOrganizationEndpoint } from "./CreateOrganizationEndpoint";
-
-describe("Endpoint.CreateOrganization", () => {
+describe('Endpoint.CreateOrganization', () => {
     // Test endpoint
     const endpoint = new CreateOrganizationEndpoint();
 
-    test("Can create a new organization", async () => {
-        const r = Request.buildJson("POST", `/v${Version}/organizations`, "todo-host.be", CreateOrganization.create({
+    test('Can create a new organization', async () => {
+        const r = Request.buildJson('POST', `/v${Version}/organizations`, 'todo-host.be', CreateOrganization.create({
             organization: OrganizationStruct.create({
-                name: "My endpoint test organization",
-                uri: "my-endpoint-test-organization",
+                name: 'My endpoint test organization',
+                uri: 'my-endpoint-test-organization',
                 address: Address.create({
-                    street: "My street",
-                    number: "1",
-                    postalCode: "9000",
-                    city: "Gent",
-                    country: Country.Belgium
+                    street: 'My street',
+                    number: '1',
+                    postalCode: '9000',
+                    city: 'Gent',
+                    country: Country.Belgium,
                 }),
-                
+
             }),
             user: NewUser.create({
-                email: "voorbeeld@stamhoofd.be",
-                password: "My user password",
+                email: 'voorbeeld@stamhoofd.be',
+                password: 'My user password',
             }),
-        }).encode({version: Version}));
+        }).encode({ version: Version }));
 
         const response = await testServer.test(endpoint, r);
         expect(response.body.token).not.toBeEmpty();
     });
 
-    test("Creating an organization with an in-use URI throws", async () => {
-        const r = Request.buildJson("POST", `/v${Version}/organizations`, "todo-host.be", CreateOrganization.create({
+    test('Creating an organization with an in-use URI throws', async () => {
+        const r = Request.buildJson('POST', `/v${Version}/organizations`, 'todo-host.be', CreateOrganization.create({
             organization: OrganizationStruct.create({
-                name: "My endpoint test organization",
-                uri: "my-endpoint-test-organization",
+                name: 'My endpoint test organization',
+                uri: 'my-endpoint-test-organization',
                 address: Address.create({
-                    street: "My street",
-                    number: "1",
-                    postalCode: "9000",
-                    city: "Gent",
-                    country: Country.Belgium
+                    street: 'My street',
+                    number: '1',
+                    postalCode: '9000',
+                    city: 'Gent',
+                    country: Country.Belgium,
                 }),
-                
+
             }),
             user: NewUser.create({
-                email: "voorbeeld@stamhoofd.be",
-                password: "My user password",
-            })
-        }).encode({version: Version}));
+                email: 'voorbeeld@stamhoofd.be',
+                password: 'My user password',
+            }),
+        }).encode({ version: Version }));
 
         await expect(testServer.test(endpoint, r)).rejects.toThrow(/name/);
     });

package/src/endpoints/global/organizations/CreateOrganizationEndpoint.ts

@@ -1,9 +1,9 @@
 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, Organization, User } from '@stamhoofd/models';
-import { CreateOrganization, PermissionLevel, Permissions, SignupResponse, UserPermissions } from "@stamhoofd/structures";
-import { Formatter } from "@stamhoofd/utility";
+import { CreateOrganization, PermissionLevel, Permissions, SignupResponse, UserPermissions } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -14,11 +14,11 @@ export class CreateOrganizationEndpoint extends Endpoint<Params, Query, Body, Re
     bodyDecoder = CreateOrganization as Decoder<CreateOrganization>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/organizations", {});
+        const params = Endpoint.parseParameters(request.url, '/organizations', {});
 
         if (params) {
             return [true, params as Params];
@@ -29,48 +29,48 @@ export class CreateOrganizationEndpoint extends Endpoint<Params, Query, Body, Re
     async handle(request: DecodedRequest<Params, Query, Body>) {
         if (STAMHOOFD.userMode === 'platform') {
             throw new SimpleError({
-                code: "invalid_field",
-                message: "Not allowed",
-                human: "Je kan geen vereniging aanmaken"
-            })
+                code: 'invalid_field',
+                message: 'Not allowed',
+                human: 'Je kan geen vereniging aanmaken',
+            });
         }
 
         if (request.body.organization.name.length < 4) {
             if (request.body.organization.name.length == 0) {
                 throw new SimpleError({
-                    code: "invalid_field",
-                    message: "Should not be empty",
-                    human: "Je bent de naam van je organisatie vergeten in te vullen",
-                    field: "organization.name"
-                })
+                    code: 'invalid_field',
+                    message: 'Should not be empty',
+                    human: 'Je bent de naam van je organisatie vergeten in te vullen',
+                    field: 'organization.name',
+                });
             }
 
             throw new SimpleError({
-                code: "invalid_field",
-                message: "Field is too short",
-                human: "Kijk de naam van je organisatie na, deze is te kort. Vul eventueel aan met de gemeente.",
-                field: "organization.name"
-            })
+                code: 'invalid_field',
+                message: 'Field is too short',
+                human: 'Kijk de naam van je organisatie na, deze is te kort. Vul eventueel aan met de gemeente.',
+                field: 'organization.name',
+            });
         }
 
         const uri = Formatter.slug(request.body.organization.name);
 
         if (uri.length > 100) {
             throw new SimpleError({
-                code: "invalid_field",
-                message: "Field is too long",
-                human: "De naam van de vereniging is te lang. Probeer de naam wat te verkorten en probeer opnieuw.",
-                field: "organization.name"
-            })
+                code: 'invalid_field',
+                message: 'Field is too long',
+                human: 'De naam van de vereniging is te lang. Probeer de naam wat te verkorten en probeer opnieuw.',
+                field: 'organization.name',
+            });
         }
         const alreadyExists = await Organization.getByURI(uri);
 
         if (alreadyExists) {
             throw new SimpleError({
-                code: "name_taken",
-                message: "An organization with the same name already exists",
-                human: "Er bestaat al een vereniging met dezelfde naam. Voeg bijvoorbeeld de naam van je gemeente toe.",
-                field: "name",
+                code: 'name_taken',
+                message: 'An organization with the same name already exists',
+                human: 'Er bestaat al een vereniging met dezelfde naam. Voeg bijvoorbeeld de naam van je gemeente toe.',
+                field: 'name',
             });
         }
 
@@ -84,61 +84,52 @@ export class CreateOrganizationEndpoint extends Endpoint<Params, Query, Body, Re
         // let registerCodeModels: Model[] = []
         // let delayEmails: EmailInterfaceBase[] = []
 
-        //if (request.body.registerCode) {
+        // if (request.body.registerCode) {
         //    const applied = await RegisterCode.applyRegisterCode(organization, request.body.registerCode)
         //    registerCodeModels = applied.models
         //    delayEmails = applied.emails
-        //}
+        // }
 
         organization.uri = uri;
-        organization.meta = request.body.organization.meta
-        organization.address = request.body.organization.address
-        organization.privateMeta.acquisitionTypes = request.body.organization.privateMeta?.acquisitionTypes ?? []
+        organization.meta = request.body.organization.meta;
+        organization.address = request.body.organization.address;
+        organization.privateMeta.acquisitionTypes = request.body.organization.privateMeta?.acquisitionTypes ?? [];
 
         try {
             await organization.save();
-        } catch (e) {
+        }
+        catch (e) {
             console.error(e);
             throw new SimpleError({
-                code: "creating_organization",
-                message: "Something went wrong while creating the organization. Please try again later or contact us.",
-                statusCode: 500
+                code: 'creating_organization',
+                message: 'Something went wrong while creating the organization. Please try again later or contact us.',
+                statusCode: 500,
             });
         }
 
         const user = await User.register(
             organization,
-            request.body.user
+            request.body.user,
         );
         if (!user) {
             // This user already exists, well that is pretty impossible
             throw new SimpleError({
-                code: "creating_user",
-                message: "Something went wrong while creating the user. Please contact us to resolve this issue.",
-                statusCode: 500
+                code: 'creating_user',
+                message: 'Something went wrong while creating the user. Please contact us to resolve this issue.',
+                statusCode: 500,
             });
         }
 
         // Should prevent this extra save
-        user.permissions = UserPermissions.create({})
-        user.permissions.organizationPermissions.set(organization.id, Permissions.create({ level: PermissionLevel.Full }))
-        await user.save()
+        user.permissions = UserPermissions.create({});
+        user.permissions.organizationPermissions.set(organization.id, Permissions.create({ level: PermissionLevel.Full }));
+        await user.save();
 
-        // for (const model of registerCodeModels) {
-        //     await model.save()
-        // }
-
-        const code = await EmailVerificationCode.createFor(user, user.email)
-        code.send(user, organization, request.i18n)
-
-        // for (const email of delayEmails) {
-        //     Email.sendInternal(email, organization.i18n)
-        // }
+        const code = await EmailVerificationCode.createFor(user, user.email);
+        code.send(user, organization, request.i18n).catch(console.error);
 
         return new Response(SignupResponse.create({
-            token: code.token
+            token: code.token,
         }));
     }
-
-    
 }

package/src/endpoints/global/organizations/GetOrganizationFromDomainEndpoint.test.ts

@@ -1,52 +1,51 @@
-import { Request } from "@simonbackx/simple-endpoints";
+import { Request } from '@simonbackx/simple-endpoints';
 import { GroupFactory, OrganizationFactory } from '@stamhoofd/models';
 import { Organization } from '@stamhoofd/structures';
 
-import { testServer } from "../../../../tests/helpers/TestServer";
+import { testServer } from '../../../../tests/helpers/TestServer';
 import { GetOrganizationFromDomainEndpoint } from './GetOrganizationFromDomainEndpoint';
 
-describe("Endpoint.GetOrganizationFromDomain", () => {
+describe('Endpoint.GetOrganizationFromDomain', () => {
     // Test endpoint
     const endpoint = new GetOrganizationFromDomainEndpoint();
 
-    test("Get organization from default uri", async () => {
-        const organization = await new OrganizationFactory({}).create()
-        const groups = await new GroupFactory({ organization }).createMultiple(2)
+    test('Get organization from default uri', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const groups = await new GroupFactory({ organization }).createMultiple(2);
 
-        const r = Request.buildJson("GET", "/v2/organization-from-domain");
+        const r = Request.buildJson('GET', '/v2/organization-from-domain');
         r.query = {
-            "domain": organization.uri+".stamhoofd.dev",
-        }
+            domain: organization.uri + '.stamhoofd.dev',
+        };
 
         const response = await testServer.test(endpoint, r);
         expect(response.body).toBeDefined();
 
         if (!(response.body instanceof Organization)) {
-            throw new Error("Expected Organization")
+            throw new Error('Expected Organization');
         }
 
-        expect(response.body.id).toEqual(organization.id)
-        expect(response.body.groups.map(g => g.id).sort()).toEqual(groups.map(g => g.id).sort())
+        expect(response.body.id).toEqual(organization.id);
+        expect(response.body.groups.map(g => g.id).sort()).toEqual(groups.map(g => g.id).sort());
     });
 
-    test("Get organization from custom domain", async () => {
-        const organization = await new OrganizationFactory({ domain: "inschrijven.mijnscouts.be"}).create()
-        const groups = await new GroupFactory({ organization }).createMultiple(2)
+    test('Get organization from custom domain', async () => {
+        const organization = await new OrganizationFactory({ domain: 'inschrijven.mijnscouts.be' }).create();
+        const groups = await new GroupFactory({ organization }).createMultiple(2);
 
-        const r = Request.buildJson("GET", "/v2/organization-from-domain");
+        const r = Request.buildJson('GET', '/v2/organization-from-domain');
         r.query = {
-            "domain": "inschrijven.mijnscouts.be",
-        }
+            domain: 'inschrijven.mijnscouts.be',
+        };
 
         const response = await testServer.test(endpoint, r);
         expect(response.body).toBeDefined();
 
         if (!(response.body instanceof Organization)) {
-            throw new Error("Expected Organization")
+            throw new Error('Expected Organization');
         }
 
-        expect(response.body.id).toEqual(organization.id)
-        expect(response.body.groups.map(g => g.id).sort()).toEqual(groups.map(g => g.id).sort())
+        expect(response.body.id).toEqual(organization.id);
+        expect(response.body.groups.map(g => g.id).sort()).toEqual(groups.map(g => g.id).sort());
     });
-
 });

package/src/endpoints/global/organizations/GetOrganizationFromDomainEndpoint.ts

@@ -1,10 +1,10 @@
-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 } from '@stamhoofd/models';
-import { Organization as OrganizationStruct } from "@stamhoofd/structures";
-import { GoogleTranslateHelper } from "@stamhoofd/utility";
-import { AuthenticatedStructures } from "../../../helpers/AuthenticatedStructures";
+import { Organization as OrganizationStruct } from '@stamhoofd/structures';
+import { GoogleTranslateHelper } from '@stamhoofd/utility';
+import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 type Params = Record<string, never>;
 
 class Query extends AutoEncoder {
@@ -12,7 +12,7 @@ class Query extends AutoEncoder {
     domain: string;
 }
 
-type Body = undefined
+type Body = undefined;
 type ResponseBody = OrganizationStruct;
 
 /**
@@ -20,15 +20,15 @@ type ResponseBody = OrganizationStruct;
  */
 
 export class GetOrganizationFromDomainEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = Query as Decoder<Query>
-    registrationDomains = [... new Set(Object.values(STAMHOOFD.domains.registration ?? {}))]
+    queryDecoder = Query as Decoder<Query>;
+    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, "/organization-from-domain", {});
+        const params = Endpoint.parseParameters(request.url, '/organization-from-domain', {});
 
         if (params) {
             return [true, params as Params];
@@ -38,28 +38,28 @@ export class GetOrganizationFromDomainEndpoint extends Endpoint<Params, Query, B
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         // Clean up google translate domains -> make sure we can translate register pages
-        request.query.domain = GoogleTranslateHelper.getDomainFromTranslateDomain(request.query.domain)
+        request.query.domain = GoogleTranslateHelper.getDomainFromTranslateDomain(request.query.domain);
 
         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_organization",
-                        message: "No organization registered with this domain name",
-                        statusCode: 404
-                    })
+                        code: 'unknown_organization',
+                        message: 'No organization registered with this domain name',
+                        statusCode: 404,
+                    });
                 }
                 return new Response(await AuthenticatedStructures.organization(organization));
             }
@@ -67,14 +67,14 @@ export class GetOrganizationFromDomainEndpoint extends Endpoint<Params, Query, B
 
         // 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) {
             throw new SimpleError({
-                code: "unknown_organization",
-                message: "No organization registered with this domain name",
-                statusCode: 404
-            })
+                code: 'unknown_organization',
+                message: 'No organization registered with this domain name',
+                statusCode: 404,
+            });
         }
         return new Response(await AuthenticatedStructures.organization(organization));
     }

package/src/endpoints/global/organizations/GetOrganizationFromUriEndpoint.ts

@@ -1,10 +1,10 @@
-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 } from '@stamhoofd/models';
-import { Organization as OrganizationStruct } from "@stamhoofd/structures";
-import { GoogleTranslateHelper } from "@stamhoofd/utility";
-import { AuthenticatedStructures } from "../../../helpers/AuthenticatedStructures";
+import { Organization as OrganizationStruct } from '@stamhoofd/structures';
+import { GoogleTranslateHelper } from '@stamhoofd/utility';
+import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 type Params = Record<string, never>;
 
 class Query extends AutoEncoder {
@@ -12,7 +12,7 @@ class Query extends AutoEncoder {
     uri: string;
 }
 
-type Body = undefined
+type Body = undefined;
 type ResponseBody = OrganizationStruct;
 
 /**
@@ -20,14 +20,14 @@ type ResponseBody = OrganizationStruct;
  */
 
 export class GetOrganizationFromUriEndpoint 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, "/organization-from-uri", {});
+        const params = Endpoint.parseParameters(request.url, '/organization-from-uri', {});
 
         if (params) {
             return [true, params as Params];
@@ -36,22 +36,22 @@ export class GetOrganizationFromUriEndpoint extends Endpoint<Params, Query, Body
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Organization.getByURI(request.query.uri)
+        const organization = await Organization.getByURI(request.query.uri);
 
         if (!organization) {
             throw new SimpleError({
-                code: "unknown_organization",
-                message: "No organization registered with this uri",
-                statusCode: 404
-            })
+                code: 'unknown_organization',
+                message: 'No organization registered with this uri',
+                statusCode: 404,
+            });
         }
 
         if (!organization.active) {
             throw new SimpleError({
-                code: "archived_organization",
-                message: "This organization has been archived",
-                statusCode: 404
-            })
+                code: 'archived_organization',
+                message: 'This organization has been archived',
+                statusCode: 404,
+            });
         }
         return new Response(await AuthenticatedStructures.organization(organization));
     }