@stamhoofd/email 2.119.0 → 2.120.1

package/src/classes/EmailMocker.ts

@@ -1,145 +0,0 @@
-import { TestUtils } from '@stamhoofd/test-utils';
-import { Email, InternalEmailData } from './Email.js';
-
-type MockedCallback = (data: InternalEmailData) => Promise<void> | void;
-type MockedResponse = { error?: Error | null; callback?: MockedCallback };
-
-export class EmailMocker {
-    sentEmails: InternalEmailData[] = [];
-    failedEmails: InternalEmailData[] = [];
-
-    responseQueue: MockedResponse[] = [];
-    mode: 'transactional' | 'broadcast' = 'transactional';
-
-    constructor(mode: 'transactional' | 'broadcast' = 'transactional') {
-        this.mode = mode;
-    }
-
-    static transactional = new EmailMocker('transactional');
-    static broadcast = new EmailMocker('broadcast');
-
-    static infect() {
-        if (STAMHOOFD.environment !== 'test') {
-            throw new Error('EmailMocker can only be used in test environment');
-        }
-
-        const handler = async (mocker: EmailMocker, data: InternalEmailData) => {
-            const nextHandler = mocker.responseQueue.shift();
-
-            try {
-                if (nextHandler) {
-                    if (nextHandler.callback) {
-                        await nextHandler.callback(data);
-                    }
-                    if (nextHandler.error) {
-                        throw nextHandler.error;
-                    }
-                }
-            }
-            catch (e) {
-                mocker.failedEmails.push(data);
-                throw e;
-            }
-
-            mocker.sentEmails.push(data);
-
-            return {
-                messageId: 'mocked-' + mocker.sentEmails.length,
-            };
-        };
-
-        TestUtils.addBeforeAll(async () => {
-            // We load async here because this is a dev dependency (otherwise Node will reach this and complain, breaking the boot)
-            const sinon = await import('sinon');
-
-            sinon.stub(Email, 'setupIfNeeded').callsFake(function (this: typeof Email) {
-                this.transporter = {
-                    sendMail: async (data: InternalEmailData) => {
-                        return handler(EmailMocker.broadcast, data);
-                    },
-                } as any;
-
-                this.transactionalTransporter = {
-                    sendMail: async (data: InternalEmailData) => {
-                        return handler(EmailMocker.transactional, data);
-                    },
-                } as any;
-            });
-        });
-
-        TestUtils.addAfterEach(() => {
-            EmailMocker.afterAll();
-        });
-    }
-
-    static afterAll() {
-        // Clear
-        EmailMocker.transactional.reset();
-        EmailMocker.broadcast.reset();
-    }
-
-    reset() {
-        this.sentEmails = [];
-        this.failedEmails = [];
-        this.responseQueue = [];
-    }
-
-    // Defining failure / success
-    onNext(callback: MockedCallback) {
-        this.responseQueue.push({ callback });
-    }
-
-    succeedNext() {
-        this.responseQueue.push({});
-    }
-
-    failNext(error: Error) {
-        this.responseQueue.push({ error });
-    }
-
-    // Helpers
-    async getSucceededCount() {
-        await Email.wait();
-        return this.sentEmails.length;
-    }
-
-    async getFailedCount() {
-        await Email.wait();
-        return this.failedEmails.length;
-    }
-
-    static async getSucceededCount() {
-        return await EmailMocker.transactional.getSucceededCount() + await EmailMocker.broadcast.getSucceededCount();
-    }
-
-    static async getFailedCount() {
-        return await EmailMocker.transactional.getFailedCount() + await EmailMocker.broadcast.getFailedCount();
-    }
-
-    getSucceededEmail(index: number) {
-        return this.sentEmails[index];
-    }
-
-    static getSucceededEmail(index: number) {
-        const transactionalCount = EmailMocker.transactional.sentEmails.length;
-        if (index < transactionalCount) {
-            return EmailMocker.transactional.getSucceededEmail(index);
-        }
-        return EmailMocker.broadcast.getSucceededEmail(index - transactionalCount);
-    }
-
-    async getSucceededEmails() {
-        await Email.wait();
-        return this.sentEmails;
-    }
-
-    static async getSucceededEmails() {
-        await Email.wait();
-        return [...EmailMocker.transactional.sentEmails, ...EmailMocker.broadcast.sentEmails];
-    }
-
-    async getFailedEmails() {
-        await Email.wait();
-        return this.failedEmails;
-    }
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from './models/EmailAddress';
-export * from './classes/Email';
-export * from './classes/EmailMocker';

package/src/migrations/1603433451-email-addresses.sql

@@ -1,14 +0,0 @@
-CREATE TABLE `email_addresses` (
-  `id` varchar(36) CHARACTER SET ascii COLLATE ascii_general_ci NOT NULL,
-  `email` varchar(255) DEFAULT NULL,
-  `organizationId` varchar(36) CHARACTER SET ascii COLLATE ascii_general_ci DEFAULT NULL,
-  `markedAsSpam` tinyint(1) DEFAULT NULL,
-  `hardBounce` tinyint(1) DEFAULT NULL,
-  `unsubscribedMarketing` tinyint(1) DEFAULT NULL,
-  `unsubscribedAll` tinyint(1) DEFAULT NULL,
-  `token` varchar(255) CHARACTER SET ascii COLLATE ascii_general_ci DEFAULT NULL,
-  `createdAt` datetime NOT NULL,
-  `updatedAt` datetime NOT NULL,
-  PRIMARY KEY (`id`),
-  UNIQUE KEY `email` (`email`,`organizationId`) USING BTREE
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

package/src/migrations/1720080973-convert-charset.sql

@@ -1,5 +0,0 @@
-set foreign_key_checks=0; 
-ALTER TABLE `email_addresses` CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;
-ALTER TABLE `email_addresses` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;
-ALTER DATABASE CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;
-set foreign_key_checks=1; 

package/src/models/EmailAddress.ts

@@ -1,160 +0,0 @@
-import { column, Database } from '@simonbackx/simple-database';
-import { QueueHandler } from '@stamhoofd/queues';
-import { QueryableModel, SQL } from '@stamhoofd/sql';
-import crypto from 'crypto';
-import { v4 as uuidv4 } from 'uuid';
-import { EmailInterfaceRecipient } from '../classes/Email.js';
-
-async function randomBytes(size: number): Promise<Buffer> {
-    return new Promise((resolve, reject) => {
-        crypto.randomBytes(size, (err: Error | null, buf: Buffer) => {
-            if (err) {
-                reject(err);
-                return;
-            }
-            resolve(buf);
-        });
-    });
-}
-
-export class EmailAddress extends QueryableModel {
-    static table = 'email_addresses';
-
-    @column({
-        primary: true, type: 'string', beforeSave(value) {
-            return value ?? uuidv4();
-        },
-    })
-    id!: string;
-
-    @column({ type: 'string', nullable: true })
-    organizationId: string | null = null;
-
-    // Columns
-    @column({ type: 'string' })
-    email: string;
-
-    @column({ type: 'boolean' })
-    markedAsSpam = false;
-
-    @column({ type: 'boolean' })
-    hardBounce = false;
-
-    @column({ type: 'boolean' })
-    unsubscribedMarketing = false;
-
-    @column({ type: 'boolean' })
-    unsubscribedAll = false;
-
-    @column({ type: 'string', nullable: true })
-    token: string | null;
-
-    /**
-     * createdAt behaves more like createdAt for Challenge. Since every save is considered to have a new challenge
-     */
-    @column({
-        type: 'datetime', beforeSave() {
-            const date = new Date();
-            date.setMilliseconds(0);
-            return date;
-        },
-    })
-    createdAt: Date;
-
-    @column({
-        type: 'datetime', beforeSave() {
-            const date = new Date();
-            date.setMilliseconds(0);
-            return date;
-        },
-    })
-    updatedAt: Date;
-
-    static async getOrCreate(email: string, organizationId: string | null): Promise<EmailAddress> {
-        // Prevent race conditions when checking the same email address at the same time, and creating a new one
-        return await QueueHandler.schedule('email-address/create-' + email + '-' + organizationId, async () => {
-            const existing = await this.getByEmail(email, organizationId);
-            if (existing) {
-                return existing;
-            }
-
-            const n = new EmailAddress();
-            n.organizationId = organizationId;
-            n.email = email;
-            n.token = (await randomBytes(64)).toString('base64').toUpperCase();
-
-            await n.save();
-
-            return n;
-        });
-    }
-
-    // Methods
-    static async getByEmails(emails: string[], organizationId: string | null): Promise<EmailAddress[]> {
-        if (emails.length > 1000) {
-            // Normally an organization will never have so much bounces, so we'll request all emails and filter in them
-            const all = await this.where({ organizationId }, { limit: 1000 });
-            return all.filter(e => emails.includes(e.email));
-        }
-
-        if (emails.length === 0) {
-            return [];
-        }
-
-        const query = EmailAddress.select().where(
-            'email', emails,
-        );
-        if (organizationId) {
-            query.andWhere(
-                SQL.where('organizationId', organizationId)
-                    .or('organizationId', null),
-            );
-        }
-        else {
-            query.andWhere(
-                SQL.where('organizationId', null)
-                    .or('hardBounce', 1)
-                    .or('markedAsSpam', 1),
-            );
-        }
-
-        return query.fetch();
-    }
-
-    // Methods
-    static async getByEmail(email: string, organizationId: string | null): Promise<EmailAddress | undefined> {
-        return (await this.where({ email, organizationId }, { limit: 1 }))[0];
-    }
-
-    /**
-     * Search organization wide if this email has been marked as spam or hard bounced
-     */
-    static async getWhereHardBounceOrSpam(email: string): Promise<EmailAddress | null> {
-        return await this.select().where(
-            'email', email,
-        ).where(
-            SQL.where('hardBounce', 1)
-                .or('markedAsSpam', 1),
-        ).first(false);
-    }
-
-    // Methods
-    static async filterSendTo(recipients: EmailInterfaceRecipient[]): Promise<EmailInterfaceRecipient[]> {
-        if (recipients.length === 0) {
-            return [];
-        }
-
-        const emails = recipients.map(r => r.email);
-        const [results] = await Database.select(
-            `SELECT email FROM ${this.table} WHERE \`email\` IN (?) AND (\`hardBounce\` = 1 OR \`markedAsSpam\` = 1)`,
-            [emails],
-        );
-
-        const remove = results.map(r => r[this.table]['email']);
-        if (remove.length === 0) {
-            return recipients;
-        }
-
-        return recipients.filter(r => !remove.includes(r.email));
-    }
-}