@prestizni-software/client-dem 0.1.26

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/AutoUpdatedClientObjectClass.ts

@@ -0,0 +1,434 @@
+import EventEmitter from "node:events";
+import "reflect-metadata";
+import {
+  Constructor,
+  DeRef,
+  InstanceOf,
+  IsData,
+  LoggersType,
+  LoggersTypeInternal,
+  Paths,
+  PathValueOf,
+  ServerResponse,
+  ServerUpdateRequest,
+  SocketType,
+} from "./CommonTypes.js";
+import { AutoUpdateManager } from "./AutoUpdateManagerClass.js";
+import { ObjectId } from "bson";
+
+export type AutoUpdated<T extends Constructor<any>> =
+  AutoUpdatedClientObject<T> & DeRef<InstanceOf<T>>;
+export async function createAutoUpdatedClass<C extends Constructor<any>>(
+  classParam: C,
+  socket: SocketType,
+  data: IsData<InstanceType<C>> | string,
+  loggers: LoggersType,
+  autoClassers: { [key: string]: AutoUpdateManager<any> }
+): Promise<AutoUpdated<C>> {
+  if (typeof data !== "string")
+    processIsRefProperties(data, classParam.prototype, undefined, [], loggers);
+
+  const instance = new (class extends AutoUpdatedClientObject<C> {})(
+    socket,
+    data,
+    loggers,
+    Reflect.getMetadata("props", classParam.prototype),
+    classParam.name,
+    classParam,
+    autoClassers
+  );
+
+  await instance.isLoadedAsync();
+
+  return instance as any;
+}
+
+export abstract class AutoUpdatedClientObject<T extends Constructor<any>> {
+  protected readonly socket: SocketType;
+  //protected updates: string[] = [];
+  protected data: IsData<T>;
+  protected readonly isServer: boolean = false;
+  protected readonly loggers: LoggersTypeInternal = {
+    info: () => {},
+    debug: () => {},
+    error: () => {},
+    warn: () => {},
+  };
+  protected isLoading = false;
+  protected readonly emitter = new EventEmitter();
+  protected readonly properties: (keyof T)[];
+  protected readonly className: string;
+  protected autoClassers: Record<string, AutoUpdateManager<any>>;
+  protected isLoadingReferences = false;
+  public readonly classProp: Constructor<T>;
+
+  private readonly loadShit = async () => {
+    if (this.isLoaded()) {
+      try {
+        await this.loadForceReferences();
+      } catch (error) {
+        this.loggers.error(error);
+      }
+      this.isLoadingReferences = false;
+
+      return;
+    }
+    this.emitter.once("loaded", async () => {
+      try {
+        await this.loadForceReferences();
+      } catch (error) {
+        this.loggers.error(error);
+      }
+      this.isLoadingReferences = false;
+    });
+  };
+  constructor(
+    socket: SocketType,
+    data: string | IsData<T>,
+    loggers: LoggersType,
+    properties: (keyof T)[],
+    className: string,
+    classProperty: Constructor<T>,
+    autoClassers: Record<string, AutoUpdateManager<any>>
+  ) {
+    this.classProp = classProperty;
+    this.isLoadingReferences = true;
+    this.isLoading = true;
+    this.autoClassers = autoClassers;
+    this.className = className;
+    this.properties = properties;
+    this.loggers.debug = loggers.debug;
+    this.loggers.info = loggers.info;
+    this.loggers.error = loggers.error;
+    this.loggers.warn = loggers.warn ?? loggers.info;
+    this.socket = socket;
+    if (typeof data === "string") {
+      if (data === "")
+        throw new Error(
+          "Cannot create a new AutoUpdatedClientClass with an empty string for ID."
+        );
+      this.socket.emit(
+        "get" + this.className + data,
+        null,
+        (res: ServerResponse<T>) => {
+          if (!res.success) {
+            this.isLoading = false;
+            this.loggers.error("Could not load data from server:", res.message);
+            this.emitter.emit("loaded");
+            return;
+          }
+          this.data = res.data as IsData<T>;
+          this.isLoading = false;
+          this.emitter.emit("loaded");
+        }
+      );
+      this.data = { _id: data } as IsData<T>;
+    } else {
+      this.isLoading = true;
+      this.data = data;
+      if (this.data._id === "") this.handleNewObject(data);
+      else this.isLoading = false;
+    }
+    if (!this.isServer) this.openSockets();
+    this.generateSettersAndGetters();
+  }
+
+  protected handleNewObject(data: IsData<T>) {
+    this.isLoading = true;
+    if (!this.className)
+      throw new Error(
+        "Cannot create a new AutoUpdatedClientClass without a class name."
+      );
+    this.socket.emit("new" + this.className, data, (res: ServerResponse<T>) => {
+      if (!res.success) {
+        this.isLoading = false;
+        this.loggers.error("Could not create data on server:", res.message);
+        this.emitter.emit("loaded");
+        return;
+      }
+      this.data = res.data as IsData<T>;
+      this.isLoading = false;
+      this.emitter.emit("loaded");
+    });
+  }
+
+  public get extractedData(): {
+    [K in keyof InstanceType<T>]: InstanceOf<InstanceType<T>>[K];
+  } {
+    return structuredClone(this.data) as any as {
+      [K in keyof InstanceType<T>]: InstanceOf<InstanceType<T>>[K];
+    };
+  }
+
+  public isLoaded(): boolean {
+    return !this.isLoading;
+  }
+
+  public async isLoadedAsync(): Promise<boolean> {
+    await this.loadShit();
+    return this.isLoading
+      ? new Promise((resolve) => {
+          this.emitter.once("loaded", () => {
+            resolve(this.isLoading === false);
+          });
+        })
+      : true;
+  }
+
+  private openSockets() {
+    this.loggers.debug(`[${this.data._id}] Opening socket listeners`);
+
+    this.socket.on(
+      "update" + this.className + this.data._id,
+      async (update: ServerUpdateRequest<T>) => {
+        await this.handleUpdateRequest(update);
+      }
+    );
+  }
+  // Example server-side handler
+  private async handleUpdateRequest(
+    update: ServerUpdateRequest<T>
+  ): Promise<ServerResponse<undefined>> {
+    try {
+      const path = update.key.split(".");
+      let dataRef: any = this.data;
+      for (let i = 0; i < path.length - 1; i++) {
+        if (!dataRef[path[i]]) dataRef[path[i]] = {};
+        dataRef = dataRef[path[i]];
+      }
+      dataRef[path.at(-1)!] = update.value;
+
+      this.loggers.debug(
+        `[${this.data._id}] Applied patch ${update.key} set to ${update.value}`
+      );
+
+      // Return success with the applied patch
+      return { success: true, data: undefined, message: "" };
+    } catch (error) {
+      this.loggers.error(`[${this.data._id}] Error applying patch:`, error);
+      return {
+        success: false,
+        message: "Error applying update: " + (error as Error).message,
+      };
+    }
+  }
+
+  private generateSettersAndGetters() {
+    this.properties.forEach((key) => {
+      if (typeof key !== "string") return;
+
+      const k = key as keyof IsData<T>;
+      const isRef = this.getMetadataRecursive(
+        "isRef",
+        this.classProp.prototype,
+        key
+      );
+
+      Object.defineProperty(this, key, {
+        get: () =>
+          isRef ? this.findReference(this.data[k] as string) : this.data[k],
+        set: () => {
+          throw new Error(
+            `Cannot set ${key} this way, use "setValue" function.`
+          );
+        },
+        enumerable: true,
+        configurable: true,
+      });
+    });
+  }
+
+  protected findReference(id: string): AutoUpdated<any> | undefined {
+    for (const classer of Object.values(this.autoClassers)) {
+      const result = classer.getObject(id);
+      if (result) return result;
+    }
+  }
+
+  public async setValue<K extends Paths<InstanceOf<T>>>(
+    key: K,
+    val: PathValueOf<T, K>
+  ): Promise<boolean> {
+    let value = val as any;
+    this.loggers.debug(
+      `[${(this.data as any)._id}] Setting ${key} to ${value}`
+    );
+    try {
+      if (value instanceof AutoUpdatedClientObject)
+        value = (value as any).extractedData._id;
+      const path = key.split(".");
+      let obj = this.data as any;
+      let lastClass = this as any;
+      let lastPath = key as string;
+      for (let i = 0; i < path.length - 1; i++) {
+        if (
+          typeof obj[path[i]] !== "object" ||
+          obj[path[i]] instanceof ObjectId
+        ) {
+          let temp = this.resolveReference(
+            obj[path[i]].toString()
+          ) as AutoUpdated<any>;
+          if (!temp) {
+            return false;
+          }
+          lastClass = temp;
+          lastPath = path.slice(i + 1).join(".");
+          return await lastClass.setValue(lastPath, value);
+        } else obj = obj[path[i]];
+      }
+
+      if (lastClass !== this || lastPath !== (key as any))
+        throw new Error("???");
+
+      const success = await this.setValueInternal(lastPath, value);
+
+      if (!success) {
+        return false;
+      }
+      const pathArr = lastPath.split(".");
+      if (pathArr.length === 1) {
+        (this.data as any)[key as any] = value;
+        return true;
+      }
+      const pathMinusLast = pathArr.splice(0, 1);
+      let ref = this as any;
+      for (const p of pathMinusLast) {
+        ref = ref[p];
+      }
+      ref[pathArr.at(-1)!] = value;
+      return true;
+    } catch (error) {
+      this.loggers.error(error);
+      return false;
+    }
+  }
+
+  protected async setValueInternal(key: string, value: any): Promise<boolean> {
+    const update: ServerUpdateRequest<T> = this.makeUpdate(key, value);
+    const promise = new Promise<boolean>((resolve) => {
+      try {
+        this.socket.emit(
+          "update" + this.className + this.data._id,
+          update,
+          (res: ServerResponse<T>) => {
+            resolve(res.success);
+          }
+        );
+      } catch (error) {
+        this.loggers.error("Error sending update:", error);
+        resolve(false);
+      }
+    });
+    return promise;
+  }
+
+  protected makeUpdate(key: string, value: any): any {
+    const id = this.data._id.toString();
+    return { _id: id, key, value } as any;
+  }
+
+  private getMetadataRecursive(metaKey: string, proto: any, prop: string) {
+    while (proto) {
+      const meta = Reflect.getMetadata(metaKey, proto, prop);
+      if (meta !== undefined) return meta;
+      proto = Object.getPrototypeOf(proto);
+    }
+    return undefined;
+  }
+
+  // return a properly typed AutoUpdatedClientClass (or null)
+  // inside AutoUpdatedClientClass
+  protected resolveReference(id: string): AutoUpdatedClientObject<any> | null {
+    if (!this.autoClassers) throw new Error("No autoClassers");
+    for (const autoClasser of Object.values(this.autoClassers)) {
+      const data = autoClasser.getObject(id);
+      if (data) return data;
+    }
+    return null;
+  }
+
+  private async loadForceReferences(
+    obj: any = this.data,
+    proto: any = Object.getPrototypeOf(this)
+  ) {
+    const props: string[] = Reflect.getMetadata("props", proto) || [];
+
+    for (const key of props) {
+      const isRef = Reflect.getMetadata("isRef", proto, key);
+
+      if (isRef) {
+        await this.handleLoadOnForced(obj, key);
+      }
+
+      // If the property itself is a nested object, check deeper
+      if (obj[key] && typeof obj[key] === "object") {
+        const nestedProto = Object.getPrototypeOf(obj[key]);
+        if (nestedProto) {
+          await this.loadForceReferences(obj[key], nestedProto);
+        }
+      }
+    }
+  }
+
+  private async handleLoadOnForced(obj: any, key: string) {
+    if (!this.autoClassers) throw new Error("No autoClassers");
+    const refId = obj[key];
+    if (refId) {
+      for (const classer of Object.values(this.autoClassers)) {
+        const result = classer.getObject(refId);
+        if (result) {
+          obj[key] = result;
+
+          // Recursively load refs inside the resolved object
+          if (typeof result.loadForceReferences === "function") {
+            await result.loadForceReferences();
+          }
+          break;
+        }
+      }
+    }
+  }
+  public async destroy(): Promise<void> {
+    this.socket.emit("delete" + this.className, this.data._id);
+    this.wipeSelf();
+  }
+
+  protected wipeSelf() {
+    for (const key of Object.keys(this.data)) {
+      delete (this.data as any)[key];
+    }
+    this.loggers.info(`[${this.data._id}] ${this.className} object wiped`);
+  }
+}
+
+export function processIsRefProperties(
+  instance: any,
+  target: any,
+  prefix = "",
+  allProps: string[] = [],
+  loggers?: LoggersType
+) {
+  const props: string[] = Reflect.getMetadata("props", target) || [];
+
+  for (const prop of props) {
+    const path = prefix ? `${prefix}.${prop}` : prop;
+    allProps.push(path);
+    if (Reflect.getMetadata("isRef", target, prop)) {
+      // 👇 here’s where you mutate
+      (loggers ?? console).debug("Changing isRef:", path);
+
+      // Example: replace with a proxy or a marker object
+      instance[prop] = instance[prop]._id;
+    }
+
+    // recurse into nested objects
+    const type = Reflect.getMetadata("design:type", target, prop);
+    if (type?.prototype) {
+      const nestedProps = Reflect.getMetadata("props", type.prototype);
+      if (nestedProps && instance[prop]) {
+        processIsRefProperties(instance[prop], type.prototype, path, allProps);
+      }
+    }
+  }
+  return allProps;
+}

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+### 0.1.26 (2025-11-04)
+
+# Changelog
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.

