@stamhoofd/backend 2.57.1 → 2.59.0

package/index.ts

@@ -1,7 +1,7 @@
 import backendEnv from '@stamhoofd/backend-env';
 backendEnv.load();
 
-import { Column, Database, Migration } from '@simonbackx/simple-database';
+import { Column, Database, Migration, Model } from '@simonbackx/simple-database';
 import { CORSPreflightEndpoint, Router, RouterServer } from '@simonbackx/simple-endpoints';
 import { I18n } from '@stamhoofd/backend-i18n';
 import { CORSMiddleware, LogMiddleware, VersionMiddleware } from '@stamhoofd/backend-middleware';
@@ -14,6 +14,8 @@ import { stopCrons, startCrons, waitForCrons } from '@stamhoofd/crons';
 import { resumeEmails } from './src/helpers/EmailResumer';
 import { ContextMiddleware } from './src/middleware/ContextMiddleware';
 import { Platform } from '@stamhoofd/models';
+import { AuditLogService } from './src/services/AuditLogService';
+import { PlatformMembershipService } from './src/services/PlatformMembershipService';
 
 process.on('unhandledRejection', (error: Error) => {
     console.error('unhandledRejection');
@@ -184,6 +186,9 @@ const start = async () => {
     await import('./src/crons');
     startCrons();
     seeds().catch(console.error);
+
+    AuditLogService.listen();
+    PlatformMembershipService.listen();
 };
 
 start().catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.57.1",
+    "version": "2.59.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -33,18 +33,18 @@
     "dependencies": {
         "@bwip-js/node": "^4.5.1",
         "@mollie/api-client": "3.7.0",
-        "@simonbackx/simple-database": "1.25.0",
-        "@simonbackx/simple-encoding": "2.17.0",
-        "@simonbackx/simple-endpoints": "1.14.0",
+        "@simonbackx/simple-database": "1.27.0",
+        "@simonbackx/simple-encoding": "2.18.0",
+        "@simonbackx/simple-endpoints": "1.15.0",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.57.1",
-        "@stamhoofd/backend-middleware": "2.57.1",
-        "@stamhoofd/email": "2.57.1",
-        "@stamhoofd/models": "2.57.1",
-        "@stamhoofd/queues": "2.57.1",
-        "@stamhoofd/sql": "2.57.1",
-        "@stamhoofd/structures": "2.57.1",
-        "@stamhoofd/utility": "2.57.1",
+        "@stamhoofd/backend-i18n": "2.59.0",
+        "@stamhoofd/backend-middleware": "2.59.0",
+        "@stamhoofd/email": "2.59.0",
+        "@stamhoofd/models": "2.59.0",
+        "@stamhoofd/queues": "2.59.0",
+        "@stamhoofd/sql": "2.59.0",
+        "@stamhoofd/structures": "2.59.0",
+        "@stamhoofd/utility": "2.59.0",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -64,5 +64,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "f109d195d0bbb0e49c7b7bcef403b710c68c025b"
+    "gitHead": "a7043be8f8fde4fd1c91943495132a21921ebbe1"
 }

package/src/audit-logs/EventLogger.ts

@@ -0,0 +1,30 @@
+import { Event } from '@stamhoofd/models';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType } from '@stamhoofd/structures';
+
+export const EventLogger = new ModelLogger(Event, {
+    optionsGenerator: getDefaultGenerator({
+        created: AuditLogType.EventAdded,
+        updated: AuditLogType.EventEdited,
+        deleted: AuditLogType.EventDeleted,
+    }),
+
+    createReplacements(model) {
+        return new Map([
+            ['e', AuditLogReplacement.create({
+                id: model.id,
+                value: model.name,
+                type: AuditLogReplacementType.Event,
+            })],
+        ]);
+    },
+
+    postProcess(event, options, log) {
+        // Replace groupId key by 'registrations'
+        for (const item of log.patchList) {
+            if (item.key.value === 'groupId') {
+                item.key = AuditLogReplacement.key('registrations');
+            }
+        }
+    },
+});

package/src/audit-logs/GroupLogger.ts

@@ -0,0 +1,95 @@
+import { Group } from '@stamhoofd/models';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType, GroupType } from '@stamhoofd/structures';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
+
+const defaultGenerator = getDefaultGenerator({
+    created: AuditLogType.GroupAdded,
+    updated: AuditLogType.GroupEdited,
+    deleted: AuditLogType.GroupDeleted,
+});
+
+export const GroupLogger = new ModelLogger(Group, {
+    skipKeys: ['periodId', 'cycle', 'organizationId', 'stockReservations', 'settings.registeredMembers'],
+    async optionsGenerator(event) {
+        const result = await defaultGenerator(event);
+
+        if (!result) {
+            return;
+        }
+
+        const model = event.model;
+        if (model.type === GroupType.WaitingList) {
+            // Change event type
+            switch (result.type) {
+                case AuditLogType.GroupAdded:
+                    result.type = AuditLogType.WaitingListAdded;
+                    break;
+                case AuditLogType.GroupEdited:
+                    result.type = AuditLogType.WaitingListEdited;
+                    break;
+                case AuditLogType.GroupDeleted:
+                    result.type = AuditLogType.WaitingListDeleted;
+                    break;
+            }
+        }
+
+        if (model.type === GroupType.EventRegistration) {
+            // Change event type
+            switch (result.type) {
+                case AuditLogType.GroupAdded:
+                    // do not log
+                    return;
+                case AuditLogType.GroupEdited:
+                    result.type = AuditLogType.EventEdited;
+
+                    if (model.settings.eventId) {
+                        result.objectId = model.settings.eventId;
+                    }
+                    break;
+                case AuditLogType.GroupDeleted:
+                    // do not log
+                    return;
+            }
+        }
+
+        return result;
+    },
+
+    postProcess(event, _options, log) {
+        if (log.type === AuditLogType.EventEdited) {
+            // Prefix changes
+            for (const item of log.patchList) {
+                item.key = item.key.prepend(AuditLogReplacement.key('registrations'));
+            }
+        }
+    },
+
+    createReplacements: (model) => {
+        if (model.type === GroupType.EventRegistration) {
+            if (model.settings.eventId) {
+                return new Map([
+                    ['e', AuditLogReplacement.create({
+                        id: model.settings.eventId,
+                        value: model.settings.name,
+                        type: AuditLogReplacementType.Event,
+                    })],
+                ]);
+            }
+            return new Map([
+                ['e', AuditLogReplacement.create({
+                    id: model.id,
+                    value: model.settings.name,
+                    type: AuditLogReplacementType.Group,
+                })],
+            ]);
+        }
+
+        return new Map([
+            ['g', AuditLogReplacement.create({
+                id: model.id,
+                value: model.settings.name,
+                type: AuditLogReplacementType.Group,
+            })],
+        ]);
+    },
+});

