taon 18.0.17 → 18.0.18

package/client/fesm2022/taon.mjs

@@ -23,45 +23,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: {
@@ -341,7 +348,7 @@ var ClassHelpers;
             : classFnOrObject?.constructor[Symbols.fullClassNameStaticProperty]) ||
             void 0);
     };
-    ClassHelpers.getUniquKey = (classFnOrObject) => {
+    ClassHelpers.getUniqueKey = (classFnOrObject) => {
         const classFn = _.isFunction(classFnOrObject)
             ? classFnOrObject
             : classFnOrObject.constructor;
@@ -1796,17 +1803,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 => {
@@ -1822,16 +1831,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);
                 }
             }
         }
@@ -1858,7 +1867,7 @@ class RealtimeSubsManager {
 class RealtimeClient {
     constructor(core) {
         this.core = core;
-        this.subsmanagers = {};
+        this.subsManagers = {};
         this.core = core;
         if (!core.ctx.disabledRealtime) {
             this.init();
@@ -1873,20 +1882,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}`);
             });
         }
     }
@@ -1921,12 +1934,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,
@@ -1934,13 +1947,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);
             };
@@ -1963,7 +1976,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) {
@@ -1971,7 +1984,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}`;
     }
@@ -1979,11 +2000,9 @@ 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) {
             /* */
@@ -2141,8 +2160,6 @@ class RealtimeServer {
         /* */
         /* */
         /* */
-    }
-    triggerChanges(entityObjOrClass, property, valueOfUniquPropery, customEvent, customEventData) {
         /* */
         /* */
         /* */
@@ -2157,6 +2174,11 @@ class RealtimeServer {
         /* */
         /* */
         /* */
+    }
+    triggerChanges(entityObjOrClass, property, valueOfUniqueProperty, customEvent, customEventData) {
+        /* */
+        /* */
+        /* */
         /* */
         /* */
         /* */
@@ -2212,18 +2234,18 @@ class RealtimeServer {
         /* */
         /* */
     }
-    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)) {
@@ -2235,16 +2257,33 @@ 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) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
     }
 }
 ;
@@ -2254,76 +2293,205 @@ 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 IpcRendererNamespace {
-    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.server = server;
+        this.electronClients = new Set();
+        this.roomsByRoomName = {};
+        this.namespaceEventHandlers = {};
+    }
+    on(eventName, callback) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    off(event, callback) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    emit(eventName, ...args) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    to(roomName) {
+        const electronClientsInroom = this.roomsByRoomName[roomName];
+        return new RoomEmitterIpc(electronClientsInroom, this.name, true);
+    }
+    in(roomName) {
+        const electronClientsInroom = this.roomsByRoomName[roomName];
+        return new RoomEmitterIpc(electronClientsInroom, this.name, false);
+    }
+    join(webContents, roomName) {
+        if (!this.roomsByRoomName[roomName]) {
+            this.roomsByRoomName[roomName] = new Set();
+        }
+        this.roomsByRoomName[roomName].add(webContents);
+    }
+    leave(webContents, roomName) {
+        if (this.roomsByRoomName[roomName]) {
+            this.roomsByRoomName[roomName].delete(webContents);
+            if (this.roomsByRoomName[roomName].size === 0) {
+                delete this.roomsByRoomName[roomName];
+            }
+        }
+    }
+    path() {
+        return this.name;
+    }
+    get nsp() {
+        const self = this;
+        return {
+            get name() {
+                return self.name;
+            },
+        };
+    }
+}
+class RoomEmitterIpc {
+    constructor(electronClients, 
+    /**
+     * namespace name
+     */
+    name, includeSender = false, sender = null) {
+        this.electronClients = electronClients;
         this.name = name;
-        this.listeners = {};
+        this.includeSender = includeSender;
+        this.sender = sender;
+    }
+    emit(eventName, ...args) {
+        const emitEvent = `(${this.name}) "${eventName}"`;
+        this.electronClients?.forEach(webContents => {
+            webContents.send(emitEvent, ...args);
+        });
+    }
+}
+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
@@ -2332,222 +2500,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 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));
+    get allServers() {
+        return Array.from(MockServer.serverByUrl.values());
     }
