@stamhoofd/backend 2.60.0 → 2.61.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.60.0",
+    "version": "2.61.1",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -37,14 +37,14 @@
         "@simonbackx/simple-encoding": "2.18.0",
         "@simonbackx/simple-endpoints": "1.15.0",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.60.0",
-        "@stamhoofd/backend-middleware": "2.60.0",
-        "@stamhoofd/email": "2.60.0",
-        "@stamhoofd/models": "2.60.0",
-        "@stamhoofd/queues": "2.60.0",
-        "@stamhoofd/sql": "2.60.0",
-        "@stamhoofd/structures": "2.60.0",
-        "@stamhoofd/utility": "2.60.0",
+        "@stamhoofd/backend-i18n": "2.61.1",
+        "@stamhoofd/backend-middleware": "2.61.1",
+        "@stamhoofd/email": "2.61.1",
+        "@stamhoofd/models": "2.61.1",
+        "@stamhoofd/queues": "2.61.1",
+        "@stamhoofd/sql": "2.61.1",
+        "@stamhoofd/structures": "2.61.1",
+        "@stamhoofd/utility": "2.61.1",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -64,5 +64,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "94ec449bbd82a2e3f49471e66136b04b902587bd"
+    "gitHead": "f092f61cf3641682fb5a5a9cb50c7977b1e350ef"
 }

package/src/audit-logs/EmailAddressLogger.ts

@@ -0,0 +1,45 @@
+import { EmailAddress } from '@stamhoofd/email';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType } from '@stamhoofd/structures';
+import { ModelLogger } from './ModelLogger';
+
+export const EmailAddressLogger = new ModelLogger(EmailAddress, {
+    async optionsGenerator(event) {
+        if (event.type === 'deleted') {
+            return;
+        }
+
+        const wasUnsubscribed = event.type === 'updated' ? !!event.originalFields.unsubscribedAll : false;
+        const isUnsubscribed = event.model.unsubscribedAll;
+
+        if (!wasUnsubscribed && isUnsubscribed) {
+            return {
+                type: AuditLogType.EmailAddressUnsubscribed,
+                data: {},
+                generatePatchList: false,
+            };
+        }
+
+        const wasUnsubscribedMarketing = event.type === 'updated' ? !!event.originalFields.unsubscribedMarketing : false;
+        const isUnsubscribedMarketing = event.model.unsubscribedMarketing;
+
+        if (!wasUnsubscribedMarketing && isUnsubscribedMarketing) {
+            return {
+                type: AuditLogType.EmailAddressUnsubscribed,
+                data: {},
+                generatePatchList: false,
+            };
+        }
+    },
+
+    createReplacements(model, options) {
+        const map = new Map([
+            ['e', AuditLogReplacement.create({
+                id: model.id,
+                value: model.email || '',
+                type: AuditLogReplacementType.EmailAddress,
+            })],
+        ]);
+        return map;
+    },
+
+});

package/src/audit-logs/EmailLogger.ts

@@ -0,0 +1,67 @@
+import { Email, EmailRecipient, replaceHtml } from '@stamhoofd/models';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType, EmailStatus } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { ModelLogger } from './ModelLogger';
+
+export const EmailLogger = new ModelLogger(Email, {
+    async optionsGenerator(event) {
+        if (event.type === 'deleted') {
+            return;
+        }
+        let oldStatus = EmailStatus.Draft;
+
+        if (event.type === 'updated') {
+            oldStatus = event.originalFields.status as EmailStatus;
+        }
+
+        const newStatus = event.model.status as EmailStatus;
+        if (newStatus === oldStatus) {
+            return;
+        }
+
+        if (newStatus !== EmailStatus.Sent && newStatus !== EmailStatus.Sending) {
+            return;
+        }
+
+        if (newStatus === EmailStatus.Sent) {
+            const recipient = await EmailRecipient.select().where('emailId', event.model.id).whereNot('sentAt', null).first(false);
+            // Get first recipient
+            return {
+                type: AuditLogType.EmailSent,
+                data: {
+                    recipient,
+                },
+                generatePatchList: false,
+            };
+        }
+
+        return {
+            type: AuditLogType.EmailSending,
+            data: {
+                recipient: null,
+            },
+            generatePatchList: false,
+        };
+    },
+
+    createReplacements(model, options) {
+        const map = new Map([
+            ['e', AuditLogReplacement.create({
+                id: model.id,
+                value: model.subject || '',
+                type: AuditLogReplacementType.Email,
+            })],
+            ['c', AuditLogReplacement.create({
+                value: Formatter.integer(model.recipientCount ?? 0),
+                count: model.recipientCount ?? 0,
+            })],
+        ]);
+        if (options.data.recipient) {
+            map.set('html', AuditLogReplacement.html(
+                replaceHtml(model.html ?? '', options.data.recipient?.replacements ?? []),
+            ));
+        }
+        return map;
+    },
+
+});

