@stamhoofd/backend 2.39.0 → 2.40.0

package/src/endpoints/admin/organizations/PatchOrganizationsEndpoint.ts

@@ -1,8 +1,8 @@
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { SimpleError } from "@simonbackx/simple-errors";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
 import { Organization, OrganizationRegistrationPeriod, Platform } from '@stamhoofd/models';
-import { OrganizationMetaData, Organization as OrganizationStruct } from "@stamhoofd/structures";
+import { OrganizationMetaData, Organization as OrganizationStruct } from '@stamhoofd/structures';
 
 import { Context } from '../../../helpers/Context';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
@@ -10,18 +10,18 @@ import { Formatter } from '@stamhoofd/utility';
 
 type Params = Record<string, never>;
 type Query = undefined;
-type Body = PatchableArrayAutoEncoder<OrganizationStruct>
-type ResponseBody = OrganizationStruct[]
+type Body = PatchableArrayAutoEncoder<OrganizationStruct>;
+type ResponseBody = OrganizationStruct[];
 
 export class PatchOrganizationsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = new PatchableArrayDecoder(OrganizationStruct as Decoder<OrganizationStruct>, OrganizationStruct.patchType() as Decoder<AutoEncoderPatchType<OrganizationStruct>>, StringDecoder)
+    bodyDecoder = new PatchableArrayDecoder(OrganizationStruct as Decoder<OrganizationStruct>, OrganizationStruct.patchType() as Decoder<AutoEncoderPatchType<OrganizationStruct>>, StringDecoder);
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "PATCH") {
+        if (request.method !== 'PATCH') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/admin/organizations", {});
+        const params = Endpoint.parseParameters(request.url, '/admin/organizations', {});
 
         if (params) {
             return [true, params as Params];
@@ -30,26 +30,26 @@ export class PatchOrganizationsEndpoint extends Endpoint<Params, Query, Body, Re
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        await Context.authenticate()
+        await Context.authenticate();
         if (!Context.auth.hasPlatformFullAccess()) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
-      
+
         if (request.body.changes.length == 0) {
             return new Response([]);
         }
 
         const result: Organization[] = [];
-        const platform = await Platform.getShared()
+        const platform = await Platform.getShared();
 
         for (const id of request.body.getDeletes()) {
             if (!Context.auth.hasPlatformFullAccess()) {
-                throw Context.auth.error('Enkel een platform hoofdbeheerder kan groepen verwijderen')
+                throw Context.auth.error('Enkel een platform hoofdbeheerder kan groepen verwijderen');
             }
 
             const organization = await Organization.getByID(id);
             if (!organization) {
-                throw new SimpleError({ code: "not_found", message: "Organization not found", statusCode: 404 });
+                throw new SimpleError({ code: 'not_found', message: 'Organization not found', statusCode: 404 });
             }
 
             await organization.delete();
@@ -59,17 +59,17 @@ export class PatchOrganizationsEndpoint extends Endpoint<Params, Query, Body, Re
         for (const patch of request.body.getPatches()) {
             const organization = await Organization.getByID(patch.id);
             if (!organization) {
-                throw new SimpleError({ code: "not_found", message: "Organization not found", statusCode: 404 });
+                throw new SimpleError({ code: 'not_found', message: 'Organization not found', statusCode: 404 });
             }
 
             if (patch.meta?.tags) {
                 const cleanedPatch = OrganizationMetaData.patch({
-                    tags: patch.meta.tags as any
-                })
+                    tags: patch.meta.tags as any,
+                });
                 const patchedMeta = organization.meta.patch(cleanedPatch);
                 for (const tag of patchedMeta.tags) {
                     if (!platform.config.tags.find(t => t.id === tag)) {
-                        throw new SimpleError({ code: "invalid_tag", message: "Invalid tag", statusCode: 400 });
+                        throw new SimpleError({ code: 'invalid_tag', message: 'Invalid tag', statusCode: 400 });
                     }
                 }
 
@@ -78,7 +78,7 @@ export class PatchOrganizationsEndpoint extends Endpoint<Params, Query, Body, Re
                     const aIndex = platform.config.tags.findIndex(t => t.id === a);
                     const bIndex = platform.config.tags.findIndex(t => t.id === b);
                     return aIndex - bIndex;
-                })
+                });
 
                 organization.meta.tags = patchedMeta.tags;
             }
@@ -88,58 +88,58 @@ export class PatchOrganizationsEndpoint extends Endpoint<Params, Query, Body, Re
         }
 
         // Organization creation
