@stamhoofd/backend 2.120.6 → 2.122.0

package/src/seeds-temporary/1780416000-migrate-audit-log-legacy-enums.test.ts

@@ -0,0 +1,69 @@
+import { AuditLog } from '@stamhoofd/models';
+import { AuditLogPatchItem, AuditLogReplacement, AuditLogReplacementType, EventNotificationStatus, getLegacyAuditLogEnumRegistrations, getLegacyAuditLogEnumReplacement } from '@stamhoofd/structures';
+
+import { migrateAuditLogLegacyEnums } from './1780416000-migrate-audit-log-legacy-enums.js';
+
+describe('Seed.migrate-audit-log-legacy-enums', () => {
+    test('It converts all legacy enum audit log values without changing their rendered names', () => {
+        let migratedValues = 0;
+
+        for (const registration of getLegacyAuditLogEnumRegistrations()) {
+            for (const value of Object.values(registration.enumObject)) {
+                if (typeof value !== 'string') {
+                    continue;
+                }
+
+                if (!getLegacyAuditLogEnumReplacement(value)) {
+                    continue;
+                }
+
+                const legacyReplacement = AuditLogReplacement.key(value);
+                const legacyName = legacyReplacement.toString();
+                const log = new AuditLog();
+                log.replacements = new Map([
+                    ['value', legacyReplacement.clone()],
+                ]);
+                log.patchList = [
+                    AuditLogPatchItem.create({
+                        key: legacyReplacement.clone(),
+                        oldValue: legacyReplacement.clone(),
+                        value: legacyReplacement.clone(),
+                    }),
+                ];
+
+                expect(migrateAuditLogLegacyEnums(log)).toBe(true);
+
+                const replacement = log.replacements.get('value');
+                expect(replacement?.type).toBe(AuditLogReplacementType.Enum);
+                expect(replacement?.toString()).toBe(legacyName);
+
+                expect(log.patchList[0].key.type).toBe(AuditLogReplacementType.Enum);
+                expect(log.patchList[0].key.toString()).toBe(legacyName);
+                expect(log.patchList[0].oldValue?.type).toBe(AuditLogReplacementType.Enum);
+                expect(log.patchList[0].oldValue?.toString()).toBe(legacyName);
+                expect(log.patchList[0].value?.type).toBe(AuditLogReplacementType.Enum);
+                expect(log.patchList[0].value?.toString()).toBe(legacyName);
+                migratedValues += 1;
+            }
+        }
+
+        expect(migratedValues).toBeGreaterThan(0);
+    });
+
+    test('It does not migrate event notification statuses through the legacy mapping', () => {
+        expect(getLegacyAuditLogEnumRegistrations().some(({ type }) => type === 'EventNotificationStatus')).toBe(false);
+
+        const legacyReplacement = AuditLogReplacement.key(EventNotificationStatus.Accepted);
+        const log = new AuditLog();
+        log.replacements = new Map([
+            ['value', legacyReplacement],
+        ]);
+
+        expect(migrateAuditLogLegacyEnums(log)).toBe(false);
+
+        expect(log.replacements.get('value')).toMatchObject({
+            value: EventNotificationStatus.Accepted,
+            type: AuditLogReplacementType.Key,
+        });
+    });
+});

package/src/seeds-temporary/1780416000-migrate-audit-log-legacy-enums.ts