package/src/audit-logs/EmailTemplateLogger.ts

@@ -0,0 +1,33 @@
+import { EmailTemplate } from '@stamhoofd/models';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType } from '@stamhoofd/structures';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
+const defaultGenerator = getDefaultGenerator({
+    created: AuditLogType.EmailTemplateAdded,
+    updated: AuditLogType.EmailTemplateEdited,
+    deleted: AuditLogType.EmailTemplateDeleted,
+});
+
+export const EmailTemplateLogger = new ModelLogger(EmailTemplate, {
+    skipKeys: ['json', 'text'], // html uses a special rendering method
+    async optionsGenerator(event) {
+        const result = await defaultGenerator(event);
+
+        if (!result) {
+            return;
+        }
+
+        // Manually inject helper methods to compare html
+
+        return result;
+    },
+
+    createReplacements(model) {
+        return new Map([
+            ['e', AuditLogReplacement.create({
+                id: model.id,
+                value: model.type.includes('Saved') ? model.subject : model.type, // Translated in UI
+                type: AuditLogReplacementType.EmailTemplate,
+            })],
+        ]);
+    },
+});

package/src/audit-logs/ModelLogger.ts

@@ -1,6 +1,6 @@
 import { Model, ModelEvent } from '@simonbackx/simple-database';
 import { AuditLog } from '@stamhoofd/models';
-import { AuditLogReplacement, AuditLogSource, AuditLogType } from '@stamhoofd/structures';
+import { AuditLogPatchItem, AuditLogPatchItemType, AuditLogReplacement, AuditLogSource, AuditLogType } from '@stamhoofd/structures';
 import { ContextInstance } from '../helpers/Context';
 import { AuditLogService } from '../services/AuditLogService';
 import { diffUnknown } from '../services/diff';
@@ -24,6 +24,8 @@ type EventOptionsGenerator<M extends Model, D> = (event: ModelEvent<M>) => Model
 export type ModelLoggerOptions<M extends Model, D = undefined> = {
     optionsGenerator: EventOptionsGenerator<M, D>;
     skipKeys?: string[];
+    sensitiveKeys?: string[];
+    renamedKeys?: Record<string, string>;
     generateDescription?(event: ModelEvent<M>, options: ModelEventLogOptions<D>): string | null | undefined;
     createReplacements?(model: M, options: ModelEventLogOptions<D>): Map<string, AuditLogReplacement>;
     postProcess?(event: ModelEvent<M>, options: ModelEventLogOptions<D>, log: AuditLog): Promise<void> | void;
@@ -88,10 +90,13 @@ export class ModelLogger<ModelType extends typeof Model, M extends InstanceType<
     model: ModelType;
     optionsGenerator: EventOptionsGenerator<M, D>;
     skipKeys: string[] = [];
+    sensitiveKeys: string[] = [];
+    renamedKeys: Record<string, string> = {};
     generateDescription?: (event: ModelEvent<M>, options: ModelEventLogOptions<D>) => string | null | undefined;
     createReplacements?: (model: M, options: ModelEventLogOptions<D>) => Map<string, AuditLogReplacement>;
     postProcess?: (event: ModelEvent<M>, options: ModelEventLogOptions<D>, log: AuditLog) => Promise<void> | void;
     static sharedSkipKeys = ['id', 'createdAt', 'updatedAt', 'deletedAt'];
+    static sharedSensitiveKeys = ['password'];
 
     constructor(model: ModelType, options: ModelLoggerOptions<M, D>) {
         this.model = model;
@@ -100,6 +105,8 @@ export class ModelLogger<ModelType extends typeof Model, M extends InstanceType<
         this.generateDescription = options.generateDescription;
         this.createReplacements = options.createReplacements;
         this.postProcess = options.postProcess;
+        this.sensitiveKeys = options.sensitiveKeys ?? [];
+        this.renamedKeys = options.renamedKeys ?? {};
     }
 
     async logEvent(event: ModelEvent<M>) {
@@ -150,11 +157,20 @@ export class ModelLogger<ModelType extends typeof Model, M extends InstanceType<
                             // Ignore relations
                             continue;
                         }
-                        log.patchList.push(...diffUnknown(
-                            key in oldModel ? oldModel[key] : undefined,
-                            key in event.model ? event.model[key] : undefined,
-                            AuditLogReplacement.key(key),
-                        ));
+                        const renamedKey = this.renamedKeys?.[key] ?? key;
+                        if (ModelLogger.sharedSensitiveKeys.includes(key) || (this.skipKeys && this.skipKeys.includes(key))) {
+                            log.patchList.push(AuditLogPatchItem.create({
+                                key: AuditLogReplacement.key(renamedKey),
+                                type: AuditLogPatchItemType.Changed,
+                            }));
+                        }
+                        else {
+                            log.patchList.push(...diffUnknown(
+                                key in oldModel ? oldModel[key] : undefined,
+                                key in event.model ? event.model[key] : undefined,
+                                AuditLogReplacement.key(renamedKey),
+                            ));
+                        }
                     }
 
                     // Remove skipped keys