-        for (const {put} of request.body.getPuts()) {
+        for (const { put } of request.body.getPuts()) {
             if (!Context.auth.hasPlatformFullAccess()) {
-                throw Context.auth.error('Enkel een platform hoofdbeheerder kan nieuwe groepen aanmaken')
+                throw Context.auth.error('Enkel een platform hoofdbeheerder kan nieuwe groepen aanmaken');
             }
 
             if (put.name.length < 4) {
                 if (put.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 = put.uri || Formatter.slug(put.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 uriExists = await Organization.getByURI(uri);
-    
+
             if (uriExists) {
                 throw new SimpleError({
-                    code: "name_taken",
-                    message: "An organization with the same name already exists",
-                    human: "Er bestaat al een vereniging met dezelfde URI. Pas deze aan zodat deze uniek is, en controleer of deze vereniging niet al bestaat.",
-                    field: "name",
+                    code: 'name_taken',
+                    message: 'An organization with the same name already exists',
+                    human: 'Er bestaat al een vereniging met dezelfde URI. Pas deze aan zodat deze uniek is, en controleer of deze vereniging niet al bestaat.',
+                    field: 'name',
                 });
             }
 
             const alreadyExists = await Organization.getByURI(Formatter.slug(put.name));
-    
+
             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',
                 });
             }
 
@@ -148,27 +148,28 @@ export class PatchOrganizationsEndpoint extends Endpoint<Params, Query, Body, Re
             organization.name = put.name;
 
             organization.uri = put.uri;
-            organization.meta = put.meta
-            organization.address = put.address
+            organization.meta = put.meta;
+            organization.address = put.address;
 
             if (put.privateMeta) {
-                organization.privateMeta = put.privateMeta
+                organization.privateMeta = put.privateMeta;
             }
 
             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 organizationPeriod = new OrganizationRegistrationPeriod();
             organizationPeriod.organizationId = organization.id;
-            organizationPeriod.periodId = (await Platform.getShared()).periodId
+            organizationPeriod.periodId = (await Platform.getShared()).periodId;
             await organizationPeriod.save();
 
             result.push(organization);

package/src/endpoints/auth/CreateAdminEndpoint.ts

@@ -1,26 +1,26 @@
 import { Decoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { SimpleError } from "@simonbackx/simple-errors";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
 import { PasswordToken, Platform, sendEmailTemplate, User } from '@stamhoofd/models';
-import { EmailTemplateType, Recipient, Replacement, UserPermissions, User as UserStruct, UserWithMembers } from "@stamhoofd/structures";
+import { EmailTemplateType, Recipient, Replacement, UserPermissions, User as UserStruct, UserWithMembers } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../helpers/AuthenticatedStructures';
 import { Context } from '../../helpers/Context';
 type Params = Record<string, never>;
 type Query = undefined;
-type Body = UserStruct
-type ResponseBody = UserWithMembers
+type Body = UserStruct;
+type ResponseBody = UserWithMembers;
 
 export class CreateAdminEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = UserStruct as Decoder<UserStruct>
+    bodyDecoder = UserStruct as Decoder<UserStruct>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/user", {});
+        const params = Endpoint.parseParameters(request.url, '/user', {});
 
         if (params) {
             return [true, params as Params];
@@ -30,37 +30,38 @@ export class CreateAdminEndpoint 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();
 
         // Fast throw first (more in depth checking for patches later)
         if (organization) {
             if (!await Context.auth.canManageAdmins(organization.id)) {
-                throw Context.auth.error()
+                throw Context.auth.error();
             }
-        } else {
+        }
+        else {
             // Fast throw first (more in depth checking for patches later)
             if (!Context.auth.canManagePlatformAdmins()) {
-                throw Context.auth.error()
+                throw Context.auth.error();
             }
         }
 
         // First check if a user exists with this email?
-        const existing = await User.getForRegister(organization?.id ?? null, request.body.email)
+        const existing = await User.getForRegister(organization?.id ?? null, request.body.email);
 
         const admin = existing ?? (await User.createInvited(organization, {
             firstName: request.body.firstName,
             lastName: request.body.lastName,
             email: request.body.email,
-            allowPlatform: true
-        }))
+            allowPlatform: true,
+        }));
 
         if (!admin) {
             throw new SimpleError({
                 code: 'internal_error',
                 message: 'Something went wrong while creating the admin',
                 human: 'Er ging iets mis bij het aanmaken van dit account',
-                statusCode: 500
-            })
+                statusCode: 500,
+            });
         }
 
         // Merge permissions