-    to(room) {
-        return {
-            emit: (event, data) => {
-                if (this.rooms[room]) {
-                    this.rooms[room].forEach(socket => socket.emit(event, data));
-                }
-            }
-        };
+    constructor(url) {
+        this.url = url;
+        this.namespacesByName = new Map();
+        MockServer.serverByUrl.set(url, this);
     }
-    joinRoom(socket, room) {
-        if (!this.rooms[room]) {
-            this.rooms[room] = new Set();
-        }
-        this.rooms[room].add(socket);
-    }
-    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;
     }
-    on(event, callback) {
-        if (!this.listeners[event]) {
-            this.listeners[event] = [];
-        }
-        this.listeners[event].push(callback);
+    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;
+            },
+        };
     }
-    off(event, callback) {
-        if (!this.listeners[event])
-            return;
-        if (callback) {
-            this.listeners[event] = this.listeners[event].filter(listener => listener !== callback);
+    path() {
+        return this.namespaceInstance?.name;
+    }
+    on(eventName, handler) {
+        if (!this.socketEventHandlers[eventName]) {
+            this.socketEventHandlers[eventName] =
+                new Set();
         }
-        else {
-            delete this.listeners[event];
+        this.socketEventHandlers[eventName].add(handler);
+        if (eventName === 'connect') {
+            setTimeout(() => {
+                this.emit('connect');
+            });
         }
     }
-    emit(event, data) {
-        this.serverSocket.emit(event, data);
-        if (this.listeners[event]) {
-            this.listeners[event].forEach(listener => listener(data));
+    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 {
+            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);
+                    }
+                }
+            }
         }
     }
-    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)
@@ -2560,15 +2728,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;
     }
 }
 ;
@@ -2587,18 +2755,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
@@ -2625,14 +2789,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)') {
@@ -2645,11 +2817,11 @@ 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);
     }
 }
@@ -2807,7 +2979,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);
@@ -3015,6 +3192,7 @@ class EndpointContext {
         /* */
         /* */
         /* */
+        /* */
         return (void 0);
     }
     get ngZone() {
@@ -3288,14 +3466,6 @@ class EndpointContext {
         return this.uri?.origin;
     }
     async initSubscribers() {
-        return; // TODO
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
         /* */
         /* */
         /* */
@@ -3310,132 +3480,6 @@ class EndpointContext {
         /* */
         /* */
         return (void 0);
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
     }
     async initEntities() {
         /* */
@@ -3548,6 +3592,8 @@ class EndpointContext {
         /* */
         /* */
         /* */
+        /* */
+        /* */
         return (void 0);
     }
     initMetadata() {
@@ -4470,6 +4516,7 @@ const createContext = (configFn) => {
             return config.contextName;
         },
         /**
+         * @deprecated
          * - get reference to internal context
          */
         async __ref() {
@@ -4480,6 +4527,10 @@ const createContext = (configFn) => {
             }
             return endpointContextRef;
         },
+        /**
+        * only for internal use
+        * @deprecated
+        */
         get __refSync() {
             return endpointContextRef;
         },
@@ -4522,6 +4573,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;
 };
@@ -4544,172 +4609,151 @@ var baseContext = /*#__PURE__*/Object.freeze({
     BaseContext: BaseContext
 });
 
-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;
-                    };
-                });
-            }
-        };
     };
 }
+class TaonSubscriberOptions extends Models.DecoratorAbstractOpt {
+}
 ;
 ({}); // @--end-of-file-for-module=taon lib/decorators/classes/subscriber-decorator.ts
 
