@stamhoofd/backend 2.58.0 → 2.59.0

package/src/services/explainPatch.ts

@@ -22,8 +22,8 @@ function createStringChangeHandler(key: string) {
         return [
             AuditLogPatchItem.create({
                 key: getAutoEncoderKey(key),
-                oldValue: getAutoEncoderValue(oldValue) || getAutoEncoderName(oldValue) || undefined,
-                value: getAutoEncoderValue(value) || getAutoEncoderName(value) || undefined,
+                oldValue: getAutoEncoderValue(oldValue, key) || getAutoEncoderName(oldValue) || undefined,
+                value: getAutoEncoderValue(value, key) || getAutoEncoderName(value) || undefined,
             }).autoType(),
         ];
     };
@@ -58,12 +58,11 @@ function createIntegerChangeHandler(key: string) {
             return [];
         }
 
-        const formatter: (typeof Formatter.price | typeof Formatter.integer) = key.toLowerCase().includes('price') ? Formatter.price.bind(Formatter) : Formatter.integer.bind(Formatter);
         return [
             AuditLogPatchItem.create({
                 key: getAutoEncoderKey(key),
-                oldValue: oldValue !== null ? AuditLogReplacement.string(formatter(oldValue)) : undefined,
-                value: value !== null ? AuditLogReplacement.string(formatter(value)) : undefined,
+                oldValue: oldValue !== null ? (getAutoEncoderValue(oldValue, key) || undefined) : undefined,
+                value: value !== null ? (getAutoEncoderValue(value, key) || undefined) : undefined,
             }).autoType(),
         ];
     };