@@ -68,28 +69,30 @@ export class CreateAdminEndpoint extends Endpoint<Params, Query, Body, ResponseB
             throw new SimpleError({
                 code: 'missing_field',
                 message: 'When creating administrators, you are required to specify permissions in the request',
-                field: 'permissions'
-            })
+                field: 'permissions',
+            });
         }
 
         if (organization) {
-            admin.permissions = UserPermissions.limitedPatch(admin.permissions, request.body.permissions, organization.id)
-        } else {
+            admin.permissions = UserPermissions.limitedPatch(admin.permissions, request.body.permissions, organization.id);
+        }
+        else {
             if (admin.permissions) {
-                admin.permissions.patchOrPut(request.body.permissions)
-            } else {
-                admin.permissions = request.body.permissions.isPut() ? request.body.permissions : null
+                admin.permissions.patchOrPut(request.body.permissions);
+            }
+            else {
+                admin.permissions = request.body.permissions.isPut() ? request.body.permissions : null;
             }
         }
 
         if (!admin.firstName && request.body.firstName) {
             // Allow setting the name if the user didn't had a name yet
-            admin.firstName = request.body.firstName
+            admin.firstName = request.body.firstName;
         }
 
         if (!admin.lastName && request.body.lastName) {
             // Allow setting the name if the user didn't had a name yet
-            admin.lastName = request.body.lastName
+            admin.lastName = request.body.lastName;
         }
 
         await admin.save();
@@ -98,12 +101,12 @@ export class CreateAdminEndpoint extends Endpoint<Params, Query, Body, ResponseB
         const validUntil = new Date();
         validUntil.setTime(validUntil.getTime() + 7 * 24 * 3600 * 1000);
 
-        const dateTime = Formatter.dateTime(validUntil)
-        const recoveryUrl = await PasswordToken.getPasswordRecoveryUrl(admin, organization, request.i18n, validUntil)
-        const platformName =  ((await Platform.getSharedStruct()).config.name)
-        
-        const name = organization?.name ?? platformName
-        const what = organization ? `de vereniging ${name} op ${platformName}` : platformName
+        const dateTime = Formatter.dateTime(validUntil);
+        const recoveryUrl = await PasswordToken.getPasswordRecoveryUrl(admin, organization, request.i18n, validUntil);
+        const platformName = ((await Platform.getSharedStruct()).config.name);
+
+        const name = organization?.name ?? platformName;
+        const what = organization ? `de vereniging ${name} op ${platformName}` : platformName;
 
         const emailTo = admin.getEmailTo();
         const email: string = typeof emailTo === 'string' ? emailTo : emailTo[0]?.email;
@@ -115,39 +118,39 @@ export class CreateAdminEndpoint extends Endpoint<Params, Query, Body, ResponseB
                     replacements: [
                         Replacement.create({
                             token: 'greeting',
-                            value: admin.firstName ? `Dag ${admin.firstName},` : 'Hallo!'
+                            value: admin.firstName ? `Dag ${admin.firstName},` : 'Hallo!',
                         }),
                         Replacement.create({
                             token: 'resetUrl',
-                            value: recoveryUrl
+                            value: recoveryUrl,
                         }),
                         Replacement.create({
                             token: 'platformOrOrganizationName',
-                            value: what
+                            value: what,
                         }),
                         Replacement.create({
                             token: 'inviterName',
-                            value: user.firstName ?? 'Iemand'
+                            value: user.firstName ?? 'Iemand',
                         }),
                         Replacement.create({
                             token: 'validUntil',
-                            value: dateTime
+                            value: dateTime,
                         }),
                         Replacement.create({
                             token: 'email',
-                            value: admin.email
-                        })
-                    ]
-                })
+                            value: admin.email,
+                        }),
+                    ],
+                }),
             ],
             template: {
-                type: admin.hasAccount() ? EmailTemplateType.AdminInvitation : EmailTemplateType.AdminInvitationNewUser
+                type: admin.hasAccount() ? EmailTemplateType.AdminInvitation : EmailTemplateType.AdminInvitationNewUser,
             },
-            type: 'transactional'
+            type: 'transactional',
         });
 
         return new Response(
-            await AuthenticatedStructures.userWithMembers(admin)
-        );        
+            await AuthenticatedStructures.userWithMembers(admin),
+        );
     }
 }