package/src/audit-logs/MemberLogger.ts

@@ -0,0 +1,24 @@
+import { Member } from '@stamhoofd/models';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType } from '@stamhoofd/structures';
+
+export const MemberLogger = new ModelLogger(Member, {
+    // Skip repeated auto generated fields
+    skipKeys: ['firstName', 'lastName', 'birthDay', 'memberNumber'],
+
+    optionsGenerator: getDefaultGenerator({
+        created: AuditLogType.MemberAdded,
+        updated: AuditLogType.MemberEdited,
+        deleted: AuditLogType.MemberDeleted,
+    }),
+
+    createReplacements(model) {
+        return new Map([
+            ['m', AuditLogReplacement.create({
+                id: model.id,
+                value: model.details.name,
+                type: AuditLogReplacementType.Member,
+            })],
+        ]);
+    },
+});

package/src/audit-logs/MemberPlatformMembershipLogger.ts

@@ -0,0 +1,57 @@
+import { Member, MemberPlatformMembership } from '@stamhoofd/models';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType, uuidToName } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
+
+const defaultGenerator = getDefaultGenerator({
+    created: AuditLogType.MemberPlatformMembershipAdded,
+    updated: AuditLogType.MemberPlatformMembershipEdited,
+    deleted: AuditLogType.MemberPlatformMembershipDeleted,
+});
+
+export const MemberPlatformMembershipLogger = new ModelLogger(MemberPlatformMembership, {
+    skipKeys: ['balanceItemId'],
+    async optionsGenerator(event) {
+        const result = await defaultGenerator(event);
+
+        if (!result) {
+            return;
+        }
+
+        const member = await Member.getByID(event.model.memberId);
+
+        if (!member) {
+            console.log('No member found for MemberPlatformMembership', event.model.id);
+            return;
+        }
+
+        return {
+            ...result,
+            data: {
+                member,
+            },
+            objectId: event.model.memberId,
+        };
+    },
+
+    generateDescription(event, options) {
+        return Formatter.capitalizeFirstLetter(Formatter.dateRange(event.model.startDate, event.model.endDate));
+    },
+
+    createReplacements(model, options) {
+        const map = new Map([
+            ['pm', AuditLogReplacement.create({
+                id: model.membershipTypeId,
+                value: uuidToName(model.membershipTypeId) || undefined,
+                type: AuditLogReplacementType.PlatformMembershipType,
+            })],
+            ['m', AuditLogReplacement.create({
+                id: options.data.member.id,
+                value: options.data.member.details.name,
+                type: AuditLogReplacementType.Member,
+            })],
+        ]);
+
+        return map;
+    },
+});

