taon 21.0.51 → 21.0.53

package/lib-prod/realtime/realtime-server.js

@@ -0,0 +1,252 @@
+import { Subject } from "rxjs";
+import { ___NS__isArray, ___NS__isFunction, ___NS__isObject, ___NS__isString, Helpers__NS__error, UtilsOs__NS__isElectron, UtilsOs__NS__isWebSQL } from "tnp-core/lib-prod";
+import { ClassHelpers__NS__getClassFnFromObject, ClassHelpers__NS__getName, ClassHelpers__NS__getUniqueKey } from "../helpers/class-helpers";
+import { Symbols__NS__REALTIME } from "../symbols";
+class RealtimeServer {
+  // private jobs = {};
+  constructor(core) {
+    this.core = core;
+    this.core = core;
+    if (core.ctx.disabledRealtime || this.core.ctx.isRemoteHost) {
+      return;
+    }
+    this.init();
+  }
+  //#region methods & getters / init
+  init() {
+    const nspPathGlobal = this.core.pathFor();
+    const nspPathRealtime = this.core.pathFor(
+      Symbols__NS__REALTIME.NAMESPACE(this.core.ctx.contextName)
+    );
+    const cors = {
+      origin: this.core.ctx.frontendHostUri.origin,
+      // only origin needs to be set - pathname not needed
+      methods: this.core.allHttpMethods
+    };
+    this.core.connectSocketBE = this.core.strategy.ioServer(
+      UtilsOs__NS__isWebSQL ? this.core.ctx.uriOrigin : this.core.ctx.serverTcpUdp,
+      {
+        path: nspPathGlobal.pathname,
+        cors
+      },
+      // @ts-ignore
+      this.core.ctx
+    );
+    this.core.ctx.logRealtime && console.info(
+      `[backend] CREATE GLOBAL NAMESPACE: '${this.core.connectSocketBE.path()}' , path: '${nspPathGlobal.pathname}'`
+    );
+    this.core.connectSocketBE.on("connection", (clientSocket) => {
+      this.core.ctx.logRealtime && console.info(
+        `[backend] client connected to namespace "${nspPathGlobal.pathname}",  host: ${this.core.ctx.host}`
+      );
+    });
+    this.core.socketBE = this.core.strategy.ioServer(
+      UtilsOs__NS__isWebSQL || UtilsOs__NS__isElectron ? this.core.ctx.uriOrigin : this.core.ctx.serverTcpUdp,
+      {
+        path: nspPathRealtime.pathname,
+        cors
+      },
+      // @ts-ignore
+      this.core.ctx
+    );
+    this.core.ctx.logRealtime && console.info(
+      `[backend] CREATE REALTIME NAMESPACE: '${this.core.socketBE.path()}' , path: '${nspPathRealtime.pathname}' `
+    );
+    this.core.socketBE.on("connection", (backendSocketForClient) => {
+      this.core.ctx.logRealtime && console.info(
+        `[backend] client connected to namespace "${nspPathRealtime.pathname}",  host: ${this.core.ctx.host}`
+      );
+      backendSocketForClient.on(
+        Symbols__NS__REALTIME.ROOM_SUBSCRIBE_CUSTOM(this.core.ctx.contextName),
+        (roomName) => {
+          this.core.ctx.logRealtime && console.info(
+            `Joining room ${roomName} in namespace  REALTIME host: ${this.core.ctx.contextName}/${this.core.ctx.host}`
+          );
+          backendSocketForClient.join(roomName);
+        }
+      );
+      backendSocketForClient.on(
+        Symbols__NS__REALTIME.ROOM_SUBSCRIBE_ENTITY_UPDATE_EVENTS(
+          this.core.ctx.contextName
+        ),
+        (roomName) => {
+          this.core.ctx.logRealtime && console.info(
+            `[backend] Joining room ${roomName} in namespace  REALTIME host: ${this.core.ctx.contextName}/${this.core.ctx.host}`
+          );
+          backendSocketForClient.join(roomName);
+        }
+      );
+      backendSocketForClient.on(
+        Symbols__NS__REALTIME.ROOM_SUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(
+          this.core.ctx.contextName
+        ),
+        (roomName) => {
+          this.core.ctx.logRealtime && console.info(
+            `[backend] Joining room ${roomName} in namespace REALTIME  host: ${this.core.ctx.contextName}/${this.core.ctx.host}`
+          );
+          backendSocketForClient.join(roomName);
+        }
+      );
+      backendSocketForClient.on(
+        Symbols__NS__REALTIME.ROOM_UNSUBSCRIBE_CUSTOM(this.core.ctx.contextName),
+        (roomName) => {
+          this.core.ctx.logRealtime && console.info(
+            `[backend] Leaving room ${roomName} in namespace  REALTIME host: ${this.core.ctx.contextName}/${this.core.ctx.host}`
+          );
+          backendSocketForClient.leave(roomName);
+        }
+      );
+      backendSocketForClient.on(
+        Symbols__NS__REALTIME.ROOM_UNSUBSCRIBE_ENTITY_UPDATE_EVENTS(
+          this.core.ctx.contextName
+        ),
+        (roomName) => {
+          this.core.ctx.logRealtime && console.info(
+            `[backend] Leaving room ${roomName} in namespace REALTIME  host: ${this.core.ctx.contextName}/${this.core.ctx.host}`
+          );
+          backendSocketForClient.leave(roomName);
+        }
+      );
+      backendSocketForClient.on(
+        Symbols__NS__REALTIME.ROOM_UNSUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(
+          this.core.ctx.contextName
+        ),
+        (roomName) => {
+          this.core.ctx.logRealtime && console.info(
+            `[backend] Leaving room ${roomName} in namespace REALTIME  host: ${this.core.ctx.contextName}/${this.core.ctx.host}`
+          );
+          backendSocketForClient.leave(roomName);
+        }
+      );
+    });
+  }
+  //#endregion
+  //#region methods & getters / trigger changes
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  triggerChanges(entityObjOrClass, property, valueOfUniqueProperty, customEvent, customEventData) {
+    let roomName;
+    if (this.core.ctx.disabledRealtime || this.core.ctx.isRemoteHost) {
+      return;
+    }
+    if (customEvent) {
+      roomName = Symbols__NS__REALTIME.ROOM_NAME_CUSTOM(
+        this.core.ctx.contextName,
+        customEvent
+      );
+    } else {
+      let entityFn = entityObjOrClass;
+      const entityIsObject = !___NS__isFunction(entityObjOrClass) && ___NS__isObject(entityObjOrClass);
+      if (entityIsObject) {
+        entityFn = ClassHelpers__NS__getClassFnFromObject(entityObjOrClass);
+      }
+      const uniqueKey = ClassHelpers__NS__getUniqueKey(entityFn);
+      if (entityIsObject) {
+        valueOfUniqueProperty = entityObjOrClass[uniqueKey];
+      }
+      if (!valueOfUniqueProperty) {
+        Helpers__NS__error(
+          `[Taon][Realtime] Entity without iD ! ${ClassHelpers__NS__getName(
+            entityFn
+          )} `,
+          true,
+          true
+        );
+        return;
+      }
+      roomName = ___NS__isString(property) ? Symbols__NS__REALTIME.ROOM_NAME_UPDATE_ENTITY_PROPERTY(
+        this.core.ctx.contextName,
+        ClassHelpers__NS__getName(entityFn),
+        property,
+        valueOfUniqueProperty
+      ) : Symbols__NS__REALTIME.ROOM_NAME_UPDATE_ENTITY(
+        this.core.ctx.contextName,
+        ClassHelpers__NS__getName(entityFn),
+        valueOfUniqueProperty
+      );
+    }
+    this.core.socketBE.in(roomName).emit(
+      roomName,
+      // roomName == eventName in room na
+      customEvent ? customEventData : ""
+    );
+  }
+  //#endregion
+  //#region entity changes
+  //#region methods & getters / trigger entity changes
+  triggerEntityChanges(entityObjOrClass, idToTrigger) {
+    if (this.core.ctx.disabledRealtime) {
+      const className = ClassHelpers__NS__getName(entityObjOrClass);
+      console.warn(
+        `[Taon][TriggerEntityChanges] Entity "${className}' is not realtime`
+      );
+      return;
+    }
+    this.triggerChanges(entityObjOrClass, void 0, idToTrigger);
+  }
+  //#endregion
+  //#region methods & getters / trigger entity property changes
+  triggerEntityPropertyChanges(entityObjOrClass, property, idToTrigger) {
+    if (this.core.ctx.disabledRealtime) {
+      const className = ClassHelpers__NS__getName(entityObjOrClass);
+      console.warn(
+        `[Taon][TriggerEntityPropertyChanges][property=${property}] Entity "${className}' is not realtime`
+      );
+      return;
+    }
+    if (___NS__isArray(property)) {
+      property.forEach((propertyFromArr) => {
+        this.triggerChanges(
+          entityObjOrClass,
+          propertyFromArr,
+          idToTrigger
+        );
+      });
+    } else {
+      this.triggerChanges(entityObjOrClass, property, idToTrigger);
+    }
+  }
+  //#endregion
+  //#region methods & getters / trigger entity table changes
+  triggerEntityTableChanges(entityClassOrInstance) {
+    const className = ClassHelpers__NS__getName(entityClassOrInstance);
+    if (this.core.ctx.disabledRealtime) {
+      console.warn(
+        `[Taon][TriggerEntityTableChanges] Entity "${className}' is not realtime`
+      );
+      return;
+    }
+    this.triggerChanges(
+      entityClassOrInstance,
+      void 0,
+      void 0,
+      Symbols__NS__REALTIME.TABLE_CHANGE(this.core.ctx.contextName, className)
+    );
+  }
+  //#endregion
+  //#endregion
+  //#region custom changes
+  //#region methods & getters / trigger custom event
+  triggerCustomEvent(customEvent, dataToPush) {
+    this.triggerChanges(void 0, void 0, void 0, customEvent, dataToPush);
+  }
+  //#endregion
+  //#region methods & getters / listen custom events from users
+  /**
+   * Listen to custom events from users
+   * @param customEvent  global event name
+   */
+  listenChangesCustomEvent(customEvent) {
+    const sub = new Subject();
+    this.core.socketBE.on("connection", (backendSocketForClient) => {
+      backendSocketForClient.on(customEvent, (data, ...args) => {
+        sub.next(data);
+      });
+    });
+    return sub.asObservable();
+  }
+  //#endregion
+  //#endregion
+}
+export {
+  RealtimeServer
+};