package/src/endpoints/auth/CreateTokenEndpoint.test.ts

@@ -1,68 +1,68 @@
-import { Request } from "@simonbackx/simple-endpoints";
-import { OrganizationFactory, Token, UserFactory } from "@stamhoofd/models";
-import { Token as TokenStruct } from "@stamhoofd/structures";
+import { Request } from '@simonbackx/simple-endpoints';
+import { OrganizationFactory, Token, UserFactory } from '@stamhoofd/models';
+import { Token as TokenStruct } from '@stamhoofd/structures';
 
-import { testServer } from "../../../tests/helpers/TestServer";
+import { testServer } from '../../../tests/helpers/TestServer';
 import { CreateTokenEndpoint } from './CreateTokenEndpoint';
 
-describe("Endpoint.CreateToken", () => {
+describe('Endpoint.CreateToken', () => {
     // Test endpoint
     const endpoint = new CreateTokenEndpoint();
 
-    test("Can get a token via password flow", async () => {
-        const organization = await new OrganizationFactory({}).create()
+    test('Can get a token via password flow', async () => {
+        const organization = await new OrganizationFactory({}).create();
         // Also check UTF8 passwords
-        const password = "54😂test👌🏾86s&é"
-        const user = await new UserFactory({ organization, password }).create()
+        const password = '54😂test👌🏾86s&é';
+        const user = await new UserFactory({ organization, password }).create();
 
-        const r = Request.buildJson("POST", "/oauth/token", organization.getApiHost(), {
-            grant_type: "password",
+        const r = Request.buildJson('POST', '/oauth/token', organization.getApiHost(), {
+            grant_type: 'password',
             username: user.email,
-            password: password
+            password: password,
         });
 
         const response = await testServer.test(endpoint, r);
         expect(response.body).toBeDefined();
 
         if (!(response.body instanceof TokenStruct)) {
-            throw new Error("Expected TokenStruct")
+            throw new Error('Expected TokenStruct');
         }
 
         // Check token is valid
-        const token = await Token.getByAccessToken(response.body.accessToken)
-        expect(token).toBeDefined()
+        const token = await Token.getByAccessToken(response.body.accessToken);
+        expect(token).toBeDefined();
 
-        const byRefresh = await Token.getByRefreshToken(response.body.refreshToken)
-        expect(byRefresh).toBeDefined()
+        const byRefresh = await Token.getByRefreshToken(response.body.refreshToken);
+        expect(byRefresh).toBeDefined();
     });
 
-    test("Can get a token via refresh flow", async () => {
-        const organization = await new OrganizationFactory({}).create()
+    test('Can get a token via refresh flow', async () => {
+        const organization = await new OrganizationFactory({}).create();
         // Also check UTF8 passwords
-        const password = "54😂test👌🏾86s&é"
-        const user = await new UserFactory({ organization, password }).create()
+        const password = '54😂test👌🏾86s&é';
+        const user = await new UserFactory({ organization, password }).create();
         const token = await Token.createToken(user);
 
-        const r = Request.buildJson("POST", "/oauth/token", organization.getApiHost(), {
-            grant_type: "refresh_token",
-            refresh_token: token.refreshToken
+        const r = Request.buildJson('POST', '/oauth/token', organization.getApiHost(), {
+            grant_type: 'refresh_token',
+            refresh_token: token.refreshToken,
         });
 
         const response = await testServer.test(endpoint, r);
         expect(response.body).toBeDefined();
 
         if (!(response.body instanceof TokenStruct)) {
-            throw new Error("Expected TokenStruct")
+            throw new Error('Expected TokenStruct');
         }
 
-        expect(response.body.accessToken).not.toEqual(token.accessToken)
-        expect(response.body.refreshToken).not.toEqual(token.refreshToken)
+        expect(response.body.accessToken).not.toEqual(token.accessToken);
+        expect(response.body.refreshToken).not.toEqual(token.refreshToken);
 
         // Check token is valid
-        const byAccess = await Token.getByAccessToken(response.body.accessToken)
-        expect(byAccess).toBeDefined()
+        const byAccess = await Token.getByAccessToken(response.body.accessToken);
+        expect(byAccess).toBeDefined();
 
-        const byRefresh = await Token.getByRefreshToken(response.body.refreshToken)
-        expect(byRefresh).toBeDefined()
+        const byRefresh = await Token.getByRefreshToken(response.body.refreshToken);
+        expect(byRefresh).toBeDefined();
     });
 });