taon 21.0.52 → 21.0.53

package/lib-prod/endpoint-context.js

@@ -0,0 +1,2033 @@
+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";
+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(`
+
+        ASSIGNING AUTO GENERATED DATABASE CONFIG
+
+        `);
+      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(`
+
+          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 `
+
+            host is required for context initialization..
+            (Or maybe you forgot mark ${this.config.contextName} context as abstract?)
+
+          `;
+        }
+        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(`
+
+
+         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(`
+
+          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(`
+          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));
+            }
+          }
+          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;
+      }
+    }
+    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},
+    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},
+    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());
+            }
+          }
+          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}"
+
+        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.
+
+      // ...
+      await Context.initialize();
+      // ...
+
+
+      `);
+    }
+  }
+  //#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);
+        });
+      });
+      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(
+          `
+
+        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);
+            }
+          });
+        }
+      });
+      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);
+                }
+              });
+            }
+          }
+        });
+        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
+            });
+          }
+          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();
+            }
+          }
+        );
+        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(`
+
+      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(`
+
+      CORS ENABLED WITHOUT SESSION
+
+      `);
+    }
+    (() => {
+      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) {
+            }
+          }
+          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) {
+              }
+            });
+          }
+          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);
+              }
+            }
+          });
+          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);
+        return {
+          received,
+          request(axiosConfig) {
+            return received;
+          }
+        };
+      };
+      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);
+            }
+          } 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) ...
+// ...
+
+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)
+        );
+      }
+      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
+}
+export {
+  EndpointContext
+};