package/CommonTypes.ts

@@ -0,0 +1,159 @@
+import { DefaultEventsMap, Server } from "socket.io";
+import { Socket as SocketClient } from "socket.io-client";
+import { ObjectId } from "bson";
+import { Test } from "./server.js";
+
+export type Ref<T> = T & { _id: string };
+export type LoggersTypeInternal = LoggersType & {
+  warn: (...args: any[]) => void;
+};
+
+export type LoggersType = {
+  info: (...args: any[]) => void;
+  debug: (...args: any[]) => void;
+  error: (...args: any[]) => void;
+  warn?: (...args: any[]) => void;
+};
+export type SocketType =
+  | SocketClient<DefaultEventsMap, DefaultEventsMap>
+  | Server<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>;
+export type IsData<T> = T extends { _id: string | ObjectId } ? T : never;
+export type ServerResponse<T> =
+  | {
+      data: T; // in this case, the applied patch
+      message: string;
+      success: true;
+    }
+  | {
+      data?: null;
+      message: string;
+      success: false;
+    };
+
+export type ServerUpdateResponse<T> = {
+  data: Partial<IsData<T>>;
+  message: string;
+  success: true;
+  updateId: string;
+};
+
+export type ServerUpdateRequest<T> = {
+  _id: string;
+  key: string;
+  value: any;
+};
+export function classProp(target: any, propertyKey: string) {
+  const props = Reflect.getMetadata("props", target) || [];
+  props.push(propertyKey);
+  Reflect.defineMetadata("props", props, target);
+}
+
+export function classRef(target: any, propertyKey: string) {
+  Reflect.defineMetadata("isRef", true, target, propertyKey);
+}
+
+// ---------------------- Core ----------------------
+export type AutoProps<T> = {
+  readonly [K in keyof T]: T[K];
+};
+
+export type Constructor<T> = new (...args: any[]) => T;
+export type UnboxConstructor<T> = T extends new (...args: any[]) => infer I
+  ? I
+  : T;
+
+// ---------------------- DeRef ----------------------
+export type NonOptional<T> = Exclude<T, null | undefined>;
+
+export type DeRef<T> = {
+  [K in keyof T]: T[K] extends Ref<infer U>
+    ? NonOptional<U>
+    : T[K] extends Ref<infer U> | null | undefined
+    ? NonOptional<U>
+    : NonOptional<T[K]>;
+};
+
+// ---------------------- Instance helper ----------------------
+export type InstanceOf<T> = T extends Constructor<infer I> ? I : T;
+
+// Generic filter for any desired type
+export type NeededTypeAtPath<C extends Constructor<any>, T> = {
+  [P in Paths<C>]: PathValueOf<C, P> extends T ? P : never;
+}[Paths<C>];
+
+// ---------------------- Paths ----------------------
+
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+type StripPrototypePrefix<P extends string> = P extends "prototype"
+  ? never
+  : P extends `prototype.${infer Rest}`
+  ? Rest
+  : P;
+
+type ResolveRef<T> = T extends Ref<infer U> ? U : T;
+type Recurseable<T> = T extends object
+  ? T extends Array<any> | Function
+    ? never
+    : T
+  : never;
+type Join<K extends string, P extends string> = `${K}.${P}`;
+type OnlyClassKeys<T> = {
+  [K in keyof T]: K;
+}[keyof T] &
+  string;
+// ---------------------- Paths ----------------------
+export type Paths<
+  T,
+  Depth extends number = 5,
+  OriginalDepth extends number = Depth
+> = Depth extends never
+  ? never
+  : {
+      [K in OnlyClassKeys<DeRef<NonOptional<T>>>]: K extends "_id"
+        ? StripPrototypePrefix<`${K}`>
+        : StripPrototypePrefix<
+            PathsHelper<K, DeRef<NonOptional<T>>[K], Depth, OriginalDepth>
+          >;
+    }[OnlyClassKeys<DeRef<NonOptional<T>>>];
+
+type PathsHelper<
+  K extends string,
+  V,
+  Depth extends number,
+  OriginalDepth extends number
+> = Recurseable<V> extends never
+  ? `${K}`
+  : `${K}` | Join<K, Paths<DeRef<NonOptional<V>>, Prev[Depth], OriginalDepth>>;
+
+// ---------------------- PathValueOf ----------------------
+type Split<S extends string> = S extends `${infer L}.${infer R}`
+  ? [L, ...Split<R>]
+  : [S];
+
+type PathValue<
+  T,
+  Parts extends readonly string[],
+  Depth extends number = 5
+> = Depth extends 0
+  ? any
+  : Parts extends [infer K, ...infer Rest]
+  ? K extends keyof T
+    ? Rest extends readonly string[]
+      ? Rest["length"] extends 0
+        ? ResolveRef<T[K]>
+        : PathValue<ResolveRef<T[K]>, Rest, Prev[Depth]>
+      : never
+    : never
+  : T;
+
+export type PathValueOf<
+  T,
+  P extends string,
+  Depth extends number = 5
+> = PathValue<DeRef<InstanceOf<T>>, Split<P>, Depth>;
+
+// ---------------------- Pretty ----------------------
+export type Pretty<T> = { [K in keyof T]: T[K] };
+
+let test1: Paths<Test> = "test2";
+let test2: PathValueOf<Test, "test2.loggers2">;

