taon 21.0.52 → 21.0.54

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

@@ -0,0 +1,280 @@
+import { ipcMain } from 'electron'; // @backend
+import { Symbols__NS__REALTIME } from '../../symbols';
+import { RealtimeStrategy } from './realtime-strategy';
+//#endregion
+//#region mock server ipc
+export class MockServerIpc {
+    static { this.serverByContextName = new Map(); }
+    static from(contextName) {
+        if (!MockServerIpc.serverByContextName.has(contextName)) {
+            MockServerIpc.serverByContextName.set(contextName, new MockServerIpc(contextName));
+        }
+        return MockServerIpc.serverByContextName.get(contextName);
+    }
+    //#region constructor
+    constructor(contextName) {
+        this.contextName = contextName;
+        this.namespacesByName = new Map();
+        MockServerIpc.serverByContextName.set(contextName, this);
+    }
+    //#endregion
+    //#region of
+    of(namespace) {
+        if (!this.namespacesByName.has(namespace)) {
+            this.namespacesByName.set(namespace, new MockNamespaceIpc(namespace, this));
+        }
+        return this.namespacesByName.get(namespace);
+    }
+}
+//#endregion
+//#region mock namespace ipc
+export class MockNamespaceIpc {
+    //#endregion
+    //#region constructor
+    constructor(
+    /**
+     * Namespace name
+     */
+    name, server) {
+        this.name = name;
+        this.server = server;
+        //#region fields & getters
+        this.electronClients = new Set();
+        this.roomsByRoomName = {};
+        this.namespaceEventHandlers = {};
+    }
+    //#endregion
+    //#region on
+    on(eventName, callback) {
+        //#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, callback) {
+        //#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, ...args) {
+        //#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) {
+        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] = 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
+//#region room emitter ipc
+class RoomEmitterIpc {
+    //#region constructor
+    constructor(electronClients, 
+    /**
+     * namespace name
+     */
+    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
+//#region mock socket ipc
+export class MockSocketIpc {
+    //#endregion
+    //#region fields & getters / name
+    get name() {
+        return this.namespaceName;
+    }
+    //#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
+        this.socketEventHandlers = {};
+    }
+    //#endregion
+    //#region on
+    on(eventName, callback) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+    }
+    //#endregion
+    //#region off
+    off(event, callback) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+    }
+    //#endregion
+    //#region emit
+    emit(event, ...args) {
+        /* */
+        /* */
+        /* */
+    }
+}
+//#endregion
+/**
+ * Purpose:
+ * - backend-browser communication between 2 processes in electron mode
+ */
+export class RealtimeStrategyIpc extends RealtimeStrategy {
+    //#region to string
+    toString() {
+        return 'ipc';
+    }
+    //#endregion
+    //#region constructor
+    constructor(ctx) {
+        super(ctx);
+        this.ctx = ctx;
+    }
+    //#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;
+    }
+}

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

