taon 0.0.0 → 18.0.15

package/lib/endpoint-context.js

@@ -0,0 +1,2128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndpointContext = void 0;
+var tslib_1 = require("tslib");
+/* eslint-disable @typescript-eslint/typedef */
+//#region imports
+//#region @websql
+var taon_typeorm_1 = require("taon-typeorm");
+var taon_typeorm_2 = require("taon-typeorm");
+//#endregion
+//#region @backend
+var express = require("express");
+var expressSession = require("express-session");
+var cors = require("cors");
+var bodyParser = require("body-parser");
+var cookieParser = require("cookie-parser");
+var methodOverride = require("method-override");
+var fileUpload = require("express-fileupload");
+var url_1 = require("url");
+var tnp_core_1 = require("tnp-core");
+//#endregion
+/* */
+/* */
+var models_1 = require("./models");
+var class_helpers_1 = require("./helpers/class-helpers");
+var symbols_1 = require("./symbols");
+var tnp_core_2 = require("tnp-core");
+var di_container_1 = require("./dependency-injection/di-container");
+var taon_helpers_1 = require("./helpers/taon-helpers");
+var ng2_rest_1 = require("ng2-rest");
+var json10_1 = require("json10");
+var tnp_core_3 = require("tnp-core");
+var rxjs_1 = require("rxjs");
+var entity_process_1 = require("./entity-process");
+var get_response_value_1 = require("./get-response-value");
+var axios_1 = require("axios");
+var taon_typeorm_3 = require("taon-typeorm");
+var env_1 = require("./env");
+var realtime_core_1 = require("./realtime/realtime-core");
+var base_subscriber_for_entity_1 = require("./base-classes/base-subscriber-for-entity");
+//#endregion
+var EndpointContext = /** @class */ (function () {
+    //#endregion
+    //#endregion
+    //#region constructor
+    function EndpointContext(originalConfig, configFn) {
+        var _this = this;
+        this.originalConfig = originalConfig;
+        this.configFn = configFn;
+        //#endregion
+        //#region fields
+        //#region fields / flags
+        this.disabledRealtime = false;
+        /**
+         * check whether context is inited
+         * (with init() function )
+         */
+        this.inited = false;
+        //#endregion
+        this.localInstaceObjSymbol = Symbol('localInstaceObjSymbol');
+        //#region fields / all instances of classes from context
+        /**
+         * all instances of classes from context
+         * key is class name
+         */
+        this.allClassesInstances = {};
+        //#endregion
+        //#region fields / class instances by name
+        this.classInstancesByNameObj = {};
+        //#endregion
+        //#region fields / obj with classes instances arr
+        this.objWithClassesInstancesArr = {};
+        //#endregion
+        //#region fields / active routes
+        this.activeRoutes = [];
+        //#endregion
+        //#region fields / types from contexts
+        this.injectableTypesfromContexts = [
+            models_1.Models.ClassType.CONTROLLER,
+            models_1.Models.ClassType.PROVIDER,
+            models_1.Models.ClassType.REPOSITORY,
+            models_1.Models.ClassType.SUBSCRIBER,
+        ];
+        //#endregion
+        this.allTypesfromContexts = tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(this.injectableTypesfromContexts), false), [
+            models_1.Models.ClassType.ENTITY,
+        ], false);
+        //#region fields / express app
+        this.expressApp = {};
+        //#endregion
+        //#region fields / entities triggers
+        this.entitiesTriggers = {};
+        //#endregion
+        //#region methods & getters / clone class
+        // eslint-disable-next-line @typescript-eslint/typedef
+        this.cloneClassWithNewMetadata = function (_a) {
+            var BaseClass = _a.BaseClass, className = _a.className, config = _a.config, ctx = _a.ctx, classType = _a.classType;
+            // Return a new class that extends the base class
+            var cloneClass = function () {
+                var _a, _b, _c, _d, _e, _f;
+                if (BaseClass[symbols_1.Symbols.fullClassNameStaticProperty] ===
+                    "".concat(ctx.contextName, ".").concat(className)) {
+                    return BaseClass;
+                }
+                return _f = /** @class */ (function (_super) {
+                        tslib_1.__extends(class_1, _super);
+                        function class_1() {
+                            var _this = _super.apply(this, tslib_1.__spreadArray([], tslib_1.__read(arguments), false)) || this;
+                            _this[_e] = ctx;
+                            return _this;
+                            // You can override prototype properties or methods here if needed
+                            // static properties override allowed
+                        }
+                        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type, @typescript-eslint/typedef
+                        class_1.__getFullPathForClass__ = function (arr) {
+                            if (arr === void 0) { arr = []; }
+                            var name = this[symbols_1.Symbols.fullClassNameStaticProperty];
+                            arr.push(name);
+                            // @ts-ignore
+                            if (this[symbols_1.Symbols.orignalClass] && // @ts-ignore
+                                this[symbols_1.Symbols.orignalClass].__getFullPathForClass__) {
+                                // @ts-ignore
+                                this[symbols_1.Symbols.orignalClass].__getFullPathForClass__(arr);
+                            }
+                            return arr.join('/');
+                        };
+                        Object.defineProperty(class_1, "fullPathForClass", {
+                            get: function () {
+                                return this.__getFullPathForClass__();
+                            },
+                            enumerable: false,
+                            configurable: true
+                        });
+                        return class_1;
+                    }(BaseClass)),
+                    _a = symbols_1.Symbols.orignalClass,
+                    _b = symbols_1.Symbols.fullClassNameStaticProperty,
+                    _c = symbols_1.Symbols.classNameStaticProperty,
+                    _d = symbols_1.Symbols.ctxInClassOrClassObj,
+                    _e = symbols_1.Symbols.ctxInClassOrClassObj,
+                    // static ['_'] = BaseClass['_'];
+                    // eslint-disable-next-line @typescript-eslint/typedef
+                    // @ts-ignore
+                    _f[_a] = BaseClass,
+                    // eslint-disable-next-line @typescript-eslint/typedef
+                    // @ts-ignore
+                    _f[_b] = "".concat(ctx.contextName, ".").concat(className),
+                    // eslint-disable-next-line @typescript-eslint/typedef
+                    // @ts-ignore
+                    _f[_c] = className,
+                    // eslint-disable-next-line @typescript-eslint/typedef
+                    _f[_d] = ctx,
+                    _f;
+            };
+            var cloneClassFunction = cloneClass();
+            //#region gather all instances for all contexts
+            // TODO this is not needed anymore - for typeorm I use normal entities
+            // this thinng belowe is nice for debugging purpose
+            // if (_.isUndefined(cloneClassFunction[Symbols.orignalClassClonesObj])) {
+            //   cloneClassFunction[Symbols.orignalClassClonesObj] = {};
+            // }
+            // if (_.isUndefined(BaseClass[Symbols.orignalClassClonesObj])) {
+            //   BaseClass[Symbols.orignalClassClonesObj] = {};
+            // }
+            // const all = {
+            //   ...BaseClass[Symbols.orignalClassClonesObj],
+            //   ...cloneClassFunction[Symbols.orignalClassClonesObj],
+            // };
+            // all[ctx.contextName] = cloneClassFunction;
+            // cloneClassFunction[Symbols.orignalClassClonesObj] = all;
+            // BaseClass[Symbols.orignalClassClonesObj] = all;
+            //#endregion
+            return cloneClassFunction;
+        };
+        //#endregion
+        //#region methods & getters / clone classes obj with new metadata
+        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+        this.cloneClassesObjWithNewMetadata = function (_a) {
+            var e_1, _b;
+            var classesInput = _a.classesInput, config = _a.config, ctx = _a.ctx, classType = _a.classType;
+            var classes = {};
+            try {
+                // console.log(Object.keys(classesInput))
+                for (var _c = tslib_1.__values(Object.keys(classesInput || {})), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var key = _d.value;
+                    var BaseClass_1 = classesInput[key];
+                    if (!BaseClass_1) {
+                        tnp_core_2.Helpers.error("Class ".concat(key, " is not defined in context ").concat(ctx.contextName, "\n\n        Please check if you have correct import in context file\n\n        "));
+                    }
+                    var className = Reflect.getMetadata(symbols_1.Symbols.metadata.className, BaseClass_1);
+                    // console.log('Metadata className', className, BaseClass);
+                    // if (!className) {
+                    //   console.warn(`Please provide className for ${BaseClass.name} class`);
+                    // }
+                    className = className || key;
+                    BaseClass_1[symbols_1.Symbols.classNameStaticProperty] = className;
+                    var clonedClass = _this.cloneClassWithNewMetadata({
+                        BaseClass: BaseClass_1,
+                        className: className,
+                        config: config,
+                        ctx: ctx,
+                        classType: classType,
+                    });
+                    classes[className] = clonedClass;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return classes;
+        };
+    }
+    //#region static
+    /* */
+    /* */
+    EndpointContext.initNgZone = function (ngZone) {
+        /* */
+        /* */
+    };
+    EndpointContext.findForTraget = function (classFnOrObject) {
+        var obj = class_helpers_1.ClassHelpers.getClassFnFromObject(classFnOrObject) || {};
+        return (classFnOrObject[symbols_1.Symbols.ctxInClassOrClassObj] ||
+            obj[symbols_1.Symbols.ctxInClassOrClassObj]);
+    };
+    Object.defineProperty(EndpointContext.prototype, "realtimeClient", {
+        get: function () {
+            return this.realtime.client;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EndpointContext.prototype, "realtimeServer", {
+        get: function () {
+            return this.realtime.server;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EndpointContext.prototype, "logHttp", {
+        //#endregion
+        //#region fields / logs
+        get: function () {
+            var _a, _b;
+            if (tnp_core_2._.isObject((_a = this.config) === null || _a === void 0 ? void 0 : _a.logs)) {
+                return !!this.config.logs.http;
+            }
+            return ((_b = this.config) === null || _b === void 0 ? void 0 : _b.logs) === true;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EndpointContext.prototype, "logRealtime", {
+        get: function () {
+            var _a, _b;
+            if (tnp_core_2._.isObject((_a = this.config) === null || _a === void 0 ? void 0 : _a.logs)) {
+                return !!this.config.logs.realtime;
+            }
+            return ((_b = this.config) === null || _b === void 0 ? void 0 : _b.logs) === true;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EndpointContext.prototype, "logFramework", {
+        get: function () {
+            var _a, _b;
+            if (tnp_core_2._.isObject((_a = this.config) === null || _a === void 0 ? void 0 : _a.logs)) {
+                return !!this.config.logs.framework;
+            }
+            return ((_b = this.config) === null || _b === void 0 ? void 0 : _b.logs) === true;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EndpointContext.prototype, "logDb", {
+        get: function () {
+            var _a, _b;
+            if (tnp_core_2._.isObject((_a = this.config) === null || _a === void 0 ? void 0 : _a.logs)) {
+                return !!this.config.logs.db;
+            }
+            return ((_b = this.config) === null || _b === void 0 ? void 0 : _b.logs) === true;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region methods & getters / init
+    EndpointContext.prototype.init = function (options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var initFromRecrusiveContextResovle, oneHour, _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, classTypeName, _o, _p, classTypeName, e_2_1;
+            var e_3, _q, e_2, _r;
+            var _this = this;
+            var _s, _t;
+            return tslib_1.__generator(this, function (_u) {
+                switch (_u.label) {
+                    case 0:
+                        initFromRecrusiveContextResovle = (options || {}).initFromRecrusiveContextResovle;
+                        this.inited = true;
+                        this.config = this.configFn(env_1.ENV);
+                        // console.log(
+                        //   `[${
+                        //     this.contextName
+                        //   }] init context... from resolve: ${!!initFromRecrusiveContextResovle}`,
+                        // );
+                        //#region debug config
+                        // console.log(
+                        //   `[taon][${this.config.contextName}] - resolve config from fn`,
+                        //   {
+                        //     config: this.config,
+                        //   },
+                        // );
+                        // for (const ctrlName of Object.keys(config.controllers || {})) {
+                        //   console.log(`${ctrlName} = ${!!config.controllers[ctrlName]}`);
+                        // }
+                        // for (const entityName of Object.keys(config.entities || {})) {
+                        //   console.log(`${entityName} = ${!!config.entities[entityName]}`);
+                        // }
+                        // for (const providersName of Object.keys(config.providers || {})) {
+                        //   console.log(`${providersName} = ${!!config.providers[providersName]}`);
+                        // }
+                        // for (const repositoryName of Object.keys(config.repositories || {})) {
+                        //   console.log(
+                        //     `${repositoryName} = ${!!config.repositories[repositoryName]}`,
+                        //   );
+                        // }
+                        //#endregion
+                        //#region resolve mode
+                        if (this.config.host) {
+                            this.mode = 'backend-frontend(tcp+udp)';
+                            /* */
+                            /* */
+                        }
+                        if (this.config.remoteHost) {
+                            if (this.config.host) {
+                                tnp_core_2.Helpers.error("[taon] You can't have remoteHost and host at the same time", false, true);
+                            }
+                            this.mode = 'remote-backend(tcp+udp)';
+                        }
+                        if (this.config.useIpcWhenElectron && tnp_core_2.Helpers.isElectron) {
+                            this.mode = 'backend-frontend(ipc-electron)';
+                        }
+                        if (!this.mode && !this.config.abstract) {
+                            tnp_core_2.Helpers.error("[taon] Context \"".concat(this.contextName, "\": You need to provide host or remoteHost or useIpcWhenElectron"), false, true);
+                            //#region @backend
+                            process.exit(1);
+                            //#endregion
+                        }
+                        //#endregion
+                        //#region resolve database config
+                        if (this.config.database === true) {
+                            this.databaseConfig = this.getAutoGeneratedConfig();
+                        }
+                        else if (tnp_core_2._.isObject(this.config.database)) {
+                            this.databaseConfig = tnp_core_2._.cloneDeep(this.config.database);
+                        }
+                        //#endregion
+                        //#region resolve session
+                        if (this.config.session) {
+                            this.session = tnp_core_2._.cloneDeep(this.config.session);
+                            oneHour = 1000 * 60 * 60 * 1;
+                            if (!this.session.cookieMaxAge) {
+                                this.session.cookieMaxAge = oneHour;
+                            }
+                            // serever and browser cookie authentication
+                            axios_1.default.defaults.withCredentials = true;
+                        }
+                        //#endregion
+                        //#region prepare & gather all classes recrusively
+                        this.config.contexts = this.config.contexts || {};
+                        this.config.entities = this.config.entities || {};
+                        this.config.controllers = this.config.controllers || {};
+                        this.config.repositories = this.config.repositories || {};
+                        this.config.providers = this.config.providers || {};
+                        this.config.subscribers = this.config.subscribers || {};
+                        _a = this.config;
+                        _b = [{}];
+                        return [4 /*yield*/, this.getRecrusiveClassesfromContextsObj(models_1.Models.ClassType.ENTITY)];
+                    case 1:
+                        _a.entities = tslib_1.__assign.apply(void 0, [tslib_1.__assign.apply(void 0, _b.concat([(_u.sent())])), this.config.entities]);
+                        _c = this.config;
+                        _d = [{}];
+                        return [4 /*yield*/, this.getRecrusiveClassesfromContextsObj(models_1.Models.ClassType.CONTROLLER)];
+                    case 2:
+                        _c.controllers = tslib_1.__assign.apply(void 0, [tslib_1.__assign.apply(void 0, _d.concat([(_u.sent())])), this.config.controllers]);
+                        _e = this.config;
+                        _f = [{}];
+                        return [4 /*yield*/, this.getRecrusiveClassesfromContextsObj(models_1.Models.ClassType.PROVIDER)];
+                    case 3:
+                        _e.providers = tslib_1.__assign.apply(void 0, [tslib_1.__assign.apply(void 0, _f.concat([(_u.sent())])), this.config.providers]);
+                        _g = this.config;
+                        _h = [{}];
+                        return [4 /*yield*/, this.getRecrusiveClassesfromContextsObj(models_1.Models.ClassType.SUBSCRIBER)];
+                    case 4:
+                        _g.subscribers = tslib_1.__assign.apply(void 0, [tslib_1.__assign.apply(void 0, _h.concat([(_u.sent())])), this.config.subscribers]);
+                        _j = this.config;
+                        _k = [{}];
+                        return [4 /*yield*/, this.getRecrusiveClassesfromContextsObj(models_1.Models.ClassType.REPOSITORY)];
+                    case 5:
+                        _j.repositories = tslib_1.__assign.apply(void 0, [tslib_1.__assign.apply(void 0, _k.concat([(_u.sent())])), this.config.repositories]);
+                        // console.log(this.config);
+                        // debugger;
+                        //#endregion
+                        //#region prepare classes instances/funcitons clones
+                        this.config.controllers = this.cloneClassesObjWithNewMetadata({
+                            classesInput: this.config.controllers,
+                            config: this.config,
+                            ctx: this,
+                            classType: models_1.Models.ClassType.CONTROLLER,
+                        });
+                        this.config.repositories = this.cloneClassesObjWithNewMetadata({
+                            classesInput: this.config.repositories,
+                            config: this.config,
+                            ctx: this,
+                            classType: models_1.Models.ClassType.REPOSITORY,
+                        });
+                        this.config.providers = this.cloneClassesObjWithNewMetadata({
+                            classesInput: this.config.providers,
+                            config: this.config,
+                            ctx: this,
+                            classType: models_1.Models.ClassType.PROVIDER,
+                        });
+                        this.config.subscribers = this.cloneClassesObjWithNewMetadata({
+                            classesInput: this.config.subscribers,
+                            config: this.config,
+                            ctx: this,
+                            classType: models_1.Models.ClassType.SUBSCRIBER,
+                        });
+                        try {
+                            //#endregion
+                            //#region prepare instances
+                            for (_l = tslib_1.__values(this.injectableTypesfromContexts), _m = _l.next(); !_m.done; _m = _l.next()) {
+                                classTypeName = _m.value;
+                                this.classInstancesByNameObj[classTypeName] = {};
+                                this.objWithClassesInstancesArr[classTypeName] = [];
+                            }
+                        }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (_m && !_m.done && (_q = _l.return)) _q.call(_l);
+                            }
+                            finally { if (e_3) throw e_3.error; }
+                        }
+                        _u.label = 6;
+                    case 6:
+                        _u.trys.push([6, 11, 12, 13]);
+                        _o = tslib_1.__values(this.injectableTypesfromContexts), _p = _o.next();
+                        _u.label = 7;
+                    case 7:
+                        if (!!_p.done) return [3 /*break*/, 10];
+                        classTypeName = _p.value;
+                        return [4 /*yield*/, this.createInstances(this.config[models_1.Models.ClassTypeKey[classTypeName]], classTypeName)];
+                    case 8:
+                        _u.sent();
+                        _u.label = 9;
+                    case 9:
+                        _p = _o.next();
+                        return [3 /*break*/, 7];
+                    case 10: return [3 /*break*/, 13];
+                    case 11:
+                        e_2_1 = _u.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 13];
+                    case 12:
+                        try {
+                            if (_p && !_p.done && (_r = _o.return)) _r.call(_o);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 13:
+                        //#endregion
+                        //#region prepares server
+                        if (this.mode === 'backend-frontend(tcp+udp)' && !this.config.abstract) {
+                            //#region @backend
+                            this.expressApp = express();
+                            this.initMidleware();
+                            this.serverTcpUdp = this.isHttpServer
+                                ? new tnp_core_1.https.Server({
+                                    key: (_s = this.config.https) === null || _s === void 0 ? void 0 : _s.key,
+                                    cert: (_t = this.config.https) === null || _t === void 0 ? void 0 : _t.cert,
+                                }, this.expressApp)
+                                : new tnp_core_1.http.Server(this.expressApp);
+                            this.publicAssets.forEach(function (asset) {
+                                _this.expressApp.use(asset.serverPath, express.static(asset.locationOnDisk));
+                            });
+                            //#endregion
+                        }
+                        //#endregion
+                        //#region prepare relatime
+                        if (!this.config.abstract) {
+                            this.disabledRealtime = !!this.config.disabledRealtime;
+                            //#region @backend
+                            if (tnp_core_2.Helpers.isRunningIn.cliMode()) {
+                                // TODO for now...
+                                this.disabledRealtime = true;
+                            }
+                            //#endregion
+                            this.realtime = new realtime_core_1.RealtimeCore(this);
+                        }
+                        //#endregion
+                        //#region show context info
+                        // console.log({ ref })
+                        if (this.config.abstract) {
+                            this.logFramework &&
+                                tnp_core_2.Helpers.info("[taon] Create abstract context: ".concat(this.config.contextName));
+                        }
+                        else {
+                            if (this.config.remoteHost) {
+                                this.logFramework &&
+                                    tnp_core_2.Helpers.info("[taon] Create context for remote host: ".concat(this.config.remoteHost));
+                            }
+                            else {
+                                this.logFramework &&
+                                    tnp_core_2.Helpers.info("[taon] Create context for host: ".concat(this.config.host));
+                            }
+                        }
+                        //#endregion
+                        // update first exposed config
+                        Object.keys(this.config).forEach(function (key) {
+                            _this.originalConfig[key] = _this.config[key];
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / get auto generated config
+    EndpointContext.prototype.getAutoGeneratedConfig = function () {
+        //#region @websqlFunc
+        var databaseConfig;
+        if (tnp_core_2.Helpers.isRunningInDocker()) {
+            tnp_core_2.Helpers.info('Running in docker, using in mysql database');
+            // TODO auto resolve database config in docker
+            databaseConfig = {
+                database: "tmp-db-".concat(tnp_core_2._.kebabCase(this.contextName), ".sqljs.db"),
+                type: 'mysql',
+                autoSave: true,
+                synchronize: true,
+                dropSchema: true,
+                logging: this.logDb,
+                databasePort: 3306,
+                databaseHost: 'localhost',
+                databaseUsername: 'root',
+                databasePassword: 'admin',
+            };
+        }
+        else {
+            this.logFramework &&
+                tnp_core_2.Helpers.info("[taon][database] Automatically resolving database config for mode ".concat(this.mode));
+            switch (this.mode) {
+                //#region resolve database config for mode backend-frontend(tcp+udp)
+                case 'backend-frontend(ipc-electron)':
+                    return {
+                        location: "tmp-db-".concat(tnp_core_2._.kebabCase(this.contextName), ".sqljs"),
+                        type: 'sqljs',
+                        autoSave: true,
+                        synchronize: true,
+                        dropSchema: true,
+                        logging: this.logDb,
+                    };
+                    break;
+                //#endregion
+                //#region  resolve database config for mode backend-frontend(websql)
+                case 'backend-frontend(websql)':
+                    databaseConfig = {
+                        location: "tmp-db-".concat(tnp_core_2._.kebabCase(this.contextName), ".sqljs"),
+                        type: 'sqljs',
+                        useLocalForage: true, // !!window['localforage'], // TODO this need to be checked in runtime
+                        autoSave: true,
+                        synchronize: true,
+                        dropSchema: true,
+                        logging: this.logDb,
+                    };
+                    var keepWebsqlDbDataAfterReload = false;
+                    /* */
+                    /* */
+                    /* */
+                    if (keepWebsqlDbDataAfterReload) {
+                        databaseConfig.dropSchema = false;
+                        delete databaseConfig.synchronize; // false is not auto synchonize - from what I understand
+                    }
+                    else {
+                        databaseConfig.dropSchema = true;
+                        databaseConfig.synchronize = true;
+                    }
+                    break;
+                //#endregion
+                //#region resolve database config for mode backend-frontend(tcp+udp)
+                case 'backend-frontend(tcp+udp)':
+                    databaseConfig = {
+                        database: "context-db-".concat(tnp_core_2._.kebabCase(this.contextName)),
+                        location: "tmp-db-".concat(tnp_core_2._.kebabCase(this.contextName), ".sqlite"),
+                        type: 'sqljs',
+                        autoSave: true,
+                        synchronize: true,
+                        dropSchema: true,
+                        logging: this.logDb,
+                    };
+                    break;
+                //#endregion
+            }
+        }
+        return databaseConfig;
+        //#endregion
+    };
+    Object.defineProperty(EndpointContext.prototype, "ngZone", {
+        //#endregion
+        //#region methods & getters / ng zone
+        get: function () {
+            /* */
+            /* */
+            return;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region methods & getters / start server
+    EndpointContext.prototype.startServer = function () {
+        var _this = this;
+        //#region @backendFunc
+        if (this.mode === 'backend-frontend(tcp+udp)') {
+            // this.displayRoutes(this.expressApp);
+            this.serverTcpUdp.listen(Number(this.uri.port), function () {
+                tnp_core_2.Helpers.log("[taon][express-server]listening on port: ".concat(_this.uri.port, ", hostname: ").concat(_this.uri.pathname, ",\n            address: ").concat(_this.uri.protocol, "//localhost:").concat(_this.uri.port).concat(_this.uri.pathname, "\n            env: ").concat(_this.expressApp.settings.env, "\n            "));
+            });
+        }
+        else {
+            this.logFramework &&
+                tnp_core_2.Helpers.info('Ipc communication enable instead tcp/upd');
+        }
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / display express routes
+    EndpointContext.prototype.displayRoutes = function (app) {
+        var _a;
+        //#region @backend
+        var routes = [];
+        (_a = app._router) === null || _a === void 0 ? void 0 : _a.stack.forEach(function (middleware) {
+            if (middleware.route) {
+                // routes registered directly on the app
+                var methods = [];
+                for (var method in middleware.route.methods) {
+                    if (middleware.route.methods[method]) {
+                        methods.push(method.toUpperCase());
+                    }
+                }
+                routes.push({ path: middleware.route.path, methods: methods });
+            }
+            else if (middleware.name === 'router') {
+                // router middleware
+                middleware.handle.stack.forEach(function (handler) {
+                    var methods = [];
+                    for (var method in handler.route.methods) {
+                        if (handler.route.methods[method]) {
+                            methods.push(method.toUpperCase());
+                        }
+                    }
+                    routes.push({ path: handler.route.path, methods: methods });
+                });
+            }
+        });
+        console.log(routes);
+        //#endregion
+    };
+    Object.defineProperty(EndpointContext.prototype, "modeAllowsDatabaseCreation", {
+        //#endregion
+        //#region methods & getters / mode allows database creation
+        get: function () {
+            return (this.mode === 'backend-frontend(tcp+udp)' ||
+                this.mode === 'backend-frontend(websql)' ||
+                this.mode === 'backend-frontend(ipc-electron)');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region methods & getters / get recrusive classes from contexts
+    EndpointContext.prototype.getRecrusiveClassesfromContextsObj = function (classType) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var arr;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getRecrusiveClassesfromContexts(classType)];
+                    case 1:
+                        arr = _a.sent();
+                        return [2 /*return*/, arr.reduce(function (acc, c) {
+                                acc[class_helpers_1.ClassHelpers.getName(c)] = c;
+                                return acc;
+                            }, {})];
+                }
+            });
+        });
+    };
+    EndpointContext.prototype.getRecrusiveClassesfromContexts = function (classType_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function (classType, arr) {
+            var contexts, contexts_1, contexts_1_1, ctx, ref, classesInput, clonedClasses, e_4_1;
+            var e_4, _a;
+            if (arr === void 0) { arr = []; }
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        contexts = Object.values(this.config.contexts || {});
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 7, 8, 9]);
+                        contexts_1 = tslib_1.__values(contexts), contexts_1_1 = contexts_1.next();
+                        _b.label = 2;
+                    case 2:
+                        if (!!contexts_1_1.done) return [3 /*break*/, 6];
+                        ctx = contexts_1_1.value;
+                        return [4 /*yield*/, ctx.__ref()];
+                    case 3:
+                        ref = _b.sent();
+                        classesInput = ref.getClassFunBy(classType);
+                        clonedClasses = Object.values(this.cloneClassesObjWithNewMetadata({
+                            classesInput: classesInput,
+                            config: this.config,
+                            ctx: this,
+                            classType: classType,
+                        }));
+                        // console.log(`${classType} clonedClasses`, clonedClasses);
+                        clonedClasses.forEach(function (c) { return arr.push(c); });
+                        return [4 /*yield*/, ref.getRecrusiveClassesfromContexts(classType, arr)];
+                    case 4:
+                        _b.sent();
+                        _b.label = 5;
+                    case 5:
+                        contexts_1_1 = contexts_1.next();
+                        return [3 /*break*/, 2];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_4_1 = _b.sent();
+                        e_4 = { error: e_4_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (contexts_1_1 && !contexts_1_1.done && (_a = contexts_1.return)) _a.call(contexts_1);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/, arr];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / get class instances by class type
+    EndpointContext.prototype.getClassInstanceObjBy = function (classType) {
+        return this.classInstancesByNameObj[classType];
+    };
+    //#endregion
+    //#region methods & getters / get class instaces arr
+    EndpointContext.prototype.getClassesInstancesArrBy = function (classType) {
+        return this.objWithClassesInstancesArr[classType];
+    };
+    //#endregion
+    //#region methods & getters / inject
+    EndpointContext.prototype.inject = function (ctor, options) {
+        var _a;
+        if (!options) {
+            options = {};
+        }
+        var className = class_helpers_1.ClassHelpers.getName(ctor);
+        var locaInstanceConstructorArgs = options.locaInstanceConstructorArgs || [];
+        if (this.isCLassType(models_1.Models.ClassType.REPOSITORY, ctor)) {
+            options.localInstance = true;
+        }
+        if (options === null || options === void 0 ? void 0 : options.localInstance) {
+            var ctxClassFn = this.getClassFunByClassName(className);
+            var entityName = '';
+            if (className === 'BaseRepository') {
+                var entityFn = locaInstanceConstructorArgs[0];
+                var entity = entityFn && entityFn();
+                entityName = entity && class_helpers_1.ClassHelpers.getName(entity);
+            }
+            if (!options.contextClassInstance[this.localInstaceObjSymbol]) {
+                options.contextClassInstance[this.localInstaceObjSymbol] = {};
+            }
+            var instanceKey = className + (entityName ? ".".concat(entityName) : '');
+            var existed = options.contextClassInstance[this.localInstaceObjSymbol][instanceKey];
+            if (existed) {
+                // console.log(`exited `, existed)
+                return existed;
+            }
+            if (!ctxClassFn) {
+                throw new Error("Not able to inject \"".concat(className, "\" inside context \"").concat(this.contextName, "\"\n\n        Make sure they share the same context or import context where \"").concat(className, "\" is defined.\n\n        "));
+            }
+            var injectedInstance = new ((_a = ctxClassFn).bind.apply(_a, tslib_1.__spreadArray([void 0], tslib_1.__read(locaInstanceConstructorArgs), false)))();
+            options.contextClassInstance[this.localInstaceObjSymbol][instanceKey] =
+                injectedInstance;
+            // console.log(`injectedInstance `, existed)
+            return injectedInstance;
+        }
+        var contextScopeInstance = this.allClassesInstances[className];
+        // if (className === 'TopicController') {
+        //   debugger;
+        // }
+        return contextScopeInstance;
+    };
+    /**
+     * alias for inject
+     */
+    EndpointContext.prototype.getInstanceBy = function (ctor) {
+        return this.inject(ctor, { localInstance: false });
+    };
+    //#endregion
+    EndpointContext.prototype.checkIfContextInitialized = function () {
+        if (tnp_core_2._.isUndefined(this.config)) {
+            throw new Error("Please check if your context has been initilized.\n\n      // ...\n      await Context.initialize();\n      // ...\n\n\n      ");
+        }
+    };
+    //#region methods & getters / get class function by class type name
+    EndpointContext.prototype.getClassFunBy = function (classType) {
+        this.checkIfContextInitialized();
+        switch (classType) {
+            case models_1.Models.ClassType.CONTROLLER:
+                return this.config.controllers;
+            case models_1.Models.ClassType.ENTITY:
+                return this.config.entities;
+            case models_1.Models.ClassType.PROVIDER:
+                return this.config.providers;
+            case models_1.Models.ClassType.REPOSITORY:
+                return this.config.repositories;
+            case models_1.Models.ClassType.SUBSCRIBER:
+                return this.config.subscribers;
+        }
+    };
+    EndpointContext.prototype.isCLassType = function (classType, classFn) {
+        return !!this.getClassFunBy(classType)[class_helpers_1.ClassHelpers.getName(classFn)];
+    };
+    /**
+     * Only for injectable types
+     * Only for classType: CONTROLLER, REPOSITORY, PROVIDER
+     */
+    EndpointContext.prototype.getClassFunByClassName = function (className) {
+        var e_5, _a;
+        try {
+            for (var _b = tslib_1.__values(this.allTypesfromContexts), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var classTypeName = _c.value;
+                var classesForInjectableType = this.config[models_1.Models.ClassTypeKey[classTypeName]];
+                if (classesForInjectableType[className]) {
+                    return classesForInjectableType[className];
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    };
+    EndpointContext.prototype.getClassFunByClass = function (classFunction) {
+        var className = class_helpers_1.ClassHelpers.getName(classFunction);
+        return this.getClassFunByClassName(className);
+    };
+    EndpointContext.prototype.getClassFunByArr = function (classType) {
+        return Object.values(this.getClassFunBy(classType) || {});
+    };
+    //#endregion
+    //#region methods & getters / create class instances
+    EndpointContext.prototype.createInstances = function (classes, classType) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, classFn, instance, classInstancesByNameObj, className;
+            var e_6, _c;
+            return tslib_1.__generator(this, function (_d) {
+                try {
+                    // const recrusiveValuesFromContext =
+                    //   await this.getRecrusiveClassesfromContexts(classType);
+                    // console.log(this.config.contexts);
+                    // console.log('recrusiveValuesFromContext', recrusiveValuesFromContext);
+                    for (_a = tslib_1.__values(tslib_1.__spreadArray([], tslib_1.__read(Object.values(classes)), false)), _b = _a.next(); !_b.done; _b = _a.next()) {
+                        classFn = _b.value;
+                        instance = di_container_1.DITaonContainer.resolve(classFn);
+                        classInstancesByNameObj = this.classInstancesByNameObj[classType];
+                        className = class_helpers_1.ClassHelpers.getName(classFn);
+                        // console.log({ classFn, classType, instance, place, className, 'classInstancesByNameObj': this.classInstancesByNameObj });
+                        classInstancesByNameObj[className] = instance;
+                        // update config
+                        this.config[models_1.Models.ClassTypeKey[classType]][className] = classFn;
+                        this.objWithClassesInstancesArr[classType].push(instance);
+                        this.allClassesInstances[className] = instance;
+                    }
+                }
+                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                finally {
+                    try {
+                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                    }
+                    finally { if (e_6) throw e_6.error; }
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / reinit controllers db example data
+    EndpointContext.prototype.reinitControllers = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var controllers, controllers_1, controllers_1_1, ctrl, e_7_1;
+            var e_7, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        controllers = this.getClassesInstancesArrBy(models_1.Models.ClassType.CONTROLLER);
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 6, 7, 8]);
+                        controllers_1 = tslib_1.__values(controllers), controllers_1_1 = controllers_1.next();
+                        _b.label = 2;
+                    case 2:
+                        if (!!controllers_1_1.done) return [3 /*break*/, 5];
+                        ctrl = controllers_1_1.value;
+                        if (!tnp_core_2._.isFunction(ctrl.initExampleDbData)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, tnp_core_2.Helpers.runSyncOrAsync({
+                                functionFn: ctrl.initExampleDbData,
+                                context: ctrl,
+                            })];
+                    case 3:
+                        _b.sent();
+                        _b.label = 4;
+                    case 4:
+                        controllers_1_1 = controllers_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_7_1 = _b.sent();
+                        e_7 = { error: e_7_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (controllers_1_1 && !controllers_1_1.done && (_a = controllers_1.return)) _a.call(controllers_1);
+                        }
+                        finally { if (e_7) throw e_7.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EndpointContext.prototype.initClasses = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, classTypeName, _c, _d, classFun, e_8_1, e_9_1, _e, _f, classTypeName, _g, _h, ctrl, e_10_1, e_11_1;
+            var e_9, _j, e_8, _k, e_11, _l, e_10, _m;
+            return tslib_1.__generator(this, function (_o) {
+                switch (_o.label) {
+                    case 0:
+                        _o.trys.push([0, 11, 12, 13]);
+                        _a = tslib_1.__values([
+                            models_1.Models.ClassType.PROVIDER,
+                            models_1.Models.ClassType.REPOSITORY,
+                            models_1.Models.ClassType.CONTROLLER,
+                            models_1.Models.ClassType.ENTITY,
+                        ]), _b = _a.next();
+                        _o.label = 1;
+                    case 1:
+                        if (!!_b.done) return [3 /*break*/, 10];
+                        classTypeName = _b.value;
+                        _o.label = 2;
+                    case 2:
+                        _o.trys.push([2, 7, 8, 9]);
+                        _c = (e_8 = void 0, tslib_1.__values(this.getClassFunByArr(classTypeName))), _d = _c.next();
+                        _o.label = 3;
+                    case 3:
+                        if (!!_d.done) return [3 /*break*/, 6];
+                        classFun = _d.value;
+                        if (!tnp_core_2._.isFunction(classFun._)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, tnp_core_2.Helpers.runSyncOrAsync({
+                                functionFn: classFun._,
+                                context: classFun,
+                            })];
+                    case 4:
+                        _o.sent();
+                        _o.label = 5;
+                    case 5:
+                        _d = _c.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_8_1 = _o.sent();
+                        e_8 = { error: e_8_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_d && !_d.done && (_k = _c.return)) _k.call(_c);
+                        }
+                        finally { if (e_8) throw e_8.error; }
+                        return [7 /*endfinally*/];
+                    case 9:
+                        _b = _a.next();
+                        return [3 /*break*/, 1];
+                    case 10: return [3 /*break*/, 13];
+                    case 11:
+                        e_9_1 = _o.sent();
+                        e_9 = { error: e_9_1 };
+                        return [3 /*break*/, 13];
+                    case 12:
+                        try {
+                            if (_b && !_b.done && (_j = _a.return)) _j.call(_a);
+                        }
+                        finally { if (e_9) throw e_9.error; }
+                        return [7 /*endfinally*/];
+                    case 13:
+                        _o.trys.push([13, 24, 25, 26]);
+                        _e = tslib_1.__values([
+                            models_1.Models.ClassType.PROVIDER,
+                            models_1.Models.ClassType.REPOSITORY,
+                            models_1.Models.ClassType.CONTROLLER,
+                        ]), _f = _e.next();
+                        _o.label = 14;
+                    case 14:
+                        if (!!_f.done) return [3 /*break*/, 23];
+                        classTypeName = _f.value;
+                        _o.label = 15;
+                    case 15:
+                        _o.trys.push([15, 20, 21, 22]);
+                        _g = (e_10 = void 0, tslib_1.__values(this.getClassesInstancesArrBy(classTypeName))), _h = _g.next();
+                        _o.label = 16;
+                    case 16:
+                        if (!!_h.done) return [3 /*break*/, 19];
+                        ctrl = _h.value;
+                        if (!tnp_core_2._.isFunction(ctrl._)) return [3 /*break*/, 18];
+                        return [4 /*yield*/, tnp_core_2.Helpers.runSyncOrAsync({
+                                functionFn: ctrl._,
+                                context: ctrl,
+                            })];
+                    case 17:
+                        _o.sent();
+                        _o.label = 18;
+                    case 18:
+                        _h = _g.next();
+                        return [3 /*break*/, 16];
+                    case 19: return [3 /*break*/, 22];
+                    case 20:
+                        e_10_1 = _o.sent();
+                        e_10 = { error: e_10_1 };
+                        return [3 /*break*/, 22];
+                    case 21:
+                        try {
+                            if (_h && !_h.done && (_m = _g.return)) _m.call(_g);
+                        }
+                        finally { if (e_10) throw e_10.error; }
+                        return [7 /*endfinally*/];
+                    case 22:
+                        _f = _e.next();
+                        return [3 /*break*/, 14];
+                    case 23: return [3 /*break*/, 26];
+                    case 24:
+                        e_11_1 = _o.sent();
+                        e_11 = { error: e_11_1 };
+                        return [3 /*break*/, 26];
+                    case 25:
+                        try {
+                            if (_f && !_f.done && (_l = _e.return)) _l.call(_e);
+                        }
+                        finally { if (e_11) throw e_11.error; }
+                        return [7 /*endfinally*/];
+                    case 26: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / is active on
+    EndpointContext.prototype.isActiveOn = function (classInstance) {
+        var contextRef = classInstance[symbols_1.Symbols.ctxInClassOrClassObj];
+        return this === contextRef;
+    };
+    Object.defineProperty(EndpointContext.prototype, "uri", {
+        //#endregion
+        //#region methods & getters / uri
+        get: function () {
+            var url = this.host
+                ? new url_1.URL(this.host)
+                : this.remoteHost
+                    ? new url_1.URL(this.remoteHost)
+                    : void 0;
+            return url;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EndpointContext.prototype, "isHttpServer", {
+        //#endregion
+        //#region methods & getters / is https server
+        get: function () {
+            return this.uri.protocol === 'https:';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EndpointContext.prototype, "contextName", {
+        //#endregion
+        //#region methods & getters / public assets
+        /**
+         * ipc/udp needs this
+         */
+        get: function () {
+            return this.config.contextName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EndpointContext.prototype, "publicAssets", {
+        //#endregion
+        //#region methods & getters / public assets
+        get: function () {
+            var _a;
+            return ((_a = this.config) === null || _a === void 0 ? void 0 : _a.publicAssets) || [];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EndpointContext.prototype, "isProductionMode", {
+        //#endregion
+        //#region methods & getters / is production mode
+        get: function () {
+            return this.config.productionMode;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EndpointContext.prototype, "remoteHost", {
+        //#endregion
+        //#region methods & getters / remote host
+        get: function () {
+            return this.config.remoteHost;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EndpointContext.prototype, "host", {
+        //#endregion
+        //#region methods & getters / host
+        get: function () {
+            return this.config.host;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EndpointContext.prototype, "orgin", {
+        //#endregion
+        //#region methods & getters / host
+        get: function () {
+            var _a;
+            return (_a = this.uri) === null || _a === void 0 ? void 0 : _a.origin;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region methods & getters / init subscribers
+    EndpointContext.prototype.initSubscribers = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var subscribers, subscribers_1, subscribers_1_1, subscriber, options, entities, index;
+            var e_12, _a;
+            var _b;
+            return tslib_1.__generator(this, function (_c) {
+                return [2 /*return*/]; // TODO
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / init entities
+    EndpointContext.prototype.initEntities = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var entities, entities_1, entities_1_1, entity, options, createTable, nameForEntity;
+            var e_13, _a;
+            return tslib_1.__generator(this, function (_b) {
+                entities = this.getClassFunByArr(models_1.Models.ClassType.ENTITY);
+                try {
+                    for (entities_1 = tslib_1.__values(entities), entities_1_1 = entities_1.next(); !entities_1_1.done; entities_1_1 = entities_1.next()) {
+                        entity = entities_1_1.value;
+                        options = Reflect.getMetadata(symbols_1.Symbols.metadata.options.entity, entity);
+                        createTable = tnp_core_2._.isUndefined(options.createTable)
+                            ? true
+                            : options.createTable;
+                        nameForEntity = class_helpers_1.ClassHelpers.getName(entity);
+                        if (tnp_core_2._.isUndefined(options.createTable) ? true : options.createTable) {
+                            this.logDb &&
+                                console.info("[taon][typeorm] create table for entity \"".concat(nameForEntity, "\" ? '").concat(createTable, "'"));
+                            // console.log('TypeormEntity', { TypeormEntity });
+                            (0, taon_typeorm_2.Entity)(nameForEntity)(entity);
+                        }
+                        else {
+                            this.logDb &&
+                                console.info("[taon][typeorm] create table for entity \"".concat(nameForEntity, "\" ? '").concat(createTable, "'"));
+                        }
+                    }
+                }
+                catch (e_13_1) { e_13 = { error: e_13_1 }; }
+                finally {
+                    try {
+                        if (entities_1_1 && !entities_1_1.done && (_a = entities_1.return)) _a.call(entities_1);
+                    }
+                    finally { if (e_13) throw e_13.error; }
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / init connection
+    EndpointContext.prototype.initDatabaseConnection = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var entities, subscribers, dataSourceDbConfig, connection, error_1;
+            var _a, _b, _c, _d;
+            return tslib_1.__generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        entities = (((_a = this.config.override) === null || _a === void 0 ? void 0 : _a.entities)
+                            ? this.config.override.entities
+                            : this.getClassFunByArr(models_1.Models.ClassType.ENTITY)).map(function (entityFn) {
+                            return class_helpers_1.ClassHelpers.getOrginalClass(entityFn);
+                        });
+                        subscribers = (((_b = this.config.override) === null || _b === void 0 ? void 0 : _b.subscribers)
+                            ? this.config.override.subscribers
+                            : this.getClassFunByArr(models_1.Models.ClassType.SUBSCRIBER)).filter(function (f) { return f instanceof base_subscriber_for_entity_1.BaseSubscriberForEntity; });
+                        dataSourceDbConfig = tnp_core_2._.isObject(this.databaseConfig)
+                            ? {
+                                type: this.databaseConfig.type,
+                                port: this.databaseConfig.databasePort,
+                                host: this.databaseConfig.databaseHost,
+                                database: this.databaseConfig.database,
+                                username: this.databaseConfig.databaseUsername,
+                                password: this.databaseConfig.databasePassword,
+                                useLocalForage: this.databaseConfig.useLocalForage,
+                                entities: entities,
+                                subscribers: subscribers,
+                                synchronize: this.databaseConfig.synchronize,
+                                autoSave: this.databaseConfig.autoSave,
+                                dropSchema: this.databaseConfig.dropSchema,
+                                logging: !!this.databaseConfig.logging,
+                                location: this.databaseConfig.location,
+                            }
+                            : {};
+                        if (!(this.modeAllowsDatabaseCreation && this.databaseConfig)) return [3 /*break*/, 5];
+                        this.logDb &&
+                            this.logFramework &&
+                            tnp_core_2.Helpers.info('[taon][database] prepare typeorm connection...');
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([1, 3, , 4]);
+                        connection = new taon_typeorm_3.DataSource(dataSourceDbConfig);
+                        this.connection = connection;
+                        return [4 /*yield*/, this.connection.initialize()];
+                    case 2:
+                        _e.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _e.sent();
+                        console.error((error_1 === null || error_1 === void 0 ? void 0 : error_1.message) || error_1);
+                        return [3 /*break*/, 4];
+                    case 4:
+                        if (!((_c = this.connection) === null || _c === void 0 ? void 0 : _c.isInitialized)) {
+                            console.log('WRONG CONFIG', dataSourceDbConfig);
+                            throw new Error("Something wrong with connection init in ".concat(this.mode));
+                            //#region @backend
+                            process.exit(1);
+                            //#endregion
+                        }
+                        (this.logDb || this.logFramework) &&
+                            console.info("\n\n        CONTECTION OK for ".concat(this.contextName, " - ").concat(this.mode, "\n\n        [taon][typeorm] db prepration done.. db initialize=").concat((_d = this.connection) === null || _d === void 0 ? void 0 : _d.isInitialized, "\n\n\n        "), dataSourceDbConfig);
+                        return [3 /*break*/, 6];
+                    case 5:
+                        tnp_core_2.Helpers.info("[taon][typeorm] Not initing db for mode ".concat(this.mode));
+                        _e.label = 6;
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / initialize metadata
+    EndpointContext.prototype.initMetadata = function () {
+        var e_14, _a;
+        var _this = this;
+        var allControllers = this.getClassFunByArr(models_1.Models.ClassType.CONTROLLER);
+        var _loop_1 = function (controllerClassFn) {
+            controllerClassFn[symbols_1.Symbols.classMethodsNames] =
+                class_helpers_1.ClassHelpers.getMethodsNames(controllerClassFn);
+            var configs = class_helpers_1.ClassHelpers.getControllerConfigs(controllerClassFn);
+            // console.log(`Class config for ${ClassHelpers.getName(controllerClassFn)}`, configs)
+            var classConfig = configs[0];
+            var parentscalculatedPath = tnp_core_2._.slice(configs, 1)
+                .reverse()
+                .map(function (bc) {
+                if (taon_helpers_1.TaonHelpers.isGoodPath(bc.path)) {
+                    return bc.path;
+                }
+                return bc.className;
+            })
+                .join('/');
+            if (taon_helpers_1.TaonHelpers.isGoodPath(classConfig.path)) {
+                classConfig.calculatedPath = classConfig.path;
+            }
+            else {
+                classConfig.calculatedPath =
+                    "".concat(parentscalculatedPath, "/").concat(class_helpers_1.ClassHelpers.getName(controllerClassFn))
+                        .replace(/\/\//g, '/')
+                        .split('/')
+                        .reduce(function (acc, bc) {
+                        return tnp_core_2._.last(acc) === bc ? acc : tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(acc), false), [bc], false);
+                    }, [])
+                        .join('/');
+            }
+            tnp_core_2._.slice(configs, 1).forEach(function (bc) {
+                var alreadyIs = classConfig.methods;
+                var toMerge = tnp_core_2._.cloneDeep(bc.methods);
+                for (var key in toMerge) {
+                    if (toMerge.hasOwnProperty(key) && !alreadyIs[key]) {
+                        var element = toMerge[key];
+                        alreadyIs[key] = element;
+                    }
+                }
+            });
+            //#region @backend
+            if (!tnp_core_2.Helpers.isRunningIn.cliMode()) {
+                //#endregion
+                this_1.logHttp &&
+                    console.groupCollapsed("[taon][express-server] routes [".concat(classConfig.className, "]"));
+                //#region @backend
+            }
+            //#endregion
+            // console.log('methods', classConfig.methods);
+            Object.keys(classConfig.methods).forEach(function (methodName) {
+                var _a;
+                var methodConfig = classConfig.methods[methodName];
+                // debugger
+                var type = methodConfig.type;
+                var expressPath = methodConfig.global
+                    ? "/".concat((_a = methodConfig.path) === null || _a === void 0 ? void 0 : _a.replace(/\//, ''))
+                    : taon_helpers_1.TaonHelpers.getExpressPath(classConfig, methodConfig);
+                // console.log({ expressPath })
+                if (tnp_core_2.Helpers.isNode || tnp_core_2.Helpers.isWebSQL) {
+                    //#region @websql
+                    var _b = _this.initServer(type, methodConfig, classConfig, expressPath, controllerClassFn), routePath = _b.routePath, method = _b.method;
+                    _this.activeRoutes.push({
+                        routePath: routePath,
+                        method: method,
+                    });
+                    //#endregion
+                }
+                var shouldInitClient = tnp_core_2.Helpers.isBrowser || _this.remoteHost || tnp_core_2.Helpers.isWebSQL;
+                // console.log('shouldInitClient', shouldInitClient);
+                if (shouldInitClient) {
+                    // console.log(
+                    //   'initClient',
+                    //   ClassHelpers.getFullInternalName(controllerClassFn),
+                    //   type,
+                    //   methodConfig,
+                    //   expressPath,
+                    // );
+                    _this.initClient(controllerClassFn, type, methodConfig, expressPath);
+                }
+            });
+            //#region @backend
+            if (!tnp_core_2.Helpers.isRunningIn.cliMode()) {
+                //#endregion
+                this_1.logHttp && console.groupEnd();
+                //#region @backend
+            }
+        };
+        var this_1 = this;
+        try {
+            // console.log('allControllers', allControllers)11
+            for (var allControllers_1 = tslib_1.__values(allControllers), allControllers_1_1 = allControllers_1.next(); !allControllers_1_1.done; allControllers_1_1 = allControllers_1.next()) {
+                var controllerClassFn = allControllers_1_1.value;
+                _loop_1(controllerClassFn);
+            }
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (allControllers_1_1 && !allControllers_1_1.done && (_a = allControllers_1.return)) _a.call(allControllers_1);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
+    };
+    //#endregion
+    //#region methods & getters / write active routes
+    EndpointContext.prototype.writeActiveRoutes = function () {
+        var _this = this;
+        var contexts = [this];
+        //#region @websql
+        var troutes = this.activeRoutes.map(function (_a) {
+            var method = _a.method, routePath = _a.routePath;
+            return (taon_helpers_1.TaonHelpers.fillUpTo(method.toUpperCase() + ':', 10) +
+                _this.uri.href.replace(/\/$/, '') +
+                routePath);
+            // return `${TaonHelpers.string(method.toUpperCase() + ':')
+            // .fillUpTo(10)}${context.uri.href.replace(/\/$/, '')}${routePath}`
+        });
+        var routes = tslib_1.__spreadArray(tslib_1.__spreadArray([], ['', "---------- FOR HOST ".concat(this.uri.href, " ----------")], false), tslib_1.__read(troutes), false);
+        var fileName = tnp_core_3.path.join(
+        //#region @backend
+        process.cwd(), 
+        //#endregion
+        "tmp-routes-".concat(tnp_core_2._.kebabCase(this.config.contextName), ".json"));
+        this.logFramework && console.log("[taon] routes file: ".concat(fileName, " "));
+        // Helpers.log(JSON.stringify(routes, null, 4))
+        //#region @backend
+        tnp_core_1.fse.writeJSONSync(fileName, routes, {
+            spaces: 2,
+            encoding: 'utf8',
+        });
+        //#endregion
+        //#endregion
+    };
+    Object.defineProperty(EndpointContext.prototype, "middlewares", {
+        //#endregion
+        //#region methods & getters / middlewares
+        get: function () {
+            //#region @backendFunc
+            return this.config.middlewares || [];
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region methods & getters / init midleware
+    EndpointContext.prototype.initMidleware = function () {
+        var _this = this;
+        //#region @backend
+        var app = this.expressApp;
+        if (this.middlewares) {
+            this.middlewares.forEach(function (m) {
+                var _a = tslib_1.__read(m, 2), fun = _a[0], args = _a[1];
+                app.use(fun.apply(null, args));
+            });
+        }
+        this.expressApp.get('/helloworld', function (req, res) {
+            res.send("Hello, world from context ".concat(_this.contextName));
+        });
+        app.use(fileUpload());
+        app.use(bodyParser.urlencoded({ extended: true }));
+        app.use(bodyParser.json());
+        app.use(methodOverride());
+        app.use(cookieParser());
+        if (this.session) {
+            tnp_core_2.Helpers.info('[taon][express-server] session enabled for this context ' +
+                this.contextName);
+            var cookieMaxAge = this.session.cookieMaxAge;
+            var frontendHost = this.config.frontendHost;
+            var sessionObj = {
+                frontendHost: frontendHost,
+                secret: 'mysecretsessioncookithing',
+                saveUninitialized: true,
+                cookieMaxAge: cookieMaxAge,
+                secure: frontendHost.startsWith('https://'),
+                resave: false,
+            };
+            app.use(cors({
+                credentials: true,
+                origin: frontendHost,
+            }));
+            app.use(expressSession(sessionObj));
+            console.log("\n\n      CORS ENABLED FOR SESSION\n\n      ");
+        }
+        else {
+            // if(this.config?.serverLogs) {
+            this.logHttp &&
+                tnp_core_2.Helpers.info("[taon][express-server] session not enabled for this context '".concat(this.contextName, "'"));
+            // }
+            app.use(cors({
+            // origin: "http://localhost:5555",
+            // methods: ["GET", "POST"],
+            // allowedHeaders: ["my-custom-header"],
+            // credentials: true
+            }));
+            this.logHttp &&
+                console.log("\n\n      CORS ENABLED WITHOUT SESSION\n\n      ");
+        }
+        (function () {
+            app.use(function (req, res, next) {
+                //#region good for cors session obj
+                // if (this.context.session) {
+                //   res.header('Access-Control-Allow-Origin', this.context.session.frontendHost);
+                //   res.header('Access-Control-Allow-Credentials', 'true');
+                //   res.header(
+                //     'Access-Control-Allow-Headers',
+                //     'Origin, X-Requested-With, Content-Type, Accept'
+                //   );
+                //   res.header("Access-Control-Allow-Methods", "PUT,POST,GET,HEAD,DELETE,OPTIONS,PATCH");
+                // // maybe this
+                // res.header("Access-Control-Allow-Headers", "Content-Type,Content-Length, Authorization, Accept,X-Requested-With");
+                // }
+                //#endregion
+                res.set('Access-Control-Expose-Headers', [
+                    'Content-Type',
+                    'Authorization',
+                    'X-Requested-With',
+                    symbols_1.Symbols.old.X_TOTAL_COUNT,
+                    symbols_1.Symbols.old.MAPPING_CONFIG_HEADER,
+                    symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_BODY,
+                    symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM,
+                ].join(', '));
+                next();
+            });
+        })();
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / init methods node
+    EndpointContext.prototype.initServer = function (
+    //#region parameters
+    type, methodConfig, classConfig, expressPath, target) {
+        var _this = this;
+        //#region resolve variables
+        //#region @websql
+        var requestHandler = methodConfig.requestHandler &&
+            typeof methodConfig.requestHandler === 'function'
+            ? methodConfig.requestHandler
+            : function (req, res, next) {
+                next();
+            };
+        //#endregion
+        var url = this.uri;
+        //#region get result
+        var getResult = function (resolvedParams, req, res) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var response, result;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = methodConfig.descriptor.value.apply(
+                        /**
+                         * Context for method @GET,@PUT etc.
+                         */
+                        this.getInstanceBy(target), 
+                        /**
+                         * Params for metjod @GET, @PUT etc.
+                         */
+                        resolvedParams);
+                        return [4 /*yield*/, (0, get_response_value_1.getResponseValue)(response, { req: req, res: res })];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        }); };
+        //#endregion
+        url.pathname = url.pathname.replace(/\/$/, '');
+        expressPath = url.pathname.startsWith('/')
+            ? "".concat(url.pathname).concat(expressPath)
+            : expressPath;
+        expressPath = expressPath.replace(/\/\//g, '/');
+        // console.log(`BACKEND: expressPath: ${ expressPath } `)
+        //#endregion
+        if (tnp_core_2.Helpers.isElectron) {
+            //#region @backend
+            var ipcKeyName = taon_helpers_1.TaonHelpers.ipcKeyNameRequest(target, methodConfig, expressPath);
+            tnp_core_2.Helpers.ipcMain.on(ipcKeyName, function (event, paramsFromBrowser) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var responseJsonData;
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, getResult(paramsFromBrowser, void 0, void 0)];
+                        case 1:
+                            responseJsonData = _a.sent();
+                            event.sender.send(taon_helpers_1.TaonHelpers.ipcKeyNameResponse(target, methodConfig, expressPath), responseJsonData);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            return {
+                routePath: expressPath,
+                method: methodConfig.type,
+            };
+            //#endregion
+        }
+        if (!this.remoteHost) {
+            //#region apply dummy websql express routers
+            //#region @websql
+            if (tnp_core_2.Helpers.isWebSQL) {
+                if (!this.expressApp[type.toLowerCase()]) {
+                    this.expressApp[type.toLowerCase()] = function () { };
+                }
+            }
+            //#endregion
+            //#endregion
+            //#region @backend
+            this.logHttp && console.log("[".concat(type.toUpperCase(), "] ").concat(expressPath, " "));
+            this.expressApp[type.toLowerCase()](expressPath, requestHandler, function (req, res) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var args, tBody, tParams, tQuery, entity, entity, resolvedParams, result, blob, file, _a, _b, img_base64, m, _c, _1, content_type, file_base64, file, error_2, err, err;
+                return tslib_1.__generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            args = [];
+                            tBody = req.body;
+                            tParams = req.params;
+                            tQuery = req.query;
+                            if (req.headers[symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_BODY]) {
+                                try {
+                                    tBody = JSON.parse(JSON.stringify(tBody), JSON.parse(req.headers[symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_BODY]));
+                                }
+                                catch (e) { }
+                            }
+                            if (req.headers[symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM]) {
+                                try {
+                                    tQuery = JSON.parse(JSON.stringify(tQuery), JSON.parse(req.headers[symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM]));
+                                }
+                                catch (e) { }
+                            }
+                            // make class instance from body
+                            // console.log('req.headers', req.headers)
+                            if (req.headers[symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS]) {
+                                try {
+                                    entity = JSON.parse(req.headers[symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS]);
+                                    tBody = ng2_rest_1.Mapping.encode(tBody, entity);
+                                }
+                                catch (e) { }
+                            }
+                            else {
+                                Object.keys(tBody).forEach(function (paramName) {
+                                    try {
+                                        var entityForParam = JSON.parse(req.headers["".concat(symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS).concat(paramName, " ")]);
+                                        tBody[paramName] = ng2_rest_1.Mapping.encode(tBody[paramName], entityForParam);
+                                    }
+                                    catch (e) { }
+                                });
+                            }
+                            // make class instance from query params
+                            // console.log('req.headers', tQuery)
+                            if (req.headers[symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS]) {
+                                try {
+                                    entity = JSON.parse(req.headers[symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS]);
+                                    tQuery = taon_helpers_1.TaonHelpers.parseJSONwithStringJSONs(ng2_rest_1.Mapping.encode(tQuery, entity));
+                                }
+                                catch (e) { }
+                            }
+                            else {
+                                Object.keys(tQuery).forEach(function (queryParamName) {
+                                    try {
+                                        var entityForParam = JSON.parse(req.headers["".concat(symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS).concat(queryParamName, " ")]);
+                                        var beforeTransofrm = tQuery[queryParamName];
+                                        if (tnp_core_2._.isString(beforeTransofrm)) {
+                                            try {
+                                                var paresed = taon_helpers_1.TaonHelpers.tryTransformParam(beforeTransofrm);
+                                                beforeTransofrm = paresed;
+                                            }
+                                            catch (e) { }
+                                        }
+                                        var afterEncoding = ng2_rest_1.Mapping.encode(beforeTransofrm, entityForParam);
+                                        tQuery[queryParamName] =
+                                            taon_helpers_1.TaonHelpers.parseJSONwithStringJSONs(afterEncoding);
+                                    }
+                                    catch (e) { }
+                                });
+                            }
+                            Object.keys(methodConfig.parameters).forEach(function (paramName) {
+                                var p = methodConfig.parameters[paramName];
+                                if (p.paramType === 'Path' && tParams) {
+                                    args.push(tParams[p.paramName]);
+                                }
+                                if (p.paramType === 'Query' && tQuery) {
+                                    if (p.paramName) {
+                                        args.push(tQuery[p.paramName]);
+                                    }
+                                    else {
+                                        args.push(tQuery);
+                                    }
+                                }
+                                if (p.paramType === 'Header' && req.headers) {
+                                    args.push(req.headers[p.paramName.toLowerCase()]);
+                                }
+                                if (p.paramType === 'Cookie' && req.cookies) {
+                                    args.push(req.cookies[p.paramName]);
+                                }
+                                if (p.paramType === 'Body' && tBody) {
+                                    if (p.paramName && typeof tBody === 'object') {
+                                        args.push(tBody[p.paramName]);
+                                    }
+                                    else {
+                                        args.push(tBody);
+                                    }
+                                }
+                            });
+                            resolvedParams = args
+                                .reverse()
+                                .map(function (v) { return taon_helpers_1.TaonHelpers.tryTransformParam(v); });
+                            _d.label = 1;
+                        case 1:
+                            _d.trys.push([1, 8, , 9]);
+                            return [4 /*yield*/, getResult(resolvedParams, req, res)];
+                        case 2:
+                            result = _d.sent();
+                            if (!(result instanceof Blob &&
+                                methodConfig.responseType ===
+                                    'blob')) return [3 /*break*/, 4];
+                            blob = result;
+                            _b = (_a = Buffer).from;
+                            return [4 /*yield*/, blob.arrayBuffer()];
+                        case 3:
+                            file = _b.apply(_a, [_d.sent()]);
+                            res.writeHead(200, {
+                                'Content-Type': blob.type,
+                                'Content-Length': file.length,
+                            });
+                            res.end(file);
+                            return [3 /*break*/, 7];
+                        case 4:
+                            if (!(tnp_core_2._.isString(result) &&
+                                methodConfig.responseType ===
+                                    'blob')) return [3 /*break*/, 5];
+                            img_base64 = result;
+                            m = /^data:(.+?);base64,(.+)$/.exec(img_base64);
+                            if (!m) {
+                                throw new Error("[taon - framework] Not a base64 image[".concat(img_base64, "]"));
+                            }
+                            _c = tslib_1.__read(m, 3), _1 = _c[0], content_type = _c[1], file_base64 = _c[2];
+                            file = Buffer.from(file_base64, 'base64');
+                            res.writeHead(200, {
+                                'Content-Type': content_type,
+                                'Content-Length': file.length,
+                            });
+                            res.end(file);
+                            return [3 /*break*/, 7];
+                        case 5: 
+                        //#region process json request
+                        return [4 /*yield*/, entity_process_1.EntityProcess.init(result, res)];
+                        case 6:
+                            //#region process json request
+                            _d.sent();
+                            _d.label = 7;
+                        case 7: return [3 /*break*/, 9];
+                        case 8:
+                            error_2 = _d.sent();
+                            //#region process error
+                            if (tnp_core_2._.isString(error_2)) {
+                                res.status(400).send(json10_1.JSON10.stringify({
+                                    message: "\n    Error inside: ".concat(req.path, "\n\n    ").concat(error_2, "\n\n"),
+                                }));
+                            }
+                            else if (error_2 instanceof models_1.Models.Http.Errors) {
+                                tnp_core_2.Helpers.error(error_2, true, false);
+                                err = error_2;
+                                res.status(400).send(json10_1.JSON10.stringify(err));
+                            }
+                            else if (error_2 instanceof Error) {
+                                err = error_2;
+                                tnp_core_2.Helpers.error(error_2, true, false);
+                                res.status(400).send(json10_1.JSON10.stringify({
+                                    stack: err.stack,
+                                    message: err.message,
+                                }));
+                            }
+                            else {
+                                tnp_core_2.Helpers.log(error_2);
+                                tnp_core_2.Helpers.error("[Taon] Bad result isomorphic method: ".concat(error_2, " "), true, false);
+                                res.status(400).send(json10_1.JSON10.stringify(error_2));
+                            }
+                            return [3 /*break*/, 9];
+                        case 9: return [2 /*return*/];
+                    }
+                });
+            }); });
+            //#endregion
+        }
+        return {
+            routePath: expressPath,
+            method: methodConfig.type,
+        };
+    };
+    //#endregion
+    //#region methods & getters / init client
+    /**
+     * client can be browser or nodejs (when remote host)
+     */
+    EndpointContext.prototype.initClient = function (
+    //#region parameters
+    target, type, methodConfig, expressPath) {
+        var ctx = this;
+        // : { received: any; /* Rest<any, any>  */ }
+        this.logHttp && console.log("".concat(type === null || type === void 0 ? void 0 : type.toUpperCase(), " ").concat(expressPath, " "));
+        // console.log('INITING', methodConfig); // @LAST inject in static
+        //#region resolve storage
+        var storage;
+        if (tnp_core_2.Helpers.isBrowser) {
+            storage = window;
+        }
+        //#region @backend
+        if (tnp_core_2.Helpers.isNode) {
+            storage = global;
+        }
+        //#endregion
+        //#endregion
+        var orgMethods = target.prototype[methodConfig.methodName];
+        //#region handle electron ipc request
+        if (tnp_core_2.Helpers.isElectron) {
+            target.prototype[methodConfig.methodName] = function () {
+                var _this = this;
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                var received = new Promise(function (resolve, reject) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    var headers, _a, request, response;
+                    return tslib_1.__generator(this, function (_b) {
+                        headers = {};
+                        _a = taon_helpers_1.TaonHelpers.websqlMocks(headers), request = _a.request, response = _a.response;
+                        tnp_core_2.Helpers.ipcRenderer.once(taon_helpers_1.TaonHelpers.ipcKeyNameResponse(target, methodConfig, expressPath), function (event, responseData) {
+                            var res = responseData;
+                            console.log({ responseData: responseData });
+                            try {
+                                var body_1 = res;
+                                res = new ng2_rest_1.Models.HttpResponse({
+                                    body: void 0,
+                                    isArray: void 0,
+                                    method: methodConfig.type,
+                                    url: "".concat(ctx.uri.origin).concat('' // TODO express path
+                                    ).concat(methodConfig.path, " "),
+                                }, tnp_core_2.Helpers.isBlob(body_1) || tnp_core_2._.isString(body_1)
+                                    ? body_1
+                                    : JSON.stringify(body_1), ng2_rest_1.RestHeaders.from(headers), void 0, function () { return body_1; });
+                                resolve(res);
+                            }
+                            catch (error) {
+                                console.error(error);
+                                reject(error);
+                            }
+                        });
+                        tnp_core_2.Helpers.ipcRenderer.send(taon_helpers_1.TaonHelpers.ipcKeyNameRequest(target, methodConfig, expressPath), args);
+                        return [2 /*return*/];
+                    });
+                }); });
+                received['observable'] = (0, rxjs_1.from)(received);
+                return {
+                    received: received,
+                };
+            };
+            return;
+        }
+        //#endregion
+        //#region handling web sql request
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        //#endregion
+        //#region handl normal request
+        target.prototype[methodConfig.methodName] = function () {
+            // console.log('[init method browser] FRONTEND expressPath', expressPath)
+            // const productionMode = FrameworkContext.isProductionMode;
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            //#region resolve frontend parameters
+            if (!storage[symbols_1.Symbols.old.ENDPOINT_META_CONFIG])
+                storage[symbols_1.Symbols.old.ENDPOINT_META_CONFIG] = {};
+            if (!storage[symbols_1.Symbols.old.ENDPOINT_META_CONFIG][ctx.uri.href])
+                storage[symbols_1.Symbols.old.ENDPOINT_META_CONFIG][ctx.uri.href] = {};
+            var endpoints = storage[symbols_1.Symbols.old.ENDPOINT_META_CONFIG];
+            var rest;
+            if (!endpoints[ctx.uri.href][expressPath]) {
+                var headers = {};
+                if (methodConfig.contentType && !methodConfig.responseType) {
+                    rest = ng2_rest_1.Resource.create(ctx.uri.href, expressPath, symbols_1.Symbols.old.MAPPING_CONFIG_HEADER, symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, ng2_rest_1.RestHeaders.from({
+                        'Content-Type': methodConfig.contentType,
+                        Accept: methodConfig.contentType,
+                    }));
+                }
+                else if (methodConfig.contentType && methodConfig.responseType) {
+                    rest = ng2_rest_1.Resource.create(ctx.uri.href, expressPath, symbols_1.Symbols.old.MAPPING_CONFIG_HEADER, symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, ng2_rest_1.RestHeaders.from({
+                        'Content-Type': methodConfig.contentType,
+                        Accept: methodConfig.contentType,
+                        responsetypeaxios: methodConfig.responseType,
+                    }));
+                }
+                else if (!methodConfig.contentType && methodConfig.responseType) {
+                    rest = ng2_rest_1.Resource.create(ctx.uri.href, expressPath, symbols_1.Symbols.old.MAPPING_CONFIG_HEADER, symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, ng2_rest_1.RestHeaders.from({
+                        responsetypeaxios: methodConfig.responseType,
+                    }));
+                }
+                else {
+                    rest = ng2_rest_1.Resource.create(ctx.uri.href, expressPath, symbols_1.Symbols.old.MAPPING_CONFIG_HEADER, symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_BODY);
+                }
+                endpoints[ctx.uri.href][expressPath] = rest;
+            }
+            else {
+                rest = endpoints[ctx.uri.href][expressPath];
+            }
+            var method = type.toLowerCase();
+            var isWithBody = method === 'put' || method === 'post';
+            var pathPrams = {};
+            var queryParams = {};
+            var bodyObject = {};
+            args.forEach(function (param, i) {
+                var currentParam = void 0;
+                for (var pp in methodConfig.parameters) {
+                    var v = methodConfig.parameters[pp];
+                    if (v.index === i) {
+                        currentParam = v;
+                        break;
+                    }
+                }
+                if (currentParam.paramType === 'Path') {
+                    pathPrams[currentParam.paramName] = param;
+                }
+                if (currentParam.paramType === 'Query') {
+                    if (currentParam.paramName) {
+                        var mapping = ng2_rest_1.Mapping.decode(param, !ctx.isProductionMode);
+                        if (mapping) {
+                            rest.headers.set("".concat(symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS).concat(currentParam.paramName, " "), JSON.stringify(mapping));
+                        }
+                        queryParams[currentParam.paramName] = param;
+                    }
+                    else {
+                        var mapping = ng2_rest_1.Mapping.decode(param, !ctx.isProductionMode);
+                        if (mapping) {
+                            rest.headers.set(symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS, JSON.stringify(mapping));
+                        }
+                        queryParams = tnp_core_2._.cloneDeep(param);
+                    }
+                }
+                if (currentParam.paramType === 'Header') {
+                    if (currentParam.paramName) {
+                        if (currentParam.paramName === symbols_1.Symbols.old.MDC_KEY) {
+                            // parese MDC
+                            rest.headers.set(currentParam.paramName, encodeURIComponent(JSON.stringify(param)));
+                        }
+                        else {
+                            rest.headers.set(currentParam.paramName, param);
+                        }
+                    }
+                    else {
+                        for (var header in param) {
+                            rest.headers.set(header, param[header]);
+                        }
+                    }
+                }
+                if (currentParam.paramType === 'Cookie') {
+                    ng2_rest_1.Resource.Cookies.write(currentParam.paramName, param, currentParam.expireInSeconds);
+                }
+                if (currentParam.paramType === 'Body') {
+                    if (currentParam.paramName) {
+                        if (class_helpers_1.ClassHelpers.getName(bodyObject) === 'FormData') {
+                            throw new Error("[taon - framework] Don use param names when posting / putting FormData.\n              Use this:\n// ...\n(@Taon.Http.Param.Body() formData: FormData) ...\n// ...\n\ninstead\n  // ...\n  (@Taon.Http.Param.Body('".concat(currentParam.paramName, "') formData: FormData) ...\n// ...\n"));
+                        }
+                        var mapping = ng2_rest_1.Mapping.decode(param, !ctx.isProductionMode);
+                        if (mapping) {
+                            rest.headers.set("".concat(symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS).concat(currentParam.paramName, " "), JSON.stringify(mapping));
+                        }
+                        bodyObject[currentParam.paramName] = param;
+                    }
+                    else {
+                        var mapping = ng2_rest_1.Mapping.decode(param, !ctx.isProductionMode);
+                        if (mapping) {
+                            rest.headers.set(symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS, JSON.stringify(mapping));
+                        }
+                        bodyObject = param;
+                    }
+                }
+            });
+            if (typeof bodyObject === 'object' &&
+                class_helpers_1.ClassHelpers.getName(bodyObject) !== 'FormData') {
+                var circuralFromItem_1 = [];
+                bodyObject = json10_1.JSON10.parse(json10_1.JSON10.stringify(bodyObject, void 0, void 0, function (circs) {
+                    circuralFromItem_1 = circs;
+                }));
+                rest.headers.set(symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, json10_1.JSON10.stringify(circuralFromItem_1));
+            }
+            if (typeof queryParams === 'object') {
+                var circuralFromQueryParams_1 = [];
+                queryParams = json10_1.JSON10.parse(json10_1.JSON10.stringify(queryParams, void 0, void 0, function (circs) {
+                    circuralFromQueryParams_1 = circs;
+                }));
+                rest.headers.set(symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM, json10_1.JSON10.stringify(circuralFromQueryParams_1));
+            }
+            //#endregion
+            var httpResultObj = {
+                received: isWithBody
+                    ? rest.model(pathPrams)[method](bodyObject, [queryParams])
+                    : rest.model(pathPrams)[method]([queryParams]),
+            };
+            return httpResultObj;
+        };
+        //#endregion
+    };
+    return EndpointContext;
+}());
+exports.EndpointContext = EndpointContext;
+//# sourceMappingURL=endpoint-context.js.map