@prestizni-software/server-dem 0.4.86 → 0.4.88

package/dist/AutoUpdatedClientObjectClass.js

@@ -1,26 +1,18 @@
 import "reflect-metadata";
 import _ from "lodash";
-import { EVENT_INTERNAL_PRE_LOADED, EVENT_DELETE, EVENT_GET, EVENT_NEW, EVENT_UPDATE, } from "./CommonTypes.js";
+import { EVENT_INTERNAL_PRE_LOADED, EVENT_DELETE, EVENT_GET, EVENT_NEW, EVENT_UPDATE, globalCache, } from "./CommonTypes.js";
 import { ObjectId } from "bson";
-import { stringSimilarity } from "string-similarity-js";
 export class AutoUpdatedClientObject {
-    //From server type for overlapping keys
     entry;
     preLoad;
     registerSocket;
     readyLoggers;
     loadFromDB(a) { }
     setValue_(a, b) { }
-    //-*--
     socket;
     data;
     isServer = false;
-    loggers = {
-        info: () => { },
-        debug: () => { },
-        error: () => { },
-        warn: () => { },
-    };
+    loggers;
     isLoading = true;
     isLoadingReferences = true;
     checkedMissingRefs = false;
@@ -33,36 +25,21 @@ export class AutoUpdatedClientObject {
     toChangeOnParents = [];
     callbacks;
     loadReferencesAsync = async () => {
-        if (this.isLoaded) {
-            try {
-                this.generateSettersAndGetters();
-                await this.loadForceReferences();
-                for (const thing of this.toChangeOnParents) {
-                    await this.setValue__(thing.key, thing.value, true, false, true);
-                }
-            }
-            catch (error) {
-                this.loggers.error("Error loading references");
-                this.loggers.error(error.message);
-                this.loggers.error(error.stack);
-            }
-            this.isLoadingReferences = false;
-            return;
-        }
-        await this.waitForPreloaded();
-        this.generateSettersAndGetters();
         try {
+            if (!this.isLoaded) {
+                await this.waitForPreloaded();
+            }
+            this.generateSettersAndGetters();
             await this.loadForceReferences();
             for (const thing of this.toChangeOnParents) {
-                await this.setValue__(thing.key, thing.value, true, false, true);
+                await this.setValue__(thing.key, thing.value, true, false, false, true);
             }
-            this.isLoadingReferences = false;
         }
         catch (error) {
+            this.loggers.error("Error loading references: " + error.message);
+        }
+        finally {
             this.isLoadingReferences = false;
-            this.loggers.error("Error loading references");
-            this.loggers.error(error.message);
-            this.loggers.error(error.stack);
         }
     };
     /** @deprecated Use loadReferencesAsync instead */
@@ -74,7 +51,6 @@ export class AutoUpdatedClientObject {
             !loggers ||
             !className ||
             !parentManager ||
-            !callback ||
             !emitter) {
             this.classParam = classParam;
             this.socket = socket;
@@ -98,64 +74,36 @@ export class AutoUpdatedClientObject {
                 throw new Error("Missing arguments???");
         }
         this.classParam = classParam;
-        if (typeof data !== "string" && data._id) {
-            processIsRefProperties(data, this, undefined, [], loggers);
-        }
+        this.socket = socket;
         this.isServer = isServer;
         this.emitter = emitter;
         this.isLoadingReferences = true;
         this.isLoading = true;
         this.parentManager = parentManager;
         this.className = className;
-        this.properties = Reflect.getMetadata("props", classParam.prototype);
+        const allProps = new Set();
+        let proto_ = classParam.prototype;
+        while (proto_ && proto_ !== Object.prototype) {
+            const props = Reflect.getOwnMetadata("props", proto_) || [];
+            for (const p of props)
+                allProps.add(p);
+            proto_ = Object.getPrototypeOf(proto_);
+        }
+        this.properties = Array.from(allProps);
         this.callbacks = callback;
-        this.loggers.debug = (s) => loggers.debug("[DEM - " +
-            this.className +
-            ": " +
-            (this.data?._id ?? "not loaded") +
-            "] " +
-            s);
-        this.loggers.info = (s) => loggers.info("[DEM - " +
-            this.className +
-            ": " +
-            (this.data?._id ?? "not loaded") +
-            "] " +
-            s);
-        this.loggers.error = (s) => loggers.error("[DEM - " +
-            this.className +
-            ": " +
-            (this.data?._id ?? "not loaded") +
-            "] " +
-            s);
-        this.loggers.warn = (s) => loggers.warn("[DEM - " +
-            this.className +
-            ": " +
-            (this.data?._id ?? "not loaded") +
-            "] " +
-            s);
-        for (const prop of this.properties) {
-            if (typeof prop !== "string")
-                throw new Error("Property '" + prop.toString() + "' is not a string");
-            if (prop.includes("."))
-                throw new Error("Property '" +
-                    prop.toString() +
-                    "' constain the illegal character '.'");
-        }
-        this.socket = socket;
+        this.loggers = {
+            debug: (s) => loggers.debug(`[DEM - ${this.className}: ${this.data?._id ?? this._id ?? "not loaded"}] ${s}`),
+            info: (s) => loggers.info(`[DEM - ${this.className}: ${this.data?._id ?? this._id ?? "not loaded"}] ${s}`),
+            warn: (s) => loggers.warn(`[DEM - ${this.className}: ${this.data?._id ?? this._id ?? "not loaded"}] ${s}`),
+            error: (s) => loggers.error(`[DEM - ${this.className}: ${this.data?._id ?? this._id ?? "not loaded"}] ${s}`),
+        };
         if (typeof data === "string") {
+            this.data = { _id: data };
             if (this.isServer) {
                 this.isLoading = false;
-                this.data = { _id: data };
+                this.generateSettersAndGetters();
                 return;
             }
-            if (!data || data === "" || data === "undefined") {
-                this.loggers.error("Cannot create a new AutoUpdatedClientClass with an empty string for ID. Data typeof: " +
-                    typeof data +
-                    " Data: " +
-                    data);
-                throw new Error("Cannot create a new AutoUpdatedClientClass with an empty string for ID.");
-            }
-            this.loggers.debug("Getting new object from server " + this.className + " - " + data);
             this.socket.emit(EVENT_GET + this.className + data, null, (res) => {
                 if (!res.success) {
                     this.isLoading = false;
@@ -169,38 +117,24 @@ export class AutoUpdatedClientObject {
                 this.emitter.emit(EVENT_INTERNAL_PRE_LOADED + this.EmitterID);
                 this.openSockets();
             });
-            this.data = { _id: data };
         }
         else {
             this.isLoading = true;
             this.data = data;
-            const dataKeys = Object.keys(data);
-            for (const key of this.properties) {
-                if (typeof key !== "string")
-                    throw new Error("Only string keys allowed. Not this shit: " + String(key));
-                dataKeys.splice(dataKeys.indexOf(key), 1);
+            for (const key of this.properties || []) {
                 const isRef = getMetadataRecursive("isRef", this, key);
-                if (isRef) {
+                if (isRef && this.data[key]) {
                     if (Array.isArray(this.data[key])) {
                         this.data[key] = this.data[key].map((obj) => obj._id?.toString() ?? obj?.toString());
                     }
                     else {
-                        this.data[key] =
-                            this.data[key]?._id?.toString() ??
-                                this.data[key]?.toString();
+                        this.data[key] = this.data[key]?._id?.toString() ?? this.data[key]?.toString();
                     }
                 }
             }
-            if (dataKeys.includes("__v"))
-                dataKeys.splice(dataKeys.indexOf("__v"), 1);
-            if (dataKeys.length > 0)
-                this.loggers.warn((dataKeys.length > 1 ? "Properties " : "Property ") +
-                    dataKeys.join(", ") +
-                    (dataKeys.length > 1 ? " were " : " was ") +
-                    "unexpected. These properties are not known by the class. Please check your level of skill issue. Known properties are:\n" +
-                    this.properties.join("\n"));
-            if ((!this.data._id || this.data._id === "") && !this.isServer)
+            if ((!this.data._id || this.data._id === "") && !this.isServer) {
                 this.handleNewObject(data);
+            }
             else {
                 this.isLoading = false;
                 if (!this.isServer)
@@ -208,15 +142,18 @@ export class AutoUpdatedClientObject {
             }
         }
         this.generateSettersAndGetters();
+        // Re-apply getters in a microtask to override any shadowing from subclass field initializers.
+        Promise.resolve().then(() => {
+            this.generateSettersAndGetters();
+        });
     }
     async waitForPreloaded() {
         if (this.isLoaded)
             return;
         await new Promise((resolve, reject) => {
             this.emitter.once(EVENT_INTERNAL_PRE_LOADED + this.EmitterID, (failed, reason) => {
-                if (failed) {
+                if (failed)
                     reject(new Error(reason));
-                }
                 else
                     resolve();
             });
@@ -224,31 +161,6 @@ export class AutoUpdatedClientObject {
     }
     handleNewObject(data) {
         this.isLoading = true;
-        if (!this.className)
-            throw new Error("Cannot create a new AutoUpdatedClientClass without a class name.");
-        this.loggers.debug(this.className + " - Requesting new object creation on server");
-        if (this.isServer)
-            for (const key of this.properties) {
-                if (typeof key !== "string")
-                    continue;
-                let pointer = getMetadataRecursive("refsTo", this, key);
-                if (pointer) {
-                    pointer = pointer.split(":");
-                    if (pointer.length != 2)
-                        throw new Error("population ref incorrectly defined. Sould be 'ParentClass:PropName.Path'");
-                    const temp = data[key];
-                    delete data[key];
-                    if (temp)
-                        this.toChangeOnParents.push({ key: key, value: temp });
-                }
-            }
-        try {
-            data = _.cloneDeep(data);
-        }
-        catch (error) {
-            this.loggers.error("Most likely cycled object: " + error.message);
-            this.loggers.error(error.stack);
-        }
         this.socket.emit(EVENT_NEW + this.className, data, (res) => {
             if (!res.success) {
                 this.isLoading = false;
@@ -259,7 +171,6 @@ export class AutoUpdatedClientObject {
             this.data = res.data;
             this.generateSettersAndGetters();
             this.isLoading = false;
-            this.loggers.debug("Created new object: " + this.data._id);
             this.emitter.emit(EVENT_INTERNAL_PRE_LOADED + this.EmitterID);
             if (!this.isServer)
                 this.openSockets();
@@ -274,7 +185,6 @@ export class AutoUpdatedClientObject {
     }
     async isPreLoadedAsync() {
         await this.loadShit();
-        this.generateSettersAndGetters();
         return true;
     }
     async loadMissingReferences() {
@@ -282,7 +192,8 @@ export class AutoUpdatedClientObject {
         this.generateSettersAndGetters();
     }
     openSockets() {
-        const event = EVENT_UPDATE + this.className + this.data._id.toString();
+        const id = this.data?._id ?? this._id;
+        const event = EVENT_UPDATE + this.className + id.toString();
         this.socket.on(event, async (update, ack) => {
             const res = await this.handleUpdateRequest(update);
             if (ack && typeof ack === "function")
@@ -293,58 +204,79 @@ export class AutoUpdatedClientObject {
     async handleUpdateRequest(update) {
         try {
             await this.setValue__(update.key, update.value, true);
-            this.loggers.debug(`Applied patch ${update.key} set to ${JSON.stringify(update.value)}`);
-            // Return success with the applied patch
             if (this.isLoaded)
                 this.callbacks.update(this, update.key);
             return { success: true, data: undefined, message: "" };
         }
         catch (error) {
-            this.loggers.error(`[${this.data._id}] Error applying patch: ` +
-                error.message +
-                "\n" +
-                error.stack);
-            return {
-                success: false,
-                message: "Error applying update: " + error.message,
-            };
+            this.loggers.error(`[${this.data._id}] Error applying patch: ${error.message}`);
+            return { success: false, message: "Error applying update: " + error.message };
         }
     }
     generateSettersAndGetters() {
+        if (!this.properties)
+            return;
         for (const key of this.properties) {
             if (typeof key !== "string")
-                return;
-            const k = key;
+                continue;
             const isRef = getMetadataRecursive("isRef", this, key);
+            // CRITICAL: Delete any existing property on the instance to ensure our getter is used.
+            delete this[key];
             Object.defineProperty(this, key, {
                 get: () => {
-                    if (isRef) {
-                        if (Array.isArray(this.data[k])) {
-                            const filtered = this.data[k]
-                                .map((id) => this.findReference(id, key))
-                                .filter(Boolean);
-                            return filtered;
+                    if (!this.data)
+                        return undefined;
+                    let val = this.data[key];
+                    if (val === null)
+                        val = undefined; // Fix for server-side MongoDB nulls
+                    if (isRef && val) {
+                        if (Array.isArray(val)) {
+                            return val.map((id) => this.findReference(id, key)).filter(Boolean);
                         }
                         else {
-                            const result = this.findReference(this.data[k], key);
-                            return result;
+                            return this.findReference(val, key);
                         }
                     }
-                    else
-                        return this.data[k];
+                    return val;
+                },
+                set: (v) => {
+                    if (this.data)
+                        this.data[key] = v;
                 },
                 enumerable: true,
                 configurable: true,
             });
         }
     }
+    getValue(key_) {
+        const key = key_;
+        const parts = key.split(".");
+        let value = this;
+        for (const part of parts) {
+            if (value === undefined || value === null)
+                return undefined;
+            // Try instance first (getters), then fallback to data
+            const nextValue = value[part];
+            if (nextValue !== undefined) {
+                value = nextValue;
+            }
+            else if (value.data && value.data[part] !== undefined) {
+                value = value.data[part];
+            }
+            else {
+                return undefined;
+            }
+        }
+        return value;
+    }
     findReference(id, key) {
-        if (typeof id !== "string" && !ObjectId.isValid(id))
-            return id;
+        if (!id)
+            return undefined;
+        const idStr = id.toString();
         if (this.parentManager.cache.references[key])
-            return this.parentManager.cache.references[key].getObject(id.toString());
+            return this.parentManager.cache.references[key].getObject(idStr);
         for (const manager of Object.values(this.parentManager.managers)) {
-            const result = manager.getObject(id.toString());
+            const result = manager.getObject(idStr);
             if (result) {
                 this.parentManager.cache.references[key] = manager;
                 return result;
@@ -353,326 +285,87 @@ export class AutoUpdatedClientObject {
         return undefined;
     }
     async setValue(key, val) {
-        const result = await this.setValue__(key, val);
-        return result;
+        return await this.setValue__(key, val);
     }
-    async setValue__(key, val, silent = false, noGet = false, noUpdate = false) {
-        let message = "Setting value " + key + " of " + this.className + " to ";
-        const isRef = getMetadataRecursive("isRef", this, key);
-        if (isRef)
-            val = Array.isArray(val)
-                ? val.map((v) => {
-                    return v._id?.toString() ?? v;
-                })
-                : (val?._id ?? val);
+    async setValue__(key, val, silent = false, noGet = false, noUpdate = false, isParentUpdate = false) {
         try {
-            message += JSON.stringify(val);
-        }
-        catch (error) {
-            const _ = error;
-            this.loggers.error("Circular object detected when setting value: " + key);
-            if (val instanceof AutoUpdatedClientObject) {
-                val = val.extractedData._id;
-                message += JSON.stringify(val);
-            }
-        }
-        this.loggers.debug(message);
-        try {
-            if (val instanceof AutoUpdatedClientObject)
-                val = val.extractedData._id;
-            if (Array.isArray(val))
-                val = val.map((v) => v instanceof AutoUpdatedClientObject ? v.extractedData._id : v);
-            let originalVal = this.getValue(key);
-            if (Array.isArray(originalVal)) {
-                originalVal = originalVal.map((v) => v instanceof AutoUpdatedClientObject ? v.extractedData._id : v);
-            }
-            else {
-                originalVal =
-                    originalVal instanceof AutoUpdatedClientObject
-                        ? originalVal.extractedData._id
-                        : originalVal;
-            }
-            if ((Array.isArray(originalVal) &&
-                Array.isArray(val) &&
-                originalVal.length === val.length &&
-                !originalVal.some((v) => !val.includes(v))) ||
-                (Array.isArray(originalVal) &&
-                    !Array.isArray(val) &&
-                    originalVal.includes(val)) ||
-                (!Array.isArray(originalVal) &&
-                    !Array.isArray(val) &&
-                    originalVal === val)) {
-                return { success: true, msg: "" };
+            const isRef = getMetadataRecursive("isRef", this, key);
+            const pointer = getMetadataRecursive("refsTo", this, key);
+            if (pointer && !isParentUpdate && !silent && !this.isServer) {
+                throw new Error("Cannot set value of a reference pointer directly.");
             }
+            let valueToStore = val;
+            if (isRef) {
+                valueToStore = Array.isArray(val)
+                    ? val.map((v) => v._id?.toString() ?? v.toString())
+                    : (val?._id ?? val?.toString() ?? val);
+            }
+            const currentVal = this.getValue(key);
+            const currentValId = Array.isArray(currentVal)
+                ? currentVal.map(v => v._id?.toString() ?? v.toString())
+                : (currentVal?._id ?? currentVal?.toString());
+            if (_.isEqual(currentValId, valueToStore))
+                return { success: true, msg: "Successfully set " + key + " to " + val };
             const path = key.split(".");
-            let obj = this.data;
-            let lastClass = this;
-            let lastPath = path[0];
-            for (let i = 0; i < path.length - 1; i++) {
-                if (typeof obj[path[i]] === "string" ||
-                    ObjectId.isValid(obj[path[i]])) {
-                    let temp;
-                    try {
-                        temp = (await this.resolveReference(obj[path[i]]?.toString()));
-                    }
-                    catch (error) {
-                        message +=
-                            "\n Error: likely undefined property on path: " +
-                                path +
-                                " on index: " +
-                                i +
-                                " with error: " +
-                                error.message;
+            if (path.length > 1) {
+                let obj = this.data;
+                for (let i = 0; i < path.length - 1; i++) {
+                    const currentKey = path[i];
+                    if (typeof obj[currentKey] === 'string' || ObjectId.isValid(obj[currentKey])) {
+                        const ref = await this.resolveReference(obj[currentKey].toString());
+                        if (!ref)
+                            throw new Error("Could not resolve reference on path: " + key);
+                        return await ref.setValue(path.slice(i + 1).join("."), val);
                     }
-                    if (!temp) {
-                        message +=
-                            "\nLikely undefined property " +
-                                path[i] +
-                                " on path: " +
-                                path +
-                                " at index: " +
-                                i;
-                        this.loggers.warn("Failed to set value for " + this.className + "\n" + message);
-                        return {
-                            success: false,
-                            msg: message,
-                        };
-                    }
-                    lastClass = temp;
-                    lastPath = path.slice(i + 1).join(".");
-                    const res = await lastClass.setValue(lastPath, val);
-                    if (!noUpdate)
-                        await this.onUpdate(noUpdate);
-                    return res;
+                    obj = obj[currentKey];
                 }
-                else
-                    obj = obj[path[i]];
             }
-            if (lastClass !== this) {
-                message +=
-                    "\n What the actual fuckity fuck error on path: " +
-                        path +
-                        " on index: " +
-                        (path.length - 1);
-                this.loggers.error("Failed to set value for " + this.className + "\n" + message);
-                return {
-                    success: false,
-                    msg: message,
-                };
-            }
-            if (!this.properties.includes(lastPath) && !lastPath.includes(".")) {
-                let nearest = "";
-                for (const prop of this.properties) {
-                    if (typeof prop !== "string")
-                        continue;
-                    if (stringSimilarity(lastPath, prop) > 0 &&
-                        stringSimilarity(lastPath, prop) > stringSimilarity(nearest, prop)) {
-                        nearest = prop;
-                    }
+            const res = await this.setValueInternal(key, valueToStore, silent, noUpdate);
+            if (res.success) {
+                const pathArr = key.split(".");
+                let obj = this.data;
+                for (let i = 0; i < pathArr.length - 1; i++) {
+                    obj = obj[pathArr[i]];
                 }
-                throw new Error(`Property ${lastPath} not found in class ${this.className}, did you mean ${nearest ?? "--No similar prop found--"}?`);
+                obj[pathArr[pathArr.length - 1]] = valueToStore;
+                await this.findAndLoadReferences(key, valueToStore);
+                if (isRef && this.parentManager.isLoaded)
+                    await this.contactChildren();
+                if (this.isLoaded)
+                    this.callbacks.update(this, key);
             }
-            let success;
-            try {
-                let isPopulated = getMetadataRecursive("refsTo", this, lastPath);
-                if (isPopulated) {
-                    isPopulated = isPopulated.split(":");
-                    if (val !== null && val !== undefined) {
-                        const parentObj = this.parentManager.managers[isPopulated[0]].getObject(val);
-                        if (!parentObj) {
-                            message +=
-                                "\n   Failed to set value for " +
-                                    this.className +
-                                    " parent not found";
-                            this.loggers.error(message);
-                            return { success: false, msg: message };
-                        }
-                        if (parentObj.getValue(isPopulated[1]) &&
-                            !Array.isArray(parentObj.getValue(isPopulated[1]))) {
-                            message +=
-                                "\nThis is a 1:1 relationship and the parent already has a parent with the ID: " +
-                                    (parentObj.getValue(isPopulated[1])._id?.toString() ??
-                                        parentObj.getValue(isPopulated[1]).toString()) +
-                                    this.loggers.error(message);
-                            return { success: false, msg: message };
-                        }
-                        let res;
-                        if (this.isServer) {
-                            const value = parentObj.getValue(isPopulated[1]);
-                            if (Array.isArray(value)) {
-                                if (value
-                                    .map((v) => v._id?.toString() ?? v.toString())
-                                    .includes(this.data._id.toString()))
-                                    return {
-                                        success: true,
-                                        msg: message + "\nValue already set",
-                                    };
-                                res = await parentObj.setValue__(isPopulated[1], value.concat(this.data._id.toString()), false, false, true);
-                            }
-                            else {
-                                if ((value?._id?.toString() ?? value?.toString()) ===
-                                    this.data._id.toString())
-                                    return {
-                                        success: true,
-                                        msg: message + "\nValue already set",
-                                    };
-                                res = await parentObj.setValue__(isPopulated[1], this.data._id.toString(), false, false, true);
-                            }
-                        }
-                        else {
-                            const value = parentObj.getValue(isPopulated[1]);
-                            if (Array.isArray(value)
-                                ? value
-                                    .map((v) => v._id?.toString() ?? v.toString())
-                                    .includes(this.data._id.toString())
-                                : (value._id?.toString() ?? value.toString()) ===
-                                    this.data._id.toString())
-                                return { success: true, msg: message + "\nValue already set" };
-                            ({ res, val } = await this.preInnerSetValue(noGet, key, val, lastPath, silent, noUpdate));
-                        }
-                        success = res.success;
-                        message +=
-                            "\nReport from inner setValue function: " +
-                                res.msg.split("\n").join("\n  ");
-                    }
-                    else {
-                        const originalParenValue = this.getValue(key).getValue(isPopulated[1]);
-                        if (!originalParenValue ||
-                            (Array.isArray(originalParenValue) &&
-                                !originalParenValue.some((v) => (v._id?.toString() ?? v.toString()) === this._id.toString()))) {
-                            message += "\n   Value already set";
-                            return { success: true, msg: message };
-                        }
-                        const parentObj = this.parentManager.managers[isPopulated[0]].getObject(originalVal);
-                        if (!parentObj) {
-                            message +=
-                                "\n   Failed to set value for " +
-                                    this.className +
-                                    " parent not found";
-                            this.loggers.error(message);
-                            return { success: false, msg: message };
-                        }
-                        let res;
-                        if (Array.isArray(originalParenValue)) {
-                            res = await parentObj.setValue__(isPopulated[1], originalParenValue
-                                .map((v) => v._id?.toString() ?? v.toString())
-                                .filter((v) => v !== this._id.toString()));
-                        }
-                        else {
-                            res = await parentObj.setValue__(isPopulated[1], null);
-                        }
-                        success = res.success;
-                        message +=
-                            "\nReport from inner setValue function: " +
-                                res.msg.split("\n").join("\n  ");
-                    }
-                }
-                else {
-                    const isRef = getMetadataRecursive("isRef", this, key);
-                    if (isRef && this.isServer && Array.isArray(val)
-                        ? !val.some((v) => !ObjectId.isValid(v))
-                        : ObjectId.isValid(val))
-                        val = Array.isArray(val)
-                            ? val.map((v) => new ObjectId(v))
-                            : new ObjectId(val);
-                    let res;
-                    ({ res, val } = await this.preInnerSetValue(noGet, key, val, lastPath, silent, noUpdate));
-                    if (res.success) {
-                        const originalValue = obj[path.at(-1)];
-                        if (!Array.isArray(val) && Array.isArray(originalValue)) {
-                            if (!originalValue.includes(val))
-                                originalValue.push(val);
-                            val = originalValue;
-                        }
-                        else
-                            obj[path.at(-1)] = val;
-                    }
-                    success = res.success;
-                    message += "\nReport from inner setValue function: \n " + res.msg;
-                }
-            }
-            catch (error) {
-                success = false;
-                message += "\nError from inner setValue function: \n  " + error.message;
-                message += error.stack;
-            }
-            if (!success) {
-                this.loggers.warn("Failed to set value for " + this.className + "\n" + message);
-                return { success: false, msg: message };
-            }
-            const pathArr = lastPath.split(".");
-            if (pathArr.length === 1) {
-                this.data[key] = val;
-            }
-            else {
-                const last = pathArr.splice(-1, 1);
-                let ref = this;
-                for (const p of pathArr) {
-                    ref = ref[p];
-                }
-                ref[last.at(-1)] = val;
-            }
-            if (!noUpdate)
-                await this.onUpdate(noUpdate);
-            await this.findAndLoadReferences(lastPath, val);
-            const isRef = getMetadataRecursive("isRef", this, path.at(-1));
-            if (isRef && this.parentManager.isLoaded) {
-                await this.contactChildren();
-            }
-            if (this.isLoaded)
-                this.callbacks.update(this, key);
-            return {
-                success: true,
-                msg: "Successfully set " + key + " to " + val,
-            };
+            return { ...res, msg: res.msg ?? "Successfully set " + key + " to " + val };
         }
         catch (error) {
-            this.loggers.error("An error occurred setting value for " +
-                this.className +
-                "\n" +
-                message +
-                "\n Random error here: " +
-                error.message +
-                "\n" +
-                error.stack);
-            this.loggers.error(error);
-            return {
-                success: false,
-                msg: message +
-                    "\n Random error here: " +
-                    error.message +
-                    "\n" +
-                    error.stack,
-            };
+            this.loggers.error(`Error setting value ${key}: ${error.message}`);
+            return { success: false, msg: error.message };
         }
     }
-    async preInnerSetValue(noGet, key, val, lastPath, silent, noUpdate) {
-        if (!noGet &&
-            this.isServer &&
-            this.getValue(key) &&
-            Array.isArray(this.getValue(key)) &&
-            !Array.isArray(val)) {
-            val = [
-                ...new Set(this.getValue(key)
-                    .concat(val)
-                    .map((v) => v?._id?.toString() ?? new ObjectId(v))
-                    .filter(Boolean)),
-            ];
+    async setValueInternal(key, value, silent = false, noUpdate = false) {
+        if (silent)
+            return { success: true, msg: "Silent" };
+        return new Promise((resolve) => {
+            const id = this.data?._id ?? this._id;
+            this.socket.emit(EVENT_UPDATE + this.className + id, { _id: id.toString(), key, value }, (res) => {
+                resolve({ success: res.success, msg: res.message ?? (res.success ? "Success" : "Error") });
+            });
+        });
+    }
+    makeUpdate(key, value) {
+        const id = this.data?._id ?? this._id;
+        if (!id) {
+            this.loggers.error(`Probably missing the identifier ['_id'] again: ${key} = ${value}`);
+            throw new Error(`Cannot make update for ${this.className} because _id is missing.`);
         }
-        const res = await this.setValueInternal(lastPath, val, silent, noUpdate);
-        if (!noGet &&
-            !this.isServer &&
-            this.getValue(key) &&
-            Array.isArray(this.getValue(key)) &&
-            !Array.isArray(val)) {
-            val = [
-                ...new Set(this.getValue(key)
-                    .concat(val)
-                    .map((v) => v?._id?.toString() ?? new ObjectId(v))
-                    .filter(Boolean)),
-            ];
+        return { _id: id.toString(), key, value };
+    }
+    async resolveReference(id) {
+        for (const manager of Object.values(this.parentManager.managers)) {
+            const obj = manager.getObject(id);
+            if (obj)
+                return obj;
         }
-        return { res, val };
+        return null;
     }
     async findAndLoadReferences(lastPath, value) {
         const isRef = getMetadataRecursive("isRef", this, lastPath);
@@ -686,395 +379,149 @@ export class AutoUpdatedClientObject {
                     if (result)
                         break;
                 }
-                if (!result) {
-                    for (const manager of Object.values(this.parentManager.managers)) {
-                        try {
-                            result = await manager.handleGetMissingObject(id?.toString());
-                            if (result)
-                                break;
-                        }
-                        catch (error) {
-                            const _ = error;
-                        }
-                    }
-                    if (!result) {
-                        this.loggers.warn("Failed to update childerns parent for " +
-                            this.className +
-                            " updating " +
-                            id +
-                            "'s parent to " +
-                            this.data._id);
-                        continue;
-                    }
-                }
                 if (result && typeof result.loadMissingReferences === "function") {
                     await result.loadMissingReferences();
                 }
-                else if (result) {
-                    this.loggers.warn(`Object in reference resolution is missing loadMissingReferences function. Type: ${typeof result}, ID: ${result._id ?? result}`);
-                }
             }
         }
     }
-    getValue(key_) {
-        const key = key_;
-        if (!key.includes(".")) {
-            let val = this[key];
-            val ??= this.data[key];
-            return val;
-        }
-        let value;
-        const parts = key.split(".");
-        for (const part of parts) {
-            try {
-                if (value !== undefined && value !== null) {
-                    value = value[part];
-                }
-                else {
-                    value = this[part];
-                }
-            }
-            catch (error) {
-                this.loggers.error(`Error getting value for ${this.className} on key ${key} at index ${part}: ${error.message}`);
-                return undefined;
-            }
-        }
-        return value;
-    }
-    async setValueInternal(key, value, silent = false, noUpdate = false) {
-        const update = this.makeUpdate(key, value);
-        const promise = new Promise((resolve) => {
-            if (silent) {
-                if (noUpdate)
-                    return resolve({ success: true, msg: "Success - no update" });
-                return this.onUpdate(true).then(() => {
-                    if (this.isLoaded)
-                        this.callbacks.update(this, key);
-                    return resolve({ success: true, msg: "Success - silent" });
-                });
-            }
-            try {
-                this.socket.emit(EVENT_UPDATE + this.className + this.data._id, update, async (res) => {
-                    if (!res.success) {
-                        this.loggers.error("Error sending update: " + res.message);
-                        resolve({ success: false, msg: res.message });
-                        return;
-                    }
-                    if (!noUpdate)
-                        await this.onUpdate(noUpdate);
-                    resolve({
-                        success: res.success,
-                        msg: res.message ?? "Success",
-                    });
-                });
-            }
-            catch (error) {
-                this.loggers.error("Error sending update:" + error.message);
-                this.loggers.error(error.stack);
-                resolve({ success: false, msg: error.message });
-            }
-        });
-        return promise;
-    }
-    makeUpdate(key, value) {
-        try {
-            const id = this.data._id.toString();
-            return { _id: id, key, value };
-        }
-        catch (error) {
-            this.loggers.error("Probably missing the fucking identifier ['_id'] again: " +
-                error.message);
-            throw error;
-        }
-    }
-    async onUpdate(_) {
-        return;
-    }
-    // return a properly typed AutoUpdatedClientClass (or null)
-    // inside AutoUpdatedClientClass
-    async resolveReference(id) {
-        if (!this.parentManager)
-            throw new Error("No Manager");
-        for (const manager of Object.values(this.parentManager.managers)) {
-            const data = manager.getObject(id);
-            if (data)
-                return data;
+    async wipeSelf() {
+        if (this.data.Wiped)
+            return;
+        const id = this.data?._id ?? this._id;
+        const _id = id ? id.toString() : "unknown";
+        for (const key of Object.keys(this.data)) {
+            delete this.data[key];
         }
-        return null;
+        this.data = { Wiped: true };
+        this.loggers.info(`[${_id}] ${this.className} object wiped`);
     }
     async loadForceReferences(obj = this.data, proto = this, alreadySeen = []) {
         const props = Reflect.getMetadata("props", proto) || [];
         for (const key of props) {
             if (typeof key !== "string")
-                return;
+                continue;
             const isRef = Reflect.getMetadata("isRef", proto, key);
             const pointer = Reflect.getMetadata("refsTo", proto, key);
-            if (pointer &&
-                obj === this.data &&
-                obj[key] &&
-                !alreadySeen.includes(obj))
+            if (pointer && obj === this.data && obj[key] && !alreadySeen.includes(obj)) {
                 await this.createdWithParent(pointer.split(":"), obj[key]);
-            alreadySeen.push(obj[key]);
-            if (isRef) {
-                await this.handleLoad(obj, key, alreadySeen);
             }
-            await this.checkRecursiveReferenceLoading(obj, key, alreadySeen);
-        }
-    }
-    async checkRecursiveReferenceLoading(obj, key, alreadySeen) {
-        const val = obj ? obj[key] : null;
-        if (val && typeof val === "object") {
-            const nestedProto = Object.getPrototypeOf(val);
-            if (nestedProto && !alreadySeen.includes(val)) {
-                alreadySeen.push(val);
-                await this.loadForceReferences(val, nestedProto, alreadySeen);
+            if (obj[key] && !alreadySeen.includes(obj[key]))
+                alreadySeen.push(obj[key]);
+            if (isRef)
+                await this.handleLoad(obj, key, alreadySeen);
+            const val = obj[key];
+            if (val && typeof val === "object") {
+                const nestedProto = Object.getPrototypeOf(val);
+                if (nestedProto && !alreadySeen.includes(val)) {
+                    alreadySeen.push(val);
+                    await this.loadForceReferences(val, nestedProto, alreadySeen);
+                }
             }
         }
     }
     async handleLoad(obj, key, alreadySeen) {
-        if (!this.parentManager)
-            throw new Error("No manager");
         const refIds = Array.isArray(obj[key]) ? obj[key] : [obj[key]];
         for (const refId of refIds) {
             if (refId) {
-                for (const manager of Object.values(this.parentManager.managers)) {
-                    const result = manager.getObject(refId);
-                    if (result && !alreadySeen.includes(refId)) {
-                        alreadySeen.push(refId);
-                        await result.loadForceReferences(undefined, undefined, alreadySeen);
-                        break;
+                const idStr = refId.toString();
+                let result = globalCache.objects[idStr]?.object;
+                if (!result) {
+                    for (const manager of Object.values(this.parentManager.managers)) {
+                        result = manager.getObject(idStr);
+                        if (result)
+                            break;
                     }
                 }
+                if (result && !alreadySeen.includes(idStr)) {
+                    alreadySeen.push(idStr);
+                    await result.loadForceReferences(undefined, undefined, alreadySeen);
+                }
             }
         }
     }
+    async onUpdate(noUpdate = false) {
+        return;
+    }
     async createdWithParent(pointer, parent) {
-        if (pointer.length !== 2) {
-            throw new Error("Invalid pointer: " +
-                JSON.stringify(pointer) +
-                " for " +
-                this.className +
-                ", poiter must be 'className:pathToParentProperty'");
-        }
-        if (!parent)
-            throw new Error("Invalid pointer: " +
-                JSON.stringify(pointer) +
-                " for " +
-                this.className +
-                ", parent is null");
-        const obj = this.parentManager.managers[pointer[0]]?.getObject(parent._id?.toString() ?? parent.toString());
+        if (pointer.length !== 2)
+            return;
+        const parentId = parent._id?.toString() ?? parent.toString();
+        const obj = this.parentManager.managers[pointer[0]]?.getObject(parentId);
         if (!obj)
             return;
         const val = obj.getValue(pointer[1]);
+        const myId = this.data._id.toString();
         if (Array.isArray(val)) {
-            const originalLength = val.length;
-            const filtred = val.filter(Boolean);
-            if (filtred.length !== originalLength) {
-                await obj.setValue__(pointer[1], filtred, true, false, true);
-                this.loggers.warn("Array value changed from " +
-                    originalLength +
-                    " to " +
-                    filtred.length +
-                    " - some values were undefined");
+            const ids = val.map(v => v._id?.toString() ?? v.toString());
+            if (!ids.includes(myId)) {
+                await obj.setValue__(pointer[1], [...val, myId], true, false, false, true);
             }
-            if (filtred.map((id) => id?._id?.toString()).includes(this.data._id))
-                await obj.contactChildren();
-            else
-                await obj.setValue__(pointer[1], [
-                    ...new Set([...filtred, this.data._id]),
-                ], true, false, true);
         }
-        else if (val?.toString() === this.data?._id?.toString())
-            await obj.contactChildren();
-        else
-            await obj.setValue__(pointer[1], this.data?._id?.toString(), true, false, true);
+        else if ((val?._id?.toString() ?? val?.toString()) !== myId) {
+            await obj.setValue__(pointer[1], myId, true, false, false, true);
+        }
     }
     async destroy(once = false) {
-        if (!once) {
+        if (!once)
             return await this.parentManager.deleteObject(this.data._id);
-        }
-        const res = await new Promise((resolve) => {
-            this.socket.emit(EVENT_DELETE + this.className, this.data._id, async (res) => {
-                if (!res.success) {
-                    this.loggers.error("Error deleting object from database - " +
-                        this.className +
-                        " - " +
-                        this.data._id);
-                    this.loggers.error(res.message);
-                    resolve({
-                        success: false,
-                        message: res.message,
-                    });
-                    return;
-                }
-                resolve({
-                    success: true,
-                    message: "Deleted",
-                });
+        return new Promise((resolve) => {
+            this.socket.emit(EVENT_DELETE + this.className, this.data._id, (res) => {
+                resolve({ success: res.success, message: res.message ?? "" });
             });
         });
-        return res;
     }
     async checkForMissingRefs() {
         for (const prop of this.properties) {
-            let pointer = getMetadataRecursive("refsTo", this, prop.toString());
+            const pointer = getMetadataRecursive("refsTo", this, prop.toString());
             if (pointer) {
-                pointer = pointer.split(":");
-                if (pointer.length != 2)
-                    throw new Error("population ref incorrectly defined. Sould be 'ParentClass:PropName'");
-                await this.findMissingObjectReference(prop, pointer);
+                const parts = pointer.split(":");
+                if (parts.length === 2)
+                    await this.findMissingObjectReference(prop, parts);
             }
         }
     }
     async findMissingObjectReference(prop, pointer) {
-        if (this.checkedMissingRefs && this.isLoadingReferences)
+        if (this.checkedMissingRefs)
             return;
         this.checkedMissingRefs = true;
         const ac = this.parentManager.managers[pointer[0]];
         if (!ac)
-            throw new Error(`No AutoUpdateManager found for class ${pointer[0]}`);
+            return;
         const targetId = this.data._id.toString();
-        const pointerKey = pointer[1];
-        const isNested = pointerKey.includes(".");
-        const pathParts = isNested ? pointerKey.split(".") : [];
-        const pendingObjects = ac.objectsAsArray.filter(obj => !obj.isLoaded);
-        if (pendingObjects.length > 0) {
-            await Promise.all(pendingObjects.map(obj => obj.waitForPreloaded()));
-        }
-        for (const obj of ac.objectsAsArray) {
-            if (!obj.isLoaded) {
+        const allObjects = Object.values(ac.objects);
+        for (const obj of allObjects) {
+            if (!obj.isLoaded)
                 await obj.waitForPreloaded();
-            }
-            let val;
-            if (isNested) {
-                val = obj;
-                for (const element of pathParts) {
-                    if (!val)
-                        break;
-                    val = val[element] ?? val.data?.[element];
-                }
-            }
-            else {
-                val = obj[pointerKey] ?? obj.data?.[pointerKey];
-            }
+            const val = obj.getValue(pointer[1]);
             if (!val)
                 continue;
-            let found = false;
-            if (Array.isArray(val)) {
-                for (const element of val) {
-                    const item = element;
-                    if (!item)
-                        continue;
-                    const idStr = item._id ? item._id.toString() : item.toString();
-                    if (idStr === targetId) {
-                        found = true;
-                        break;
-                    }
-                }
-            }
-            else {
-                const idStr = val._id ? val._id.toString() : val.toString();
-                found = (idStr === targetId);
-            }
-            if (found) {
+            const ids = Array.isArray(val) ? val.map(v => v._id?.toString() ?? v.toString()) : [val._id?.toString() ?? val.toString()];
+            if (ids.includes(targetId)) {
                 this.data[prop] = obj._id;
                 return;
             }
         }
     }
-    async wipeSelf() {
-        if (this.data.Wiped)
-            return;
-        const _id = this.data._id.toString();
-        for (const key of Object.keys(this.data)) {
-            delete this.data[key];
-        }
-        this.data = { Wiped: true };
-        this.loggers.info(`[${_id}] ${this.className} object wiped`);
-    }
     async contactChildren() {
-        let childsManager = null;
-        const findMissingObjectWithoutKnownManager = async (o) => {
-            if (o instanceof AutoUpdatedClientObject)
-                return o;
-            if (childsManager)
-                try {
-                    return await childsManager.handleGetMissingObject(o._id?.toString() ?? o.toString());
-                }
-                catch (error) {
-                    this.loggers.error("This should fucking not happen wtffffff");
-                    this.loggers.error(error.message);
-                    childsManager = null;
-                }
-            else {
-                for (const manager of Object.values(this.parentManager.managers)) {
-                    try {
-                        const newO = await manager.handleGetMissingObject(o._id?.toString() ?? o.toString());
-                        childsManager = manager;
-                        return newO;
-                    }
-                    catch (e) {
-                        const _ = e;
-                    }
-                }
-                return undefined;
-            }
-        };
         for (const prop of this.properties) {
-            const pointer = getMetadataRecursive("refsTo", this, prop.toString());
             const isRef = getMetadataRecursive("isRef", this, prop.toString());
+            const pointer = getMetadataRecursive("refsTo", this, prop.toString());
             if (!isRef || pointer)
                 continue;
-            let obj = this.getValue(prop);
-            if (!obj || (Array.isArray(obj) && obj.length == 0)) {
-                obj = this.getValueInternal(prop);
-                try {
-                    if (Array.isArray(obj))
-                        obj = await Promise.all(obj.map(findMissingObjectWithoutKnownManager));
-                    else
-                        obj = await findMissingObjectWithoutKnownManager(obj);
-                }
-                catch (error) {
-                    const _ = error;
-                }
-            }
+            const obj = this.getValue(prop);
             if (!obj)
                 continue;
-            if (Array.isArray(obj)) {
-                for (const child of obj) {
-                    try {
-                        if (child && typeof child.loadMissingReferences === "function") {
-                            await child.loadMissingReferences();
-                        }
-                        else if (child) {
-                            this.loggers.warn(`Object in property ${prop.toString()} is missing loadMissingReferences function. Type: ${typeof child}, ID: ${child._id ?? child}`);
-                        }
-                    }
-                    catch (error) {
-                        this.loggers.error(error.message);
-                    }
-                }
-            }
-            else {
-                if (obj && typeof obj.loadMissingReferences === "function") {
-                    await obj.loadMissingReferences();
-                }
-                else if (obj) {
-                    this.loggers.warn(`Object in property ${prop.toString()} is missing loadMissingReferences function. Type: ${typeof obj}, ID: ${obj._id ?? obj}`);
+            const children = Array.isArray(obj) ? obj : [obj];
+            for (const child of children) {
+                if (child && typeof child.loadMissingReferences === "function") {
+                    await child.loadMissingReferences();
                 }
             }
         }
     }
-    getValueInternal(key) {
-        const keys = key.toString().split(".");
-        let value = this.data;
-        for (const k of keys) {
-            value = value[k];
-        }
-        return value;
-    }
 }
-export function processIsRefProperties(instance, target, prefix = null, allProps = [], newData = {}, loggers = console) {
+export function processIsRefProperties(instance, target, prefix, allProps, newData, loggers) {
     const props = Reflect.getMetadata("props", target) || [];
     for (const prop of props) {
         const path = prefix ? `${prefix}.${prop}` : prop;
@@ -1085,19 +532,17 @@ export function processIsRefProperties(instance, target, prefix = null, allProps
         if (Reflect.getMetadata("isRef", target, prop)) {
             if (Array.isArray(instance[prop]))
                 newData[prop] = instance[prop]
-                    .map((item) => item?._id?.toString() ?? item?.toString() ?? undefined)
+                    .map((item) => item?._id?.toString() ?? item?.toString())
                     .filter(Boolean);
             else
                 newData[prop] =
-                    instance[prop]?._id?.toString() ??
-                        instance[prop]?.toString() ??
-                        undefined;
+                    instance[prop]?._id?.toString() ?? instance[prop]?.toString();
         }
         const type = Reflect.getMetadata("design:type", target, prop);
         if (type?.prototype) {
             const nestedProps = Reflect.getMetadata("props", type.prototype);
             if (nestedProps && instance[prop]) {
-                newData[prop] = processIsRefProperties(instance[prop], type.prototype, path, allProps, undefined, loggers).newData;
+                newData[prop] = processIsRefProperties(instance[prop], type.prototype, path, allProps, {}, loggers).newData;
             }
         }
     }