@@ -0,0 +1,289 @@
+import { RealtimeStrategy } from './realtime-strategy';
+import { Symbols__NS__REALTIME } from '../../symbols';
+//#endregion
+//#region mock server
+class MockServer {
+    static { this.serverByUrl = new Map(); }
+    static from(url) {
+        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());
+    }
+    //#region constructor
+    constructor(url) {
+        this.url = url;
+        this.namespacesByName = new Map();
+        MockServer.serverByUrl.set(url, this);
+    }
+    //#endregion
+    //#region of
+    of(namespace) {
+        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
+//#region mock namespace
+class MockNamespace {
+    //#region constructor
+    constructor(
+    /**
+     * unique namespace name
+     */
+    name, server) {
+        this.name = name;
+        this.server = server;
+        /**
+         * All sockets connected to this namespace
+         */
+        this.allSocketsForNamespace = new Set();
+        /**
+         * Rooms and their sockets
+         */
+        this.socketByRoomName = {};
+        /**
+         * Event handlers for this namespace
+         */
+        this.namespaceEventHandlers = {};
+    }
+    //#endregion
+    //#region on
+    on(eventName, handler) {
+        // console.log(`ON EVNET event "${eventName}"`);
+        if (!this.namespaceEventHandlers[eventName]) {
+            this.namespaceEventHandlers[eventName] =
+                new Set();
+        }
+        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, ...args) {
+        this.allSocketsForNamespace?.forEach(socket => {
+            socket.emit(event, ...args);
+        });
+    }
+    //#endregion
+    //#region connect
+    connect(socket) {
+        this.allSocketsForNamespace.add(socket);
+        socket.namespaceInstance = this;
+    }
+    //#endregion
+    //#region to
+    to(roomName) {
+        const socketsInRoom = this.socketByRoomName[roomName];
+        return new RoomEmitter(socketsInRoom, true);
+    }
+    //#endregion
+    //#region to room
+    in(roomName) {
+        const socketsInRoom = this.socketByRoomName[roomName];
+        return new RoomEmitter(socketsInRoom, false);
+    }
+    //#endregion
+    //#region join room
+    joinRoom(roomName, socket) {
+        if (!this.socketByRoomName[roomName]) {
+            this.socketByRoomName[roomName] = new Set();
+        }
+        this.socketByRoomName[roomName].add(socket);
+    }
+    //#endregion
+    //#region leave room
+    leaveRoom(roomName, socket) {
+        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(sockets, includeSender = false, sender = null) {
+        this.sockets = sockets;
+        this.includeSender = includeSender;
+        this.sender = sender;
+    }
+    //#endregion
+    //#region emit in room
+    emit(event, ...args) {
+        // 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
+//#region mock socket
+class MockSocket {
+    get id() {
+        return this.nsp.name;
+    }
+    //#region constructor
+    constructor(url, opts) {
+        this.url = url;
+        this.socketEventHandlers = {};
+        // @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, handler) {
+        if (!this.socketEventHandlers[eventName]) {
+            this.socketEventHandlers[eventName] =
+                new Set();
+        }
+        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, ...args) {
+        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) {
+        this.namespaceInstance.joinRoom(roomName, this);
+    }
+    //#endregion
+    //#region leave room
+    leave(roomName) {
+        this.namespaceInstance.leaveRoom(roomName, this);
+    }
+}
+//#endregion
+/**
+ * Purpose:
+ * - browser-browser communication mock (in websql mode)
+ */
+export class RealtimeStrategyMock extends RealtimeStrategy {
+    //#region toString
+    toString() {
+        return 'mock';
+    }
+    //#endregion
+    //#region constructor
+    constructor(ctx) {
+        super(ctx);
+        this.ctx = ctx;
+    }
+    //#endregion
+    //#region server & io
+    ioServer(url, opt) {
+        const server = MockServer.from(url || this.ctx.uriOrigin);
+        return server.of(opt?.path || '/');
+    }
+    get ioClient() {
+        const clientIo = (uri, opts) => {
+            return new MockSocket(uri || this.ctx.uriOrigin, opts);
+        };
+        return clientIo;
+    }
+}

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

@@ -0,0 +1,27 @@
+import { RealtimeStrategy } from './realtime-strategy';
+//#region @backend
+import { Server } from 'socket.io';
+//#endregion
+import { io } from 'socket.io-client';
+/**
+ * Purpose:
+ * - backend-browser communication
+ * - backend-backend communication
+ */
+export class RealtimeStrategySocketIO extends RealtimeStrategy {
+    toString() {
+        return 'socket-io';
+    }
+    constructor(ctx) {
+        super(ctx);
+        this.ctx = ctx;
+    }
+    ioServer(...args) {
+        //#region @backendFunc
+        return new Server(...args);
+        //#endregion
+    }
+    get ioClient() {
+        return io;
+    }
+}

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

@@ -0,0 +1,11 @@
+export class RealtimeStrategy {
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    get ioClient() {
+        throw new Error('Not implemented');
+    }
+    ioServer(url, opt) {
+        throw new Error('Not implemented');
+    }
+}

package/lib-prod/realtime/realtime-subs-manager.js

@@ -0,0 +1,88 @@
+//#endregion
+import { ___NS__isString } from 'tnp-core/lib-prod';
+import { Symbols__NS__REALTIME } from '../symbols';
+//#endregion
+export class RealtimeSubsManager {
+    constructor(options) {
+        this.options = options;
+        this.isListening = false;
+        this.observers = [];
+    }
+    //#region methods & getters / start listen if not started
+    startListenIfNotStarted(realtime) {
+        if (this.options.core.ctx.disabledRealtime) {
+            console.warn(`[Taon][startListenIfNotStarted] sockets are disabled`);
+            return;
+        }
+        if (!realtime) {
+            console.warn(`[Taon][startListenIfNotStarted] invalid socket connection`);
+            return;
+        }
+        if (!this.isListening) {
+            // console.info(`[BROWSER]][IPC] subscribe to "${this.options?.roomName}" by sending event: "${subscribeEvent}"`, this.options);
+            this.isListening = true;
+            if (this.options.customEvent) {
+                const subscribeEvent = Symbols__NS__REALTIME.ROOM_SUBSCRIBE_CUSTOM(this.options.core.ctx.contextName);
+                // this means: send to current client custom event notification
+                realtime.emit(subscribeEvent, this.options.roomName);
+            }
+            else {
+                if (___NS__isString(this.options.property)) {
+                    const subscribeEvent = Symbols__NS__REALTIME.ROOM_SUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(this.options.core.ctx.contextName);
+                    // this means: send to current client entity property events updates
+                    realtime.emit(subscribeEvent, this.options.roomName);
+                }
+                else {
+                    const subscribeEvent = Symbols__NS__REALTIME.ROOM_SUBSCRIBE_ENTITY_UPDATE_EVENTS(this.options.core.ctx.contextName);
+                    // this means: send to current client entity update events
+                    realtime.emit(subscribeEvent, this.options.roomName);
+                }
+            }
+            // subPath -> SYMBOL - (customevnet|entityupdatebyid){..}{..}
+            realtime.on(this.options.roomName, data => {
+                this.update(data);
+            });
+        }
+    }
+    //#endregion
+    //#region methods & getters / add observer
+    add(observer) {
+        // log.info('Add observer')
+        this.observers.push(observer);
+    }
+    //#endregion
+    //#region methods & getters / remove observer
+    remove(observer) {
+        // log.info('Remove observer')
+        this.observers = this.observers.filter(obs => obs !== observer);
+        if (this.observers.length === 0) {
+            // log.info('Emit unsubscribe to server SERVER')
+            this.isListening = false;
+            const { core, customEvent, roomName, property } = this.options;
+            const realtime = core.socketFE;
+            if (customEvent) {
+                realtime.emit(Symbols__NS__REALTIME.ROOM_UNSUBSCRIBE_CUSTOM(this.options.core.ctx.contextName), roomName);
+            }
+            else {
+                if (___NS__isString(property)) {
+                    realtime.emit(Symbols__NS__REALTIME.ROOM_UNSUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(this.options.core.ctx.contextName), roomName);
+                }
+                else {
+                    realtime.emit(Symbols__NS__REALTIME.ROOM_UNSUBSCRIBE_ENTITY_UPDATE_EVENTS(this.options.core.ctx.contextName), roomName);
+                }
+            }
+        }
+    }
+    //#endregion
+    //#region methods & getters / update
+    update(data) {
+        // log.data(`realtime update!!!!!  observers=${this.observers?.length} `)
+        // console.log('updating', data);
+        this.observers.forEach(observer => {
+            // console.log(`observer closed: ${observer.closed}`,observer);
+            if (!observer.closed) {
+                observer.next(data);
+            }
+        });
+    }
+}

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

@@ -0,0 +1,2 @@
+export {};
+//end of namespace RealtimeModels