package/src/audit-logs/OrderLogger.ts

@@ -1,6 +1,6 @@
 import { Order, Webshop } from '@stamhoofd/models';
-import { getDefaultGenerator, ModelLogger } from './ModelLogger';
 import { AuditLogReplacement, AuditLogReplacementType, AuditLogType, OrderStatus } from '@stamhoofd/structures';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
 
 const defaultGenerator = getDefaultGenerator({
     created: AuditLogType.OrderAdded,

package/src/audit-logs/UserLogger.ts

@@ -0,0 +1,45 @@
+import { User } from '@stamhoofd/models';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType } from '@stamhoofd/structures';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
+
+const defaultGenerator = getDefaultGenerator({
+    created: AuditLogType.UserAdded,
+    updated: AuditLogType.UserEdited,
+    deleted: AuditLogType.UserDeleted,
+});
+
+export const UserLogger = new ModelLogger(User, {
+    skipKeys: ['meta'],
+    sensitiveKeys: ['password'],
+    renamedKeys: {
+        memberId: 'linkedMember',
+        verified: 'emailVerified',
+    },
+    async optionsGenerator(event) {
+        const result = await defaultGenerator(event);
+
+        if (!result) {
+            return;
+        }
+
+        if (!event.model.hasAccount() && !event.model.permissions) {
+            // Do not log changes to placeholder users
+
+            if (event.type !== 'updated' || (event.originalFields.permissions === null)) {
+                return;
+            }
+        }
+
+        return result;
+    },
+
+    createReplacements: (model, options) => {
+        return new Map([
+            ['u', AuditLogReplacement.create({
+                id: model.id,
+                value: model.email,
+                type: AuditLogReplacementType.User,
+            })],
+        ]);
+    },
+});

package/src/crons/amazon-ses.ts

@@ -0,0 +1,324 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import { registerCron } from '@stamhoofd/crons';
+import { Email, EmailAddress } from '@stamhoofd/email';
+import { AuditLog, Organization } from '@stamhoofd/models';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogSource, AuditLogType } from '@stamhoofd/structures';
+import AWS from 'aws-sdk';
+import { ForwardHandler } from '../helpers/ForwardHandler';
+
+registerCron('checkComplaints', checkComplaints);
+registerCron('checkReplies', checkReplies);
+registerCron('checkBounces', checkBounces);
+
+async function saveLog({ email, organization, type, subType, subject, response, sender, id }: { id: string; email: string; organization: Organization | undefined; type: AuditLogType; subType?: string; subject: string; response: string; sender: string }) {
+    if (!id || typeof id !== 'string') {
+        throw new Error('Invalid AWS SES id received');
+    }
+
+    const log = new AuditLog();
+    log.organizationId = organization?.id ?? null;
+    log.externalId = 'aws-ses-message-' + id.toString();
+    log.type = type;
+    log.source = AuditLogSource.System;
+    log.objectId = email;
+    log.replacements = new Map([
+        ['e', AuditLogReplacement.create({
+            value: email || '',
+            type: AuditLogReplacementType.EmailAddress,
+        })],
+        ['subType', AuditLogReplacement.key(subType || 'unknown')],
+        ['response', AuditLogReplacement.longText(response)],
+        ['subject', AuditLogReplacement.string(subject)],
+        ['sender', AuditLogReplacement.create({
+            value: sender,
+            type: AuditLogReplacementType.EmailAddress,
+        })],
+    ]);
+    // Check if we already logged this bounce
+    const existing = await AuditLog.select().where('externalId', log.externalId).first(false);
+    if (existing) {
+        console.log('Already logged this bounce, skipping');
+        return;
+    }
+
+    await log.save();
+}
+
+async function checkBounces() {
+    if (STAMHOOFD.environment !== 'production' || !STAMHOOFD.AWS_ACCESS_KEY_ID) {
+        return;
+    }
+
+    console.log('[AWS BOUNCES] Checking bounces from AWS SQS');
+    const sqs = new AWS.SQS();
+    const messages = await sqs.receiveMessage({ QueueUrl: 'https://sqs.eu-west-1.amazonaws.com/118244293157/stamhoofd-bounces-queue', MaxNumberOfMessages: 10 }).promise();
+    if (messages.Messages) {
+        for (const message of messages.Messages) {
+            console.log('[AWS BOUNCES] Received bounce message');
+            console.log('[AWS BOUNCES]', message);
+
+            if (message.ReceiptHandle) {
+                if (STAMHOOFD.environment === 'production') {
+                    await sqs.deleteMessage({
+                        QueueUrl: 'https://sqs.eu-west-1.amazonaws.com/118244293157/stamhoofd-bounces-queue',
+                        ReceiptHandle: message.ReceiptHandle,
+                    }).promise();
+                    console.log('[AWS BOUNCES] Deleted from queue');
+                }
+            }
+
+            try {
+                if (message.Body) {
+                    // decode the JSON value
+                    const bounce = JSON.parse(message.Body);
+
+                    if (bounce.Message) {
+                        const message = JSON.parse(bounce.Message);
+
+                        if (message.bounce) {
+                            const b = message.bounce;
+                            // Block all receivers that generate a permanent bounce
+                            const type = b.bounceType;
+                            const subtype = b.bounceSubType;
+
+                            const source = message.mail.source;
+
+                            // try to find organization that is responsible for this e-mail address
+
+                            for (const recipient of b.bouncedRecipients) {
+                                const email = recipient.emailAddress;
+
+                                if (
+                                    type === 'Permanent'
+                                    || (
+                                        recipient.diagnosticCode && (
+                                            (recipient.diagnosticCode as string).toLowerCase().includes('invalid domain')
+                                            || (recipient.diagnosticCode as string).toLowerCase().includes('unable to lookup dns')
+                                        )
+                                    )
+                                ) {
+                                    const organization: Organization | undefined = source ? await Organization.getByEmail(source) : undefined;
+                                    if (organization) {
+                                        const emailAddress = await EmailAddress.getOrCreate(email, organization.id);
+                                        emailAddress.hardBounce = true;
+                                        await emailAddress.save();
+                                    }
+                                    else {
+                                        console.error('[AWS BOUNCES] Unknown organization for email address ' + source);
+                                    }
+
+                                    await saveLog({
+                                        id: b.feedbackId,
+                                        email,
+                                        organization,
+                                        type: AuditLogType.EmailAddressHardBounced,
+                                        subType: subtype || 'unknown',
+                                        sender: source,
+                                        response: b.diagnosticCode || '',
+                                        subject: message.mail.commonHeaders?.subject || '',
+                                    });
+                                }
+                                else if (
+                                    type === 'Transient'
+                                ) {
+                                    const organization: Organization | undefined = source ? await Organization.getByEmail(source) : undefined;
+                                    await saveLog({
+                                        id: b.feedbackId,
+                                        email,
+                                        organization,
+                                        type: AuditLogType.EmailAddressSoftBounced,
+                                        subType: subtype || 'unknown',
+                                        sender: source,
+                                        response: b.diagnosticCode || '',
+                                        subject: message.mail.commonHeaders?.subject || '',
+                                    });
+                                }
+                            }
+                            console.log('[AWS BOUNCES] For domain ' + source);
+                        }
+                        else {
+                            console.log("[AWS BOUNCES] 'bounce' field missing in bounce message");
+                        }
+                    }
+                    else {
+                        console.log("[AWS BOUNCES] 'Message' field missing in bounce message");
+                    }
+                }
+                else {
+                    console.log('[AWS BOUNCES] Message Body missing in bounce');
+                }
+            }
+            catch (e) {
+                console.log('[AWS BOUNCES] Bounce message processing failed:');
+                console.error('[AWS BOUNCES] Bounce message processing failed:');
+                console.error('[AWS BOUNCES]', e);
+            }
+        }
+    }
+}
+
+async function checkReplies() {
+    if (STAMHOOFD.environment !== 'production' || !STAMHOOFD.AWS_ACCESS_KEY_ID) {
+        return;
+    }
+
+    console.log('Checking replies from AWS SQS');
+    const sqs = new AWS.SQS();
+    const messages = await sqs.receiveMessage({ QueueUrl: 'https://sqs.eu-west-1.amazonaws.com/118244293157/stamhoofd-email-forwarding', MaxNumberOfMessages: 10 }).promise();
+    if (messages.Messages) {
+        for (const message of messages.Messages) {
+            console.log('Received message from forwarding queue');
+
+            if (message.ReceiptHandle) {
+                if (STAMHOOFD.environment === 'production') {
+                    await sqs.deleteMessage({
+                        QueueUrl: 'https://sqs.eu-west-1.amazonaws.com/118244293157/stamhoofd-email-forwarding',
+                        ReceiptHandle: message.ReceiptHandle,
+                    }).promise();
+                    console.log('Deleted from queue');
+                }
+            }
+
+            try {
+                if (message.Body) {
+                    // decode the JSON value
+                    const bounce = JSON.parse(message.Body);
+
+                    if (bounce.Message) {
+                        const message = JSON.parse(bounce.Message);
+
+                        // Read message content
+                        if (message.mail && message.content && message.receipt) {
+                            const content = message.content;
+                            const receipt = message.receipt as {
+                                recipients: string[];
+                                spamVerdict: { status: 'PASS' | string };
+                                virusVerdict: { status: 'PASS' | string };
+                                spfVerdict: { status: 'PASS' | string };
+                                dkimVerdict: { status: 'PASS' | string };
+                                dmarcVerdict: { status: 'PASS' | string };
+                            };
+
+                            const options = await ForwardHandler.handle(content, receipt);
+                            if (options) {
+                                if (STAMHOOFD.environment === 'production') {
+                                    Email.send(options);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+    }
+}
+
+async function checkComplaints() {
+    if (STAMHOOFD.environment !== 'production' || !STAMHOOFD.AWS_ACCESS_KEY_ID) {
+        return;
+    }
+
+    console.log('[AWS COMPLAINTS] Checking complaints from AWS SQS');
+    const sqs = new AWS.SQS();
+    const messages = await sqs.receiveMessage({ QueueUrl: 'https://sqs.eu-west-1.amazonaws.com/118244293157/stamhoofd-complaints-queue', MaxNumberOfMessages: 10 }).promise();
+    if (messages.Messages) {
+        for (const message of messages.Messages) {
+            console.log('[AWS COMPLAINTS] Received complaint message');
+            console.log('[AWS COMPLAINTS]', message);
+
+            if (message.ReceiptHandle) {
+                if (STAMHOOFD.environment === 'production') {
+                    await sqs.deleteMessage({
+                        QueueUrl: 'https://sqs.eu-west-1.amazonaws.com/118244293157/stamhoofd-complaints-queue',
+                        ReceiptHandle: message.ReceiptHandle,
+                    }).promise();
+                    console.log('[AWS COMPLAINTS] Deleted from queue');
+                }
+            }
+
+            try {
+                if (message.Body) {
+                    // decode the JSON value
+                    const complaint = JSON.parse(message.Body);
+                    console.log('[AWS COMPLAINTS]', complaint);
+
+                    if (complaint.Message) {
+                        const message = JSON.parse(complaint.Message);
+
+                        if (message.complaint) {
+                            const b = message.complaint;
+                            const source = message.mail.source;
+                            const organization: Organization | undefined = source ? await Organization.getByEmail(source) : undefined;
+
+                            const type: 'abuse' | 'auth-failure' | 'fraud' | 'not-spam' | 'other' | 'virus' = b.complaintFeedbackType;
+
+                            if (organization) {
+                                for (const recipient of b.complainedRecipients) {
+                                    const email = recipient.emailAddress;
+                                    const emailAddress = await EmailAddress.getOrCreate(email, organization.id);
+                                    emailAddress.markedAsSpam = type !== 'not-spam';
+                                    await emailAddress.save();
+
+                                    if (type !== 'not-spam') {
+                                        if (type === 'virus' || type === 'fraud') {
+                                            await saveLog({
+                                                id: b.feedbackId,
+                                                email: source,
+                                                organization,
+                                                type: AuditLogType.EmailAddressFraudComplaint,
+                                                subType: type || 'unknown',
+                                                sender: source,
+                                                response: b.diagnosticCode || '',
+                                                subject: message.mail.commonHeaders?.subject || '',
+                                            });
+                                        }
+                                        else {
+                                            await saveLog({
+                                                id: b.feedbackId,
+                                                email: source,
+                                                organization,
+                                                type: AuditLogType.EmailAddressMarkedAsSpam,
+                                                subType: type || 'unknown',
+                                                sender: source,
+                                                response: b.diagnosticCode || '',
+                                                subject: message.mail.commonHeaders?.subject || '',
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                console.error('[AWS COMPLAINTS] Unknown organization for email address ' + source);
+                            }
+
+                            if (type === 'virus' || type === 'fraud') {
+                                console.error('[AWS COMPLAINTS] Received virus / fraud complaint!');
+                                console.error('[AWS COMPLAINTS]', complaint);
+                                if (STAMHOOFD.environment === 'production') {
+                                    Email.sendWebmaster({
+                                        subject: 'Received a ' + type + ' email notification',
+                                        text: 'We received a ' + type + ' notification for an e-mail from the organization: ' + organization?.name + '. Please check and adjust if needed.\n',
+                                    });
+                                }
+                            }
+                        }
+                        else {
+                            console.log('[AWS COMPLAINTS] Missing complaint field');
+                        }
+                    }
+                    else {
+                        console.log('[AWS COMPLAINTS] Missing message field in complaint');
+                    }
+                }
+            }
+            catch (e) {
+                console.log('[AWS COMPLAINTS] Complain message processing failed:');
+                console.error('[AWS COMPLAINTS] Complain message processing failed:');
+                console.error('[AWS COMPLAINTS]', e);
+            }
+        }
+    }
+}

package/src/crons/clearExcelCache.ts

@@ -1,8 +1,11 @@
+import { registerCron } from '@stamhoofd/crons';
 import fs from 'fs/promises';
 
 const msIn22Hours = 79200000;
 let lastExcelClear: number | null = null;
 
+registerCron('clearExcelCache', clearExcelCache);
+
 export async function clearExcelCache() {
     const now = new Date();
 

package/src/crons/endFunctionsOfUsersWithoutRegistration.ts

@@ -1,8 +1,11 @@
+import { registerCron } from '@stamhoofd/crons';
 import { FlagMomentCleanup } from '../helpers/FlagMomentCleanup';
 
 let lastCleanupYear: number = -1;
 let lastCleanupMonth: number = -1;
 
+registerCron('endFunctionsOfUsersWithoutRegistration', endFunctionsOfUsersWithoutRegistration);
+
 export async function endFunctionsOfUsersWithoutRegistration() {
     const now = new Date();
     const currentYear = now.getFullYear();

package/src/crons/index.ts

@@ -0,0 +1,4 @@
+import './amazon-ses.js';
+import './clearExcelCache.js';
+import './endFunctionsOfUsersWithoutRegistration.js';
+import './postmark.js';