taon 21.0.44 → 21.0.45

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

@@ -0,0 +1,344 @@
+//#region imports
+/* */                                                    
+import type * as Electron from 'electron';
+import { ipcMain } from 'electron'; // @backend
+import { Server, ServerOptions } from 'socket.io';
+import type { io, ManagerOptions, SocketOptions } from 'socket.io-client';
+
+import { EndpointContext } from '../../endpoint-context';
+import { Symbols__NS__classMethodsNames, Symbols__NS__classNameStaticProperty, Symbols__NS__ctxInClassOrClassObj, Symbols__NS__fullClassNameStaticProperty, Symbols__NS__metadata, Symbols__NS__old, Symbols__NS__orignalClass, Symbols__NS__orignalClassClonesObj, Symbols__NS__REALTIME } from '../../symbols';
+import { RealtimeModels__NS__ChangeOption, RealtimeModels__NS__EventHandler, RealtimeModels__NS__SubsManagerOpt } from '../realtime.models';
+
+import { RealtimeStrategy } from './realtime-strategy';
+//#endregion
+
+//#region mock server ipc
+export class MockServerIpc {
+  static serverByContextName = new Map<string, MockServerIpc>();
+
+  static from(contextName: string): MockServerIpc {
+    if (!MockServerIpc.serverByContextName.has(contextName)) {
+      MockServerIpc.serverByContextName.set(
+        contextName,
+        new MockServerIpc(contextName),
+      );
+    }
+    return MockServerIpc.serverByContextName.get(contextName);
+  }
+
+  namespacesByName = new Map<string, MockNamespaceIpc>();
+
+  //#region constructor
+  constructor(public contextName: string) {
+    MockServerIpc.serverByContextName.set(contextName, this);
+  }
+  //#endregion
+
+  //#region of
+  of(namespace: string): MockNamespaceIpc {
+    if (!this.namespacesByName.has(namespace)) {
+      this.namespacesByName.set(
+        namespace,
+        new MockNamespaceIpc(namespace, this),
+      );
+    }
+    return this.namespacesByName.get(namespace);
+  }
+  //#endregion
+}
+//#endregion
+
+//#region mock namespace ipc
+export class MockNamespaceIpc {
+  //#region fields & getters
+  electronClients = new Set<Electron.WebContents>();
+  roomsByRoomName: {
+    [roomName: string]: Set<Electron.WebContents>;
+  } = {};
+
+  private namespaceEventHandlers: {
+    [eventName: string]: Set<RealtimeModels__NS__EventHandler>;
+  } = {};
+  //#endregion
+
+  //#region constructor
+  constructor(
+    /**
+     * Namespace name
+     */
+    public name: string,
+    public server: MockServerIpc,
+  ) {}
+  //#endregion
+
+  //#region on
+  on(eventName: string, callback: RealtimeModels__NS__EventHandler) {
+    //#region @backendFunc
+    const listenKey = `(${this.name}) "${eventName}"`;
+
+    if (!this.namespaceEventHandlers[eventName]) {
+      this.namespaceEventHandlers[eventName] = 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);
+        }
+      }
+    });
+    // this.emit(listenKey); // QUICK_FIX
+    //#endregion
+  }
+  //#endregion
+
+  //#region off
+  off(event: string, callback?: RealtimeModels__NS__EventHandler) {
+    //#region @backendFunc
+    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
+  }
+  //#endregion
+
+  //#region emit
+  emit(eventName: string, ...args: any[]) {
+    //#region @backendFunc
+    const sendEventKey = `(${this.name}) "${eventName}"`;
+    for (const webContents of this.electronClients) {
+      webContents.send(sendEventKey, ...args);
+    }
+    // const allWindows = Electron.BrowserWindow.getAllWindows();
+    // allWindows.forEach((win, index) => {
+    //   win.webContents.send(sendEventKey, ...args);
+    // });
+    //#endregion
+  }
+  //#endregion
+
+  //#region to
+  to(roomName: string) {
+    const electronClientsInroom = this.roomsByRoomName[roomName];
+    return new RoomEmitterIpc(electronClientsInroom, this.name, true);
+  }
+  //#endregion
+
+  //#region in
+  in(roomName: string) {
+    const electronClientsInroom = this.roomsByRoomName[roomName];
+    return new RoomEmitterIpc(electronClientsInroom, this.name, false);
+  }
+  //#endregion
+
+  //#region join
+  join(webContents: Electron.WebContents, roomName: string) {
+    if (!this.roomsByRoomName[roomName]) {
+      this.roomsByRoomName[roomName] = new Set();
+    }
+    this.roomsByRoomName[roomName].add(webContents);
+  }
+  //#endregion
+
+  //#region leave
+  leave(webContents: Electron.WebContents, roomName: string) {
+    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
+}
+
+//#endregion
+
+//#region room emitter ipc
+class RoomEmitterIpc {
+  //#region constructor
+  constructor(
+    private electronClients: Set<Electron.WebContents>,
+    /**
+     * namespace name
+     */
+    private name: string,
+    private includeSender: boolean = false,
+    private sender: MockSocketIpc = null, // TODO QUICK FIX how to include sender
+  ) {}
+  //#endregion
+
+  //#region emit in room
+  emit(eventName: string, ...args: any[]): void {
+    const emitEvent = `(${this.name}) "${eventName}"`;
+    this.electronClients?.forEach(webContents => {
+      webContents.send(emitEvent, ...args);
+    });
+  }
+  //#endregion
+}
+//#endregion
+
+//#region mock socket ipc
+export class MockSocketIpc {
+  //#region fields & getters
+
+  //#region fields & getters / ipc renderer
+/* */
+/* */
+  
+  //#endregion
+
+  //#region fields & getters / event handlers by name
+  private socketEventHandlers = {} as {
+    [eventName: string]: Set<RealtimeModels__NS__EventHandler>;
+  };
+  //#endregion
+
+  //#region fields & getters / name
+  get name() {
+    return this.namespaceName;
+  }
+  //#endregion
+
+  //#endregion
+
+  //#region constructor
+  /**
+   * @param namespaceName instead url for ipc
+   */
+  constructor(public namespaceName: string) {
+/* */
+/* */
+  
+  }
+  //#endregion
+
+  //#region on
+  on(eventName: string, callback: (event: any, ...args: any[]) => void) {
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+  
+  }
+  //#endregion
+
+  //#region off
+  off(event: string, callback?: (event: any, ...args: any[]) => void) {
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+  
+  }
+  //#endregion
+
+  //#region emit
+  emit(event: string, ...args: any[]) {
+/* */
+/* */
+/* */
+  
+  }
+  //#endregion
+}
+//#endregion
+
+/**
+ * Purpose:
+ * - backend-browser communication between 2 processes in electron mode
+ */
+export class RealtimeStrategyIpc extends RealtimeStrategy {
+  //#region to string
+  toString(): string {
+    return 'ipc';
+  }
+  //#endregion
+
+  //#region constructor
+  constructor(protected ctx: EndpointContext) {
+    super(ctx);
+  }
+  //#endregion
+
+  //#region server & io
+  ioServer(__: string, opt: ServerOptions) {
+    const namespace = opt?.path || '/';
+    const server = MockServerIpc.from(this.ctx.contextName);
+    return server.of(namespace) as any;
+  }
+
+  get ioClient() {
+    const clientIo = (
+      __: string,
+      opt?: Partial<ManagerOptions & SocketOptions>,
+    ): MockSocketIpc => {
+      const namespace = opt?.path || '/';
+      return new MockSocketIpc(namespace);
+    };
+    return clientIo as any;
+  }
+  //#endregion
+}

