@prestizni-software/server-dem 0.2.4 → 0.2.6

package/AutoUpdateManagerClass.ts

@@ -1,71 +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>>;
-}
+import { AutoUpdated } from "./AutoUpdatedClientObjectClass.ts";
+import { Constructor, IsData, LoggersType, SocketType } from "./CommonTypes.ts";
+
+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

@@ -1,6 +1,6 @@
 import { Server, Socket } from "socket.io";
-import { AutoUpdateManager } from "./AutoUpdateManagerClass.js";
-import { createAutoUpdatedClass } from "./AutoUpdatedServerObjectClass.js";
+import { AutoUpdateManager } from "./AutoUpdateManagerClass.ts";
+import { createAutoUpdatedClass } from "./AutoUpdatedServerObjectClass.ts";
 import {
   Constructor,
   IsData,
@@ -8,8 +8,8 @@ import {
   Paths,
   ServerResponse,
   ServerUpdateRequest,
-} from "./CommonTypes.js";
-import { BeAnObject, ReturnModelType } from "@typegoose/typegoose/lib/types.js";
+} from "./CommonTypes.ts";
+import { BeAnObject, ReturnModelType } from "@typegoose/typegoose/lib/types.ts";
 import { getModelForClass } from "@typegoose/typegoose";
 export type WrappedInstances<T extends Record<string, Constructor<any>>> = {
   [K in keyof T]: AutoUpdateServerManager<T[K]>;

package/AutoUpdatedClientObjectClass.ts

@@ -12,8 +12,8 @@ import {
   ServerResponse,
   ServerUpdateRequest,
   SocketType,
-} from "./CommonTypes.js";
-import { AutoUpdateManager } from "./AutoUpdateManagerClass.js";
+} from "./CommonTypes.ts";
+import { AutoUpdateManager } from "./AutoUpdateManagerClass.ts";
 import { ObjectId } from "bson";
 
 export type AutoUpdated<T extends Constructor<any>> =

package/AutoUpdatedServerObjectClass.ts

