@stamhoofd/backend 2.3.1 → 2.4.0

package/index.ts

@@ -10,6 +10,7 @@ import { sleep } from "@stamhoofd/utility";
 
 import { areCronsRunning, crons, stopCronScheduling } from './src/crons';
 import { ContextMiddleware } from "./src/middleware/ContextMiddleware";
+import { resumeEmails } from "./src/helpers/EmailResumer";
 
 process.on("unhandledRejection", (error: Error) => {
     console.error("unhandledRejection");
@@ -81,6 +82,8 @@ const start = async () => {
 
     routerServer.listen(STAMHOOFD.PORT ?? 9090);
 
+    resumeEmails().catch(console.error);
+
     if (routerServer.server) {
         // Default timeout is a bit too short
         routerServer.server.timeout = 61000;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.3.1",
+    "version": "2.4.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -22,7 +22,7 @@
     },
     "devDependencies": {
         "@types/cookie": "^0.5.1",
-        "@types/luxon": "^2.0.8",
+        "@types/luxon": "3.4.2",
         "@types/mailparser": "3.4.4",
         "@types/mysql": "^2.15.20",
         "@types/node": "^18.11.17",
@@ -41,7 +41,7 @@
         "formidable": "3.5.1",
         "handlebars": "^4.7.7",
         "jsonwebtoken": "9.0.0",
-        "luxon": "^2.2.0",
+        "luxon": "3.4.4",
         "mailparser": "3.7.0",
         "mockdate": "^3.0.2",
         "mysql": "^2.18.1",
@@ -50,5 +50,5 @@
         "postmark": "4.0.2",
         "stripe": "^11.5.0"
     },
-    "gitHead": "9a2484194d078935d8b50c4aee790196d798435e"
+    "gitHead": "5313c328ca0e90544bf198bc6bebc90d7dced2aa"
 }

package/src/endpoints/admin/memberships/GetChargeMembershipsSummaryEndpoint.ts

@@ -1,6 +1,6 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SQL, SQLAlias, SQLSum, SQLCount, SQLDistinct, SQLSelectAs } from '@stamhoofd/sql';
-import { ChargeMembershipsSummary } from '@stamhoofd/structures';
+import { ChargeMembershipsSummary, ChargeMembershipsTypeSummary } from '@stamhoofd/structures';
 import { Context } from '../../../helpers/Context';
 
 
@@ -81,8 +81,69 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
                 memberships: memberships ?? 0,
                 members: members ?? 0,
                 price: price ?? 0,
-                organizations: organizations ?? 0
+                organizations: organizations ?? 0,
+                membershipsPerType: await this.fetchPerType()
             })
         );
     }
+
+    async fetchPerType() {
+        const query = SQL
+            .select(
+                SQL.column('member_platform_memberships', 'membershipTypeId'),
+                new SQLSelectAs(
+                    new SQLCount(
+                        new SQLDistinct(
+                            SQL.column('member_platform_memberships', 'id')
+                        )
+                    ),
+                    new SQLAlias('data__memberships')
+                ),
+                new SQLSelectAs(
+                    new SQLCount(
+                        new SQLDistinct(
+                            SQL.column('member_platform_memberships', 'memberId')
+                        )
+                    ),
+                    new SQLAlias('data__members')
+                ),
+                new SQLSelectAs(
+                    new SQLCount(
+                        new SQLDistinct(
+                            SQL.column('member_platform_memberships', 'organizationId')
+                        )
+                    ),
+                    new SQLAlias('data__organizations')
+                ),
+                new SQLSelectAs(
+                    new SQLSum(
+                        SQL.column('member_platform_memberships', 'price')
+                    ),
+                    new SQLAlias('data__price')
+                )
+            )
+            .from(
+                SQL.table('member_platform_memberships')
+            );
+        query.where(SQL.column('invoiceId'), null)
+        query.andWhere(SQL.column('invoiceItemDetailId'), null)
+        query.groupBy(SQL.column('member_platform_memberships', 'membershipTypeId'));
+
+
+        const result = await query.fetch();
+        console.log(result);
+
+        const membershipsPerType = new Map<string, ChargeMembershipsTypeSummary>();
+
+        for (const row of result) {
+            membershipsPerType.set(row['member_platform_memberships']['membershipTypeId'] as string, ChargeMembershipsTypeSummary.create({
+                memberships: row['data']['memberships'] as number,
+                members: row['data']['members'] as number,
+                price: row['data']['price'] as number,
+                organizations: row['data']['organizations'] as number
+            }));
+        }
+
+        return membershipsPerType;
+    }
 }