package/client.ts

@@ -0,0 +1,120 @@
+import { io } from "socket.io-client";
+import readline from "readline";
+import { classProp, classRef, LoggersType } from "./CommonTypes.js";
+import { AUCManagerFactory } from "./AutoUpdateClientManagerClass.js";
+
+class Test2 {
+  @classProp public _id!: string;
+  @classProp public login!: string;
+  @classProp public loggers!: LoggersType;
+  public func = () => {
+    console.log("func");
+  };
+}
+
+class Test {
+  @classProp public _id!: string;
+  @classProp public login!: string[];
+  @classProp public loggers!: LoggersType;
+
+  // mark as compile-time Ref<Test2> (runtime is still string id)
+  @classProp @classRef public test2!: Test2;
+
+  // force-loaded ref
+  @classProp @classRef public test3!: Test2;
+}
+const loggers: LoggersType = {
+  info: console.log,
+  debug: console.debug,
+  error: console.error,
+  warn: console.warn,
+};
+
+const socket = io("http://localhost:3000", {
+  extraHeaders: {
+    //HEADRY
+    Authorization: "Bearer " + "token",
+  },
+});
+socket.on("connect", async () => {
+  
+  const classers = await AUCManagerFactory({ Test, Test2 }, loggers, socket);
+
+  // ---------------------- Setup CLI ----------------------
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  setTimeout(async () => {
+    const ass = ((classers).Test.getObject("68c9f23872cff1778cb1abe2"));
+    ass?.test2.loggers.info("test");
+    ass?.test2.func();
+  }, 100);
+  
+  // ---------------------- Interactive CLI ----------------------
+  function prompt() {
+    rl.question(
+      "\nCommands:\n[list] List all collections\n[show <collection> <id> <field?>] Show object\n[set <collection> <id> <field> <value>] Update field\n[new <collection>] Request new object\n[exit] Exit\n> ",
+      async (input) => {
+        const args = input.trim().split(" ");
+        const cmd = args[0];
+
+        switch (cmd) {
+          case "list":
+            console.log("Collections:");
+            for (const classer of Object.values(classers)) {
+              console.log(`- ${classer.className}`);
+              for (const id of classer.objectIDs) {
+                console.log(`   • ${id}`);
+              }
+            }
+            break;
+
+          case "show":
+            if (args.length < 3)
+              return console.log("❌ Usage: show <collection> <id> <field?>");
+
+            const objShow = await (classers as any)[args[1]]?.getClass(args[2]);
+            if (!objShow) return console.log("❌ Collection not found");
+
+            if (args[3]) {
+              const val = objShow.getValue(args[3]);
+              console.log(val !== undefined ? val : "❌ Field not found");
+            } else {
+              console.log(objShow.extractData);
+            }
+            break;
+
+          case "set":
+            if (args.length < 5)
+              return console.log(
+                "❌ Usage: set <collection> <id> <field> <value>"
+              );
+
+            const objSet = await (classers as any)[args[1]]?.getClass(args[2]);
+            if (!objSet) return console.log("❌ Object not found");
+
+            const fieldPath = args[3];
+            const value = args.slice(4).join(" "); // allow spaces in value
+
+            if (fieldPath === "_id") return console.log("❌ Cannot change _id");
+
+            objSet.setValue(fieldPath, value);
+            console.log(`✅ Updated ${fieldPath} = ${value}`);
+            break;
+
+          case "exit":
+            console.log("👋 Exiting...");
+            process.exit(0);
+
+          default:
+            console.log("❌ Unknown command");
+        }
+
+        prompt();
+      }
+    );
+  }
+  prompt();
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@prestizni-software/client-dem",
+  "version": "0.1.26",
+  "description": "An solution for when making http requests is not a good solution",
+  "keywords": [
+    "websockets"
+  ],
+  "license": "ISC",
+  "author": "xx0055",
+  "type": "module",
+  "main": "none",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "release": "standard-version && git push --follow-tags && npm publish --access public"
+  },
+  "dependencies": {
+    "socket.io": "^4.8.1",
+    "socket.io-client": "^4.8.1"
+  }
+}