package/src/audit-logs/MemberResponsibilityRecordLogger.ts

@@ -0,0 +1,69 @@
+import { Group, Member, MemberResponsibilityRecord, Organization, Platform } from '@stamhoofd/models';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType } from '@stamhoofd/structures';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
+
+const defaultGenerator = getDefaultGenerator({
+    created: AuditLogType.MemberResponsibilityRecordAdded,
+    updated: AuditLogType.MemberResponsibilityRecordEdited,
+    deleted: AuditLogType.MemberResponsibilityRecordDeleted,
+});
+
+export const MemberResponsibilityRecordLogger = new ModelLogger(MemberResponsibilityRecord, {
+    skipKeys: ['balanceItemId'],
+    async optionsGenerator(event) {
+        const result = await defaultGenerator(event);
+
+        if (!result) {
+            return;
+        }
+
+        const member = await Member.getByID(event.model.memberId);
+        const group = event.model.groupId ? (await Group.getByID(event.model.groupId)) : null;
+
+        if (!member) {
+            console.log('No member found for MemberResponsibilityRecord', event.model.id);
+            return;
+        }
+
+        if (event.type === 'updated' && event.changedFields.endDate && event.originalFields.endDate === null) {
+            result.type = AuditLogType.MemberResponsibilityRecordDeleted;
+            result.generatePatchList = false;
+        }
+
+        return {
+            ...result,
+            data: {
+                member,
+                group,
+                platform: await Platform.getSharedStruct(),
+            },
+            objectId: event.model.memberId,
+        };
+    },
+
+    createReplacements(model, options) {
+        const name = options.data.platform.config.responsibilities.find(r => r.id === model.responsibilityId)?.name;
+        const map = new Map([
+            ['r', AuditLogReplacement.create({
+                id: model.responsibilityId,
+                value: name,
+                type: AuditLogReplacementType.MemberResponsibility,
+            })],
+            ['m', AuditLogReplacement.create({
+                id: options.data.member.id,
+                value: options.data.member.details.name,
+                type: AuditLogReplacementType.Member,
+            })],
+        ]);
+
+        if (options.data.group) {
+            map.set('g', AuditLogReplacement.create({
+                id: options.data.group.id,
+                value: options.data.group.settings.name,
+                type: AuditLogReplacementType.Group,
+            }));
+        }
+
+        return map;
+    },
+});

package/src/audit-logs/ModelLogger.ts

