@prestizni-software/client-dem 0.2.21 → 0.2.23

package/dist/CommonTypes.d.ts

@@ -0,0 +1,78 @@
+import { DefaultEventsMap, Server } from "socket.io";
+import { Socket as SocketClient } from "socket.io-client";
+import { ObjectId } from "bson";
+import { AutoUpdated } from "./AutoUpdatedClientObjectClass.js";
+import "reflect-metadata";
+export type Ref<T> = string | (T extends Constructor<any> ? AutoUpdated<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;
+    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 declare function classProp(target: any, propertyKey: string): void;
+export declare function classRef(target: any, propertyKey: string): void;
+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;
+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]>;
+};
+export type RefToId<T> = {
+    [K in keyof T]: T[K] extends Ref<infer U> ? string : T[K];
+};
+export type InstanceOf<T> = T extends Constructor<infer I> ? I : T;
+export type NeededTypeAtPath<C extends Constructor<any>, T> = {
+    [P in Paths<C>]: PathValueOf<C, P> extends T ? P : never;
+}[Paths<C>];
+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;
+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>>;
+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>;
+export type Pretty<T> = {
+    [K in keyof T]: T[K];
+};
+export {};

package/dist/CommonTypes.js

@@ -0,0 +1,10 @@
+import "reflect-metadata";
+export function classProp(target, propertyKey) {
+    const props = Reflect.getMetadata("props", target) || [];
+    props.push(propertyKey);
+    Reflect.defineMetadata("props", props, target);
+}
+export function classRef(target, propertyKey) {
+    Reflect.defineMetadata("isRef", true, target, propertyKey);
+}
+//# sourceMappingURL=CommonTypes.js.map

package/dist/CommonTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommonTypes.js","sourceRoot":"","sources":["../CommonTypes.ts"],"names":[],"mappings":"AAIA,OAAO,kBAAkB,CAAC;AAyC1B,MAAM,UAAU,SAAS,CAAC,MAAW,EAAE,WAAmB;IACxD,MAAM,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC;IACzD,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACxB,OAAO,CAAC,cAAc,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,MAAW,EAAE,WAAmB;IACvD,OAAO,CAAC,cAAc,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;AAC7D,CAAC"}

package/dist/client.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client.js

@@ -0,0 +1,11 @@
+import * as AutoUpdateClientManagerClass from "./AutoUpdateClientManagerClass.js";
+import * as AutoUpdateManagerClass from "./AutoUpdateManagerClass.js";
+import * as AutoUpdatedClientObjectClass from "./AutoUpdatedClientObjectClass.js";
+import * as CommonTypes from "./CommonTypes.js";
+module.exports = {
+    AutoUpdateClientManagerClass,
+    AutoUpdateManagerClass,
+    AutoUpdatedClientObjectClass,
+    CommonTypes,
+};
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,4BAA4B,MAAM,mCAAmC,CAAC;AAClF,OAAO,KAAK,sBAAsB,MAAM,6BAA6B,CAAC;AACtE,OAAO,KAAK,4BAA4B,MAAM,mCAAmC,CAAC;AAClF,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC;AAEhD,MAAM,CAAC,OAAO,GAAG;IACf,4BAA4B;IAC5B,sBAAsB;IACtB,4BAA4B;IAC5B,WAAW;CACZ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prestizni-software/client-dem",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "description": "An solution for when making http requests is not a good solution",
   "keywords": [
     "websockets"
@@ -8,7 +8,12 @@
   "license": "ISC",
   "author": "xx0055",
   "type": "module",
-  "main": "client.ts",
+  "main": "./dist/client.js",
+  "module": "./dist/client.mjs",
+  "types": "./dist/client.d.ts",
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"

package/AutoUpdateClientManagerClass.ts

@@ -1,82 +0,0 @@
-import { Socket } from "socket.io-client";
-import { AutoUpdateManager } from "./AutoUpdateManagerClass.ts";
-import { createAutoUpdatedClass } from "./AutoUpdatedClientObjectClass.ts";
-import { Constructor, IsData, LoggersType } from "./CommonTypes.ts";
-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>;
-  const emitter =  new EventTarget();
-  for (const key in defs) {
-    const Model = defs[key];
-    const c = new AutoUpdateClientManager(
-      Model,
-      loggers,
-      socket,
-      classers as any,
-      emitter
-    );
-    classers[key] = c;
-    await c.isLoadedAsync();
-  }
-
-  return classers;
-}
-
-export class AutoUpdateClientManager<
-  T extends Constructor<any>
-> extends AutoUpdateManager<T> {
-  constructor(
-    classParam: T,
-    loggers: LoggersType,
-    socket: Socket,
-    classers: Record<string, AutoUpdateManager<any>>,
-    emitter: EventTarget
-  ) {
-    super(classParam, socket, loggers, classers, emitter);
-    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]);
-      }
-      emitter.dispatchEvent(new Event("ManagerLoaded"+this.classParam.name+this.className));
-    });
-    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,
-      this.emitter
-    );
-  }
-
-  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.emitter
-    );
-    this.classes[object._id as any] = object;
-    return object;
-  }
-}

package/AutoUpdateManagerClass.ts

@@ -1,83 +0,0 @@
-import { AutoUpdated } from "./AutoUpdatedClientObjectClass.ts";
-import { Constructor, IsData, LoggersType, SocketType } from "./CommonTypes.ts";
-import "reflect-metadata";
-
-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>[] = [];
-  protected emitter: EventTarget;
-  private isLoaded = false;
-  constructor(
-    classParam: T,
-    socket: SocketType,
-    loggers: LoggersType,
-    classers: Record<string, AutoUpdateManager<any>>,
-    emitter: EventTarget
-  ) {
-    this.emitter = emitter;
-    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 isLoadedAsync(): Promise<boolean> {
-    if (this.isLoaded) return this.isLoaded;
-    await new Promise((resolve) => this.emitter.addEventListener("ManagerLoaded"+this.classParam.name+this.className, resolve));
-    this.isLoaded = true;
-    return this.isLoaded;
-  }
-
-  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>>;
-}