@prestizni-software/server-dem 0.4.94 → 0.4.96

package/dist/AutoUpdatedClientObjectClass.d.ts

@@ -1,29 +1,26 @@
 import "reflect-metadata";
-import { Constructor, EventEmitter3, IsData, LoggersType, PathValueOf, ServerUpdateRequest, Paths, ExtractedData } from "./CommonTypes.js";
-import { ObjectId } from "bson";
-import { Socket } from "socket.io-client";
+import { Constructor, EventEmitter3, IsData, LoggersType, PathValueOf, ServerUpdateRequest, MongoId, IDEMSocket } from "./CommonTypes.js";
 import { AutoUpdateManager } from "./AutoUpdateManagerClass.js";
-export type DEMClientCallbacks<T extends AutoUpdatedClientObject<T>> = {
+export type DEMClientCallbacks<T extends AutoUpdatedClientObject<T, any>> = {
     new: (obj: T) => Promise<void> | void;
     update: (obj: T, key: string) => Promise<void> | void;
     delete: (obj: T) => Promise<void> | void;
     progress: (percent: number) => void;
-    onUpdate?: (obj: T, set: <K extends Paths<T>>(key: K, val: PathValueOf<IsData<T>, K>) => Promise<{
+    onUpdate?: (obj: T, set: <K extends keyof IsData<T> & string>(key: K, val: PathValueOf<IsData<T>, K>) => Promise<{
         success: boolean;
         msg: string;
     }>) => Promise<void>;
 };
-type SocketType = Socket<any, any>;
-export declare abstract class AutoUpdatedClientObject<T extends AutoUpdatedClientObject<T>> {
-    protected entry: any;
-    preLoad: any;
-    registerSocket: any;
-    readyLoggers: any;
-    loadFromDB(a: any): any;
-    protected readonly socket: SocketType;
+export declare abstract class AutoUpdatedClientObject<T extends AutoUpdatedClientObject<T, any>, M extends Record<string, any> = any> {
+    protected entry: unknown;
+    preLoad: unknown;
+    registerSocket: unknown;
+    readyLoggers: unknown;
+    loadFromDB(a: unknown): unknown;
+    protected readonly socket: IDEMSocket;
     protected data: IsData<T>;
     protected readonly isServer: boolean;
-    abstract readonly _id: any;
+    abstract readonly _id: MongoId;
     protected readonly loggers: LoggersType;
     protected isLoading: boolean;
     protected isLoadingReferences: boolean;
@@ -32,29 +29,31 @@ export declare abstract class AutoUpdatedClientObject<T extends AutoUpdatedClien
     readonly properties: (keyof IsData<T> & string)[];
     readonly classParam: Constructor<T>;
     readonly className: string;
-    parentManager: AutoUpdateManager<T>;
+    parentManager: AutoUpdateManager<T, M>;
     private readonly EmitterID;
     protected readonly toChangeOnParents: {
         key: string;
-        value: any;
+        value: unknown;
     }[];
     callbacks: DEMClientCallbacks<T>;
     private readonly loadReferencesAsync;
     /** @deprecated Use loadReferencesAsync instead */
     private readonly loadShit;
-    constructor(classParam?: Constructor<T>, socket?: SocketType, data?: string | IsData<T>, loggers?: LoggersType, className?: string, parentManager?: AutoUpdateManager<T>, callback?: DEMClientCallbacks<T>, emitter?: EventEmitter3, isServer?: boolean);
+    constructor(classParam?: Constructor<T>, socket?: IDEMSocket, data?: string | IsData<T>, loggers?: LoggersType, className?: string, parentManager?: AutoUpdateManager<T, M>, callback?: DEMClientCallbacks<T>, emitter?: EventEmitter3, isServer?: boolean);
     waitForPreloaded(): Promise<void>;
     protected handleNewObject(data: IsData<T>): void;
-    get extractedData(): ExtractedData<T, never>;
+    get extractedData(): {
+        [K in keyof IsData<T>]: unknown;
+    };
     get isLoaded(): boolean;
     isPreLoadedAsync(): Promise<boolean>;
     loadMissingReferences(): Promise<void>;
     private openSockets;
     private handleUpdateRequest;
     protected generateSettersAndGetters(): void;
-    getValue(key_: Paths<T>): any;
-    protected findReference(id: string | ObjectId, key: string): any;
-    setValue<K extends Paths<T>>(key: K, val: PathValueOf<IsData<T>, K>, options?: {
+    getValue(key_: keyof IsData<T> & string): unknown;
+    protected findReference(id: string | MongoId, key: string): unknown;
+    setValue<K extends keyof IsData<T> & string>(key: K, val: PathValueOf<IsData<T>, K>, options?: {
         silent?: boolean;
         noGet?: boolean;
         noUpdate?: boolean;
@@ -63,12 +62,12 @@ export declare abstract class AutoUpdatedClientObject<T extends AutoUpdatedClien
         success: boolean;
         msg: string;
     }>;
-    protected setValueInternal(key: string, value: any, silent?: boolean, noUpdate?: boolean): Promise<{
+    protected setValueInternal(key: string, value: unknown, silent?: boolean, noUpdate?: boolean): Promise<{
         success: boolean;
         msg: string;
     }>;
-    protected makeUpdate(key: string, value: any): ServerUpdateRequest<T>;
-    protected resolveReference(id: string): Promise<AutoUpdatedClientObject<any> | null>;
+    protected makeUpdate(key: string, value: unknown): ServerUpdateRequest<T>;
+    protected resolveReference(id: string): Promise<AutoUpdatedClientObject<any, any> | null>;
     private findAndLoadReferences;
     protected wipeSelf(): Promise<void>;
     private loadForceReferences;
@@ -83,9 +82,8 @@ export declare abstract class AutoUpdatedClientObject<T extends AutoUpdatedClien
     private findMissingObjectReference;
     contactChildren(): Promise<void>;
 }
-export declare function processIsRefProperties(instance: any, target: any, prefix: string | null, allProps: string[], newData: any, loggers: LoggersType): {
+export declare function processIsRefProperties(instance: Record<string, any>, target: object, prefix: string | null, allProps: string[], newData: Record<string, unknown>, loggers: LoggersType): {
     allProps: string[];
-    newData: any;
+    newData: Record<string, unknown>;
 };
-export declare function getMetadataRecursive(metaKey: string, proto: any, prop: string): any;
-export {};
+export declare function getMetadataRecursive(metaKey: string, target: object, prop: string): unknown;

package/dist/AutoUpdatedClientObjectClass.js

@@ -7,7 +7,7 @@ export class AutoUpdatedClientObject {
     preLoad;
     registerSocket;
     readyLoggers;
-    loadFromDB(a) { }
+    loadFromDB(a) { return a; }
     socket;
     data;
     isServer = false;
@@ -35,7 +35,7 @@ export class AutoUpdatedClientObject {
             }
         }
         catch (error) {
-            this.loggers.error("Error loading references: " + error.message);
+            // this.loggers?.error?.("Error loading references: " + error.message);
         }
         finally {
             this.isLoadingReferences = false;
@@ -59,18 +59,8 @@ export class AutoUpdatedClientObject {
             this.parentManager = parentManager;
             this.callbacks = callback;
             this.emitter = emitter;
-            this.properties = undefined;
-            if (!classParam &&
-                !socket &&
-                !data &&
-                !loggers &&
-                !className &&
-                !parentManager &&
-                !callback &&
-                !emitter)
-                return;
-            else
-                throw new Error("Missing arguments???");
+            this.properties = [];
+            return;
         }
         this.classParam = classParam;
         this.socket = socket;
@@ -83,31 +73,44 @@ export class AutoUpdatedClientObject {
         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);
+            const props = Reflect.getOwnMetadata("props", proto);
+            if (props) {
+                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(`[${this.className}: ${this.data?._id ?? this._id ?? "not loaded"}] ${s}`),
-            info: (s) => loggers.info(`[${this.className}: ${this.data?._id ?? this._id ?? "not loaded"}] ${s}`),
-            warn: (s) => loggers.warn(`[${this.className}: ${this.data?._id ?? this._id ?? "not loaded"}] ${s}`),
-            error: (s) => loggers.error(`[${this.className}: ${this.data?._id ?? this._id ?? "not loaded"}] ${s}`),
+        this.callbacks = callback || {
+            new: () => { },
+            update: () => { },
+            delete: () => { },
+            progress: () => { },
         };
         if (typeof data === "string") {
             this.data = { _id: data };
+        }
+        else {
+            this.data = data;
+        }
+        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.isLoading = false;
                 this.generateSettersAndGetters();
+                this.emitter.emit(EVENT_INTERNAL_PRE_LOADED + this.EmitterID);
                 return;
             }
             this.socket.emit(EVENT_GET + this.className + data, null, async (res) => {
                 if (!res.success) {
                     this.isLoading = false;
-                    this.loggers.error("Could not load data from server: " + res.message);
-                    this.emitter.emit(EVENT_INTERNAL_PRE_LOADED + this.EmitterID);
+                    this.emitter.emit(EVENT_INTERNAL_PRE_LOADED + this.EmitterID, true, res.message);
                     return;
                 }
                 this.data = res.data;
@@ -119,44 +122,46 @@ export class AutoUpdatedClientObject {
             });
         }
         else {
-            this.isLoading = true;
-            this.data = data;
-            for (const key of this.properties || []) {
+            const currentDataRec = this.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 (isRef && currentDataRec[key]) {
+                    if (Array.isArray(currentDataRec[key])) {
+                        currentDataRec[key] = currentDataRec[key].map((obj) => obj._id?.toString() ?? obj?.toString());
                     }
                     else {
-                        this.data[key] = this.data[key]?._id?.toString() ?? this.data[key]?.toString();
+                        currentDataRec[key] = currentDataRec[key]?._id?.toString() ?? currentDataRec[key]?.toString();
                     }
                 }
             }
-            if ((!this.data._id || this.data._id === "") && !this.isServer) {
+            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(); // Client load/creation trigger
+                    this.onUpdate();
                 }
             }
         }
         this.generateSettersAndGetters();
-        // Re-apply getters in a microtask to override any shadowing from subclass field initializers.
+        // Ensure setters/getters are set after child constructor
         Promise.resolve().then(() => {
             this.generateSettersAndGetters();
         });
+        if (!this.isServer) {
+            this.loadShit();
+        }
     }
     async waitForPreloaded() {
         if (this.isLoaded)
             return;
-        // console.log(`[DEBUG] ${this.className} Waiting for preloaded - ID: ${this.data?._id ?? (this as any)._id}`);
         await new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
-                console.error(`[FATAL] ${this.className} TIMEOUT waiting for preloaded - ID: ${this.data?._id ?? this._id}`);
-                reject(new Error("Timeout waiting for preloaded"));
+                reject(new Error(`Timeout waiting for preloaded: ${this.className}`));
             }, 10000);
             this.emitter.once(EVENT_INTERNAL_PRE_LOADED + this.EmitterID, (failed, reason) => {
                 clearTimeout(timer);
@@ -169,10 +174,14 @@ export class AutoUpdatedClientObject {
     }
     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.loggers.error("Could not create data on server: " + res.message);
                 this.emitter.emit(EVENT_INTERNAL_PRE_LOADED + this.EmitterID, true, res.message);
                 return;
             }
@@ -186,13 +195,13 @@ export class AutoUpdatedClientObject {
     }
     get extractedData() {
         const extracted = processIsRefProperties(this.data, this, null, [], {}, this.loggers).newData;
-        return _.cloneDeep(extracted);
+        return extracted;
     }
     get isLoaded() {
         return !this.isLoading;
     }
     async isPreLoadedAsync() {
-        await this.loadShit();
+        await this.waitForPreloaded();
         return true;
     }
     async loadMissingReferences() {
@@ -200,11 +209,14 @@ export class AutoUpdatedClientObject {
         this.generateSettersAndGetters();
     }
     openSockets() {
-        const id = this.data?._id ?? this._id;
+        const dataRec = this.data;
+        const id = dataRec["_id"];
+        if (!id || !this.socket || typeof this.socket.on !== 'function')
+            return;
         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")
+            if (ack)
                 ack(res);
             return res;
         });
@@ -217,7 +229,8 @@ export class AutoUpdatedClientObject {
             return { success: true, data: undefined, message: "" };
         }
         catch (error) {
-            this.loggers.error(`[${this.data._id}] Error applying patch: ${error.message}`);
+            const dataRec = this.data;
+            this.loggers.error?.(`[${dataRec["_id"]?.toString()}] Error applying patch: ${error.message}`);
             return { success: false, message: "Error applying update: " + error.message };
         }
     }
@@ -230,7 +243,8 @@ export class AutoUpdatedClientObject {
             const isRef = getMetadataRecursive("isRef", this, key);
             Object.defineProperty(this, key, {
                 get: () => {
-                    let val = this.data[key];
+                    const dataRec = this.data;
+                    let val = dataRec ? dataRec[key] : undefined;
                     if (isRef && val) {
                         if (Array.isArray(val)) {
                             return val.map((id) => this.findReference(id, key)).filter(Boolean);
@@ -242,7 +256,8 @@ export class AutoUpdatedClientObject {
                     return val;
                 },
                 set: (v) => {
-                    throw new Error("Cannot set value of a reference pointer directly.");
+                    if (this.data)
+                        this.data[key] = v;
                 },
                 enumerable: true,
                 configurable: true,
@@ -251,19 +266,20 @@ export class AutoUpdatedClientObject {
     }
     getValue(key_) {
         const key = key_;
-        // Shallow only now
-        return this[key] !== undefined ? this[key] : this.data[key];
+        const dataRec = this.data;
+        return (this)[key] === undefined ? (dataRec ? dataRec[key_] : undefined) : this[key_];
     }
     findReference(id, key) {
-        if (!id)
+        if (!id || !this.parentManager)
             return undefined;
         const idStr = id.toString();
-        if (this.parentManager.cache.references[key])
-            return this.parentManager.cache.references[key].getObject(idStr);
+        const cacheRec = this.parentManager.cache.references;
+        if (cacheRec[key])
+            return cacheRec[key].getObject(idStr);
         for (const manager of Object.values(this.parentManager.managers)) {
             const result = manager.getObject(idStr);
             if (result) {
-                this.parentManager.cache.references[key] = manager;
+                cacheRec[key] = manager;
                 return result;
             }
         }
@@ -281,16 +297,18 @@ export class AutoUpdatedClientObject {
             if (isRef) {
                 valueToStore = Array.isArray(val)
                     ? val.map((v) => v._id?.toString() ?? v.toString())
-                    : (val?._id ?? val?.toString() ?? val);
+                    : (val?._id?.toString() ?? val?.toString() ?? val);
             }
-            const currentVal = this.data[key];
+            const dataRec = this.data;
+            const currentVal = dataRec ? dataRec[key] : undefined;
             if (_.isEqual(currentVal, valueToStore))
                 return { success: true, msg: "Successfully set " + key + " to " + val };
             const res = await this.setValueInternal(key, valueToStore, silent, noUpdate);
             if (res.success) {
-                this.data[key] = valueToStore;
+                if (this.data)
+                    this.data[key] = valueToStore;
                 await this.findAndLoadReferences(key, valueToStore);
-                if (isRef && this.parentManager.isLoaded)
+                if (isRef && this.parentManager && this.parentManager.isLoaded)
                     await this.contactChildren();
                 if (this.isLoaded)
                     this.callbacks.update(this, key);
@@ -298,7 +316,7 @@ export class AutoUpdatedClientObject {
             return { ...res, msg: res.msg ?? "Successfully set " + key + " to " + val };
         }
         catch (error) {
-            this.loggers.error(`Error setting value ${key}: ${error.message}`);
+            this.loggers.error?.(`Error setting value ${key}: ${error.message}`);
             return { success: false, msg: error.message };
         }
     }
@@ -306,21 +324,34 @@ export class AutoUpdatedClientObject {
         if (silent || noUpdate)
             return { success: true, msg: "Silent or no update" };
         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) => {
+            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" });
+            }
+            const timeout = setTimeout(() => {
+                resolve({ success: false, msg: "Timeout waiting for server response" });
+            }, 5000);
+            this.socket.emit(EVENT_UPDATE + this.className + id.toString(), { _id: id.toString(), key, value }, (res) => {
+                clearTimeout(timeout);
                 resolve({ success: res.success, msg: res.message ?? (res.success ? "Success" : "Error") });
             });
         });
     }
     makeUpdate(key, value) {
-        const id = this.data?._id ?? this._id;
+        const dataRec = this.data;
+        const id = dataRec ? dataRec["_id"] : undefined;
         if (!id) {
-            this.loggers.error(`Probably missing the identifier ['_id'] again: ${key} = ${value}`);
+            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.toString(), key, value };
+        return { _id: id, 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)
@@ -330,7 +361,7 @@ export class AutoUpdatedClientObject {
     }
     async findAndLoadReferences(lastPath, value) {
         const isRef = getMetadataRecursive("isRef", this, lastPath);
-        if (isRef) {
+        if (isRef && this.parentManager) {
             for (const id of Array.isArray(value) ? value : [value]) {
                 if (!id)
                     continue;
@@ -347,51 +378,57 @@ export class AutoUpdatedClientObject {
         }
     }
     async wipeSelf() {
-        if (this.data.Wiped)
+        const dataRec = this.data;
+        if (!dataRec || dataRec["Wiped"])
             return;
-        const id = this.data?._id ?? this._id;
+        const id = dataRec["_id"];
         const _id = id ? id.toString() : "unknown";
-        for (const key of Object.keys(this.data)) {
-            delete this.data[key];
+        for (const key of Object.keys(dataRec)) {
+            delete dataRec[key];
         }
-        this.data = { Wiped: true };
-        this.loggers.info(`[${_id}] ${this.className} object wiped`);
+        dataRec["Wiped"] = true;
+        this.loggers.info?.(`[${_id}] ${this.className} object wiped`);
     }
     async loadForceReferences(obj = this.data, proto = this, alreadySeen = []) {
+        if (!obj)
+            return;
         if (obj === this.data) {
-            const myId = this.data?._id?.toString();
+            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);
-            if (pointer && obj === this.data && obj[key] && !alreadySeen.includes(obj)) {
-                await this.createdWithParent(pointer.split(":"), obj[key]);
+            const objRec = obj;
+            if (pointer && obj === this.data && objRec[key] && !alreadySeen.includes(JSON.stringify(obj))) {
+                await this.createdWithParent(pointer.split(":"), objRec[key]);
             }
-            if (obj[key] && !alreadySeen.includes(obj[key]))
-                alreadySeen.push(obj[key]);
+            if (objRec[key] && !alreadySeen.includes(objRec[key]))
+                alreadySeen.push(objRec[key]);
             if (isRef)
                 await this.handleLoad(obj, key, alreadySeen);
-            const val = obj[key];
+            const val = objRec[key];
             if (val && typeof val === "object") {
                 const nestedProto = Object.getPrototypeOf(val);
-                if (nestedProto && !alreadySeen.includes(val)) {
-                    alreadySeen.push(val);
+                if (nestedProto && nestedProto !== Object.prototype && !alreadySeen.includes(JSON.stringify(val))) {
+                    alreadySeen.push(JSON.stringify(val));
                     await this.loadForceReferences(val, nestedProto, alreadySeen);
                 }
             }
         }
     }
     async handleLoad(obj, key, alreadySeen) {
-        const refIds = Array.isArray(obj[key]) ? obj[key] : [obj[key]];
+        if (!this.parentManager)
+            return;
+        const objRec = obj;
+        const refIds = Array.isArray(objRec[key]) ? objRec[key] : [objRec[key]];
         for (const refId of refIds) {
             if (refId) {
                 const idStr = refId.toString();
-                let result = globalCache.objects[idStr]?.object;
+                let result = (globalCache.objects[idStr]?.object);
                 if (!result) {
                     for (const manager of Object.values(this.parentManager.managers)) {
                         result = manager.getObject(idStr);
@@ -414,14 +451,20 @@ export class AutoUpdatedClientObject {
         });
     }
     async createdWithParent(pointer, parent) {
-        if (pointer.length !== 2)
+        if (pointer.length !== 2 || !this.parentManager)
             return;
         const parentId = parent._id?.toString() ?? parent.toString();
-        const obj = this.parentManager.managers[pointer[0]]?.getObject(parentId);
+        const ac = this.parentManager.managers[pointer[0]];
+        if (!ac)
+            return;
+        const obj = ac.getObject(parentId);
         if (!obj)
             return;
         const val = obj.getValue(pointer[1]);
-        const myId = this.data._id.toString();
+        const dataRec = this.data;
+        const myId = dataRec["_id"]?.toString();
+        if (!myId)
+            return;
         if (Array.isArray(val)) {
             const ids = val.map(v => v._id?.toString() ?? v.toString());
             if (!ids.includes(myId)) {
@@ -433,10 +476,21 @@ export class AutoUpdatedClientObject {
         }
     }
     async destroy(once = false) {
-        if (!once)
-            return await this.parentManager.deleteObject(this.data._id.toString());
+        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);
         return new Promise((resolve) => {
-            this.socket.emit(EVENT_DELETE + this.className, this.data._id, (res) => {
+            if (!this.socket || typeof this.socket.emit !== 'function') {
+                return resolve({ success: false, message: "Socket not available" });
+            }
+            const timeout = setTimeout(() => {
+                resolve({ success: false, message: "Timeout waiting for server deletion" });
+            }, 5000);
+            this.socket.emit(EVENT_DELETE + this.className, id.toString(), (res) => {
+                clearTimeout(timeout);
                 resolve({ success: res.success, message: res.message ?? "" });
             });
         });
@@ -444,7 +498,7 @@ export class AutoUpdatedClientObject {
     async checkForMissingRefs() {
         for (const prop of this.properties) {
             const pointer = getMetadataRecursive("refsTo", this, prop.toString());
-            if (pointer) {
+            if (typeof pointer === "string") {
                 const parts = pointer.split(":");
                 if (parts.length === 2)
                     await this.findMissingObjectReference(prop, parts);
@@ -452,13 +506,16 @@ export class AutoUpdatedClientObject {
         }
     }
     async findMissingObjectReference(prop, pointer) {
-        if (this.checkedMissingRefs)
+        if (this.checkedMissingRefs || !this.parentManager)
             return;
         this.checkedMissingRefs = true;
         const ac = this.parentManager.managers[pointer[0]];
         if (!ac)
             return;
-        const targetId = this.data._id.toString();
+        const dataRec = this.data;
+        const targetId = dataRec ? dataRec["_id"]?.toString() : undefined;
+        if (!targetId)
+            return;
         const allObjects = Object.values(ac.objects);
         for (const obj of allObjects) {
             if (!obj.isLoaded)
@@ -468,7 +525,7 @@ export class AutoUpdatedClientObject {
                 continue;
             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;
+                dataRec[prop] = obj._id;
                 return;
             }
         }
@@ -497,6 +554,8 @@ 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];
@@ -511,18 +570,16 @@ export function processIsRefProperties(instance, target, prefix, allProps, newDa
         }
         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, {}, loggers).newData;
-            }
+            // DO NOT RECURSE into nested prototypes to avoid circularity issues
         }
     }
     return { allProps, newData };
 }
-export function getMetadataRecursive(metaKey, proto, prop) {
+export function getMetadataRecursive(metaKey, target, prop) {
+    let proto = target;
     while (proto) {
         const meta = Reflect.getMetadata(metaKey, proto, prop);
-        if (meta)
+        if (meta !== undefined)
             return meta;
         proto = Object.getPrototypeOf(proto);
     }