@@ -0,0 +1,218 @@
+import { Model, ModelEvent } from '@simonbackx/simple-database';
+import { AuditLog } from '@stamhoofd/models';
+import { AuditLogReplacement, AuditLogSource, AuditLogType } from '@stamhoofd/structures';
+import { ContextInstance } from '../helpers/Context';
+import { AuditLogService } from '../services/AuditLogService';
+import { createUnknownChangeHandler } from '../services/explainPatch';
+
+export type ModelEventLogOptions<D> = {
+    type: AuditLogType;
+    generatePatchList?: boolean;
+    data: D;
+    mergeInto?: AuditLog;
+    objectId?: string;
+};
+
+type DefaultLogOptionsType = {
+    created?: AuditLogType;
+    updated?: AuditLogType;
+    deleted?: AuditLogType;
+};
+
+type EventOptionsGenerator<M extends Model, D> = (event: ModelEvent<M>) => ModelEventLogOptions<D> | Promise<ModelEventLogOptions<D> | undefined> | undefined;
+
+export type ModelLoggerOptions<M extends Model, D = undefined> = {
+    optionsGenerator: EventOptionsGenerator<M, D>;
+    skipKeys?: 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;
+};
+
+const ModelEventsMap = new WeakMap<Model, { events: AuditLog[] }>();
+
+export function getDefaultGenerator(types: DefaultLogOptionsType): EventOptionsGenerator<Model, undefined> {
+    return (event: ModelEvent<Model>) => {
+        if (event.type === 'created') {
+            if (types.created) {
+                return { type: types.created, data: undefined };
+            }
+            return;
+        }
+
+        let mergeInto: AuditLog | undefined = undefined;
+
+        if (event.type === 'updated') {
+            // Generate changes list
+            if ('deletedAt' in event.changedFields && ((event.model as any).deletedAt)) {
+                if (!('deletedAt' in event.originalFields) || !event.originalFields.deletedAt) {
+                    event = {
+                        ...event,
+                        type: 'deleted',
+                    };
+
+                    if (types.deleted) {
+                        return { type: types.deleted, data: undefined };
+                    }
+                }
+            }
+
+            if (types.updated) {
+                if ('createdAt' in event.model && event.model.createdAt instanceof Date && event.model.createdAt.getTime() >= Date.now() - 1000) {
+                    // Ignore quick model changes after insertion: these are often side effects of code that should not be logged
+                    // (the created event normally doesn't contain what has been added - so no need to log what has been changed since creation)
+                    if (types.created && types.created !== types.updated) {
+                        // Merge into create event
+                        const events = ModelEventsMap.get(event.model)?.events;
+                        if (events && events.length > 0) {
+                            mergeInto = events[0];
+                        }
+                    }
+                }
+
+                return { type: types.updated, generatePatchList: true, data: undefined, mergeInto };
+            }
+            return;
+        }
+
+        if (event.type === 'deleted') {
+            if (types.deleted) {
+                return { type: types.deleted, data: undefined };
+            }
+            return;
+        }
+    };
+}
+
+export class ModelLogger<ModelType extends typeof Model, M extends InstanceType<ModelType>, D> {
+    model: ModelType;
+    optionsGenerator: EventOptionsGenerator<M, D>;
+    skipKeys: 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'];
+
+    constructor(model: ModelType, options: ModelLoggerOptions<M, D>) {
+        this.model = model;
+        this.optionsGenerator = options.optionsGenerator;
+        this.skipKeys = options.skipKeys ?? [];
+        this.generateDescription = options.generateDescription;
+        this.createReplacements = options.createReplacements;
+        this.postProcess = options.postProcess;
+    }
+
+    async logEvent(event: ModelEvent<M>) {
+        try {
+            const context = ContextInstance.optional;
+            const log = new AuditLog();
+            const settings = AuditLogService.getContext();
+            const userId = settings?.userId !== undefined ? settings?.userId : (context?.optionalAuth?.user?.id ?? settings?.fallbackUserId ?? null);
+            log.userId = userId;
+
+            log.organizationId = context?.organization?.id ?? settings?.fallbackOrganizationId ?? null;
+
+            if ('organizationId' in event.model && typeof event.model['organizationId'] === 'string') {
+                // Always override
+                log.organizationId = event.model.organizationId;
+            }
+
+            if (settings?.source) {
+                log.source = settings.source;
+            }
+            else if (context) {
+                log.source = userId ? AuditLogSource.User : AuditLogSource.Anonymous;
+            }
+            else {
+                log.source = AuditLogSource.System;
+            }
+
+            const options = await this.optionsGenerator(event);
+
+            if (!options) {
+                return false;
+            }
+
+            log.type = options.type;
+            log.objectId = options.objectId ?? event.model.getPrimaryKey()?.toString() ?? null;
+            log.replacements = this.createReplacements ? this.createReplacements(event.model as M, options) : new Map();
+            log.description = (this.generateDescription ? this.generateDescription(event, options) : '') ?? '';
+
+            if (options.generatePatchList && event.type === 'updated') {
+                const oldModel = event.getOldModel();
+
+                // Generate changes list
+                const changedProperties = Object.keys(event.changedFields).filter(k => !this.skipKeys?.includes(k) && !ModelLogger.sharedSkipKeys.includes(k));
+
+                if (changedProperties.length > 0) {
+                    for (const key of changedProperties) {
+                        if (changedProperties[key] instanceof Model) {
+                            // Ignore relations
+                            continue;
+                        }
+                        log.patchList.push(...createUnknownChangeHandler(key)(
+                            key in oldModel ? oldModel[key] : undefined,
+                            key in event.model ? event.model[key] : undefined,
+                        ));
+                    }
+
+                    // Remove skipped keys
+                    log.patchList = log.patchList.filter(p => !this.skipKeys?.includes(p.key.toKey()));
+
+                    if (log.patchList.length === 0 && !log.description) {
+                        // No changes or all skipped
+                        console.log('No changes after secundary filtering');
+                        return false;
+                    }
+                }
+                else {
+                    console.log('No changes');
+                    return false;
+                }
+            }
+
+            if (this.postProcess) {
+                await this.postProcess(event, options, log);
+            }
+
+            if (options.mergeInto) {
+                // Merge into
+                console.log('Merging new audit log into existing log', options.mergeInto.id);
+
+                if (!options.mergeInto.description) {
+                    options.mergeInto.description = log.description;
+                }
+
+                if (log.replacements.size) {
+                    options.mergeInto.replacements = log.replacements;
+                }
+
+                if (!options.mergeInto.patchList.length) {
+                    options.mergeInto.patchList = log.patchList;
+                }
+
+                if (options.mergeInto.userId === null) {
+                    options.mergeInto.userId = log.userId;
+                }
+
+                if (options.mergeInto.organizationId === null) {
+                    options.mergeInto.organizationId = log.organizationId;
+                }
+
+                return await options.mergeInto.save();
+            }
+
+            const saved = await log.save();
+
+            // Assign to map
+            ModelEventsMap.set(event.model, {
+                events: [...(ModelEventsMap.get(event.model)?.events ?? []), log],
+            });
+            return saved;
+        }
+        catch (e) {
+            console.error('Failed to save log', e);
+        }
+        return false;
+    };
+}