package/lib-prod/realtime/realtime-strategy/index.js

@@ -0,0 +1,4 @@
+export * from "./realtime-strategy";
+export * from "./realtime-strategy-ipc";
+export * from "./realtime-strategy-mock";
+export * from "./realtime-strategy-socket-io";

package/lib-prod/realtime/realtime-strategy/realtime-strategy-ipc.js

@@ -0,0 +1,226 @@
+import { ipcMain } from "electron";
+import { Symbols__NS__REALTIME } from "../../symbols";
+import { RealtimeStrategy } from "./realtime-strategy";
+class MockServerIpc {
+  //#region constructor
+  constructor(contextName) {
+    this.contextName = contextName;
+    MockServerIpc.serverByContextName.set(contextName, this);
+  }
+  static serverByContextName = /* @__PURE__ */ new Map();
+  static from(contextName) {
+    if (!MockServerIpc.serverByContextName.has(contextName)) {
+      MockServerIpc.serverByContextName.set(
+        contextName,
+        new MockServerIpc(contextName)
+      );
+    }
+    return MockServerIpc.serverByContextName.get(contextName);
+  }
+  namespacesByName = /* @__PURE__ */ new Map();
+  //#endregion
+  //#region of
+  of(namespace) {
+    if (!this.namespacesByName.has(namespace)) {
+      this.namespacesByName.set(
+        namespace,
+        new MockNamespaceIpc(namespace, this)
+      );
+    }
+    return this.namespacesByName.get(namespace);
+  }
+  //#endregion
+}
+class MockNamespaceIpc {
+  //#endregion
+  //#region constructor
+  constructor(name, server) {
+    this.name = name;
+    this.server = server;
+  }
+  //#region fields & getters
+  electronClients = /* @__PURE__ */ new Set();
+  roomsByRoomName = {};
+  namespaceEventHandlers = {};
+  //#endregion
+  //#region on
+  on(eventName, callback) {
+    const listenKey = `(${this.name}) "${eventName}"`;
+    if (!this.namespaceEventHandlers[eventName]) {
+      this.namespaceEventHandlers[eventName] = /* @__PURE__ */ new Set();
+    }
+    this.namespaceEventHandlers[eventName].add(callback);
+    ipcMain.on(listenKey, (eventElectron, ...args) => {
+      this.electronClients.add(eventElectron.sender);
+      const connectionListener = `(${this.name}) "connection"`;
+      if (connectionListener === listenKey) {
+        callback(this, ...args);
+      } else {
+        if (eventName.includes(`:${Symbols__NS__REALTIME.KEYroomSubscribe}`)) {
+          const roomName = args[0];
+          this.join(eventElectron.sender, roomName);
+        } else if (eventName.includes(`:${Symbols__NS__REALTIME.KEYroomUnsubscribe}`)) {
+          const roomName = args[0];
+          this.leave(eventElectron.sender, roomName);
+        } else {
+          callback(...args);
+        }
+      }
+    });
+  }
+  //#endregion
+  //#region off
+  off(event, callback) {
+    if (!this.namespaceEventHandlers[event]) {
+      return;
+    }
+    if (callback) {
+      this.namespaceEventHandlers[event].delete(callback);
+    } else {
+      delete this.namespaceEventHandlers[event];
+    }
+    const removeKey = `(${this.name}) "${event}"`;
+    ipcMain.removeListener(removeKey, callback);
+  }
+  //#endregion
+  //#region emit
+  emit(eventName, ...args) {
+    const sendEventKey = `(${this.name}) "${eventName}"`;
+    for (const webContents of this.electronClients) {
+      webContents.send(sendEventKey, ...args);
+    }
+  }
+  //#endregion
+  //#region to
+  to(roomName) {
+    const electronClientsInroom = this.roomsByRoomName[roomName];
+    return new RoomEmitterIpc(electronClientsInroom, this.name, true);
+  }
+  //#endregion
+  //#region in
+  in(roomName) {
+    const electronClientsInroom = this.roomsByRoomName[roomName];
+    return new RoomEmitterIpc(electronClientsInroom, this.name, false);
+  }
+  //#endregion
+  //#region join
+  join(webContents, roomName) {
+    if (!this.roomsByRoomName[roomName]) {
+      this.roomsByRoomName[roomName] = /* @__PURE__ */ new Set();
+    }
+    this.roomsByRoomName[roomName].add(webContents);
+  }
+  //#endregion
+  //#region leave
+  leave(webContents, roomName) {
+    if (this.roomsByRoomName[roomName]) {
+      this.roomsByRoomName[roomName].delete(webContents);
+      if (this.roomsByRoomName[roomName].size === 0) {
+        delete this.roomsByRoomName[roomName];
+      }
+    }
+  }
+  //#endregion
+  //#region path
+  path() {
+    return this.name;
+  }
+  //#endregion
+  //#region get nsp
+  get nsp() {
+    const self = this;
+    return {
+      get name() {
+        return self.name;
+      }
+    };
+  }
+  //#endregion
+}
+class RoomEmitterIpc {
+  //#region constructor
+  constructor(electronClients, name, includeSender = false, sender = null) {
+    this.electronClients = electronClients;
+    this.name = name;
+    this.includeSender = includeSender;
+    this.sender = sender;
+  }
+  //#endregion
+  //#region emit in room
+  emit(eventName, ...args) {
+    const emitEvent = `(${this.name}) "${eventName}"`;
+    this.electronClients?.forEach((webContents) => {
+      webContents.send(emitEvent, ...args);
+    });
+  }
+  //#endregion
+}
+class MockSocketIpc {
+  //#endregion
+  //#endregion
+  //#region constructor
+  /**
+   * @param namespaceName instead url for ipc
+   */
+  constructor(namespaceName) {
+    this.namespaceName = namespaceName;
+  }
+  //#region fields & getters
+  //#region fields & getters / ipc renderer
+  /* */
+  /* */
+  //#endregion
+  //#region fields & getters / event handlers by name
+  socketEventHandlers = {};
+  //#endregion
+  //#region fields & getters / name
+  get name() {
+    return this.namespaceName;
+  }
+  //#endregion
+  //#region on
+  on(eventName, callback) {
+  }
+  //#endregion
+  //#region off
+  off(event, callback) {
+  }
+  //#endregion
+  //#region emit
+  emit(event, ...args) {
+  }
+  //#endregion
+}
+class RealtimeStrategyIpc extends RealtimeStrategy {
+  //#endregion
+  //#region constructor
+  constructor(ctx) {
+    super(ctx);
+    this.ctx = ctx;
+  }
+  //#region to string
+  toString() {
+    return "ipc";
+  }
+  //#endregion
+  //#region server & io
+  ioServer(__, opt) {
+    const namespace = opt?.path || "/";
+    const server = MockServerIpc.from(this.ctx.contextName);
+    return server.of(namespace);
+  }
+  get ioClient() {
+    const clientIo = (__, opt) => {
+      const namespace = opt?.path || "/";
+      return new MockSocketIpc(namespace);
+    };
+    return clientIo;
+  }
+  //#endregion
+}
+export {
+  MockNamespaceIpc,
+  MockServerIpc,
+  MockSocketIpc,
+  RealtimeStrategyIpc
+};