@stamhoofd/backend 2.97.2 → 2.98.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.97.2",
+    "version": "2.98.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -45,14 +45,14 @@
         "@simonbackx/simple-encoding": "2.22.0",
         "@simonbackx/simple-endpoints": "1.20.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.97.2",
-        "@stamhoofd/backend-middleware": "2.97.2",
-        "@stamhoofd/email": "2.97.2",
-        "@stamhoofd/models": "2.97.2",
-        "@stamhoofd/queues": "2.97.2",
-        "@stamhoofd/sql": "2.97.2",
-        "@stamhoofd/structures": "2.97.2",
-        "@stamhoofd/utility": "2.97.2",
+        "@stamhoofd/backend-i18n": "2.98.0",
+        "@stamhoofd/backend-middleware": "2.98.0",
+        "@stamhoofd/email": "2.98.0",
+        "@stamhoofd/models": "2.98.0",
+        "@stamhoofd/queues": "2.98.0",
+        "@stamhoofd/sql": "2.98.0",
+        "@stamhoofd/structures": "2.98.0",
+        "@stamhoofd/utility": "2.98.0",
         "archiver": "^7.0.1",
         "axios": "^1.8.2",
         "cookie": "^0.7.0",
@@ -70,5 +70,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "b8acc52aa065a07ff0689bd6cd0fd90a49a0c54e"
+    "gitHead": "d15c1756a1e10788fa2736efcc6abbc2e3f365a6"
 }

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

@@ -4,16 +4,20 @@ import { SimpleError } from '@simonbackx/simple-errors';
 import { EmailAddress } from '@stamhoofd/email';
 import { Organization } from '@stamhoofd/models';
 import { EmailAddressSettings, OrganizationSimple } from '@stamhoofd/structures';
+import { Context } from '../../../helpers/Context';
 
 type Params = Record<string, never>;
 type Body = undefined;
 
 class Query extends AutoEncoder {
-    @field({ decoder: StringDecoder })
-    id: string;
+    @field({ decoder: StringDecoder, nullable: true, optional: true })
+    id: string | null = null;
 
-    @field({ decoder: StringDecoder })
-    token: string;
+    @field({ decoder: StringDecoder, nullable: true, optional: true })
+    token: string | null = null;
+
+    @field({ decoder: StringDecoder, nullable: true, optional: true })
+    email: string | null = null;
 }
 
 type ResponseBody = EmailAddressSettings;
@@ -35,19 +39,75 @@ export class GetEmailAddressEndpoint extends Endpoint<Params, Query, Body, Respo
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        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: $t(`ceacb5a8-7777-4366-abcb-9dd90ffb832e`),
-            });
+        if (request.query.id) {
+            if (!request.query.token) {
+                throw new SimpleError({
+                    code: 'missing_field',
+                    message: 'Missing token',
+                    field: 'token',
+                });
+            }
+
+            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: $t(`ceacb5a8-7777-4366-abcb-9dd90ffb832e`),
+                });
+            }
+
+            const organization = email.organizationId ? (await Organization.getByID(email.organizationId)) : undefined;
+            return new Response(EmailAddressSettings.create({
+                ...email,
+                organization: organization ? OrganizationSimple.create(organization) : null,
+            }));
         }
+        else {
+            if (!request.query.email) {
+                throw new SimpleError({
+                    code: 'missing_field',
+                    message: 'Missing email or id',
+                    field: 'email',
+                });
+            }
+
+            const organization = await Context.setOptionalOrganizationScope();
+            await Context.authenticate();
+
+            if (!Context.auth.hasPlatformFullAccess()) {
+                throw Context.auth.error();
+            }
 
-        const organization = email.organizationId ? (await Organization.getByID(email.organizationId)) : undefined;
-        return new Response(EmailAddressSettings.create({
-            ...email,
-            organization: organization ? OrganizationSimple.create(organization) : null,
-        }));
+            const query = EmailAddress.select().where(
+                'email', request.query.email,
+            );
+            if (organization) {
+                query.andWhere('organizationId', organization.id);
+            }
+            else {
+                // No need
+            }
+
+            const emails = await query.fetch();
+
+            if (emails.length === 0) {
+                throw new SimpleError({
+                    code: 'not_found',
+                    message: 'Email not found',
+                    human: $t(`9ddb6616-f62d-4c91-82a9-e5cf398e4c4a`),
+                    statusCode: 404,
+                });
+            }
+
+            return new Response(EmailAddressSettings.create({
+                email: request.query.email,
+                unsubscribedAll: !!emails.find(e => e.unsubscribedAll),
+                unsubscribedMarketing: !!emails.find(e => e.unsubscribedMarketing),
+                hardBounce: !!emails.find(e => e.hardBounce),
+                markedAsSpam: !!emails.find(e => e.markedAsSpam),
+                organization: organization ? OrganizationSimple.create(organization) : null,
+            }));
+        }
     }
 }

