taon 21.0.53 → 21.0.55

package/lib-prod/endpoint-context.js

@@ -1,786 +1,895 @@
-import { URL } from "url";
-import axios from "axios";
-import { ipcMain } from "electron";
-import { JSON10 } from "json10/lib-prod";
-import { walk } from "lodash-walk-object/lib-prod";
-import { Resource, RestHeaders, Mapping__NS__decode, Mapping__NS__encode } from "ng2-rest/lib-prod";
-import { from } from "rxjs";
-import { EventSubscriber } from "taon-typeorm/lib-prod";
-import { Entity as TypeormEntity } from "taon-typeorm/lib-prod";
-import {
-  DataSource
-} from "taon-typeorm/lib-prod";
-import { path, requireDefault } from "tnp-core/lib-prod";
-import { config } from "tnp-core/lib-prod";
-import { CoreModels__NS__TaonHttpErrorCustomProp } from "tnp-core/lib-prod";
-import { fse, http, https } from "tnp-core/lib-prod";
-import { Utils__NS__uniqArray, UtilsOs__NS__getRealHomeDir, UtilsOs__NS__isBrowser, UtilsOs__NS__isElectron, UtilsOs__NS__isNode, UtilsOs__NS__isRunningInCliMode, UtilsOs__NS__isRunningInDocker, UtilsOs__NS__isWebSQL } from "tnp-core/lib-prod";
-import { crossPlatformPath } from "tnp-core/lib-prod";
-import { ___NS__cloneDeep, ___NS__first, ___NS__isBoolean, ___NS__isFunction, ___NS__isNil, ___NS__isObject, ___NS__isString, ___NS__isUndefined, ___NS__last, ___NS__set, ___NS__slice, ___NS__snakeCase, ___NS__startCase, Helpers__NS__error, Helpers__NS__exists, Helpers__NS__info, Helpers__NS__log, Helpers__NS__mkdirp, Helpers__NS__throwError, Helpers__NS__writeFile } from "tnp-core/lib-prod";
-import { apiPrefix } from "./constants";
-import { ContextDbMigrations } from "./context-db-migrations";
-import { DITaonContainer } from "./dependency-injection/di-container";
-import { EntityProcess } from "./entity-process";
-import { getResponseValue } from "./get-response-value";
-import { ClassHelpers__NS__asyncHandler, ClassHelpers__NS__getControllerConfigs, ClassHelpers__NS__getMethodsNames, ClassHelpers__NS__getName, ClassHelpers__NS__getOrginalClass } from "./helpers/class-helpers";
-import { TaonHelpers__NS__fillUpTo, TaonHelpers__NS__firstStringOrElemFromArray, TaonHelpers__NS__getExpressPath, TaonHelpers__NS__ipcKeyNameRequest, TaonHelpers__NS__ipcKeyNameResponse, TaonHelpers__NS__isGoodPath, TaonHelpers__NS__parseJSONwithStringJSONs, TaonHelpers__NS__tryTransformParam, TaonHelpers__NS__websqlMocks } from "./helpers/taon-helpers";
-import { Models__NS__ClassType, Models__NS__ClassTypeKey, Models__NS__DatabaseConfig, Models__NS__DatabasesFolder } from "./models";
-import { RealtimeCore } from "./realtime/realtime-core";
-import { Symbols__NS__classMethodsNames, Symbols__NS__classNameStaticProperty, Symbols__NS__ctxInClassOrClassObj, Symbols__NS__fullClassNameStaticProperty, Symbols__NS__metadata, Symbols__NS__old, Symbols__NS__orignalClass } from "./symbols";
+import { URL } from 'url'; // @backend
+import axios from 'axios';
+import { ipcMain } from 'electron'; // @backend
+import { JSON10 } from 'json10/lib-prod';
+import { walk } from 'lodash-walk-object/lib-prod';
+import { Resource, RestHeaders, Mapping__NS__decode, Mapping__NS__encode } from 'ng2-rest/lib-prod';
+import { from } from 'rxjs';
+import { EventSubscriber } from 'taon-typeorm/lib-prod'; // @websql
+import { Entity as TypeormEntity } from 'taon-typeorm/lib-prod'; // @websql
+import { DataSource, } from 'taon-typeorm/lib-prod';
+import { path, requireDefault } from 'tnp-core/lib-prod';
+import { config } from 'tnp-core/lib-prod';
+import { CoreModels__NS__TaonHttpErrorCustomProp } from 'tnp-core/lib-prod';
+import { fse, http, https } from 'tnp-core/lib-prod'; // @backend
+import { Utils__NS__uniqArray, UtilsOs__NS__getRealHomeDir, UtilsOs__NS__isBrowser, UtilsOs__NS__isElectron, UtilsOs__NS__isNode, UtilsOs__NS__isRunningInCliMode, UtilsOs__NS__isRunningInDocker, UtilsOs__NS__isWebSQL } from 'tnp-core/lib-prod';
+import { crossPlatformPath } from 'tnp-core/lib-prod';
+import { ___NS__cloneDeep, ___NS__first, ___NS__isBoolean, ___NS__isFunction, ___NS__isNil, ___NS__isObject, ___NS__isString, ___NS__isUndefined, ___NS__last, ___NS__set, ___NS__slice, ___NS__snakeCase, ___NS__startCase, Helpers__NS__error, Helpers__NS__exists, Helpers__NS__info, Helpers__NS__log, Helpers__NS__mkdirp, Helpers__NS__throwError, Helpers__NS__writeFile } from 'tnp-core/lib-prod';
+import { apiPrefix } from './constants';
+import { ContextDbMigrations } from './context-db-migrations';
+import { DITaonContainer } from './dependency-injection/di-container';
+import { EntityProcess } from './entity-process';
+import { getResponseValue } from './get-response-value';
+import { ClassHelpers__NS__asyncHandler, ClassHelpers__NS__getControllerConfigs, ClassHelpers__NS__getMethodsNames, ClassHelpers__NS__getName, ClassHelpers__NS__getOrginalClass } from './helpers/class-helpers';
+import { TaonHelpers__NS__fillUpTo, TaonHelpers__NS__firstStringOrElemFromArray, TaonHelpers__NS__getExpressPath, TaonHelpers__NS__ipcKeyNameRequest, TaonHelpers__NS__ipcKeyNameResponse, TaonHelpers__NS__isGoodPath, TaonHelpers__NS__parseJSONwithStringJSONs, TaonHelpers__NS__tryTransformParam, TaonHelpers__NS__websqlMocks } from './helpers/taon-helpers';
+import { Models__NS__ClassType, Models__NS__ClassTypeKey, Models__NS__DatabaseConfig, Models__NS__DatabasesFolder } from './models';
+import { RealtimeCore } from './realtime/realtime-core';
+import { Symbols__NS__classMethodsNames, Symbols__NS__classNameStaticProperty, Symbols__NS__ctxInClassOrClassObj, Symbols__NS__fullClassNameStaticProperty, Symbols__NS__metadata, Symbols__NS__old, Symbols__NS__orignalClass } from './symbols';
+/* */
+//#endregion
 let bodyParser;
 let cookieParser;
 let cors;
 let express;
 let methodOverride;
 let expressSession;
