@stamhoofd/backend 2.58.0 → 2.60.0

package/src/helpers/TagHelper.ts

@@ -1,38 +1,41 @@
 import { Organization, Platform } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
-import { OrganizationTag, TagHelper as SharedTagHelper } from '@stamhoofd/structures';
+import { AuditLogSource, OrganizationTag, TagHelper as SharedTagHelper } from '@stamhoofd/structures';
 import { ModelHelper } from './ModelHelper';
+import { AuditLogService } from '../services/AuditLogService';
 
 export class TagHelper extends SharedTagHelper {
     static async updateOrganizations() {
         const queueId = 'update-tags-on-organizations';
         QueueHandler.cancel(queueId);
 
-        await QueueHandler.schedule(queueId, async () => {
-            let platform = await Platform.getShared();
+        await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
+            await QueueHandler.schedule(queueId, async () => {
+                let platform = await Platform.getShared();
 
-            const tagCounts = new Map<string, number>();
-            await this.loopOrganizations(async (organizations) => {
-                for (const organization of organizations) {
-                    organization.meta.tags = this.getAllTagsFromHierarchy(organization.meta.tags, platform.config.tags);
+                const tagCounts = new Map<string, number>();
+                await this.loopOrganizations(async (organizations) => {
+                    for (const organization of organizations) {
+                        organization.meta.tags = this.getAllTagsFromHierarchy(organization.meta.tags, platform.config.tags);
 
-                    for (const tag of organization.meta.tags) {
-                        tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+                        for (const tag of organization.meta.tags) {
+                            tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+                        }
                     }
-                }
 
-                await Promise.all(organizations.map(organization => organization.save()));
-            });
+                    await Promise.all(organizations.map(organization => organization.save()));
+                });
 
-            // Reload platform to avoid race conditions
-            platform = await Platform.getShared();
-            for (const [tag, count] of tagCounts.entries()) {
-                const tagObject = platform.config.tags.find(t => t.id === tag);
-                if (tagObject) {
-                    tagObject.organizationCount = count;
+                // Reload platform to avoid race conditions
+                platform = await Platform.getShared();
+                for (const [tag, count] of tagCounts.entries()) {
+                    const tagObject = platform.config.tags.find(t => t.id === tag);
+                    if (tagObject) {
+                        tagObject.organizationCount = count;
+                    }
                 }
-            }
-            await platform.save();
+                await platform.save();
+            });
         });
     }
 

package/src/seeds/1722344162-update-membership.ts

@@ -1,5 +1,5 @@
 import { Migration } from '@simonbackx/simple-database';
-import { MembershipHelper } from '../helpers/MembershipHelper';
+import { PlatformMembershipService } from '../services/PlatformMembershipService';
 
 export default new Migration(async () => {
     if (STAMHOOFD.environment == 'test') {
@@ -13,5 +13,5 @@ export default new Migration(async () => {
     }
 
     process.stdout.write('\n');
-    await MembershipHelper.updateAll();
+    await PlatformMembershipService.updateAll();
 });

package/src/seeds/1726572303-schedule-stock-updates.ts

@@ -1,5 +1,6 @@
 import { Migration } from '@simonbackx/simple-database';
 import { Registration } from '@stamhoofd/models';
+import { RegistrationService } from '../services/RegistrationService';
 
 export default new Migration(async () => {
     if (STAMHOOFD.environment == 'test') {
@@ -27,7 +28,7 @@ export default new Migration(async () => {
         const registrations = await Registration.getByIDs(...rawRegistrations.map(g => g.id));
 
         for (const registration of registrations) {
-            registration.scheduleStockUpdate();
+            RegistrationService.scheduleStockUpdate(registration.id);
 
             c++;
 

package/src/seeds/1726847064-setup-steps.ts

@@ -1,5 +1,5 @@
 import { Migration } from '@simonbackx/simple-database';
-import { SetupStepUpdater } from '@stamhoofd/models';
+import { SetupStepUpdater } from '../helpers/SetupStepUpdater';
 
 export default new Migration(async () => {
     if (STAMHOOFD.environment == 'test') {

package/src/seeds/1733319079-fill-paying-organization-ids.ts

@@ -0,0 +1,68 @@
+import { Migration } from '@simonbackx/simple-database';
+import { logger } from '@simonbackx/simple-logging';
+import { BalanceItem, Registration } from '@stamhoofd/models';
+import { Formatter } from '@stamhoofd/utility';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment == 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    process.stdout.write('\n');
+    let c = 0;
+    let id: string = '';
+
+    await logger.setContext({ tags: ['seed'] }, async () => {
+        while (true) {
+            const items = await BalanceItem.where({
+                id: {
+                    value: id,
+                    sign: '>',
+                },
+                registrationId: {
+                    value: null,
+                    sign: '!=',
+                },
+                payingOrganizationId: {
+                    value: null,
+                    sign: '!=',
+                },
+            }, { limit: 1000, sort: ['id'] });
+
+            if (items.length === 0) {
+                break;
+            }
+
+            process.stdout.write('.');
+
+            const registrationIds = Formatter.uniqueArray(items.map(i => i.registrationId!));
+            const registrations = await Registration.getByIDs(...registrationIds);
+
+            for (const item of items) {
+                if (!item.registrationId || !item.payingOrganizationId) {
+                    continue;
+                }
+                const registration = registrations.find(r => r.id === item.registrationId);
+                if (!registration) {
+                    continue;
+                }
+
+                registration.payingOrganizationId = item.payingOrganizationId;
+                if (await registration.save()) {
+                    c++;
+                }
+            }
+
+            if (items.length < 1000) {
+                break;
+            }
+            id = items[items.length - 1].id;
+        }
+    });
+
+    console.log('Updated ' + c + ' registrations');
+
+    // Do something here
+    return Promise.resolve();
+});

package/src/services/AuditLogService.ts

@@ -1,317 +1,102 @@
-import { AutoEncoder, AutoEncoderPatchType } from '@simonbackx/simple-encoding';
-import { AuditLog, Group, Member, Organization, Registration, Event, RegistrationPeriod, StripeAccount } from '@stamhoofd/models';
-import { AuditLogReplacement, AuditLogReplacementType, AuditLogType, GroupType, MemberDetails, OrganizationMetaData, OrganizationPrivateMetaData, PlatformConfig, PlatformPrivateConfig } from '@stamhoofd/structures';
-import { Context } from '../helpers/Context';
-import { explainPatch } from './explainPatch';
+import { Model, ModelEvent } from '@simonbackx/simple-database';
+import { AuditLogSource } from '@stamhoofd/structures';
 import { AsyncLocalStorage } from 'node:async_hooks';
-
-export type MemberAddedAuditOptions = {
-    type: AuditLogType.MemberAdded;
-    member: Member;
-};
-
-export type MemberEditedAuditOptions = {
-    type: AuditLogType.MemberEdited;
-    member: Member;
-    oldMemberDetails: MemberDetails;
-    memberDetailsPatch: AutoEncoderPatchType<MemberDetails>;
-};
-
-export type MemberRegisteredAuditOptions = {
-    type: AuditLogType.MemberRegistered | AuditLogType.MemberUnregistered;
-    member: Member;
-    group: Group;
-    registration: Registration;
+import { DocumentTemplateLogger } from '../audit-logs/DocumentTemplateLogger';
+import { EventLogger } from '../audit-logs/EventLogger';
+import { GroupLogger } from '../audit-logs/GroupLogger';
+import { MemberLogger } from '../audit-logs/MemberLogger';
+import { MemberPlatformMembershipLogger } from '../audit-logs/MemberPlatformMembershipLogger';
+import { MemberResponsibilityRecordLogger } from '../audit-logs/MemberResponsibilityRecordLogger';
+import { OrderLogger } from '../audit-logs/OrderLogger';
+import { OrganizationLogger } from '../audit-logs/OrganizationLogger';
+import { OrganizationRegistrationPeriodLogger } from '../audit-logs/OrganizationRegistrationPeriodLogger';
+import { PaymentLogger } from '../audit-logs/PaymentLogger';
+import { PlatformLogger } from '../audit-logs/PlatformLogger';
+import { RegistrationLogger } from '../audit-logs/RegistrationLogger';
+import { RegistrationPeriodLogger } from '../audit-logs/RegistrationPeriodLogger';
+import { StripeAccountLogger } from '../audit-logs/StripeAccountLogger';
+import { WebshopLogger } from '../audit-logs/WebshopLogger';
+
+export type AuditLogContextSettings = {
+    disable?: boolean;
+    source?: AuditLogSource;
+    userId?: string | null;
+
+    // If no userId is known, fallback to this userId
+    // this is useful e.g. for side effects of webhooks where the webhook calls but we don't have the userid in the request, still the action is tied to a user
+    fallbackUserId?: string | null;
+    fallbackOrganizationId?: string | null;
 };
 
-export type PlatformConfigChangeAuditOptions = {
-    type: AuditLogType.PlatformSettingsChanged;
-    oldData?: AutoEncoder;
-    patch?: AutoEncoder | AutoEncoderPatchType<AutoEncoder>;
-};
+export class AuditLogService {
+    private constructor() { }
+    static disableLocalStore = new AsyncLocalStorage<AuditLogContextSettings>();
 
-export type OrganizationConfigChangeAuditOptions = {
-    type: AuditLogType.OrganizationSettingsChanged;
-    organization: Organization;
-    oldData?: AutoEncoder;
-    patch?: AutoEncoder | AutoEncoderPatchType<AutoEncoder>;
-};
+    static disable<T>(run: () => T): T {
+        return this.setContext({ disable: true }, run);
+    }
 
-export type EventAuditOptions = {
-    type: AuditLogType.EventAdded | AuditLogType.EventEdited | AuditLogType.EventDeleted;
-    event: Event;
-    oldData?: AutoEncoder;
-    patch?: AutoEncoder | AutoEncoderPatchType<AutoEncoder>;
-};
-
-export type GroupAuditOptions = {
-    type: AuditLogType.GroupAdded | AuditLogType.GroupEdited | AuditLogType.GroupDeleted;
-    group: Group;
-    oldData?: AutoEncoder;
-    patch?: AutoEncoder | AutoEncoderPatchType<AutoEncoder>;
-};
-
-export type PeriodAuditOptions = {
-    type: AuditLogType.RegistrationPeriodAdded | AuditLogType.RegistrationPeriodEdited | AuditLogType.RegistrationPeriodDeleted;
-    period: RegistrationPeriod;
-    oldData?: AutoEncoder;
-    patch?: AutoEncoder | AutoEncoderPatchType<AutoEncoder>;
-};
-
-export type StripeAccountAuditOptions = {
-    type: AuditLogType.StripeAccountAdded | AuditLogType.StripeAccountEdited | AuditLogType.StripeAccountDeleted;
-    stripeAccount: StripeAccount;
-    oldData?: AutoEncoder;
-    patch?: AutoEncoder | AutoEncoderPatchType<AutoEncoder>;
-};
-
-export type AuditLogOptions = StripeAccountAuditOptions | PeriodAuditOptions | GroupAuditOptions | EventAuditOptions | MemberAddedAuditOptions | MemberEditedAuditOptions | MemberRegisteredAuditOptions | PlatformConfigChangeAuditOptions | OrganizationConfigChangeAuditOptions;
-
-export const AuditLogService = {
-    disableLocalStore: new AsyncLocalStorage<boolean>(),
-
-    disable<T extends Promise<void> | void>(run: () => T): T {
-        return this.disableLocalStore.run(true, () => {
+    static setContext<T>(context: AuditLogContextSettings, run: () => T): T {
+        const currentContext = this.getContext() ?? {};
+        return this.disableLocalStore.run({ ...currentContext, ...context }, () => {
             return run();
         });
-    },
-
-    isDisabled(): boolean {
-        const c = this.disableLocalStore.getStore();
-
-        if (!c) {
-            return false;
-        }
-
-        return true;
-    },
-
-    async log(options: AuditLogOptions) {
-        try {
-            if (this.isDisabled()) {
-                return;
-            }
-            const userId = Context.optionalAuth?.user?.id ?? null;
-            const organizationId = Context.organization?.id ?? null;
-
-            const model = new AuditLog();
-
-            model.type = options.type;
-            model.userId = userId;
-            model.organizationId = organizationId;
-
-            if (options.type === AuditLogType.MemberRegistered) {
-                this.fillForMemberRegistered(model, options);
-            }
-            else if (options.type === AuditLogType.MemberUnregistered) {
-                this.fillForMemberRegistered(model, options);
-            }
-            else if (options.type === AuditLogType.MemberEdited) {
-                this.fillForMemberEdited(model, options);
-            }
-            else if (options.type === AuditLogType.MemberAdded) {
-                this.fillForMemberAdded(model, options);
-            }
-            else if (options.type === AuditLogType.PlatformSettingsChanged) {
-                this.fillForPlatformConfig(model, options);
-            }
-            else if (options.type === AuditLogType.OrganizationSettingsChanged) {
-                this.fillForOrganizationConfig(model, options);
-            }
-            else if (options.type === AuditLogType.EventAdded || options.type === AuditLogType.EventEdited || options.type === AuditLogType.EventDeleted) {
-                this.fillForEvent(model, options);
-            }
-            else if (options.type === AuditLogType.GroupAdded || options.type === AuditLogType.GroupEdited || options.type === AuditLogType.GroupDeleted) {
-                this.fillForGroup(model, options);
-            }
-            else if (options.type === AuditLogType.RegistrationPeriodAdded || options.type === AuditLogType.RegistrationPeriodEdited || options.type === AuditLogType.RegistrationPeriodDeleted) {
-                this.fillForPeriod(model, options);
-            }
-            else if (options.type === AuditLogType.StripeAccountAdded || options.type === AuditLogType.StripeAccountEdited || options.type === AuditLogType.StripeAccountDeleted) {
-                if (this.fillForStripeAccount(model, options) === false) {
-                    // do not save
-                    return;
-                }
-            }
-
-            // In the future we might group these saves together in one query to improve performance
-            await model.save();
-        }
-        catch (e) {
-            console.error('Failed to save log', options, e);
-        }
-    },
+    }
 
-    fillForMemberRegistered(model: AuditLog, options: MemberRegisteredAuditOptions) {
-        model.objectId = options.member.id;
-        model.replacements = new Map([
-            ['m', AuditLogReplacement.create({
-                id: options.member.id,
-                value: options.member.details.name,
-                type: AuditLogReplacementType.Member,
-            })],
-            ['g', AuditLogReplacement.create({
-                id: options.group.id,
-                value: options.group.settings.name,
-                type: AuditLogReplacementType.Group,
-            })],
-        ]);
+    static isDisabled(): boolean {
+        const c = this.getContext();
 
-        const registrationStructure = options.registration.setRelation(Registration.group, options.group).getStructure();
-        if (registrationStructure.description) {
-            model.description = registrationStructure.description;
+        if (c && c.disable === true) {
+            return true;
         }
-    },
-
-    fillForMemberEdited(model: AuditLog, options: MemberEditedAuditOptions) {
-        model.objectId = options.member.id;
-
-        model.replacements = new Map([
-            ['m', AuditLogReplacement.create({
-                id: options.member.id,
-                value: options.member.details.name,
-                type: AuditLogReplacementType.Member,
-            })],
-        ]);
-
-        // Generate changes list
-        model.patchList = explainPatch(options.oldMemberDetails, options.memberDetailsPatch);
-    },
-
-    fillForMemberAdded(model: AuditLog, options: MemberAddedAuditOptions) {
-        model.objectId = options.member.id;
-
-        model.replacements = new Map([
-            ['m', AuditLogReplacement.create({
-                id: options.member.id,
-                value: options.member.details.name,
-                type: AuditLogReplacementType.Member,
-            })],
-        ]);
 
-        // Generate changes list
-        model.patchList = explainPatch(null, options.member.details);
-    },
+        return false;
+    }
 
-    fillForPlatformConfig(model: AuditLog, options: PlatformConfigChangeAuditOptions) {
-        model.objectId = null;
-
-        // Generate changes list
-        if (options.patch) {
-            // Generate changes list
-            model.patchList = explainPatch(options.oldData ?? null, options.patch);
-        }
-    },
-
-    fillForOrganizationConfig(model: AuditLog, options: OrganizationConfigChangeAuditOptions) {
-        model.objectId = options.organization.id;
-        model.organizationId = options.organization.id;
-
-        model.replacements = new Map([
-            ['o', AuditLogReplacement.create({
-                id: options.organization.id,
-                value: options.organization.name,
-                type: AuditLogReplacementType.Organization,
-            })],
-        ]);
-
-        // Generate changes list
-        if (options.patch) {
-            // Generate changes list
-            model.patchList = explainPatch(options.oldData ?? null, options.patch);
-        }
-    },
-
-    fillForEvent(model: AuditLog, options: EventAuditOptions) {
-        model.objectId = options.event.id;
-
-        if (options.patch) {
-            // Generate changes list
-            model.patchList = explainPatch(options.oldData ?? null, options.patch);
-        }
-
-        model.replacements = new Map([
-            ['e', AuditLogReplacement.create({
-                id: options.event.id,
-                value: options.event.name,
-                type: AuditLogReplacementType.Event,
-            })],
-        ]);
-    },
+    static getContext(): AuditLogContextSettings | null {
+        const c = this.disableLocalStore.getStore();
+        return c ?? null;
+    }
 
-    fillForGroup(model: AuditLog, options: GroupAuditOptions) {
-        model.objectId = options.group.id;
+    static listening = false;
 
-        if (options.patch) {
-            // Generate changes list
-            model.patchList = explainPatch(options.oldData ?? null, options.patch);
+    static listen() {
+        if (this.listening) {
+            return;
         }
+        this.listening = true;
+        Model.modelEventBus.addListener(this, async (event) => {
+            const modelType = event.model.static as typeof Model;
+            const definition = modelLogDefinitions.get(modelType);
 
-        if (options.group.type === GroupType.WaitingList) {
-            // Change event type
-            switch (options.type) {
-                case AuditLogType.GroupAdded:
-                    model.type = AuditLogType.WaitingListAdded;
-                    break;
-                case AuditLogType.GroupEdited:
-                    model.type = AuditLogType.WaitingListEdited;
-                    break;
-                case AuditLogType.GroupDeleted:
-                    model.type = AuditLogType.WaitingListDeleted;
-                    break;
+            if (!definition) {
+                return;
             }
-        }
-
-        model.replacements = new Map([
-            ['g', AuditLogReplacement.create({
-                id: options.group.id,
-                value: options.group.settings.name,
-                type: AuditLogReplacementType.Group,
-            })],
-        ]);
-    },
-
-    fillForPeriod(model: AuditLog, options: PeriodAuditOptions) {
-        model.objectId = options.period.id;
-
-        if (options.patch) {
-            // Generate changes list
-            model.patchList = explainPatch(options.oldData ?? null, options.patch);
-        }
-
-        model.replacements = new Map([
-            ['p', AuditLogReplacement.create({
-                id: options.period.id,
-                value: options.period.getStructure().nameShort,
-                type: AuditLogReplacementType.RegistrationPeriod,
-            })],
-        ]);
-    },
 
-    fillForStripeAccount(model: AuditLog, options: StripeAccountAuditOptions) {
-        model.objectId = options.stripeAccount.id;
-
-        if (options.patch) {
-            // Generate changes list
-            model.patchList = explainPatch(options.oldData ?? null, options.patch);
-
-            if (model.patchList.length === 0) {
-                // No changes, ignore (only for stripe)
-                return false;
+            if (this.isDisabled()) {
+                console.log('Audit log disabled');
+                return;
             }
-        }
 
-        if (options.type === AuditLogType.StripeAccountEdited) {
-            // Never caused by a user
-            model.userId = null;
-        }
-
-        model.replacements = new Map([
-            ['a', AuditLogReplacement.create({
-                id: options.stripeAccount.id,
-                value: options.stripeAccount.accountId,
-                type: AuditLogReplacementType.StripeAccount,
-            })],
-        ]);
-    },
+            await definition.logEvent(event);
+        });
+    }
 };
+
+const modelLogDefinitions = new Map<typeof Model, { logEvent: (event: ModelEvent) => Promise<any> }>();
+
+modelLogDefinitions.set(RegistrationLogger.model, RegistrationLogger);
+modelLogDefinitions.set(GroupLogger.model, GroupLogger);
+modelLogDefinitions.set(OrganizationLogger.model, OrganizationLogger);
+modelLogDefinitions.set(PlatformLogger.model, PlatformLogger);
+modelLogDefinitions.set(EventLogger.model, EventLogger);
+modelLogDefinitions.set(RegistrationPeriodLogger.model, RegistrationPeriodLogger);
+modelLogDefinitions.set(OrganizationRegistrationPeriodLogger.model, OrganizationRegistrationPeriodLogger);
+modelLogDefinitions.set(StripeAccountLogger.model, StripeAccountLogger);
+modelLogDefinitions.set(MemberLogger.model, MemberLogger);
+modelLogDefinitions.set(WebshopLogger.model, WebshopLogger);
+modelLogDefinitions.set(OrderLogger.model, OrderLogger);
+modelLogDefinitions.set(PaymentLogger.model, PaymentLogger);
+modelLogDefinitions.set(MemberPlatformMembershipLogger.model, MemberPlatformMembershipLogger);
+modelLogDefinitions.set(MemberResponsibilityRecordLogger.model, MemberResponsibilityRecordLogger);
+modelLogDefinitions.set(DocumentTemplateLogger.model, DocumentTemplateLogger);

package/src/services/BalanceItemPaymentService.ts

@@ -16,7 +16,7 @@ export const BalanceItemPaymentService = {
         await balanceItemPayment.balanceItem.save();
 
         // Do logic of balance item
-        if (balanceItemPayment.balanceItem.status === BalanceItemStatus.Paid && old !== BalanceItemStatus.Paid) {
+        if (balanceItemPayment.balanceItem.status === BalanceItemStatus.Paid && old !== BalanceItemStatus.Paid && balanceItemPayment.price >= 0) {
             // Only call markPaid once (if it wasn't (partially) paid before)
             await BalanceItemService.markPaid(balanceItemPayment.balanceItem, balanceItemPayment.payment, organization);
         }

package/src/services/BalanceItemService.ts

@@ -1,6 +1,7 @@
 import { BalanceItem, Order, Organization, Payment, Webshop } from '@stamhoofd/models';
-import { BalanceItemStatus, OrderStatus } from '@stamhoofd/structures';
+import { AuditLogSource, BalanceItemStatus, OrderStatus } from '@stamhoofd/structures';
 import { RegistrationService } from './RegistrationService';
+import { AuditLogService } from './AuditLogService';
 
 export const BalanceItemService = {
     async markPaid(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
@@ -16,6 +17,10 @@ export const BalanceItemService = {
             }
         }
 
+        // It is possible this balance item was earlier paid
+        // and later the regigstration / order has been canceled and it became a negative balance item - which as some point has been reembursed and marked as 'paid'
+        // in that case, we should be careful not to mark the registration as valid again
+
         // If registration
         if (balanceItem.registrationId) {
             await RegistrationService.markValid(balanceItem.registrationId);
@@ -43,10 +48,14 @@ export const BalanceItemService = {
     async markUpdated(balanceItem: BalanceItem, payment: Payment, organization: Organization) {
         // For orders: mark order as changed (so they are refetched in front ends)
         if (balanceItem.orderId) {
-            const order = await Order.getByID(balanceItem.orderId);
-            if (order) {
-                await order.paymentChanged(payment, organization);
-            }
+            await AuditLogService.setContext({ source: AuditLogSource.Payment }, async () => {
+                if (balanceItem.orderId) {
+                    const order = await Order.getByID(balanceItem.orderId);
+                    if (order) {
+                        await order.paymentChanged(payment, organization);
+                    }
+                }
+            });
         }
     },
 

package/src/services/DocumentService.ts

@@ -0,0 +1,43 @@
+import { Model } from '@simonbackx/simple-database';
+import { PlainObject } from '@simonbackx/simple-encoding';
+import { Document, Group } from '@stamhoofd/models';
+
+function getGroupFieldsAffectingDocuments(group: Group): PlainObject {
+    return {
+        type: group.type,
+        startDate: group.settings.startDate.getTime(),
+        endDate: group.settings.endDate.getTime(),
+        name: group.settings.name,
+    };
+}
+
+export class DocumentService {
+    static listening = false;
+
+    static listen() {
+        if (this.listening) {
+            return;
+        }
+        this.listening = true;
+        Model.modelEventBus.addListener(this, async (event) => {
+            try {
+                if (event.model instanceof Group && event.type === 'updated' && event.changedFields.settings && !event.model.deletedAt) {
+                    const oldModel = event.getOldModel() as Group;
+                    const oldFields = getGroupFieldsAffectingDocuments(oldModel);
+                    const newFields = getGroupFieldsAffectingDocuments(event.model);
+
+                    if (JSON.stringify(oldFields) === JSON.stringify(newFields)) {
+                        console.log('Group changes cannot affect documents');
+                        return;
+                    }
+
+                    // If a group is changed - update the documents for it
+                    await Document.updateForGroup(event.model.id, event.model.organizationId);
+                }
+            }
+            catch (e) {
+                console.error('Failed to update documents after group change', e);
+            }
+        });
+    }
+};