taon 21.0.52 → 21.0.54

package/lib-prod/orm/columns.js

@@ -0,0 +1,64 @@
+import { Column } from 'taon-typeorm/lib-prod';
+import { ___NS__isNil } from 'tnp-core/lib-prod';
+export { Repository, Connection, Generated, AfterInsert, AfterLoad, AfterRecover, AfterRemove, AfterSoftRemove, AfterUpdate, BeforeInsert, BeforeRecover, BeforeRemove, BeforeSoftRemove, BeforeUpdate, TreeChildren, TreeParent, PrimaryGeneratedColumn, PrimaryColumn, Index, CreateDateColumn, UpdateDateColumn, DeleteDateColumn, Column, VersionColumn, VirtualColumn, JoinTable, JoinColumn, OneToMany, OneToOne, ManyToMany, ManyToOne, } from 'taon-typeorm/lib-prod';
+export { Column as CustomColumn } from 'taon-typeorm/lib-prod';
+export { Generated as GeneratedColumn } from 'taon-typeorm/lib-prod';
+/**
+ * 100 default characters varchar
+ */
+export const StringColumn = (defaultValue = null, length = 100) => Column({
+    type: 'varchar',
+    length,
+    nullable: ___NS__isNil(defaultValue),
+    default: defaultValue,
+});
+/**
+ * 100 characters varchar
+ */
+export const String100Column = (defaultValue = null) => Column({
+    type: 'varchar',
+    length: 100,
+    nullable: ___NS__isNil(defaultValue),
+    default: defaultValue,
+});
+/**
+ * 20 characters varchar
+ */
+export const String20Column = (defaultValue = null) => Column({
+    type: 'varchar',
+    length: 20,
+    nullable: ___NS__isNil(defaultValue),
+    default: defaultValue,
+});
+/**
+ * 45 characters varchar
+ */
+export const String45Column = (defaultValue = null) => Column({
+    type: 'varchar',
+    length: 45,
+    nullable: ___NS__isNil(defaultValue),
+    default: defaultValue,
+});
+/**
+ * 500 characters varchar
+ */
+export const String500Column = (defaultValue = null) => Column({
+    type: 'varchar',
+    length: 500,
+    nullable: ___NS__isNil(defaultValue),
+    default: defaultValue,
+});
+/**
+ * 200 characters varchar
+ */
+export const String200Column = (defaultValue = null) => Column({
+    type: 'varchar',
+    length: 200,
+    nullable: ___NS__isNil(defaultValue),
+    default: defaultValue,
+});
+export const NumberColumn = () => Column({ type: 'int', nullable: true });
+export const DecimalNumberColumn = () => Column({ type: 'float', nullable: true });
+export const SimpleJsonColumn = () => Column({ type: 'simple-json', nullable: true });
+export const BooleanColumn = (defaultValue) => Column({ type: 'boolean', nullable: true, default: defaultValue });
+export const DateTimeColumn = (defaultValue = null) => Column({ type: 'datetime', nullable: true, default: defaultValue });

package/lib-prod/orm/index.js