-bodyParser = requireDefault("body-parser");
-cookieParser = requireDefault("cookie-parser");
-cors = requireDefault("cors");
-express = requireDefault("express");
-methodOverride = requireDefault("method-override");
-expressSession = requireDefault("express-session");
-class EndpointContext {
-  constructor(originalConfig, configFn, cloneOptions) {
-    this.originalConfig = originalConfig;
-    this.configFn = configFn;
-    this.cloneOptions = cloneOptions;
-    this.cloneOptions = this.cloneOptions || {};
-    this.isRunningInsideDocker = UtilsOs__NS__isRunningInDocker();
-  }
-  //#region fields
-  //#region fields / use mariadb mysql in docker
-  /**
-   * JUST FOR TESTING PURPOSES
-   */
-  USE_MARIADB_MYSQL_IN_DOCKER = false;
-  //#endregion
-  //#region fields / flags
-  disabledRealtime = false;
-  /**
-   * check whether context is inited
-   * (with init() function )
-   */
-  inited = false;
-  //#endregion
-  //#region fields / db migrations
-  dbMigrations = new ContextDbMigrations(this);
-  //#endregion
-  //#region fields / local instance obj symbol
-  localInstaceObjSymbol = Symbol("localInstaceObjSymbol");
-  //#endregion
-  //#region fields / all instances of classes from context
-  /**
-   * all instances of classes from context
-   * key is class name
-   */
-  allClassesInstances = {};
-  //#endregion
-  //#region fields / class instances by name
-  classInstancesByNameObj = {};
-  //#endregion
-  //#region fields / obj with classes instances arr
-  objWithClassesInstancesArr = {};
-  //#endregion
-  //#region fields / active routes
-  activeRoutes = [];
-  //#endregion
-  //#region fields / typeorm repositories
-  //#region @websql
-  repos = /* @__PURE__ */ new Map();
-  //#endregion
-  //#endregion
-  //#region fields / source context
-  get sourceContext() {
-    return this.cloneOptions?.sourceContext;
-  }
-  //#endregion
-  //#region fields / skip writing server routes
-  skipWritingServerRoutes = false;
-  //#endregion
-  //#region fields / types from contexts
-  injectableTypesfromContexts = [
-    Models__NS__ClassType.CONTROLLER,
-    Models__NS__ClassType.PROVIDER,
-    Models__NS__ClassType.MIDDLEWARE,
-    Models__NS__ClassType.REPOSITORY,
-    Models__NS__ClassType.SUBSCRIBER,
-    Models__NS__ClassType.MIGRATION
-  ];
-  //#endregion
-  //#region fields / all types from contexts
-  allTypesfromContexts = [
-    ...this.injectableTypesfromContexts,
-    Models__NS__ClassType.ENTITY
-  ];
-  //#endregion
-  //#region fields / express app
-  expressApp = {};
-  //#endregion
-  //#region fields / server tcp udp
-  serverTcpUdp;
-  //#endregion
-  //#region fields / database config
-  databaseConfig;
-  //#endregion
-  //#region fields /  mode
-  mode;
-  //#endregion
-  //#region fields / only migration start
-  onlyMigrationRun = false;
-  onlyMigrationRevertToTimestamp = void 0;
-  get isRunOrRevertOnlyMigrationAppStart() {
-    return !!(this.onlyMigrationRun || this.onlyMigrationRevertToTimestamp);
-  }
-  //#endregion
-  //#region fields  / session
-  session;
-  //#endregion
-  //#region fields / connection
-  connection;
-  //#endregion
-  //#region fields / entities triggers
-  entitiesTriggers = {};
-  //#endregion
-  //#region fields / realtime
-  realtime;
-  get realtimeClient() {
-    return this.realtime.client;
-  }
-  get realtimeServer() {
-    return this.realtime.server;
-  }
-  //#endregion
-  //#region fields / config
-  /**
-   * available after init()
-   */
-  config;
-  //#endregion
-  //#region fields / logs
-  get logHttp() {
-    if (___NS__isObject(this.config?.logs)) {
-      return !!this.config.logs.http;
-    }
-    return this.config?.logs === true;
-  }
-  get logRealtime() {
-    if (___NS__isObject(this.config?.logs)) {
-      return !!this.config.logs.realtime;
-    }
-    return this.config?.logs === true;
-  }
-  get logFramework() {
-    if (___NS__isObject(this.config?.logs)) {
-      return !!this.config.logs.framework;
-    }
-    return this.config?.logs === true;
-  }
-  get logRoutes() {
-    if (___NS__isObject(this.config?.logs)) {
-      return !!this.config.logs.routes;
-    }
-    return this.config?.logs === true;
-  }
-  get logDb() {
-    if (___NS__isObject(this.config?.logs)) {
-      return !!this.config.logs.db;
-    }
-    return this.config?.logs === true;
-  }
-  get logMigrations() {
-    if (___NS__isObject(this.config?.logs)) {
-      return !!this.config.logs.migrations;
-    }
-    return this.config?.logs === true;
-  }
-  //#endregion
-  //#endregion
-  //#region constructor
-  /**
-   * Inside docker there is not need for https secure server
-   */
-  isRunningInsideDocker = false;
-  //#endregion
-  //#region methods & getters / init
-  async init(options) {
-    const {
-      initFromRecrusiveContextResovle,
-      onlyMigrationRun,
-      onlyMigrationRevertToTimestamp
-    } = options || {};
-    this.inited = true;
-    this.onlyMigrationRun = onlyMigrationRun;
-    this.onlyMigrationRevertToTimestamp = onlyMigrationRevertToTimestamp;
-    this.config = this.configFn({});
-    if (___NS__isObject(this.config.database)) {
-      this.config.database = Models__NS__DatabaseConfig.from(
-        this.config.database
-      ).databaseConfigTypeORM;
-    }
-    this.config.host = this.host === null ? void 0 : this.host;
-    if (this.cloneOptions.overrideHost && !this.cloneOptions.useAsRemoteContext) {
-      this.config.host = this.cloneOptions.overrideHost;
-    }
-    if (this.cloneOptions.overrideRemoteHost && this.cloneOptions.useAsRemoteContext) {
-      this.config.host = this.cloneOptions.overrideRemoteHost;
-    }
-    if (this.config.host && !this.config.host.startsWith("http://") && !this.config.host.startsWith("https://")) {
-      Helpers__NS__throwError(
-        `[taon-config] Your${this.host ? " remote" : ""} 'host' must start with http:// or https://`
-      );
-    }
-    if (___NS__isUndefined(this.config.useIpcWhenElectron)) {
-      this.config.useIpcWhenElectron = true;
-    }
-    this.skipWritingServerRoutes = ___NS__isBoolean(
-      this.config.skipWritingServerRoutes
-    ) ? this.config.skipWritingServerRoutes : false;
-    if (this.config.host) {
-      this.mode = "backend-frontend(tcp+udp)";
-    }
-    if (this.isRemoteHost) {
-      this.mode = "remote-backend(tcp+udp)";
-    }
-    if (this.config.useIpcWhenElectron && UtilsOs__NS__isElectron) {
-      if (UtilsOs__NS__isWebSQL) {
-        this.mode = "backend-frontend(websql-electron)";
-      } else {
-        this.mode = "backend-frontend(ipc-electron)";
-      }
-    }
-    if (!this.mode && !this.config.abstract) {
-      const errMsg = `You need to provide host property or useIpcWhenElectron or mark it as abstract`;
-      Helpers__NS__error(
-        `[taon][Context=${this.contextName}]: ${errMsg}`,
-        false,
-        true
-      );
-      process.exit(1);
-    }
-    if (this.config.database === true) {
-      this.logFramework && console.log(`
+//#region @backend
+bodyParser = requireDefault('body-parser');
+cookieParser = requireDefault('cookie-parser');
+cors = requireDefault('cors');
+express = requireDefault('express');
+methodOverride = requireDefault('method-override');
+expressSession = requireDefault('express-session');
+//#endregion
+export class EndpointContext {
+    //#endregion
+    //#endregion
+    //#region fields / source context
+    get sourceContext() {
+        return this.cloneOptions?.sourceContext;
+    }
+    get isRunOrRevertOnlyMigrationAppStart() {
+        return !!(this.onlyMigrationRun || this.onlyMigrationRevertToTimestamp);
+    }
+    get realtimeClient() {
+        return this.realtime.client;
+    }
+    get realtimeServer() {
+        return this.realtime.server;
+    }
+    //#endregion
+    //#region fields / logs
+    get logHttp() {
+        if (___NS__isObject(this.config?.logs)) {
+            return !!this.config.logs.http;
+        }
+        return this.config?.logs === true;
+    }
+    get logRealtime() {
+        if (___NS__isObject(this.config?.logs)) {
+            return !!this.config.logs.realtime;
+        }
+        return this.config?.logs === true;
+    }
+    get logFramework() {
+        if (___NS__isObject(this.config?.logs)) {
+            return !!this.config.logs.framework;
+        }
+        return this.config?.logs === true;
+    }
+    get logRoutes() {
+        if (___NS__isObject(this.config?.logs)) {
+            return !!this.config.logs.routes;
+        }
+        return this.config?.logs === true;
+    }
+    get logDb() {
+        if (___NS__isObject(this.config?.logs)) {
+            return !!this.config.logs.db;
+        }
+        return this.config?.logs === true;
+    }
+    get logMigrations() {
+        if (___NS__isObject(this.config?.logs)) {
+            return !!this.config.logs.migrations;
+        }
+        return this.config?.logs === true;
+    }
+    constructor(originalConfig, configFn, 
+    /**
+     * (@default: false)
+     * If TRUE context is NOT going to create db/express server/http endpoints
+     * PURPOSE OF THIS PROPERTY
+     * -> ONLY remote access from backend or frontend to specific backend
+     */
+    cloneOptions) {
+        this.originalConfig = originalConfig;
+        this.configFn = configFn;
+        this.cloneOptions = cloneOptions;
+        //#region fields
+        //#region fields / use mariadb mysql in docker
+        /**
+         * JUST FOR TESTING PURPOSES
+         */
+        this.USE_MARIADB_MYSQL_IN_DOCKER = false;
+        //#endregion
+        //#region fields / flags
+        this.disabledRealtime = false;
+        /**
+         * check whether context is inited
+         * (with init() function )
+         */
+        this.inited = false;
+        //#endregion
+        //#region fields / db migrations
+        this.dbMigrations = new ContextDbMigrations(this);
+        //#endregion
+        //#region fields / local instance obj symbol
+        this.localInstaceObjSymbol = Symbol('localInstaceObjSymbol');
+        //#endregion
+        //#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 / typeorm repositories
+        //#region @websql
+        this.repos = new Map();
+        //#endregion
+        //#region fields / skip writing server routes
+        this.skipWritingServerRoutes = false;
+        //#endregion
+        //#region fields / types from contexts
+        this.injectableTypesfromContexts = [
+            Models__NS__ClassType.CONTROLLER,
+            Models__NS__ClassType.PROVIDER,
+            Models__NS__ClassType.MIDDLEWARE,
+            Models__NS__ClassType.REPOSITORY,
+            Models__NS__ClassType.SUBSCRIBER,
+            Models__NS__ClassType.MIGRATION,
+        ];
+        //#endregion
+        //#region fields / all types from contexts
+        this.allTypesfromContexts = [
+            ...this.injectableTypesfromContexts,
+            Models__NS__ClassType.ENTITY,
+        ];
+        //#endregion
+        //#region fields / express app
+        this.expressApp = {};
+        //#endregion
+        //#region fields / only migration start
+        this.onlyMigrationRun = false;
+        this.onlyMigrationRevertToTimestamp = undefined;
+        //#endregion
+        //#region fields / entities triggers
+        this.entitiesTriggers = {};
+        //#endregion
+        //#endregion
+        //#region constructor
+        /**
+         * Inside docker there is not need for https secure server
+         */
+        this.isRunningInsideDocker = false;
+        //#endregion
+        //#region methods & getters / clone class
+        this.cloneClassWithNewMetadata = ({ TaonBaseClass, className, config, ctx, classType, }) => {
+            // Return a new class that extends the base class
+            const cloneClass = () => {
+                var _a, _b, _c, _d, _e;
+                if (TaonBaseClass[Symbols__NS__fullClassNameStaticProperty] ===
+                    `${ctx.contextName}.${className}`) {
+                    return TaonBaseClass;
+                }
+                return class extends TaonBaseClass {
+                    constructor() {
+                        // static ['_'] = TaonBaseClass['_'];
+                        super(...arguments);
+                        this[_e] = ctx;
+                        // You can override prototype properties or methods here if needed
+                        // static properties override allowed
+                    }
+                    static { _a = Symbols__NS__orignalClass, _b = Symbols__NS__fullClassNameStaticProperty, _c = Symbols__NS__classNameStaticProperty, _d = Symbols__NS__ctxInClassOrClassObj, _e = Symbols__NS__ctxInClassOrClassObj; }
+                    // @ts-ignore
+                    static { this[_a] = TaonBaseClass; }
+                    // @ts-ignore
+                    static { this[_b] = `${ctx.contextName}.${className}`; }
+                    // @ts-ignore
+                    static { this[_c] = className; }
+                    static { this[_d] = ctx; }
+                    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+                    static __getFullPathForClass__(arr = []) {
+                        const name = this[Symbols__NS__fullClassNameStaticProperty];
+                        arr.push(name);
+                        // @ts-ignore
+                        if (this[Symbols__NS__orignalClass] && // @ts-ignore
+                            this[Symbols__NS__orignalClass].__getFullPathForClass__) {
+                            // @ts-ignore
+                            this[Symbols__NS__orignalClass].__getFullPathForClass__(arr);
+                        }
+                        return arr.join('/');
+                    }
+                    static get fullPathForClass() {
+                        return this.__getFullPathForClass__();
+                    }
+                };
+            };
+            const 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 (___NS__isUndefined(cloneClassFunction[Symbols__NS__orignalClassClonesObj])) {
+            //   cloneClassFunction[Symbols__NS__orignalClassClonesObj] = {};
+            // }
+            // if (___NS__isUndefined(TaonBaseClass[Symbols__NS__orignalClassClonesObj])) {
+            //   TaonBaseClass[Symbols__NS__orignalClassClonesObj] = {};
+            // }
+            // const all = {
+            //   ...TaonBaseClass[Symbols__NS__orignalClassClonesObj],
+            //   ...cloneClassFunction[Symbols__NS__orignalClassClonesObj],
+            // };
+            // all[ctx.contextName] = cloneClassFunction;
+            // cloneClassFunction[Symbols__NS__orignalClassClonesObj] = all;
+            // TaonBaseClass[Symbols__NS__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 = ({ classesInput, config, ctx, classType, }) => {
+            const classes = {};
+            // console.log(Object.keys(classesInput))
+            for (const key of Object.keys(classesInput || {})) {
+                const TaonBaseClass = classesInput[key];
+                if (!TaonBaseClass) {
+                    Helpers__NS__error(`Class ${key} is not defined in context ${ctx.contextName}
+
+        Please check if you have correct import in context file
+
+        `);
+                }
+                var className = Reflect.getMetadata(Symbols__NS__metadata.className, TaonBaseClass);
+                // console.log('Metadata className', className, TaonBaseClass);
+                // if (!className) {
+                //   console.warn(`Please provide className for ${TaonBaseClass.name} class`);
+                // }
+                className = className || key;
+                TaonBaseClass[Symbols__NS__classNameStaticProperty] = className;
+                const clonedClass = this.cloneClassWithNewMetadata({
+                    TaonBaseClass,
+                    className,
+                    config,
+                    ctx,
+                    classType,
+                });
+                classes[className] = clonedClass;
+            }
+            return classes;
+        };
+        this.cloneOptions = this.cloneOptions || {};
+        this.isRunningInsideDocker = UtilsOs__NS__isRunningInDocker();
+    }
+    //#endregion
+    //#region methods & getters / init
+    async init(options) {
+        const { initFromRecrusiveContextResovle, onlyMigrationRun, onlyMigrationRevertToTimestamp, } = options || {}; // TODO use it ?
+        this.inited = true;
+        // @ts-ignore
+        this.onlyMigrationRun = onlyMigrationRun;
+        // @ts-ignore
+        this.onlyMigrationRevertToTimestamp = onlyMigrationRevertToTimestamp;
+        this.config = this.configFn({});
+        if (___NS__isObject(this.config.database)) {
+            this.config.database = Models__NS__DatabaseConfig.from(this.config.database).databaseConfigTypeORM;
+        }
+        this.config.host = this.host === null ? void 0 : this.host;
+        if (this.cloneOptions.overrideHost &&
+            !this.cloneOptions.useAsRemoteContext) {
+            this.config.host = this.cloneOptions.overrideHost;
+        }
+        if (this.cloneOptions.overrideRemoteHost &&
+            this.cloneOptions.useAsRemoteContext) {
+            this.config.host = this.cloneOptions.overrideRemoteHost;
+        }
+        if (this.config.host &&
+            !this.config.host.startsWith('http://') &&
+            !this.config.host.startsWith('https://')) {
+            Helpers__NS__throwError(`[taon-config] Your${this.host ? ' remote' : ''} 'host' must start with http:// or https://`);
+        }
+        if (___NS__isUndefined(this.config.useIpcWhenElectron)) {
+            this.config.useIpcWhenElectron = true;
+        }
+        // console.log(`config for ${this.contextName}`, this.config);
+        //#region resolve if skipping writing server routes
+        //@ts-expect-error overriding readonly
+        this.skipWritingServerRoutes = ___NS__isBoolean(this.config.skipWritingServerRoutes)
+            ? this.config.skipWritingServerRoutes
+            : false;
+        //#endregion
+        //#region resolve mode
+        if (this.config.host) {
+            this.mode = 'backend-frontend(tcp+udp)';
+            /* */
+            /* */
+        }
+        if (this.isRemoteHost) {
+            this.mode = 'remote-backend(tcp+udp)';
+        }
+        // console.log(`
+        //   useIpcWhenElectron: ${this.config.useIpcWhenElectron}
+        //   UtilsOs__NS__isElectron: ${UtilsOs__NS__isElectron}
+        //   `)
+        if (this.config.useIpcWhenElectron && UtilsOs__NS__isElectron) {
+            if (UtilsOs__NS__isWebSQL) {
+                this.mode = 'backend-frontend(websql-electron)';
+            }
+            else {
+                this.mode = 'backend-frontend(ipc-electron)';
+            }
+        }
+        // mode === undefined for TaonBaseContext => ok behavior
+        // console.log(`Mode for BE/FE communication: ${this.mode}`);
+        // if(!this.mode) {
+        //   console.log(this.config)
+        // }
+        if (!this.mode && !this.config.abstract) {
+            const errMsg = `You need to provide host property or ` +
+                `useIpcWhenElectron or mark it as abstract`;
+            Helpers__NS__error(`[taon][Context=${this.contextName}]: ${errMsg}`, false, true);
+            //#region @backend
+            process.exit(1);
+            //#endregion
+        }
+        //#endregion
+        //#region resolve database config
+        if (this.config.database === true) {
+            this.logFramework &&
+                console.log(`
 
         ASSIGNING AUTO GENERATED DATABASE CONFIG
 
         `);
-      this.databaseConfig = this.getAutoGeneratedConfig();
-    } else if (___NS__isObject(this.config.database)) {
-      this.logFramework && console.log(`
+            this.databaseConfig = this.getAutoGeneratedConfig();
+        }
+        else if (___NS__isObject(this.config.database)) {
+            this.logFramework &&
+                console.log(`
 
         OVERRIDE DATABASE CONFIG FROM CONFIGURATION
 
         `);
-      this.databaseConfig = this.getAutoGeneratedConfig();
-      walk.Object(
-        this.config.database,
-        (value, lodashPath) => {
-          if (___NS__isNil(value) || ___NS__isFunction(value) || ___NS__isObject(value)) {
-          } else {
-            this.logFramework && console.info(
-              `Overriding database config: ${lodashPath}=${value}`
-            );
-            ___NS__set(this.databaseConfig, lodashPath, value);
-          }
-        },
-        {
-          walkGetters: false
-        }
-      );
-    }
-    if (this.config.session) {
-      this.session = ___NS__cloneDeep(this.config.session);
-      const oneHour = 1e3 * 60 * 60 * 1;
-      if (!this.session.cookieMaxAge) {
-        this.session.cookieMaxAge = oneHour;
-      }
-      axios.defaults.withCredentials = true;
-    }
-    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 || {};
-    this.config.migrations = this.config.migrations || {};
-    this.config.entities = {
-      ...await this.getRecrusiveClassesfromContextsObj(
-        Models__NS__ClassType.ENTITY
-      ),
-      ...this.config.entities
-    };
-    this.config.controllers = {
-      ...await this.getRecrusiveClassesfromContextsObj(
-        Models__NS__ClassType.CONTROLLER
-      ),
-      ...this.config.controllers
-    };
-    this.config.providers = {
-      ...await this.getRecrusiveClassesfromContextsObj(
-        Models__NS__ClassType.PROVIDER
-      ),
-      ...this.config.providers
-    };
-    this.config.middlewares = {
-      ...await this.getRecrusiveClassesfromContextsObj(
-        Models__NS__ClassType.MIDDLEWARE
-      ),
-      ...this.config.middlewares
-    };
-    this.config.subscribers = {
-      ...await this.getRecrusiveClassesfromContextsObj(
-        Models__NS__ClassType.SUBSCRIBER
-      ),
-      ...this.config.subscribers
-    };
-    this.config.repositories = {
-      ...await this.getRecrusiveClassesfromContextsObj(
-        Models__NS__ClassType.REPOSITORY
-      ),
-      ...this.config.repositories
-    };
-    this.config.migrations = {
-      ...await this.getRecrusiveClassesfromContextsObj(
-        Models__NS__ClassType.MIGRATION
-      ),
-      ...this.config.migrations
-    };
-    this.config.controllers = this.cloneClassesObjWithNewMetadata({
-      classesInput: this.config.controllers,
-      config: this.config,
-      ctx: this,
-      classType: Models__NS__ClassType.CONTROLLER
-    });
-    this.config.repositories = this.cloneClassesObjWithNewMetadata({
-      classesInput: this.config.repositories,
-      config: this.config,
-      ctx: this,
-      classType: Models__NS__ClassType.REPOSITORY
-    });
-    this.config.providers = this.cloneClassesObjWithNewMetadata({
-      classesInput: this.config.providers,
-      config: this.config,
-      ctx: this,
-      classType: Models__NS__ClassType.PROVIDER
-    });
-    this.config.middlewares = this.cloneClassesObjWithNewMetadata({
-      classesInput: this.config.middlewares,
-      config: this.config,
-      ctx: this,
-      classType: Models__NS__ClassType.MIDDLEWARE
-    });
-    this.config.subscribers = this.cloneClassesObjWithNewMetadata({
-      classesInput: this.config.subscribers,
-      config: this.config,
-      ctx: this,
-      classType: Models__NS__ClassType.SUBSCRIBER
-    });
-    this.config.migrations = this.cloneClassesObjWithNewMetadata({
-      classesInput: this.config.migrations,
-      config: this.config,
-      ctx: this,
-      classType: Models__NS__ClassType.MIGRATION
-    });
-    for (const classTypeName of this.injectableTypesfromContexts) {
-      this.classInstancesByNameObj[classTypeName] = {};
-      this.objWithClassesInstancesArr[classTypeName] = [];
-    }
-    for (const classTypeName of this.injectableTypesfromContexts) {
-      await this.createInstances(
-        this.config[Models__NS__ClassTypeKey[classTypeName]],
-        classTypeName
-      );
-    }
-    if (!this.isRunOrRevertOnlyMigrationAppStart) {
-      if (this.mode === "backend-frontend(tcp+udp)" && !this.config.abstract) {
-        this.expressApp = express();
-        if (process.env.NODE_ENV === "production") {
-          this.expressApp.set("trust proxy", 1);
-        }
-        await this.initBackendMiddlewares();
-        await this.initCustomBackendMiddlewares();
-        const shouldStartHttpsSecureServer = this.isHttpServer && !this.isRunningInsideDocker;
-        this.logFramework && Helpers__NS__info(`
+            this.databaseConfig = this.getAutoGeneratedConfig();
+            walk.Object(this.config.database, (value, lodashPath) => {
+                if (___NS__isNil(value) || ___NS__isFunction(value) || ___NS__isObject(value)) {
+                    // skipping
+                }
+                else {
+                    this.logFramework &&
+                        console.info(`Overriding database config: ${lodashPath}=${value}`);
+                    ___NS__set(this.databaseConfig, lodashPath, value);
+                }
+            }, {
+                walkGetters: false,
+            });
+        }
+        //#endregion
+        //#region resolve session
+        if (this.config.session) {
+            this.session = ___NS__cloneDeep(this.config.session);
+            const oneHour = 1000 * 60 * 60 * 1; // 24;
+            if (!this.session.cookieMaxAge) {
+                this.session.cookieMaxAge = oneHour;
+            }
+            // serever and browser cookie authentication
+            axios.defaults.withCredentials = true;
+        }
+        //#endregion
+        //#region prepare & gather all classes recursively
+        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 || {};
+        this.config.migrations = this.config.migrations || {};
+        this.config.entities = {
+            ...(await this.getRecrusiveClassesfromContextsObj(Models__NS__ClassType.ENTITY)),
+            ...this.config.entities,
+        };
+        this.config.controllers = {
+            ...(await this.getRecrusiveClassesfromContextsObj(Models__NS__ClassType.CONTROLLER)),
+            ...this.config.controllers,
+        };
+        this.config.providers = {
+            ...(await this.getRecrusiveClassesfromContextsObj(Models__NS__ClassType.PROVIDER)),
+            ...this.config.providers,
+        };
+        this.config.middlewares = {
+            ...(await this.getRecrusiveClassesfromContextsObj(Models__NS__ClassType.MIDDLEWARE)),
+            ...this.config.middlewares,
+        };
+        this.config.subscribers = {
+            ...(await this.getRecrusiveClassesfromContextsObj(Models__NS__ClassType.SUBSCRIBER)),
+            ...this.config.subscribers,
+        };
+        this.config.repositories = {
+            ...(await this.getRecrusiveClassesfromContextsObj(Models__NS__ClassType.REPOSITORY)),
+            ...this.config.repositories,
+        };
+        this.config.migrations = {
+            ...(await this.getRecrusiveClassesfromContextsObj(Models__NS__ClassType.MIGRATION)),
+            ...this.config.migrations,
+        };
+        // console.log(this.config);
+        // debugger;
+        //#endregion
+        //#region prepare classes instances/functions clones
+        this.config.controllers = this.cloneClassesObjWithNewMetadata({
+            classesInput: this.config.controllers,
+            config: this.config,
+            ctx: this,
+            classType: Models__NS__ClassType.CONTROLLER,
+        });
+        this.config.repositories = this.cloneClassesObjWithNewMetadata({
+            classesInput: this.config.repositories,
+            config: this.config,
+            ctx: this,
+            classType: Models__NS__ClassType.REPOSITORY,
+        });
+        this.config.providers = this.cloneClassesObjWithNewMetadata({
+            classesInput: this.config.providers,
+            config: this.config,
+            ctx: this,
+            classType: Models__NS__ClassType.PROVIDER,
+        });
+        this.config.middlewares = this.cloneClassesObjWithNewMetadata({
+            classesInput: this.config.middlewares,
+            config: this.config,
+            ctx: this,
+            classType: Models__NS__ClassType.MIDDLEWARE,
+        });
+        this.config.subscribers = this.cloneClassesObjWithNewMetadata({
+            classesInput: this.config.subscribers,
+            config: this.config,
+            ctx: this,
+            classType: Models__NS__ClassType.SUBSCRIBER,
+        });
+        this.config.migrations = this.cloneClassesObjWithNewMetadata({
+            classesInput: this.config.migrations,
+            config: this.config,
+            ctx: this,
+            classType: Models__NS__ClassType.MIGRATION,
+        });
+        //#endregion
+        //#region prepare instances
+        for (const classTypeName of this.injectableTypesfromContexts) {
+            this.classInstancesByNameObj[classTypeName] = {};
+            this.objWithClassesInstancesArr[classTypeName] = [];
+        }
+        for (const classTypeName of this.injectableTypesfromContexts) {
+            await this.createInstances(this.config[Models__NS__ClassTypeKey[classTypeName]], classTypeName);
+        }
+        //#endregion
+        if (!this.isRunOrRevertOnlyMigrationAppStart) {
+            //#region prepares server
+            if (this.mode === 'backend-frontend(tcp+udp)' && !this.config.abstract) {
+                //#region @backend
+                this.expressApp = express();
+                if (process.env.NODE_ENV === 'production') {
+                    this.expressApp.set('trust proxy', 1);
+                }
+                await this.initBackendMiddlewares();
+                await this.initCustomBackendMiddlewares();
+                const shouldStartHttpsSecureServer = this.isHttpServer && !this.isRunningInsideDocker;
+                this.logFramework &&
+                    Helpers__NS__info(`
 
-          Starting server ${shouldStartHttpsSecureServer ? "with" : "without"} HTTPS secure server
+          Starting server ${shouldStartHttpsSecureServer ? 'with' : 'without'} HTTPS secure server
 
           `);
-        this.serverTcpUdp = shouldStartHttpsSecureServer ? new https.Server(
-          {
-            key: this.config.https?.key,
-            cert: this.config.https?.cert
-          },
-          this.expressApp
-        ) : new http.Server(this.expressApp);
-        this.publicAssets.forEach((asset) => {
-          this.expressApp.use(
-            asset.serverPath,
-            express.static(asset.locationOnDisk)
-          );
-        });
-        await this.initCustomClientMiddlewares();
-      }
-      if (!this.config.abstract) {
-        this.disabledRealtime = this.config.disabledRealtime;
-        if (!this.host) {
-          throw `
+                this.serverTcpUdp = shouldStartHttpsSecureServer
+                    ? new https.Server({
+                        key: this.config.https?.key,
+                        cert: this.config.https?.cert,
+                    }, this.expressApp)
+                    : new http.Server(this.expressApp);
+                this.publicAssets.forEach(asset => {
+                    this.expressApp.use(asset.serverPath, express.static(asset.locationOnDisk));
+                });
+                //#endregion
+                await this.initCustomClientMiddlewares();
+            }
+            //#endregion
+            //#region prepare realtime
+            if (!this.config.abstract) {
+                this.disabledRealtime = this.config.disabledRealtime;
+                if (!this.host) {
+                    throw `
 
             host is required for context initialization..
             (Or maybe you forgot mark ${this.config.contextName} context as abstract?)
 
           `;
+                }
+                //#region @backend
+                // if (UtilsOs__NS__isRunningInCliMode() && !___NS__isNil(this.config.disabledRealtime)) {
+                //   // TODO for now...
+                //   Helpers__NS__logInfo(`Realtime disable on backend for cli mode`);
+                //   this.disabledRealtime = true;
+                // } else {
+                //   Helpers__NS__logInfo(`Realtime enabled on backend`);
+                // }
+                //#endregion
+                this.logRealtime &&
+                    Helpers__NS__info(`[ctx=${this.contextName}] Init Realtime for ${this.mode}`);
+                this.realtime = new RealtimeCore(this);
+            }
+            //#endregion
         }
-        this.logRealtime && Helpers__NS__info(
-          `[ctx=${this.contextName}] Init Realtime for ${this.mode}`
-        );
-        this.realtime = new RealtimeCore(this);
-      }
-    }
-    if (this.config.abstract) {
-      this.logFramework && Helpers__NS__info(
-        `[taon] Create abstract context: ${this.config.contextName}`
-      );
-    } else {
-      if (this.isRemoteHost) {
-        this.logFramework && Helpers__NS__info(
-          `[taon] Create context for remote host: ${this.config.host}`
-        );
-      } else {
-        this.logFramework && Helpers__NS__info(`[taon] Create context for host: ${this.config.host}`);
-      }
-    }
-    Object.keys(this.config).forEach((key) => {
-      this.originalConfig[key] = this.config[key];
-    });
-  }
-  //#endregion
-  //#region methods & getters / get auto generated config
-  getAutoGeneratedConfig() {
-    this.logFramework && console.log(`
+        //#region show context info
+        // console.log({ ref })
+        if (this.config.abstract) {
+            this.logFramework &&
+                Helpers__NS__info(`[taon] Create abstract context: ${this.config.contextName}`);
+        }
+        else {
+            if (this.isRemoteHost) {
+                this.logFramework &&
+                    Helpers__NS__info(`[taon] Create context for remote host: ${this.config.host}`);
+            }
+            else {
+                this.logFramework &&
+                    Helpers__NS__info(`[taon] Create context for host: ${this.config.host}`);
+            }
+        }
+        //#endregion
+        // update first exposed config
+        Object.keys(this.config).forEach(key => {
+            this.originalConfig[key] = this.config[key];
+        });
+    }
+    //#endregion
+    //#region methods & getters / get auto generated config
+    getAutoGeneratedConfig() {
+        this.logFramework &&
+            console.log(`
 
 
          IS RUNNING IN DOCKER: ${this.isRunningInsideDocker}
 
     `);
-    let databaseConfig = Models__NS__DatabaseConfig.from({});
-    const tcpUdpDatabaseSqliteRelativeFileLocation = `${Models__NS__DatabasesFolder}/db-${this.contextName}.sqlite`;
-    if (this.isRunningInsideDocker) {
-      if (this.USE_MARIADB_MYSQL_IN_DOCKER) {
-      } else {
-        this.logFramework && console.log(`
+        //#region @websqlFunc
+        let databaseConfig = Models__NS__DatabaseConfig.from({});
+        const tcpUdpDatabaseSqliteRelativeFileLocation = `${Models__NS__DatabasesFolder}/db-${this.contextName}.sqlite`;
+        if (this.isRunningInsideDocker) {
+            if (this.USE_MARIADB_MYSQL_IN_DOCKER) {
+                // Helpers__NS__info('Running in docker, using in mysql database');
+                // // TODO auto resolve database config in docker
+                // databaseConfig = Models__NS__DatabaseConfig.from({
+                //   database: `db-${this.contextName}.sqlite`,
+                //   type: 'mysql',
+                //   recreateMode: 'PRESERVE_DATA+MIGRATIONS',
+                //   logging: this.logDb,
+                //   databasePort: 3306,
+                //   databaseHost: 'localhost',
+                //   databaseUsername: 'root',
+                //   databasePassword: 'admin',
+                // });
+            }
+            else {
+                // TOOD @LAST for now.. just use sqljs in docker
+                this.logFramework &&
+                    console.log(`
 
           USING GENERATED CONFIG FOR SQLJS IN DOCKER
 
           `);
-        const locationOfTheDatabase = crossPlatformPath([
-          process.cwd(),
-          `db-${this.contextName}.sqlite`
-        ]);
-        databaseConfig = databaseConfig = Models__NS__DatabaseConfig.from({
-          location: tcpUdpDatabaseSqliteRelativeFileLocation,
-          type: "sqljs",
-          useLocalForage: false,
-          recreateMode: "PRESERVE_DATA+MIGRATIONS",
-          logging: true
-        });
-        if (!fse.existsSync(locationOfTheDatabase)) {
-          databaseConfig.recreateMode = "DROP_DB+MIGRATIONS";
-        }
-        this.logFramework && console.log(`
+                //#region @backend
+                const locationOfTheDatabase = crossPlatformPath([
+                    process.cwd(),
+                    `db-${this.contextName}.sqlite`,
+                ]);
+                //#endregion
+                databaseConfig = databaseConfig = Models__NS__DatabaseConfig.from({
+                    location: tcpUdpDatabaseSqliteRelativeFileLocation,
+                    type: 'sqljs',
+                    useLocalForage: false,
+                    recreateMode: 'PRESERVE_DATA+MIGRATIONS',
+                    logging: true,
+                });
+                //#region @backend
+                if (!fse.existsSync(locationOfTheDatabase)) {
+                    databaseConfig.recreateMode = 'DROP_DB+MIGRATIONS';
+                }
+                // TODO @LAST add same thing for mariadb/mysql
+                this.logFramework &&
+                    console.log(`
           location of database: ${locationOfTheDatabase}
           db file exists: ${fse.existsSync(locationOfTheDatabase)}
           synchronize: ${databaseConfig.synchronize}
           dropSchema: ${databaseConfig.dropSchema}
         `);
-      }
-    } else {
-      this.logFramework && Helpers__NS__info(
-        `[taon][database] Automatically resolving database config for mode ${this.mode}`
-      );
-      switch (this.mode) {
-        //#region resolve database config for backend-frontend(ipc-electron)
-        case "backend-frontend(ipc-electron)":
-          let dbLocationInOs;
-          if (UtilsOs__NS__isElectron) {
-            dbLocationInOs = crossPlatformPath([
-              UtilsOs__NS__getRealHomeDir(),
-              `.taon/databases-for-electron-apps/${this.appId || ___NS__snakeCase(process.cwd()).replace(/\_/, ".")}/${this.contextName}.sqlite`
-            ]);
-            if (!Helpers__NS__exists(path.dirname(dbLocationInOs))) {
-              Helpers__NS__mkdirp(path.dirname(dbLocationInOs));
+                //#endregion
             }
-          }
-          databaseConfig = Models__NS__DatabaseConfig.from({
-            location: UtilsOs__NS__isElectron ? dbLocationInOs : `db-${this.contextName}.sqlite`,
-            type: "sqljs",
-            recreateMode: "DROP_DB+MIGRATIONS",
-            logging: this.logDb
-          });
-          break;
-        //#endregion
-        //#region  resolve database config for mode backend-frontend(websql)
-        case "backend-frontend(websql-electron)":
-        case "backend-frontend(websql)":
-          let keepWebsqlDbDataAfterReload = false;
-          databaseConfig = databaseConfig = Models__NS__DatabaseConfig.from({
-            location: `db-${this.contextName}.sqlite`,
-            type: "sqljs",
-            useLocalForage: true,
-            // !!window['localforage'], // TODO this need to be checked in runtime
-            recreateMode: keepWebsqlDbDataAfterReload ? "PRESERVE_DATA+MIGRATIONS" : "DROP_DB+MIGRATIONS",
-            logging: this.logDb
-          });
-          break;
+        }
+        else {
+            //#region auto resolve db config
+            this.logFramework &&
+                Helpers__NS__info(`[taon][database] Automatically resolving database config for mode ${this.mode}`);
+            switch (this.mode) {
+                //#region resolve database config for backend-frontend(ipc-electron)
+                case 'backend-frontend(ipc-electron)':
+                    let dbLocationInOs;
+                    //#region @backend
+                    if (UtilsOs__NS__isElectron) {
+                        dbLocationInOs = crossPlatformPath([
+                            UtilsOs__NS__getRealHomeDir(),
+                            `.taon/databases-for-electron-apps/${this.appId || ___NS__snakeCase(process.cwd()).replace(/\_/, '.')}/${this.contextName}.sqlite`,
+                        ]);
+                        if (!Helpers__NS__exists(path.dirname(dbLocationInOs))) {
+                            Helpers__NS__mkdirp(path.dirname(dbLocationInOs));
+                        }
+                    }
+                    //#endregion
+                    databaseConfig = Models__NS__DatabaseConfig.from({
+                        location: UtilsOs__NS__isElectron
+                            ? dbLocationInOs
+                            : `db-${this.contextName}.sqlite`,
+                        type: 'sqljs',
+                        recreateMode: 'DROP_DB+MIGRATIONS',
+                        logging: this.logDb,
+                    });
+                    break;
+                //#endregion
+                //#region  resolve database config for mode backend-frontend(websql)
+                case 'backend-frontend(websql-electron)':
+                case 'backend-frontend(websql)':
+                    let keepWebsqlDbDataAfterReload = false;
+                    /* */
+                    /* */
+                    /* */
+                    databaseConfig = databaseConfig = Models__NS__DatabaseConfig.from({
+                        location: `db-${this.contextName}.sqlite`,
+                        type: 'sqljs',
+                        useLocalForage: true, // !!window['localforage'], // TODO this need to be checked in runtime
+                        recreateMode: keepWebsqlDbDataAfterReload
+                            ? 'PRESERVE_DATA+MIGRATIONS'
+                            : 'DROP_DB+MIGRATIONS',
+                        logging: this.logDb,
+                    });
+                    break;
+                //#endregion
+                //#region resolve database config for mode backend-frontend(tcp+udp)
+                case 'backend-frontend(tcp+udp)':
+                    databaseConfig = Models__NS__DatabaseConfig.from({
+                        database: `context-db-${this.contextName}`,
+                        location: tcpUdpDatabaseSqliteRelativeFileLocation,
+                        type: 'sqljs',
+                        recreateMode: 'DROP_DB+MIGRATIONS',
+                        logging: this.logDb,
+                    });
+                    break;
+                //#endregion
+            }
+            //#endregion
+        }
+        return databaseConfig.databaseConfigTypeORM;
         //#endregion
-        //#region resolve database config for mode backend-frontend(tcp+udp)
-        case "backend-frontend(tcp+udp)":
-          databaseConfig = Models__NS__DatabaseConfig.from({
-            database: `context-db-${this.contextName}`,
-            location: tcpUdpDatabaseSqliteRelativeFileLocation,
-            type: "sqljs",
-            recreateMode: "DROP_DB+MIGRATIONS",
-            logging: this.logDb
-          });
-          break;
-      }
-    }
-    return databaseConfig.databaseConfigTypeORM;
-  }
-  //#endregion
-  //#region methods & getters / start server
-  async startServer() {
-    if (this.isRemoteHost || this.isRunOrRevertOnlyMigrationAppStart) {
-      return;
-    }
-    if (this.mode === "backend-frontend(tcp+udp)") {
-      return await new Promise((resolve) => {
-        if (this.isRunningInsideDocker) {
-          this.serverTcpUdp.listen(Number(this.uriPort), "0.0.0.0", () => {
-            this.logFramework && Helpers__NS__log(
-              `[ctx=${this.contextName}] Express server (inside docker) started 0.0.0.0:${this.uriPort}`
-            );
-            this.logFramework && Helpers__NS__log(`[taon][express-server]listening on port: ${this.uriPort}, hostname: ${this.uriPathname},
+    }
+    //#endregion
+    //#region methods & getters / start server
+    async startServer() {
+        //#region @backendFunc
+        if (this.isRemoteHost || this.isRunOrRevertOnlyMigrationAppStart) {
+            return;
+        }
+        if (this.mode === 'backend-frontend(tcp+udp)') {
+            return await new Promise(resolve => {
+                if (this.isRunningInsideDocker) {
+                    // this.displayRoutes(this.expressApp);
+                    this.serverTcpUdp.listen(Number(this.uriPort), '0.0.0.0', () => {
+                        this.logFramework &&
+                            Helpers__NS__log(`[ctx=${this.contextName}] Express server (inside docker) started 0.0.0.0:${this.uriPort}`);
+                        this.logFramework &&
+                            Helpers__NS__log(`[taon][express-server]listening on port: ${this.uriPort}, hostname: ${this.uriPathname},
     address: ${this.uriProtocol}//localhost:${this.uriPort}${this.uriPathname}
     ExpressJS mode: ${this.expressApp.settings.env}
     `);
-            resolve(void 0);
-          });
-        } else {
-          this.serverTcpUdp.listen(Number(this.uriPort), () => {
-            this.logFramework && Helpers__NS__log(
-              `[ctx=${this.contextName}] Express server (inside nodejs app) started on localhost:${this.uriPort}`
-            );
-            this.logFramework && Helpers__NS__log(`[taon][express-server]listening on port: ${this.uriPort}, hostname: ${this.uriPathname},
+                        resolve(void 0);
+                    });
+                }
+                else {
+                    // this.displayRoutes(this.expressApp);
+                    this.serverTcpUdp.listen(Number(this.uriPort), () => {
+                        this.logFramework &&
+                            Helpers__NS__log(`[ctx=${this.contextName}] Express server (inside nodejs app) started on localhost:${this.uriPort}`);
+                        this.logFramework &&
+                            Helpers__NS__log(`[taon][express-server]listening on port: ${this.uriPort}, hostname: ${this.uriPathname},
     address: ${this.uriProtocol}//localhost:${this.uriPort}${this.uriPathname}
     expressJS mode: ${this.expressApp.settings.env}
             `);
-            resolve(void 0);
-          });
-        }
-      });
-    } else {
-      this.logFramework && Helpers__NS__info("Ipc communication enable instead tcp/upd");
-    }
-  }
-  //#endregion
-  //#region methods & getters / display express routes
-  displayRoutes(app) {
-    const routes = [];
-    app._router?.stack.forEach(function(middleware) {
-      if (middleware.route) {
-        const methods = [];
-        for (let method in middleware.route.methods) {
-          if (middleware.route.methods[method]) {
-            methods.push(method.toUpperCase());
-          }
-        }
-        routes.push({ path: middleware.route.path, methods });
-      } else if (middleware.name === "router") {
-        middleware.handle.stack.forEach(function(handler) {
-          const methods = [];
-          for (let method in handler.route.methods) {
-            if (handler.route.methods[method]) {
-              methods.push(method.toUpperCase());
+                        resolve(void 0);
+                    });
+                }
+            });
+        }
+        else {
+            this.logFramework &&
+                Helpers__NS__info('Ipc communication enable instead tcp/upd');
+        }
+        //#endregion
+    }
+    //#endregion
+    //#region methods & getters / display express routes
+    displayRoutes(app) {
+        //#region @backend
+        const routes = [];
+        app._router?.stack.forEach(function (middleware) {
+            if (middleware.route) {
+                // routes registered directly on the app
+                const methods = [];
+                for (let 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) {
+                    const methods = [];
+                    for (let method in handler.route.methods) {
+                        if (handler.route.methods[method]) {
+                            methods.push(method.toUpperCase());
+                        }
+                    }
+                    routes.push({ path: handler.route.path, methods: methods });
+                });
             }
-          }
-          routes.push({ path: handler.route.path, methods });
         });
-      }
-    });
-    console.log(routes);
-  }
-  //#endregion
-  //#region methods & getters / mode allows database creation
-  get modeAllowsDatabaseCreation() {
-    return this.mode === "backend-frontend(tcp+udp)" || this.mode === "backend-frontend(websql)" || this.mode === "backend-frontend(ipc-electron)";
-  }
-  //#endregion
-  //#region methods & getters / clone class
-  cloneClassWithNewMetadata = ({
-    TaonBaseClass,
-    className,
-    config: config2,
-    ctx,
-    classType
-  }) => {
-    const cloneClass = () => {
-      if (TaonBaseClass[Symbols__NS__fullClassNameStaticProperty] === `${ctx.contextName}.${className}`) {
-        return TaonBaseClass;
-      }
-      return class extends TaonBaseClass {
-        // static ['_'] = TaonBaseClass['_'];
-        // @ts-ignore
-        static [Symbols__NS__orignalClass] = TaonBaseClass;
-        // @ts-ignore
-        static [Symbols__NS__fullClassNameStaticProperty] = `${ctx.contextName}.${className}`;
-        // @ts-ignore
-        static [Symbols__NS__classNameStaticProperty] = className;
-        static [Symbols__NS__ctxInClassOrClassObj] = ctx;
-        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-        static __getFullPathForClass__(arr = []) {
-          const name = this[Symbols__NS__fullClassNameStaticProperty];
-          arr.push(name);
-          if (this[Symbols__NS__orignalClass] && // @ts-ignore
-          this[Symbols__NS__orignalClass].__getFullPathForClass__) {
-            this[Symbols__NS__orignalClass].__getFullPathForClass__(arr);
-          }
-          return arr.join("/");
-        }
-        static get fullPathForClass() {
-          return this.__getFullPathForClass__();
-        }
-        [Symbols__NS__ctxInClassOrClassObj] = ctx;
-        // You can override prototype properties or methods here if needed
-        // static properties override allowed
-      };
-    };
-    const cloneClassFunction = cloneClass();
-    return cloneClassFunction;
-  };
-  //#endregion
-  //#region methods & getters / clone classes obj with new metadata
-  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-  cloneClassesObjWithNewMetadata = ({
-    classesInput,
-    config: config2,
-    ctx,
-    classType
-  }) => {
-    const classes = {};
-    for (const key of Object.keys(classesInput || {})) {
-      const TaonBaseClass = classesInput[key];
-      if (!TaonBaseClass) {
-        Helpers__NS__error(`Class ${key} is not defined in context ${ctx.contextName}
-
-        Please check if you have correct import in context file
-
-        `);
-      }
-      var className = Reflect.getMetadata(
-        Symbols__NS__metadata.className,
-        TaonBaseClass
-      );
-      className = className || key;
-      TaonBaseClass[Symbols__NS__classNameStaticProperty] = className;
-      const clonedClass = this.cloneClassWithNewMetadata({
-        TaonBaseClass,
-        className,
-        config: config2,
-        ctx,
-        classType
-      });
-      classes[className] = clonedClass;
-    }
-    return classes;
-  };
-  //#endregion
-  //#region methods & getters / get recursive classes from contexts
-  async getRecrusiveClassesfromContextsObj(classType) {
-    const arr = await this.getRecrusiveClassesfromContexts(classType);
-    return arr.reduce((acc, c) => {
-      acc[ClassHelpers__NS__getName(c)] = c;
-      return acc;
-    }, {});
-  }
-  async getRecrusiveClassesfromContexts(classType, arr = []) {
-    const contexts = Object.values(this.config.contexts || {});
-    for (const ctx of contexts) {
-      const ref = await ctx.__ref();
-      const classesInput = ref.getClassFunBy(classType);
-      const clonedClasses = Object.values(
-        this.cloneClassesObjWithNewMetadata({
-          classesInput,
-          config: this.config,
-          ctx: this,
-          classType
-        })
-      );
-      clonedClasses.forEach((c) => arr.push(c));
-      await ref.getRecrusiveClassesfromContexts(classType, arr);
-    }
-    return arr;
-  }
-  //#endregion
-  //#region methods & getters / get class instances by class type
-  getClassInstanceObjBy(classType) {
-    return this.classInstancesByNameObj[classType];
-  }
-  //#endregion
-  //#region methods & getters / get class instances arr
-  getClassesInstancesArrBy(classType) {
-    return this.objWithClassesInstancesArr[classType];
-  }
-  //#endregion
-  //#region methods & getters / inject
-  inject(ctor, options) {
-    const className = ClassHelpers__NS__getName(ctor);
-    const locaInstanceConstructorArgs = options.locaInstanceConstructorArgs || [];
-    if (this.isCLassType(Models__NS__ClassType.REPOSITORY, ctor)) {
-      options.localInstance = true;
-    }
-    if (options?.localInstance) {
-      const ctxClassFn = this.getClassFunByClassName(className);
-      let entityName = "";
-      const entityFn = ___NS__first(locaInstanceConstructorArgs);
-      const entity = entityFn && entityFn();
-      entityName = entity && ClassHelpers__NS__getName(entity) || "";
-      if (!options.contextClassInstance[this.localInstaceObjSymbol]) {
-        options.contextClassInstance[this.localInstaceObjSymbol] = {};
-      }
-      const instanceKey = className + (entityName ? `.${entityName}` : "");
-      const existed = options.contextClassInstance[this.localInstaceObjSymbol][instanceKey];
-      if (existed) {
-        return existed;
-      }
-      if (!ctxClassFn) {
-        throw new Error(`Not able to inject "${className}" inside context "${this.contextName}"
+        console.log(routes);
+        //#endregion
+    }
+    //#endregion
+    //#region methods & getters / mode allows database creation
+    get modeAllowsDatabaseCreation() {
+        return (this.mode === 'backend-frontend(tcp+udp)' ||
+            this.mode === 'backend-frontend(websql)' ||
+            this.mode === 'backend-frontend(ipc-electron)');
+    }
+    //#endregion
+    //#region methods & getters / get recursive classes from contexts
+    async getRecrusiveClassesfromContextsObj(classType) {
+        const arr = await this.getRecrusiveClassesfromContexts(classType);
+        return arr.reduce((acc, c) => {
+            acc[ClassHelpers__NS__getName(c)] = c;
+            return acc;
+        }, {});
+    }
+    async getRecrusiveClassesfromContexts(classType, arr = []) {
+        const contexts = Object.values(this.config.contexts || {});
+        // console.log({
+        //   contexts,
+        // });
+        for (const ctx of contexts) {
+            // console.log(`STARTING ${ctx.contextName}`);
+            const ref = await ctx.__ref();
+            // console.log(`CTX FROM ${ctx.contextName}`, ref.contextName);
+            const classesInput = ref.getClassFunBy(classType);
+            // console.log(`${ref.contextName} - ${classType}`, { classesInput });
+            const clonedClasses = Object.values(this.cloneClassesObjWithNewMetadata({
+                classesInput,
+                config: this.config,
+                ctx: this,
+                classType,
+            }));
+            // console.log(`${classType} clonedClasses`, clonedClasses);
+            clonedClasses.forEach(c => arr.push(c));
+            await ref.getRecrusiveClassesfromContexts(classType, arr);
+        }
+        return arr;
+    }
+    //#endregion
+    //#region methods & getters / get class instances by class type
+    getClassInstanceObjBy(classType) {
+        return this.classInstancesByNameObj[classType];
+    }
+    //#endregion
+    //#region methods & getters / get class instances arr
+    getClassesInstancesArrBy(classType) {
+        return this.objWithClassesInstancesArr[classType];
+    }
+    //#endregion
+    //#region methods & getters / inject
+    inject(ctor, options) {
+        const className = ClassHelpers__NS__getName(ctor);
+        const locaInstanceConstructorArgs = options.locaInstanceConstructorArgs || [];
+        if (this.isCLassType(Models__NS__ClassType.REPOSITORY, ctor)) {
+            options.localInstance = true;
+        }
+        if (options?.localInstance) {
+            const ctxClassFn = this.getClassFunByClassName(className);
+            let entityName = '';
+            // entity thing is only for repositories local repositories
+            // if (className === 'TaonBaseRepository') {
+            const entityFn = ___NS__first(locaInstanceConstructorArgs);
+            const entity = entityFn && entityFn();
+            entityName = (entity && ClassHelpers__NS__getName(entity)) || '';
+            // console.log(`entityName `, entityName);
+            // }
+            if (!options.contextClassInstance[this.localInstaceObjSymbol]) {
+                options.contextClassInstance[this.localInstaceObjSymbol] = {};
+            }
+            const instanceKey = className + (entityName ? `.${entityName}` : '');
+            const existed = options.contextClassInstance[this.localInstaceObjSymbol][instanceKey];
+            if (existed) {
+                // console.log(
+                //   `EXISTED ${ClassHelpers__NS__getName(options.parentInstanceThatWillGetInjectedStuff)} Inject ${className} instanceKey "${instanceKey}"`,
+                // );
+                return existed;
+            }
+            // console.log(
+            //   `NEW ${ClassHelpers__NS__getName(options.parentInstanceThatWillGetInjectedStuff)} Inject ${className} instanceKey "${instanceKey}"`,
+            // );
+            if (!ctxClassFn) {
+                throw new Error(`Not able to inject "${className}" inside context "${this.contextName}"
 
         Make sure they share the same context or import context where "${className}" is defined.
 
         `);
-      }
-      const injectedInstance = new ctxClassFn(
-        ...locaInstanceConstructorArgs
-      );
-      options.contextClassInstance[this.localInstaceObjSymbol][instanceKey] = injectedInstance;
-      return injectedInstance;
-    }
-    const contextScopeInstance = this.allClassesInstances[className];
-    return contextScopeInstance;
-  }
-  /**
-   * alias for inject
-   */
-  getInstanceBy(ctor) {
-    return this.inject(ctor, {
-      localInstance: false,
-      parentInstanceThatWillGetInjectedStuff: this
-    });
-  }
-  //#endregion
-  //#region methods & getters / check if context initialized
-  checkIfContextInitialized() {
-    if (___NS__isUndefined(this.config)) {
-      throw new Error(`Please check if your context has been initialized.
+            }
+            const injectedInstance = new ctxClassFn(...locaInstanceConstructorArgs);
+            options.contextClassInstance[this.localInstaceObjSymbol][instanceKey] =
+                injectedInstance;
+            // console.log(`injectedInstance `, existed)
+            return injectedInstance;
+        }
+        const contextScopeInstance = this.allClassesInstances[className];
+        // if (className === 'TopicController') {
+        //   debugger;
+        // }
+        return contextScopeInstance;
+    }
+    /**
+     * alias for inject
+     */
+    getInstanceBy(ctor) {
+        // if (!!this.__contextForControllerInstanceAccess) {
+        //   const className = ClassHelpers__NS__getName(ctor);
+        //   const allControllers = this.getClassFunByArr(Models__NS__ClassType.CONTROLLER);
+        //   // TODO QUICK_FIX cache controllers
+        //   for (const ctrl of allControllers) {
+        //     if (ClassHelpers__NS__getName(ctrl) === className) {
+        //       // console.log('injecting from contextForControllerInstanceAcesss', className);
+        //       return this.__contextForControllerInstanceAccess.inject(ctor, {
+        //         localInstance: false,
+        //       });
+        //     }
+        //   }
+        // }
+        return this.inject(ctor, {
+            localInstance: false,
+            parentInstanceThatWillGetInjectedStuff: this,
+        });
+    }
+    //#endregion
+    //#region methods & getters / check if context initialized
+    checkIfContextInitialized() {
+        if (___NS__isUndefined(this.config)) {
+            throw new Error(`Please check if your context has been initialized.
 
       // ...
       await Context.initialize();
@@ -788,1178 +897,1448 @@ class EndpointContext {
 
 
       `);
+        }
+    }
+    //#endregion
+    //#region methods & getters / get class function by class type name
+    getClassFunBy(classType) {
+        this.checkIfContextInitialized();
+        switch (classType) {
+            case Models__NS__ClassType.CONTROLLER:
+                return this.config.controllers;
+            case Models__NS__ClassType.ENTITY:
+                return this.config.entities;
+            case Models__NS__ClassType.PROVIDER:
+                return this.config.providers;
+            case Models__NS__ClassType.MIDDLEWARE:
+                return this.config.middlewares;
+            case Models__NS__ClassType.REPOSITORY:
+                return this.config.repositories;
+            case Models__NS__ClassType.SUBSCRIBER:
+                return this.config.subscribers;
+            case Models__NS__ClassType.MIGRATION:
+                return this.config.migrations;
+        }
+    }
+    isCLassType(classType, classFn) {
+        return !!this.getClassFunBy(classType)[ClassHelpers__NS__getName(classFn)];
+    }
+    /**
+     * Only for injectable types
+     * Only for classType: CONTROLLER, REPOSITORY, PROVIDER, MIDDLEWARES
+     */
+    getClassFunByClassName(className) {
+        for (const classTypeName of this.allTypesfromContexts) {
+            const classesForInjectableType = this.config[Models__NS__ClassTypeKey[classTypeName]];
+            if (classesForInjectableType[className]) {
+                return classesForInjectableType[className];
+            }
+        }
+    }
+    getClassFunByClass(classFunction) {
+        const className = ClassHelpers__NS__getName(classFunction);
+        return this.getClassFunByClassName(className);
+    }
+    getClassFunByArr(classType) {
+        return Object.values(this.getClassFunBy(classType) || {});
+    }
+    //#endregion
+    //#region methods & getters / create class instances
+    async createInstances(classes, classType) {
+        // const recrusiveValuesFromContext =
+        //   await this.getRecrusiveClassesfromContexts(classType);
+        // console.log(this.config.contexts);
+        // console.log('recrusiveValuesFromContext', recrusiveValuesFromContext);
+        for (const classFn of [
+            // ...recrusiveValuesFromContext,
+            ...Object.values(classes),
+        ]) {
+            const instance = DITaonContainer.resolve(classFn);
+            const classInstancesByNameObj = this.classInstancesByNameObj[classType];
+            const className = ClassHelpers__NS__getName(classFn);
+            // console.log({ classFn, classType, instance, place, className, 'classInstancesByNameObj': this.classInstancesByNameObj });
+            classInstancesByNameObj[className] = instance;
+            // update config
+            this.config[Models__NS__ClassTypeKey[classType]][className] = classFn;
+            this.objWithClassesInstancesArr[classType].push(instance);
+            this.allClassesInstances[className] = instance;
+        }
+    }
+    //#endregion
+    //#region methods & getters / init classes
+    async initClasses() {
+        if (this.isRemoteHost) {
+            return;
+        }
+        //#region @websql
+        for (const classFun of this.getClassFunByArr(Models__NS__ClassType.ENTITY)) {
+            const repo = (await this.connection.getRepository(ClassHelpers__NS__getOrginalClass(classFun)));
+            this.repos.set(ClassHelpers__NS__getName(classFun), repo);
+        }
+        //#endregion
+        for (const classTypeName of [
+            Models__NS__ClassType.MIDDLEWARE,
+            Models__NS__ClassType.PROVIDER,
+            Models__NS__ClassType.REPOSITORY,
+            Models__NS__ClassType.CONTROLLER,
+            Models__NS__ClassType.ENTITY,
+            Models__NS__ClassType.MIGRATION,
+        ]) {
+            //#region init class static _ property
+            for (const classFun of this.getClassFunByArr(classTypeName)) {
+                if (___NS__isFunction(classFun._)) {
+                    await classFun._();
+                }
+            }
+            //#endregion
+        }
+        for (const classTypeName of [
+            Models__NS__ClassType.MIDDLEWARE,
+            Models__NS__ClassType.PROVIDER,
+            Models__NS__ClassType.REPOSITORY,
+            Models__NS__ClassType.CONTROLLER,
+            Models__NS__ClassType.MIGRATION,
+        ]) {
+            //#region init providers, repositories  _ property
+            // Helpers__NS__taskStarted(
+            //   `[taon] REINITING _ INS FN ${classTypeName} ${this.contextName} STARTED`,
+            // );
+            for (const ctrl of this.getClassesInstancesArrBy(classTypeName)) {
+                if (___NS__isFunction(ctrl._)) {
+                    await ctrl._();
+                }
+            }
+            // Helpers__NS__taskStarted(
+            //   `[taon] REINITING _ INS FN ${classTypeName} ${this.contextName} DONE`,
+            // );
+            //#endregion
+        }
+    }
+    //#endregion
+    //#region methods & getters / is active on
+    isActiveOn(classInstance) {
+        let contextRef = classInstance[Symbols__NS__ctxInClassOrClassObj];
+        return this === contextRef;
+    }
+    //#endregion
+    //#region methods & getters / uri
+    get frontendHostUri() {
+        const url = this.config?.frontendHost?.startsWith('http')
+            ? this.config.frontendHost
+            : `${globalThis?.location?.protocol || 'http:'}//${this.config?.frontendHost}`;
+        const uri = new URL(url.replace(/\/$/, ''));
+        return uri;
+    }
+    get uri() {
+        const url = this.host ? new URL(this.host) : void 0;
+        return url;
+    }
+    //#endregion
+    //#region methods & getters / host uri protocol
+    get uriProtocol() {
+        return this.uri?.protocol;
+    }
+    //#endregion
+    //#region methods & getters / host uri origin
+    /**
+     * Examples
+     * http://localhost:3000
+     * https://localhost (from localhost:80)   *
+     */
+    get uriOrigin() {
+        return this.uri?.origin;
+    }
+    //#endregion
+    //#region methods & getters / host uri pathname
+    /**
+     * Exampels
+     * http://localhost:3000/path/to/somewhere
+     * https://localhost/path/to/somewhere (from localhost:80)
+     */
+    // get uriOriginWithPathname(): string | undefined {
+    //   return this.uri?.origin
+    //     ? this.uri?.origin + this.uriPathnameOrNothingIfRoot.replace(/\/$/, '')
+    //     : undefined;
+    // }
+    get uriPathname() {
+        return this.uri?.pathname;
+    }
+    //#endregion
+    //#region methods & getters / uri pathname or nothing if root
+    /**
+     * Examples
+     * http://localhost:3000/path/to/somewhere -> '/path/to/somewhere'
+     * http://localhost:3000 -> '' #
+     * https://localhost/path/to/  -> '/path/to/somewhere' # remove last slash
+     */
+    get uriPathnameOrNothingIfRoot() {
+        const isNonRootProperPathName = this.uri?.pathname && this.uri.pathname !== '/';
+        return isNonRootProperPathName ? this.uri.pathname.replace(/\/$/, '') : '';
+    }
+    //#endregion
+    //#region methods & getters / port from uri
+    get uriPort() {
+        if (!this.uri?.origin?.includes('localhost')) {
+            return this.config?.hostPortNumber?.toString();
+        }
+        return this.uri?.port;
+    }
+    // TODO do i need 2 getters for port?
+    /**
+     * Port from uri as number
+     * @returns {Number | undefined}
+     */
+    get port() {
+        return this.uri?.port ? Number(this.uriPort) : undefined;
+    }
+    //#endregion
+    //#region methods & getters / is https server
+    get isHttpServer() {
+        return this.uriProtocol === 'https:';
+    }
+    //#endregion
+    //#region methods & getters / is remote host
+    /**
+     * Check if context is for remote only
+     */
+    get isRemoteHost() {
+        return !!this.cloneOptions?.useAsRemoteContext;
+    }
+    //#endregion
+    //#region methods & getters / context name
+    /**
+     * ipc/udp needs this
+     */
+    get contextName() {
+        // console.log(this.originalConfig);
+        return this.config?.contextName || this.originalConfig?.contextName;
+    }
+    //#endregion
+    //#region methods & getters / context name for communication
+    /**
+     * ipc/udp needs this
+     */
+    get contextNameForCommunication() {
+        let contextName = this.contextName;
+        if (this.isRemoteHost) {
+            if (this.sourceContext?.contextName) {
+                contextName = this.sourceContext?.contextName;
+            }
+            else {
+                // console.log(
+                //   `CANT GET SOURCE CONTEXT NAME FOR REMOTE CONTEXT ${this.contextName}`,
+                // );
+            }
+        }
+        return contextName;
+    }
+    //#endregion
+    //#region methods & getters / get context type
+    /**
+     * Check context type
+     */
+    get contextType() {
+        if (this.config.abstract) {
+            return 'abstract';
+        }
+        if (this.host) {
+            return this.isRemoteHost ? 'remote' : 'normal';
+        }
+        return 'invalid';
+    }
+    //#endregion
+    //#region methods & getters / current working directory
+    get cwd() {
+        return this.config.cwd || process.cwd();
+    }
+    //#endregion
+    //#region methods & getters / active context
+    get activeContext() {
+        return this.config.activeContext || null;
+    }
+    //#endregion
+    //#region methods & getters / app id
+    get appId() {
+        return this.config.appId;
+    }
+    //#endregion
+    //#region methods & getters / public assets
+    get publicAssets() {
+        return this.config?.publicAssets || [];
+    }
+    //#endregion
+    //#region methods & getters / is production mode
+    get isProductionMode() {
+        return this.config.productionMode;
+    }
+    //#endregion
+    //#region methods & getters / host
+    get host() {
+        return this.config.host;
+    }
+    //#endregion
+    //#region methods & getters / origin
+    get origin() {
+        return this.uri?.origin;
+    }
+    //#endregion
+    //#region methods & getters / init subscribers
+    async initSubscribers() {
+        //#region @websqlFunc
+        if (this.isRemoteHost) {
+            return;
+        }
+        const subscriberClasses = this.getClassFunByArr(Models__NS__ClassType.SUBSCRIBER);
+        for (const subscriberClassFn of subscriberClasses) {
+            const options = Reflect.getMetadata(Symbols__NS__metadata.options.subscriber, subscriberClassFn);
+            // console.log('subscriber options', options);
+            // const nameForSubscriber = ClassHelpers__NS__getName(subscriber);
+            EventSubscriber()(subscriberClassFn);
+        }
+        //#endregion
+    }
+    //#endregion
+    //#region methods & getters / init entities
+    async initEntities() {
+        //#region @websql
+        if (this.isRemoteHost) {
+            return;
+        }
+        const entities = this.getClassFunByArr(Models__NS__ClassType.ENTITY);
+        for (const entity of entities) {
+            const options = Reflect.getMetadata(Symbols__NS__metadata.options.entity, entity);
+            const createTable = ___NS__isUndefined(options.createTable)
+                ? true
+                : options.createTable;
+            const nameForEntity = ClassHelpers__NS__getName(entity);
+            if (createTable) {
+                this.logDb &&
+                    console.info(`[taon][typeorm] create table for entity "${nameForEntity}" ? '${createTable}'`);
+                // console.log('TypeormEntity', { TypeormEntity });
+                TypeormEntity(nameForEntity)(entity);
+            }
+            else {
+                this.logDb &&
+                    console.info(`[taon][typeorm] create table for entity "${nameForEntity}" ? '${createTable}'`);
+            }
+        }
+        //#endregion
+    }
+    //#endregion
+    //#region methods & getters / destroy
+    async destroy() {
+        //#region @websqlFunc
+        if (this.connection) {
+            await this.connection?.destroy();
+            delete this.connection;
+        }
+        if (this.serverTcpUdp) {
+            await new Promise(resolve => {
+                this.serverTcpUdp?.close(() => {
+                    resolve(true);
+                });
+            });
+            delete this.serverTcpUdp;
+        }
+        delete this.expressApp;
+        //#endregion
     }
-  }
-  //#endregion
-  //#region methods & getters / get class function by class type name
-  getClassFunBy(classType) {
-    this.checkIfContextInitialized();
-    switch (classType) {
-      case Models__NS__ClassType.CONTROLLER:
-        return this.config.controllers;
-      case Models__NS__ClassType.ENTITY:
-        return this.config.entities;
-      case Models__NS__ClassType.PROVIDER:
-        return this.config.providers;
-      case Models__NS__ClassType.MIDDLEWARE:
-        return this.config.middlewares;
-      case Models__NS__ClassType.REPOSITORY:
-        return this.config.repositories;
-      case Models__NS__ClassType.SUBSCRIBER:
-        return this.config.subscribers;
-      case Models__NS__ClassType.MIGRATION:
-        return this.config.migrations;
-    }
-  }
-  isCLassType(classType, classFn) {
-    return !!this.getClassFunBy(classType)[ClassHelpers__NS__getName(classFn)];
-  }
-  /**
-   * Only for injectable types
-   * Only for classType: CONTROLLER, REPOSITORY, PROVIDER, MIDDLEWARES
-   */
-  getClassFunByClassName(className) {
-    for (const classTypeName of this.allTypesfromContexts) {
-      const classesForInjectableType = this.config[Models__NS__ClassTypeKey[classTypeName]];
-      if (classesForInjectableType[className]) {
-        return classesForInjectableType[className];
-      }
-    }
-  }
-  getClassFunByClass(classFunction) {
-    const className = ClassHelpers__NS__getName(classFunction);
-    return this.getClassFunByClassName(className);
-  }
-  getClassFunByArr(classType) {
-    return Object.values(this.getClassFunBy(classType) || {});
-  }
-  //#endregion
-  //#region methods & getters / create class instances
-  async createInstances(classes, classType) {
-    for (const classFn of [
-      // ...recrusiveValuesFromContext,
-      ...Object.values(classes)
-    ]) {
-      const instance = DITaonContainer.resolve(classFn);
-      const classInstancesByNameObj = this.classInstancesByNameObj[classType];
-      const className = ClassHelpers__NS__getName(classFn);
-      classInstancesByNameObj[className] = instance;
-      this.config[Models__NS__ClassTypeKey[classType]][className] = classFn;
-      this.objWithClassesInstancesArr[classType].push(instance);
-      this.allClassesInstances[className] = instance;
-    }
-  }
-  //#endregion
-  //#region methods & getters / init classes
-  async initClasses() {
-    if (this.isRemoteHost) {
-      return;
-    }
-    for (const classFun of this.getClassFunByArr(
-      Models__NS__ClassType.ENTITY
-    )) {
-      const repo = await this.connection.getRepository(
-        ClassHelpers__NS__getOrginalClass(classFun)
-      );
-      this.repos.set(ClassHelpers__NS__getName(classFun), repo);
-    }
-    for (const classTypeName of [
-      Models__NS__ClassType.MIDDLEWARE,
-      Models__NS__ClassType.PROVIDER,
-      Models__NS__ClassType.REPOSITORY,
-      Models__NS__ClassType.CONTROLLER,
-      Models__NS__ClassType.ENTITY,
-      Models__NS__ClassType.MIGRATION
-    ]) {
-      for (const classFun of this.getClassFunByArr(classTypeName)) {
-        if (___NS__isFunction(classFun._)) {
-          await classFun._();
-        }
-      }
-    }
-    for (const classTypeName of [
-      Models__NS__ClassType.MIDDLEWARE,
-      Models__NS__ClassType.PROVIDER,
-      Models__NS__ClassType.REPOSITORY,
-      Models__NS__ClassType.CONTROLLER,
-      Models__NS__ClassType.MIGRATION
-    ]) {
-      for (const ctrl of this.getClassesInstancesArrBy(classTypeName)) {
-        if (___NS__isFunction(ctrl._)) {
-          await ctrl._();
-        }
-      }
-    }
-  }
-  //#endregion
-  //#region methods & getters / is active on
-  isActiveOn(classInstance) {
-    let contextRef = classInstance[Symbols__NS__ctxInClassOrClassObj];
-    return this === contextRef;
-  }
-  //#endregion
-  //#region methods & getters / uri
-  get frontendHostUri() {
-    const url = this.config?.frontendHost?.startsWith("http") ? this.config.frontendHost : `${globalThis?.location?.protocol || "http:"}//${this.config?.frontendHost}`;
-    const uri = new URL(url.replace(/\/$/, ""));
-    return uri;
-  }
-  get uri() {
-    const url = this.host ? new URL(this.host) : void 0;
-    return url;
-  }
-  //#endregion
-  //#region methods & getters / host uri protocol
-  get uriProtocol() {
-    return this.uri?.protocol;
-  }
-  //#endregion
-  //#region methods & getters / host uri origin
-  /**
-   * Examples
-   * http://localhost:3000
-   * https://localhost (from localhost:80)   *
-   */
-  get uriOrigin() {
-    return this.uri?.origin;
-  }
-  //#endregion
-  //#region methods & getters / host uri pathname
-  /**
-   * Exampels
-   * http://localhost:3000/path/to/somewhere
-   * https://localhost/path/to/somewhere (from localhost:80)
-   */
-  // get uriOriginWithPathname(): string | undefined {
-  //   return this.uri?.origin
-  //     ? this.uri?.origin + this.uriPathnameOrNothingIfRoot.replace(/\/$/, '')
-  //     : undefined;
-  // }
-  get uriPathname() {
-    return this.uri?.pathname;
-  }
-  //#endregion
-  //#region methods & getters / uri pathname or nothing if root
-  /**
-   * Examples
-   * http://localhost:3000/path/to/somewhere -> '/path/to/somewhere'
-   * http://localhost:3000 -> '' #
-   * https://localhost/path/to/  -> '/path/to/somewhere' # remove last slash
-   */
-  get uriPathnameOrNothingIfRoot() {
-    const isNonRootProperPathName = this.uri?.pathname && this.uri.pathname !== "/";
-    return isNonRootProperPathName ? this.uri.pathname.replace(/\/$/, "") : "";
-  }
-  //#endregion
-  //#region methods & getters / port from uri
-  get uriPort() {
-    if (!this.uri?.origin?.includes("localhost")) {
-      return this.config?.hostPortNumber?.toString();
-    }
-    return this.uri?.port;
-  }
-  // TODO do i need 2 getters for port?
-  /**
-   * Port from uri as number
-   * @returns {Number | undefined}
-   */
-  get port() {
-    return this.uri?.port ? Number(this.uriPort) : void 0;
-  }
-  //#endregion
-  //#region methods & getters / is https server
-  get isHttpServer() {
-    return this.uriProtocol === "https:";
-  }
-  //#endregion
-  //#region methods & getters / is remote host
-  /**
-   * Check if context is for remote only
-   */
-  get isRemoteHost() {
-    return !!this.cloneOptions?.useAsRemoteContext;
-  }
-  //#endregion
-  //#region methods & getters / context name
-  /**
-   * ipc/udp needs this
-   */
-  get contextName() {
-    return this.config?.contextName || this.originalConfig?.contextName;
-  }
-  //#endregion
-  //#region methods & getters / context name for communication
-  /**
-   * ipc/udp needs this
-   */
-  get contextNameForCommunication() {
-    let contextName = this.contextName;
-    if (this.isRemoteHost) {
-      if (this.sourceContext?.contextName) {
-        contextName = this.sourceContext?.contextName;
-      } else {
-      }
-    }
-    return contextName;
-  }
-  //#endregion
-  //#region methods & getters / get context type
-  /**
-   * Check context type
-   */
-  get contextType() {
-    if (this.config.abstract) {
-      return "abstract";
-    }
-    if (this.host) {
-      return this.isRemoteHost ? "remote" : "normal";
-    }
-    return "invalid";
-  }
-  //#endregion
-  //#region methods & getters / current working directory
-  get cwd() {
-    return this.config.cwd || process.cwd();
-  }
-  //#endregion
-  //#region methods & getters / active context
-  get activeContext() {
-    return this.config.activeContext || null;
-  }
-  //#endregion
-  //#region methods & getters / app id
-  get appId() {
-    return this.config.appId;
-  }
-  //#endregion
-  //#region methods & getters / public assets
-  get publicAssets() {
-    return this.config?.publicAssets || [];
-  }
-  //#endregion
-  //#region methods & getters / is production mode
-  get isProductionMode() {
-    return this.config.productionMode;
-  }
-  //#endregion
-  //#region methods & getters / host
-  get host() {
-    return this.config.host;
-  }
-  //#endregion
-  //#region methods & getters / origin
-  get origin() {
-    return this.uri?.origin;
-  }
-  //#endregion
-  //#region methods & getters / init subscribers
-  async initSubscribers() {
-    if (this.isRemoteHost) {
-      return;
-    }
-    const subscriberClasses = this.getClassFunByArr(
-      Models__NS__ClassType.SUBSCRIBER
-    );
-    for (const subscriberClassFn of subscriberClasses) {
-      const options = Reflect.getMetadata(
-        Symbols__NS__metadata.options.subscriber,
-        subscriberClassFn
-      );
-      EventSubscriber()(subscriberClassFn);
-    }
-  }
-  //#endregion
-  //#region methods & getters / init entities
-  async initEntities() {
-    if (this.isRemoteHost) {
-      return;
-    }
-    const entities = this.getClassFunByArr(Models__NS__ClassType.ENTITY);
-    for (const entity of entities) {
-      const options = Reflect.getMetadata(
-        Symbols__NS__metadata.options.entity,
-        entity
-      );
-      const createTable = ___NS__isUndefined(options.createTable) ? true : options.createTable;
-      const nameForEntity = ClassHelpers__NS__getName(entity);
-      if (createTable) {
-        this.logDb && console.info(
-          `[taon][typeorm] create table for entity "${nameForEntity}" ? '${createTable}'`
-        );
-        TypeormEntity(nameForEntity)(entity);
-      } else {
-        this.logDb && console.info(
-          `[taon][typeorm] create table for entity "${nameForEntity}" ? '${createTable}'`
-        );
-      }
-    }
-  }
-  //#endregion
-  //#region methods & getters / destroy
-  async destroy() {
-    if (this.connection) {
-      await this.connection?.destroy();
-      delete this.connection;
-    }
-    if (this.serverTcpUdp) {
-      await new Promise((resolve) => {
-        this.serverTcpUdp?.close(() => {
-          resolve(true);
+    //#endregion
+    //#region methods & getters / init connection
+    async initDatabaseConnection() {
+        //#region @websqlFunc
+        if (this.isRemoteHost || !this.databaseConfig) {
+            return;
+        }
+        const entities = this.getClassFunByArr(Models__NS__ClassType.ENTITY).map(entityFn => {
+            return ClassHelpers__NS__getOrginalClass(entityFn);
         });
-      });
-      delete this.serverTcpUdp;
-    }
-    delete this.expressApp;
-  }
-  //#endregion
-  //#region methods & getters / init connection
-  async initDatabaseConnection() {
-    if (this.isRemoteHost || !this.databaseConfig) {
-      return;
-    }
-    const entities = this.getClassFunByArr(Models__NS__ClassType.ENTITY).map(
-      (entityFn) => {
-        return ClassHelpers__NS__getOrginalClass(entityFn);
-      }
-    );
-    const subscribers = this.getClassFunByArr(Models__NS__ClassType.SUBSCRIBER);
-    let autoSave = false;
-    if (!___NS__isNil(this.databaseConfig.autoSave)) {
-      autoSave = this.databaseConfig.autoSave;
-    } else {
-      if (this.USE_MARIADB_MYSQL_IN_DOCKER) {
-        autoSave = !this.isRunningInsideDocker;
-      } else {
-        autoSave = true;
-      }
-    }
-    const dataSourceDbConfig = ___NS__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,
-      // I am not using typeorm migration system
-      entities,
-      subscribers,
-      synchronize: this.isRunOrRevertOnlyMigrationAppStart ? false : this.databaseConfig.synchronize,
-      autoSave,
-      dropSchema: this.isRunOrRevertOnlyMigrationAppStart ? false : this.databaseConfig.dropSchema,
-      logging: !!this.databaseConfig.logging,
-      location: this.databaseConfig.location
-    } : {};
-    this.logFramework && console.log(
-      `[Context: "${this.contextName}"] dataSourceDbConfig`,
-      dataSourceDbConfig
-    );
-    if (this.modeAllowsDatabaseCreation && this.databaseConfig) {
-      this.logDb && this.logFramework && Helpers__NS__info("[taon][database] prepare typeorm connection...");
-      try {
-        const connection = new DataSource(dataSourceDbConfig);
-        this.connection = connection;
-        await this.connection.initialize();
-      } catch (error) {
-        console.error(
-          `[taon][typeorm] Error while initializing connection for ${this.contextName}, ERROR STARTED `
-        );
-        console.error(error?.stack || "< No stack trace > ");
-        console.error(error?.message || error);
-        console.error(
-          `[taon][typeorm] Error while initializing connection for ${this.contextName}, ERROR ENDS `
-        );
-      }
-      if (!this.connection?.isInitialized) {
-        console.log("WRONG CONFIG", dataSourceDbConfig);
-        throw new Error(`Something wrong with connection init in ${this.mode}`);
-        process.exit(1);
-      }
-      if (this.logDb || this.logFramework) {
-        console.info(
-          `
+        const subscribers = this.getClassFunByArr(Models__NS__ClassType.SUBSCRIBER);
+        let autoSave = false;
+        if (!___NS__isNil(this.databaseConfig.autoSave)) {
+            autoSave = this.databaseConfig.autoSave;
+        }
+        else {
+            if (this.USE_MARIADB_MYSQL_IN_DOCKER) {
+                autoSave = !this.isRunningInsideDocker; // in docker I am using mysql or posgress
+            }
+            else {
+                autoSave = true; // on docker with sqljs I need to save db
+            }
+        }
+        const dataSourceDbConfig = ___NS__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,
+                // I am not using typeorm migration system
+                entities,
+                subscribers,
+                synchronize: this.isRunOrRevertOnlyMigrationAppStart
+                    ? false
+                    : this.databaseConfig.synchronize,
+                autoSave,
+                dropSchema: this.isRunOrRevertOnlyMigrationAppStart
+                    ? false
+                    : this.databaseConfig.dropSchema,
+                logging: !!this.databaseConfig.logging,
+                location: this.databaseConfig.location,
+            }
+            : {};
+        // debugger;
+        this.logFramework &&
+            console.log(`[Context: "${this.contextName}"] dataSourceDbConfig`, dataSourceDbConfig);
+        if (this.modeAllowsDatabaseCreation && this.databaseConfig) {
+            this.logDb &&
+                this.logFramework &&
+                Helpers__NS__info('[taon][database] prepare typeorm connection...');
+            try {
+                const connection = new DataSource(dataSourceDbConfig);
+                this.connection = connection;
+                await this.connection.initialize();
+            }
+            catch (error) {
+                console.error(`[taon][typeorm] Error while initializing connection for ${this.contextName}, ERROR STARTED `);
+                console.error(error?.stack || '< No stack trace > ');
+                console.error(error?.message || error);
+                console.error(`[taon][typeorm] Error while initializing connection for ${this.contextName}, ERROR ENDS `);
+            }
+            if (!this.connection?.isInitialized) {
+                console.log('WRONG CONFIG', dataSourceDbConfig);
+                throw new Error(`Something wrong with connection init in ${this.mode}`);
+                //#region @backend
+                process.exit(1);
+                //#endregion
+            }
+            if (this.logDb || this.logFramework) {
+                console.info(`
 
         CONTECTION OK for ${this.contextName} - ${this.mode}
 
         [taon][typeorm] db prepration done.. db initialize=${this.connection?.isInitialized}
 
 
-        `,
-          // dataSourceDbConfig,
-          { "this.connection": !!this.connection }
-        );
-        console.log(
-          `Database file location: ${this.connection.options.database}`
-        );
-      }
-    } else {
-      Helpers__NS__info(`[taon][typeorm] Not initing db for mode ${this.mode}`);
-    }
-  }
-  //#endregion
-  //#region methods & getters / initialize metadata
-  //#region methods & getters / update class calculate path
-  updateCalculatedPathsForControllers(rawConfigs, classConfig, controllerClassFn) {
-    const parentsCalculatedPath = ___NS__slice(rawConfigs, 1).reverse().map((bc) => {
-      if (TaonHelpers__NS__isGoodPath(bc.path)) {
-        return bc.path;
-      }
-      return bc.className;
-    }).join("/");
-    const contextNameForCommunication = this.contextNameForCommunication;
-    if (TaonHelpers__NS__isGoodPath(classConfig.path)) {
-      classConfig.calculatedPath = classConfig.path;
-    } else {
-      classConfig.calculatedPath = `${this.uriPathnameOrNothingIfRoot}/${apiPrefix}/${contextNameForCommunication}/tcp${parentsCalculatedPath}/${ClassHelpers__NS__getName(controllerClassFn)}`.replace(/\/\//g, "/").split("/").reduce((acc, bc) => {
-        return ___NS__last(acc) === bc ? acc : [...acc, bc];
-      }, []).join("/");
-    }
-  }
-  //#endregion
-  //#region methods & getters / dedupe class configs
-  mergeControllerMethodsConfigs(rawConfigs, classConfig, controllerClassFn) {
-    const currentControllerMethodsConfig = classConfig.methods;
-    ___NS__slice(rawConfigs, 1).forEach((bc) => {
-      const parentControllerMethods = ___NS__cloneDeep(bc.methods);
-      for (const methodsName in parentControllerMethods) {
-        if (parentControllerMethods.hasOwnProperty(methodsName)) {
-          if (!currentControllerMethodsConfig[methodsName]) {
-            const methodConfig = parentControllerMethods[methodsName];
-            currentControllerMethodsConfig[methodsName] = methodConfig;
-          }
-        }
-      }
-    });
-  }
-  //#endregion
-  async initControllersHook(ctxStorage) {
-    if (this.isRunOrRevertOnlyMigrationAppStart) {
-      return;
-    }
-    const allControllers = this.getClassFunByArr(Models__NS__ClassType.CONTROLLER);
-    for (const controllerClassFn of allControllers) {
-      const instance = this.getInstanceBy(
-        controllerClassFn
-      );
-      if (___NS__isFunction(instance.afterAllCtxInited)) {
-        await instance.afterAllCtxInited({ ctxStorage });
-      }
-    }
-  }
-  async initControllers() {
-    if (this.isRunOrRevertOnlyMigrationAppStart) {
-      return;
-    }
-    const allControllers = this.getClassFunByArr(Models__NS__ClassType.CONTROLLER);
-    for (const controllerClassFn of allControllers) {
-      controllerClassFn[Symbols__NS__classMethodsNames] = ClassHelpers__NS__getMethodsNames(controllerClassFn);
-      const rawConfigs = ClassHelpers__NS__getControllerConfigs(controllerClassFn);
-      const classConfig = rawConfigs[0];
-      this.updateCalculatedPathsForControllers(
-        rawConfigs,
-        classConfig,
-        controllerClassFn
-      );
-      this.mergeControllerMethodsConfigs(
-        rawConfigs,
-        classConfig,
-        controllerClassFn
-      );
-      classConfig.calculatedMiddlewaresControllerObj = {};
-      [...rawConfigs].reverse().forEach((rc) => {
-        if (___NS__isFunction(rc.middlewares)) {
-          classConfig.calculatedMiddlewaresControllerObj = rc.middlewares({
-            parentMiddlewares: classConfig.calculatedMiddlewaresControllerObj,
-            className(middlewareClass) {
-              return ClassHelpers__NS__getName(controllerClassFn);
+        `, 
+                // dataSourceDbConfig,
+                { 'this.connection': !!this.connection });
+                console.log(`Database file location: ${this.connection.options.database}`);
+            }
+            //     const entityMetadata = getMetadataArgsStorage();
+            //     console.log(
+            //       `
+            // entityMetadata after connection init for ${this.contextName} - ${this.mode}
+            // `,
+            //       entityMetadata,
+            //     );
+            //     debugger;
+        }
+        else {
+            Helpers__NS__info(`[taon][typeorm] Not initing db for mode ${this.mode}`);
+        }
+        //#endregion
+    }
+    //#endregion
+    //#region methods & getters / initialize metadata
+    //#region methods & getters / update class calculate path
+    updateCalculatedPathsForControllers(rawConfigs, classConfig, controllerClassFn) {
+        const parentsCalculatedPath = ___NS__slice(rawConfigs, 1)
+            .reverse()
+            .map(bc => {
+            if (TaonHelpers__NS__isGoodPath(bc.path)) {
+                return bc.path;
             }
-          });
-        }
-      });
-      if (!UtilsOs__NS__isRunningInCliMode()) {
-        this.logHttp && console.groupCollapsed(
-          `[taon][express-server] routes [${classConfig.className}]`
-        );
-      }
-      const methodNames = Object.keys(classConfig.methods);
-      for (const methodName of methodNames) {
-        const methodConfig = classConfig.methods[methodName];
-        let calculatedMiddlewaresMethodObj = {};
-        [...rawConfigs].reverse().forEach((rc) => {
-          if (rc.methods[methodName]) {
-            const parentMethodConfig = rc.methods[methodName];
-            if (___NS__isFunction(parentMethodConfig.middlewares)) {
-              calculatedMiddlewaresMethodObj = parentMethodConfig.middlewares({
-                parentMiddlewares: calculatedMiddlewaresMethodObj,
-                className(middlewareClass) {
-                  return ClassHelpers__NS__getName(controllerClassFn);
+            return bc.className;
+        })
+            .join('/');
+        const contextNameForCommunication = this.contextNameForCommunication;
+        if (TaonHelpers__NS__isGoodPath(classConfig.path)) {
+            classConfig.calculatedPath = classConfig.path;
+        }
+        else {
+            classConfig.calculatedPath = (`${this.uriPathnameOrNothingIfRoot}` +
+                `/${apiPrefix}/${contextNameForCommunication}/tcp${parentsCalculatedPath}/` +
+                `${ClassHelpers__NS__getName(controllerClassFn)}`)
+                .replace(/\/\//g, '/')
+                .split('/')
+                .reduce((acc, bc) => {
+                return ___NS__last(acc) === bc ? acc : [...acc, bc];
+            }, [])
+                .join('/');
+        }
+        // console.log('calculatedPath', classConfig.calculatedPath);
+    }
+    //#endregion
+    //#region methods & getters / dedupe class configs
+    mergeControllerMethodsConfigs(rawConfigs, classConfig, controllerClassFn) {
+        const currentControllerMethodsConfig = classConfig.methods;
+        ___NS__slice(rawConfigs, 1).forEach(bc => {
+            const parentControllerMethods = ___NS__cloneDeep(bc.methods);
+            for (const methodsName in parentControllerMethods) {
+                if (parentControllerMethods.hasOwnProperty(methodsName)) {
+                    if (!currentControllerMethodsConfig[methodsName]) {
+                        //#region add non existed method
+                        const methodConfig = parentControllerMethods[methodsName];
+                        currentControllerMethodsConfig[methodsName] = methodConfig;
+                        //#endregion
+                    }
                 }
-              });
             }
-          }
         });
-        methodConfig.calculatedMiddlewaresMethodObj = {
-          ...calculatedMiddlewaresMethodObj,
-          ...classConfig.calculatedMiddlewaresControllerObj
-        };
-        methodConfig.calculatedMiddlewares = Object.values(
-          methodConfig.calculatedMiddlewaresMethodObj || {}
-        );
-        const httpMethodType = methodConfig.type;
-        const globalPathPart = this.isRunningInsideDocker || !this.frontendHostUri?.origin?.includes("localhost") ? `${this.uriPathnameOrNothingIfRoot.replace(
-          /\/$/,
-          ""
-        )}/${apiPrefix}/${this.contextName}`.replace(/\/\//, "/") : "";
-        const expressPath = methodConfig.global ? `${globalPathPart}/${methodConfig.path?.replace(
-          /\/$/,
-          ""
-        )}`.replace(/\/\//, "/") : TaonHelpers__NS__getExpressPath(classConfig, methodConfig);
-        if (UtilsOs__NS__isNode || UtilsOs__NS__isWebSQL) {
-          const route = this.initServer(
-            httpMethodType,
-            methodConfig,
-            classConfig,
-            expressPath,
-            controllerClassFn
-          );
-          this.activeRoutes.push({
-            expressPath: route.expressPath,
-            method: route.method
-          });
-        }
-        const shouldInitClient = UtilsOs__NS__isBrowser || this.isRemoteHost || UtilsOs__NS__isWebSQL;
-        if (shouldInitClient) {
-          await this.initClient(
-            controllerClassFn,
-            httpMethodType,
-            methodConfig,
-            expressPath
-          );
-        }
-      }
-      if (!UtilsOs__NS__isRunningInCliMode()) {
-        this.logHttp && console.groupEnd();
-      }
-    }
-  }
-  //#endregion
-  //#region methods & getters / write active routes
-  writeActiveRoutes() {
-    if (this.isRemoteHost || this.isRunOrRevertOnlyMigrationAppStart) {
-      return;
-    }
-    const troutes = Utils__NS__uniqArray(
-      this.activeRoutes.map((f) => {
-        return `${f.method} ${f.expressPath}`;
-      })
-    ).map((f) => {
-      const [method, expressPath] = f.split(" ");
-      return `
-### ${___NS__startCase(___NS__last(expressPath.split("/")))}
-` + TaonHelpers__NS__fillUpTo(method.toUpperCase() + " ", 10) + this.uriOrigin + expressPath;
-    });
-    const routes = [
-      ...["", `#  ROUTES FOR HOST ${this.uriOrigin} `],
-      ...troutes
-    ].join("\n");
-    const fileName = crossPlatformPath([
-      //#region @backend
-      process.cwd(),
-      //#endregion
-      `routes/routes-${this.config.contextName}.rest`
-    ]);
-    this.logFramework && console.log(`[taon] routes file: ${fileName} `);
-    this.logRoutes && console.log(routes);
-    if (!UtilsOs__NS__isElectron && !this.skipWritingServerRoutes) {
-      Helpers__NS__writeFile(fileName, routes);
-    }
-  }
-  //#endregion
-  //#region methods & getters / middlewares
-  get middlewares() {
-    return this.config.middlewares || [];
-  }
-  //#endregion
-  //#region methods & getters / init middlewares
-  async initCustomClientMiddlewares() {
-    const middlewares = this.getClassesInstancesArrBy(
-      Models__NS__ClassType.MIDDLEWARE
-    ).map((f) => f).filter((f) => ___NS__isFunction(f.interceptClient));
-    middlewares.forEach((middlewareInstanceName) => {
-      const contextName = this.contextName;
-      const interceptorName = `${contextName}-${ClassHelpers__NS__getName(
-        middlewareInstanceName
-      )}`;
-      Resource.request.interceptors.set(interceptorName, {
-        intercept: ({ req, next }) => {
-          const url = new URL(req.url);
-          if (url.pathname.startsWith(
-            `${this.uriPathnameOrNothingIfRoot}/${apiPrefix}/${contextName}/`
-          )) {
-            return middlewareInstanceName.interceptClient({
-              req,
-              next
+    }
+    //#endregion
+    async initControllersHook(ctxStorage) {
+        if (this.isRunOrRevertOnlyMigrationAppStart) {
+            return;
+        }
+        const allControllers = this.getClassFunByArr(Models__NS__ClassType.CONTROLLER);
+        for (const controllerClassFn of allControllers) {
+            const instance = this.getInstanceBy(controllerClassFn);
+            if (___NS__isFunction(instance.afterAllCtxInited)) {
+                await instance.afterAllCtxInited({ ctxStorage });
+            }
+        }
+    }
+    async initControllers() {
+        if (this.isRunOrRevertOnlyMigrationAppStart) {
+            return;
+        }
+        const allControllers = this.getClassFunByArr(Models__NS__ClassType.CONTROLLER);
+        // debugger
+        // console.log('allControllers', allControllers);
+        for (const controllerClassFn of allControllers) {
+            // console.log(ClassHelpers__NS__getClassConfig(controllerClassFn));
+            // const controllerName = ClassHelpers__NS__getName(controllerClassFn);
+            // console.log(
+            //   `for ${controllerName}`,
+            //   ClassHelpers__NS__getClassConfig(controllerClassFn),
+            // );
+            controllerClassFn[Symbols__NS__classMethodsNames] =
+                ClassHelpers__NS__getMethodsNames(controllerClassFn);
+            const rawConfigs = ClassHelpers__NS__getControllerConfigs(controllerClassFn);
+            // console.log(controllerName, { rawConfigs });
+            // console.log(`Class config for ${ClassHelpers__NS__getName(controllerClassFn)}`, configs)
+            const classConfig = rawConfigs[0];
+            this.updateCalculatedPathsForControllers(rawConfigs, classConfig, controllerClassFn);
+            this.mergeControllerMethodsConfigs(rawConfigs, classConfig, controllerClassFn);
+            //#region combine middlewares from controllers
+            classConfig.calculatedMiddlewaresControllerObj = {};
+            [...rawConfigs].reverse().forEach(rc => {
+                if (___NS__isFunction(rc.middlewares)) {
+                    classConfig.calculatedMiddlewaresControllerObj = rc.middlewares({
+                        parentMiddlewares: classConfig.calculatedMiddlewaresControllerObj,
+                        className(middlewareClass) {
+                            return ClassHelpers__NS__getName(controllerClassFn);
+                        },
+                    });
+                }
             });
-          }
-          return next.handle(req);
-        }
-      });
-    });
-  }
-  async initCustomBackendMiddlewares() {
-    const app = this.expressApp;
-    const middlewares = this.getClassesInstancesArrBy(
-      Models__NS__ClassType.MIDDLEWARE
-    );
-    for (const middleware of middlewares) {
-      const middlewareInstance = middleware;
-      if (___NS__isFunction(middlewareInstance.interceptServer)) {
-        const middlewareFn = ClassHelpers__NS__asyncHandler(
-          async (req, res, next) => {
-            if (req.originalUrl.startsWith(
-              `${this.uriPathnameOrNothingIfRoot}/${apiPrefix}/${this.contextName}/`
-            )) {
-              await middlewareInstance.interceptServer({
-                req,
-                res,
-                next
-              });
-            } else {
-              next();
+            //#endregion
+            //#region group start
+            //#region @backend
+            if (!UtilsOs__NS__isRunningInCliMode()) {
+                //#endregion
+                this.logHttp &&
+                    console.groupCollapsed(`[taon][express-server] routes [${classConfig.className}]`);
+                //#region @backend
             }
-          }
-        );
-        app.use(middlewareFn);
-      }
-    }
-  }
-  async initBackendMiddlewares() {
-    const app = this.expressApp;
-    this.expressApp.get("/helloworld", (req, res) => {
-      res.send(`Hello, world from context ${this.contextName}`);
-    });
-    app.use(bodyParser.urlencoded({ extended: true }));
-    app.use(bodyParser.json());
-    app.use(methodOverride());
-    app.use(cookieParser());
-    if (this.session) {
-      Helpers__NS__info(
-        "[taon][express-server] session enabled for this context " + this.contextName
-      );
-      const { cookieMaxAge } = this.session;
-      const frontendHost = this.config.frontendHost;
-      const sessionObj = {
-        frontendHost,
-        secret: "mysecretsessioncookithing",
-        saveUninitialized: true,
-        cookieMaxAge,
-        secure: frontendHost.startsWith("https://"),
-        resave: false
-      };
-      app.use(
-        cors({
-          credentials: true,
-          origin: frontendHost
-        })
-      );
-      app.use(expressSession(sessionObj));
-      console.log(`
+            //#endregion
+            //#endregion
+            //#region init client or server methods
+            const methodNames = Object.keys(classConfig.methods);
+            for (const methodName of methodNames) {
+                const methodConfig = classConfig.methods[methodName];
+                //#region combine all class methods middlewares
+                let calculatedMiddlewaresMethodObj = {};
+                [...rawConfigs].reverse().forEach(rc => {
+                    if (rc.methods[methodName]) {
+                        const parentMethodConfig = rc.methods[methodName];
+                        if (___NS__isFunction(parentMethodConfig.middlewares)) {
+                            calculatedMiddlewaresMethodObj = parentMethodConfig.middlewares({
+                                parentMiddlewares: calculatedMiddlewaresMethodObj,
+                                className(middlewareClass) {
+                                    return ClassHelpers__NS__getName(controllerClassFn);
+                                },
+                            });
+                        }
+                    }
+                });
+                // add class middlewares to method middlewares
+                methodConfig.calculatedMiddlewaresMethodObj = {
+                    ...calculatedMiddlewaresMethodObj,
+                    ...classConfig.calculatedMiddlewaresControllerObj,
+                };
+                methodConfig.calculatedMiddlewares = Object.values(methodConfig.calculatedMiddlewaresMethodObj || {});
+                //#endregion
+                // methodConfig.calculatedMiddlewares = TODO
+                //#region initialized method express path
+                const httpMethodType = methodConfig.type;
+                // this is quick fix - in docker global path should not be used
+                const globalPathPart = this.isRunningInsideDocker ||
+                    !this.frontendHostUri?.origin?.includes('localhost') // fe with domain -> is in docker
+                    ? `${this.uriPathnameOrNothingIfRoot.replace(/\/$/, '')}/${apiPrefix}/${this.contextName}`.replace(/\/\//, '/')
+                    : '';
+                const expressPath = methodConfig.global
+                    ? `${globalPathPart}/${methodConfig.path?.replace(/\/$/, '')}`.replace(/\/\//, '/')
+                    : TaonHelpers__NS__getExpressPath(classConfig, methodConfig);
+                //#endregion
+                //#region init server
+                // console.log({ expressPath });
+                if (UtilsOs__NS__isNode || UtilsOs__NS__isWebSQL) {
+                    //#region @websql
+                    const route = this.initServer(httpMethodType, methodConfig, classConfig, expressPath, controllerClassFn);
+                    this.activeRoutes.push({
+                        expressPath: route.expressPath,
+                        method: route.method,
+                    });
+                    //#endregion
+                }
+                //#endregion
+                //#region init client
+                const shouldInitClient = UtilsOs__NS__isBrowser || this.isRemoteHost || UtilsOs__NS__isWebSQL;
+                // console.log('shouldInitClient', shouldInitClient);
+                if (shouldInitClient) {
+                    // console.log(
+                    //   'initClient',
+                    //   ClassHelpers__NS__getFullInternalName(controllerClassFn),
+                    //   type,
+                    //   methodConfig,
+                    //   expressPath,
+                    // );
+                    await this.initClient(controllerClassFn, httpMethodType, methodConfig, expressPath);
+                }
+                //#endregion
+            }
+            //#endregion
+            //#region group end
+            //#region @backend
+            if (!UtilsOs__NS__isRunningInCliMode()) {
+                //#endregion
+                this.logHttp && console.groupEnd();
+                //#region @backend
+            }
+            //#endregion
+            //#endregion
+        }
+    }
+    //#endregion
+    //#region methods & getters / write active routes
+    writeActiveRoutes() {
+        if (this.isRemoteHost || this.isRunOrRevertOnlyMigrationAppStart) {
+            return;
+        }
+        // const contexts: EndpointContext[] = [this];
+        //#region @websql
+        const troutes = Utils__NS__uniqArray(this.activeRoutes.map(f => {
+            return `${f.method} ${f.expressPath}`;
+        })).map(f => {
+            const [method, expressPath] = f.split(' ');
+            return (`\n### ${___NS__startCase(___NS__last(expressPath.split('/')))}\n` +
+                TaonHelpers__NS__fillUpTo(method.toUpperCase() + ' ', 10) +
+                this.uriOrigin +
+                expressPath);
+            // return `${TaonHelpers.string(method.toUpperCase() + ':')
+            // .fillUpTo(10)}${context.uriHref.replace(/\/$/, '')}${expressPath}`
+        });
+        const routes = [
+            ...['', `#  ROUTES FOR HOST ${this.uriOrigin} `],
+            ...troutes,
+        ].join('\n');
+        const fileName = crossPlatformPath([
+            //#region @backend
+            process.cwd(),
+            //#endregion
+            `routes/routes-${this.config.contextName}.rest`,
+        ]);
+        this.logFramework && console.log(`[taon] routes file: ${fileName} `);
+        this.logRoutes && console.log(routes);
+        //#region @backend
+        if (!UtilsOs__NS__isElectron && !this.skipWritingServerRoutes) {
+            Helpers__NS__writeFile(fileName, routes);
+        }
+        //#endregion
+        //#endregion
+    }
+    //#endregion
+    //#region methods & getters / middlewares
+    get middlewares() {
+        //#region @backendFunc
+        return this.config.middlewares || [];
+        //#endregion
+    }
+    //#endregion
+    //#region methods & getters / init middlewares
+    async initCustomClientMiddlewares() {
+        const middlewares = this.getClassesInstancesArrBy(Models__NS__ClassType.MIDDLEWARE)
+            .map(f => f)
+            .filter(f => ___NS__isFunction(f.interceptClient));
+        middlewares.forEach(middlewareInstanceName => {
+            const contextName = this.contextName;
+            const interceptorName = `${contextName}-${ClassHelpers__NS__getName(middlewareInstanceName)}`;
+            Resource.request.interceptors.set(interceptorName, {
+                intercept: ({ req, next }) => {
+                    const url = new URL(req.url);
+                    if (url.pathname.startsWith(`${this.uriPathnameOrNothingIfRoot}/${apiPrefix}/${contextName}/`)) {
+                        // console.log('intercepting', url.pathname, req);
+                        return middlewareInstanceName.interceptClient({
+                            req,
+                            next,
+                        });
+                    }
+                    return next.handle(req);
+                },
+            });
+        });
+    }
+    async initCustomBackendMiddlewares() {
+        //#region @backend
+        const app = this.expressApp;
+        const middlewares = this.getClassesInstancesArrBy(Models__NS__ClassType.MIDDLEWARE);
+        for (const middleware of middlewares) {
+            const middlewareInstance = middleware;
+            if (___NS__isFunction(middlewareInstance.interceptServer)) {
+                const middlewareFn = ClassHelpers__NS__asyncHandler(async (req, res, next) => {
+                    if (req.originalUrl.startsWith(`${this.uriPathnameOrNothingIfRoot}/${apiPrefix}/${this.contextName}/`)) {
+                        await middlewareInstance.interceptServer({
+                            req,
+                            res,
+                            next,
+                        });
+                    }
+                    else {
+                        next();
+                    }
+                });
+                app.use(middlewareFn);
+            }
+        }
+        //#endregion
+    }
+    async initBackendMiddlewares() {
+        //#region @backend
+        const app = this.expressApp;
+        // if (this.middlewares) {
+        //   this.middlewares.forEach(m => {
+        //     const [fun, args] = m;
+        //     app.use(fun.apply(null, args));
+        //   });
+        // }
+        this.expressApp.get('/helloworld', (req, res) => {
+            res.send(`Hello, world from context ${this.contextName}`);
+        });
+        // app.use(fileUpload());
+        app.use(bodyParser.urlencoded({ extended: true }));
+        app.use(bodyParser.json());
+        app.use(methodOverride());
+        app.use(cookieParser());
+        if (this.session) {
+            Helpers__NS__info('[taon][express-server] session enabled for this context ' +
+                this.contextName);
+            const { cookieMaxAge } = this.session;
+            const frontendHost = this.config.frontendHost;
+            const sessionObj = {
+                frontendHost,
+                secret: 'mysecretsessioncookithing',
+                saveUninitialized: true,
+                cookieMaxAge,
+                secure: frontendHost.startsWith('https://'),
+                resave: false,
+            };
+            app.use(cors({
+                credentials: true,
+                origin: frontendHost,
+            }));
+            app.use(expressSession(sessionObj));
+            console.log(`
 
       CORS ENABLED FOR SESSION
 
       `);
-    } else {
-      this.logHttp && Helpers__NS__info(
-        `[taon][express-server] session not enabled for this context '${this.contextName}'`
-      );
-      app.use(
-        cors({
-          // origin: "http://localhost:5555",
-          // methods: ["GET", "POST"],
-          // allowedHeaders: ["my-custom-header"],
-          // credentials: true
-        })
-      );
-      this.logHttp && console.log(`
+        }
+        else {
+            // if(this.config?.serverLogs) {
+            this.logHttp &&
+                Helpers__NS__info(`[taon][express-server] session not enabled for this context '${this.contextName}'`);
+            // }
+            app.use(cors({
+            // origin: "http://localhost:5555",
+            // methods: ["GET", "POST"],
+            // allowedHeaders: ["my-custom-header"],
+            // credentials: true
+            }));
+            this.logHttp &&
+                console.log(`
 
       CORS ENABLED WITHOUT SESSION
 
       `);
+        }
+        (() => {
+            app.use((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__NS__old.X_TOTAL_COUNT,
+                    Symbols__NS__old.MAPPING_CONFIG_HEADER,
+                    Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY,
+                    Symbols__NS__old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM,
+                ].join(', '));
+                next();
+            });
+        })();
+        //#endregion
     }
-    (() => {
-      app.use((req, res, next) => {
-        res.set(
-          "Access-Control-Expose-Headers",
-          [
-            "Content-Type",
-            "Authorization",
-            "X-Requested-With",
-            Symbols__NS__old.X_TOTAL_COUNT,
-            Symbols__NS__old.MAPPING_CONFIG_HEADER,
-            Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY,
-            Symbols__NS__old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM
-          ].join(", ")
-        );
-        next();
-      });
-    })();
-  }
-  //#endregion
-  //#region methods & getters / init methods node
-  initServer(httpMethodType, methodConfig, classConfig, expressPath, target) {
-    const middlewareHandlers = methodConfig.calculatedMiddlewares.map((middlewareClassFun) => {
-      const middlewareInstance = this.getInstanceBy(
-        middlewareClassFun
-      );
-      if (middlewareInstance && ___NS__isFunction(middlewareInstance.interceptServerMethod)) {
-        const middlewareFn = ClassHelpers__NS__asyncHandler(
-          async (req, res, next) => {
-            await middlewareInstance.interceptServerMethod(
-              {
-                req,
-                res,
-                next
-              },
-              {
-                methodName: methodConfig.methodName,
-                expressPath,
-                httpRequestType: methodConfig.type
-              }
-            );
-          }
-        );
-        return middlewareFn;
-      }
-    }).filter((f) => !!f);
-    const getResult = async (resolvedParams, req, res) => {
-      const response = methodConfig.descriptor.value.apply(
-        /**
-         * Context for method @GET,@PUT etc.
-         */
-        this.getInstanceBy(target),
-        /**
-         * Params for method @GET, @PUT etc.
-         */
-        resolvedParams
-      );
-      let result = await getResponseValue(response, { req, res });
-      return result;
-    };
-    if (UtilsOs__NS__isElectron) {
-      const ipcKeyName = TaonHelpers__NS__ipcKeyNameRequest(
-        target,
-        methodConfig,
-        expressPath
-      );
-      ipcMain.on(ipcKeyName, async (event, paramsFromBrowser) => {
-        const responseJsonData = await getResult(
-          paramsFromBrowser,
-          void 0,
-          void 0
-        );
-        const sendToIpsMainOn = TaonHelpers__NS__ipcKeyNameResponse(
-          target,
-          methodConfig,
-          expressPath
-        );
-        event.sender.send(sendToIpsMainOn, responseJsonData);
-      });
-      return {
-        expressPath,
-        method: methodConfig.type
-      };
-    }
-    if (!this.isRemoteHost) {
-      if (UtilsOs__NS__isWebSQL) {
-        if (!this.expressApp[httpMethodType.toLowerCase()]) {
-          this.expressApp[httpMethodType.toLowerCase()] = () => {
-          };
-        }
-      }
-      this.expressApp[httpMethodType.toLowerCase()](
-        expressPath,
-        ...middlewareHandlers,
-        async (req, res) => {
-          const args = [];
-          let tBody = req.body;
-          let tParams = req.params;
-          let tQuery = req.query;
-          if (req.headers[Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY]) {
-            try {
-              tBody = JSON.parse(
-                JSON.stringify(tBody),
-                JSON.parse(
-                  TaonHelpers__NS__firstStringOrElemFromArray(
-                    req.headers[Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY]
-                  )
-                )
-              );
-            } catch (e) {
+    //#endregion
+    //#region methods & getters / init methods node
+    initServer(
+    //#region parameters
+    httpMethodType, methodConfig, classConfig, expressPath, target) {
+        //#region resolve variables
+        // console.log(
+        //   `CLIENT: expressPath: "${expressPath}" interceptor for method: ${methodConfig.calculatedMiddlewares.length}`,
+        // );
+        const middlewareHandlers = methodConfig.calculatedMiddlewares
+            .map(middlewareClassFun => {
+            const middlewareInstance = this.getInstanceBy(middlewareClassFun);
+            if (middlewareInstance &&
+                ___NS__isFunction(middlewareInstance.interceptServerMethod)) {
+                const middlewareFn = ClassHelpers__NS__asyncHandler(async (req, res, next) => {
+                    await middlewareInstance.interceptServerMethod({
+                        req,
+                        res,
+                        next,
+                    }, {
+                        methodName: methodConfig.methodName,
+                        expressPath,
+                        httpRequestType: methodConfig.type,
+                    });
+                });
+                return middlewareFn;
             }
-          }
-          if (req.headers[Symbols__NS__old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM]) {
-            try {
-              tQuery = JSON.parse(
-                JSON.stringify(tQuery),
-                JSON.parse(
-                  TaonHelpers__NS__firstStringOrElemFromArray(
-                    req.headers[Symbols__NS__old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM]
-                  )
-                )
-              );
-            } catch (e) {
-            }
-          }
-          if (req.headers[Symbols__NS__old.MAPPING_CONFIG_HEADER_BODY_PARAMS]) {
-            try {
-              const entity = JSON.parse(
-                TaonHelpers__NS__firstStringOrElemFromArray(
-                  req.headers[Symbols__NS__old.MAPPING_CONFIG_HEADER_BODY_PARAMS]
-                )
-              );
-              tBody = Mapping__NS__encode(tBody, entity);
-            } catch (e) {
-            }
-          } else {
-            Object.keys(tBody).forEach((paramName) => {
-              try {
-                const entityForParam = JSON.parse(
-                  TaonHelpers__NS__firstStringOrElemFromArray(
-                    req.headers[`${Symbols__NS__old.MAPPING_CONFIG_HEADER_BODY_PARAMS}${paramName} `]
-                  )
-                );
-                tBody[paramName] = Mapping__NS__encode(
-                  tBody[paramName],
-                  entityForParam
-                );
-              } catch (e) {
-              }
+        })
+            .filter(f => !!f);
+        // const url = this.uri;
+        //#region get result
+        const getResult = async (resolvedParams, req, res) => {
+            const response = methodConfig.descriptor.value.apply(
+            /**
+             * Context for method @GET,@PUT etc.
+             */
+            this.getInstanceBy(target), 
+            /**
+             * Params for method @GET, @PUT etc.
+             */
+            resolvedParams);
+            let result = await getResponseValue(response, { req, res });
+            return result;
+        };
+        //#endregion
+        // console.log(`BACKEND: expressPath: "${expressPath}" `);
+        //#endregion
+        if (UtilsOs__NS__isElectron) {
+            //#region @backend
+            const ipcKeyName = TaonHelpers__NS__ipcKeyNameRequest(target, methodConfig, expressPath);
+            ipcMain.on(ipcKeyName, async (event, paramsFromBrowser) => {
+                const responseJsonData = await getResult(paramsFromBrowser, void 0, void 0);
+                const sendToIpsMainOn = TaonHelpers__NS__ipcKeyNameResponse(target, methodConfig, expressPath);
+                // console.log({ sendToIpsMainOn });
+                event.sender.send(sendToIpsMainOn, responseJsonData);
             });
-          }
-          if (req.headers[Symbols__NS__old.MAPPING_CONFIG_HEADER_QUERY_PARAMS]) {
-            try {
-              const entity = JSON.parse(
-                TaonHelpers__NS__firstStringOrElemFromArray(
-                  req.headers[Symbols__NS__old.MAPPING_CONFIG_HEADER_QUERY_PARAMS]
-                )
-              );
-              tQuery = TaonHelpers__NS__parseJSONwithStringJSONs(
-                Mapping__NS__encode(tQuery, entity)
-              );
-            } catch (e) {
+            return {
+                expressPath,
+                method: methodConfig.type,
+            };
+            //#endregion
+        }
+        if (!this.isRemoteHost) {
+            //#region apply dummy websql express routers
+            //#region @websql
+            if (UtilsOs__NS__isWebSQL) {
+                if (!this.expressApp[httpMethodType.toLowerCase()]) {
+                    this.expressApp[httpMethodType.toLowerCase()] = () => { };
+                    // TODO add middlewares for WEBSQL and ELECTRON mode
+                }
             }
-          } else {
-            Object.keys(tQuery).forEach((queryParamName) => {
-              try {
-                const entityForParam = JSON.parse(
-                  TaonHelpers__NS__firstStringOrElemFromArray(
-                    req.headers[`${Symbols__NS__old.MAPPING_CONFIG_HEADER_QUERY_PARAMS}${queryParamName} `]
-                  )
-                );
-                let beforeTransofrm = tQuery[queryParamName];
-                if (___NS__isString(beforeTransofrm)) {
-                  try {
-                    const paresed = TaonHelpers__NS__tryTransformParam(beforeTransofrm);
-                    beforeTransofrm = paresed;
-                  } catch (e) {
-                  }
+            //#endregion
+            //#endregion
+            //#region @backend
+            // this.logHttp &&
+            //   console.log(`[${httpMethodType.toUpperCase()}] ${expressPath} `);
+            this.expressApp[httpMethodType.toLowerCase()](expressPath, ...middlewareHandlers, async (req, res) => {
+                // console.log(`[${type.toUpperCase()}] ${expressPath} `);
+                //#region process params
+                const args = [];
+                let tBody = req.body;
+                let tParams = req.params;
+                let tQuery = req.query;
+                if (req.headers[Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY]) {
+                    try {
+                        tBody = JSON.parse(JSON.stringify(tBody), JSON.parse(TaonHelpers__NS__firstStringOrElemFromArray(req.headers[Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY])));
+                    }
+                    catch (e) { }
+                }
+                if (req.headers[Symbols__NS__old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM]) {
+                    try {
+                        tQuery = JSON.parse(JSON.stringify(tQuery), JSON.parse(TaonHelpers__NS__firstStringOrElemFromArray(req.headers[Symbols__NS__old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM])));
+                    }
+                    catch (e) { }
+                }
+                // make class instance from body
+                // console.log('req.headers', req.headers)
+                if (req.headers[Symbols__NS__old.MAPPING_CONFIG_HEADER_BODY_PARAMS]) {
+                    try {
+                        const entity = JSON.parse(TaonHelpers__NS__firstStringOrElemFromArray(req.headers[Symbols__NS__old.MAPPING_CONFIG_HEADER_BODY_PARAMS]));
+                        tBody = Mapping__NS__encode(tBody, entity);
+                    }
+                    catch (e) { }
+                }
+                else {
+                    Object.keys(tBody).forEach(paramName => {
+                        try {
+                            const entityForParam = JSON.parse(TaonHelpers__NS__firstStringOrElemFromArray(req.headers[`${Symbols__NS__old.MAPPING_CONFIG_HEADER_BODY_PARAMS}${paramName} `]));
+                            tBody[paramName] = Mapping__NS__encode(tBody[paramName], entityForParam);
+                        }
+                        catch (e) { }
+                    });
+                }
+                // make class instance from query params
+                // console.log('req.headers', tQuery)
+                if (req.headers[Symbols__NS__old.MAPPING_CONFIG_HEADER_QUERY_PARAMS]) {
+                    try {
+                        const entity = JSON.parse(TaonHelpers__NS__firstStringOrElemFromArray(req.headers[Symbols__NS__old.MAPPING_CONFIG_HEADER_QUERY_PARAMS]));
+                        tQuery = TaonHelpers__NS__parseJSONwithStringJSONs(Mapping__NS__encode(tQuery, entity));
+                    }
+                    catch (e) { }
+                }
+                else {
+                    Object.keys(tQuery).forEach(queryParamName => {
+                        try {
+                            const entityForParam = JSON.parse(TaonHelpers__NS__firstStringOrElemFromArray(req.headers[`${Symbols__NS__old.MAPPING_CONFIG_HEADER_QUERY_PARAMS}${queryParamName} `]));
+                            let beforeTransofrm = tQuery[queryParamName];
+                            if (___NS__isString(beforeTransofrm)) {
+                                try {
+                                    const paresed = TaonHelpers__NS__tryTransformParam(beforeTransofrm);
+                                    beforeTransofrm = paresed;
+                                }
+                                catch (e) { }
+                            }
+                            const afterEncoding = Mapping__NS__encode(beforeTransofrm, entityForParam);
+                            tQuery[queryParamName] =
+                                TaonHelpers__NS__parseJSONwithStringJSONs(afterEncoding);
+                        }
+                        catch (e) { }
+                    });
+                }
+                Object.keys(methodConfig.parameters).forEach(paramName => {
+                    let 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);
+                        }
+                    }
+                });
+                //#endregion
+                const resolvedParams = args
+                    .reverse()
+                    .map(v => TaonHelpers__NS__tryTransformParam(v));
+                try {
+                    let result = await getResult(resolvedParams, req, res);
+                    if (methodConfig.responseType)
+                        if (res.headersSent) {
+                            // SKIP FURTHER PROCESSING IF RESPONSE ALREADY SENT
+                            return;
+                        }
+                    if (methodConfig.overrideExpressSendAsHtml) {
+                        res.setHeader('Content-Type', 'text/html');
+                        res.send(result);
+                        return;
+                    }
+                    if (result instanceof Blob &&
+                        methodConfig.responseType ===
+                            'blob') {
+                        // console.log('INSTANCE OF BLOB')
+                        //#region processs blob result type
+                        const blob = result;
+                        const file = Buffer.from(await blob.arrayBuffer());
+                        res.writeHead(200, {
+                            'Content-Type': blob.type,
+                            'Content-Length': file.length,
+                        });
+                        res.end(file);
+                        //#endregion
+                    }
+                    else if (___NS__isString(result) &&
+                        methodConfig.responseType ===
+                            'blob') {
+                        // console.log('BASE64')
+                        //#region process string buffer TODO refacetor
+                        const img_base64 = result;
+                        const m = /^data:(.+?);base64,(.+)$/.exec(img_base64);
+                        if (!m) {
+                            throw new Error(`[taon - framework] Not a base64 image[${img_base64}]`);
+                        }
+                        const [_, content_type, file_base64] = m;
+                        const file = Buffer.from(file_base64, 'base64');
+                        res.writeHead(200, {
+                            'Content-Type': content_type,
+                            'Content-Length': file.length,
+                        });
+                        res.end(file);
+                        //#endregion
+                    }
+                    else {
+                        //#region process json request
+                        await EntityProcess.init(result, res);
+                        //#endregion
+                    }
+                }
+                catch (error) {
+                    if (res.headersSent) {
+                        // SKIP FURTHER PROCESSING IF RESPONSE ALREADY SENT
+                        return;
+                    }
+                    if (methodConfig.overrideExpressSendAsHtml) {
+                        res.setHeader('Content-Type', 'text/html');
+                        res.send(error);
+                        return;
+                    }
+                    this.sendError(res, error, req, expressPath);
                 }
-                const afterEncoding = Mapping__NS__encode(
-                  beforeTransofrm,
-                  entityForParam
-                );
-                tQuery[queryParamName] = TaonHelpers__NS__parseJSONwithStringJSONs(afterEncoding);
-              } catch (e) {
-              }
             });
-          }
-          Object.keys(methodConfig.parameters).forEach((paramName) => {
-            let 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);
-              }
-            }
-          });
-          const resolvedParams = args.reverse().map((v) => TaonHelpers__NS__tryTransformParam(v));
-          try {
-            let result = await getResult(resolvedParams, req, res);
-            if (methodConfig.responseType) {
-              if (res.headersSent) {
-                return;
-              }
-            }
-            if (methodConfig.overrideExpressSendAsHtml) {
-              res.setHeader("Content-Type", "text/html");
-              res.send(result);
-              return;
-            }
-            if (result instanceof Blob && methodConfig.responseType === "blob") {
-              const blob = result;
-              const file = Buffer.from(await blob.arrayBuffer());
-              res.writeHead(200, {
-                "Content-Type": blob.type,
-                "Content-Length": file.length
-              });
-              res.end(file);
-            } else if (___NS__isString(result) && methodConfig.responseType === "blob") {
-              const img_base64 = result;
-              const m = /^data:(.+?);base64,(.+)$/.exec(img_base64);
-              if (!m) {
-                throw new Error(
-                  `[taon - framework] Not a base64 image[${img_base64}]`
-                );
-              }
-              const [_, content_type, file_base64] = m;
-              const file = Buffer.from(file_base64, "base64");
-              res.writeHead(200, {
-                "Content-Type": content_type,
-                "Content-Length": file.length
-              });
-              res.end(file);
-            } else {
-              await EntityProcess.init(result, res);
-            }
-          } catch (error) {
-            if (res.headersSent) {
-              return;
-            }
-            if (methodConfig.overrideExpressSendAsHtml) {
-              res.setHeader("Content-Type", "text/html");
-              res.send(error);
-              return;
-            }
-            this.sendError(res, error, req, expressPath);
-          }
-        }
-      );
-    }
-    return {
-      expressPath,
-      method: methodConfig.type
-    };
-  }
-  //#endregion
-  //#region methods & getters / send error
-  sendError(res, error, req, expressPath) {
-    let status = 500;
-    let message = "Internal Server Error";
-    let details = void 0;
-    let success = false;
-    let code = void 0;
-    if (typeof error === "function") {
-      const obj = error(res) || {};
-      status = obj.status || 400;
-      message = obj.message;
-      details = obj.details;
-      code = obj.code;
-    } else if (typeof error === "string") {
-      message = error;
-      status = 400;
-    } else if (error instanceof Error) {
-      message = error.message;
-      details = process.env.NODE_ENV !== "production" ? error.stack : void 0;
-    } else {
-      message = "Unexpected error";
-      details = error;
-    }
-    res.status(status).json({
-      success,
-      message,
-      details,
-      code,
-      [CoreModels__NS__TaonHttpErrorCustomProp]: true
-    });
-  }
-  //#endregion
-  //#region methods & getters / init client
-  /**
-   * client can be browser or nodejs (when remote host)
-   */
-  async initClient(target, httpRequestType, methodConfig, expressPath) {
-    const ctx = this;
-    const middlewares = methodConfig.calculatedMiddlewares;
-    const middlewaresInstances = middlewares.map((f) => this.getInstanceBy(f)).filter((f) => ___NS__isFunction(f.interceptClientMethod));
-    middlewaresInstances.forEach((instance) => {
-      const middlewareName = ClassHelpers__NS__getName(instance);
-      const interceptorKey = `${middlewareName}-${methodConfig.type?.toUpperCase()}-${expressPath}`;
-      Resource.request.methodsInterceptors.set(interceptorKey, {
-        intercept: ({ req, next }) => {
-          return instance.interceptClientMethod(
-            {
-              req,
-              next
-            },
-            {
-              methodName: methodConfig.methodName,
-              expressPath,
-              httpRequestType
-            }
-          );
-        }
-      });
-    });
-    const storage = globalThis;
-    const orgMethods = target.prototype[methodConfig.methodName];
-    if (UtilsOs__NS__isElectron) {
-      const ipcRenderer = window.require("electron").ipcRenderer;
-      target.prototype[methodConfig.methodName] = function(...args) {
-        const received = new Promise(async (resolve, reject) => {
-          const headers = {};
-          const { request, response } = TaonHelpers__NS__websqlMocks(headers);
-        });
-        received["observable"] = from(received);
+            //#endregion
+        }
         return {
-          received,
-          request(axiosConfig) {
-            return received;
-          }
+            expressPath: expressPath,
+            method: methodConfig.type,
         };
-      };
-      return;
-    }
-    target.prototype[methodConfig.methodName] = function(...args) {
-      if (!storage[Symbols__NS__old.ENDPOINT_META_CONFIG])
-        storage[Symbols__NS__old.ENDPOINT_META_CONFIG] = {};
-      if (!storage[Symbols__NS__old.ENDPOINT_META_CONFIG][ctx.uriOrigin])
-        storage[Symbols__NS__old.ENDPOINT_META_CONFIG][ctx.uriOrigin] = {};
-      const endpoints = storage[Symbols__NS__old.ENDPOINT_META_CONFIG];
-      let rest;
-      if (!endpoints[ctx.uriOrigin][expressPath]) {
-        let headers = {};
-        if (methodConfig.contentType && !methodConfig.responseType) {
-          rest = Resource.create(
-            ctx.uriOrigin,
-            expressPath,
-            Symbols__NS__old.MAPPING_CONFIG_HEADER,
-            Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY,
-            RestHeaders.from({
-              "Content-Type": methodConfig.contentType,
-              Accept: methodConfig.contentType
-            })
-          );
-        } else if (methodConfig.contentType && methodConfig.responseType) {
-          rest = Resource.create(
-            ctx.uriOrigin,
-            expressPath,
-            Symbols__NS__old.MAPPING_CONFIG_HEADER,
-            Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY,
-            RestHeaders.from({
-              "Content-Type": methodConfig.contentType,
-              Accept: methodConfig.contentType,
-              responsetypeaxios: methodConfig.responseType
-            })
-          );
-        } else if (!methodConfig.contentType && methodConfig.responseType) {
-          rest = Resource.create(
-            ctx.uriOrigin,
-            expressPath,
-            Symbols__NS__old.MAPPING_CONFIG_HEADER,
-            Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY,
-            RestHeaders.from({
-              responsetypeaxios: methodConfig.responseType
-            })
-          );
-        } else {
-          rest = Resource.create(
-            ctx.uriOrigin,
-            expressPath,
-            Symbols__NS__old.MAPPING_CONFIG_HEADER,
-            Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY
-          );
-        }
-        endpoints[ctx.uriOrigin][expressPath] = rest;
-      } else {
-        rest = endpoints[ctx.uriOrigin][expressPath];
-      }
-      const method = httpRequestType.toLowerCase();
-      const pathPrams = {};
-      let queryParams = {};
-      let bodyObject = {};
-      args.forEach((param, i) => {
-        let currentParam = void 0;
-        for (let pp in methodConfig.parameters) {
-          let v = methodConfig.parameters[pp];
-          if (v.index === i) {
-            currentParam = v;
-            break;
-          }
-        }
-        if (!currentParam) {
-          const errorMessage = `[${config.frameworkName}] Unable to resolve parameter at index ${i} for method ${methodConfig.methodName} at path ${expressPath}.`;
-          console.error(errorMessage);
-          process.exit(0);
-          throw new Error(errorMessage);
-        }
-        if (currentParam.paramType === "Path") {
-          pathPrams[currentParam.paramName] = param;
-        }
-        if (currentParam.paramType === "Query") {
-          if (currentParam.paramName) {
-            const mapping = Mapping__NS__decode(param, !ctx.isProductionMode);
-            if (mapping) {
-              rest.headers.set(
-                `${Symbols__NS__old.MAPPING_CONFIG_HEADER_QUERY_PARAMS}${currentParam.paramName} `,
-                JSON.stringify(mapping)
-              );
-            }
-            queryParams[currentParam.paramName] = param;
-          } else {
-            const mapping = Mapping__NS__decode(param, !ctx.isProductionMode);
-            if (mapping) {
-              rest.headers.set(
-                Symbols__NS__old.MAPPING_CONFIG_HEADER_QUERY_PARAMS,
-                JSON.stringify(mapping)
-              );
-            }
-            queryParams = ___NS__cloneDeep(param);
-          }
-        }
-        if (currentParam.paramType === "Header") {
-          if (currentParam.paramName) {
-            if (currentParam.paramName === Symbols__NS__old.MDC_KEY) {
-              rest.headers.set(
-                currentParam.paramName,
-                encodeURIComponent(JSON.stringify(param))
-              );
-            } else {
-              rest.headers.set(currentParam.paramName, param);
+    }
+    //#endregion
+    //#region methods & getters / send error
+    sendError(res, error, req, expressPath) {
+        //#region @backendFunc
+        let status = 500;
+        let message = 'Internal Server Error';
+        let details = undefined;
+        let success = false;
+        let code = undefined;
+        if (typeof error === 'function') {
+            const obj = error(res) || {};
+            status = obj.status || 400;
+            message = obj.message;
+            details = obj.details;
+            code = obj.code;
+        }
+        else if (typeof error === 'string') {
+            message = error;
+            status = 400;
+        }
+        else if (error instanceof Error) {
+            message = error.message;
+            details = process.env.NODE_ENV !== 'production' ? error.stack : undefined;
+        }
+        else {
+            message = 'Unexpected error';
+            details = error;
+        }
+        res.status(status).json({
+            success,
+            message,
+            details,
+            code,
+            [CoreModels__NS__TaonHttpErrorCustomProp]: true,
+        });
+        //#endregion
+    }
+    //#endregion
+    //#region methods & getters / init client
+    /**
+     * client can be browser or nodejs (when remote host)
+     */
+    async initClient(target, httpRequestType, methodConfig, // Models.Http.Rest.MethodConfig,
+    expressPath) {
+        const ctx = this;
+        // console.log(
+        //   `CLIENT: expressPath: "${expressPath}" interceptor for method: ${methodConfig.calculatedMiddlewares?.length} `,
+        // );
+        //#region init middlewares
+        const middlewares = methodConfig.calculatedMiddlewares;
+        const middlewaresInstances = middlewares
+            .map(f => this.getInstanceBy(f))
+            .filter(f => ___NS__isFunction(f.interceptClientMethod));
+        middlewaresInstances.forEach(instance => {
+            const middlewareName = ClassHelpers__NS__getName(instance);
+            // middlewareName - only needed for inheritace and uniqness of interceptors
+            const interceptorKey = `${middlewareName}-${methodConfig.type?.toUpperCase()}-${expressPath}`;
+            Resource.request.methodsInterceptors.set(interceptorKey, {
+                intercept: ({ req, next }) => {
+                    return instance.interceptClientMethod({
+                        req,
+                        next,
+                    }, {
+                        methodName: methodConfig.methodName,
+                        expressPath,
+                        httpRequestType: httpRequestType,
+                    });
+                },
+            });
+        });
+        //#endregion
+        // : { received: any; /* Rest<any, any>  */ }
+        // this.logHttp &&
+        //   console.log(`${httpRequestType?.toUpperCase()} ${expressPath} `);
+        // console.log('INITING', methodConfig); // TODO inject in static
+        //#region resolve storage
+        // TODO not a good idea
+        const storage = globalThis;
+        //#endregion
+        const orgMethods = target.prototype[methodConfig.methodName];
+        //#region handle electron ipc request
+        if (UtilsOs__NS__isElectron) {
+            const ipcRenderer = window.require('electron').ipcRenderer;
+            target.prototype[methodConfig.methodName] = function (...args) {
+                const received = new Promise(async (resolve, reject) => {
+                    const headers = {};
+                    const { request, response } = TaonHelpers__NS__websqlMocks(headers);
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                });
+                received['observable'] = from(received);
+                return {
+                    received,
+                    request(axiosConfig) {
+                        return received;
+                    },
+                };
+            };
+            return;
+        }
+        //#endregion
+        //#region handling web sql request
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        //#endregion
+        //#region handle normal request
+        target.prototype[methodConfig.methodName] = function (...args) {
+            // console.log('[init method browser] FRONTEND expressPath', expressPath)
+            // const productionMode = FrameworkContext.isProductionMode;
+            //#region resolve frontend parameters
+            if (!storage[Symbols__NS__old.ENDPOINT_META_CONFIG])
+                storage[Symbols__NS__old.ENDPOINT_META_CONFIG] = {};
+            if (!storage[Symbols__NS__old.ENDPOINT_META_CONFIG][ctx.uriOrigin])
+                storage[Symbols__NS__old.ENDPOINT_META_CONFIG][ctx.uriOrigin] = {};
+            const endpoints = storage[Symbols__NS__old.ENDPOINT_META_CONFIG];
+            let rest;
+            if (!endpoints[ctx.uriOrigin][expressPath]) {
+                let headers = {};
+                if (methodConfig.contentType && !methodConfig.responseType) {
+                    rest = Resource.create(ctx.uriOrigin, expressPath, Symbols__NS__old.MAPPING_CONFIG_HEADER, Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY, RestHeaders.from({
+                        'Content-Type': methodConfig.contentType,
+                        Accept: methodConfig.contentType,
+                    }));
+                }
+                else if (methodConfig.contentType && methodConfig.responseType) {
+                    rest = Resource.create(ctx.uriOrigin, expressPath, Symbols__NS__old.MAPPING_CONFIG_HEADER, Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY, RestHeaders.from({
+                        'Content-Type': methodConfig.contentType,
+                        Accept: methodConfig.contentType,
+                        responsetypeaxios: methodConfig.responseType,
+                    }));
+                }
+                else if (!methodConfig.contentType && methodConfig.responseType) {
+                    rest = Resource.create(ctx.uriOrigin, expressPath, Symbols__NS__old.MAPPING_CONFIG_HEADER, Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY, RestHeaders.from({
+                        responsetypeaxios: methodConfig.responseType,
+                    }));
+                }
+                else {
+                    rest = Resource.create(ctx.uriOrigin, expressPath, Symbols__NS__old.MAPPING_CONFIG_HEADER, Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY);
+                }
+                endpoints[ctx.uriOrigin][expressPath] = rest;
             }
-          } else {
-            for (let header in param) {
-              rest.headers.set(header, param[header]);
+            else {
+                rest = endpoints[ctx.uriOrigin][expressPath];
             }
-          }
-        }
-        if (currentParam.paramType === "Cookie") {
-          Resource.Cookies.write(
-            currentParam.paramName,
-            param,
-            currentParam.expireInSeconds
-          );
-        }
-        if (currentParam.paramType === "Body") {
-          if (currentParam.paramName) {
-            if (ClassHelpers__NS__getName(bodyObject) === "FormData") {
-              throw new Error(`[taon - framework] Don use param names when posting / putting FormData.
+            const method = httpRequestType.toLowerCase();
+            const pathPrams = {};
+            let queryParams = {};
+            let bodyObject = {};
+            args.forEach((param, i) => {
+                let currentParam = void 0;
+                for (let pp in methodConfig.parameters) {
+                    let v = methodConfig.parameters[pp];
+                    if (v.index === i) {
+                        currentParam = v;
+                        break;
+                    }
+                }
+                if (!currentParam) {
+                    const errorMessage = `[${config.frameworkName}] Unable to resolve parameter` +
+                        ` at index ${i} for method ${methodConfig.methodName} at path ${expressPath}.`;
+                    //#region @backend
+                    console.error(errorMessage);
+                    process.exit(0);
+                    //#endregion
+                    throw new Error(errorMessage);
+                }
+                if (currentParam.paramType === 'Path') {
+                    pathPrams[currentParam.paramName] = param;
+                }
+                if (currentParam.paramType === 'Query') {
+                    if (currentParam.paramName) {
+                        const mapping = Mapping__NS__decode(param, !ctx.isProductionMode);
+                        if (mapping) {
+                            rest.headers.set(`${Symbols__NS__old.MAPPING_CONFIG_HEADER_QUERY_PARAMS}${currentParam.paramName} `, JSON.stringify(mapping));
+                        }
+                        queryParams[currentParam.paramName] = param;
+                    }
+                    else {
+                        const mapping = Mapping__NS__decode(param, !ctx.isProductionMode);
+                        if (mapping) {
+                            rest.headers.set(Symbols__NS__old.MAPPING_CONFIG_HEADER_QUERY_PARAMS, JSON.stringify(mapping));
+                        }
+                        queryParams = ___NS__cloneDeep(param);
+                    }
+                }
+                if (currentParam.paramType === 'Header') {
+                    if (currentParam.paramName) {
+                        if (currentParam.paramName === Symbols__NS__old.MDC_KEY) {
+                            // parese MDC
+                            rest.headers.set(currentParam.paramName, encodeURIComponent(JSON.stringify(param)));
+                        }
+                        else {
+                            rest.headers.set(currentParam.paramName, param);
+                        }
+                    }
+                    else {
+                        for (let header in param) {
+                            rest.headers.set(header, param[header]);
+                        }
+                    }
+                }
+                if (currentParam.paramType === 'Cookie') {
+                    Resource.Cookies.write(currentParam.paramName, param, currentParam.expireInSeconds);
+                }
+                if (currentParam.paramType === 'Body') {
+                    if (currentParam.paramName) {
+                        if (ClassHelpers__NS__getName(bodyObject) === 'FormData') {
+                            throw new Error(`[taon - framework] Don use param names when posting / putting FormData.
               Use this:
 // ...
 (@Taon.Http.Param.Body() formData: FormData) ...
@@ -1970,64 +2349,49 @@ instead
   (@Taon.Http.Param.Body('${currentParam.paramName}') formData: FormData) ...
 // ...
 `);
+                        }
+                        const mapping = Mapping__NS__decode(param, !ctx.isProductionMode);
+                        if (mapping) {
+                            rest.headers.set(`${Symbols__NS__old.MAPPING_CONFIG_HEADER_BODY_PARAMS}${currentParam.paramName} `, JSON.stringify(mapping));
+                        }
+                        bodyObject[currentParam.paramName] = param;
+                    }
+                    else {
+                        const mapping = Mapping__NS__decode(param, !ctx.isProductionMode);
+                        if (mapping) {
+                            rest.headers.set(Symbols__NS__old.MAPPING_CONFIG_HEADER_BODY_PARAMS, JSON.stringify(mapping));
+                        }
+                        bodyObject = param;
+                    }
+                }
+            });
+            if (typeof bodyObject === 'object' &&
+                ClassHelpers__NS__getName(bodyObject) !== 'FormData') {
+                let circuralFromItem = [];
+                bodyObject = JSON10.parse(JSON10.stringify(bodyObject, void 0, void 0, circs => {
+                    circuralFromItem = circs;
+                }));
+                rest.headers.set(Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY, JSON10.stringify(circuralFromItem));
             }
-            const mapping = Mapping__NS__decode(param, !ctx.isProductionMode);
-            if (mapping) {
-              rest.headers.set(
-                `${Symbols__NS__old.MAPPING_CONFIG_HEADER_BODY_PARAMS}${currentParam.paramName} `,
-                JSON.stringify(mapping)
-              );
-            }
-            bodyObject[currentParam.paramName] = param;
-          } else {
-            const mapping = Mapping__NS__decode(param, !ctx.isProductionMode);
-            if (mapping) {
-              rest.headers.set(
-                Symbols__NS__old.MAPPING_CONFIG_HEADER_BODY_PARAMS,
-                JSON.stringify(mapping)
-              );
+            if (typeof queryParams === 'object') {
+                let circuralFromQueryParams = [];
+                queryParams = JSON10.parse(JSON10.stringify(queryParams, void 0, void 0, circs => {
+                    circuralFromQueryParams = circs;
+                }));
+                rest.headers.set(Symbols__NS__old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM, JSON10.stringify(circuralFromQueryParams));
             }
-            bodyObject = param;
-          }
-        }
-      });
-      if (typeof bodyObject === "object" && ClassHelpers__NS__getName(bodyObject) !== "FormData") {
-        let circuralFromItem = [];
-        bodyObject = JSON10.parse(
-          JSON10.stringify(bodyObject, void 0, void 0, (circs) => {
-            circuralFromItem = circs;
-          })
-        );
-        rest.headers.set(
-          Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY,
-          JSON10.stringify(circuralFromItem)
-        );
-      }
-      if (typeof queryParams === "object") {
-        let circuralFromQueryParams = [];
-        queryParams = JSON10.parse(
-          JSON10.stringify(queryParams, void 0, void 0, (circs) => {
-            circuralFromQueryParams = circs;
-          })
-        );
-        rest.headers.set(
-          Symbols__NS__old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM,
-          JSON10.stringify(circuralFromQueryParams)
-        );
-      }
-      const httpResultObj = {
-        get received() {
-          return rest.model(pathPrams)[method](bodyObject, [queryParams]);
-        },
-        request(axiosConfig) {
-          return rest.model(pathPrams)[method](bodyObject, [queryParams], axiosConfig);
-        }
-      };
-      return httpResultObj;
-    };
-  }
-  //#endregion
+            //#endregion
+            const httpResultObj = {
+                get received() {
+                    return rest.model(pathPrams)[method](bodyObject, [queryParams]);
+                },
+                request(axiosConfig) {
+                    return rest
+                        .model(pathPrams)[method](bodyObject, [queryParams], axiosConfig);
+                },
+            };
+            return httpResultObj;
+        };
+        //#endregion
+    }
 }
-export {
-  EndpointContext
-};