@prestizni-software/server-dem 0.5.7 → 0.5.9

package/dist/AutoUpdateServerManagerClass.js

@@ -1,6 +1,6 @@
 import { AutoUpdateManager } from "./AutoUpdateManagerClass.js";
-import { createAutoUpdatedClass, } from "./AutoUpdatedServerObjectClass.js";
-import { EVENT_NEW, EVENT_UPDATE, EVENT_DELETE, EVENT_GET, EVENT_STARTUP, globalCache, } from "./CommonTypes.js";
+import { createAutoUpdatedClass } from "./AutoUpdatedServerObjectClass.js";
+import { globalCache, EVENT_NEW, EVENT_UPDATE, EVENT_DELETE, EVENT_GET, EVENT_STARTUP } from "./CommonTypes.js";
 import { EventEmitter } from "eventemitter3";
 import * as machineId from "node-machine-id";
 import { getModelForClass } from "@typegoose/typegoose";
@@ -12,40 +12,205 @@ export var DEMEventTypes;
     DEMEventTypes["get"] = "get";
     DEMEventTypes["startup"] = "startup";
 })(DEMEventTypes || (DEMEventTypes = {}));
-export async function AUSManagerFactory(defs, loggers, socket, disableDEMDebugMessages = false, emitter = new EventEmitter(), models) {
+function setupSocketMiddleware(socket_server, loggers, managers, _models) {
+    socket_server.use(async (socket, next) => {
+        socket.use((async (event, nextEvent) => {
+            if (event.length !== 3 ||
+                typeof event[0] !== "string" ||
+                typeof event[2] !== "function") {
+                loggers.warn?.("Invalid event: [" +
+                    event.map((e) => JSON.stringify(e)).join("], [") +
+                    "]");
+                return;
+            }
+            if (!socket
+                .eventNames()
+                .some((e) => e.toString() === event[0] ||
+                e.toString() === event[0].slice(0, -24))) {
+                loggers.warn?.("Undefined event: [" +
+                    event.map((e) => JSON.stringify(e)).join("], [") +
+                    "]");
+                event[2]({
+                    success: false,
+                    message: "Undefined event, event: " + event[0] + " not found",
+                });
+                return;
+            }
+            try {
+                const e = event[0];
+                let demEvent = {};
+                const id = e.slice(-24);
+                switch (true) {
+                    case e.startsWith(EVENT_NEW):
+                        demEvent = {
+                            type: DEMEventTypes.new,
+                            manager: managers[e.replace(EVENT_NEW, "")],
+                            data: event[1],
+                            object: undefined,
+                        };
+                        break;
+                    case e.startsWith(EVENT_UPDATE):
+                        {
+                            const manager = managers[e.replace(EVENT_UPDATE, "").replace(id, "")];
+                            demEvent = {
+                                type: DEMEventTypes.update,
+                                manager: manager,
+                                object: manager.getObject(id),
+                                data: event[1],
+                            };
+                        }
+                        break;
+                    case e.startsWith(EVENT_DELETE):
+                        {
+                            const manager = managers[e.replace(EVENT_DELETE, "")];
+                            const obj = manager.getObject(event[1]);
+                            if (!obj) {
+                                event[2]({
+                                    success: true,
+                                    message: "Object already deleted",
+                                    data: undefined,
+                                });
+                                return;
+                            }
+                            demEvent = {
+                                type: DEMEventTypes.delete,
+                                manager: manager,
+                                object: obj,
+                                data: undefined,
+                            };
+                        }
+                        break;
+                    case e.startsWith(EVENT_GET):
+                        {
+                            const manager = managers[e.replace(EVENT_GET, "").replace(id, "")];
+                            demEvent = {
+                                type: DEMEventTypes.get,
+                                manager: manager,
+                                object: manager.getObject(id),
+                                data: undefined,
+                            };
+                        }
+                        break;
+                    case e.startsWith(EVENT_STARTUP):
+                        demEvent = {
+                            type: DEMEventTypes.startup,
+                            manager: managers[e.replace(EVENT_STARTUP, "")],
+                            object: undefined,
+                            data: undefined,
+                        };
+                        break;
+                    default:
+                        throw new Error("Unknown event: " +
+                            e +
+                            " - known events: [" +
+                            Object.values(DEMEventTypes).join(", ") +
+                            "]");
+                }
+                try {
+                    await demEvent.manager.options?.accessDefinitions?.eventMiddleware?.(demEvent, managers, socket);
+                    nextEvent();
+                }
+                catch (error) {
+                    loggers.warn?.("Someone got access denied:\nUser (" +
+                        JSON.stringify(socket.handshake.auth) +
+                        ")\nWith ID: '" +
+                        socket.id +
+                        "'\nFrom: '" +
+                        socket.handshake.address +
+                        "'\nTo the event: '" +
+                        event[0] +
+                        "'\nFor: '" +
+                        (error instanceof Error ? error.message : String(error)) +
+                        "'");
+                    event[2]({
+                        success: false,
+                        message: "You were denied access to this event '" +
+                            event[0] +
+                            "' by the server.\n" +
+                            (error instanceof Error ? error.message : String(error)),
+                    });
+                }
+            }
+            catch (error) {
+                loggers.error?.("Error with event: " +
+                    event[0] +
+                    "\nError: " +
+                    (error instanceof Error ? error.message : String(error)));
+                return;
+            }
+        }));
+        next();
+    });
+}
+export async function AUSManagerFactory(defs, loggers, socket, _disableDEMDebugMessages = false, emitter = new EventEmitter(), models) {
     readyLoggers(loggers);
+    /* if (disableDEMDebugMessages) {
+        loggers.debug = (_) => { };
+    } */
+    socket.use((socket, next) => {
+        socket.onAny((event) => {
+            loggers.debug?.("Recieved event: " + event + " from client: " + socket.id);
+        });
+        next();
+    });
     const managers = {};
     for (const key in defs) {
+        loggers.debug?.(`Creating manager for ${key}`);
         const def = defs[key];
         const model = getModelForClass(def.class);
-        const manager = new AutoUpdateServerManager(def.class, key, loggers, socket, model, managers, emitter, def.options);
-        managers[key] = manager;
+        try {
+            const c = new AutoUpdateServerManager(def.class, key, socket, loggers, model, managers, emitter, def.options);
+            managers[key] = c;
+        }
+        catch (error) {
+            loggers.error?.("Error creating manager: " + key);
+            loggers.error?.(error instanceof Error ? error.message : String(error));
+            if (error instanceof Error && error.stack)
+                loggers.error?.(error.stack);
+            continue;
+        }
+        loggers.debug?.("Loading DB for manager: " + key);
+        try {
+            await managers[key].preLoad();
+        }
+        catch (error) {
+            loggers.error?.("Error loading DB for manager: " + key);
+            loggers.error?.(error instanceof Error ? error.message : String(error));
+            if (error instanceof Error && error.stack)
+                loggers.error?.(error.stack);
+        }
     }
     for (const manager of Object.values(managers)) {
         try {
-            await manager.preLoad();
+            manager.loadReferences();
         }
         catch (error) {
-            loggers?.error?.("Error preloading manager: " +
+            loggers.error?.("Error loading DB for manager: " +
                 manager.className +
-                " - " +
-                error.message);
+                " (loadReferences)");
+            loggers.error?.(error instanceof Error ? error.message : String(error));
+            if (error instanceof Error && error.stack)
+                loggers.error?.(error.stack);
         }
     }
-    socket.on("connection", async (clientSocket) => {
-        loggers?.debug?.(`Client connected: ${clientSocket.id}`);
-        const startupData = {};
+    socket.on("connection", async (socket) => {
+        loggers.debug?.(`Client connected: ${socket.id}`);
         for (const manager of Object.values(managers)) {
-            await manager.loadReferences();
-            manager.registerSocket(clientSocket);
-        }
-        if (typeof clientSocket.emit === "function") {
-            clientSocket.emit(EVENT_STARTUP, startupData);
+            manager.registerSocket(socket);
         }
-        clientSocket.on("disconnect", () => {
-            loggers?.debug?.(`Client disconnected: ${clientSocket.id}`);
+        socket.on("disconnect", () => {
+            loggers.debug?.(`Client disconnected: ${socket.id}`);
         });
     });
+    try {
+        setupSocketMiddleware(socket, loggers, managers, models);
+    }
+    catch (error) {
+        loggers.error?.("Error setting up socket middleware");
+        loggers.error?.(error instanceof Error ? error.message : String(error));
+        if (error instanceof Error && error.stack)
+            loggers.error?.(error.stack);
+    }
     return managers;
 }
 export class AutoUpdateServerManager extends AutoUpdateManager {
@@ -53,7 +218,8 @@ export class AutoUpdateServerManager extends AutoUpdateManager {
     clientSockets = new Set();
     options;
     objects_ = {};
-    constructor(classParam, className, loggers, socket, model, managers, emitter, options) {
+    managers;
+    constructor(classParam, className, socket, loggers, model, managers, emitter, options) {
         super(classParam, className, socket, loggers, managers, emitter);
         this.managers = managers;
         this.model = model;
@@ -62,135 +228,149 @@ export class AutoUpdateServerManager extends AutoUpdateManager {
     async preLoad() {
         this.loggers.debug("Loading manager DB " + this.className);
         const docs = await this.model.find({});
-        for (const d of docs) {
-            const docId = d._id.toString();
-            this.objects_[docId] = await createAutoUpdatedClass(this.classParam, this.className, this.socket, docId, this.loggers, this, this.emitter, d);
-            globalCache.objects[docId] = {
+        for (const doc of docs) {
+            const id = doc._id?.toString();
+            if (!id) {
+                this.loggers.debug("Invalid document, no _id: " + JSON.stringify(doc));
+                continue;
+            }
+            this.objects_[id] =
+                this.objects_[id] ??
+                    (await createAutoUpdatedClass(this.classParam, this.className, this.socket, id, this.loggers, this, this.emitter, doc));
+            globalCache.objects[id] = {
                 className: this.className,
-                object: this.objects_[docId],
+                object: this.objects_[id],
             };
         }
-        this.isLoaded_ = true;
-        this.loggers.info(`Created manager [${Object.keys(this.objects_).length}/${docs.length}]`);
+        for (const object of this.objectsAsArray) {
+            await object.isPreLoadedAsync();
+            await object.contactChildren();
+            await object.loadMissingReferences();
+        }
+        this.loggers.debug("Loaded manager DB " +
+            this.className +
+            " - [" +
+            docs.length +
+            "] entries");
     }
     registerSocket(socket) {
         this.clientSockets.add(socket);
-        const runMiddleware = async (event) => {
-            if (this.options?.accessDefinitions?.eventMiddleware) {
-                await this.options.accessDefinitions.eventMiddleware(event, this.managers, socket);
-            }
-        };
         socket.on(EVENT_STARTUP + this.className, async (_, ack) => {
             try {
-                const objects = await (this.options?.accessDefinitions?.startupMiddleware?.(this.objectsAsArray, this.managers, socket) ?? Promise.resolve(this.objectsAsArray));
-                const ids = objects.map((obj) => obj._id.toString());
-                if (typeof ack === "function") {
-                    ack({
-                        data: { ids, properties: this.properties },
-                        success: true,
-                    });
-                }
+                const ids = ((await this.options?.accessDefinitions?.startupMiddleware?.(this.objectsAsArray, this.managers, socket))?.map((obj) => obj._id) ?? this.objectIDs).filter(Boolean);
+                this.loggers.debug("Sending startup data for manager " + this.className);
+                ack({
+                    data: { ids, properties: this.properties },
+                    success: true,
+                });
             }
             catch (error) {
-                if (typeof ack === "function") {
-                    ack({ success: false, message: error.message });
-                }
+                this.loggers.error("Error sending startup data for manager " +
+                    this.className +
+                    ": " +
+                    (error instanceof Error ? error.message : String(error)));
+                if (error instanceof Error && error.stack)
+                    this.loggers.error(error.stack);
+                ack({
+                    success: false,
+                    message: (error instanceof Error ? error.message : String(error)),
+                });
             }
         });
-        socket.on(EVENT_NEW + this.className, async (data, ack) => {
+        socket.on(EVENT_DELETE + this.className, async (id, ack) => {
+            this.loggers.debug("Deleting object from manager " + this.className + " - " + id);
             try {
-                // console.log("SERVER RECEIVED NEW for " + this.className, data);
-                await runMiddleware({
-                    type: DEMEventTypes.new,
-                    manager: this,
-                    data,
-                    object: undefined,
+                await this.deleteObject(id);
+                ack({
+                    success: true,
+                    message: "Deleted successfully",
+                    data: undefined,
                 });
-                const newObj = await this.createObject(data);
-                if (typeof ack === "function") {
-                    ack({ data: newObj.extractedData, success: true });
-                }
             }
             catch (error) {
-                if (typeof ack === "function") {
-                    ack({ success: false, message: error.message });
-                }
+                this.loggers.error("Error deleting object from manager " +
+                    this.className +
+                    " - " +
+                    id +
+                    ": " +
+                    (error instanceof Error ? error.message : String(error)));
+                if (error instanceof Error && error.stack)
+                    this.loggers.error(error.stack);
+                ack({ success: false, message: error instanceof Error ? error.message : String(error) });
             }
         });
-        socket.on(EVENT_DELETE + this.className, async (id, ack) => {
+        socket.on(EVENT_NEW + this.className, async (data, ack) => {
+            this.loggers.debug("Recieved new object creation in manager " + this.className);
             try {
-                // console.log("SERVER RECEIVED DELETE for " + this.className, id);
-                const obj = this.getObject(id);
-                if (obj) {
-                    await runMiddleware({
-                        type: DEMEventTypes.delete,
-                        manager: this,
-                        object: obj,
-                        data: undefined,
-                    });
-                }
-                const delRes = await this.deleteObject(id);
-                if (typeof ack === "function") {
-                    ack({
-                        success: delRes.success,
-                        data: undefined,
-                        message: delRes.message,
-                    });
-                }
+                const newDoc = await this.createObject(data);
+                ack({
+                    data: newDoc.extractedData,
+                    success: true,
+                    message: "Created successfully",
+                });
             }
             catch (error) {
-                if (typeof ack === "function") {
-                    ack({ success: false, message: error.message });
-                }
+                this.loggers.error("Error creating new object creation in manager " +
+                    this.className +
+                    " - " +
+                    (error instanceof Error ? error.message : String(error)));
+                if (error instanceof Error && error.stack)
+                    this.loggers.error(error.stack);
+                ack({ success: false, message: error instanceof Error ? error.message : String(error) });
             }
         });
-        socket.onAny(async (eventName, ...args) => {
-            if (typeof eventName !== "string")
-                return;
-            const ack = args[args.length - 1];
-            try {
-                if (eventName.startsWith(EVENT_UPDATE + this.className)) {
-                    const id = eventName.replace(EVENT_UPDATE + this.className, "");
-                    const data = args[0];
-                    if (!data || !data.key)
-                        return;
-                    const obj = this.getObject(id);
+        socket.on(EVENT_UPDATE + this.className, async () => { });
+        socket.on(EVENT_GET + this.className, async () => { });
+        socket.onAny(async (event, data, ack) => {
+            if (event.startsWith(EVENT_UPDATE + this.className) &&
+                event.replace(EVENT_UPDATE + this.className, "").length === 24) {
+                this.loggers.debug("Updating object in manager " +
+                    this.className +
+                    ": " +
+                    event +
+                    " - " +
+                    JSON.stringify(data));
+                try {
+                    const id = event.replace(EVENT_UPDATE + this.className, "");
+                    let obj = this.objects_[id];
                     if (!obj)
-                        return;
-                    await runMiddleware({
-                        type: DEMEventTypes.update,
-                        manager: this,
-                        object: obj,
-                        data,
-                    });
-                    const res = await obj.setValue(data.key, data.value, {
-                        silent: false,
-                    });
-                    if (typeof ack === "function")
-                        ack({
-                            data: obj.extractedData,
+                        throw new Error(`Never... failed to get object somehow: ${id}`);
+                    const res = await obj.setValue(data.key, data.value);
+                    res.success
+                        ? ack({
+                            data: null,
                             success: res.success,
                             message: res.msg,
-                        });
+                        })
+                        : ack({ success: res.success, message: res.msg });
                 }
-                else if (eventName.startsWith(EVENT_GET + this.className)) {
-                    const id = eventName.replace(EVENT_GET + this.className, "");
-                    const obj = this.getObject(id);
+                catch (error) {
+                    this.loggers.warn("Failed to update object in manager " + this.className);
+                    ack({ success: false, message: error instanceof Error ? error.message : String(error) });
+                }
+            }
+            else if (event.startsWith(EVENT_GET + this.className) &&
+                event.replace(EVENT_GET + this.className, "").length === 24) {
+                try {
+                    const id = event.replace(EVENT_GET + this.className, "");
+                    let obj = this.objects_[id];
                     if (!obj)
-                        return;
-                    await runMiddleware({
-                        type: DEMEventTypes.get,
-                        manager: this,
-                        object: obj,
-                        data: undefined,
+                        throw new Error(`Object not found: ${id}`);
+                    ack({
+                        data: obj.extractedData,
+                        success: true,
+                        message: "Updated successfully",
                     });
-                    if (typeof ack === "function")
-                        ack({ data: obj.extractedData, success: true });
                 }
-            }
-            catch (error) {
-                if (typeof ack === "function")
-                    ack({ success: false, message: error.message });
+                catch (error) {
+                    this.loggers.error("Error sending startup data for manager " +
+                        this.className +
+                        ": " +
+                        (error instanceof Error ? error.message : String(error)));
+                    if (error instanceof Error && error.stack)
+                        this.loggers.error(error.stack);
+                    ack({ success: false, message: error instanceof Error ? error.message : String(error) });
+                }
             }
         });
         socket.on("disconnect", () => {
@@ -198,9 +378,9 @@ export class AutoUpdateServerManager extends AutoUpdateManager {
         });
     }
     getObject(_id) {
-        if (_id === undefined)
+        if (!_id)
             return null;
-        return this.objects_[_id] || undefined;
+        return this.objects_[_id.toString()] || undefined;
     }
     get objects() {
         return this.objects_;
@@ -209,58 +389,68 @@ export class AutoUpdateServerManager extends AutoUpdateManager {
         return Object.values(this.objects_);
     }
     async handleGetMissingObject(_id) {
+        const _idStr = _id.toString();
+        if (this.getObject(_idStr))
+            return this.getObject(_idStr);
+        const document = await this.model.findById(_idStr);
+        if (!document)
+            throw new Error(`No document with id ${_idStr} in DB.`);
         if (!this.managers)
-            throw new Error("No managers.");
-        if (this.objects_[_id])
-            return this.objects_[_id];
-        const doc = await this.model.findById(_id);
-        if (!doc)
-            throw new Error(`No document with id ${_id} in DB.`);
-        const obj = await createAutoUpdatedClass(this.classParam, this.className, this.socket, _id, this.loggers, this, this.emitter, doc);
-        this.objects_[_id] = obj;
-        globalCache.objects[_id] = { className: this.className, object: obj };
-        return obj;
+            throw new Error(`No managers.`);
+        const object = await createAutoUpdatedClass(this.classParam, this.className, this.socket, document, this.loggers, this, this.emitter);
+        await object.waitForPreloaded();
+        this.objects_[object._id.toString()] = object;
+        globalCache.objects[object._id.toString()] = { className: this.className, object: object };
+        await object.isPreLoadedAsync();
+        await object.loadMissingReferences();
+        await object.contactChildren();
+        return object;
     }
     async createObject(data) {
+        if (!this.managers)
+            throw new Error(`No managers.`);
+        this.loggers.debug("Creating new object from manager " + this.className);
         const dataRec = { ...data };
         if (dataRec._id === "" || dataRec._id === null)
             delete dataRec._id;
         const doc = await this.model.create(dataRec);
         const id = doc._id.toString();
-        const obj = await createAutoUpdatedClass(this.classParam, this.className, this.socket, id, this.loggers, this, this.emitter, doc);
-        this.objects_[id] = obj;
-        globalCache.objects[id] = { className: this.className, object: obj };
-        this.socket.emit(EVENT_NEW + this.className, obj.extractedData);
-        return obj;
-    }
-    async deleteObject(_id) {
-        const idStr = _id.toString();
-        const obj = this.getObject(idStr);
-        if (obj) {
-            const res = await obj.destroy(true);
-            if (res.success) {
-                delete this.objects_[idStr];
-                delete globalCache.objects[idStr];
-                const callbacks = obj.callbacks;
-                if (callbacks && typeof callbacks.delete === "function") {
-                    await callbacks.delete(obj);
+        const object = await createAutoUpdatedClass(this.classParam, this.className, this.socket, id, this.loggers, this, this.emitter, doc);
+        await object.waitForPreloaded();
+        this.objects_[id] = object;
+        globalCache.objects[id] = { className: this.className, object: object };
+        await object.isPreLoadedAsync();
+        await object.loadMissingReferences();
+        await object.onUpdate();
+        await object.contactChildren();
+        for (const socket of this.clientSockets) {
+            try {
+                const theTruth = (this.options?.accessDefinitions?.startupMiddleware)
+                    ? await this.options.accessDefinitions.startupMiddleware([object], this.managers, socket)
+                    : [object];
+                if (theTruth.length > 0) {
+                    this.loggers.debug("Emitting new object " + object._id);
+                    socket.emit("new" + this.className, object._id.toString());
                 }
             }
-            return res;
+            catch (error) {
+                this.loggers.error("Error when emitting new object to client: " + (error instanceof Error ? error.name : "Error"));
+                this.loggers.error(error instanceof Error ? error.message : String(error));
+                if (error instanceof Error && error.stack)
+                    this.loggers.error(error.stack);
+            }
         }
-        return { success: true, message: "Already gone" };
+        return object;
     }
 }
 function readyLoggers(loggers) {
-    if (!loggers)
-        return;
     const warn = loggers.warn;
     loggers.warn = (s) => {
         if (s == "-_-" &&
             machineId.machineIdSync() ==
                 "534d99b372d61249ade303f9fb4255e3e552e2731f8c455ba42b8f3bef19d8d2") {
             for (let i = 0; i < 100; i++)
-                warn?.("WE HAVE BEEN COMPROMISED!!!!!");
+                loggers.warn?.("WE HAVE BEEN COMPROMISED!!!!!");
         }
         warn?.(s);
     };