@@ -1,107 +1,107 @@
-import { IObjectWithTypegooseFunction } from "@typegoose/typegoose/lib/types.js";
-import { Types, Document } from "mongoose";
-import { AutoUpdatedClientObject } from "./AutoUpdatedClientObjectClass.js";
-import {
-  AutoProps,
-  Constructor,
-  DeRef,
-  IsData,
-  LoggersType,
-  ServerUpdateRequest,
-  SocketType,
-  UnboxConstructor,
-} from "./CommonTypes.js";
-import { AutoUpdateManager } from "./AutoUpdateManagerClass.js";
-import { AutoUpdateServerManager } from "./AutoUpdateServerManagerClass.js";
-import "reflect-metadata";
-
-export type AutoUpdated<T extends Constructor<any>> = AutoUpdatedServerObject<T> & UnboxConstructor<T>;
-
-export async function createAutoUpdatedClass<C extends Constructor<any>>(
-  classParam: C,
-  socket: SocketType,
-  data: DocWithProps<InstanceType<C>>,
-  loggers: LoggersType,
-  autoClassers: Record<string, AutoUpdateManager<any>>
-): Promise<AutoProps<C> & AutoUpdated<InstanceType<C>> & DeRef<InstanceType<C>>> {
-  const instance = new (class extends AutoUpdatedServerObject<
-    InstanceType<C>
-  > {})(
-    socket,
-    data,
-    loggers,
-    Reflect.getMetadata(
-      "props",
-      classParam.prototype
-    ) as (keyof InstanceType<C>)[],
-    classParam.name,
-    classParam,
-    autoClassers
-  );
-  await instance.isLoadedAsync();
-  return instance as AutoProps<C> & AutoUpdated<InstanceType<C>> & DeRef<InstanceType<C>>;
-}
-
-// ---------------------- Class ----------------------
-export abstract class AutoUpdatedServerObject<
-  T extends Constructor<any>
-> extends AutoUpdatedClientObject<T> {
-  protected readonly isServer: boolean = true;
-  private readonly entry: DocWithProps<T>;
-
-  constructor(
-    socket: SocketType,
-    data: DocWithProps<T>,
-    loggers: {
-      info: (...args: any[]) => void;
-      debug: (...args: any[]) => void;
-      error: (...args: any[]) => void;
-      warn?: (...args: any[]) => void;
-    },
-    properties: (keyof T)[],
-    className: string,
-    classProp: Constructor<T>,
-    autoClassers: Record<string, AutoUpdateManager<any>>
-  ) {
-    super(
-      socket,
-      data.toObject(),
-      loggers,
-      properties,
-      className,
-      classProp,
-      autoClassers
-    );
-    this.entry = data;
-    this.socket.emit("new", { id: this.data._id, type: className });
-  }
-
-  protected handleNewObject(_data: IsData<T>) {
-    throw new Error("Cannot create new objects like this.");
-  }
-  protected async setValueInternal(key: string, value: any): Promise<boolean> {
-    try {
-      await (
-        this.autoClassers[this.className] as AutoUpdateServerManager<any>
-      ).model.updateOne({ _id: this.data._id }, { $set: { [key]: value } });
-
-      const update: ServerUpdateRequest<T> = this.makeUpdate(key, value);
-      this.socket.emit("update" + this.className + this.data._id, update);
-
-      return true;
-    } catch (error) {
-      this.loggers.error("Error saving object:", error);
-      return false;
-    }
-  }
-
-  public async destroy(): Promise<void> {
-    this.socket.emit("delete" + this.className, this.data._id);
-    await this.entry.deleteOne({ _id: this.data._id });
-    this.wipeSelf();
-  }
-}
-
-export type DocWithProps<T> = Document &
-  Omit<T & { _id: Types.ObjectId; __v: number }, "typegooseName"> &
-  IObjectWithTypegooseFunction;
+import { IObjectWithTypegooseFunction } from "@typegoose/typegoose/lib/types.ts";
+import { Types, Document } from "mongoose";
+import { AutoUpdatedClientObject } from "./AutoUpdatedClientObjectClass.ts";
+import {
+  AutoProps,
+  Constructor,
+  DeRef,
+  IsData,
+  LoggersType,
+  ServerUpdateRequest,
+  SocketType,
+  UnboxConstructor,
+} from "./CommonTypes.ts";
+import { AutoUpdateManager } from "./AutoUpdateManagerClass.ts";
+import { AutoUpdateServerManager } from "./AutoUpdateServerManagerClass.ts";
+import "reflect-metadata";
+
+export type AutoUpdated<T extends Constructor<any>> = AutoUpdatedServerObject<T> & UnboxConstructor<T>;
+
+export async function createAutoUpdatedClass<C extends Constructor<any>>(
+  classParam: C,
+  socket: SocketType,
+  data: DocWithProps<InstanceType<C>>,
+  loggers: LoggersType,
+  autoClassers: Record<string, AutoUpdateManager<any>>
+): Promise<AutoProps<C> & AutoUpdated<InstanceType<C>> & DeRef<InstanceType<C>>> {
+  const instance = new (class extends AutoUpdatedServerObject<
+    InstanceType<C>
+  > {})(
+    socket,
+    data,
+    loggers,
+    Reflect.getMetadata(
+      "props",
+      classParam.prototype
+    ) as (keyof InstanceType<C>)[],
+    classParam.name,
+    classParam,
+    autoClassers
+  );
+  await instance.isLoadedAsync();
+  return instance as AutoProps<C> & AutoUpdated<InstanceType<C>> & DeRef<InstanceType<C>>;
+}
+
+// ---------------------- Class ----------------------
+export abstract class AutoUpdatedServerObject<
+  T extends Constructor<any>
+> extends AutoUpdatedClientObject<T> {
+  protected readonly isServer: boolean = true;
+  private readonly entry: DocWithProps<T>;
+
+  constructor(
+    socket: SocketType,
+    data: DocWithProps<T>,
+    loggers: {
+      info: (...args: any[]) => void;
+      debug: (...args: any[]) => void;
+      error: (...args: any[]) => void;
+      warn?: (...args: any[]) => void;
+    },
+    properties: (keyof T)[],
+    className: string,
+    classProp: Constructor<T>,
+    autoClassers: Record<string, AutoUpdateManager<any>>
+  ) {
+    super(
+      socket,
+      data.toObject(),
+      loggers,
+      properties,
+      className,
+      classProp,
+      autoClassers
+    );
+    this.entry = data;
+    this.socket.emit("new", { id: this.data._id, type: className });
+  }
+
+  protected handleNewObject(_data: IsData<T>) {
+    throw new Error("Cannot create new objects like this.");
+  }
+  protected async setValueInternal(key: string, value: any): Promise<boolean> {
+    try {
+      await (
+        this.autoClassers[this.className] as AutoUpdateServerManager<any>
+      ).model.updateOne({ _id: this.data._id }, { $set: { [key]: value } });
+
+      const update: ServerUpdateRequest<T> = this.makeUpdate(key, value);
+      this.socket.emit("update" + this.className + this.data._id, update);
+
+      return true;
+    } catch (error) {
+      this.loggers.error("Error saving object:", error);
+      return false;
+    }
+  }
+
+  public async destroy(): Promise<void> {
+    this.socket.emit("delete" + this.className, this.data._id);
+    await this.entry.deleteOne({ _id: this.data._id });
+    this.wipeSelf();
+  }
+}
+
+export type DocWithProps<T> = Document &
+  Omit<T & { _id: Types.ObjectId; __v: number }, "typegooseName"> &
+  IObjectWithTypegooseFunction;

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 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.2.6](https://github.com/Prestizni-Software/server-dem/compare/v0.2.5...v0.2.6) (2025-11-06)
+
+### [0.2.5](https://github.com/Prestizni-Software/server-dem/compare/v0.2.4...v0.2.5) (2025-11-06)
+
 ### [0.2.4](https://github.com/Prestizni-Software/server-dem/compare/v0.2.3...v0.2.4) (2025-11-06)
 
 ### [0.2.3](https://github.com/Prestizni-Software/server-dem/compare/v0.2.2...v0.2.3) (2025-11-04)

package/CommonTypes.ts

@@ -1,9 +1,9 @@
 import { DefaultEventsMap, Server } from "socket.io";
 import { Socket as SocketClient } from "socket.io-client";
 import { ObjectId } from "bson";
-import { AutoUpdated } from "./AutoUpdatedClientObjectClass.js";
+import { AutoUpdated } from "./AutoUpdatedClientObjectClass.ts";
 
-export type Ref<T extends Constructor<any>> = T & { _id: string } | string | AutoUpdated<T>;
+export type Ref<T> = string | (T extends Constructor<any> ? AutoUpdated<T> : (T & { _id: string }));
 export type LoggersTypeInternal = LoggersType & {
   warn: (...args: any[]) => void;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prestizni-software/server-dem",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "An solution for when making http requests is not a good solution",
   "keywords": [
     "websockets"

package/server.ts

@@ -1,8 +1,8 @@
-import * as AutoUpdateServerManagerClass from "./AutoUpdateServerManagerClass.js";
-import * as AutoUpdateManagerClass from "./AutoUpdateManagerClass.js";
-import * as AutoUpdatedClientObjectClass from "./AutoUpdatedClientObjectClass.js";
-import * as AutoUpdatedServerObjectClass from "./AutoUpdatedServerObjectClass.js";
-import * as CommonTypes from "./CommonTypes.js";
+import * as AutoUpdateServerManagerClass from "./AutoUpdateServerManagerClass.ts";
+import * as AutoUpdateManagerClass from "./AutoUpdateManagerClass.ts";
+import * as AutoUpdatedClientObjectClass from "./AutoUpdatedClientObjectClass.ts";
+import * as AutoUpdatedServerObjectClass from "./AutoUpdatedServerObjectClass.ts";
+import * as CommonTypes from "./CommonTypes.ts";
 
 module.exports = {
   AutoUpdateServerManagerClass,