@@ -0,0 +1,85 @@
+import { Migration } from '@simonbackx/simple-database';
+import { AuditLog } from '@stamhoofd/models';
+import { AuditLogReplacement, AuditLogReplacementType, getLegacyAuditLogEnumReplacement } from '@stamhoofd/structures';
+
+export function migrateAuditLogReplacementLegacyEnums(replacement: AuditLogReplacement | undefined): { replacement: AuditLogReplacement | undefined; changed: boolean } {
+    if (!replacement) {
+        return { replacement, changed: false };
+    }
+
+    if (replacement.type === AuditLogReplacementType.Key) {
+        const migrated = getLegacyAuditLogEnumReplacement(replacement.value);
+        if (migrated) {
+            return { replacement: migrated, changed: true };
+        }
+    }
+
+    if (replacement.type === AuditLogReplacementType.Array) {
+        let changed = false;
+        const values = replacement.values.map((value) => {
+            const result = migrateAuditLogReplacementLegacyEnums(value);
+            changed ||= result.changed;
+            return result.replacement ?? value;
+        });
+
+        if (changed) {
+            const clone = replacement.clone();
+            clone.values = values;
+            return { replacement: clone, changed: true };
+        }
+    }
+
+    return { replacement, changed: false };
+}
+
+export function migrateAuditLogLegacyEnums(log: AuditLog): boolean {
+    let changed = false;
+
+    for (const [key, replacement] of log.replacements) {
+        const result = migrateAuditLogReplacementLegacyEnums(replacement);
+        if (result.changed && result.replacement) {
+            log.replacements.set(key, result.replacement);
+            changed = true;
+        }
+    }
+
+    for (const item of log.patchList) {
+        const key = migrateAuditLogReplacementLegacyEnums(item.key);
+        if (key.changed && key.replacement) {
+            item.key = key.replacement;
+            changed = true;
+        }
+
+        const oldValue = migrateAuditLogReplacementLegacyEnums(item.oldValue);
+        if (oldValue.changed) {
+            item.oldValue = oldValue.replacement;
+            changed = true;
+        }
+
+        const value = migrateAuditLogReplacementLegacyEnums(item.value);
+        if (value.changed) {
+            item.value = value.replacement;
+            changed = true;
+        }
+    }
+
+    return changed;
+}
+
+export default new Migration(async () => {
+    console.log('Start migrating legacy audit log enum replacements.');
+
+    const batchSize = 100;
+    let count = 0;
+
+    for await (const log of AuditLog.select().limit(batchSize).all()) {
+        if (!migrateAuditLogLegacyEnums(log)) {
+            continue;
+        }
+
+        await log.save();
+        count += 1;
+    }
+
+    console.log('Finished migrating legacy audit log enum replacements for ' + count + ' audit logs.');
+});

package/src/services/AuditLogService.test.ts

@@ -0,0 +1,51 @@
+import { column, Model } from '@simonbackx/simple-database';
+import { EnumDecoder } from '@simonbackx/simple-encoding';
+import { PaymentStatus } from '@stamhoofd/structures';
+
+import { AuditLogService, modelLogDefinitions } from './AuditLogService.js';
+
+enum UnregisteredAuditLogStatus {
+    Pending = 'Pending',
+}
+
+class UnregisteredAuditLogModel extends Model {
+    static table = 'unregistered_audit_log_models';
+
+    @column({ type: 'string', decoder: new EnumDecoder(UnregisteredAuditLogStatus) })
+    status = UnregisteredAuditLogStatus.Pending;
+}
+
+class RegisteredAuditLogModel extends Model {
+    static table = 'registered_audit_log_models';
+
+    @column({ type: 'string', decoder: new EnumDecoder(PaymentStatus) })
+    status = PaymentStatus.Pending;
+}
+
+describe('AuditLogService', () => {
+    const originalModelLogDefinitions = new Map(modelLogDefinitions);
+
+    afterEach(() => {
+        modelLogDefinitions.clear();
+        for (const [model, definition] of originalModelLogDefinitions) {
+            modelLogDefinitions.set(model, definition);
+        }
+    });
+
+    test('It throws when an audited enum column has no registered translation helper', () => {
+        modelLogDefinitions.clear();
+        modelLogDefinitions.set(UnregisteredAuditLogModel, {
+            async logEvent() {
+                // Not needed for validation.
+            },
+        });
+        modelLogDefinitions.set(RegisteredAuditLogModel, {
+            async logEvent() {
+                // Not needed for validation.
+            },
+        });
+
+        expect(() => AuditLogService.validateAuditLogEnumTranslations())
+            .toThrow('Missing audit log enum translation registration for: UnregisteredAuditLogModel.status');
+    });
+});

package/src/services/AuditLogService.ts

@@ -1,5 +1,7 @@
 import type { ModelEvent } from '@simonbackx/simple-database';
 import { Model } from '@simonbackx/simple-database';
+import { ArrayDecoder, EnumDecoder, MapDecoder, SymbolDecoder } from '@simonbackx/simple-encoding';
+import { getAuditLogEnumDecoderObject, getAuditLogEnumType } from '@stamhoofd/structures';
 import type { AuditLogSource } from '@stamhoofd/structures';
 import { AsyncLocalStorage } from 'node:async_hooks';
 