package/src/endpoints/global/email/GetUserEmailsEndpoint.test.ts

@@ -40,6 +40,11 @@ describe('Endpoint.GetUserEmails', () => {
         userToken = await Token.createToken(user);
     });
 
+    afterEach(async () => {
+        // Delete all emails
+        await Email.delete();
+    });
+
     const getUserEmails = async (query: LimitedFilteredRequest = new LimitedFilteredRequest({ limit: 10 }), token: Token = userToken, testOrganization: Organization = organization) => {
         const request = Request.get({
             path: baseUrl,
@@ -379,8 +384,7 @@ describe('Endpoint.GetUserEmails', () => {
 
         // Should prefer the exact match recipient
         expect(emailResult.recipients).toHaveLength(1);
-        expect(emailResult.recipients[0].firstName).toBe('Exact');
-        expect(emailResult.recipients[0].lastName).toBe('Match');
+        expect(emailResult.recipients[0].id).toBe(exactMatchRecipient.id);
     });
 
     test('Should return generic data when recipient has no matching user id or email', async () => {
@@ -420,12 +424,7 @@ describe('Endpoint.GetUserEmails', () => {
 
         // Should return the generic recipient data
         expect(emailResult.recipients).toHaveLength(1);
-        expect(emailResult.recipients[0].firstName).toBe('Generic');
-        expect(emailResult.recipients[0].lastName).toBe('Member');
-        // The original recipient struct keeps its original userId and email
-        expect(emailResult.recipients[0].userId).toBe(null); // Original was null
-        expect(emailResult.recipients[0].email).toBe(null); // Original was null
-        // But replacements should be generated for the current user (tested below)
+        expect(emailResult.recipients[0].id).toBe(genericRecipient.id);
         expect(emailResult.recipients[0].replacements).toBeDefined();
     });
 
@@ -440,7 +439,7 @@ describe('Endpoint.GetUserEmails', () => {
         email.subject = 'Sensitive Data Email';
         email.status = EmailStatus.Sent;
         email.text = 'Email with sensitive replacements {{outstandingBalance}} {{loginDetails}} {{unsubscribeUrl}}';
-        email.html = '<p>Email with sensitive replacements {{outstandingBalance}} {{loginDetails}} {{unsubscribeUrl}}</p>';
+        email.html = '<p>Email with sensitive replacements {{outstandingBalance}} {{loginDetails}} {{unsubscribeUrl}}</p>{{balanceTable}}';
         email.json = {};
         email.organizationId = organization.id;
         email.showInMemberPortal = true;
@@ -498,9 +497,9 @@ describe('Endpoint.GetUserEmails', () => {
         expect(emailResult.recipients).toHaveLength(1);
         const recipient = emailResult.recipients[0];
 
-        // The original recipient struct keeps its original userId and email from the sensitive user
-        expect(recipient.userId).toBe(sensitiveUser.id); // Original userId
-        expect(recipient.email).toBe(sensitiveUser.email); // Original email
+        // The original recipient struct keeps its original userId and email from the sensitive user, but returns different data:
+        expect(recipient.userId).toBe(user.id); // new userId
+        expect(recipient.email).toBe(user.email); // new email
 
         // Verify that sensitive data has been properly processed
         expect(recipient.replacements).toBeDefined();
@@ -552,6 +551,139 @@ describe('Endpoint.GetUserEmails', () => {
         expect(balanceTableReplacement!.html).toBe('<p class="description">' + $t('4c4f6571-f7b5-469d-a16f-b1547b43a610') + '</p>');
     });
 
+    test('Should return one recipient for each member the user is associated with, if the email is different for each member', async () => {
+        // Create another member associated with the same user
+        const secondMember = await new MemberFactory({
+            organization,
+            user,
+        }).create();
+
+        // Create an email
+        const email = new Email();
+        email.subject = 'Email for Multiple Members';
+        email.status = EmailStatus.Sent;
+        email.text = 'Member name: {{memberFirstName}}';
+        email.html = '<p>Member name: {{memberFirstName}}</p>';
+        email.json = {};
+        email.organizationId = organization.id;
+        email.showInMemberPortal = true;
+        email.sentAt = new Date();
+        await email.save();
+
+        // Create an email recipient linked to the FIRST member
+        const recipient1 = new EmailRecipient();
+        recipient1.emailId = email.id;
+        recipient1.memberId = member.id; // First member
+        recipient1.userId = user.id;
+        recipient1.email = user.email;
+        recipient1.firstName = member.details.firstName;
+        recipient1.lastName = member.details.lastName;
+        recipient1.replacements = [
+            Replacement.create({
+                token: 'memberFirstName',
+                value: member.details.firstName,
+            }),
+        ];
+        recipient1.sentAt = new Date();
+        await recipient1.save();
+
+        // Create an email recipient linked to the SECOND member
+        const recipient2 = new EmailRecipient();
+        recipient2.emailId = email.id;
+        recipient2.memberId = secondMember.id; // Second member
+        recipient2.userId = user.id;
+        recipient2.email = user.email;
+        recipient2.firstName = secondMember.details.firstName;
+        recipient2.lastName = secondMember.details.lastName;
+        recipient2.sentAt = new Date();
+        recipient2.replacements = [
+            Replacement.create({
+                token: 'memberFirstName',
+                value: secondMember.details.firstName,
+            }),
+        ];
+        await recipient2.save();
+
+        const response = await getUserEmails(
+            new LimitedFilteredRequest({ limit: 10, search: 'Email for Multiple Members' }),
+        );
+
+        expect(response.body.results).toHaveLength(1);
+        const emailResult = response.body.results[0];
+
+        // Should include both members as separate recipients
+        expect(emailResult.recipients).toHaveLength(2);
+        const firstNames = emailResult.recipients.map(r => r.member?.firstName);
+        expect(firstNames).toContain(member.details.firstName);
+        expect(firstNames).toContain(secondMember.details.firstName);
+    });
+
+    test('Should return a merged recipient for each member the user is associated with, if the email is the same for each member', async () => {
+        // Create another member associated with the same user
+        const secondMember = await new MemberFactory({
+            organization,
+            user,
+        }).create();
+
+        // Create an email
+        const email = new Email();
+        email.subject = 'Email for Multiple Members';
+        email.status = EmailStatus.Sent;
+        email.text = 'Same content';
+        email.html = '<p>Same content</p>';
+        email.json = {};
+        email.organizationId = organization.id;
+        email.showInMemberPortal = true;
+        email.sentAt = new Date();
+        await email.save();
+
+        // Create an email recipient linked to the FIRST member
+        const recipient1 = new EmailRecipient();
+        recipient1.emailId = email.id;
+        recipient1.memberId = member.id; // First member
+        recipient1.userId = user.id;
+        recipient1.email = user.email;
+        recipient1.firstName = member.details.firstName;
+        recipient1.lastName = member.details.lastName;
+        recipient1.replacements = [
+            // will get automatically removed because it is not used
+            Replacement.create({
+                token: 'memberFirstName',
+                value: member.details.firstName,
+            }),
+        ];
+        recipient1.sentAt = new Date();
+        await recipient1.save();
+
+        // Create an email recipient linked to the SECOND member
+        const recipient2 = new EmailRecipient();
+        recipient2.emailId = email.id;
+        recipient2.memberId = secondMember.id; // Second member
+        recipient2.userId = user.id;
+        recipient2.email = user.email;
+        recipient2.firstName = secondMember.details.firstName;
+        recipient2.lastName = secondMember.details.lastName;
+        recipient2.sentAt = new Date();
+        recipient2.replacements = [
+            // will get automatically removed because it is not used
+            Replacement.create({
+                token: 'memberFirstName',
+                value: secondMember.details.firstName,
+            }),
+        ];
+        await recipient2.save();
+
+        const response = await getUserEmails(
+            new LimitedFilteredRequest({ limit: 10, search: 'Email for Multiple Members' }),
+        );
+
+        expect(response.body.results).toHaveLength(1);
+        const emailResult = response.body.results[0];
+
+        // Should include both members as separate recipients
+        expect(emailResult.recipients).toHaveLength(1);
+    });
+
     test('Should not return emails from other members the user does not have access to', async () => {
         // Create another user and member
         const otherUser = await new UserFactory({

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

@@ -2,22 +2,39 @@ import { AutoEncoder, BooleanDecoder, Decoder, field, StringDecoder } from '@sim
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { EmailAddress } from '@stamhoofd/email';
+import { Context } from '../../../helpers/Context';
+import { SESv2Client, DeleteSuppressedDestinationCommand } from '@aws-sdk/client-sesv2'; // ES Modules import
 
 type Params = Record<string, never>;
 type Query = undefined;
 
 class Body extends AutoEncoder {
-    @field({ decoder: StringDecoder })
-    id: string;
+    @field({ decoder: StringDecoder, nullable: true, optional: true })
+    id: string | null = null;
 
-    @field({ decoder: StringDecoder })
-    token: string;
+    @field({ decoder: StringDecoder, nullable: true, optional: true })
+    token: string | null = null;
+
+    @field({ decoder: StringDecoder, nullable: true, optional: true })
+    email: string | null = null;
 
     @field({ decoder: BooleanDecoder, optional: true })
     unsubscribedMarketing?: boolean;
 
     @field({ decoder: BooleanDecoder, optional: true })
     unsubscribedAll?: boolean;
+
+    /**
+     * Set to false to unblock
+     */
+    @field({ decoder: BooleanDecoder, optional: true })
+    hardBounce?: boolean;
+
+    /**
+     * Set to false to unblock
+     */
+    @field({ decoder: BooleanDecoder, optional: true })
+    markedAsSpam?: boolean;
 }
 
 type ResponseBody = undefined;
@@ -39,19 +56,90 @@ export class ManageEmailAddressEndpoint extends Endpoint<Params, Query, Body, Re
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const email = await EmailAddress.getByID(request.body.id);
-        if (!email || email.token !== request.body.token || request.body.token.length < 10 || request.body.id.length < 10) {
-            throw new SimpleError({
-                code: 'invalid_fields',
-                message: 'Invalid token or id',
-                human: $t(`ceacb5a8-7777-4366-abcb-9dd90ffb832e`),
-            });
+        if (request.body.id) {
+            if (!request.body.token) {
+                throw new SimpleError({
+                    code: 'missing_field',
+                    message: 'Missing token',
+                    field: 'token',
+                });
+            }
+            const email = await EmailAddress.getByID(request.body.id);
+            if (!email || email.token !== request.body.token || request.body.token.length < 10 || request.body.id.length < 10) {
+                throw new SimpleError({
+                    code: 'invalid_fields',
+                    message: 'Invalid token or id',
+                    human: $t(`ceacb5a8-7777-4366-abcb-9dd90ffb832e`),
+                });
+            }
+
+            email.unsubscribedAll = request.body.unsubscribedAll ?? email.unsubscribedAll;
+            email.unsubscribedMarketing = request.body.unsubscribedMarketing ?? email.unsubscribedMarketing;
+
+            await email.save();
+            return new Response(undefined);
         }
+        else {
+            if (!request.body.email) {
+                throw new SimpleError({
+                    code: 'missing_field',
+                    message: 'Missing email or id',
+                    field: 'email',
+                });
+            }
 
-        email.unsubscribedAll = request.body.unsubscribedAll ?? email.unsubscribedAll;
-        email.unsubscribedMarketing = request.body.unsubscribedMarketing ?? email.unsubscribedMarketing;
+            const organization = await Context.setOptionalOrganizationScope();
+            await Context.authenticate();
 
-        await email.save();
-        return new Response(undefined);
+            if (!Context.auth.hasPlatformFullAccess()) {
+                throw Context.auth.error();
+            }
+
+            const query = EmailAddress.select().where(
+                'email', request.body.email,
+            );
+            if (organization) {
+                query.andWhere('organizationId', organization.id);
+            }
+
+            const emails = await query.fetch();
+
+            if (emails.length === 0) {
+                throw new SimpleError({
+                    code: 'not_found',
+                    message: 'Email not found',
+                    human: $t(`9ddb6616-f62d-4c91-82a9-e5cf398e4c4a`),
+                    statusCode: 404,
+                });
+            }
+            console.log('Updated email address settings', request.body);
+            const client = new SESv2Client({});
+
+            if (request.body.hardBounce === false || request.body.markedAsSpam === false) {
+                // Remove from AWS suppression list
+                // todo
+                try {
+                    const input = {
+                        EmailAddress: request.body.email,
+                    };
+                    const command = new DeleteSuppressedDestinationCommand(input);
+                    const response = await client.send(command);
+                    console.log('Removed from AWS suppression list', request.body.email, response);
+                }
+                catch (error) {
+                    console.error('Error removing from suppression list', request.body.email, error);
+                }
+            }
+
+            for (const email of emails) {
+                email.unsubscribedAll = request.body.unsubscribedAll ?? email.unsubscribedAll;
+                email.unsubscribedMarketing = request.body.unsubscribedMarketing ?? email.unsubscribedMarketing;
+                email.hardBounce = request.body.hardBounce ?? email.hardBounce;
+                email.markedAsSpam = request.body.markedAsSpam ?? email.markedAsSpam;
+                await email.save();
+            }
+
+            return new Response(undefined);
+        }
     }
 }

package/src/endpoints/global/email-recipients/RetryEmailRecipientEndpoint.ts

@@ -0,0 +1,83 @@
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { Email, EmailRecipient } from '@stamhoofd/models';
+import { EmailRecipient as EmailRecipientStruct, EmailStatus, PermissionLevel } 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 = EmailRecipientStruct;
+
+export class RetryEmailRecipientEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'POST') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/email-recipients/@id/retry', { id: String });
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOptionalOrganizationScope();
+        await Context.authenticate();
+
+        if (!await Context.auth.canReadEmails(organization)) {
+            // Fast fail before query
+            throw Context.auth.error();
+        }
+        const emailRecipient = await EmailRecipient.getByID(request.params.id);
+        if (!emailRecipient || emailRecipient.organizationId !== (organization?.id ?? null)) {
+            throw new SimpleError({
+                code: 'not_found',
+                message: 'Email recipient not found',
+                human: $t(`2e79bf4a-878b-43b0-902b-9d080c8b7fdf`),
+                statusCode: 404,
+            });
+        }
+
+        const model = await Email.getByID(emailRecipient.emailId);
+        if (!model || (model.organizationId !== (organization?.id ?? null))) {
+            throw new SimpleError({
+                code: 'not_found',
+                message: 'Email not found',
+                human: $t(`9ddb6616-f62d-4c91-82a9-e5cf398e4c4a`),
+                statusCode: 404,
+            });
+        }
+
+        if (!await Context.auth.canAccessEmail(model, PermissionLevel.Write)) {
+            throw Context.auth.error();
+        }
+
+        if (model.status !== EmailStatus.Sent) {
+            throw new SimpleError({
+                code: 'not_sent',
+                message: 'Cant retry email that is not sent',
+                statusCode: 400,
+            });
+        }
+
+        if (emailRecipient.sentAt) {
+            throw new SimpleError({
+                code: 'already_sent',
+                message: 'Cant retry email recipient that is already sent',
+                human: $t(`f3f837eb-d6f7-4c6e-9477-d566a03e09b1`),
+                statusCode: 400,
+            });
+        }
+
+        // Retry
+        await model.resumeSending(emailRecipient.id);
+
+        await emailRecipient.refresh();
+
+        return new Response((await EmailRecipient.getStructures([emailRecipient]))[0]);
+    }
+}