@prestizni-software/client-dem 0.5.8 → 0.5.9

package/dist/AutoUpdatedClientObjectClass.js

@@ -1,23 +1,22 @@
 import "reflect-metadata";
 import _ from "lodash";
-import { EVENT_INTERNAL_PRE_LOADED, EVENT_DELETE, EVENT_GET, EVENT_NEW, EVENT_UPDATE, globalCache, } from "./CommonTypes.js";
+import { EVENT_INTERNAL_PRE_LOADED, EVENT_DELETE, EVENT_GET, EVENT_NEW, EVENT_UPDATE, globalCache, } from "./CommonTypes";
 import { ObjectId } from "bson";
 export class AutoUpdatedClientObject {
     entry;
     preLoad;
     registerSocket;
     readyLoggers;
-    loadFromDB(a) {
-        return a;
-    }
+    loadFromDB(a) { }
+    setValue_(a, b) { }
     socket;
     data;
     isServer = false;
     loggers;
     isLoading = true;
+    loadError;
     isLoadingReferences = true;
     checkedMissingRefs = false;
-    isDestroyed = false;
     emitter;
     properties;
     classParam;
@@ -26,7 +25,6 @@ export class AutoUpdatedClientObject {
     EmitterID = new ObjectId().toHexString();
     toChangeOnParents = [];
     callbacks;
-    preloadTimers = new Set();
     loadReferencesAsync = async () => {
         try {
             if (!this.isLoaded) {
@@ -35,14 +33,11 @@ export class AutoUpdatedClientObject {
             this.generateSettersAndGetters();
             await this.loadForceReferences();
             for (const thing of this.toChangeOnParents) {
-                await this.setValue(thing.key, thing.value, {
-                    silent: true,
-                    isParentUpdate: true,
-                });
+                await this.setValue__(thing.key, thing.value, true, false, false, true);
             }
         }
         catch (error) {
-            // this.loggers?.error?.("Error loading references: " + error.message);
+            this.loggers.error?.("Error loading references: " + error.message);
         }
         finally {
             this.isLoadingReferences = false;
@@ -66,8 +61,18 @@ export class AutoUpdatedClientObject {
             this.parentManager = parentManager;
             this.callbacks = callback;
             this.emitter = emitter;
-            this.properties = [];
-            return;
+            this.properties = undefined;
+            if (!classParam &&
+                !socket &&
+                !data &&
+                !loggers &&
+                !className &&
+                !parentManager &&
+                !callback &&
+                !emitter)
+                return;
+            else
+                throw new Error("Missing arguments???");
         }
         this.classParam = classParam;
         this.socket = socket;
@@ -78,126 +83,95 @@ export class AutoUpdatedClientObject {
         this.parentManager = parentManager;
         this.className = className;
         const allProps = new Set();
-        let proto = classParam.prototype;
-        while (proto && proto !== Object.prototype) {
-            const props = Reflect.getOwnMetadata("props", proto);
-            if (props) {
-                for (const p of props)
-                    allProps.add(p);
-            }
-            proto = Object.getPrototypeOf(proto);
+        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 || {
-            new: () => { },
-            update: () => { },
-            delete: () => { },
-            progress: () => { },
+        this.callbacks = callback;
+        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}`),
         };
-        try {
-            if (typeof data === "string") {
-                this.data = { _id: data };
-            }
-            else {
-                this.data = data;
+        if (typeof data === "string") {
+            this.data = { _id: data };
+            if (this.isServer) {
+                this.isLoading = false;
+                this.generateSettersAndGetters();
+                return;
             }
-            const currentId = this.data?._id?.toString() ?? "not loaded";
-            this.loggers = {
-                debug: (s) => loggers.debug?.(`[${this.className}: ${currentId}] ${s}`),
-                info: (s) => loggers.info?.(`[${this.className}: ${currentId}] ${s}`),
-                warn: (s) => loggers.warn?.(`[${this.className}: ${currentId}] ${s}`),
-                error: (s) => loggers.error?.(`[${this.className}: ${currentId}] ${s}`),
-            };
-            if (typeof data === "string") {
-                if (this.isServer) {
+            this.socket.emit(EVENT_GET + this.className + data, null, (res) => {
+                if (!res.success) {
                     this.isLoading = false;
-                    this.generateSettersAndGetters();
-                    this.emitter.emit(EVENT_INTERNAL_PRE_LOADED + this.EmitterID);
+                    this.loadError = res.message;
+                    this.loggers.error?.("Could not load data from server: " + res.message);
+                    this.emitter.emit(EVENT_INTERNAL_PRE_LOADED + this.EmitterID, true, res.message);
                     return;
                 }
-                this.socket.emit(EVENT_GET + this.className + data, null, async (res) => {
-                    if (this.isDestroyed)
-                        return;
-                    if (!res.success) {
-                        this.isLoading = false;
-                        this.emitter.emit(EVENT_INTERNAL_PRE_LOADED + this.EmitterID, true, res.message);
-                        return;
-                    }
-                    this.data = res.data;
-                    this.generateSettersAndGetters();
-                    this.isLoading = false;
-                    await this.onUpdate();
-                    this.emitter.emit(EVENT_INTERNAL_PRE_LOADED + this.EmitterID);
-                    this.openSockets();
-                });
-            }
-            else {
-                const currentDataRec = this.data;
-                for (const key of this.properties) {
-                    const isRef = getMetadataRecursive("isRef", this, key);
-                    if (isRef && currentDataRec[key]) {
-                        if (Array.isArray(currentDataRec[key])) {
-                            currentDataRec[key] = currentDataRec[key].map((obj) => obj._id?.toString() ?? obj?.toString());
-                        }
-                        else {
-                            currentDataRec[key] =
-                                currentDataRec[key]?._id?.toString() ??
-                                    currentDataRec[key]?.toString();
-                        }
+                this.data = res.data;
+                this.generateSettersAndGetters();
+                this.isLoading = false;
+                this.emitter.emit(EVENT_INTERNAL_PRE_LOADED + this.EmitterID);
+                this.openSockets();
+            });
+        }
+        else {
+            this.isLoading = true;
+            this.data = data;
+            for (const key of this.properties || []) {
+                const isRef = getMetadataRecursive("isRef", this, key);
+                if (isRef && this.data[key]) {
+                    if (Array.isArray(this.data[key])) {
+                        this.data[key] = this.data[key].map((obj) => obj._id?.toString() ?? obj?.toString());
                     }
-                }
-                if ((!currentDataRec["_id"] || currentDataRec["_id"] === "") &&
-                    !this.isServer) {
-                    this.isLoading = true;
-                    this.handleNewObject(this.data);
-                }
-                else {
-                    this.isLoading = false;
-                    this.emitter.emit(EVENT_INTERNAL_PRE_LOADED + this.EmitterID);
-                    if (!this.isServer) {
-                        this.openSockets();
-                        this.onUpdate();
+                    else {
+                        this.data[key] =
+                            this.data[key]?._id?.toString() ??
+                                this.data[key]?.toString();
                     }
                 }
             }
-            this.generateSettersAndGetters();
-            // Ensure setters/getters are set after child constructor
-            Promise.resolve().then(() => {
-                if (!this.isDestroyed)
-                    this.generateSettersAndGetters();
-            });
-            if (!this.isServer && !this.isLoaded) {
-                this.loadShit();
+            if ((!this.data._id || this.data._id === "") &&
+                !this.isServer) {
+                this.handleNewObject(data);
+            }
+            else {
+                this.isLoading = false;
+                if (!this.isServer)
+                    this.openSockets();
             }
         }
-        catch (e) {
-            this.destroyImmediate();
-            throw e;
-        }
+        this.generateSettersAndGetters();
+        Promise.resolve().then(() => {
+            this.generateSettersAndGetters();
+        });
     }
     async waitForPreloaded() {
+        if (this.loadError)
+            throw new Error(this.loadError);
         if (this.isLoaded)
             return;
-        return new Promise((resolve, reject) => {
-            const onPreloaded = (failed, reason) => {
+        await new Promise((resolve, reject) => {
+            this.emitter.once(EVENT_INTERNAL_PRE_LOADED + this.EmitterID, (failed, reason) => {
                 if (failed)
                     reject(new Error(reason));
                 else
                     resolve();
-            };
-            this.emitter.once(EVENT_INTERNAL_PRE_LOADED + this.EmitterID, onPreloaded);
+            });
         });
     }
     handleNewObject(data) {
         this.isLoading = true;
-        if (!this.socket || typeof this.socket.emit !== "function") {
-            this.isLoading = false;
-            this.emitter.emit(EVENT_INTERNAL_PRE_LOADED + this.EmitterID, true, "Socket not available");
-            return;
-        }
         this.socket.emit(EVENT_NEW + this.className, data, (res) => {
             if (!res.success) {
                 this.isLoading = false;
+                this.loadError = res.message;
+                this.loggers.error?.("Could not create data on server: " + res.message);
                 this.emitter.emit(EVENT_INTERNAL_PRE_LOADED + this.EmitterID, true, res.message);
                 return;
             }
@@ -211,45 +185,38 @@ export class AutoUpdatedClientObject {
     }
     get extractedData() {
         const extracted = processIsRefProperties(this.data, this, null, [], {}, this.loggers).newData;
-        return extracted;
+        return _.cloneDeep(extracted);
     }
     get isLoaded() {
         return !this.isLoading;
     }
     async isPreLoadedAsync() {
-        await this.waitForPreloaded();
+        await this.loadShit();
         return true;
     }
     async loadMissingReferences() {
-        this.loggers.debug?.(`loadMissingReferences for ${this.className}:${this._id}`);
         await this.checkForMissingRefs();
         this.generateSettersAndGetters();
     }
     openSockets() {
-        const dataRec = this.data;
-        const id = dataRec["_id"];
-        if (!id || !this.socket || typeof this.socket.on !== "function")
-            return;
+        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)
+            if (ack && typeof ack === "function")
                 ack(res);
             return res;
         });
     }
     async handleUpdateRequest(update) {
         try {
-            await this.setValue(update.key, update.value, {
-                silent: true,
-            });
+            await this.setValue__(update.key, update.value, true);
             if (this.isLoaded)
                 this.callbacks.update(this, update.key);
             return { success: true, data: undefined, message: "" };
         }
         catch (error) {
-            const dataRec = this.data;
-            this.loggers.error?.(`[${dataRec["_id"]?.toString()}] Error applying patch: ${error.message}`);
+            this.loggers.error?.(`[${this.data._id}] Error applying patch: ${error.message}`);
             return {
                 success: false,
                 message: "Error applying update: " + error.message,
@@ -263,10 +230,14 @@ export class AutoUpdatedClientObject {
             if (typeof key !== "string")
                 continue;
             const isRef = getMetadataRecursive("isRef", this, key);
+            delete this[key];
             Object.defineProperty(this, key, {
                 get: () => {
-                    const dataRec = this.data;
-                    let val = dataRec ? dataRec[key] : undefined;
+                    if (!this.data)
+                        return undefined;
+                    let val = this.data[key];
+                    if (val === null)
+                        val = undefined;
                     if (isRef && val) {
                         if (Array.isArray(val)) {
                             return val
@@ -290,36 +261,43 @@ export class AutoUpdatedClientObject {
     }
     getValue(key_) {
         const key = key_;
-        const dataRec = this.data;
-        return this[key] === undefined
-            ? dataRec
-                ? dataRec[key_]
-                : undefined
-            : this[key_];
+        const parts = key.split(".");
+        let value = this;
+        for (const part of parts) {
+            if (value === undefined || value === null)
+                return undefined;
+            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 (!id || !this.parentManager)
+        if (!id)
             return undefined;
         const idStr = id.toString();
-        const cacheRec = this.parentManager.cache.references;
-        if (cacheRec[key]) {
-            const obj = cacheRec[key].getObject(idStr);
-            if (obj)
-                return obj;
-        }
+        if (this.parentManager.cache.references[key])
+            return this.parentManager.cache.references[key].getObject(idStr);
         for (const manager of Object.values(this.parentManager.managers)) {
             const result = manager.getObject(idStr);
             if (result) {
-                this.loggers.debug?.(`findReference: Resolved ${idStr} for ${key} in manager ${manager.className}`);
-                cacheRec[key] = manager;
+                this.parentManager.cache.references[key] = manager;
                 return result;
             }
         }
-        this.loggers.warn?.(`findReference: Could NOT resolve ${idStr} for property ${key} in any manager.`);
         return undefined;
     }
-    async setValue(key, val, options = {}) {
-        const { silent = false, noUpdate = false, isParentUpdate = false, } = options;
+    async setValue(key, val) {
+        return await this.setValue__(key, val);
+    }
+    async setValue__(key, val, silent = false, noGet = false, noUpdate = false, isParentUpdate = false) {
         try {
             const isRef = getMetadataRecursive("isRef", this, key);
             const pointer = getMetadataRecursive("refsTo", this, key);
@@ -330,18 +308,39 @@ export class AutoUpdatedClientObject {
             if (isRef) {
                 valueToStore = Array.isArray(val)
                     ? val.map((v) => v._id?.toString() ?? v.toString())
-                    : (val?._id?.toString() ?? val?.toString() ?? val);
+                    : val?._id ?? val?.toString() ?? val;
             }
-            const dataRec = this.data;
-            const currentVal = dataRec ? dataRec[key] : undefined;
-            if (_.isEqual(currentVal, valueToStore))
+            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(".");
+            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);
+                    }
+                    obj = obj[currentKey];
+                }
+            }
             const res = await this.setValueInternal(key, valueToStore, silent, noUpdate);
             if (res.success) {
-                if (this.data)
-                    this.data[key] = valueToStore;
+                const pathArr = key.split(".");
+                let obj = this.data;
+                for (let i = 0; i < pathArr.length - 1; i++) {
+                    obj = obj[pathArr[i]];
+                }
+                obj[pathArr[pathArr.length - 1]] = valueToStore;
                 await this.findAndLoadReferences(key, valueToStore);
-                if (isRef && this.parentManager && this.parentManager.isLoaded)
+                if (isRef && this.parentManager.isLoaded)
                     await this.contactChildren();
                 if (this.isLoaded)
                     this.callbacks.update(this, key);
@@ -357,17 +356,11 @@ export class AutoUpdatedClientObject {
         }
     }
     async setValueInternal(key, value, silent = false, noUpdate = false) {
-        if (silent || noUpdate)
-            return { success: true, msg: "Silent or no update" };
+        if (silent)
+            return { success: true, msg: "Silent" };
         return new Promise((resolve) => {
-            const dataRec = this.data;
-            const id = dataRec ? dataRec["_id"] : undefined;
-            if (!id)
-                return resolve({ success: false, msg: "Missing _id" });
-            if (!this.socket || typeof this.socket.emit !== "function") {
-                return resolve({ success: false, msg: "Socket not available" });
-            }
-            this.socket.emit(EVENT_UPDATE + this.className + id.toString(), { _id: id.toString(), key, value }, (res) => {
+            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"),
@@ -376,17 +369,14 @@ export class AutoUpdatedClientObject {
         });
     }
     makeUpdate(key, value) {
-        const dataRec = this.data;
-        const id = dataRec ? dataRec["_id"] : undefined;
+        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.`);
         }
-        return { _id: id, key, value };
+        return { _id: id.toString(), key, value };
     }
     async resolveReference(id) {
-        if (!this.parentManager)
-            return null;
         for (const manager of Object.values(this.parentManager.managers)) {
             const obj = manager.getObject(id);
             if (obj)
@@ -396,7 +386,7 @@ export class AutoUpdatedClientObject {
     }
     async findAndLoadReferences(lastPath, value) {
         const isRef = getMetadataRecursive("isRef", this, lastPath);
-        if (isRef && this.parentManager) {
+        if (isRef) {
             for (const id of Array.isArray(value) ? value : [value]) {
                 if (!id)
                     continue;
@@ -413,60 +403,48 @@ export class AutoUpdatedClientObject {
         }
     }
     async wipeSelf() {
-        const dataRec = this.data;
-        if (!dataRec || dataRec["Wiped"])
+        if (this.data.Wiped)
             return;
-        const id = dataRec["_id"];
+        const id = this.data?._id ?? this._id;
         const _id = id ? id.toString() : "unknown";
-        for (const key of Object.keys(dataRec)) {
-            delete dataRec[key];
+        for (const key of Object.keys(this.data)) {
+            delete this.data[key];
         }
-        dataRec["Wiped"] = true;
+        this.data = { Wiped: true };
         this.loggers.info?.(`[${_id}] ${this.className} object wiped`);
     }
+    destroyImmediate() {
+        this.wipeSelf();
+    }
     async loadForceReferences(obj = this.data, proto = this, alreadySeen = []) {
-        if (!obj)
-            return;
-        if (obj === this.data) {
-            const dataRec = this.data;
-            const myId = dataRec["_id"]?.toString();
-            if (myId && !alreadySeen.includes(myId))
-                alreadySeen.push(myId);
-        }
         const props = Reflect.getMetadata("props", proto) || [];
         for (const key of props) {
+            if (typeof key !== "string")
+                continue;
             const isRef = Reflect.getMetadata("isRef", proto, key);
             const pointer = Reflect.getMetadata("refsTo", proto, key);
-            const objRec = obj;
             if (pointer &&
                 obj === this.data &&
-                objRec[key] &&
-                !alreadySeen.includes(JSON.stringify(obj))) {
-                await this.createdWithParent(pointer.split(":"), objRec[key]);
+                obj[key] &&
+                !alreadySeen.includes(obj)) {
+                await this.createdWithParent(pointer.split(":"), obj[key]);
             }
-            if (objRec[key] && !alreadySeen.includes(objRec[key]))
-                alreadySeen.push(objRec[key]);
+            if (obj[key] && !alreadySeen.includes(obj[key]))
+                alreadySeen.push(obj[key]);
             if (isRef)
                 await this.handleLoad(obj, key, alreadySeen);
-            const val = objRec[key];
+            const val = obj[key];
             if (val && typeof val === "object") {
                 const nestedProto = Object.getPrototypeOf(val);
-                if (nestedProto &&
-                    nestedProto !== Object.prototype &&
-                    !alreadySeen.includes(JSON.stringify(val))) {
-                    alreadySeen.push(JSON.stringify(val));
+                if (nestedProto && !alreadySeen.includes(val)) {
+                    alreadySeen.push(val);
                     await this.loadForceReferences(val, nestedProto, alreadySeen);
                 }
             }
         }
     }
     async handleLoad(obj, key, alreadySeen) {
-        if (!this.parentManager)
-            return;
-        const objRec = obj;
-        const refIds = Array.isArray(objRec[key])
-            ? objRec[key]
-            : [objRec[key]];
+        const refIds = Array.isArray(obj[key]) ? obj[key] : [obj[key]];
         for (const refId of refIds) {
             if (refId) {
                 const idStr = refId.toString();
@@ -485,82 +463,38 @@ export class AutoUpdatedClientObject {
             }
         }
     }
-    async onUpdate(noUpdate = false) {
-        if (noUpdate)
-            return;
-        try {
-            await this.callbacks?.onUpdate?.(this, (key, val) => {
-                return this.setValue(key, val, {
-                    silent: false,
-                    noGet: true,
-                    noUpdate: true,
-                });
-            });
-        }
-        catch (error) {
-            this.loggers.error(`[onUpdate] ${error}`);
-        }
-    }
     async createdWithParent(pointer, parent) {
-        if (pointer.length !== 2 || !this.parentManager)
+        if (pointer.length !== 2)
             return;
         const parentId = parent._id?.toString() ?? parent.toString();
-        const ac = this.parentManager.managers[pointer[0]];
-        if (!ac)
-            return;
-        const obj = ac.getObject(parentId);
+        const obj = this.parentManager.managers[pointer[0]]?.getObject(parentId);
         if (!obj)
             return;
         const val = obj.getValue(pointer[1]);
-        const dataRec = this.data;
-        const myId = dataRec["_id"]?.toString();
-        if (!myId)
-            return;
+        const myId = this.data._id.toString();
         if (Array.isArray(val)) {
             const ids = val.map((v) => v._id?.toString() ?? v.toString());
             if (!ids.includes(myId)) {
-                await obj.setValue(pointer[1], [...val, myId], { silent: true, isParentUpdate: true });
+                await obj.setValue__(pointer[1], [...val, myId], true, false, false, true);
             }
         }
         else if ((val?._id?.toString() ?? val?.toString()) !== myId) {
-            await obj.setValue(pointer[1], myId, {
-                silent: true,
-                isParentUpdate: true,
-            });
+            await obj.setValue__(pointer[1], myId, true, false, false, true);
         }
     }
     async destroy(once = false) {
-        for (const timer of this.preloadTimers) {
-            clearTimeout(timer);
-        }
-        this.preloadTimers.clear();
-        const dataRec = this.data;
-        const id = dataRec ? dataRec["_id"] : undefined;
-        if (!id)
-            return { success: false, message: "Missing _id" };
-        if (!once && this.parentManager)
-            return await this.parentManager.deleteObject(id);
+        if (!once)
+            return await this.parentManager.deleteObject(this.data._id);
         return new Promise((resolve) => {
-            if (!this.socket || typeof this.socket.emit !== "function") {
-                return resolve({ success: false, message: "Socket not available" });
-            }
-            this.socket.emit(EVENT_DELETE + this.className, id.toString(), (res) => {
+            this.socket.emit(EVENT_DELETE + this.className, this.data._id, (res) => {
                 resolve({ success: res.success, message: res.message ?? "" });
             });
         });
     }
-    destroyImmediate() {
-        this.isDestroyed = true;
-        for (const timer of this.preloadTimers) {
-            clearTimeout(timer);
-        }
-        this.preloadTimers.clear();
-        this.isLoading = false;
-    }
     async checkForMissingRefs() {
         for (const prop of this.properties) {
             const pointer = getMetadataRecursive("refsTo", this, prop.toString());
-            if (typeof pointer === "string") {
+            if (pointer) {
                 const parts = pointer.split(":");
                 if (parts.length === 2)
                     await this.findMissingObjectReference(prop, parts);
@@ -568,22 +502,14 @@ export class AutoUpdatedClientObject {
         }
     }
     async findMissingObjectReference(prop, pointer) {
-        if (this.checkedMissingRefs || !this.parentManager)
+        if (this.checkedMissingRefs)
             return;
         this.checkedMissingRefs = true;
         const ac = this.parentManager.managers[pointer[0]];
-        if (!ac) {
-            this.loggers.warn?.(`findMissingObjectReference: Manager ${pointer[0]} not found for pointer ${pointer.join(":")}`);
-            return;
-        }
-        const dataRec = this.data;
-        const targetId = dataRec
-            ? dataRec["_id"]?.toString()
-            : undefined;
-        if (!targetId)
+        if (!ac)
             return;
+        const targetId = this.data._id.toString();
         const allObjects = Object.values(ac.objects);
-        this.loggers.debug?.(`findMissingObjectReference: Checking ${allObjects.length} objects in ${pointer[0]} for child link on ${pointer[1]}`);
         for (const obj of allObjects) {
             if (!obj.isLoaded)
                 await obj.waitForPreloaded();
@@ -594,56 +520,30 @@ export class AutoUpdatedClientObject {
                 ? val.map((v) => v._id?.toString() ?? v.toString())
                 : [val._id?.toString() ?? val.toString()];
             if (ids.includes(targetId)) {
-                this.loggers.info?.(`findMissingObjectReference: Found parent ${obj.className}:${obj._id} for property ${prop}`);
-                dataRec[prop] = obj._id;
+                this.data[prop] = obj._id;
                 return;
             }
         }
-        this.loggers.debug?.(`findMissingObjectReference: Finished checking ${pointer[0]} for ${targetId}, no parent found yet.`);
-    }
-    async resolveReferences() {
-        this.loggers.debug?.(`Starting resolveReferences for ${this.className}:${this._id}`);
-        await this.loadMissingReferences();
-        await this.contactChildren();
-        this.loggers.debug?.(`Finished resolveReferences for ${this.className}:${this._id}`);
     }
     async contactChildren() {
-        if (!this.parentManager)
-            return;
-        this.loggers.debug?.(`contactChildren for ${this.className}:${this._id}`);
         for (const prop of this.properties) {
             const isRef = getMetadataRecursive("isRef", this, prop.toString());
             const pointer = getMetadataRecursive("refsTo", this, prop.toString());
             if (!isRef || pointer)
                 continue;
-            const val = this.getValue(prop);
-            if (!val)
+            const obj = this.getValue(prop);
+            if (!obj)
                 continue;
-            const idsOrObjs = Array.isArray(val) ? val : [val];
-            for (const item of idsOrObjs) {
-                if (!item)
-                    continue;
-                let childObj = item;
-                if (typeof item === "string" || item instanceof ObjectId) {
-                    const idStr = item.toString();
-                    this.loggers.debug?.(`contactChildren searching for child ${idStr} (prop: ${prop})`);
-                    for (const manager of Object.values(this.parentManager.managers)) {
-                        childObj = manager.getObject(idStr);
-                        if (childObj)
-                            break;
-                    }
-                }
-                if (childObj &&
-                    typeof childObj.loadMissingReferences === "function") {
-                    this.loggers.debug?.(`contactChildren triggering resolution for child ${childObj.className}:${childObj._id}`);
-                    await childObj.loadMissingReferences();
-                }
-                else if (!childObj) {
-                    this.loggers.warn?.(`contactChildren could NOT find child ${item} for property ${prop}`);
+            const children = Array.isArray(obj) ? obj : [obj];
+            for (const child of children) {
+                if (child && typeof child.loadMissingReferences === "function") {
+                    await child.loadMissingReferences();
                 }
             }
         }
-        this.generateSettersAndGetters();
+    }
+    async onUpdate() {
+        // Placeholder for server-side override
     }
 }
 export function processIsRefProperties(instance, target, prefix, allProps, newData, loggers) {
@@ -651,8 +551,6 @@ export function processIsRefProperties(instance, target, prefix, allProps, newDa
     for (const prop of props) {
         const path = prefix ? `${prefix}.${prop}` : prop;
         allProps.push(path);
-        if (!instance)
-            continue;
         newData[prop] = ObjectId.isValid(instance[prop])
             ? instance[prop]?.toString()
             : instance[prop];
@@ -667,16 +565,18 @@ export function processIsRefProperties(instance, target, prefix, allProps, newDa
         }
         const type = Reflect.getMetadata("design:type", target, prop);
         if (type?.prototype) {
-            // DO NOT RECURSE into nested prototypes to avoid circularity issues
+            const nestedProps = Reflect.getMetadata("props", type.prototype);
+            if (nestedProps && instance[prop]) {
+                newData[prop] = processIsRefProperties(instance[prop], type.prototype, path, allProps, {}, loggers).newData;
+            }
         }
     }
     return { allProps, newData };
 }
-export function getMetadataRecursive(metaKey, target, prop) {
-    let proto = target;
+export function getMetadataRecursive(metaKey, proto, prop) {
     while (proto) {
         const meta = Reflect.getMetadata(metaKey, proto, prop);
-        if (meta !== undefined)
+        if (meta)
             return meta;
         proto = Object.getPrototypeOf(proto);
     }