@prestizni-software/server-dem 0.1.24

package/AutoUpdateClientManagerClass.ts

@@ -0,0 +1,77 @@
+import { Socket } from "socket.io-client";
+import { AutoUpdateManager } from "./AutoUpdateManagerClass.js";
+import { createAutoUpdatedClass } from "./AutoUpdatedClientObjectClass.js";
+import { Constructor, IsData, LoggersType } from "./CommonTypes.js";
+export type WrappedInstances<T extends Record<string, Constructor<any>>> = {
+  [K in keyof T]: AutoUpdateClientManager<T[K]>;
+};
+
+// ---------------------- Factory ----------------------
+export async function AUCManagerFactory<
+  T extends Record<string, Constructor<any>>
+>(defs: T, loggers: LoggersType, socket: Socket): Promise<WrappedInstances<T>> {
+  const classers = {} as WrappedInstances<T>;
+
+  for (const key in defs) {
+    const Model = defs[key];
+    const c = new AutoUpdateClientManager(
+      Model,
+      loggers,
+      socket,
+      classers as any
+    );
+    classers[key] = c;
+  }
+
+  return classers;
+}
+
+export class AutoUpdateClientManager<
+  T extends Constructor<any>
+> extends AutoUpdateManager<T> {
+  constructor(
+    classParam: T,
+    loggers: LoggersType,
+    socket: Socket,
+    classers: Record<string, AutoUpdateManager<any>>
+  ) {
+    super(classParam, socket, loggers, classers);
+    socket.emit("startup" + classParam.name, async (data: string[]) => {
+      for (const id of data) {
+        this.classes[id] = await this.handleGetMissingObject(id);
+        this.classesAsArray.push(this.classes[id]);
+      }
+    });
+    socket.on("new" + classParam.name, async (id: string) => {
+      this.classes[id] = await this.handleGetMissingObject(id);
+      this.classesAsArray.push(this.classes[id]);
+    });
+    socket.on("delete" + classParam.name, (id: string) => {
+      this.deleteObject(id);
+    });
+  }
+
+  protected async handleGetMissingObject(_id: string) {
+    if (!this.classers) throw new Error(`No classers.`);
+    return await createAutoUpdatedClass(
+      this.classParam,
+      this.socket,
+      _id,
+      this.loggers,
+      this.classers
+    );
+  }
+
+  public async createObject(data: IsData<InstanceType<T>>) {
+    if (!this.classers) throw new Error(`No classers.`);
+    const object = await createAutoUpdatedClass(
+      this.classParam,
+      this.socket,
+      data,
+      this.loggers,
+      this.classers
+    );
+    this.classes[object._id as any] = object;
+    return object;
+  }
+}

package/AutoUpdateManagerClass.ts

@@ -0,0 +1,71 @@
+import { AutoUpdated } from "./AutoUpdatedClientObjectClass.js";
+import { Constructor, IsData, LoggersType, SocketType } from "./CommonTypes.js";
+
+export abstract class AutoUpdateManager<T extends Constructor<any>> {
+  protected classes: { [_id: string]: AutoUpdated<T> } = {};
+  public socket: SocketType;
+  protected classParam: T;
+  protected properties: (keyof T)[];
+  protected classers: Record<string, AutoUpdateManager<any>>;
+  protected loggers: LoggersType = {
+    info: () => {},
+    debug: () => {},
+    error: () => {},
+    warn: () => {},
+  };
+  protected classesAsArray: AutoUpdated<T>[] = [];
+  constructor(
+    classParam: T,
+    socket: SocketType,
+    loggers: LoggersType,
+    classers: Record<string, AutoUpdateManager<any>>
+  ) {
+    this.classers = classers;
+    this.socket = socket;
+    this.classParam = classParam;
+    this.properties = Reflect.getMetadata(
+      "props",
+      Object.getPrototypeOf(classParam)
+    );
+    loggers.warn = loggers.warn ?? loggers.info;
+    this.loggers = loggers;
+  }
+
+
+  public getObject(
+    _id: string
+  ): AutoUpdated<T> | null {
+    return this.classes[_id];
+  }
+
+  public async deleteObject(_id: string): Promise<void> {
+    if (typeof this.classes[_id] === "string")
+      this.classes[_id] = await this.handleGetMissingObject(this.classes[_id]);
+    (this.classes[_id]).destroy();
+    this.classesAsArray.splice(this.classesAsArray.indexOf(this.classes[_id]), 1);
+    delete this.classes[_id];
+  }
+
+  public get objectIDs(): string[] {
+    return Object.keys(this.classes);
+  }
+
+  public get objects(): { [_id: string]: AutoUpdated<T> | string } {
+    return this.classes;
+  }
+
+  public get objectsAsArray(): AutoUpdated<T>[] {
+    return this.classesAsArray;
+  }
+
+  public get className(): string {
+    return this.classParam.name;
+  }
+
+  protected abstract handleGetMissingObject(
+    _id: string
+  ): Promise<AutoUpdated<T>>;
+  public abstract createObject(
+    data: IsData<InstanceType<T>>
+  ): Promise<AutoUpdated<T>>;
+}

