taon 0.0.0 → 18.0.12

package/websql/esm2022/lib/helpers/taon-helpers.mjs

@@ -0,0 +1,120 @@
+import { _ } from 'tnp-core/websql';
+import * as JSON5 from 'json5';
+import { ClassHelpers } from './class-helpers';
+export var TaonHelpers;
+(function (TaonHelpers) {
+    TaonHelpers.fillUpTo = (s, nCharacters) => {
+        return _.times(nCharacters, n => {
+            if (s.charAt(n)) {
+                return s.charAt(n);
+            }
+            return ' ';
+        }).join('');
+    };
+    TaonHelpers.isGoodPath = (p) => {
+        return p && typeof p === 'string' && p.trim() !== '';
+    };
+    TaonHelpers.tryTransformParam = param => {
+        if (typeof param === 'string') {
+            let n = Number(param);
+            if (!isNaN(n))
+                return n;
+            const bool = param.trim().toLowerCase();
+            if (bool === 'true') {
+                return true;
+            }
+            if (bool === 'false') {
+                return false;
+            }
+            try {
+                const t = JSON5.parse(param);
+                return t;
+            }
+            catch (e) {
+                return param;
+            }
+        }
+        return param;
+    };
+    TaonHelpers.getExpressPath = (c, pathOrClassConfig) => {
+        if (typeof pathOrClassConfig === 'string')
+            return `${c.calculatedPath}${pathOrClassConfig}`.replace(/\/$/, '');
+        return `${c.calculatedPath}${pathOrClassConfig.path}`.replace(/\/$/, '');
+    };
+    TaonHelpers.defaultType = value => {
+        if (typeof value === 'string')
+            return '';
+        if (typeof value === 'boolean')
+            return false;
+        if (Array.isArray(value))
+            return {};
+        if (typeof value === 'object')
+            return {};
+    };
+    TaonHelpers.parseJSONwithStringJSONs = (object, waring = false) => {
+        if (!_.isObject(object)) {
+            if (waring) {
+                console.error(`
+        parseJSONwithStringJSONs(...)
+        Parameter should be a object, but is ${typeof object}
+        `, object);
+            }
+            return object;
+        }
+        let res = _.cloneDeep(object);
+        Object.keys(res).forEach(key => {
+            let isJson = false;
+            try {
+                const possibleJSON = JSON.parse(res[key]);
+                res[key] = possibleJSON;
+                isJson = true;
+            }
+            catch (e) {
+                isJson = false;
+            }
+            if (isJson) {
+                res[key] = TaonHelpers.parseJSONwithStringJSONs(res[key], false);
+            }
+        });
+        return res;
+    };
+    TaonHelpers.isPlainFileOrFolder = filePath => {
+        return /^([a-zA-Z]|\-|\_|\@|\#|\$|\!|\^|\&|\*|\(|\))+$/.test(filePath);
+    };
+    TaonHelpers.ipcKeyNameResponse = (target, methodConfig, expressPath) => {
+        return [
+            'response',
+            ClassHelpers.getName(target),
+            methodConfig.methodName,
+            methodConfig.type,
+            expressPath,
+        ].join('--');
+    };
+    TaonHelpers.ipcKeyNameRequest = (target, methodConfig, expressPath) => {
+        return [
+            'request',
+            ClassHelpers.getName(target),
+            methodConfig.methodName,
+            methodConfig.type,
+            expressPath,
+        ].join('--');
+    };
+    TaonHelpers.websqlMocks = headers => {
+        const response = {
+            status(status) {
+                return {
+                    send(send) {
+                    },
+                };
+            },
+            setHeader(key, value) {
+                headers[key] = value;
+            },
+        };
+        const request = {};
+        return { request, response };
+    };
+})(TaonHelpers || (TaonHelpers = {}));
+;
+({}); // @--end-of-file-for-module=taon lib/helpers/taon-helpers.ts
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"taon-helpers.js","sourceRoot":"","sources":["../../../../../tmp-libs-for-dist-websql/taon/projects/taon/src/lib/helpers/taon-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["\n\nimport { _ } from 'tnp-core/websql';\nimport * as JSON5 from 'json5';\nimport { Models } from '../models';\nimport { ClassHelpers } from './class-helpers';\n\nexport namespace TaonHelpers {\n\n  export const fillUpTo = (s: string, nCharacters: number) => {\n    return _.times(nCharacters, n => {\n      if (s.charAt(n)) {\n        return s.charAt(n);\n      }\n      return ' ';\n    }).join('');\n  };\n\n\n\n  export const isGoodPath = (p: string) => {\n    return p && typeof p === 'string' && p.trim() !== '';\n  };\n\n\n\n  export const tryTransformParam = param => {\n    if (typeof param === 'string') {\n      let n = Number(param);\n      if (!isNaN(n)) return n;\n      const bool = param.trim().toLowerCase();\n      if (bool === 'true') {\n        return true;\n      }\n      if (bool === 'false') {\n        return false;\n      }\n      try {\n        const t = JSON5.parse(param);\n        return t;\n      } catch (e) {\n        return param;\n      }\n    }\n    return param;\n  };\n\n\n\n  export const getExpressPath = (\n    c: Models.RuntimeControllerConfig,\n    pathOrClassConfig: Models.MethodConfig,\n  ) => {\n    if (typeof pathOrClassConfig === 'string')\n      return `${c.calculatedPath}${pathOrClassConfig}`.replace(/\\/$/, '');\n    return `${c.calculatedPath}${pathOrClassConfig.path}`.replace(/\\/$/, '');\n  };\n\n\n\n  export const defaultType = value => {\n    if (typeof value === 'string') return '';\n    if (typeof value === 'boolean') return false;\n    if (Array.isArray(value)) return {};\n    if (typeof value === 'object') return {};\n  };\n\n\n\n  export const parseJSONwithStringJSONs = (\n    object: Object,\n    waring = false,\n  ): Object => {\n\n    if (!_.isObject(object)) {\n      if (waring) {\n        console.error(\n          `\n        parseJSONwithStringJSONs(...)\n        Parameter should be a object, but is ${typeof object}\n        `,\n          object,\n        );\n      }\n\n      return object;\n    }\n\n    let res = _.cloneDeep(object);\n\n    Object.keys(res).forEach(key => {\n      let isJson = false;\n      try {\n        const possibleJSON = JSON.parse(res[key]);\n        res[key] = possibleJSON;\n        isJson = true;\n      } catch (e) {\n        isJson = false;\n      }\n\n      if (isJson) {\n        res[key] = parseJSONwithStringJSONs(res[key], false);\n      }\n    });\n\n    return res;\n  };\n\n\n\n  export const isPlainFileOrFolder = filePath => {\n    return /^([a-zA-Z]|\\-|\\_|\\@|\\#|\\$|\\!|\\^|\\&|\\*|\\(|\\))+$/.test(filePath);\n  };\n\n\n\n  export const ipcKeyNameResponse = (\n    target: Function,\n    methodConfig: Models.MethodConfig,\n    expressPath: string,\n  ) => {\n    return [\n      'response',\n      ClassHelpers.getName(target),\n      methodConfig.methodName,\n      methodConfig.type,\n      expressPath,\n    ].join('--');\n  };\n\n\n\n  export const ipcKeyNameRequest = (\n    target: Function,\n    methodConfig: Models.MethodConfig,\n    expressPath: string,\n  ) => {\n    return [\n      'request',\n      ClassHelpers.getName(target),\n      methodConfig.methodName,\n      methodConfig.type,\n      expressPath,\n    ].join('--');\n  };\n\n\n\n  export const websqlMocks = headers => {\n    const response: Express.Response = {\n      status(status: any) {\n\n        return {\n          send(send: any) {\n\n          },\n        };\n      },\n      setHeader(key: string, value: any) {\n\n        headers[key] = value;\n      },\n    };\n    const request: Express.Request = {};\n    return { request, response };\n  };\n\n}\n\n ;({}); // @--end-of-file-for-module=taon lib/helpers/taon-helpers.ts"]}

package/websql/esm2022/lib/index.mjs

@@ -0,0 +1,81 @@
+import 'reflect-metadata';
+import * as http from './decorators/http/http-decorators';
+import * as base from './base-classes/base';
+import * as controllerDecorator from './decorators/classes/controller-decorator';
+import * as entityDecorator from './decorators/classes/entity-decorator';
+import * as providerDecorator from './decorators/classes/provider-decorator';
+import * as repositoryDecorator from './decorators/classes/repository-decorator';
+import * as subscriberDecorator from './decorators/classes/subscriber-decorator';
+import * as createContextFn from './create-context';
+import * as orm from './orm';
+import * as coreHelpers from 'tnp-core/websql';
+import * as injectFn from './inject';
+import * as endpointContext from './endpoint-context';
+import * as allSymbols from './symbols';
+import * as getResponse from './get-response-value';
+export { BaseRepository } from './base-classes/base-repository';
+export { BaseController } from './base-classes/base-controller';
+export { BaseProvider } from './base-classes/base-provider';
+export { BaseSubscriber } from './base-classes/base-subscriber';
+export { BaseEntity } from './base-classes/base-entity';
+export { BaseContext } from './base-classes/base-context';
+export { createContext } from './create-context';
+export { inject } from './inject';
+export { Models } from './models';
+export * from './constants';
+export { ClassHelpers } from './helpers/class-helpers';
+export var Taon;
+(function (Taon) {
+    Taon.Http = http.Http;
+    Taon.Base = base.Base;
+    Taon.Orm = orm.Orm;
+    Taon.getResponseValue = getResponse.getResponseValue;
+    Taon.Controller = controllerDecorator.TaonController;
+    Taon.Entity = entityDecorator.TaonEntity;
+    Taon.Provider = providerDecorator.TaonProvider;
+    Taon.Repository = repositoryDecorator.TaonRepository;
+    Taon.Subscriber = subscriberDecorator.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 = createContextFn.createContext;
+    Taon.inject = injectFn.inject;
+    Taon.initNgZone = (ngZone) => {
+        endpointContext.EndpointContext.initNgZone(ngZone);
+    };
+    Taon.symbols = allSymbols.Symbols;
+    /**
+     * @deprecated
+     * use createContext instead
+     */
+    Taon.init = async (options) => {
+        const BaseContext = (await import('./base-classes/base-context'))
+            .BaseContext;
+        const context = Taon.createContext(() => ({
+            contextName: 'default',
+            host: options.host,
+            contexts: { BaseContext },
+            database: true,
+            entities: Array.from(options.entities),
+            controllers: Array.from(options.controllers),
+        }));
+        await context.initialize();
+        return context;
+    };
+})(Taon || (Taon = {}));
+;
+({}); // @--end-of-file-for-module=taon lib/index.ts
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../tmp-libs-for-dist-websql/taon/projects/taon/src/lib/index.ts"],"names":[],"mappings":"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","sourcesContent":["\n\nimport 'reflect-metadata';\nimport * as http from './decorators/http/http-decorators';\nimport * as base from './base-classes/base';\nimport * as controllerDecorator from './decorators/classes/controller-decorator';\nimport * as entityDecorator from './decorators/classes/entity-decorator';\nimport * as providerDecorator from './decorators/classes/provider-decorator';\nimport * as repositoryDecorator from './decorators/classes/repository-decorator';\nimport * as subscriberDecorator from './decorators/classes/subscriber-decorator';\nimport * as createContextFn from './create-context';\nimport * as orm from './orm';\nimport * as models from './models';\nimport * as coreHelpers from 'tnp-core/websql';\nimport * as injectFn from './inject';\nimport * as endpointContext from './endpoint-context';\nimport * as allSymbols from './symbols';\nimport * as getResponse from './get-response-value';\n\nimport { NgZone } from '@angular/core';\n\n\n\nexport { BaseRepository } from './base-classes/base-repository';\nexport { BaseController } from './base-classes/base-controller';\nexport { BaseProvider } from './base-classes/base-provider';\nexport { BaseSubscriber } from './base-classes/base-subscriber';\nexport { BaseEntity } from './base-classes/base-entity';\nexport { BaseContext } from './base-classes/base-context';\nexport { createContext } from './create-context';\nexport { inject } from './inject';\nexport { Models } from './models';\nexport * from './constants';\nexport { ClassHelpers } from './helpers/class-helpers';\n\n\nexport namespace Taon {\n  export import Response = models.Models.Http.Response;\n  export import Http = http.Http;\n  export import Base = base.Base;\n  export import Orm = orm.Orm;\n\n  export const getResponseValue = getResponse.getResponseValue;\n\n\n  export import Controller = controllerDecorator.TaonController;\n  export import Entity = entityDecorator.TaonEntity;\n  export import Provider = providerDecorator.TaonProvider;\n  export import Repository = repositoryDecorator.TaonRepository;\n  export import Subscriber = subscriberDecorator.TaonSubscriber;\n\n\n  /**\n   * @deprecated\n   */\n  export const isBrowser = coreHelpers.Helpers.isBrowser;\n  /**\n   * @deprecated\n   */\n  export const isNode = coreHelpers.Helpers.isNode;\n  /**\n   * @deprecated\n   */\n  export const isWebSQL = coreHelpers.Helpers.isWebSQL;\n  /**\n   * @deprecated\n   */\n  export const isElectron = coreHelpers.Helpers.isElectron;\n\n  export const createContext = createContextFn.createContext;\n\n  export const inject = injectFn.inject;\n\n\n\n\n  export const initNgZone = (ngZone: NgZone) => {\n    endpointContext.EndpointContext.initNgZone(ngZone);\n  };\n\n\n  export const symbols = allSymbols.Symbols;\n\n  /**\n   * @deprecated\n   * use createContext instead\n   */\n  export const init = async (options: {\n    host: string;\n    entities: Function[];\n    controllers: Function[];\n  }) => {\n    const BaseContext = (await import('./base-classes/base-context'))\n      .BaseContext;\n    const context = createContext(() => ({\n      contextName: 'default',\n      host: options.host,\n      contexts: { BaseContext },\n      database: true,\n      entities: Array.from(options.entities) as any,\n      controllers: Array.from(options.controllers) as any,\n    }));\n\n    await context.initialize();\n    return context;\n  };\n}\n\n ;({}); // @--end-of-file-for-module=taon lib/index.ts"]}

package/websql/esm2022/lib/inject.mjs

@@ -0,0 +1,70 @@
+import { inject as angularInject } from '@angular/core';
+import { Symbols } from './symbols';
+import { Subject } from 'rxjs';
+export const inject = (entity) => {
+    return new Proxy({}, {
+        get: (_, propName) => {
+            if (propName === 'hasOwnProperty') {
+                return () => false;
+            }
+            const ctor = entity();
+            const contextFromClass = ctor[Symbols.ctxInClassOrClassObj];
+            const resultContext = contextFromClass;
+            if (resultContext) {
+                let instance = resultContext.inject(ctor);
+                if (propName === 'getOriginalPrototype') {
+                    return () => Object.getPrototypeOf(instance);
+                }
+                if (propName === 'getOriginalConstructor') {
+                    return () => instance.constructor;
+                }
+                const methods = ctor[Symbols.classMethodsNames] || [];
+                const isMethods = methods.includes(propName);
+                const methodOrProperty = isMethods
+                    ? instance[propName].bind(instance)
+                    : instance[propName];
+                return methodOrProperty;
+            }
+            return angularInject(ctor)[propName];
+        },
+    });
+};
+export const injectController = inject;
+export 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;
+};
+;
+({}); // @--end-of-file-for-module=taon lib/inject.ts
+//# sourceMappingURL=data:application/json;base64,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

package/websql/esm2022/lib/models.mjs

@@ -0,0 +1,70 @@
+/* */
+/* */
+import { Models as ModelsNg2Rest } from 'ng2-rest/websql';
+import { ClassHelpers } from './helpers/class-helpers';
+export var Models;
+(function (Models) {
+    let ClassType;
+    (function (ClassType) {
+        ClassType["ENTITY"] = "ENTITY";
+        ClassType["CONTROLLER"] = "CONTROLLER";
+        ClassType["REPOSITORY"] = "REPOSITORY";
+        ClassType["PROVIDER"] = "PROVIDER";
+        ClassType["SUBSCRIBER"] = "SUBSCRIBER";
+    })(ClassType = Models.ClassType || (Models.ClassType = {}));
+    Models.ClassTypeKey = {
+        [ClassType.ENTITY]: 'entities',
+        [ClassType.CONTROLLER]: 'controllers',
+        [ClassType.REPOSITORY]: 'repositories',
+        [ClassType.PROVIDER]: 'providers',
+        [ClassType.SUBSCRIBER]: 'subscribers',
+    };
+    class DecoratorAbstractOpt {
+    }
+    Models.DecoratorAbstractOpt = DecoratorAbstractOpt;
+    class ParamConfig {
+    }
+    Models.ParamConfig = ParamConfig;
+    class MethodConfig {
+        constructor() {
+            this.parameters = {};
+        }
+    }
+    Models.MethodConfig = MethodConfig;
+    class ControllerConfig extends DecoratorAbstractOpt {
+        constructor() {
+            super(...arguments);
+            this.methods = {};
+        }
+    }
+    Models.ControllerConfig = ControllerConfig;
+    class RuntimeControllerConfig extends ControllerConfig {
+    }
+    Models.RuntimeControllerConfig = RuntimeControllerConfig;
+    let Http;
+    (function (Http) {
+        Http.Rest = ModelsNg2Rest;
+        class Errors {
+            constructor(message, code = 400) {
+                this.message = message;
+                this.code = code;
+                this.toString = () => {
+                    return this.message;
+                };
+            }
+            static create(message, code = 400) {
+                return new Errors(message, code);
+            }
+            static entityNotFound(entity) {
+                return Errors.create(`Entity ${ClassHelpers.getName(entity)} not found`);
+            }
+            static custom(message, code = 400) {
+                return Errors.create(message, code);
+            }
+        }
+        Http.Errors = Errors;
+    })(Http = Models.Http || (Models.Http = {}));
+})(Models || (Models = {}));
+;
+({}); // @--end-of-file-for-module=taon lib/models.ts
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"models.js","sourceRoot":"","sources":["../../../../tmp-libs-for-dist-websql/taon/projects/taon/src/lib/models.ts"],"names":[],"mappings":"AAKA,KAAK;AACL,KAAK;AAEL,OAAO,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAIvD,MAAM,KAAW,MAAM,CAoRtB;AApRD,WAAiB,MAAM;IAQrB,IAAY,SAMX;IAND,WAAY,SAAS;QACnB,8BAAiB,CAAA;QACjB,sCAAyB,CAAA;QACzB,sCAAyB,CAAA;QACzB,kCAAqB,CAAA;QACrB,sCAAyB,CAAA;IAC3B,CAAC,EANW,SAAS,GAAT,gBAAS,KAAT,gBAAS,QAMpB;IAEY,mBAAY,GAAG;QAC1B,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,UAAU;QAC9B,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,aAAa;QACrC,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,cAAc;QACtC,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,WAAW;QACjC,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,aAAa;KAGtC,CAAC;IA4GF,MAAa,oBAAoB;KAEhC;IAFY,2BAAoB,uBAEhC,CAAA;IAID,MAAa,WAAW;KAMvB;IANY,kBAAW,cAMvB,CAAA;IAID,MAAa,YAAY;QAAzB;YAoBE,eAAU,GAAyC,EAAE,CAAC;QACxD,CAAC;KAAA;IArBY,mBAAY,eAqBxB,CAAA;IAID,MAAa,gBAAiB,SAAQ,oBAAoB;QAA1D;;YAIE,YAAO,GAA2C,EAAE,CAAC;QACvD,CAAC;KAAA;IALY,uBAAgB,mBAK5B,CAAA;IAID,MAAa,uBAAwB,SAAQ,gBAAgB;KAG5D;IAHY,8BAAuB,0BAGnC,CAAA;IAID,IAAiB,IAAI,CAqFpB;IArFD,WAAiB,IAAI;QACL,SAAI,GAAG,aAAa,CAAC;QA+CnC,MAAa,MAAM;YAKjB,YACS,OAAe,EACd,OAA+B,GAAG;gBADnC,YAAO,GAAP,OAAO,CAAQ;gBACd,SAAI,GAAJ,IAAI,CAA8B;gBANrC,aAAQ,GAAG,GAAW,EAAE;oBAC7B,OAAO,IAAI,CAAC,OAAO,CAAC;gBACtB,CAAC,CAAC;YAKC,CAAC;YAEI,MAAM,CAAC,MAAM,CACnB,OAAe,EACf,OAA+B,GAAG;gBAElC,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;YACnC,CAAC;YAEM,MAAM,CAAC,cAAc,CAAC,MAAiB;gBAC5C,OAAO,MAAM,CAAC,MAAM,CAClB,UAAU,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC,YAAY,CACnD,CAAC;YACJ,CAAC;YAEM,MAAM,CAAC,MAAM,CAClB,OAAe,EACf,OAA+B,GAAG;gBAElC,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;YACtC,CAAC;SACF;QA7BY,WAAM,SA6BlB,CAAA;IAQH,CAAC,EArFgB,IAAI,GAAJ,WAAI,KAAJ,WAAI,QAqFpB;AAEH,CAAC,EApRgB,MAAM,KAAN,MAAM,QAoRtB;AAEA,CAAC;AAAA,CAAC,EAAE,CAAC,CAAC,CAAC,+CAA+C","sourcesContent":["\n\nimport { CoreModels } from 'tnp-core/websql';\nimport { Response, RequestHandler } from 'express';\nimport {   Response as ExpressResponse,   Request as ExpressRequest, } from 'express';/* */\n/* */\n/* */\n\nimport { Models as ModelsNg2Rest } from 'ng2-rest/websql';\nimport { ClassHelpers } from './helpers/class-helpers';\nimport type { TaonControllerOptions } from './decorators/classes/controller-decorator';\nimport type { TaonEntityOptions } from './decorators/classes/entity-decorator';\n\nexport namespace Models {\n  export type FrameworkMode =\n    | 'backend-frontend(tcp+udp)'\n    | 'remote-backend(tcp+udp)'\n    | 'backend-frontend(ipc-electron)'\n    | 'backend-frontend(websql)';\n\n\n  export enum ClassType {\n    ENTITY = 'ENTITY',\n    CONTROLLER = 'CONTROLLER',\n    REPOSITORY = 'REPOSITORY',\n    PROVIDER = 'PROVIDER',\n    SUBSCRIBER = 'SUBSCRIBER',\n  }\n\n  export const ClassTypeKey = {\n    [ClassType.ENTITY]: 'entities',\n    [ClassType.CONTROLLER]: 'controllers',\n    [ClassType.REPOSITORY]: 'repositories',\n    [ClassType.PROVIDER]: 'providers',\n    [ClassType.SUBSCRIBER]: 'subscribers',\n  } as {\n    [key in ClassType]: keyof ContextOptions<any, any, any, any, any, any>;\n  };\n\n\n\n\n  export type MiddlewareType = [Function, any[]];\n\n\n\n  export interface DatabaseConfig {\n    /**\n     * database name\n     */\n    database?: string;\n    /**\n     * only for file base db: sqlite, sqljs\n     */\n    location?: string;\n    synchronize: boolean;\n    dropSchema: boolean;\n    type?: CoreModels.DatabaseType;\n\n    autoSave: boolean; // TODO what is this ?\n    /**\n     * for websql db mode\n     */\n    useLocalForage?: boolean;\n    logging: boolean;\n\n    databasePort?: number;\n    databaseHost?: string;\n    databaseUsername?: string;\n    databasePassword?: string;\n  }\n\n\n\n\n  export type ISession = {\n    secret?: string;\n    saveUninitialized?: boolean;\n    /**\n     * max age of session\n     */\n    cookieMaxAge?: number;\n    secure?: boolean;\n    resave?: boolean;\n  };\n\n\n\n  export type ContectionOptionsLogs = {\n    http: boolean;\n    realtime: boolean;\n    framework: boolean;\n    db: boolean;\n  };\n  export interface ContextOptions<\n    CONTEXTS,\n    CONTROLLERS,\n    ENTITIES,\n    REPOSITORIES,\n    PROVIDERS,\n    SUBSCRIBERS,\n  > {\n    contextName: string;\n    host?: string;\n    /**\n   * frontend host only needed when we are using\n   * withCredentials for axios\n   * and session cookie\n   */\n    frontendHost?: string;\n    remoteHost?: string;\n    useIpcWhenElectron?: boolean;\n    contexts?: CONTEXTS;\n    controllers?: CONTROLLERS;\n    entities?: ENTITIES;\n    repositories?: REPOSITORIES;\n    providers?: PROVIDERS;\n    subscribers?: SUBSCRIBERS;\n    session?: ISession;\n    productionMode?: boolean;\n    abstract?: boolean;\n    logs?: boolean | ContectionOptionsLogs;\n    database?: boolean | DatabaseConfig;\n    disabledRealtime?: boolean;\n    https?: {\n      key: string;\n      cert: string;\n    };\n    publicAssets?: { serverPath: string; locationOnDisk: string }[];\n    middlewares?: MiddlewareType[];\n    /**\n     * @deprecated\n     * only for debugging purpose\n     */\n    override?: {\n      entities?: Function[];\n      controllers?: Function[];\n      repositories?: Function[];\n      providers?: Function[];\n      subscribers?: Function[];\n    };\n  }\n\n\n\n  export class DecoratorAbstractOpt {\n    className: string;\n  }\n\n\n\n  export class ParamConfig {\n    paramName: string;\n    paramType: CoreModels.ParamType;\n    index: number;\n    defaultType: any;\n    expireInSeconds?: number;\n  }\n\n\n\n  export class MethodConfig {\n    methodName: string;\n    /**\n     * path is global in express app\n     */\n    global?: boolean;\n    /**\n     * override default content type\n     */\n    contentType?: any;\n    /**\n     * override default axiso response type\n     */\n    responseType?: any;\n    path: string;\n    descriptor: PropertyDescriptor;\n    type: CoreModels.HttpMethod;\n\n    requestHandler: any;\n\n    parameters: { [paramName: string]: ParamConfig } = {};\n  }\n\n\n\n  export class ControllerConfig extends DecoratorAbstractOpt {\n    realtime?: boolean;\n    path: string;\n    uniqueKey?: string;\n    methods: { [methodName: string]: MethodConfig } = {};\n  }\n\n\n\n  export class RuntimeControllerConfig extends ControllerConfig {\n    calculatedPath?: string;\n    browserTransformFn?: (entity: any) => any;\n  }\n\n\n\n  export namespace Http {\n    export import Rest = ModelsNg2Rest;\n\n    export type ContextENDPOINT = { target: Function; initFN: Function };\n\n    export type FormlyFromType = 'material' | 'bootstrap';\n\n    export type ExpressContext<T> = (\n      req: ExpressRequest,\n      res: ExpressResponse,\n    ) => T;\n\n    export type SyncResponse<T> = string | T;\n\n    export type ResponseFuncOpt<T> = {\n      limitSize?: (\n        enties: Function | Function[],\n        include: string[],\n        exclude: string[],\n      ) => void;\n    };\n\n    export type SyncResponseFunc<T> = (\n      options?: ResponseFuncOpt<T>,\n    ) => SyncResponse<T>;\n    export type MixResponse<T> = SyncResponse<T> | ExpressContext<T>;\n\n    export interface ClientAction<T> {\n      received?: Rest.PromiseObservableMix<Rest.HttpResponse<T>>;\n    }\n\n    export interface __Response<T> {\n\n      send?: MixResponse<T>;\n\n    }\n\n    export interface AsyncResponse<T> {\n      (\n        req?: ExpressRequest,\n        res?: ExpressResponse,\n      ): Promise<SyncResponse<T> | SyncResponseFunc<T>>;\n    }\n\n    export type Response<T = string> = (__Response<T> | AsyncResponse<T>) &\n      ClientAction<T> &\n      __Response<T>;\n\n    export class Errors {\n      public toString = (): string => {\n        return this.message;\n      };\n\n      private constructor(\n        public message: string,\n        private code: ModelsNg2Rest.HttpCode = 400,\n      ) {}\n\n      private static create(\n        message: string,\n        code: ModelsNg2Rest.HttpCode = 400,\n      ) {\n        return new Errors(message, code);\n      }\n\n      public static entityNotFound(entity?: Function) {\n        return Errors.create(\n          `Entity ${ClassHelpers.getName(entity)} not found`,\n        );\n      }\n\n      public static custom(\n        message: string,\n        code: ModelsNg2Rest.HttpCode = 400,\n      ) {\n        return Errors.create(message, code);\n      }\n    }\n\n\n    export interface AuthCallBack {\n      (methodReference: Function): RequestHandler;\n    }\n\n\n  }\n\n}\n\n ;({}); // @--end-of-file-for-module=taon lib/models.ts"]}

package/websql/esm2022/lib/orm.mjs

@@ -0,0 +1,60 @@
+import * as tsorm from 'taon-typeorm/websql';
+export var Orm;
+(function (Orm) {
+    Orm.Repository = tsorm.Repository;
+    Orm.Connection = tsorm.Connection;
+    let ListenEvent;
+    (function (ListenEvent) {
+        ListenEvent.AfterInsert = tsorm.AfterInsert;
+        ListenEvent.AfterLoad = tsorm.AfterLoad;
+        ListenEvent.AfterRecover = tsorm.AfterRecover;
+        ListenEvent.AfterRemove = tsorm.AfterRemove;
+        ListenEvent.AfterSoftRemove = tsorm.AfterSoftRemove;
+        ListenEvent.AfterUpdate = tsorm.AfterUpdate;
+        ListenEvent.BeforeInsert = tsorm.BeforeInsert;
+        ListenEvent.BeforeRecover = tsorm.BeforeRecover;
+        ListenEvent.BeforeRemove = tsorm.BeforeRemove;
+        ListenEvent.BeforeSoftRemove = tsorm.BeforeSoftRemove;
+        ListenEvent.BeforeUpdate = tsorm.BeforeUpdate;
+    })(ListenEvent = Orm.ListenEvent || (Orm.ListenEvent = {}));
+    let Tree;
+    (function (Tree) {
+        Tree.Children = tsorm.TreeChildren;
+        Tree.Parent = tsorm.TreeParent;
+    })(Tree = Orm.Tree || (Orm.Tree = {}));
+    let Column;
+    (function (Column) {
+        Column.Generated = tsorm.PrimaryGeneratedColumn;
+        Column.Primary = tsorm.PrimaryColumn;
+        Column.Index = tsorm.Index;
+        Column.CreateDate = tsorm.CreateDateColumn;
+        Column.UpdateDate = tsorm.UpdateDateColumn;
+        Column.DeleteDate = tsorm.DeleteDateColumn;
+        Column.Custom = tsorm.Column;
+        /**
+         * 100 characters varchar
+         */
+        Column.String = () => tsorm.Column({ type: 'varchar', length: 100, nullable: true });
+        Column.Number = () => tsorm.Column({ type: 'int', nullable: true });
+        Column.DecimalNumber = () => tsorm.Column({ type: 'float', nullable: true });
+        Column.SimpleJson = () => tsorm.Column({ type: 'simple-json', nullable: true });
+        Column.Boolean = (defaultValue) => tsorm.Column({ type: 'boolean', default: defaultValue });
+        Column.Version = tsorm.VersionColumn;
+        Column.Virtual = tsorm.VirtualColumn;
+    })(Column = Orm.Column || (Orm.Column = {}));
+    let Join;
+    (function (Join) {
+        Join.Table = tsorm.JoinTable;
+        Join.Column = tsorm.JoinColumn;
+    })(Join = Orm.Join || (Orm.Join = {}));
+    let Relation;
+    (function (Relation) {
+        Relation.OneToMany = tsorm.OneToMany;
+        Relation.OneToOne = tsorm.OneToOne;
+        Relation.ManyToMany = tsorm.ManyToMany;
+        Relation.ManyToOne = tsorm.ManyToOne;
+    })(Relation = Orm.Relation || (Orm.Relation = {}));
+})(Orm || (Orm = {}));
+;
+({}); // @--end-of-file-for-module=taon lib/orm.ts
+//# sourceMappingURL=data:application/json;base64,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

package/websql/esm2022/lib/realtime/realtime-client.mjs

@@ -0,0 +1,129 @@
+import { _ } from 'tnp-core/websql';
+import { Symbols } from '../symbols';
+import { Observable } from 'rxjs';
+import { ClassHelpers } from '../helpers/class-helpers';
+import { RealtimeSubsManager } from './realtime-subs-manager';
+export class RealtimeClient {
+    constructor(core) {
+        this.core = core;
+        this.subsmanagers = {};
+        this.core = core;
+        if (!core.ctx.disabledRealtime) {
+            this.init();
+        }
+    }
+    init() {
+        const nspPath = {
+            global: this.core.pathFor(),
+            realtime: this.core.pathFor(Symbols.REALTIME.NAMESPACE(this.core.ctx.contextName)),
+        };
+        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}`);
+        this.core.FE = this.core.strategy.io(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}`);
+            });
+        }
+        this.core.FE_REALTIME = this.core.strategy.io(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}`);
+            });
+        }
+    }
+    /**
+     * Changes trigger on backend needs to be done manually.. example code:
+     *
+     * ...
+     * Context.Realtime.Server.TrigggerEntityChanges(myEntityInstance);
+     * ...
+     */
+    listenChangesEntity(entityClassFn, idOrUniqValue, options) {
+        options = options || {};
+        const { property, customEvent } = options;
+        const className = !customEvent && ClassHelpers.getName(entityClassFn);
+        if (_.isString(property)) {
+            if (property.trim() === '') {
+                throw new Error(`[Taon][listenChangesEntity.. incorect property '' for ${className}`);
+            }
+        }
+        return new Observable(observer => {
+            if (this.core.ctx.disabledRealtime) {
+                console.error(`[Taon][realtime rxjs] remove taon config flag:
+
+        ...
+        disabledRealtime: true
+        ...
+
+to use socket realtime connection;
+        `);
+                return () => {
+                };
+            }
+            let roomName;
+            if (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);
+            }
+            const roomSubOptions = {
+                core: this.core,
+                property,
+                roomName,
+                customEvent,
+            };
+            const subManagerId = this.getRoomIdFrom(roomSubOptions);
+            if (!this.subsmanagers[subManagerId]) {
+                this.subsmanagers[subManagerId] = new RealtimeSubsManager(roomSubOptions);
+            }
+            const inst = this.subsmanagers[subManagerId];
+            inst.add(observer);
+            inst.startListenIfNotStarted(this.core.FE_REALTIME);
+            return () => {
+                inst.remove(observer);
+            };
+        });
+    }
+    listenChangesEntityTable(entityClassFn) {
+        const className = ClassHelpers.getName(entityClassFn);
+        return this.listenChangesEntity(entityClassFn, void 0, {
+            customEvent: Symbols.REALTIME.TABLE_CHANGE(this.core.ctx.contextName, className),
+        });
+    }
+    /**
+     * Changes trigger on backend needs to be done manually.. example code:
+     *
+     * ...
+     * Context.Realtime.Server.TrigggerEntityChanges(myEntityInstance);
+     * // or
+     * Context.Realtime.Server.TrigggerEntityPropertyChanges(myEntityInstance,{ property: 'geolocationX' });
+     * ...
+     */
+    listenChangesEntityObj(entity, options) {
+        const classFn = ClassHelpers.getClassFnFromObject(entity);
+        const uniqueKey = ClassHelpers.getUniquKey(classFn);
+        return this.listenChangesEntity(classFn, entity[uniqueKey], options);
+    }
+    listenChangesCustomEvent(customEvent) {
+        return this.listenChangesEntity(void 0, void 0, {
+            customEvent,
+        });
+    }
+    getRoomIdFrom(options) {
+        const url = new URL(options.core.ctx.host);
+        return `${this.core.ctx.contextName}:${url.origin}|${options.roomName}|${options.property}|${options.customEvent}`;
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-client.ts
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"realtime-client.js","sourceRoot":"","sources":["../../../../../tmp-libs-for-dist-websql/taon/projects/taon/src/lib/realtime/realtime-client.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAC;AAEpC,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAM9D,MAAM,OAAO,cAAc;IAEzB,YAAoB,IAAkB;QAAlB,SAAI,GAAJ,IAAI,CAAc;QAD9B,iBAAY,GAA4C,EAAE,CAAC;QAEjE,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,EAAE,CAAC;YAE/B,IAAI,CAAC,IAAI,EAAE,CAAC;QAEd,CAAC;IACH,CAAC;IAGO,IAAI;QAEV,MAAM,OAAO,GAAG;YACd,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;YAC3B,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CACzB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CACtD;SACF,CAAC;QAEF,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW;YACvB,OAAO,CAAC,IAAI,CACV,4BAA4B,EAC5B,OAAO,CAAC,MAAM,CAAC,IAAI,GAAG,UAAU,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CACrD,CAAC;QAEJ,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW;YACvB,OAAO,CAAC,IAAI,CACV,6BAA6B,EAC7B,OAAO,CAAC,QAAQ,CAAC,IAAI,GAAG,UAAU,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CACvD,CAAC;QAIJ,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE;YAC1D,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,QAAQ;SAC9B,CAAC,CAAC;QAEH,IAAI,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YACpB,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;gBAI9B,OAAO,CAAC,IAAI,CACV,yCAAyC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,aAAa,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAC1F,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;QAKD,IAAI,CAAC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE;YACrE,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,QAAQ;SAChC,CAAC,CAAC;QAEH,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,EAAE,CAAC;YAC7B,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;gBAIvC,OAAO,CAAC,IAAI,CACV,2CAA2C,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,UAAU,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAClG,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;IAGH,CAAC;IAID;;;;;;OAMG;IACH,mBAAmB,CACjB,aAAuB,EACvB,aAAkB,EAClB,OAAoC;QAEpC,OAAO,GAAG,OAAO,IAAK,EAAU,CAAC;QAGjC,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC;QAC1C,MAAM,SAAS,GAAG,CAAC,WAAW,IAAI,YAAY,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;QAEtE,IAAI,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YACzB,IAAI,QAAQ,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;gBAC3B,MAAM,IAAI,KAAK,CACb,yDAAyD,SAAS,EAAE,CACrE,CAAC;YACJ,CAAC;QACH,CAAC;QAGD,OAAO,IAAI,UAAU,CAAC,QAAQ,CAAC,EAAE;YAG/B,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,EAAE,CAAC;gBACnC,OAAO,CAAC,KAAK,CAAC;;;;;;;SAOb,CAAC,CAAC;gBACH,OAAO,GAAG,EAAE;gBAEZ,CAAC,CAAC;YACJ,CAAC;YAED,IAAI,QAAgB,CAAC;YAErB,IAAI,WAAW,EAAE,CAAC;gBAChB,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,CAC1C,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,EACzB,WAAW,CACZ,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;oBAC7B,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,sBAAsB,CAC/C,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,EACzB,SAAS,EACT,QAAQ,EACR,aAAa,CACd;oBACH,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,aAAa,CACtC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,EACzB,SAAS,EACT,aAAa,CACd,CAAC;YACR,CAAC;YAED,MAAM,cAAc,GAAkC;gBACpD,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,QAAQ;gBACR,QAAQ;gBACR,WAAW;aACZ,CAAC;YAGF,MAAM,YAAY,GAAG,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;YACxD,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,EAAE,CAAC;gBACrC,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,GAAG,IAAI,mBAAmB,CACvD,cAAc,CACf,CAAC;YACJ,CAAC;YACD,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;YAC7C,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YAEnB,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAEpD,OAAO,GAAG,EAAE;gBACV,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YACxB,CAAC,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAKD,wBAAwB,CAAC,aAAuB;QAC9C,MAAM,SAAS,GAAG,YAAY,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;QACtD,OAAO,IAAI,CAAC,mBAAmB,CAAC,aAAa,EAAE,KAAK,CAAC,EAAE;YACrD,WAAW,EAAE,OAAO,CAAC,QAAQ,CAAC,YAAY,CACxC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,EACzB,SAAS,CACV;SACF,CAAC,CAAC;IACL,CAAC;IAKD;;;;;;;;OAQG;IACH,sBAAsB,CACpB,MAAS,EACT,OAAqC;QAErC,MAAM,OAAO,GAAG,YAAY,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;QAC1D,MAAM,SAAS,GAAG,YAAY,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACpD,OAAO,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,MAAM,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,CAAC;IACvE,CAAC;IAID,wBAAwB,CAAC,WAAmB;QAC1C,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,EAAE;YAC9C,WAAW;SACZ,CAAC,CAAC;IACL,CAAC;IAIO,aAAa,CAAC,OAAsC;QAC1D,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC3C,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,MAAM,IAAI,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IACrH,CAAC;CAEF;AAEA,CAAC;AAAA,CAAC,EAAE,CAAC,CAAC,CAAC,iEAAiE","sourcesContent":["\n\n\nimport { _ } from 'tnp-core/websql';\nimport { RealtimeCore } from './realtime-core';\nimport { Symbols } from '../symbols';\nimport { Observable } from 'rxjs';\nimport { ClassHelpers } from '../helpers/class-helpers';\nimport { RealtimeSubsManager } from './realtime-subs-manager';\nimport { RealtimeModels } from './realtime.models';\nimport type { BaseEntity } from '../base-classes/base-entity';\nimport { Helpers } from 'tnp-core/websql';\n\n\nexport class RealtimeClient {\n  private subsmanagers: { [path: string]: RealtimeSubsManager } = {};\n  constructor(private core: RealtimeCore) {\n    this.core = core;\n    if (!core.ctx.disabledRealtime) {\n\n      this.init();\n\n    }\n  }\n\n\n  private init() {\n\n    const nspPath = {\n      global: this.core.pathFor(),\n      realtime: this.core.pathFor(\n        Symbols.REALTIME.NAMESPACE(this.core.ctx.contextName),\n      ),\n    };\n\n    this.core.ctx.logRealtime &&\n      console.info(\n        '[CLIENT] NAMESPACE GLOBAL ',\n        nspPath.global.href + ` host: ${this.core.ctx.host}`,\n      );\n\n    this.core.ctx.logRealtime &&\n      console.info(\n        '[CLIENT] NAMESPACE REALTIME',\n        nspPath.realtime.href + ` host: ${this.core.ctx.host}`,\n      );\n\n\n\n    this.core.FE = this.core.strategy.io(nspPath.global.origin, {\n      path: nspPath.global.pathname,\n    });\n\n    if (this.core.FE.on) {\n      this.core.FE.on('connect', () => {\n\n\n\n        console.info(\n          `[CLIENT] conented to GLOBAL namespace ${this.core.FE.id} of host: ${this.core.ctx.host}`,\n        );\n      });\n    }\n\n\n\n\n    this.core.FE_REALTIME = this.core.strategy.io(nspPath.realtime.origin, {\n      path: nspPath.realtime.pathname,\n    });\n\n    if (this.core.FE_REALTIME.on) {\n      this.core.FE_REALTIME.on('connect', () => {\n\n\n\n        console.info(\n          `[CLIENT] conented to REALTIME namespace ${this.core.FE_REALTIME.id} host: ${this.core.ctx.host}`,\n        );\n      });\n    }\n\n\n  }\n\n\n\n  /**\n   * Changes trigger on backend needs to be done manually.. example code:\n   *\n   * ...\n   * Context.Realtime.Server.TrigggerEntityChanges(myEntityInstance);\n   * ...\n   */\n  listenChangesEntity(\n    entityClassFn: Function,\n    idOrUniqValue: any,\n    options: RealtimeModels.ChangeOption,\n  ) {\n    options = options || ({} as any);\n\n\n    const { property, customEvent } = options;\n    const className = !customEvent && ClassHelpers.getName(entityClassFn);\n\n    if (_.isString(property)) {\n      if (property.trim() === '') {\n        throw new Error(\n          `[Taon][listenChangesEntity.. incorect property '' for ${className}`,\n        );\n      }\n    }\n\n\n    return new Observable(observer => {\n\n\n      if (this.core.ctx.disabledRealtime) {\n        console.error(`[Taon][realtime rxjs] remove taon config flag:\n\n        ...\n        disabledRealtime: true\n        ...\n\nto use socket realtime connection;\n        `);\n        return () => {\n\n        };\n      }\n\n      let roomName: string;\n\n      if (customEvent) {\n        roomName = Symbols.REALTIME.ROOM_NAME.CUSTOM(\n          this.core.ctx.contextName,\n          customEvent,\n        );\n      } else {\n        roomName = _.isString(property)\n          ? Symbols.REALTIME.ROOM_NAME.UPDATE_ENTITY_PROPERTY(\n              this.core.ctx.contextName,\n              className,\n              property,\n              idOrUniqValue,\n            )\n          : Symbols.REALTIME.ROOM_NAME.UPDATE_ENTITY(\n              this.core.ctx.contextName,\n              className,\n              idOrUniqValue,\n            );\n      }\n\n      const roomSubOptions: RealtimeModels.SubsManagerOpt = {\n        core: this.core,\n        property,\n        roomName,\n        customEvent,\n      };\n\n\n      const subManagerId = this.getRoomIdFrom(roomSubOptions);\n      if (!this.subsmanagers[subManagerId]) {\n        this.subsmanagers[subManagerId] = new RealtimeSubsManager(\n          roomSubOptions,\n        );\n      }\n      const inst = this.subsmanagers[subManagerId];\n      inst.add(observer);\n\n      inst.startListenIfNotStarted(this.core.FE_REALTIME);\n\n      return () => {\n        inst.remove(observer);\n      };\n    });\n  }\n\n\n\n\n  listenChangesEntityTable(entityClassFn: Function) {\n    const className = ClassHelpers.getName(entityClassFn);\n    return this.listenChangesEntity(entityClassFn, void 0, {\n      customEvent: Symbols.REALTIME.TABLE_CHANGE(\n        this.core.ctx.contextName,\n        className,\n      ),\n    });\n  }\n\n\n\n\n  /**\n   * Changes trigger on backend needs to be done manually.. example code:\n   *\n   * ...\n   * Context.Realtime.Server.TrigggerEntityChanges(myEntityInstance);\n   * // or\n   * Context.Realtime.Server.TrigggerEntityPropertyChanges(myEntityInstance,{ property: 'geolocationX' });\n   * ...\n   */\n  listenChangesEntityObj<T extends BaseEntity>(\n    entity: T,\n    options?: RealtimeModels.ChangeOption,\n  ) {\n    const classFn = ClassHelpers.getClassFnFromObject(entity);\n    const uniqueKey = ClassHelpers.getUniquKey(classFn);\n    return this.listenChangesEntity(classFn, entity[uniqueKey], options);\n  }\n\n\n\n  listenChangesCustomEvent(customEvent: string) {\n    return this.listenChangesEntity(void 0, void 0, {\n      customEvent,\n    });\n  }\n\n\n\n  private getRoomIdFrom(options: RealtimeModels.SubsManagerOpt) {\n    const url = new URL(options.core.ctx.host);\n    return `${this.core.ctx.contextName}:${url.origin}|${options.roomName}|${options.property}|${options.customEvent}`;\n  }\n\n}\n\n ;({}); // @--end-of-file-for-module=taon lib/realtime/realtime-client.ts"]}