@stamhoofd/backend 2.59.0 → 2.61.0

package/index.ts

@@ -16,6 +16,8 @@ import { ContextMiddleware } from './src/middleware/ContextMiddleware';
 import { Platform } from '@stamhoofd/models';
 import { AuditLogService } from './src/services/AuditLogService';
 import { PlatformMembershipService } from './src/services/PlatformMembershipService';
+import { DocumentService } from './src/services/DocumentService';
+import { SetupStepUpdater } from './src/helpers/SetupStepUpdater';
 
 process.on('unhandledRejection', (error: Error) => {
     console.error('unhandledRejection');
@@ -189,6 +191,8 @@ const start = async () => {
 
     AuditLogService.listen();
     PlatformMembershipService.listen();
+    DocumentService.listen();
+    SetupStepUpdater.listen();
 };
 
 start().catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.59.0",
+    "version": "2.61.0",
     "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.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",
+        "@stamhoofd/backend-i18n": "2.61.0",
+        "@stamhoofd/backend-middleware": "2.61.0",
+        "@stamhoofd/email": "2.61.0",
+        "@stamhoofd/models": "2.61.0",
+        "@stamhoofd/queues": "2.61.0",
+        "@stamhoofd/sql": "2.61.0",
+        "@stamhoofd/structures": "2.61.0",
+        "@stamhoofd/utility": "2.61.0",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -64,5 +64,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "a7043be8f8fde4fd1c91943495132a21921ebbe1"
+    "gitHead": "3df41cac9090d5e99abdbc51e4a4a02e9ea1784a"
 }

package/src/audit-logs/DocumentTemplateLogger.ts

@@ -0,0 +1,22 @@
+import { DocumentTemplate } from '@stamhoofd/models';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType } from '@stamhoofd/structures';
+
+export const DocumentTemplateLogger = new ModelLogger(DocumentTemplate, {
+    skipKeys: ['html'],
+    optionsGenerator: getDefaultGenerator({
+        created: AuditLogType.DocumentTemplateAdded,
+        updated: AuditLogType.DocumentTemplateEdited,
+        deleted: AuditLogType.DocumentTemplateDeleted,
+    }),
+
+    createReplacements(model) {
+        return new Map([
+            ['d', AuditLogReplacement.create({
+                id: model.id,
+                value: model.settings.name,
+                type: AuditLogReplacementType.DocumentTemplate,
+            })],
+        ]);
+    },
+});

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/MemberPlatformMembershipLogger.ts

@@ -1,5 +1,5 @@
-import { Member, MemberPlatformMembership } from '@stamhoofd/models';
-import { AuditLogReplacement, AuditLogReplacementType, AuditLogType, uuidToName } from '@stamhoofd/structures';
+import { Member, MemberPlatformMembership, Platform } from '@stamhoofd/models';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { getDefaultGenerator, ModelLogger } from './ModelLogger';
 
@@ -29,6 +29,7 @@ export const MemberPlatformMembershipLogger = new ModelLogger(MemberPlatformMemb
             ...result,
             data: {
                 member,
+                platform: await Platform.getSharedStruct(),
             },
             objectId: event.model.memberId,
         };
@@ -39,10 +40,12 @@ export const MemberPlatformMembershipLogger = new ModelLogger(MemberPlatformMemb
     },
 
     createReplacements(model, options) {
+        const name = options.data.platform.config.membershipTypes.find(r => r.id === model.membershipTypeId)?.name;
+
         const map = new Map([
             ['pm', AuditLogReplacement.create({
                 id: model.membershipTypeId,
-                value: uuidToName(model.membershipTypeId) || undefined,
+                value: name,
                 type: AuditLogReplacementType.PlatformMembershipType,
             })],
             ['m', AuditLogReplacement.create({

package/src/audit-logs/ModelLogger.ts

@@ -1,9 +1,9 @@
 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 { createUnknownChangeHandler } from '../services/explainPatch';
+import { diffUnknown } from '../services/diff';
 
 export type ModelEventLogOptions<D> = {
     type: AuditLogType;
@@ -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,10 +157,20 @@ export class ModelLogger<ModelType extends typeof Model, M extends InstanceType<
                             // Ignore relations
                             continue;
                         }
-                        log.patchList.push(...createUnknownChangeHandler(key)(
-                            key in oldModel ? oldModel[key] : undefined,
-                            key in event.model ? event.model[key] : undefined,
-                        ));
+                        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,
@@ -46,7 +46,7 @@ export const OrderLogger = new ModelLogger(Order, {
                 value: options.data.webshop.meta.name,
                 type: AuditLogReplacementType.Webshop,
             })],
-            ['org', AuditLogReplacement.create({
+            ['o', AuditLogReplacement.create({
                 id: model.id,
                 value: model.number ? `bestelling #${model.number}` : `bestelling van ${model.data.customer.name}`,
                 type: AuditLogReplacementType.Order,

package/src/audit-logs/OrganizationLogger.ts

@@ -1,6 +1,6 @@
 import { Organization } from '@stamhoofd/models';
+import { AuditLogType } from '@stamhoofd/structures';
 import { getDefaultGenerator, ModelLogger } from './ModelLogger';
-import { AuditLogReplacement, AuditLogReplacementType, AuditLogType } from '@stamhoofd/structures';
 
 export const OrganizationLogger = new ModelLogger(Organization, {
     skipKeys: ['searchIndex'],
@@ -10,16 +10,6 @@ export const OrganizationLogger = new ModelLogger(Organization, {
         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;
     },

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,
+            })],
+        ]);
+    },
+});