package/src/endpoints/auth/CreateAdminEndpoint.ts

@@ -3,14 +3,15 @@ import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-
 import { SimpleError } from "@simonbackx/simple-errors";
 import { Email } from '@stamhoofd/email';
 import { PasswordToken, User } from '@stamhoofd/models';
-import { User as UserStruct,UserPermissions } from "@stamhoofd/structures";
+import { User as UserStruct,UserPermissions, UserWithMembers } from "@stamhoofd/structures";
 import { Formatter } from '@stamhoofd/utility';
 
 import { Context } from '../../helpers/Context';
+import { AuthenticatedStructures } from '../../helpers/AuthenticatedStructures';
 type Params = Record<string, never>;
 type Query = undefined;
 type Body = UserStruct
-type ResponseBody = UserStruct
+type ResponseBody = UserWithMembers
 
 export class CreateAdminEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     bodyDecoder = UserStruct as Decoder<UserStruct>
@@ -132,6 +133,8 @@ export class CreateAdminEndpoint extends Endpoint<Params, Query, Body, ResponseB
             });
         }
 
-        return new Response(UserStruct.create({...admin, hasAccount: admin.hasAccount()}));
+        return new Response(
+            await AuthenticatedStructures.userWithMembers(admin)
+        );        
     }
 }

package/src/endpoints/auth/GetOtherUserEndpoint.ts

@@ -0,0 +1,41 @@
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { UserWithMembers } from '@stamhoofd/structures';
+
+import { AuthenticatedStructures } from '../../helpers/AuthenticatedStructures';
+import { Context } from '../../helpers/Context';
+import { User } from '@stamhoofd/models';
+
+type Params = {id: string};
+type Query = undefined;
+type Body = undefined;
+type ResponseBody = UserWithMembers;
+
+export class GetUserEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/user/@id", {id: String});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.setOptionalOrganizationScope()
+        await Context.authenticate()
+
+        const user = await User.getByID(request.params.id)
+        if (!user || !(await Context.auth.canAccessUser(user)) ){
+            throw Context.auth.error()
+        }
+
+        return new Response(
+            await AuthenticatedStructures.userWithMembers(user)
+        );
+    }
+}

package/src/endpoints/auth/GetUserEndpoint.ts

@@ -1,12 +1,13 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { MyUser, User as UserStruct } from '@stamhoofd/structures';
+import { UserWithMembers } from '@stamhoofd/structures';
 
+import { AuthenticatedStructures } from '../../helpers/AuthenticatedStructures';
 import { Context } from '../../helpers/Context';
 
 type Params = Record<string, never>;
 type Query = undefined;
 type Body = undefined;
-type ResponseBody = UserStruct|MyUser;
+type ResponseBody = UserWithMembers;
 
 export class GetUserEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
 
@@ -27,31 +28,8 @@ export class GetUserEndpoint extends Endpoint<Params, Query, Body, ResponseBody>
         await Context.setOptionalOrganizationScope()
         const {user} = await Context.authenticate({allowWithoutAccount: true})
 
-        if (request.request.getVersion() < 243) {
-            // Password
-            const st = MyUser.create({
-                firstName: user.firstName,
-                lastName: user.lastName,
-                id: user.id,
-                organizationId: user.organizationId,
-                email: user.email,
-                verified: user.verified,
-                permissions: user.permissions,
-                hasAccount: user.hasAccount()
-            })
-            return new Response(st);
-        }
-
-        const st = UserStruct.create({
-            firstName: user.firstName,
-            lastName: user.lastName,
-            id: user.id,
-            organizationId: user.organizationId,
-            email: user.email,
-            verified: user.verified,
-            permissions: user.permissions,
-            hasAccount: user.hasAccount()
-        })
-        return new Response(st);
+        return new Response(
+            await AuthenticatedStructures.userWithMembers(user)
+        );
     }
 }

package/src/endpoints/auth/PatchUserEndpoint.ts