@@ -85,7 +84,7 @@ function createDateChangeHandler(key: string) {
         let dno = oldValue ? Formatter.dateNumber(oldValue, true) : undefined;
         let dn = value ? Formatter.dateNumber(value, true) : undefined;
 
-        if (dno && dn && (dno === dn || (Formatter.time(oldValue!) !== Formatter.time(value!)))) {
+        if (dno && dn && (dno === dn || (Formatter.time(oldValue!) !== Formatter.time(value!))) && key !== 'birthDay') {
             // Add time
             dno += ' ' + Formatter.time(oldValue!);
             dn += ' ' + Formatter.time(value!);
@@ -157,7 +156,7 @@ function getAutoEncoderName(autoEncoder: unknown): AuditLogReplacement | null {
     }
     return null;
 }
-function getAutoEncoderPutValue(autoEncoder: unknown): AuditLogReplacement | null {
+function getAutoEncoderPutValue(autoEncoder: unknown, key?: string): AuditLogReplacement | null {
     if (typeof autoEncoder === 'object' && autoEncoder !== null && 'getPutValue' in autoEncoder && typeof autoEncoder.getPutValue === 'function') {
         const name = autoEncoder.getPutValue();
         if (typeof name === 'string') {
@@ -167,14 +166,18 @@ function getAutoEncoderPutValue(autoEncoder: unknown): AuditLogReplacement | nul
             return name;
         }
     }
-    return getAutoEncoderValue(autoEncoder);
+    return getAutoEncoderValue(autoEncoder, key);
 }
 
-function getAutoEncoderValue(autoEncoder: unknown): AuditLogReplacement | null {
+function getAutoEncoderValue(autoEncoder: unknown, key?: string): AuditLogReplacement | null {
     if (typeof autoEncoder === 'string') {
         if (isUuid(autoEncoder)) {
             return AuditLogReplacement.uuid(autoEncoder);
         }
+        if (key && key === 'status') {
+            // Will be an enum
+            return AuditLogReplacement.key(autoEncoder);
+        }
         return AuditLogReplacement.string(autoEncoder);
     }
 
@@ -187,6 +190,9 @@ function getAutoEncoderValue(autoEncoder: unknown): AuditLogReplacement | null {
     }
 
     if (typeof autoEncoder === 'number') {
+        if (key && (key.toLowerCase().includes('price') || key.toLowerCase().includes('fee'))) {
+            return AuditLogReplacement.string(Formatter.price(autoEncoder));
+        }
         return AuditLogReplacement.string(Formatter.integer(autoEncoder));
     }
 
@@ -246,6 +252,10 @@ function findOriginalById(id: unknown, oldArray: unknown[]): unknown | null {
     return id ? oldArray.find(v => getId(v) === id) : null;
 }
 
+function findOriginalIndexById(id: unknown, oldArray: unknown[]): number {
+    return id ? oldArray.findIndex(v => getId(v) === id) : -1;
+}
+
 function getId(object: unknown): string | number | null {
     const id = getOptionalId(object);
     if (typeof id !== 'string' && typeof id !== 'number') {
@@ -262,6 +272,10 @@ function findOriginal(put: unknown, oldArray: unknown[]): unknown | null {
     return findOriginalById(getId(put), oldArray);
 }
 
+function findIndex(put: unknown, oldArray: unknown[]): number {
+    return findOriginalIndexById(getId(put), oldArray);
+}
+
 function processPut(key: string, put: unknown, original: unknown | null, createdIdSet?: Set<string>): AuditLogPatchItem[] {
     const items: AuditLogPatchItem[] = [];
     const keySingular = getKeySingular(key);
@@ -269,10 +283,11 @@ function processPut(key: string, put: unknown, original: unknown | null, created
 
     // Added a new parent
     if (!original) {
+        const n = getAutoEncoderName(put);
         items.push(
             AuditLogPatchItem.create({
-                key: AuditLogReplacement.key(keySingular).append(getAutoEncoderName(put)),
-                value: v || undefined,
+                key: AuditLogReplacement.key(keySingular).append(n),
+                value: (n?.toString() !== v?.toString()) ? (v || undefined) : undefined,
                 type: AuditLogPatchItemType.Added,
             }),
         );
@@ -345,10 +360,10 @@ function processPatch(key: string, patch: unknown, original: unknown | null): Au
             ov = null;
             v = null;
 
-            if (l.length === 0) {
-                // Probably no change
-                return [];
-            }
+            // if (l.length === 0) {
+            // Probably no change
+            return [];
+            // }
         }
 
         // Simplify changes by providing one change instead of for all keys
@@ -380,15 +395,16 @@ function processDelete(key: string, deletedItem: unknown, createdIdSet?: Set<str
     }
 
     const v = getAutoEncoderPutValue(deletedItem);
+    const n = getAutoEncoderName(deletedItem);
 
     const keySingular = getKeySingular(key);
-    const k = AuditLogReplacement.key(keySingular).append(getAutoEncoderName(deletedItem));
+    const k = AuditLogReplacement.key(keySingular).append(n);
 
     return [
         AuditLogPatchItem.create({
             key: k,
             type: AuditLogPatchItemType.Removed,
-            oldValue: v ?? undefined,
+            oldValue: (n?.toString() !== v?.toString()) ? (v || undefined) : undefined,
         }),
     ];
 }
@@ -404,16 +420,25 @@ function createArrayChangeHandler(key: string) {
         if (!isPatchableArray(value)) {
             if (Array.isArray(value)) {
                 // Search for puts
-                for (const newItem of value) {
-                    const original = findOriginal(newItem, oldValue);
+                let orderChanged = false;
+                let added = 0;
+                for (const [index, newItem] of value.entries()) {
+                    const originalIndex = findIndex(newItem, oldValue);
 
-                    if (!original) {
+                    if (originalIndex === -1) {
                         // Has been added
-                        items.push(...processPut(key, newItem, original));
+                        items.push(...processPut(key, newItem, null));
+                        added++;
                     }
                     else {
                         // Has been overwritten
+                        const original = oldValue[originalIndex];
                         items.push(...processPatch(key, newItem, original));
+
+                        if ((index - added) !== originalIndex) {
+                            // Order has changed
+                            orderChanged = true;
+                        }
                     }
                 }
 
@@ -423,8 +448,20 @@ function createArrayChangeHandler(key: string) {
                     if (!newItem) {
                         // Has been deleted
                         items.push(...processDelete(key, original));
+
+                        orderChanged = false; // ignore order changed as delete will have set it to true
                     }
                 }
+
+                if (orderChanged) {
+                    // Check if order has changed
+                    items.push(
+                        AuditLogPatchItem.create({
+                            key: getAutoEncoderKey(key),
+                            type: AuditLogPatchItemType.Reordered,
+                        }),
+                    );
+                }
             }
             // Not supported
             return items;
@@ -524,10 +561,10 @@ function createMapChangeHandler(key?: string) {
                         ov = null;
                         nv = null;
 
-                        if (c.length === 0) {
-                            // Probably no change
-                            continue;
-                        }
+                        // if (c.length === 0) {
+                        // Probably no change
+                        continue;
+                        // }
                     }
 
                     // Simplify change
@@ -587,32 +624,32 @@ function createMapChangeHandler(key?: string) {
     };
 }
 
-function createUnknownChangeHandler(key: string) {
+export function createUnknownChangeHandler(key: string) {
     return (oldValue: unknown, value: unknown) => {
-        if (typeof value !== 'object' && value !== null) {
+        if (oldValue === value) {
             return [];
         }
 
-        if (oldValue === value) {
-            return [];
+        if ((Array.isArray(oldValue) || Array.isArray(value)) && (!oldValue || Array.isArray(oldValue)) && (Array.isArray(value) || !value)) {
+            return createArrayChangeHandler(key)(oldValue, value);
         }
 
-        if (!oldValue && getAutoEncoderValue(value)) {
+        if (!oldValue && oldValue !== 0 && getAutoEncoderValue(value, key)) {
         // Simplify addition
             return [
                 AuditLogPatchItem.create({
                     key: getAutoEncoderKey(key),
-                    value: getAutoEncoderPutValue(value) || undefined,
+                    value: getAutoEncoderPutValue(value, key) || undefined,
                     type: AuditLogPatchItemType.Added,
                 }),
             ];
         }
 
-        if (oldValue && value === null) {
+        if ((oldValue || oldValue === 0) && (value === null || value === undefined)) {
             return [
                 AuditLogPatchItem.create({
                     key: getAutoEncoderKey(key),
-                    oldValue: getAutoEncoderPutValue(oldValue) || undefined,
+                    oldValue: getAutoEncoderPutValue(oldValue, key) || undefined,
                     type: AuditLogPatchItemType.Removed,
                 }),
             ];
@@ -623,10 +660,10 @@ function createUnknownChangeHandler(key: string) {
             return i;
         });
 
-        let v = getAutoEncoderValue(value);
-        let ov = getAutoEncoderValue(oldValue);
+        let v = getAutoEncoderValue(value, key);
+        let ov = getAutoEncoderValue(oldValue, key);
 
-        if (oldValue && value && getAutoEncoderValue(value) && items.length === 0 && value instanceof AutoEncoder && value.isPatch()) {
+        if (oldValue !== undefined && oldValue !== null && value !== undefined && value !== null && getAutoEncoderValue(value, key) && items.length === 0 && value instanceof AutoEncoder && value.isPatch()) {
             return [
                 AuditLogPatchItem.create({
                     key: getAutoEncoderKey(key),
@@ -643,10 +680,10 @@ function createUnknownChangeHandler(key: string) {
                 v = null;
                 ov = null;
 
-                if (items.length === 0) {
-                    // Probably no change
-                    return [];
-                }
+                // if (items.length === 0) {
+                // Probably no change
+                return [];
+                // }
             }
 
             return [
@@ -694,7 +731,39 @@ function getExplainerForField(field: Field<any>) {
     }
 
     if (field.decoder instanceof ArrayDecoder) {
-        return createArrayChangeHandler(field.property);
+        const handler = createArrayChangeHandler(field.property);
+
+        if (field.decoder.decoder instanceof EnumDecoder) {
+            // Map values to keys
+            return (oldValue: unknown, value: unknown) => {
+                const items = handler(oldValue, value);
+
+                for (const item of items) {
+                    if (item.oldValue && !item.oldValue.type) {
+                        item.oldValue.type = AuditLogReplacementType.Key;
+                    }
+                    if (item.value && !item.value.type) {
+                        item.value.type = AuditLogReplacementType.Key;
+                    }
+
+                    // If item.key is an array that ends with a 'value', also change it
+                    if (item.key.type === AuditLogReplacementType.Array) {
+                        const lastKeyItem = item.key.values[item.key.values.length - 1];
+                        if (!lastKeyItem.type) {
+                            lastKeyItem.type = AuditLogReplacementType.Key;
+                        }
+                    }
+                    else {
+                        if (!item.key.type) {
+                            item.key.type = AuditLogReplacementType.Key;
+                        }
+                    }
+                }
+                return items;
+            };
+        }
+
+        return handler;
     }
 
     if (field.decoder instanceof MapDecoder) {

package/src/helpers/MembershipHelper.ts

@@ -1,54 +0,0 @@
-import { logger } from '@simonbackx/simple-logging';
-import { Member } from '@stamhoofd/models';
-import { QueueHandler } from '@stamhoofd/queues';
-
-export class MembershipHelper {
-    static async updateAll() {
-        console.log('Scheduling updateAllMemberships');
-
-        let c = 0;
-        let id: string = '';
-        const tag = 'updateAllMemberships';
-        const batch = 100;
-
-        QueueHandler.cancel(tag);
-
-        await QueueHandler.schedule(tag, async () => {
-            console.log('Starting updateAllMemberships');
-            await logger.setContext({ tags: ['silent-seed', 'seed'] }, async () => {
-                while (true) {
-                    const rawMembers = await Member.where({
-                        id: {
-                            value: id,
-                            sign: '>',
-                        },
-                    }, { limit: batch, sort: ['id'] });
-
-                    if (rawMembers.length === 0) {
-                        break;
-                    }
-
-                    const promises: Promise<any>[] = [];
-
-                    for (const member of rawMembers) {
-                        promises.push((async () => {
-                            await Member.updateMembershipsForId(member.id, true);
-                            c++;
-
-                            if (c % 10000 === 0) {
-                                process.stdout.write(c + ' members updated\n');
-                            }
-                        })());
-                    }
-
-                    await Promise.all(promises);
-                    id = rawMembers[rawMembers.length - 1].id;
-
-                    if (rawMembers.length < batch) {
-                        break;
-                    }
-                }
-            });
-        });
-    }
-}