package/lib-prod/realtime/realtime-strategy/realtime-strategy-mock.ts

@@ -0,0 +1,349 @@
+//#region imports
+import type { EndpointContext } from '../../endpoint-context';
+import { RealtimeStrategy } from './realtime-strategy';
+import { Symbols__NS__classMethodsNames, Symbols__NS__classNameStaticProperty, Symbols__NS__ctxInClassOrClassObj, Symbols__NS__fullClassNameStaticProperty, Symbols__NS__metadata, Symbols__NS__old, Symbols__NS__orignalClass, Symbols__NS__orignalClassClonesObj, Symbols__NS__REALTIME } from '../../symbols';
+import { ManagerOptions, SocketOptions } from 'socket.io-client';
+import { RealtimeModels__NS__ChangeOption, RealtimeModels__NS__EventHandler, RealtimeModels__NS__SubsManagerOpt } from '../realtime.models';
+import { ServerOptions } from 'socket.io';
+//#endregion
+
+//#region mock server
+class MockServer {
+  static serverByUrl = new Map<string, MockServer>();
+  static from(url: string): MockServer {
+    if (!MockServer.serverByUrl.has(url)) {
+      MockServer.serverByUrl.set(url, new MockServer(url));
+    }
+    return MockServer.serverByUrl.get(url);
+  }
+
+  get allServers() {
+    return Array.from(MockServer.serverByUrl.values());
+  }
+
+  namespacesByName = new Map<string, MockNamespace>();
+
+  //#region constructor
+  constructor(public url: string) {
+    MockServer.serverByUrl.set(url, this);
+  }
+  //#endregion
+
+  //#region of
+  of(namespace: string): MockNamespace {
+    if (!this.namespacesByName.has(namespace)) {
+      this.namespacesByName.set(namespace, new MockNamespace(namespace, this));
+    }
+    return this.namespacesByName.get(namespace);
+  }
+  //#endregion
+
+  //#region path
+  path() {
+    return this.url;
+  }
+  //#endregion
+}
+//#endregion
+
+//#region mock namespace
+class MockNamespace {
+  /**
+   * All sockets connected to this namespace
+   */
+  public readonly allSocketsForNamespace = new Set<MockSocket>();
+  /**
+   * Rooms and their sockets
+   */
+  private socketByRoomName: {
+    [roomName: string]: Set<MockSocket>;
+  } = {};
+  /**
+   * Event handlers for this namespace
+   */
+  public namespaceEventHandlers: {
+    [eventName: string]: Set<RealtimeModels__NS__EventHandler>;
+  } = {};
+
+  //#region constructor
+  constructor(
+    /**
+     * unique namespace name
+     */
+    public name: string,
+    public server: MockServer,
+  ) {}
+  //#endregion
+
+  //#region on
+  on(eventName: string, handler: RealtimeModels__NS__EventHandler): void {
+    // console.log(`ON EVNET event "${eventName}"`);
+    if (!this.namespaceEventHandlers[eventName]) {
+      this.namespaceEventHandlers[eventName] =
+        new Set<RealtimeModels__NS__EventHandler>();
+    }
+
+    if (!this.namespaceEventHandlers[eventName].has(handler)) {
+      this.namespaceEventHandlers[eventName].add(handler);
+    }
+
+    // QUICK_FIX Emit connection event for backend
+    // TODO make it in emit
+    if (eventName === 'connection') {
+      setTimeout(() => {
+        this.emit('connection', this);
+      });
+    }
+  }
+  //#endregion
+
+  //#region emit
+  emit(event: string, ...args: any[]): void {
+    this.allSocketsForNamespace?.forEach(socket => {
+      socket.emit(event, ...args);
+    });
+  }
+  //#endregion
+
+  //#region connect
+  connect(socket: MockSocket): void {
+    this.allSocketsForNamespace.add(socket);
+    socket.namespaceInstance = this;
+  }
+  //#endregion
+
+  //#region to
+  to(roomName: string): RoomEmitter {
+    const socketsInRoom = this.socketByRoomName[roomName];
+    return new RoomEmitter(socketsInRoom, true);
+  }
+  //#endregion
+
+  //#region to room
+  in(roomName: string): RoomEmitter {
+    const socketsInRoom = this.socketByRoomName[roomName];
+    return new RoomEmitter(socketsInRoom, false);
+  }
+  //#endregion
+
+  //#region join room
+  joinRoom(roomName: string, socket: MockSocket): void {
+    if (!this.socketByRoomName[roomName]) {
+      this.socketByRoomName[roomName] = new Set<MockSocket>();
+    }
+    this.socketByRoomName[roomName].add(socket);
+  }
+  //#endregion
+
+  //#region leave room
+  leaveRoom(roomName: string, socket: MockSocket): void {
+    const roomSockets = this.socketByRoomName[roomName];
+    if (roomSockets) {
+      this.socketByRoomName[roomName].delete(socket);
+    }
+  }
+  //#endregion
+
+  //#region nsp + name
+  get nsp() {
+    const self = this;
+    return {
+      get name() {
+        return self.name;
+      },
+    };
+  }
+  //#endregion
+
+  path() {
+    return this.name;
+  }
+}
+//#endregion
+
+//#region room emitter
+class RoomEmitter {
+  //#region constructor
+  constructor(
+    private sockets: Set<MockSocket>,
+    private includeSender: boolean = false,
+    private sender: MockSocket = null, // TODO QUICK FIX how to include sender
+  ) {}
+  //#endregion
+
+  //#region emit in room
+  emit(event: string, ...args: any[]): void {
+    // console.log(
+    //   `emit room emiter ${event} ,  this.sockets ${this.sockets.length}`,
+    // );
+    this.sockets?.forEach(socket => {
+      // console.log(`emit event ${event} to socket ${socket.id}`);
+      if (this.includeSender || socket !== this.sender) {
+        socket.emit(event, ...args);
+      }
+    });
+  }
+  //#endregion
+}
+//#endregion
+
+//#region mock socket
+class MockSocket {
+  public namespaceInstance: MockNamespace;
+  private socketEventHandlers = {} as {
+    [eventName: string]: Set<RealtimeModels__NS__EventHandler>;
+  };
+  get id() {
+    return this.nsp.name;
+  }
+
+  //#region constructor
+  constructor(
+    public url: string,
+    opts?: Partial<ManagerOptions & SocketOptions>,
+  ) {
+    // @ts-ignore
+    const [baseUrl, namespace] = [url, opts.path || '/'];
+    // console.log({ url, baseUrl, namespace });
+    const namespaceName = namespace || '/';
+
+    // Look up the server instance from the registry
+    const server = MockServer.from(url);
+
+    const ns = server.of(namespaceName);
+    ns.connect(this);
+  }
+  //#endregion
+
+  //#region nsp + name
+  get nsp() {
+    const self = this;
+    return {
+      get name() {
+        return self.namespaceInstance?.name;
+      },
+    };
+  }
+  //#endregion
+
+  //#region path
+  path() {
+    return this.namespaceInstance?.name;
+  }
+  //#endregion
+
+  //#region on
+  on(eventName: string, handler: RealtimeModels__NS__EventHandler): void {
+    if (!this.socketEventHandlers[eventName]) {
+      this.socketEventHandlers[eventName] =
+        new Set<RealtimeModels__NS__EventHandler>();
+    }
+    this.socketEventHandlers[eventName].add(handler);
+
+    // QUICK_FIX client initing itself
+    if (eventName === 'connect') {
+      setTimeout(() => {
+        this.emit('connect');
+        // this.namespaceInstance.emit('connection', this); @UNCOMMNENT
+      });
+    }
+  }
+  //#endregion
+
+  //#region emit
+  emit(eventName: string, ...args: any[]): void {
+    eventName = eventName || '';
+
+    if (eventName.includes(`:${Symbols__NS__REALTIME.KEYroomSubscribe}`)) {
+      const room = args[0];
+      this.join(room);
+    } else if (eventName.includes(`:${Symbols__NS__REALTIME.KEYroomUnsubscribe}`)) {
+      const room = args[0];
+      this.leave(room);
+    } else {
+      // console.log('try to emit event (to server)', event);
+      if (this.namespaceInstance) {
+        const namespaceEventHandlers =
+          this.namespaceInstance.namespaceEventHandlers[eventName] || [];
+
+        // emit to namespace events
+        for (const namespaceEventHandler of namespaceEventHandlers) {
+          if (namespaceEventHandler) {
+            namespaceEventHandler(...args);
+          }
+        }
+
+        const allSocketsForNamespaceExceptCurrent = Array.from(
+          this.namespaceInstance.allSocketsForNamespace.values(),
+        ).filter(socket => socket !== this);
+
+        // emit to all sockets in namespace
+        for (const socket of allSocketsForNamespaceExceptCurrent) {
+          const socketEventHandlers = socket.socketEventHandlers[eventName];
+          for (const socketEventHandler of socketEventHandlers) {
+            if (socketEventHandler) {
+              socketEventHandler(...args);
+            }
+          }
+        }
+
+        // Emit to current socket
+        const socketEventHandlers = this.socketEventHandlers[eventName] || [];
+        for (const clientHandler of socketEventHandlers) {
+          if (clientHandler) {
+            clientHandler(...args);
+          }
+        }
+      }
+    }
+  }
+  //#endregion
+
+  //#region join room
+  join(roomName: string): void {
+    this.namespaceInstance.joinRoom(roomName, this);
+  }
+  //#endregion
+
+  //#region leave room
+  leave(roomName: string): void {
+    this.namespaceInstance.leaveRoom(roomName, this);
+  }
+  //#endregion
+}
+//#endregion
+
+/**
+ * Purpose:
+ * - browser-browser communication mock (in websql mode)
+ */
+export class RealtimeStrategyMock extends RealtimeStrategy {
+  //#region toString
+  toString(): string {
+    return 'mock';
+  }
+  //#endregion
+
+  //#region constructor
+  constructor(protected ctx: EndpointContext) {
+    super(ctx);
+  }
+  //#endregion
+
+  //#region server & io
+  ioServer(url: string, opt: ServerOptions) {
+    const server = MockServer.from(url || this.ctx.uriOrigin);
+    return server.of(opt?.path || '/') as any;
+  }
+
+  get ioClient() {
+    const clientIo = (
+      uri: string,
+      opts?: Partial<ManagerOptions & SocketOptions>,
+    ): MockSocket => {
+      return new MockSocket(uri || this.ctx.uriOrigin, opts as any);
+    };
+    return clientIo as any;
+  }
+  //#endregion
+}

package/lib-prod/realtime/realtime-strategy/realtime-strategy-socket-io.ts

@@ -0,0 +1,30 @@
+import { EndpointContext } from '../../endpoint-context';
+import { RealtimeStrategy } from './realtime-strategy';
+//#region @backend
+import { Server, ServerOptions } from 'socket.io';
+//#endregion
+import { io, ManagerOptions, Socket, SocketOptions } from 'socket.io-client';
+
+/**
+ * Purpose:
+ * - backend-browser communication
+ * - backend-backend communication
+ */
+export class RealtimeStrategySocketIO extends RealtimeStrategy {
+  toString(): string {
+    return 'socket-io';
+  }
+  constructor(protected ctx: EndpointContext) {
+    super(ctx);
+  }
+
+  ioServer(...args) {
+    //#region @backendFunc
+    return new Server(...args);
+    //#endregion
+  }
+
+  get ioClient() {
+    return io;
+  }
+}