-let BaseSubscriber = class BaseSubscriber extends BaseInjector {
-    __trigger_event__(eventName) {
-        const ctx = this.__endpoint_context__;
-        console.log('Trigger event', eventName, ctx);
-    }
-};
-BaseSubscriber = __decorate([
-    TaonSubscriber({
-        className: 'BaseSubscriber',
-    })
-], BaseSubscriber);
-;
-({}); // @--end-of-file-for-module=taon lib/base-classes/base-subscriber.ts
-
 let BaseSubscriberForEntity = class BaseSubscriberForEntity extends BaseInjector {
     /**
      * Called after entity is loaded.
      */
     afterLoad(entity) {
-        console.log(`AFTER ENTITY LOADED: `, entity);
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER ENTITY LOADED: `, entity);
     }
     /**
      * Called before query execution.
      */
     beforeQuery(event) {
-        console.log(`BEFORE QUERY: `, event.query);
+        this.__endpoint_context__.logDb &&
+            console.log(`BEFORE QUERY: `, event.query);
     }
     /**
      * Called after query execution.
      */
     afterQuery(event) {
-        console.log(`AFTER QUERY: `, event.query);
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER QUERY: `, event.query);
     }
     /**
      * Called before entity insertion.
      */
     beforeInsert(event) {
-        console.log(`BEFORE ENTITY INSERTED: `, event.entity);
+        this.__endpoint_context__.logDb &&
+            console.log(`BEFORE ENTITY INSERTED: `, event.entity);
     }
     /**
      * Called after entity insertion.
      */
     afterInsert(event) {
-        console.log(`AFTER ENTITY INSERTED: `, event.entity);
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER ENTITY INSERTED: `, event.entity);
     }
     /**
      * Called before entity update.
      */
     beforeUpdate(event) {
-        console.log(`BEFORE ENTITY UPDATED: `, event.entity);
+        this.__endpoint_context__.logDb &&
+            console.log(`BEFORE ENTITY UPDATED: `, event.entity);
     }
     /**
      * Called after entity update.
      */
     afterUpdate(event) {
-        console.log(`AFTER ENTITY UPDATED: `, event.entity);
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER ENTITY UPDATED: `, event.entity);
     }
     /**
      * Called before entity removal.
      */
     beforeRemove(event) {
-        console.log(`BEFORE ENTITY WITH ID ${event.entityId} REMOVED: `, event.entity);
+        this.__endpoint_context__.logDb &&
+            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);
+        this.__endpoint_context__.logDb &&
+            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);
+        this.__endpoint_context__.logDb &&
+            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);
+        this.__endpoint_context__.logDb &&
+            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);
+        this.__endpoint_context__.logDb &&
+            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);
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER ENTITY WITH ID ${event.entityId} RECOVERED: `, event.entity);
     }
     /**
      * Called before transaction start.
      */
     beforeTransactionStart(event) {
-        console.log(`BEFORE TRANSACTION STARTED: `, event);
+        this.__endpoint_context__.logDb &&
+            console.log(`BEFORE TRANSACTION STARTED: `, event);
     }
     /**
      * Called after transaction start.
      */
     afterTransactionStart(event) {
-        console.log(`AFTER TRANSACTION STARTED: `, event);
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER TRANSACTION STARTED: `, event);
     }
     /**
      * Called before transaction commit.
      */
     beforeTransactionCommit(event) {
-        console.log(`BEFORE TRANSACTION COMMITTED: `, event);
+        this.__endpoint_context__.logDb &&
+            console.log(`BEFORE TRANSACTION COMMITTED: `, event);
     }
     /**
      * Called after transaction commit.
      */
     afterTransactionCommit(event) {
-        console.log(`AFTER TRANSACTION COMMITTED: `, event);
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER TRANSACTION COMMITTED: `, event);
     }
     /**
      * Called before transaction rollback.
      */
     beforeTransactionRollback(event) {
-        console.log(`BEFORE TRANSACTION ROLLBACK: `, event);
+        this.__endpoint_context__.logDb &&
+            console.log(`BEFORE TRANSACTION ROLLBACK: `, event);
     }
     /**
      * Called after transaction rollback.
      */
     afterTransactionRollback(event) {
-        console.log(`AFTER TRANSACTION ROLLBACK: `, event);
+        this.__endpoint_context__.logDb &&
+            console.log(`AFTER TRANSACTION ROLLBACK: `, event);
     }
 };
 BaseSubscriberForEntity = __decorate([
@@ -4729,7 +4773,6 @@ var Base;
     Base.Provider = BaseProvider;
     Base.Class = BaseClass;
     Base.Repository = BaseRepository;
-    Base.Subscriber = BaseSubscriber;
     Base.SubscriberForEntity = BaseSubscriberForEntity;
     Base.Context = BaseContext;
 })(Base || (Base = {}));
@@ -4797,42 +4840,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
 
@@ -4849,21 +4859,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;
@@ -4897,5 +4895,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