package/src/audit-logs/OrderLogger.ts

@@ -0,0 +1,57 @@
+import { Order, Webshop } from '@stamhoofd/models';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType, OrderStatus } from '@stamhoofd/structures';
+
+const defaultGenerator = getDefaultGenerator({
+    created: AuditLogType.OrderAdded,
+    updated: AuditLogType.OrderEdited,
+    deleted: AuditLogType.OrderDeleted,
+});
+
+export const OrderLogger = new ModelLogger(Order, {
+    skipKeys: ['amount', 'timeSlotTime', 'validAt', 'paymentId'],
+    async optionsGenerator(event) {
+        const result = await defaultGenerator(event);
+
+        if (!result) {
+            return;
+        }
+
+        // todo: when placing an order / marking an order as paid
+        // we should not log any stock changes
+
+        const webshop = Order.webshop.isLoaded(event.model) ? (event.model as (Order & Record<'webshop', Webshop>)).webshop : (await Webshop.getByID(event.model.webshopId));
+        if (!webshop) {
+            console.log('No webshop found for order', event.model.id);
+            return;
+        }
+
+        if (event.type === 'updated' && event.changedFields.status === OrderStatus.Deleted) {
+            result.type = AuditLogType.OrderDeleted;
+            result.generatePatchList = false;
+        }
+
+        return {
+            ...result,
+            data: {
+                webshop,
+            },
+        };
+    },
+
+    createReplacements: (model, options) => {
+        return new Map([
+            ['w', AuditLogReplacement.create({
+                id: options.data.webshop.id,
+                value: options.data.webshop.meta.name,
+                type: AuditLogReplacementType.Webshop,
+            })],
+            ['org', AuditLogReplacement.create({
+                id: model.id,
+                value: model.number ? `bestelling #${model.number}` : `bestelling van ${model.data.customer.name}`,
+                type: AuditLogReplacementType.Order,
+                description: model.number ? model.data.customer.name : 'Deze bestelling heeft nog geen nummer',
+            })],
+        ]);
+    },
+});

package/src/audit-logs/OrganizationLogger.ts

@@ -0,0 +1,26 @@
+import { Organization } from '@stamhoofd/models';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType } from '@stamhoofd/structures';
+
+export const OrganizationLogger = new ModelLogger(Organization, {
+    skipKeys: ['searchIndex'],
+    optionsGenerator: getDefaultGenerator({
+        created: AuditLogType.OrganizationAdded,
+        updated: AuditLogType.OrganizationEdited,
+        deleted: AuditLogType.OrganizationDeleted,
+    }),
+
+    createReplacements(model) {
+        return new Map([
+            ['o', AuditLogReplacement.create({
+                id: model.id,
+                value: model.name,
+                type: AuditLogReplacementType.Organization,
+            })],
+        ]);
+    },
+
+    postProcess(event, options, log) {
+        log.organizationId = event.model.id;
+    },
+});