taon 18.0.15 → 18.0.18

package/websql/fesm2022/taon.mjs

@@ -25,45 +25,52 @@ var Symbols;
     Symbols.orignalClass = OrignalClassKey;
     Symbols.orignalClassClonesObj = `$$originalClassClonesObj$$`;
     Symbols.classMethodsNames = `$$classMethodsNames$$`;
-    Symbols.REALTIME = {
-        NAMESPACE: (contextName) => `${contextName}:taonRealtimeNsp`,
+    /**
+     * for backendSocket.in(ROOM_NAME).emit(EVENT)
+     *
+     * Room names are uniqe..
+     * here I am limiting number of event for clients.
+     */
+    class Realtime {
+        constructor() {
+            this.KEYroomSubscribe = `roomSubscribe`;
+            this.KEYroomUnsubscribe = `roomUnsubscribe`;
+        }
+        NAMESPACE(contextName) {
+            return `${contextName}-taonRealtimeNsp`;
+        }
         TABLE_CHANGE(contextName, tableName) {
             return `${contextName}:listentablename${tableName}`;
-        },
-        /**
-         * for backendSocket.in(ROOM_NAME).emit(EVENT)
-         *
-         * Room names are uniqe..
-         * here I am limiting number of event for clients.
-         */
-        ROOM_NAME: {
-            CUSTOM(contextName, customEvent) {
-                return `${contextName}:roomcustomevnet${customEvent}`;
-            },
-            /**
-             * @LAST TODO
-             */
-            SUBSCRIBER_EVENT(contextName, className, propertyName) {
-                return `${contextName}:room${_.camelCase(className)}${propertyName}`.toLowerCase();
-            },
-            UPDATE_ENTITY(contextName, className, entityId) {
-                return `${contextName}:room${_.camelCase(className)}${entityId}`.toLowerCase();
-            },
-            UPDATE_ENTITY_PROPERTY(contextName, className, property, entityId) {
-                return `${contextName}:room${_.camelCase(className)}${_.camelCase(property)}${entityId}`.toLowerCase();
-            },
-            SUBSCRIBE: {
-                CUSTOM: (contextName) => `${contextName}:roomSubscribeCustomRoomEvent`,
-                ENTITY_UPDATE_EVENTS: (contextName) => `${contextName}:roomSubscribeEntityEvents`,
-                ENTITY_PROPERTY_UPDATE_EVENTS: (contextName) => `${contextName}:roomSubscribeEntityPropertyEvents`,
-            },
-            UNSUBSCRIBE: {
-                CUSTOM: (contextName) => `${contextName}:roomUnsubscribeCustomRoomEvent`,
-                ENTITY_UPDATE_EVENTS: (contextName) => `${contextName}:roomUnsubscribeEntityEvents`,
-                ENTITY_PROPERTY_UPDATE_EVENTS: (contextName) => `${contextName}:roomUnsubscribeEntityPropertyEvents`,
-            },
-        },
-    };
+        }
+        ROOM_NAME_CUSTOM(contextName, customEvent) {
+            return `${contextName}:CustomRoomEvent${customEvent}`;
+        }
+        ROOM_SUBSCRIBE_CUSTOM(contextName) {
+            return `${contextName}:${this.KEYroomSubscribe}CustomRoomEvent`;
+        }
+        ROOM_UNSUBSCRIBE_CUSTOM(contextName) {
+            return `${contextName}:${this.KEYroomUnsubscribe}CustomRoomEvent`;
+        }
+        ROOM_NAME_UPDATE_ENTITY(contextName, className, entityId) {
+            return `${contextName}:room${_.camelCase(className)}${entityId}`.toLowerCase();
+        }
+        ROOM_SUBSCRIBE_ENTITY_UPDATE_EVENTS(contextName) {
+            return `${contextName}:${this.KEYroomSubscribe}EntityEvents`;
+        }
+        ROOM_UNSUBSCRIBE_ENTITY_UPDATE_EVENTS(contextName) {
+            return `${contextName}:${this.KEYroomUnsubscribe}EntityEvents`;
+        }
+        ROOM_NAME_UPDATE_ENTITY_PROPERTY(contextName, className, property, entityId) {
+            return `${contextName}:room${_.camelCase(className)}${_.camelCase(property)}${entityId}`.toLowerCase();
+        }
+        ROOM_SUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(contextName) {
+            return `${contextName}:${this.KEYroomSubscribe}EntityPropertyEvents`;
+        }
+        ROOM_UNSUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(contextName) {
+            return `${contextName}:${this.KEYroomUnsubscribe}EntityPropertyEvents`;
+        }
+    }
+    Symbols.REALTIME = new Realtime();
     Symbols.metadata = {
         className: `class:realname`,
         options: {
@@ -343,7 +350,7 @@ var ClassHelpers;
             : classFnOrObject?.constructor[Symbols.fullClassNameStaticProperty]) ||
             void 0);
     };