@@ -15,6 +17,26 @@ export type AuditLogContextSettings = {
 };
 export const modelLogDefinitions = new Map<typeof Model, { logEvent: (event: ModelEvent) => Promise<any> }>();
 
+function getEnumDecoders(decoder: unknown): EnumDecoder<any>[] {
+    if (decoder instanceof EnumDecoder) {
+        return [decoder];
+    }
+
+    if (decoder instanceof SymbolDecoder) {
+        return getEnumDecoders(decoder.decoder);
+    }
+
+    if (decoder instanceof ArrayDecoder) {
+        return getEnumDecoders(decoder.decoder);
+    }
+
+    if (decoder instanceof MapDecoder) {
+        return [...getEnumDecoders(decoder.keyDecoder), ...getEnumDecoders(decoder.valueDecoder)];
+    }
+
+    return [];
+}
+
 export class AuditLogService {
     private constructor() { }
     static disableLocalStore = new AsyncLocalStorage<AuditLogContextSettings>();
@@ -47,6 +69,29 @@ export class AuditLogService {
 
     static listening = false;
 
+    static validateAuditLogEnumTranslations() {
+        const missing: string[] = [];
+
+        for (const [model] of modelLogDefinitions) {
+            const columns = model.columns;
+            if (!columns) {
+                continue;
+            }
+
+            for (const [key, column] of columns) {
+                for (const enumDecoder of getEnumDecoders(column.decoder)) {
+                    if (!getAuditLogEnumType(getAuditLogEnumDecoderObject(enumDecoder))) {
+                        missing.push(`${model.name}.${key}`);
+                    }
+                }
+            }
+        }
+
+        if (missing.length > 0) {
+            throw new Error(`Missing audit log enum translation registration for: ${missing.join(', ')}`);
+        }
+    }
+
     static listen() {
         if (this.listening) {
             return;

package/src/services/BalanceItemService.ts

@@ -1,7 +1,9 @@
 import { Model } from '@simonbackx/simple-database';
-import type { Organization, Payment} from '@stamhoofd/models';
-import { BalanceItem, CachedBalance, Document, MemberUser, Order, Webshop } from '@stamhoofd/models';
-import { AuditLogSource, BalanceItemStatus, BalanceItemType, OrderStatus, PaymentStatus, ReceivableBalanceType } from '@stamhoofd/structures';
+import type { Organization } from '@stamhoofd/models';
+import { BalanceItem, CachedBalance, Document, MemberUser, Order, Payment, Platform, Webshop } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+import { AuditLogSource, BalanceItemStatus, BalanceItemType, OrderStatus, PaymentStatus, PaymentType, ReceivableBalanceType } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
 import { GroupedThrottledQueue } from '../helpers/GroupedThrottledQueue.js';
 import { ThrottledQueue } from '../helpers/ThrottledQueue.js';
 import { AuditLogService } from './AuditLogService.js';
@@ -32,11 +34,21 @@ const userUpdateQueue = new GroupedThrottledQueue(async (organizationId: string,
 }, { maxDelay: 10_000 });
 
 const organizationUpdateQueue = new GroupedThrottledQueue(async (organizationId: string, organizationIds: string[]) => {
-    await CachedBalance.updateForOrganizations(organizationId, organizationIds);
+    const results = await CachedBalance.updateForOrganizations(organizationId, organizationIds);
 
     for (const payingOrganizationId of organizationIds) {
         await PaymentReallocationService.reallocate(organizationId, payingOrganizationId, ReceivableBalanceType.organization);
     }
+
+    const platform = await Platform.getShared();
+    if (organizationId === platform.membershipOrganizationId) {
+        // Clear failed payments
+        for (const [organizationId, result] of results) {
+            if (result.amountOpen === 0 && result.amountPending === 0) {
+                await STPackageService.markBalanceRestored(organizationId);
+            }
+        }
+    }
 }, { maxDelay: 60_000 });
 
 export const registrationUpdateQueue = new GroupedThrottledQueue(async (organizationId: string, registrationIds: string[]) => {
@@ -50,10 +62,10 @@ const bundleDiscountsUpdateQueue = new ThrottledQueue(async (registrationIds: st
     }
 }, { maxDelay: 10_000 });
 
-export const BalanceItemService = {
-    listening: false,
+export class BalanceItemService {
+    static listening = false;
 
-    listen() {
+    static listen() {
         if (this.listening) {
             return;
         }
@@ -64,7 +76,7 @@ export const BalanceItemService = {
             }
 
             if (event.type === 'created' || event.type === 'deleted') {
-                await this.scheduleUpdate(event.model);
+                this.scheduleUpdate(event.model);
                 return;
             }
 
@@ -79,10 +91,10 @@ export const BalanceItemService = {
                 || 'payingOrganizationId' in event.changedFields
                 || 'registrationId' in event.changedFields
             ) {
-                await this.scheduleUpdate(event.model);
+                this.scheduleUpdate(event.model);
             }
         });
-    },
+    }
 
     /**
      * Schedule an update for the balance item:
@@ -90,8 +102,8 @@ export const BalanceItemService = {
      *
      * Does not execute the update immediately, but schedules it to be run in the background.
      */
-    async scheduleUpdate(item: BalanceItem) {
-        await this.scheduleUpdates([item]);
+    static scheduleUpdate(item: BalanceItem) {
+        this.scheduleUpdates([item]);
 
         // Todo: optimize
         if (item.type === BalanceItemType.RegistrationBundleDiscount) {
@@ -100,49 +112,58 @@ export const BalanceItemService = {
                 bundleDiscountsUpdateQueue.addItem(item.registrationId);
             }
         }
-    },
+    }
 
     /**
      * Call this when a payment or payment balance items have changed.
      * It will also call updateOutstanding automatically, so no need to call that separately again
      */
-    async updatePaidAndPending(items: BalanceItem[]) {
+    static async updatePaidAndPending(items: BalanceItem[]) {
         console.log('updatePaidAndPending for', items.length, 'items');
-        await BalanceItem.updatePricePaid(items.map(i => i.id));
-        await this.scheduleUpdates(items);
-    },
+        await BalanceItem.updatePricePaid(Formatter.uniqueArray(items.map(i => i.id)));
+        this.scheduleUpdates(items);
+    }
+
+    /**
+     * Call this when a payment or payment balance items have changed.
+     * It will also call updateOutstanding automatically, so no need to call that separately again
+     */
+    static async updateInvoiced(items: (BalanceItem | string)[]) {
+        console.log('updateInvoiced for', items.length, 'items');
+        await BalanceItem.updateInvoiced(Formatter.uniqueArray(items.map(i => typeof i === 'string' ? i : i.id)));
+    }
 
     /**
      * In some situations we need immediate updates
      */
-    async flushRegistrationDiscountsCache() {
+    static async flushRegistrationDiscountsCache() {
         await bundleDiscountsUpdateQueue.flushAndWait();
-    },
+    }
 
     /**
      * Make sure all the pending changes for cached balances are run
      */
-    async flushCaches(organizationId: string) {
+    static async flushCaches(organizationId: string) {
         await memberUpdateQueue.flushGroupAndWait(organizationId);
         await userUpdateQueue.flushGroupAndWait(organizationId);
         await organizationUpdateQueue.flushGroupAndWait(organizationId);
         await registrationUpdateQueue.flushGroupAndWait(organizationId);
         await bundleDiscountsUpdateQueue.flushAndWait();
-    },
+    }
 
-    async flushAll() {
+    static async flushAll() {
         await memberUpdateQueue.flushAndWait();
         await userUpdateQueue.flushAndWait();
         await organizationUpdateQueue.flushAndWait();
         await registrationUpdateQueue.flushAndWait();
         await bundleDiscountsUpdateQueue.flushAndWait();
-    },
+    }
 
     /**
      * Update how many every object in the system owes or needs to be reimbursed
      * and also updates the pricePaid/pricePending cached values in Balance items and members
      */
-    async scheduleUpdates(items: BalanceItem[]) {
+    static scheduleUpdates(items: BalanceItem[]) {
         console.log('Schedule outstanding balance for', items.length, 'items');
 
         for (const item of items) {
@@ -162,21 +183,21 @@ export const BalanceItemService = {
                 registrationUpdateQueue.addItem(item.organizationId, item.registrationId);
             }
         }
-    },
+    }
 
-    scheduleUserUpdate(organizationId: string, userId: string) {
+    static scheduleUserUpdate(organizationId: string, userId: string) {
         userUpdateQueue.addItem(organizationId, userId);
-    },
+    }
 
-    scheduleMemberUpdate(organizationId: string, memberId: string) {
+    static cheduleMemberUpdate(organizationId: string, memberId: string) {
         memberUpdateQueue.addItem(organizationId, memberId);
-    },
+    }
 
-    scheduleOrganizationUpdate(organizationId: string, payingOrganizationId: string) {
+    static scheduleOrganizationUpdate(organizationId: string, payingOrganizationId: string) {
         organizationUpdateQueue.addItem(organizationId, payingOrganizationId);
-    },
+    }
 
-    async markDue(balanceItem: BalanceItem) {
+    static async markDue(balanceItem: BalanceItem) {
         if (balanceItem.status === BalanceItemStatus.Hidden) {
             balanceItem.status = BalanceItemStatus.Due;
             await balanceItem.save();
@@ -190,9 +211,21 @@ export const BalanceItemService = {
                 await balanceItem.save();
             }
         }
-    },
+    }
+
+    static async markPaid(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
+        if (payment && payment.type === PaymentType.Chargeback) {
+            const realPayment = payment.reversingPaymentId ? (await Payment.getByID(payment.reversingPaymentId) ?? null) : null;
+            await this.handleChargeback(balanceItem, payment, realPayment, organization);
+            return;
+        }
+
+        if (payment && payment.price !== 0 && payment.refundedAmount === payment.price) {
+            // Charged back, already handled
+            // First cancel the chargeback if the payment should resucceed again
+            return;
+        }
 
-    async markPaid(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
         await this.markDue(balanceItem);
         let shouldMarkUpdated = true;
 
@@ -250,9 +283,9 @@ export const BalanceItemService = {
 
         balanceItem.paidAt = new Date();
         await balanceItem.save();
-    },
+    }
 
-    async markUpdated(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
+    static async markUpdated(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
         // For orders: mark order as changed (so they are refetched in front ends)
         if (balanceItem.orderId) {
             await AuditLogService.setContext({ source: AuditLogSource.Payment }, async () => {
@@ -264,9 +297,9 @@ export const BalanceItemService = {
                 }
             });
         }
-    },
+    }
 
-    async undoPaid(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
+    static async undoPaid(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
         // If order
         if (balanceItem.orderId) {
             const order = await Order.getByID(balanceItem.orderId);
@@ -275,16 +308,24 @@ export const BalanceItemService = {
                 await order.undoPaid(payment, organization);
             }
         }
+    }
 
-        // If a rounded payment was canceled, make sure the balance item is hidden again (will become visible again when marking paid)
-        if (this.type === BalanceItemType.Rounding && balanceItem.status !== BalanceItemStatus.Hidden) {
-            // Mark undue
-            balanceItem.status = BalanceItemStatus.Hidden;
-            await balanceItem.save();
+    /**
+     *
+     */
+    static async handleChargeback(balanceItem: BalanceItem, chargeback: Payment | null, payment: Payment | null, organization: Organization) {
+        if (balanceItem.failedAt) {
+            // Already ran side effects
+            return;
         }
-    },
 
-    async markFailed(balanceItem: BalanceItem, payment: Payment, organization: Organization) {
+        // todo
+
+        balanceItem.failedAt = new Date();
+        await balanceItem.save();
+    }
+
+    static async markFailed(balanceItem: BalanceItem, payment: Payment, organization: Organization) {
         // If order
         if (balanceItem.orderId) {
             const order = await Order.getByID(balanceItem.orderId);
@@ -297,16 +338,10 @@ export const BalanceItemService = {
                 }
             }
         }
+        await this.handleChargeback(balanceItem, null, payment, organization);
+    }
 
-        // If a rounded payment was canceled, make sure the balance item is hidden again (will become visible again when marking paid)
-        if (this.type === BalanceItemType.Rounding && balanceItem.status !== BalanceItemStatus.Hidden) {
-            // Mark undue
-            balanceItem.status = BalanceItemStatus.Hidden;
-            await balanceItem.save();
-        }
-    },
-
-    async undoFailed(balanceItem: BalanceItem, payment: Payment, organization: Organization) {
+    static async undoFailed(balanceItem: BalanceItem, payment: Payment, organization: Organization) {
         // If order
         if (balanceItem.orderId) {
             const order = await Order.getByID(balanceItem.orderId);
@@ -314,5 +349,63 @@ export const BalanceItemService = {
                 await order.undoPaymentFailed(payment, organization);
             }
         }
-    },
+    }
+
+    /**
+     * Apply discounts to the balance a user is going to checkout
+     */
+    static async applyDiscountsToCheckout({ minimumAmount, totalPrice, balanceItems, sellingOrganizationId, payingOrganizationId, payingUserId }: {
+        balanceItems: Map<BalanceItem, number>;
+        totalPrice: number;
+        minimumAmount?: number;
+        sellingOrganizationId: string;
+        payingOrganizationId?: string | null | undefined;
+        payingUserId?: string | null | undefined;
+    }) {
+        if (totalPrice <= (minimumAmount ?? 0)) {
+            return {
+                totalPrice,
+            };
+        }
+
+        let items: BalanceItem[];
+        if (payingOrganizationId) {
+            items = await BalanceItem.select()
+                .where('organizationId', sellingOrganizationId)
+                .where('payingOrganizationId', payingOrganizationId)
+                .whereNot('status', BalanceItemStatus.Hidden)
+                .where('priceOpen', '<', 0)
+                .fetch();
+        } else if (payingUserId) {
+            const memberUsers = await MemberUser.select().where('usersId', payingUserId).fetch();
+            const memberIds = Formatter.uniqueArray(memberUsers.map(mu => mu.membersId));
+
+            items = await BalanceItem.select()
+                .where('organizationId', sellingOrganizationId)
+                .where(
+                    SQL.where('userId', payingUserId)
+                        .or('memberId', memberIds),
+                )
+                .whereNot('status', BalanceItemStatus.Hidden)
+                .where('priceOpen', '<', 0)
+                .fetch();
+        } else {
+            return {
+                totalPrice,
+            };
+        }
+
+        for (const item of items) {
+            const remove = Math.min(totalPrice - (minimumAmount ?? 0), -item.priceOpen);
+            if (remove === 0) {
+                break;
+            }
+            balanceItems.set(item, -remove);
+            totalPrice -= remove;
+        }
+
+        return {
+            totalPrice,
+        };
+    }
 };

package/src/services/CpuService.ts

@@ -56,8 +56,7 @@ class StaticCpuService {
         }
         if (size === this.maxSamples) {
             return this.samples.reduce((a, b) => a + b, 0) / size;
-        }
-        else {
+        } else {
             // To read before current index
             const toReadBeforeIndex = Math.min(size, this.currentIndex);
             const toReadFromEnd = size - toReadBeforeIndex;
@@ -89,13 +88,11 @@ class StaticCpuService {
         if (five > 80) {
             // Danger zone, in this case we don't want to log all slow queries any longer because the information won't be trustworthy.
             SQLLogger.slowQueryThresholdMs = null;
-        }
-        else {
+        } else {
             if (five < 20) {
                 // No load, safe to log all slow queries
                 SQLLogger.slowQueryThresholdMs = 300;
-            }
-            else {
+            } else {
                 SQLLogger.slowQueryThresholdMs = 500;
             }
         }

package/src/services/DatabaseCollationService.test.ts

@@ -10,8 +10,7 @@ describe('DatabaseCollationService', () => {
             expect(error).toContain('MySQL collation mismatch');
             expect(error).toContain('expected utf8mb4_0900_ai_ci');
             expect(error).toContain('collation_connection=utf8mb4_general_ci');
-        }
-        finally {
+        } finally {
             await Database.statement('SET collation_connection = DEFAULT');
         }
     });

package/src/services/DocumentService.ts

@@ -33,8 +33,7 @@ export class DocumentService {
                     // If a group is changed - update the documents for it
                     await Document.updateForGroup(event.model.id, event.model.organizationId);
                 }
-            }
-            catch (e) {
+            } catch (e) {
                 console.error('Failed to update documents after group change', e);
             }
         });

package/src/services/EventNotificationService.ts

@@ -1,6 +1,6 @@
 import { SimpleError } from '@simonbackx/simple-errors';
 import { EventNotification, Member, MemberResponsibilityRecord, Organization, Platform, sendEmailTemplate, User } from '@stamhoofd/models';
-import type { EmailTemplateType} from '@stamhoofd/structures';
+import type { EmailTemplateType } from '@stamhoofd/structures';
 import { PermissionLevel, Recipient, RecordCategory, Replacement } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { AdminPermissionChecker } from '../helpers/AdminPermissionChecker.js';