@@ -0,0 +1,56 @@
+export * from './columns';
+// TODO new 5.8 typescript is not allowing this
+// export namespace Orm {
+//   export const Repository = tsorm.Repository;
+//   export import Connection = tsorm.Connection;
+//   export namespace ListenEvent {
+//     export import AfterInsert = tsorm.AfterInsert;
+//     export import AfterLoad = tsorm.AfterLoad;
+//     export import AfterRecover = tsorm.AfterRecover;
+//     export import AfterRemove = tsorm.AfterRemove;
+//     export import AfterSoftRemove = tsorm.AfterSoftRemove;
+//     export import AfterUpdate = tsorm.AfterUpdate;
+//     export import BeforeInsert = tsorm.BeforeInsert;
+//     export import BeforeRecover = tsorm.BeforeRecover;
+//     export import BeforeRemove = tsorm.BeforeRemove;
+//     export import BeforeSoftRemove = tsorm.BeforeSoftRemove;
+//     export import BeforeUpdate = tsorm.BeforeUpdate;
+//   }
+//   export namespace Tree {
+//     export import Children = tsorm.TreeChildren;
+//     export import Parent = tsorm.TreeParent;
+//   }
+//   export namespace Column {
+//     export import Generated = tsorm.PrimaryGeneratedColumn;
+//     export import Primary = tsorm.PrimaryColumn;
+//     export import Index = tsorm.Index;
+//     export import CreateDate = tsorm.CreateDateColumn;
+//     export import UpdateDate = tsorm.UpdateDateColumn;
+//     export import DeleteDate = tsorm.DeleteDateColumn;
+//     export import Custom = tsorm.Column;
+//     export import String = additionalColumns.StringColumn;
+//     export import String100 = additionalColumns.String100Column;
+//     export import String45 = additionalColumns.String45Column;
+//     export import String500 = additionalColumns.String500Column;
+//     export import String200 = additionalColumns.String200Column;
+//     export import Number = additionalColumns.NumberColumn;
+//     export import DecimalNumber = additionalColumns.DecimalNumberColumn;
+//     export import SimpleJson = additionalColumns.SimpleJsonColumn;
+//     export import Boolean = additionalColumns.BooleanColumn;
+//     export import DateTIme = additionalColumns.DateTImeColumn;
+//     // TODO has limitation => comma in name
+//     // export const SimpleArray = () => tsorm.Column({ type: 'simple-array', nullable: true });
+//     export import Version = tsorm.VersionColumn;
+//     export import Virtual = tsorm.VirtualColumn;
+//   }
+//   export namespace Join {
+//     export import Table = tsorm.JoinTable;
+//     export import Column = tsorm.JoinColumn;
+//   }
+//   export namespace Relation {
+//     export import OneToMany = tsorm.OneToMany;
+//     export import OneToOne = tsorm.OneToOne;
+//     export import ManyToMany = tsorm.ManyToMany;
+//     export import ManyToOne = tsorm.ManyToOne;
+//   }
+// }

package/lib-prod/package.json

@@ -1,4 +1,4 @@
 {
   "name": "taon/lib-prod",
-  "version": "21.0.52"
+  "version": "21.0.54"
 }

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