@@ -1,15 +1,17 @@
 import { AutoEncoderPatchType, Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { SimpleError } from "@simonbackx/simple-errors";
-import { EmailVerificationCode, PasswordToken, Token, User } from '@stamhoofd/models';
-import { NewUser, PermissionLevel, SignupResponse, User as UserStruct,UserPermissions } from "@stamhoofd/structures";
+import { EmailVerificationCode, Member, PasswordToken, Token, User } from '@stamhoofd/models';
+import { NewUser, PermissionLevel, SignupResponse, UserPermissions, UserWithMembers } from "@stamhoofd/structures";
 
 import { Context } from '../../helpers/Context';
+import { MemberUserSyncer } from '../../helpers/MemberUserSyncer';
+import { AuthenticatedStructures } from '../../helpers/AuthenticatedStructures';
 
 type Params = { id: string };
 type Query = undefined;
 type Body = AutoEncoderPatchType<NewUser>
-type ResponseBody = UserStruct
+type ResponseBody = UserWithMembers
 
 export class PatchUserEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     bodyDecoder = NewUser.patchType() as Decoder<AutoEncoderPatchType<NewUser>>
@@ -46,8 +48,23 @@ export class PatchUserEndpoint extends Endpoint<Params, Query, Body, ResponseBod
         }
 
         if (await Context.auth.canEditUserName(editUser)) {
-            editUser.firstName = request.body.firstName ?? editUser.firstName
-            editUser.lastName = request.body.lastName ?? editUser.lastName
+            if (editUser.memberId) {
+                const member = await Member.getWithRegistrations(editUser.memberId)
+                if (member) {
+                    member.details.firstName = request.body.firstName ?? member.details.firstName
+                    member.details.lastName = request.body.lastName ?? member.details.lastName
+
+                    editUser.firstName = member.details.firstName
+                    editUser.lastName = member.details.lastName
+                    await member.save()
+
+                    // Also propage the name change to other users of the same member if needed
+                    await MemberUserSyncer.onChangeMember(member)
+                }
+            } else {
+                editUser.firstName = request.body.firstName ?? editUser.firstName
+                editUser.lastName = request.body.lastName ?? editUser.lastName
+            }
         }
 
         if (request.body.permissions !== undefined) {
@@ -117,6 +134,8 @@ export class PatchUserEndpoint extends Endpoint<Params, Query, Body, ResponseBod
             }
         }
 
-        return new Response(UserStruct.create({...editUser, hasAccount: editUser.hasAccount()}));      
+        return new Response(
+            await AuthenticatedStructures.userWithMembers(editUser)
+        );      
     }
 }

package/src/endpoints/auth/SignupEndpoint.ts

@@ -34,10 +34,10 @@ export class SignupEndpoint extends Endpoint<Params, Query, Body, ResponseBody>
         const u = await User.getForRegister(organization?.id ?? null, request.body.email)
 
         // Don't optimize. Always run two queries atm.
-        let user = await User.register(
+        let user = u ? undefined : (await User.register(
             organization,
             request.body
-        );
+        ));
 
         let sendCode = true
 

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

