@stamhoofd/backend 2.97.3 → 2.98.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.97.3",
+    "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.3",
-        "@stamhoofd/backend-middleware": "2.97.3",
-        "@stamhoofd/email": "2.97.3",
-        "@stamhoofd/models": "2.97.3",
-        "@stamhoofd/queues": "2.97.3",
-        "@stamhoofd/sql": "2.97.3",
-        "@stamhoofd/structures": "2.97.3",
-        "@stamhoofd/utility": "2.97.3",
+        "@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": "254bc1658dc444653db96e7e4197b05035907a44"
+    "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/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]);
+    }
+}