@@ -0,0 +1,198 @@
+//#region imports
+import { Observable } from 'rxjs';
+import { ___NS__isObject, ___NS__isString } from 'tnp-core/lib-prod';
+import { Helpers__NS__logInfo } from 'tnp-core/lib-prod';
+import { ClassHelpers__NS__getClassFnFromObject, ClassHelpers__NS__getName, ClassHelpers__NS__getUniqueKey } from '../helpers/class-helpers';
+import { Symbols__NS__REALTIME } from '../symbols';
+import { RealtimeSubsManager } from './realtime-subs-manager';
+//#endregion
+/**
+ * Client for realtime communication
+ * you can listen to:
+ * - entity changes (any property in table changed)
+ * - entity custom property changes (specific property changed)
+ * - entity table changes (new instance added, instance removed)
+ * - custom events
+ */
+export class RealtimeClient {
+    constructor(core) {
+        this.core = core;
+        this.subsManagers = {};
+        this.core = core;
+        if (!core.ctx.disabledRealtime) {
+            // this.core.ctx.logRealtime &&
+            //   Helpers__NS__info(`
+            //   [ctx=${this.core.ctx.contextName}] init RealtimeClient (type: ${this.core.ctx.contextType})
+            //   `);
+            this.init();
+        }
+    }
+    //#region methods & getters / init
+    init() {
+        //#region prepare naspaces pathes
+        const nspPath = {
+            global: this.core.pathFor(),
+            realtime: this.core.pathFor(Symbols__NS__REALTIME.NAMESPACE(this.core.ctx.contextName)),
+        };
+        // console.log('[browser] nspPath', nspPath);
+        if (this.core.ctx.config.frontendHost &&
+            this.core.ctx.config.frontendHost !== '' &&
+            this.core.ctx.isRunningInsideDocker) {
+            this.core.ctx.logRealtime &&
+                Helpers__NS__logInfo(`[${this.core.ctx.contextName}] USING FRONTEND HOST` +
+                    ` ${this.core.ctx.config.frontendHost} FOR REALTIME`);
+            nspPath.global = new URL(`${this.core.ctx.frontendHostUri.origin}${nspPath.global.pathname}`);
+            nspPath.realtime = new URL(`${this.core.ctx.frontendHostUri.origin}${nspPath.realtime.pathname}`);
+        }
+        else {
+            this.core.ctx.logRealtime &&
+                Helpers__NS__logInfo(`[${this.core.ctx.contextName}] Not using frontend host for realtime`);
+        }
+        this.core.ctx.logRealtime &&
+            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}`);
+        //#endregion
+        //#region prepare globa FE socket
+        this.core.conectSocketFE = this.core.strategy.ioClient(nspPath.global.origin, {
+            path: nspPath.global.pathname,
+        });
+        if (this.core.conectSocketFE.on) {
+            this.core.conectSocketFE.on('connect', () => {
+                // console.info(
+                //   `[CLIENT] connected to GLOBAL namespace ${global.nsp} of host: ${context.host}`,
+                // );
+                this.core.ctx.logRealtime &&
+                    console.info(`[CLIENT] connected to GLOBAL namespace ${nspPath.global.pathname}` +
+                        ` of host: ${this.core.ctx.host}`);
+            });
+        }
+        //#endregion
+        //#region prepare realtime FE socket
+        this.core.socketFE = this.core.strategy.ioClient(nspPath.realtime.origin, {
+            path: nspPath.realtime.pathname,
+        });
+        if (this.core.socketFE.on) {
+            this.core.socketFE.on('connect', () => {
+                // console.info(
+                //   `[CLIENT] connected to REALTIME namespace ${realtime.nsp} host: ${context.host}`,
+                // );
+                this.core.ctx.logRealtime &&
+                    console.info(`[CLIENT] connected to REALTIME namespace ${nspPath.realtime.pathname}` +
+                        ` host: ${this.core.ctx.host}`);
+            });
+        }
+        //#endregion
+    }
+    //#endregion
+    //#region methods & getters  / listen changes entity
+    /**
+     * Usage:
+     * myContext.realtimeClient.listenChangesEntity(myEntityInstance);
+     *
+     *
+     * Changes trigger on backend needs to be done manually.. example code:
+     *
+     * myContext.realtimeServer.triggerEntityChanges(myEntityInstance);
+     * ...
+     */
+    listenChangesEntity(entityClassFnOrObj, options) {
+        options = options || {};
+        if (___NS__isObject(entityClassFnOrObj)) {
+            const orgObj = entityClassFnOrObj;
+            entityClassFnOrObj =
+                ClassHelpers__NS__getClassFnFromObject(entityClassFnOrObj);
+            const uniqueKey = ClassHelpers__NS__getUniqueKey(entityClassFnOrObj);
+            if (uniqueKey) {
+                options.idOrUniqValue = orgObj[uniqueKey];
+            }
+        }
+        //#region parameters validation
+        const { property, customEvent } = options;
+        const className = !customEvent && ClassHelpers__NS__getName(entityClassFnOrObj);
+        if (___NS__isString(property)) {
+            if (property.trim() === '') {
+                throw new Error(`[Taon][listenChangesEntity.. incorrect property '' for ${className}`);
+            }
+        }
+        //#endregion
+        return new Observable(observer => {
+            //#region prepare parameters for manager
+            if (this.core.ctx.disabledRealtime) {
+                console.error(`[Taon][realtime rxjs] remove taon config flag:
+
+        ...
+        disabledRealtime: true
+        ...
+
+to use socket realtime connection;
+        `);
+                return () => {
+                    // empty nothing to do
+                };
+            }
+            let roomName;
+            if (customEvent) {
+                roomName = Symbols__NS__REALTIME.ROOM_NAME_CUSTOM(this.core.ctx.contextName, customEvent);
+            }
+            else {
+                roomName = ___NS__isString(property)
+                    ? Symbols__NS__REALTIME.ROOM_NAME_UPDATE_ENTITY_PROPERTY(this.core.ctx.contextName, className, property, options.idOrUniqValue)
+                    : Symbols__NS__REALTIME.ROOM_NAME_UPDATE_ENTITY(this.core.ctx.contextName, className, options.idOrUniqValue);
+            }
+            const roomSubOptions = {
+                core: this.core,
+                property,
+                roomName,
+                customEvent,
+            };
+            //#endregion
+            const subManagerId = this.getUniqueIdentifierForConnection(roomSubOptions);
+            if (!this.subsManagers[subManagerId]) {
+                this.subsManagers[subManagerId] = new RealtimeSubsManager(roomSubOptions);
+            }
+            const inst = this.subsManagers[subManagerId];
+            inst.add(observer);
+            inst.startListenIfNotStarted(this.core.socketFE);
+            return () => {
+                inst.remove(observer);
+            };
+        });
+    }
+    //#endregion
+    //#region listen changes entity table
+    /**
+     * Listen changes entity table
+     * Example: for pagination, lists update ...
+     */
+    listenChangesEntityTable(entityClassFn) {
+        const className = ClassHelpers__NS__getName(entityClassFn);
+        return this.listenChangesEntity(entityClassFn, {
+            customEvent: Symbols__NS__REALTIME.TABLE_CHANGE(this.core.ctx.contextName, className),
+        });
+    }
+    //#endregion
+    //#region listen changes custom event
+    listenChangesCustomEvent(customEvent) {
+        return this.listenChangesEntity(void 0, {
+            customEvent,
+        });
+    }
+    //#endregion
+    //#region methods & getters / trigger custom event\
+    /**
+     * Trigger custom event on backend
+     * @param customEvent global event name
+     * @param dataToPush
+     */
+    triggerCustomEvent(customEvent, dataToPush) {
+        this.core.socketFE.emit(customEvent, dataToPush);
+    }
+    //#endregion
+    //#region methods & getters / get room id from
+    getUniqueIdentifierForConnection(options) {
+        let url = new URL(options.core.ctx.host);
+        let contextNameForCommunication = options.core.ctx.contextNameForCommunication;
+        return `${contextNameForCommunication}:${url.origin}|${options.roomName}|${options.property}|${options.customEvent}`;
+    }
+}

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

@@ -0,0 +1,81 @@
+import { UtilsOs__NS__isElectron, UtilsOs__NS__isWebSQL } from 'tnp-core/lib-prod';
+import { apiPrefix } from '../constants';
+import { RealtimeClient } from './realtime-client';
+import { RealtimeServer } from './realtime-server';
+import { RealtimeStrategyIpc, RealtimeStrategyMock, RealtimeStrategySocketIO, } from './realtime-strategy';
+//#endregion
+/**
+ * Realtime class
+ * - mock (when browser-browser)
+ * - sockets (from socket io when backend-browser)
+ * - ipc (when electron is used or between processes)
+ * - webworker (when webworker is used in browser or nodejs)
+ */
+export class RealtimeCore {
+    //#endregion
+    //#region constructor
+    constructor(ctx) {
+        this.ctx = ctx;
+        //#region fields
+        this.allHttpMethods = [
+            'GET',
+            'POST',
+            'PUT',
+            'DELETE',
+            'PATCH',
+            'OPTIONS',
+            'HEAD',
+        ];
+        this.ctx = ctx;
+        this.strategy = this.resolveStrategy();
+        //     this.ctx.logRealtime &&
+        //       console.log(`
+        // [ctx=${this.ctx.contextName}] realtime strategy: ${this.strategy}, context type: ${this.ctx.contextType}
+        //         `);
+        if (UtilsOs__NS__isWebSQL) {
+            this.server = new RealtimeServer(this);
+            // console.log('DONE INITING SERVER');
+            this.client = new RealtimeClient(this);
+            // console.log('DONE INITING CLIENT');
+        }
+        else {
+            this.client = new RealtimeClient(this);
+            this.server = new RealtimeServer(this);
+        }
+    }
+    //#endregion
+    //#region methods & getters / resovle staraegy
+    resolveStrategy() {
+        // console.log(`[taon] resolveStrategy for this.ctx.mode ${this.ctx.mode}`);
+        if (this.ctx.mode === 'backend-frontend(websql)' ||
+            this.ctx.mode === 'backend-frontend(websql-electron)') {
+            // debugger
+            return new RealtimeStrategyMock(this.ctx);
+        }
+        if (this.ctx.mode === 'backend-frontend(ipc-electron)') {
+            return new RealtimeStrategyIpc(this.ctx);
+        }
+        // if (this.ctx.mode === 'backend-frontend(tcp+udp)') {
+        //   return new RealtimeStrategySocketIO(this.ctx);
+        // }
+        // if (this.ctx.mode === 'remote-backend(tcp+udp)') {
+        //   return new RealtimeStrategySocketIO(this.ctx);
+        // }
+        return new RealtimeStrategySocketIO(this.ctx);
+    }
+    //#endregion
+    //#region path for
+    pathFor(namespace) {
+        let nsp = namespace ? namespace : '';
+        nsp = nsp === '/' ? '' : nsp;
+        const contextNameForCommunication = this.ctx.contextNameForCommunication;
+        let prefix = `${apiPrefix}/${contextNameForCommunication}/udp`;
+        if (UtilsOs__NS__isElectron) {
+            prefix = ``;
+        }
+        const href = `${this.ctx.uriOrigin}${this.ctx.uriPathnameOrNothingIfRoot}` +
+            `/${prefix}${prefix && nsp ? '-' + nsp : nsp}`;
+        // console.log(`HREF: ${href}, nsp: ${nsp}`)
+        return new URL(href);
+    }
+}

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

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

package/lib-prod/realtime/realtime-strategy/{index.ts → index.js}

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