@@ -0,0 +1,120 @@
+import { Decoder } from '@simonbackx/simple-encoding';
+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 { Context } from '../../../helpers/Context';
+import { SQL } from '@stamhoofd/sql';
+
+type Params = Record<string, never>;
+type Query = undefined;
+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
+        },
+        {   
+            // 10.000 requests per week
+            limit: 10000,
+            duration: 24 * 60 * 1000 * 60 * 7
+        }
+    ]
+});
+
+export const freeEmailRateLimiter = new RateLimiter({
+    limits: [
+        {   
+            // Max 100 a day
+            limit: 100,
+            duration: 24 * 60 * 1000 * 60
+        },
+        {   
+            // Max 200 a week
+            limit: 200,
+            duration: 7 * 24 * 60 * 1000 * 60
+        }
+    ]
+});
+
+/**
+ * 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 CreateEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    bodyDecoder = EmailStruct as Decoder<EmailStruct>
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "POST") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/email", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOptionalOrganizationScope();
+        const {user} = await Context.authenticate()
+
+        if (!Context.auth.canSendEmails()) {
+            throw Context.auth.error()
+        }
+
+        const model = new Email();
+        model.userId = user.id;
+        model.organizationId = organization?.id ?? null;
+        model.recipientFilter = request.body.recipientFilter;
+
+        model.subject = request.body.subject;
+        model.html = request.body.html;
+        model.text = request.body.text;
+        model.json = request.body.json;
+        model.status = request.body.status;
+        model.attachments = request.body.attachments;
+        model.fromAddress = request.body.fromAddress;
+        model.fromName = request.body.fromName;
+
+        // 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)
+             
+            // Most specific template: for specific group
+            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 }))
+            }
+
+            if (templates.length == 0) {
+                // No default
+            } else {
+                const defaultTemplate = templates[0]
+                model.html = defaultTemplate.html;
+                model.text = defaultTemplate.text;
+                model.subject = defaultTemplate.subject;
+                model.json = defaultTemplate.json;
+            }
+        }
+
+        await model.save();
+        await model.buildExampleRecipient()
+        model.updateCount();
+
+        if (request.body.status === EmailStatus.Sending || request.body.status === EmailStatus.Sent) {
+            model.send().catch(console.error)
+        }
+
+
+        return new Response(await model.getPreviewStructure());
+    }
+}

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

@@ -0,0 +1,51 @@
+import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { Email } from '@stamhoofd/models';
+import { EmailPreview } from "@stamhoofd/structures";
+
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Context } from '../../../helpers/Context';
+
+type Params = {id: string};
+type Query = undefined;
+type Body = undefined
+type ResponseBody = EmailPreview;
+
+/**
+ * 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 GetEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/email/@id", {id: String});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOptionalOrganizationScope();
+        const {user} = await Context.authenticate()
+
+        if (!Context.auth.canSendEmails()) {
+            throw Context.auth.error()
+        }  
+
+        const model = await Email.getByID(request.params.id);
+        if (!model || model.userId !== user.id || (model.organizationId !== (organization?.id ?? null))) {
+            throw new SimpleError({
+                code: "not_found",
+                human: "Email not found",
+                message: 'Deze e-mail bestaat niet of is verwijderd',
+                statusCode: 404
+            })
+        }
+
+        return new Response(await model.getPreviewStructure());
+    }
+}

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

@@ -0,0 +1,108 @@
+import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { Email } from '@stamhoofd/models';
+import { EmailPreview, EmailStatus, Email as EmailStruct } from "@stamhoofd/structures";
+
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Context } from '../../../helpers/Context';
+import { AutoEncoderPatchType, Decoder, patchObject } from "@simonbackx/simple-encoding";
+
+type Params = {id: string};
+type Query = undefined;
+type Body = AutoEncoderPatchType<EmailStruct>
+type ResponseBody = EmailPreview;
+
+/**
+ * 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 PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    bodyDecoder = EmailStruct.patchType() as Decoder<AutoEncoderPatchType<EmailStruct>>
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "PATCH") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/email/@id", {id: String});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOptionalOrganizationScope();
+        const {user} = await Context.authenticate()
+
+        if (!Context.auth.canSendEmails()) {
+            throw Context.auth.error()
+        }  
+
+        const model = await Email.getByID(request.params.id);
+        if (!model || model.userId !== user.id || (model.organizationId !== (organization?.id ?? null))) {
+            throw new SimpleError({
+                code: "not_found",
+                human: "Email not found",
+                message: 'Deze e-mail bestaat niet of is verwijderd',
+                statusCode: 404
+            })
+        }
+
+        if (model.status !== EmailStatus.Draft) {
+            throw new SimpleError({
+                code: "not_draft",
+                human: "Email is not a draft",
+                message: 'Deze e-mail is al verzonden en kan niet meer aangepast worden',
+                statusCode: 400
+            })
+        }
+
+        let rebuild = false;
+
+        if (request.body.subject !== undefined) {
+            model.subject = request.body.subject;
+        }
+
+        if (request.body.html !== undefined) {
+            model.html = request.body.html;
+        }
+
+        if (request.body.text !== undefined) {
+            model.text = request.body.text;
+        }
+
+        if (request.body.json !== undefined) {
+            model.json = request.body.json;
+        }
+
+        if (request.body.fromAddress !== undefined) {
+            model.fromAddress = request.body.fromAddress;
+        }
+
+        if (request.body.fromName !== undefined) {
+            model.fromName = request.body.fromName;
+        }
+
+        if (request.body.recipientFilter) {
+            model.recipientFilter = patchObject(model.recipientFilter, request.body.recipientFilter);
+            rebuild = true;
+        }
+
+        await model.save();
+
+        if (rebuild) {
+            await model.buildExampleRecipient()
+            model.updateCount()
+
+            // Force null - because we have stale data
+            model.recipientCount = null
+        }
+
+        if (request.body.status === EmailStatus.Sending || request.body.status === EmailStatus.Sent) {
+            model.send().catch(console.error)
+        }
+
+        return new Response(await model.getPreviewStructure());
+    }
+}