-    ClassHelpers.getUniquKey = (classFnOrObject) => {
+    ClassHelpers.getUniqueKey = (classFnOrObject) => {
         const classFn = _.isFunction(classFnOrObject)
             ? classFnOrObject
             : classFnOrObject.constructor;
@@ -1786,17 +1793,19 @@ class RealtimeSubsManager {
             return;
         }
         if (!this.isListening) {
-            const subscribeEvent = Symbols.REALTIME.ROOM_NAME.SUBSCRIBE.CUSTOM(this.options.core.ctx.contextName);
             this.isListening = true;
             if (this.options.customEvent) {
+                const subscribeEvent = Symbols.REALTIME.ROOM_SUBSCRIBE_CUSTOM(this.options.core.ctx.contextName);
                 realtime.emit(subscribeEvent, this.options.roomName);
             }
             else {
                 if (_.isString(this.options.property)) {
-                    realtime.emit(Symbols.REALTIME.ROOM_NAME.SUBSCRIBE.ENTITY_PROPERTY_UPDATE_EVENTS(this.options.core.ctx.contextName), this.options.roomName);
+                    const subscribeEvent = Symbols.REALTIME.ROOM_SUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(this.options.core.ctx.contextName);
+                    realtime.emit(subscribeEvent, this.options.roomName);
                 }
                 else {
-                    realtime.emit(Symbols.REALTIME.ROOM_NAME.SUBSCRIBE.ENTITY_UPDATE_EVENTS(this.options.core.ctx.contextName), this.options.roomName);
+                    const subscribeEvent = Symbols.REALTIME.ROOM_SUBSCRIBE_ENTITY_UPDATE_EVENTS(this.options.core.ctx.contextName);
+                    realtime.emit(subscribeEvent, this.options.roomName);
                 }
             }
             realtime.on(this.options.roomName, data => {
@@ -1812,16 +1821,16 @@ class RealtimeSubsManager {
         if (this.observers.length === 0) {
             this.isListening = false;
             const { core, customEvent, roomName, property } = this.options;
-            const realtime = core.FE_REALTIME;
+            const realtime = core.socketFE;
             if (customEvent) {
-                realtime.emit(Symbols.REALTIME.ROOM_NAME.UNSUBSCRIBE.CUSTOM(this.options.core.ctx.contextName), roomName);
+                realtime.emit(Symbols.REALTIME.ROOM_UNSUBSCRIBE_CUSTOM(this.options.core.ctx.contextName), roomName);
             }
             else {
                 if (_.isString(property)) {
-                    realtime.emit(Symbols.REALTIME.ROOM_NAME.UNSUBSCRIBE.ENTITY_PROPERTY_UPDATE_EVENTS(this.options.core.ctx.contextName), roomName);
+                    realtime.emit(Symbols.REALTIME.ROOM_UNSUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(this.options.core.ctx.contextName), roomName);
                 }
                 else {
-                    realtime.emit(Symbols.REALTIME.ROOM_NAME.UNSUBSCRIBE.ENTITY_UPDATE_EVENTS(this.options.core.ctx.contextName), roomName);
+                    realtime.emit(Symbols.REALTIME.ROOM_UNSUBSCRIBE_ENTITY_UPDATE_EVENTS(this.options.core.ctx.contextName), roomName);
                 }
             }
         }
@@ -1848,7 +1857,7 @@ class RealtimeSubsManager {
 class RealtimeClient {
     constructor(core) {
         this.core = core;
-        this.subsmanagers = {};
+        this.subsManagers = {};
         this.core = core;
         if (!core.ctx.disabledRealtime) {
             this.init();
@@ -1863,20 +1872,24 @@ class RealtimeClient {
             console.info('[CLIENT] NAMESPACE GLOBAL ', nspPath.global.href + ` host: ${this.core.ctx.host}`);
         this.core.ctx.logRealtime &&
             console.info('[CLIENT] NAMESPACE REALTIME', nspPath.realtime.href + ` host: ${this.core.ctx.host}`);
-        this.core.FE = this.core.strategy.io(nspPath.global.origin, {
+        this.core.conectSocketFE = this.core.strategy.ioClient(nspPath.global.origin, {
             path: nspPath.global.pathname,
         });
-        if (this.core.FE.on) {
-            this.core.FE.on('connect', () => {
-                console.info(`[CLIENT] conented to GLOBAL namespace ${this.core.FE.id} of host: ${this.core.ctx.host}`);
+        if (this.core.conectSocketFE.on) {
+            this.core.conectSocketFE.on('connect', () => {
+                this.core.ctx.logRealtime &&
+                    console.info(`[CLIENT] connected to GLOBAL namespace ${nspPath.global.pathname}` +
+                        ` of host: ${this.core.ctx.host}`);
             });
         }
-        this.core.FE_REALTIME = this.core.strategy.io(nspPath.realtime.origin, {
+        this.core.socketFE = this.core.strategy.ioClient(nspPath.realtime.origin, {
             path: nspPath.realtime.pathname,
         });
-        if (this.core.FE_REALTIME.on) {
-            this.core.FE_REALTIME.on('connect', () => {
-                console.info(`[CLIENT] conented to REALTIME namespace ${this.core.FE_REALTIME.id} host: ${this.core.ctx.host}`);
+        if (this.core.socketFE.on) {
+            this.core.socketFE.on('connect', () => {
+                this.core.ctx.logRealtime &&
+                    console.info(`[CLIENT] connected to REALTIME namespace ${nspPath.realtime.pathname}` +
+                        ` host: ${this.core.ctx.host}`);
             });
         }
     }
@@ -1911,12 +1924,12 @@ to use socket realtime connection;
             }
             let roomName;
             if (customEvent) {
-                roomName = Symbols.REALTIME.ROOM_NAME.CUSTOM(this.core.ctx.contextName, customEvent);
+                roomName = Symbols.REALTIME.ROOM_NAME_CUSTOM(this.core.ctx.contextName, customEvent);
             }
             else {
                 roomName = _.isString(property)
-                    ? Symbols.REALTIME.ROOM_NAME.UPDATE_ENTITY_PROPERTY(this.core.ctx.contextName, className, property, idOrUniqValue)
-                    : Symbols.REALTIME.ROOM_NAME.UPDATE_ENTITY(this.core.ctx.contextName, className, idOrUniqValue);
+                    ? Symbols.REALTIME.ROOM_NAME_UPDATE_ENTITY_PROPERTY(this.core.ctx.contextName, className, property, idOrUniqValue)
+                    : Symbols.REALTIME.ROOM_NAME_UPDATE_ENTITY(this.core.ctx.contextName, className, idOrUniqValue);
             }
             const roomSubOptions = {
                 core: this.core,
@@ -1924,13 +1937,13 @@ to use socket realtime connection;
                 roomName,
                 customEvent,
             };
-            const subManagerId = this.getRoomIdFrom(roomSubOptions);
-            if (!this.subsmanagers[subManagerId]) {
-                this.subsmanagers[subManagerId] = new RealtimeSubsManager(roomSubOptions);
+            const subManagerId = this.getUniqueIdentifierForConnection(roomSubOptions);
+            if (!this.subsManagers[subManagerId]) {
+                this.subsManagers[subManagerId] = new RealtimeSubsManager(roomSubOptions);
             }
-            const inst = this.subsmanagers[subManagerId];
+            const inst = this.subsManagers[subManagerId];
             inst.add(observer);
-            inst.startListenIfNotStarted(this.core.FE_REALTIME);
+            inst.startListenIfNotStarted(this.core.socketFE);
             return () => {
                 inst.remove(observer);
             };
@@ -1953,7 +1966,7 @@ to use socket realtime connection;
      */
     listenChangesEntityObj(entity, options) {
         const classFn = ClassHelpers.getClassFnFromObject(entity);
-        const uniqueKey = ClassHelpers.getUniquKey(classFn);
+        const uniqueKey = ClassHelpers.getUniqueKey(classFn);
         return this.listenChangesEntity(classFn, entity[uniqueKey], options);
     }
     listenChangesCustomEvent(customEvent) {
@@ -1961,7 +1974,15 @@ to use socket realtime connection;
             customEvent,
         });
     }
-    getRoomIdFrom(options) {
+    /**
+     * Trigger custom event on backend
+     * @param customEvent global event name
+     * @param dataToPush
+     */
+    triggerCustomEvent(customEvent, dataToPush) {
+        this.core.socketFE.emit(customEvent, dataToPush);
+    }
+    getUniqueIdentifierForConnection(options) {
         const url = new URL(options.core.ctx.host);
         return `${this.core.ctx.contextName}:${url.origin}|${options.roomName}|${options.property}|${options.customEvent}`;
     }
@@ -1969,135 +1990,139 @@ to use socket realtime connection;
 ;
 ({}); // @--end-of-file-for-module=taon lib/realtime/realtime-client.ts
 
-const SOCKET_EVENT_DEBOUNCE = 500;
 class RealtimeServer {
     constructor(core) {
         this.core = core;
-        this.jobs = {};
         this.core = core;
         if (!core.ctx.disabledRealtime) {
             this.init();
         }
     }
     init() {
+        if (!this.core.ctx.config.frontendHost) {
+            console.warn(`[Taon][Realtime]
+
+      Frontend host is not defined
+      REALTIME COMMUNICATION WILL NOT WORK
+
+      provide "frontendHost" property in your taon config
+
+      `);
+        }
         const nspPath = {
             global: this.core.pathFor(),
             realtime: this.core.pathFor(Symbols.REALTIME.NAMESPACE(this.core.ctx.contextName)),
         };
-        this.core.BE = new this.core.strategy.Server(this.core.ctx.serverTcpUdp, {
+        this.core.connectSocketBE = this.core.strategy.ioServer(Helpers.isWebSQL ? this.core.ctx.uri.origin : this.core.ctx.serverTcpUdp, {
             path: nspPath.global.pathname,
             cors: {
                 origin: this.core.ctx.config.frontendHost,
                 methods: this.core.allHttpMethods,
             },
-        });
+        }, // @ts-ignore
+        this.core.ctx);
         this.core.ctx.logRealtime &&
-            console.info(`CREATE GLOBAL NAMESPACE: '${this.core.BE.path()}' , path: '${nspPath.global.pathname}'`);
-        this.core.BE.on('connection', clientSocket => {
-            if (Helpers.isElectron) {
-                // @ts-ignore
-                this.core.BE.emit('connect'); // TODO QUICK_FIX
-            }
-            console.info(`client conected to namespace "${clientSocket.nsp?.name}",  host: ${this.core.ctx.host}`);
+            console.info(`[backend] CREATE GLOBAL NAMESPACE: '${this.core.connectSocketBE.path()}'` +
+                ` , path: '${nspPath.global.pathname}'`);
+        this.core.connectSocketBE.on('connection', clientSocket => {
+            console.info(`[backend] client connected to namespace "${nspPath.global.pathname}", ` +
+                ` host: ${this.core.ctx.host}`);
         });
-        this.core.BE_REALTIME = new this.core.strategy.Server(this.core.ctx.serverTcpUdp, {
+        this.core.socketBE = this.core.strategy.ioServer(Helpers.isWebSQL || Helpers.isElectron
+            ? this.core.ctx.uri.origin
+            : this.core.ctx.serverTcpUdp, {
             path: nspPath.realtime.pathname,
             cors: {
                 origin: this.core.ctx.config.frontendHost,
                 methods: this.core.allHttpMethods,
             },
-        });
+        }, // @ts-ignore
+        this.core.ctx);
         this.core.ctx.logRealtime &&
-            console.info(`CREATE REALTIME NAMESPACE: '${this.core.BE_REALTIME.path()}' , path: '${nspPath.realtime.pathname}' `);
-        this.core.BE_REALTIME.on('connection', backendSocketForClient => {
-            console.info(`client conected to namespace "${backendSocketForClient.nsp?.name}",  host: ${this.core.ctx.host}`);
-            if (Helpers.isElectron) {
-                // @ts-ignore
-                backendSocketForClient = this.core.BE_REALTIME; // TODO QUICK_FIX
-                this.core.BE_REALTIME.emit('connect');
-            }
-            backendSocketForClient.on(Symbols.REALTIME.ROOM_NAME.SUBSCRIBE.CUSTOM(this.core.ctx.contextName), roomName => {
-                console.info(`Joining room ${roomName} in namespace  REALTIME` +
-                    ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`);
+            console.info(`[backend] CREATE REALTIME NAMESPACE: '${this.core.socketBE.path()}'` +
+                ` , path: '${nspPath.realtime.pathname}' `);
+        this.core.socketBE.on('connection', backendSocketForClient => {
+            console.info(`[backend] client connected to namespace "${nspPath.realtime.pathname}", ` +
+                ` host: ${this.core.ctx.host}`);
+            backendSocketForClient.on(Symbols.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.REALTIME.ROOM_NAME.SUBSCRIBE.ENTITY_UPDATE_EVENTS(this.core.ctx.contextName), roomName => {
-                console.info(`Joining room ${roomName} in namespace  REALTIME` +
-                    ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`);
+            backendSocketForClient.on(Symbols.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.REALTIME.ROOM_NAME.SUBSCRIBE.ENTITY_PROPERTY_UPDATE_EVENTS(this.core.ctx.contextName), roomName => {
-                console.info(`Joining room ${roomName} in namespace REALTIME ` +
-                    ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`);
+            backendSocketForClient.on(Symbols.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.REALTIME.ROOM_NAME.UNSUBSCRIBE.CUSTOM(this.core.ctx.contextName), roomName => {
-                console.info(`Leaving room ${roomName} in namespace  REALTIME` +
-                    ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`);
+            backendSocketForClient.on(Symbols.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.REALTIME.ROOM_NAME.UNSUBSCRIBE.ENTITY_UPDATE_EVENTS(this.core.ctx.contextName), roomName => {
-                console.info(`Leaving room ${roomName} in namespace REALTIME ` +
-                    ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`);
+            backendSocketForClient.on(Symbols.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.REALTIME.ROOM_NAME.UNSUBSCRIBE.ENTITY_PROPERTY_UPDATE_EVENTS(this.core.ctx.contextName), roomName => {
-                console.info(`Leaving room ${roomName} in namespace REALTIME ` +
-                    ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`);
+            backendSocketForClient.on(Symbols.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);
             });
         });
     }
-    triggerChanges(entityObjOrClass, property, valueOfUniquPropery, customEvent, customEventData) {
+    triggerChanges(entityObjOrClass, property, valueOfUniqueProperty, customEvent, customEventData) {
         let roomName;
         if (this.core.ctx.disabledRealtime) {
             return;
         }
         if (customEvent) {
-            roomName = Symbols.REALTIME.ROOM_NAME.CUSTOM(this.core.ctx.contextName, customEvent);
+            roomName = Symbols.REALTIME.ROOM_NAME_CUSTOM(this.core.ctx.contextName, customEvent);
         }
         else {
             let entityFn = entityObjOrClass;
-            const enittyIsObject = !_.isFunction(entityObjOrClass) && _.isObject(entityObjOrClass);
-            if (enittyIsObject) {
+            const entityIsObject = !_.isFunction(entityObjOrClass) && _.isObject(entityObjOrClass);
+            if (entityIsObject) {
                 entityFn = ClassHelpers.getClassFnFromObject(entityObjOrClass);
             }
-            const uniqueKey = ClassHelpers.getUniquKey(entityFn);
-            if (enittyIsObject) {
-                valueOfUniquPropery = entityObjOrClass[uniqueKey];
+            const uniqueKey = ClassHelpers.getUniqueKey(entityFn);
+            if (entityIsObject) {
+                valueOfUniqueProperty = entityObjOrClass[uniqueKey];
             }
-            if (!valueOfUniquPropery) {
+            if (!valueOfUniqueProperty) {
                 Helpers.error(`[Taon][Realtime] Entity without iD ! ${ClassHelpers.getName(entityFn)} `, true, true);
                 return;
             }
             roomName = _.isString(property)
-                ? Symbols.REALTIME.ROOM_NAME.UPDATE_ENTITY_PROPERTY(this.core.ctx.contextName, ClassHelpers.getName(entityFn), property, valueOfUniquPropery)
-                : Symbols.REALTIME.ROOM_NAME.UPDATE_ENTITY(this.core.ctx.contextName, ClassHelpers.getName(entityFn), valueOfUniquPropery);
-        }
-        const job = () => {
-            console.log(`Trigger realtime: ${this.core.ctx.contextName}/${roomName}`);
-            this.core.BE_REALTIME.in(roomName).emit(roomName, // roomName == eventName in room na
-            customEventData ? customEventData : '');
-        };
-        if (!_.isFunction(this.jobs[roomName])) {
-            this.jobs[roomName] = _.debounce(() => {
-                job();
-            }, SOCKET_EVENT_DEBOUNCE);
+                ? Symbols.REALTIME.ROOM_NAME_UPDATE_ENTITY_PROPERTY(this.core.ctx.contextName, ClassHelpers.getName(entityFn), property, valueOfUniqueProperty)
+                : Symbols.REALTIME.ROOM_NAME_UPDATE_ENTITY(this.core.ctx.contextName, ClassHelpers.getName(entityFn), valueOfUniqueProperty);
         }
-        this.jobs[roomName]();
+        this.core.socketBE.in(roomName).emit(roomName, // roomName == eventName in room na
+        customEvent ? customEventData : '');
     }
-    trigggerEntityChanges(entityObjOrClass, idToTrigger) {
+    triggerEntityChanges(entityObjOrClass, idToTrigger) {
         if (this.core.ctx.disabledRealtime) {
             const className = ClassHelpers.getName(entityObjOrClass);
-            console.warn(`[Taon][TrigggerEntityChanges] Entity "${className}' is not realtime`);
+            console.warn(`[Taon][TriggerEntityChanges] Entity "${className}' is not realtime`);
             return;
         }
         this.triggerChanges(entityObjOrClass, void 0, idToTrigger);
     }
-    trigggerEntityPropertyChanges(entityObjOrClass, property, idToTrigger) {
+    triggerEntityPropertyChanges(entityObjOrClass, property, idToTrigger) {
         if (this.core.ctx.disabledRealtime) {
             const className = ClassHelpers.getName(entityObjOrClass);
-            console.warn(`[Taon][TrigggerEntityPropertyChanges][property=${property}] Entity "${className}' is not realtime`);
+            console.warn(`[Taon][TriggerEntityPropertyChanges][property=${property}] Entity "${className}' is not realtime`);
             return;
         }
         if (_.isArray(property)) {
@@ -2109,16 +2134,29 @@ class RealtimeServer {
             this.triggerChanges(entityObjOrClass, property, idToTrigger);
         }
     }
-    triggerCustomEvent(customEvent, dataToPush) {
-        this.triggerChanges(void 0, void 0, void 0, customEvent, dataToPush);
-    }
-    trigggerEntityTableChanges(entityClass) {
-        const className = ClassHelpers.getName(entityClass);
+    triggerEntityTableChanges(entityClassOrInstance) {
+        const className = ClassHelpers.getName(entityClassOrInstance);
         if (this.core.ctx.disabledRealtime) {
-            console.warn(`[Taon][TrigggerEntityTableChanges] Entity "${className}' is not realtime`);
+            console.warn(`[Taon][TriggerEntityTableChanges] Entity "${className}' is not realtime`);
             return;
         }
-        this.triggerChanges(entityClass, void 0, void 0, Symbols.REALTIME.TABLE_CHANGE(this.core.ctx.contextName, className));
+        this.triggerChanges(entityClassOrInstance, void 0, void 0, Symbols.REALTIME.TABLE_CHANGE(this.core.ctx.contextName, className));
+    }
+    triggerCustomEvent(customEvent, dataToPush) {
+        this.triggerChanges(void 0, void 0, void 0, customEvent, dataToPush);
+    }
+    /**
+     * 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();
     }
 }
 ;
@@ -2128,22 +2166,69 @@ class RealtimeStrategy {
     constructor(ctx) {
         this.ctx = ctx;
     }
-    testTypes() {
+    get ioClient() {
+        throw new Error('Not implemented');
+    }
+    ioServer(url, opt) {
+        throw new Error('Not implemented');
     }
 }
 ;
 ({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy.ts
 
-/* */
-/* */
-/* */
-class IpcMainNamespace {
-    constructor(name) {
+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);
+    }
+    constructor(contextName) {
+        this.contextName = contextName;
+        this.namespacesByName = new Map();
+        MockServerIpc.serverByContextName.set(contextName, this);
+    }
+    of(namespace) {
+        if (!this.namespacesByName.has(namespace)) {
+            this.namespacesByName.set(namespace, new MockNamespaceIpc(namespace, this));
+        }
+        return this.namespacesByName.get(namespace);
+    }
+}
+class MockNamespaceIpc {
+    constructor(
+    /**
+     * Namespace name
+     */
+    name, server) {
         this.name = name;
-        this.rooms = {};
-        this.listeners = {};
+        this.server = server;
+        this.electronClients = new Set();
+        this.roomsByRoomName = {};
+        this.namespaceEventHandlers = {};
     }
-    on(event, callback) {
+    on(eventName, callback) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
         /* */
         /* */
         /* */
@@ -2168,10 +2253,11 @@ class IpcMainNamespace {
         /* */
         /* */
         /* */
-        /* */
         return (void 0);
     }
-    emit(event, ...args) {
+    emit(eventName, ...args) {
+        /* */
+        /* */
         /* */
         /* */
         /* */
@@ -2181,39 +2267,25 @@ class IpcMainNamespace {
         /* */
         return (void 0);
     }
-    to(room) {
-        return {
-            emit: (event, ...args) => {
-                const emitEvent = `(${this.name}) "${event}"`;
-                const allWindows = Electron.BrowserWindow.getAllWindows();
-                allWindows.forEach((win, index) => {
-                    win.webContents.send(emitEvent, ...args);
-                });
-            },
-        };
+    to(roomName) {
+        const electronClientsInroom = this.roomsByRoomName[roomName];
+        return new RoomEmitterIpc(electronClientsInroom, this.name, true);
     }
-    in(room) {
-        return {
-            emit: (event, ...args) => {
-                const sendEventKey = `(${this.name}) "${event}"`;
-                const allWindows = Electron.BrowserWindow.getAllWindows();
-                allWindows.forEach((win, index) => {
-                    win.webContents.send(sendEventKey, ...args);
-                });
-            },
-        };
+    in(roomName) {
+        const electronClientsInroom = this.roomsByRoomName[roomName];
+        return new RoomEmitterIpc(electronClientsInroom, this.name, false);
     }
-    join(webContents, room) {
-        if (!this.rooms[room]) {
-            this.rooms[room] = new Set();
+    join(webContents, roomName) {
+        if (!this.roomsByRoomName[roomName]) {
+            this.roomsByRoomName[roomName] = new Set();
         }
-        this.rooms[room].add(webContents);
+        this.roomsByRoomName[roomName].add(webContents);
     }
-    leave(webContents, room) {
-        if (this.rooms[room]) {
-            this.rooms[room].delete(webContents);
-            if (this.rooms[room].size === 0) {
-                delete this.rooms[room];
+    leave(webContents, roomName) {
+        if (this.roomsByRoomName[roomName]) {
+            this.roomsByRoomName[roomName].delete(webContents);
+            if (this.roomsByRoomName[roomName].size === 0) {
+                delete this.roomsByRoomName[roomName];
             }
         }
     }
@@ -2229,117 +2301,70 @@ class IpcMainNamespace {
         };
     }
 }
-;
-({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-main-namespace.ts
-
-class ioIpcStrategy {
-    constructor(contextName) {
-        this.contextName = contextName;
-        this.namespaces = {
-            ' /': new IpcMainNamespace('/'),
-        };
-    }
-    of(namespace) {
-        if (!this.namespaces[namespace]) {
-            this.namespaces[namespace] = new IpcMainNamespace(namespace);
-        }
-        return this.namespaces[namespace];
-    }
-    on(event, callback) {
-        const eventKey = `(${this.contextName}) "${event}"`;
-        this.namespaces['/'].on(eventKey, callback);
-    }
-    emit(event, ...args) {
-        const eventKey = `(${this.contextName}) "${event}"`;
-        this.namespaces['/'].emit(eventKey, ...args);
-    }
-    path() {
-        return '/';
-    }
-    get nsp() {
-        return {
-            get name() {
-                return '/';
-            },
-        };
+class RoomEmitterIpc {
+    constructor(electronClients, 
+    /**
+     * namespace name
+     */
+    name, includeSender = false, sender = null) {
+        this.electronClients = electronClients;
+        this.name = name;
+        this.includeSender = includeSender;
+        this.sender = sender;
     }
-    in(room) {
-        return {
-            emit: (event, ...args) => {
-                Object.values(this.namespaces).forEach(namespace => {
-                    namespace.to(room).emit(event, ...args);
-                });
-            },
-        };
+    emit(eventName, ...args) {
+        const emitEvent = `(${this.name}) "${eventName}"`;
+        this.electronClients?.forEach(webContents => {
+            webContents.send(emitEvent, ...args);
+        });
     }
 }
-;
-({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-main-wrapper.ts
-
-class IpcRendererNamespace {
-    constructor(name) {
-        this.name = name;
-        this.listeners = {};
+class MockSocketIpc {
+    get name() {
+        return this.namespaceName;
+    }
+    /**
+     * @param namespaceName instead url for ipc
+     */
+    constructor(namespaceName) {
+        this.namespaceName = namespaceName;
+        this.socketEventHandlers = {};
         this.ipcRenderer = window.require('electron').ipcRenderer;
     }
     on(eventName, callback) {
-        if (!this.listeners[eventName]) {
-            this.listeners[eventName] = [];
+        if (!this.socketEventHandlers[eventName]) {
+            this.socketEventHandlers[eventName] = new Set();
         }
-        this.listeners[eventName].push(callback);
+        this.socketEventHandlers[eventName].add(callback);
         const listenToEvent = `(${this.name}) "${eventName}"`;
-        this.ipcRenderer.on(listenToEvent, callback);
+        this.ipcRenderer.on(listenToEvent, (rendereEvent, data) => {
+            callback(data);
+        });
         if (eventName === 'connect') {
-            this.emit('connection');
-        }
-        else {
-            this.emit(eventName);
+            const connectionEventKey = `(${this.name}) "connection"`;
+            this.ipcRenderer.send(connectionEventKey, this.name);
         }
     }
     off(event, callback) {
-        if (!this.listeners[event])
+        if (!this.socketEventHandlers[event]) {
             return;
+        }
         if (callback) {
-            this.listeners[event] = this.listeners[event].filter(listener => listener !== callback);
+            this.socketEventHandlers[event].delete(callback);
         }
         else {
-            delete this.listeners[event];
+            delete this.socketEventHandlers[event];
         }
         const removeListener = `(${this.name}) "${event}"`;
-        this.ipcRenderer.removeListener(removeListener, callback);
+        this.ipcRenderer.removeListener(removeListener, data => {
+            callback(data);
+        });
     }
     emit(event, ...args) {
         const emitEvent = `(${this.name}) "${event}"`;
         this.ipcRenderer.send(emitEvent, ...args);
     }
 }
-;
-({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-renderer-namespace.ts
-
-class IpcRendererWrapper {
-    constructor(contextName) {
-        this.contextName = contextName;
-        this.namespaces = {
-            '/': new IpcRendererNamespace('/'),
-        };
-        this.connected = false;
-    }
-    of(namespace) {
-        if (!this.namespaces[namespace]) {
-            this.namespaces[namespace] = new IpcRendererNamespace(namespace);
-        }
-        return this.namespaces[namespace];
-    }
-    on(event, callback) {
-        this.namespaces['/'].on(event, callback);
-    }
-    emit(event, ...args) {
-        this.namespaces['/'].emit(event, ...args);
-    }
-}
-;
-({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-renderer-wrapper.ts
-
 /**
  * Purpose:
  * - backend-browser communication between 2 processes in electron mode
@@ -2348,220 +2373,222 @@ class RealtimeStrategyIpc extends RealtimeStrategy {
     toString() {
         return 'ipc';
     }
-    establishConnection() {
-        throw new Error('Method not implemented.');
-    }
     constructor(ctx) {
         super(ctx);
         this.ctx = ctx;
-        this.contextsServers = {};
-        this.contextsIO = {};
     }
-    get io() {
-        return ((__, { path: namespacePath }) => {
-            if (this.contextsIO[namespacePath]) {
-                return this.contextsIO[namespacePath];
-            }
-            const wrap = new IpcRendererWrapper(this.ctx.contextName);
-            const nsp = wrap.of(namespacePath);
-            this.contextsIO[namespacePath] = nsp;
-            return nsp;
-        });
-        return void 0;
+    ioServer(__, opt) {
+        const namespace = opt?.path || '/';
+        const server = MockServerIpc.from(this.ctx.contextName);
+        return server.of(namespace);
     }
-    get Server() {
-        return ((___, { path: namespacePath }) => {
-            if (this.contextsServers[namespacePath]) {
-                return this.contextsServers[namespacePath];
-            }
-            const wrap = new ioIpcStrategy(this.ctx.contextName);
-            const nsp = wrap.of(namespacePath);
-            this.contextsServers[namespacePath] = nsp;
-            return nsp;
-        });
-        return void 0;
+    get ioClient() {
+        const clientIo = (__, opt) => {
+            const namespace = opt?.path || '/';
+            return new MockSocketIpc(namespace);
+        };
+        return clientIo;
     }
 }
 ;
 ({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-ipc.ts
 
-class MockNamespace {
-    constructor(name, contextName) {
-        this.name = name;
-        this.contextName = contextName;
-        this.rooms = {};
-        this.sockets = new Set();
-    }
-    on(event, callback) {
-        if (event === 'connection') {
-            this.sockets.forEach(socket => callback(socket));
+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);
     }
-    emit(event, data) {
-        this.sockets.forEach(socket => socket.emit(event, data));
-    }
-    to(room) {
-        return {
-            emit: (event, data) => {
-                if (this.rooms[room]) {
-                    this.rooms[room].forEach(socket => socket.emit(event, data));
-                }
-            }
-        };
+    get allServers() {
+        return Array.from(MockServer.serverByUrl.values());
     }
-    joinRoom(socket, room) {
-        if (!this.rooms[room]) {
-            this.rooms[room] = new Set();
-        }
-        this.rooms[room].add(socket);
+    constructor(url) {
+        this.url = url;
+        this.namespacesByName = new Map();
+        MockServer.serverByUrl.set(url, this);
     }
-    leaveRoom(socket, room) {
-        if (this.rooms[room]) {
-            this.rooms[room].delete(socket);
-            if (this.rooms[room].size === 0) {
-                delete this.rooms[room];
-            }
+    of(namespace) {
+        if (!this.namespacesByName.has(namespace)) {
+            this.namespacesByName.set(namespace, new MockNamespace(namespace, this));
         }
+        return this.namespacesByName.get(namespace);
     }
-    addSocket(socket) {
-        this.sockets.add(socket);
-    }
-    removeSocket(socket) {
-        this.sockets.delete(socket);
+    path() {
+        return this.url;
     }
 }
-;
-({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock-namespaces.ts
-
-class MockSocket {
-    constructor(id, namespace) {
-        this.id = id;
-        this.namespace = namespace;
-        this.listeners = {};
-        this.namespace.addSocket(this);
-    }
-    on(event, callback) {
-        if (!this.listeners[event]) {
-            this.listeners[event] = [];
-        }
-        this.listeners[event].push(callback);
+class MockNamespace {
+    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 = {};
     }
-    off(event, callback) {
-        if (!this.listeners[event])
-            return;
-        if (callback) {
-            this.listeners[event] = this.listeners[event].filter(listener => listener !== callback);
+    on(eventName, handler) {
+        if (!this.namespaceEventHandlers[eventName]) {
+            this.namespaceEventHandlers[eventName] =
+                new Set();
         }
-        else {
-            delete this.listeners[event];
+        if (!this.namespaceEventHandlers[eventName].has(handler)) {
+            this.namespaceEventHandlers[eventName].add(handler);
         }
-    }
-    emit(event, data) {
-        if (this.listeners[event]) {
-            this.listeners[event].forEach(listener => listener(data));
+        if (eventName === 'connection') {
+            setTimeout(() => {
+                this.emit('connection', this);
+            });
         }
     }
-    join(room) {
-        this.namespace.joinRoom(this, room);
+    emit(event, ...args) {
+        this.allSocketsForNamespace?.forEach(socket => {
+            socket.emit(event, ...args);
+        });
     }
-    leave(room) {
-        this.namespace.leaveRoom(this, room);
+    connect(socket) {
+        this.allSocketsForNamespace.add(socket);
+        socket.namespaceInstance = this;
     }
-    disconnect() {
-        this.emit('disconnect');
-        this.namespace.removeSocket(this);
-        this.listeners = {};
+    to(roomName) {
+        const socketsInRoom = this.socketByRoomName[roomName];
+        return new RoomEmitter(socketsInRoom, true);
     }
-}
-;
-({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock-socket.ts
-
-class MockServer {
-    constructor(contextName) {
-        this.contextName = contextName;
-        this.namespaces = {
-            '/': new MockNamespace('/', this.contextName)
-        };
+    in(roomName) {
+        const socketsInRoom = this.socketByRoomName[roomName];
+        return new RoomEmitter(socketsInRoom, false);
     }
-    of(namespace) {
-        if (!this.namespaces[namespace]) {
-            this.namespaces[namespace] = new MockNamespace(namespace, this.contextName);
+    joinRoom(roomName, socket) {
+        if (!this.socketByRoomName[roomName]) {
+            this.socketByRoomName[roomName] = new Set();
         }
-        return this.namespaces[namespace];
+        this.socketByRoomName[roomName].add(socket);
     }
-    on(event, callback) {
-        if (event === 'connection') {
-            this.namespaces['/'].on('connection', callback);
+    leaveRoom(roomName, socket) {
+        const roomSockets = this.socketByRoomName[roomName];
+        if (roomSockets) {
+            this.socketByRoomName[roomName].delete(socket);
         }
     }
-    emit(event, data) {
-        this.namespaces['/'].emit(event, data);
+    get nsp() {
+        const self = this;
+        return {
+            get name() {
+                return self.name;
+            },
+        };
+    }
+    path() {
+        return this.name;
+    }
+}
+class RoomEmitter {
+    constructor(sockets, includeSender = false, sender = null) {
+        this.sockets = sockets;
+        this.includeSender = includeSender;
+        this.sender = sender;
     }
-    connect(id, namespace = '/') {
-        const ns = this.of(namespace);
-        const socket = new MockSocket(id, ns);
-        ns.on('connection', (socket) => {
-            socket.emit('connect');
+    emit(event, ...args) {
+        this.sockets?.forEach(socket => {
+            if (this.includeSender || socket !== this.sender) {
+                socket.emit(event, ...args);
+            }
         });
-        return socket;
     }
 }
-;
-({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock-server.ts
-
-class MockClientSocket {
-    constructor(serverSocket, contextName) {
-        this.serverSocket = serverSocket;
-        this.contextName = contextName;
-        this.listeners = {};
-        serverSocket.on('message', (data) => this.emit('message', data));
+class MockSocket {
+    get id() {
+        return this.nsp.name;
+    }
+    constructor(url, opts) {
+        this.url = url;
+        this.socketEventHandlers = {};
+        // @ts-ignore
+        const [baseUrl, namespace] = [url, opts.path || '/'];
+        const namespaceName = namespace || '/';
+        const server = MockServer.from(url);
+        const ns = server.of(namespaceName);
+        ns.connect(this);
+    }
+    get nsp() {
+        const self = this;
+        return {
+            get name() {
+                return self.namespaceInstance?.name;
+            },
+        };
+    }
+    path() {
+        return this.namespaceInstance?.name;
     }
-    on(event, callback) {
-        if (!this.listeners[event]) {
-            this.listeners[event] = [];
+    on(eventName, handler) {
+        if (!this.socketEventHandlers[eventName]) {
+            this.socketEventHandlers[eventName] =
+                new Set();
+        }
+        this.socketEventHandlers[eventName].add(handler);
+        if (eventName === 'connect') {
+            setTimeout(() => {
+                this.emit('connect');
+            });
         }
-        this.listeners[event].push(callback);
     }
-    off(event, callback) {
-        if (!this.listeners[event])
-            return;
-        if (callback) {
-            this.listeners[event] = this.listeners[event].filter(listener => listener !== callback);
+    emit(eventName, ...args) {
+        eventName = eventName || '';
+        if (eventName.includes(`:${Symbols.REALTIME.KEYroomSubscribe}`)) {
+            const room = args[0];
+            this.join(room);
+        }
+        else if (eventName.includes(`:${Symbols.REALTIME.KEYroomUnsubscribe}`)) {
+            const room = args[0];
+            this.leave(room);
         }
         else {
-            delete this.listeners[event];
+            if (this.namespaceInstance) {
+                const namespaceEventHandlers = this.namespaceInstance.namespaceEventHandlers[eventName] || [];
+                for (const namespaceEventHandler of namespaceEventHandlers) {
+                    if (namespaceEventHandler) {
+                        namespaceEventHandler(...args);
+                    }
+                }
+                const allSocketsForNamespaceExceptCurrent = Array.from(this.namespaceInstance.allSocketsForNamespace.values()).filter(socket => socket !== this);
+                for (const socket of allSocketsForNamespaceExceptCurrent) {
+                    const socketEventHandlers = socket.socketEventHandlers[eventName];
+                    for (const socketEventHandler of socketEventHandlers) {
+                        if (socketEventHandler) {
+                            socketEventHandler(...args);
+                        }
+                    }
+                }
+                const socketEventHandlers = this.socketEventHandlers[eventName] || [];
+                for (const clientHandler of socketEventHandlers) {
+                    if (clientHandler) {
+                        clientHandler(...args);
+                    }
+                }
+            }
         }
     }
-    emit(event, data) {
-        this.serverSocket.emit(event, data);
-        if (this.listeners[event]) {
-            this.listeners[event].forEach(listener => listener(data));
-        }
-    }
-    disconnect() {
-        this.serverSocket.disconnect();
-        this.listeners = {};
-    }
-    join(room) {
-        this.serverSocket.join(room);
+    join(roomName) {
+        this.namespaceInstance.joinRoom(roomName, this);
     }
-    leave(room) {
-        this.serverSocket.leave(room);
+    leave(roomName) {
+        this.namespaceInstance.leaveRoom(roomName, this);
     }
 }
-function mockIo(server) {
-    return (namespace = '/') => {
-        const socketId = Math.random().toString(36).substring(2);
-        const serverSocket = server.connect(socketId, namespace);
-        return new MockClientSocket(serverSocket, server.contextName);
-    };
-}
-;
-({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock-client.ts
-
-;
-({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-mock-models/index.ts
-
 /**
  * Purpose:
  * - browser-browser communication mock (in websql mode)
@@ -2574,15 +2601,15 @@ class RealtimeStrategyMock extends RealtimeStrategy {
         super(ctx);
         this.ctx = ctx;
     }
-    get Server() {
-        return MockServer;
-    }
-    ;
-    get io() {
-        return mockIo;
+    ioServer(url, opt) {
+        const server = MockServer.from(url || this.ctx.uri.origin);
+        return server.of(opt?.path || '/');
     }
-    establishConnection() {
-        throw new Error('Method not implemented.');
+    get ioClient() {
+        const clientIo = (uri, opts) => {
+            return new MockSocket(uri || this.ctx.uri.origin, opts);
+        };
+        return clientIo;
     }
 }
 ;
@@ -2601,18 +2628,14 @@ class RealtimeStrategySocketIO extends RealtimeStrategy {
         super(ctx);
         this.ctx = ctx;
     }
-    get Server() {
+    ioServer(...args) {
         /* */
         /* */
         return (void 0);
     }
-    ;
-    get io() {
+    get ioClient() {
         return io;
     }
-    establishConnection() {
-        throw new Error('Method not implemented.');
-    }
 }
 ;
 ({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-socket-io.ts
@@ -2639,14 +2662,22 @@ class RealtimeCore {
             'OPTIONS',
             'HEAD',
         ];
+        this.ctx = ctx;
         this.strategy = this.resolveStrategy();
-        ctx.logFramework &&
+        this.ctx.logRealtime &&
             console.log(`[taon] realtime strategy: ${this.strategy}`);
-        this.client = new RealtimeClient(this);
-        this.server = new RealtimeServer(this);
+        if (Helpers.isWebSQL) {
+            this.server = new RealtimeServer(this);
+            this.client = new RealtimeClient(this);
+        }
+        else {
+            this.client = new RealtimeClient(this);
+            this.server = new RealtimeServer(this);
+        }
     }
     resolveStrategy() {
-        if (this.ctx.mode === 'backend-frontend(websql)') {
+        if (this.ctx.mode === 'backend-frontend(websql)' ||
+            this.ctx.mode === 'backend-frontend(websql-electron)') {
             return new RealtimeStrategyMock(this.ctx);
         }
         if (this.ctx.mode === 'backend-frontend(ipc-electron)') {
@@ -2659,179 +2690,17 @@ class RealtimeCore {
         let nsp = namespace ? namespace : '';
         nsp = nsp === '/' ? '' : nsp;
         const pathname = uri.pathname !== '/' ? uri.pathname : '';
-        let prefix = `taonContext-`;
+        let prefix = `taonContext`;
         if (Helpers.isElectron) {
             prefix = ``;
         }
-        const href = `${uri.origin}${pathname}/${prefix}${nsp}`;
+        const href = `${uri.origin}${pathname}/${prefix}${prefix && nsp ? '-' + nsp : nsp}`;
         return new URL(href);
     }
 }
 ;
 ({}); // @--end-of-file-for-module=taon lib/realtime/realtime-core.ts
 
-class TaonSubscriberOptions extends Models.DecoratorAbstractOpt {
-}
-function TaonSubscriber(options) {
-    return function (constructor) {
-        Reflect.defineMetadata(Symbols.metadata.options.repository, options, constructor);
-        Reflect.defineMetadata(Symbols.metadata.className, options?.className || constructor.name, constructor);
-        ClassHelpers.setName(constructor, options?.className);
-        return class extends constructor {
-            constructor(...args) {
-                super(...args);
-                const methodNamesAll = ClassHelpers.getMethodsNames(constructor.prototype);
-                const methodNames = methodNamesAll.filter(m => {
-                    return (!['__trigger_event__', 'clone'].includes(m) &&
-                        !m.startsWith('_') &&
-                        !m.startsWith('inject'));
-                });
-                methodNames.forEach(methodName => {
-                    const originalMethod = this[methodName];
-                    this[methodName] = async (...methodArgs) => {
-                        const result = originalMethod.apply(this, methodArgs);
-                        if (result instanceof Promise) {
-                            await result;
-                        }
-                        if (options.allowedEvents === undefined ||
-                            options.allowedEvents.includes(methodName)) {
-                            // @ts-ignore
-                            this.__trigger_event__(methodName);
-                        }
-                        return result;
-                    };
-                });
-            }
-        };
-    };
-}
-;
-({}); // @--end-of-file-for-module=taon lib/decorators/classes/subscriber-decorator.ts
-
-let BaseSubscriberForEntity = class BaseSubscriberForEntity extends BaseInjector {
-    /**
-     * Called after entity is loaded.
-     */
-    afterLoad(entity) {
-        console.log(`AFTER ENTITY LOADED: `, entity);
-    }
-    /**
-     * Called before query execution.
-     */
-    beforeQuery(event) {
-        console.log(`BEFORE QUERY: `, event.query);
-    }
-    /**
-     * Called after query execution.
-     */
-    afterQuery(event) {
-        console.log(`AFTER QUERY: `, event.query);
-    }
-    /**
-     * Called before entity insertion.
-     */
-    beforeInsert(event) {
-        console.log(`BEFORE ENTITY INSERTED: `, event.entity);
-    }
-    /**
-     * Called after entity insertion.
-     */
-    afterInsert(event) {
-        console.log(`AFTER ENTITY INSERTED: `, event.entity);
-    }
-    /**
-     * Called before entity update.
-     */
-    beforeUpdate(event) {
-        console.log(`BEFORE ENTITY UPDATED: `, event.entity);
-    }
-    /**
-     * Called after entity update.
-     */
-    afterUpdate(event) {
-        console.log(`AFTER ENTITY UPDATED: `, event.entity);
-    }
-    /**
-     * Called before entity removal.
-     */
-    beforeRemove(event) {
-        console.log(`BEFORE ENTITY WITH ID ${event.entityId} REMOVED: `, event.entity);
-    }
-    /**
-     * Called after entity removal.
-     */
-    afterRemove(event) {
-        console.log(`AFTER ENTITY WITH ID ${event.entityId} REMOVED: `, event.entity);
-    }
-    /**
-     * Called before entity removal.
-     */
-    beforeSoftRemove(event) {
-        console.log(`BEFORE ENTITY WITH ID ${event.entityId} SOFT REMOVED: `, event.entity);
-    }
-    /**
-     * Called after entity removal.
-     */
-    afterSoftRemove(event) {
-        console.log(`AFTER ENTITY WITH ID ${event.entityId} SOFT REMOVED: `, event.entity);
-    }
-    /**
-     * Called before entity recovery.
-     */
-    beforeRecover(event) {
-        console.log(`BEFORE ENTITY WITH ID ${event.entityId} RECOVERED: `, event.entity);
-    }
-    /**
-     * Called after entity recovery.
-     */
-    afterRecover(event) {
-        console.log(`AFTER ENTITY WITH ID ${event.entityId} RECOVERED: `, event.entity);
-    }
-    /**
-     * Called before transaction start.
-     */
-    beforeTransactionStart(event) {
-        console.log(`BEFORE TRANSACTION STARTED: `, event);
-    }
-    /**
-     * Called after transaction start.
-     */
-    afterTransactionStart(event) {
-        console.log(`AFTER TRANSACTION STARTED: `, event);
-    }
-    /**
-     * Called before transaction commit.
-     */
-    beforeTransactionCommit(event) {
-        console.log(`BEFORE TRANSACTION COMMITTED: `, event);
-    }
-    /**
-     * Called after transaction commit.
-     */
-    afterTransactionCommit(event) {
-        console.log(`AFTER TRANSACTION COMMITTED: `, event);
-    }
-    /**
-     * Called before transaction rollback.
-     */
-    beforeTransactionRollback(event) {
-        console.log(`BEFORE TRANSACTION ROLLBACK: `, event);
-    }
-    /**
-     * Called after transaction rollback.
-     */
-    afterTransactionRollback(event) {
-        console.log(`AFTER TRANSACTION ROLLBACK: `, event);
-    }
-};
-BaseSubscriberForEntity = __decorate([
-    TaonSubscriber({
-        className: 'BaseSubscriberForEntity',
-    })
-], BaseSubscriberForEntity);
-;
-({}); // @--end-of-file-for-module=taon lib/base-classes/base-subscriber-for-entity.ts
-
 /* eslint-disable @typescript-eslint/typedef */
 class EndpointContext {
     static initNgZone(ngZone) {
@@ -2982,7 +2851,12 @@ class EndpointContext {
             this.mode = 'remote-backend(tcp+udp)';
         }
         if (this.config.useIpcWhenElectron && Helpers.isElectron) {
-            this.mode = 'backend-frontend(ipc-electron)';
+            if (Helpers.isWebSQL) {
+                this.mode = 'backend-frontend(websql-electron)';
+            }
+            else {
+                this.mode = 'backend-frontend(ipc-electron)';
+            }
         }
         if (!this.mode && !this.config.abstract) {
             Helpers.error(`[taon] Context "${this.contextName}": You need to provide host or remoteHost or useIpcWhenElectron`, false, true);
@@ -3139,6 +3013,7 @@ class EndpointContext {
                         logging: this.logDb,
                     };
                     break;
+                case 'backend-frontend(websql-electron)':
                 case 'backend-frontend(websql)':
                     databaseConfig = {
                         location: `tmp-db-${_.kebabCase(this.contextName)}.sqljs`,
@@ -3447,19 +3322,10 @@ class EndpointContext {
         return this.uri?.origin;
     }
     async initSubscribers() {
-        return; // TODO
-        if (!this.connection?.initialize) {
-            return;
-        }
-        const subscribers = this.getClassFunByArr(Models.ClassType.SUBSCRIBER);
-        for (const subscriber of subscribers) {
-            const options = Reflect.getMetadata(Symbols.metadata.options.subscriber, subscriber);
-            EventSubscriber()(subscriber);
-        }
-        console.log(this.config.subscribers);
-        return;
-        const entities = this.getClassFunByArr(Models.ClassType.ENTITY);
-        for (let index = 0; index < entities.length; index++) {
+        const subscriberClasses = this.getClassFunByArr(Models.ClassType.SUBSCRIBER);
+        for (const subscriberClassFn of subscriberClasses) {
+            const options = Reflect.getMetadata(Symbols.metadata.options.subscriber, subscriberClassFn);
+            EventSubscriber()(subscriberClassFn);
         }
     }
     async initEntities() {
@@ -3487,9 +3353,9 @@ class EndpointContext {
             : this.getClassFunByArr(Models.ClassType.ENTITY)).map(entityFn => {
             return ClassHelpers.getOrginalClass(entityFn);
         });
-        const subscribers = (this.config.override?.subscribers
+        const subscribers = this.config.override?.subscribers
             ? this.config.override.subscribers
-            : this.getClassFunByArr(Models.ClassType.SUBSCRIBER)).filter(f => f instanceof BaseSubscriberForEntity);
+            : this.getClassFunByArr(Models.ClassType.SUBSCRIBER);
         const dataSourceDbConfig = _.isObject(this.databaseConfig)
             ? {
                 type: this.databaseConfig.type,
@@ -3508,6 +3374,8 @@ class EndpointContext {
                 location: this.databaseConfig.location,
             }
             : {};
+        this.logFramework &&
+            console.log(`[Context: "${this.contextName}"] dataSourceDbConfig`, dataSourceDbConfig);
         if (this.modeAllowsDatabaseCreation && this.databaseConfig) {
             this.logDb &&
                 this.logFramework &&
@@ -4329,6 +4197,7 @@ const createContext = (configFn) => {
             return config.contextName;
         },
         /**
+         * @deprecated
          * - get reference to internal context
          */
         async __ref() {
@@ -4339,6 +4208,10 @@ const createContext = (configFn) => {
             }
             return endpointContextRef;
         },
+        /**
+        * only for internal use
+        * @deprecated
+        */
         get __refSync() {
             return endpointContextRef;
         },
@@ -4380,6 +4253,20 @@ const createContext = (configFn) => {
                 });
             });
         },
+        /**
+         * realtime communication with server
+         * Udp socket.io (or ipc) based.
+         */
+        get realtime() {
+            return {
+                get client() {
+                    return endpointContextRef.realtimeClient;
+                },
+                get server() {
+                    return endpointContextRef.realtimeServer;
+                }
+            };
+        },
     };
     return res;
 };
@@ -4402,19 +4289,160 @@ var baseContext = /*#__PURE__*/Object.freeze({
     BaseContext: BaseContext
 });
 
-let BaseSubscriber = class BaseSubscriber extends BaseInjector {
-    __trigger_event__(eventName) {
-        const ctx = this.__endpoint_context__;
-        console.log('Trigger event', eventName, ctx);
+function TaonSubscriber(options) {
+    return function (constructor) {
+        Reflect.defineMetadata(Symbols.metadata.options.repository, options, constructor);
+        Reflect.defineMetadata(Symbols.metadata.className, options?.className || constructor.name, constructor);
+        ClassHelpers.setName(constructor, options?.className);
+    };
+}
+class TaonSubscriberOptions extends Models.DecoratorAbstractOpt {
+}
+;
+({}); // @--end-of-file-for-module=taon lib/decorators/classes/subscriber-decorator.ts
+
+let BaseSubscriberForEntity = class BaseSubscriberForEntity extends BaseInjector {
+    /**
+     * Called after entity is loaded.
+     */
+    afterLoad(entity) {
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER ENTITY LOADED: `, entity);
+    }
+    /**
+     * Called before query execution.
+     */
+    beforeQuery(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`BEFORE QUERY: `, event.query);
+    }
+    /**
+     * Called after query execution.
+     */
+    afterQuery(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER QUERY: `, event.query);
+    }
+    /**
+     * Called before entity insertion.
+     */
+    beforeInsert(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`BEFORE ENTITY INSERTED: `, event.entity);
+    }
+    /**
+     * Called after entity insertion.
+     */
+    afterInsert(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER ENTITY INSERTED: `, event.entity);
+    }
+    /**
+     * Called before entity update.
+     */
+    beforeUpdate(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`BEFORE ENTITY UPDATED: `, event.entity);
+    }
+    /**
+     * Called after entity update.
+     */
+    afterUpdate(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER ENTITY UPDATED: `, event.entity);
+    }
+    /**
+     * Called before entity removal.
+     */
+    beforeRemove(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`BEFORE ENTITY WITH ID ${event.entityId} REMOVED: `, event.entity);
+    }
+    /**
+     * Called after entity removal.
+     */
+    afterRemove(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER ENTITY WITH ID ${event.entityId} REMOVED: `, event.entity);
+    }
+    /**
+     * Called before entity removal.
+     */
+    beforeSoftRemove(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`BEFORE ENTITY WITH ID ${event.entityId} SOFT REMOVED: `, event.entity);
+    }
+    /**
+     * Called after entity removal.
+     */
+    afterSoftRemove(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER ENTITY WITH ID ${event.entityId} SOFT REMOVED: `, event.entity);
+    }
+    /**
+     * Called before entity recovery.
+     */
+    beforeRecover(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`BEFORE ENTITY WITH ID ${event.entityId} RECOVERED: `, event.entity);
+    }
+    /**
+     * Called after entity recovery.
+     */
+    afterRecover(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER ENTITY WITH ID ${event.entityId} RECOVERED: `, event.entity);
+    }
+    /**
+     * Called before transaction start.
+     */
+    beforeTransactionStart(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`BEFORE TRANSACTION STARTED: `, event);
+    }
+    /**
+     * Called after transaction start.
+     */
+    afterTransactionStart(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER TRANSACTION STARTED: `, event);
+    }
+    /**
+     * Called before transaction commit.
+     */
+    beforeTransactionCommit(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`BEFORE TRANSACTION COMMITTED: `, event);
+    }
+    /**
+     * Called after transaction commit.
+     */
+    afterTransactionCommit(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER TRANSACTION COMMITTED: `, event);
+    }
+    /**
+     * Called before transaction rollback.
+     */
+    beforeTransactionRollback(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`BEFORE TRANSACTION ROLLBACK: `, event);
+    }
+    /**
+     * Called after transaction rollback.
+     */
+    afterTransactionRollback(event) {
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER TRANSACTION ROLLBACK: `, event);
     }
 };
-BaseSubscriber = __decorate([
+BaseSubscriberForEntity = __decorate([
     TaonSubscriber({
-        className: 'BaseSubscriber',
+        className: 'BaseSubscriberForEntity',
     })
-], BaseSubscriber);
+], BaseSubscriberForEntity);
 ;
-({}); // @--end-of-file-for-module=taon lib/base-classes/base-subscriber.ts
+({}); // @--end-of-file-for-module=taon lib/base-classes/base-subscriber-for-entity.ts
 
 var Base;
 (function (Base) {
@@ -4425,7 +4453,6 @@ var Base;
     Base.Provider = BaseProvider;
     Base.Class = BaseClass;
     Base.Repository = BaseRepository;
-    Base.Subscriber = BaseSubscriber;
     Base.SubscriberForEntity = BaseSubscriberForEntity;
     Base.Context = BaseContext;
 })(Base || (Base = {}));
@@ -4490,42 +4517,9 @@ const inject = (entity) => {
         },
     });
 };
-const injectController = inject;
-const injectSubscriberEvents = (subscriberClassResolveFn, eventName) => {
-    const eventsSrc = new Subject();
-    const obs = eventsSrc.asObservable();
-    let isFirstSubscription = true;
-    const proxiedObservable = new Proxy(obs, {
-        get(target, prop, receiver) {
-            if (prop === 'subscribe') {
-                return (...args) => {
-                    if (isFirstSubscription) {
-                        isFirstSubscription = false;
-                        const subscriberClassFN = subscriberClassResolveFn();
-                        const ctx = subscriberClassFN[Symbols.ctxInClassOrClassObj];
-                        if (!ctx) {
-                            throw new Error(`You are trying to inject class without context. Use context like this;
-
-              Taon.injectSubscriberEvents( ()=> ` +
-                                `MyContext.getInstance(${subscriberClassFN?.name}), '${eventName}' )
-
-
-              `);
-                        }
-                        const subscriberInstance = ctx.getInstanceBy(subscriberClassFN);
-                        console.log('First subscription, you can access arguments here:', {
-                            subscriberClassFN,
-                            eventName,
-                        });
-                    }
-                    return target.subscribe(...args);
-                };
-            }
-            return Reflect.get(target, prop, receiver);
-        },
-    });
-    return proxiedObservable;
-};
+/**
+ * TODO
+ */
 ;
 ({}); // @--end-of-file-for-module=taon lib/inject.ts
 
@@ -4543,21 +4537,9 @@ var Taon;
     Taon.Provider = TaonProvider;
     Taon.Repository = TaonRepository;
     Taon.Subscriber = TaonSubscriber;
-    /**
-     * @deprecated
-     */
     Taon.isBrowser = coreHelpers.Helpers.isBrowser;
-    /**
-     * @deprecated
-     */
     Taon.isNode = coreHelpers.Helpers.isNode;
-    /**
-     * @deprecated
-     */
     Taon.isWebSQL = coreHelpers.Helpers.isWebSQL;
-    /**
-     * @deprecated
-     */
     Taon.isElectron = coreHelpers.Helpers.isElectron;
     Taon.createContext = createContext;
     Taon.inject = inject;
@@ -4591,5 +4573,5 @@ var Taon;
  * Generated bundle index. Do not edit.
  */
 
-export { BaseContext, BaseController, BaseEntity, BaseProvider, BaseRepository, BaseSubscriber, ClassHelpers, Models, Taon, createContext, inject };
+export { BaseContext, BaseController, BaseEntity, BaseProvider, BaseRepository, ClassHelpers, Models, Taon, createContext, inject };
 //# sourceMappingURL=taon.mjs.map