@prestizni-software/server-dem 0.4.95 → 0.4.97

package/dist/AutoUpdatedClientObjectClass.js

@@ -7,7 +7,9 @@ export class AutoUpdatedClientObject {
     preLoad;
     registerSocket;
     readyLoggers;
-    loadFromDB(a) { }
+    loadFromDB(a) {
+        return a;
+    }
     socket;
     data;
     isServer = false;
@@ -31,11 +33,14 @@ 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, {
+                    silent: true,
+                    isParentUpdate: true,
+                });
             }
         }
         catch (error) {
-            this.loggers.error("Error loading references: " + error.message);
+            // this.loggers?.error?.("Error loading references: " + error.message);
         }
         finally {
             this.isLoadingReferences = false;
@@ -59,18 +64,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 +78,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,60 +127,71 @@ 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.isLoaded) {
+            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) => {
+        return 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"));
+                this.emitter.off(EVENT_INTERNAL_PRE_LOADED + this.EmitterID, onPreloaded);
+                reject(new Error(`Timeout waiting for preloaded: ${this.className}`));
             }, 10000);
-            this.emitter.once(EVENT_INTERNAL_PRE_LOADED + this.EmitterID, (failed, reason) => {
+            const onPreloaded = (failed, reason) => {
                 clearTimeout(timer);
                 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.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 +205,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,25 +219,34 @@ 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;
         });
     }
     async handleUpdateRequest(update) {
         try {
-            await this.setValue(update.key, update.value, { silent: true });
+            await this.setValue(update.key, update.value, {
+                silent: true,
+            });
             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}`);
-            return { success: false, message: "Error applying update: " + 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,
+            };
         }
     }
     generateSettersAndGetters() {
@@ -230,10 +258,13 @@ 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);
+                            return val
+                                .map((id) => this.findReference(id, key))
+                                .filter(Boolean);
                         }
                         else {
                             return this.findReference(val, key);
@@ -242,7 +273,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,26 +283,31 @@ export class AutoUpdatedClientObject {
     }
     getValue(key_) {
         const key = key_;
-        // Shallow only now
-        return (this)[key] === undefined ? this.data[key] : this[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;
             }
         }
         return undefined;
     }
     async setValue(key, val, options = {}) {
-        const { silent = false, noUpdate = false, isParentUpdate = false } = options;
+        const { silent = false, noUpdate = false, isParentUpdate = false, } = options;
         try {
             const isRef = getMetadataRecursive("isRef", this, key);
             const pointer = getMetadataRecursive("refsTo", this, key);
@@ -281,24 +318,29 @@ 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);
             }
-            return { ...res, msg: res.msg ?? "Successfully set " + key + " to " + val };
+            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 +348,37 @@ 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) => {
-                resolve({ success: res.success, msg: res.message ?? (res.success ? "Success" : "Error") });
+            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 +388,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,47 +405,60 @@ 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();
@@ -410,33 +481,60 @@ export class AutoUpdatedClientObject {
         if (noUpdate)
             return;
         await this.callbacks?.onUpdate?.(this, (key, val) => {
-            return this.setValue(key, val, { silent: false, noGet: true, noUpdate: true });
+            return this.setValue(key, val, {
+                silent: false,
+                noGet: true,
+                noUpdate: true,
+            });
         });
     }
     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());
+            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 });
             }
         }
         else if ((val?._id?.toString() ?? val?.toString()) !== myId) {
-            await obj.setValue(pointer[1], myId, { silent: true, isParentUpdate: true });
+            await obj.setValue(pointer[1], myId, {
+                silent: true,
+                isParentUpdate: true,
+            });
         }
     }
     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 +542,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 +550,18 @@ 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)
@@ -466,9 +569,11 @@ export class AutoUpdatedClientObject {
             const val = obj.getValue(pointer[1]);
             if (!val)
                 continue;
-            const ids = Array.isArray(val) ? val.map(v => v._id?.toString() ?? v.toString()) : [val._id?.toString() ?? val.toString()];
+            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;
             }
         }
@@ -484,7 +589,8 @@ export class AutoUpdatedClientObject {
                 continue;
             const children = Array.isArray(obj) ? obj : [obj];
             for (const child of children) {
-                if (child && typeof child.loadMissingReferences === "function") {
+                if (child &&
+                    typeof child.loadMissingReferences === "function") {
                     await child.loadMissingReferences();
                 }
             }
@@ -497,6 +603,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 +619,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);
     }