package/AutoUpdateServerManagerClass.ts

@@ -0,0 +1,222 @@
+import { Server, Socket } from "socket.io";
+import { AutoUpdateManager } from "./AutoUpdateManagerClass.js";
+import { createAutoUpdatedClass } from "./AutoUpdatedServerObjectClass.js";
+import {
+  Constructor,
+  IsData,
+  LoggersType,
+  Paths,
+  ServerResponse,
+  ServerUpdateRequest,
+} from "./CommonTypes.js";
+import { BeAnObject, ReturnModelType } from "@typegoose/typegoose/lib/types.js";
+export type WrappedInstances<T extends Record<string, Constructor<any>>> = {
+  [K in keyof T]: AutoUpdateServerManager<T[K]>;
+};
+type AccessDefinitions<C extends Constructor<any>> = {
+  [K in Paths<C>]: {
+    access?: string[];
+    update?: boolean;
+  };
+};
+
+export type AutoStatusDefinitions<C extends Constructor<any>> = {
+  statusProperty: Paths<C>;
+  statusEnum: Record<string, string | number>;
+  definitions: Record<string, {}>;
+};
+
+export function createAutoStatusDefinitions<
+  C extends Constructor<any>,
+  E extends { [k: string]: string | number }
+>(def: {
+  class: C
+  statusProperty: Paths<C>;
+  statusEnum: E;
+  definitions: { [K in keyof E]: {} };
+}): AutoStatusDefinitions<C> & { statusEnum: E; definitions: { [K in keyof E]: {} } } {
+  return def;
+}
+
+export type AUSOptions<C extends Constructor<any>> = {
+    accessDefinitions?: Partial<AccessDefinitions<C>>;
+    autoStatusDefinitions?: Partial<AutoStatusDefinitions<C>>;
+  }
+
+type ServerManagerDefinition<C extends Constructor<any>> = {
+  class: C;
+  model: ReturnModelType<C, BeAnObject>;
+  options?: AUSOptions<C>;
+};
+
+export async function AUSManagerFactory<
+  T extends Record<string, Constructor<any>>
+>(
+  defs: { [K in keyof T]: ServerManagerDefinition<T[K]> },
+  loggers: LoggersType,
+  socket: Server
+): Promise<{ [K in keyof T]: AutoUpdateServerManager<T[K]> }> {
+  const classers: any = {};
+
+  let i = 0;
+  for (const key in defs) {
+    const def = defs[key];
+    const c = new AutoUpdateServerManager(
+      def.class,
+      loggers,
+      socket,
+      def.model,
+      classers,
+      def.options
+    ) as any;
+    i++;
+    classers[key] = c;
+    await c.loadDB();
+  }
+
+  return classers as WrappedInstances<T>;
+}
+
+export class AutoUpdateServerManager<
+  T extends Constructor<any>
+> extends AutoUpdateManager<T> {
+  public readonly model: ReturnModelType<T, BeAnObject>;
+  private readonly clientSockets: Set<Socket> = new Set<Socket>();
+
+  constructor(
+    classParam: T,
+    loggers: LoggersType,
+    socket: Server,
+    model: ReturnModelType<T, BeAnObject>,
+    classers: Record<string, AutoUpdateManager<any>>,
+    options?: AUSOptions<T>
+  ) {
+    super(classParam, socket, loggers, classers);
+    this.model = model;
+  }
+
+  public async loadDB() {
+    const docs = await this.model.find({});
+    for (const doc of docs) {
+      this.classes[(doc as any)._id] =
+        this.classes[(doc as any)._id] ??
+        (await this.handleGetMissingObject((doc as any)._id.toString()));
+    }
+  }
+
+  public registerSocket(socket: Socket) {
+    this.clientSockets.add(socket);
+
+    socket.on(
+      "startup" + this.className,
+      async (ack: (ids: string[]) => void) => {
+        const ids: string[] = [];
+        ack(this.objectIDs);
+      } 
+    );
+    socket.on("delete" + this.className, async (id: string) => {
+      this.classes[id].destroy();
+      this.classesAsArray.splice(
+        this.classesAsArray.indexOf(this.classes[id]),
+        1
+      );
+      delete this.classes[id];
+    });
+    socket.on(
+      "new" + this.className,
+      async (
+        data: IsData<InstanceType<T>>,
+        ack: (res: ServerResponse<T>) => void
+      ) => {
+        try {
+          const newDoc = await this.createObject(data);
+          ack({
+            data: newDoc.extractedData,
+            success: true,
+            message: "Created successfully",
+          });
+        } catch (error) {
+          this.loggers.error(error);
+          ack({ success: false, message: (error as any).message });
+        }
+      }
+    );
+
+    socket.onAny(
+      async (
+        event: string,
+        data: ServerUpdateRequest<T>,
+        ack: (res: ServerResponse<T>) => void
+      ) => {
+        if (
+          event.startsWith("update" + this.className) &&
+          event.replace("update" + this.className, "").length === 24
+        ) {
+          try {
+            const id = event.replace("update" + this.className, "");
+            let obj = this.classes[id];
+            if (typeof obj === "string")
+              this.classes[id] = obj = await this.handleGetMissingObject(obj);
+            if (typeof obj === "string") throw new Error(`Never...`);
+            obj.setValue(data.key as any, data.value);
+            ack({
+              data: obj.extractedData,
+              success: true,
+              message: "Updated successfully",
+            });
+          } catch (error) {
+            ack({ success: false, message: (error as any).message });
+          }
+        } else if (
+          event.startsWith("get" + this.className) &&
+          event.replace("get" + this.className, "").length === 24
+        ) {
+          try {
+            const id = event.replace("get" + this.className, "");
+            let obj = this.classes[id];
+            ack({
+              data: obj.extractedData,
+              success: true,
+              message: "Updated successfully",
+            });
+          } catch (error) {
+            ack({ success: false, message: (error as any).message });
+          }
+        }
+      }
+    );
+    socket.on("disconnect", () => {
+      this.clientSockets.delete(socket);
+    });
+  }
+
+  protected async handleGetMissingObject(_id: string) {
+    const document = await this.model.findById(_id);
+    if (!document) throw new Error(`No document with id ${_id} in DB.`);
+    if (!this.classers) throw new Error(`No classers.`);
+    return await createAutoUpdatedClass(
+      this.classParam,
+      this.socket,
+      document,
+      this.loggers,
+      this.classers
+    );
+  }
+
+  public async createObject(data: Omit<IsData<InstanceType<T>>, "_id">) {
+    if (!this.classers) throw new Error(`No classers.`);
+    (data as any)._id = undefined;
+    const entry = await this.model.create(data);
+    const object = await createAutoUpdatedClass(
+      this.classParam,
+      this.socket,
+      entry,
+      this.loggers,
+      this.classers
+    );
+    this.classes[object._id] = object;
+    this.classesAsArray.push(object);
+    this.socket.emit("new" + this.classParam.name, await object._id);
+    return object;
+  }
+}