taon 21.0.18 → 21.0.29

package/lib-prod/endpoint-context.js

@@ -0,0 +1,2416 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndpointContext = void 0;
+const url_1 = require("url"); // @backend
+const axios_1 = require("axios");
+const bodyParser = require("body-parser"); // @backend
+const cookieParser = require("cookie-parser"); // @backend
+const cors = require("cors"); // @backend
+const electron_1 = require("electron"); // @backend
+const express = require("express");
+//  multer in taon middleware will do better job than express-fileupload
+// import * as fileUpload from 'express-fileupload'; // @backend
+const expressSession = require("express-session"); // @backend
+const lib_prod_1 = require("json10/lib-prod");
+const lib_prod_2 = require("lodash-walk-object/lib-prod");
+const methodOverride = require("method-override"); // @backend
+const lib_prod_3 = require("ng2-rest/lib-prod");
+const rxjs_1 = require("rxjs");
+const lib_prod_4 = require("taon-typeorm/lib-prod"); // @websql
+const lib_prod_5 = require("taon-typeorm/lib-prod"); // @websql
+const lib_prod_6 = require("taon-typeorm/lib-prod");
+const lib_prod_7 = require("tnp-core/lib-prod");
+const lib_prod_8 = require("tnp-core/lib-prod");
+const lib_prod_9 = require("tnp-core/lib-prod"); // @backend
+const lib_prod_10 = require("tnp-core/lib-prod");
+const lib_prod_11 = require("tnp-core/lib-prod");
+const lib_prod_12 = require("tnp-core/lib-prod");
+const lib_prod_13 = require("tnp-core/lib-prod");
+const constants_1 = require("./constants");
+const context_db_migrations_1 = require("./context-db-migrations");
+const di_container_1 = require("./dependency-injection/di-container");
+const entity_process_1 = require("./entity-process");
+const get_response_value_1 = require("./get-response-value");
+const class_helpers_1 = require("./helpers/class-helpers");
+const taon_helpers_1 = require("./helpers/taon-helpers");
+const models_1 = require("./models");
+const realtime_core_1 = require("./realtime/realtime-core");
+const symbols_1 = require("./symbols");
+/* */
+//#endregion
+class EndpointContext {
+    originalConfig;
+    configFn;
+    cloneOptions;
+    //#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 context_db_migrations_1.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 = 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_1.Models.ClassType.CONTROLLER,
+        models_1.Models.ClassType.PROVIDER,
+        models_1.Models.ClassType.MIDDLEWARE,
+        models_1.Models.ClassType.REPOSITORY,
+        models_1.Models.ClassType.SUBSCRIBER,
+        models_1.Models.ClassType.MIGRATION,
+    ];
+    //#endregion
+    //#region fields / all types from contexts
+    allTypesfromContexts = [
+        ...this.injectableTypesfromContexts,
+        models_1.Models.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 = undefined;
+    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 (lib_prod_12._.isObject(this.config?.logs)) {
+            return !!this.config.logs.http;
+        }
+        return this.config?.logs === true;
+    }
+    get logRealtime() {
+        if (lib_prod_12._.isObject(this.config?.logs)) {
+            return !!this.config.logs.realtime;
+        }
+        return this.config?.logs === true;
+    }
+    get logFramework() {
+        if (lib_prod_12._.isObject(this.config?.logs)) {
+            return !!this.config.logs.framework;
+        }
+        return this.config?.logs === true;
+    }
+    get logRoutes() {
+        if (lib_prod_12._.isObject(this.config?.logs)) {
+            return !!this.config.logs.routes;
+        }
+        return this.config?.logs === true;
+    }
+    get logDb() {
+        if (lib_prod_12._.isObject(this.config?.logs)) {
+            return !!this.config.logs.db;
+        }
+        return this.config?.logs === true;
+    }
+    get logMigrations() {
+        if (lib_prod_12._.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;
+    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;
+        this.cloneOptions = this.cloneOptions || {};
+        this.isRunningInsideDocker = lib_prod_10.UtilsOs.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 (lib_prod_12._.isObject(this.config.database)) {
+            this.config.database = models_1.Models.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://')) {
+            lib_prod_12.Helpers.throw(`[taon-config] Your${this.host ? ' remote' : ''} 'host' must start with http:// or https://`);
+        }
+        if (lib_prod_12._.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 = lib_prod_12._.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}
+        //   Helpers.isElectron: ${Helpers.isElectron}
+        //   `)
+        if (this.config.useIpcWhenElectron && lib_prod_12.Helpers.isElectron) {
+            if (lib_prod_12.Helpers.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`;
+            lib_prod_12.Helpers.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 (lib_prod_12._.isObject(this.config.database)) {
+            this.logFramework &&
+                console.log(`
+
+        OVERRIDE DATABASE CONFIG FROM CONFIGURATION
+
+        `);
+            this.databaseConfig = this.getAutoGeneratedConfig();
+            lib_prod_2.walk.Object(this.config.database, (value, lodashPath) => {
+                if (lib_prod_12._.isNil(value) || lib_prod_12._.isFunction(value) || lib_prod_12._.isObject(value)) {
+                    // skipping
+                }
+                else {
+                    this.logFramework &&
+                        console.info(`Overriding database config: ${lodashPath}=${value}`);
+                    lib_prod_12._.set(this.databaseConfig, lodashPath, value);
+                }
+            }, {
+                walkGetters: false,
+            });
+        }
+        //#endregion
+        //#region resolve session
+        if (this.config.session) {
+            this.session = lib_prod_12._.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_1.default.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_1.Models.ClassType.ENTITY)),
+            ...this.config.entities,
+        };
+        this.config.controllers = {
+            ...(await this.getRecrusiveClassesfromContextsObj(models_1.Models.ClassType.CONTROLLER)),
+            ...this.config.controllers,
+        };
+        this.config.providers = {
+            ...(await this.getRecrusiveClassesfromContextsObj(models_1.Models.ClassType.PROVIDER)),
+            ...this.config.providers,
+        };
+        this.config.middlewares = {
+            ...(await this.getRecrusiveClassesfromContextsObj(models_1.Models.ClassType.MIDDLEWARE)),
+            ...this.config.middlewares,
+        };
+        this.config.subscribers = {
+            ...(await this.getRecrusiveClassesfromContextsObj(models_1.Models.ClassType.SUBSCRIBER)),
+            ...this.config.subscribers,
+        };
+        this.config.repositories = {
+            ...(await this.getRecrusiveClassesfromContextsObj(models_1.Models.ClassType.REPOSITORY)),
+            ...this.config.repositories,
+        };
+        this.config.migrations = {
+            ...(await this.getRecrusiveClassesfromContextsObj(models_1.Models.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_1.Models.ClassType.CONTROLLER,
+        });
+        this.config.repositories = this.cloneClassesObjWithNewMetadata({
+            classesInput: this.config.repositories,
+            config: this.config,
+            ctx: this,
+            classType: models_1.Models.ClassType.REPOSITORY,
+        });
+        this.config.providers = this.cloneClassesObjWithNewMetadata({
+            classesInput: this.config.providers,
+            config: this.config,
+            ctx: this,
+            classType: models_1.Models.ClassType.PROVIDER,
+        });
+        this.config.middlewares = this.cloneClassesObjWithNewMetadata({
+            classesInput: this.config.middlewares,
+            config: this.config,
+            ctx: this,
+            classType: models_1.Models.ClassType.MIDDLEWARE,
+        });
+        this.config.subscribers = this.cloneClassesObjWithNewMetadata({
+            classesInput: this.config.subscribers,
+            config: this.config,
+            ctx: this,
+            classType: models_1.Models.ClassType.SUBSCRIBER,
+        });
+        this.config.migrations = this.cloneClassesObjWithNewMetadata({
+            classesInput: this.config.migrations,
+            config: this.config,
+            ctx: this,
+            classType: models_1.Models.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_1.Models.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 &&
+                    lib_prod_12.Helpers.info(`
+
+          Starting server ${shouldStartHttpsSecureServer ? 'with' : 'without'} HTTPS secure server
+
+          `);
+                this.serverTcpUdp = shouldStartHttpsSecureServer
+                    ? new lib_prod_9.https.Server({
+                        key: this.config.https?.key,
+                        cert: this.config.https?.cert,
+                    }, this.expressApp)
+                    : new lib_prod_9.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.isRunningInCliMode() && !_.isNil(this.config.disabledRealtime)) {
+                //   // TODO for now...
+                //   Helpers.logInfo(`Realtime disable on backend for cli mode`);
+                //   this.disabledRealtime = true;
+                // } else {
+                //   Helpers.logInfo(`Realtime enabled on backend`);
+                // }
+                //#endregion
+                this.logRealtime &&
+                    lib_prod_12.Helpers.info(`[ctx=${this.contextName}] Init Realtime for ${this.mode}`);
+                this.realtime = new realtime_core_1.RealtimeCore(this);
+            }
+            //#endregion
+        }
+        //#region show context info
+        // console.log({ ref })
+        if (this.config.abstract) {
+            this.logFramework &&
+                lib_prod_12.Helpers.info(`[taon] Create abstract context: ${this.config.contextName}`);
+        }
+        else {
+            if (this.isRemoteHost) {
+                this.logFramework &&
+                    lib_prod_12.Helpers.info(`[taon] Create context for remote host: ${this.config.host}`);
+            }
+            else {
+                this.logFramework &&
+                    lib_prod_12.Helpers.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}
+
+    `);
+        //#region @websqlFunc
+        let databaseConfig = models_1.Models.DatabaseConfig.from({});
+        const tcpUdpDatabaseSqliteRelativeFileLocation = `${models_1.Models.DatabasesFolder}/db-${this.contextName}.sqlite`;
+        if (this.isRunningInsideDocker) {
+            if (this.USE_MARIADB_MYSQL_IN_DOCKER) {
+                // Helpers.info('Running in docker, using in mysql database');
+                // // TODO auto resolve database config in docker
+                // databaseConfig = Models.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
+
+          `);
+                //#region @backend
+                const locationOfTheDatabase = (0, lib_prod_11.crossPlatformPath)([
+                    process.cwd(),
+                    `db-${this.contextName}.sqlite`,
+                ]);
+                //#endregion
+                databaseConfig = databaseConfig = models_1.Models.DatabaseConfig.from({
+                    location: tcpUdpDatabaseSqliteRelativeFileLocation,
+                    type: 'sqljs',
+                    useLocalForage: false,
+                    recreateMode: 'PRESERVE_DATA+MIGRATIONS',
+                    logging: true,
+                });
+                //#region @backend
+                if (!lib_prod_9.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: ${lib_prod_9.fse.existsSync(locationOfTheDatabase)}
+          synchronize: ${databaseConfig.synchronize}
+          dropSchema: ${databaseConfig.dropSchema}
+        `);
+                //#endregion
+            }
+        }
+        else {
+            //#region auto resolve db config
+            this.logFramework &&
+                lib_prod_12.Helpers.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 (lib_prod_10.UtilsOs.isElectron) {
+                        dbLocationInOs = (0, lib_prod_11.crossPlatformPath)([
+                            lib_prod_10.UtilsOs.getRealHomeDir(),
+                            `.taon/databases-for-electron-apps/${this.appId || lib_prod_12._.snakeCase(process.cwd()).replace(/\_/, '.')}/${this.contextName}.sqlite`,
+                        ]);
+                        if (!lib_prod_12.Helpers.exists(lib_prod_13.path.dirname(dbLocationInOs))) {
+                            lib_prod_12.Helpers.mkdirp(lib_prod_13.path.dirname(dbLocationInOs));
+                        }
+                    }
+                    //#endregion
+                    databaseConfig = models_1.Models.DatabaseConfig.from({
+                        location: lib_prod_10.UtilsOs.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_1.Models.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_1.Models.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
+    }
+    //#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 &&
+                            lib_prod_12.Helpers.log(`[ctx=${this.contextName}] Express server (inside docker) started 0.0.0.0:${this.uriPort}`);
+                        this.logFramework &&
+                            lib_prod_12.Helpers.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.displayRoutes(this.expressApp);
+                    this.serverTcpUdp.listen(Number(this.uriPort), () => {
+                        this.logFramework &&
+                            lib_prod_12.Helpers.log(`[ctx=${this.contextName}] Express server (inside nodejs app) started on localhost:${this.uriPort}`);
+                        this.logFramework &&
+                            lib_prod_12.Helpers.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 &&
+                lib_prod_12.Helpers.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 });
+                });
+            }
+        });
+        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 / clone class
+    cloneClassWithNewMetadata = ({ TaonBaseClass, className, config, ctx, classType, }) => {
+        // Return a new class that extends the base class
+        const cloneClass = () => {
+            if (TaonBaseClass[symbols_1.Symbols.fullClassNameStaticProperty] ===
+                `${ctx.contextName}.${className}`) {
+                return TaonBaseClass;
+            }
+            return class extends TaonBaseClass {
+                // static ['_'] = TaonBaseClass['_'];
+                // @ts-ignore
+                static [symbols_1.Symbols.orignalClass] = TaonBaseClass;
+                // @ts-ignore
+                static [symbols_1.Symbols.fullClassNameStaticProperty] = `${ctx.contextName}.${className}`;
+                // @ts-ignore
+                static [symbols_1.Symbols.classNameStaticProperty] = className;
+                static [symbols_1.Symbols.ctxInClassOrClassObj] = ctx;
+                // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+                static __getFullPathForClass__(arr = []) {
+                    const name = this[symbols_1.Symbols.fullClassNameStaticProperty];
+                    arr.push(name);
+                    // @ts-ignore
+                    if (this[symbols_1.Symbols.orignalClass] && // @ts-ignore
+                        this[symbols_1.Symbols.orignalClass].__getFullPathForClass__) {
+                        // @ts-ignore
+                        this[symbols_1.Symbols.orignalClass].__getFullPathForClass__(arr);
+                    }
+                    return arr.join('/');
+                }
+                static get fullPathForClass() {
+                    return this.__getFullPathForClass__();
+                }
+                [symbols_1.Symbols.ctxInClassOrClassObj] = ctx;
+            };
+        };
+        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 (_.isUndefined(cloneClassFunction[Symbols.orignalClassClonesObj])) {
+        //   cloneClassFunction[Symbols.orignalClassClonesObj] = {};
+        // }
+        // if (_.isUndefined(TaonBaseClass[Symbols.orignalClassClonesObj])) {
+        //   TaonBaseClass[Symbols.orignalClassClonesObj] = {};
+        // }
+        // const all = {
+        //   ...TaonBaseClass[Symbols.orignalClassClonesObj],
+        //   ...cloneClassFunction[Symbols.orignalClassClonesObj],
+        // };
+        // all[ctx.contextName] = cloneClassFunction;
+        // cloneClassFunction[Symbols.orignalClassClonesObj] = all;
+        // TaonBaseClass[Symbols.orignalClassClonesObj] = all;
+        //#endregion
+        return cloneClassFunction;
+    };
+    //#endregion
+    //#region methods & getters / clone classes obj with new metadata
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    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) {
+                lib_prod_12.Helpers.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_1.Symbols.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_1.Symbols.classNameStaticProperty] = className;
+            const clonedClass = this.cloneClassWithNewMetadata({
+                TaonBaseClass,
+                className,
+                config,
+                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[class_helpers_1.ClassHelpers.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 = class_helpers_1.ClassHelpers.getName(ctor);
+        const locaInstanceConstructorArgs = options.locaInstanceConstructorArgs || [];
+        if (this.isCLassType(models_1.Models.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 = lib_prod_12._.first(locaInstanceConstructorArgs);
+            const entity = entityFn && entityFn();
+            entityName = (entity && class_helpers_1.ClassHelpers.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.getName(options.parentInstanceThatWillGetInjectedStuff)} Inject ${className} instanceKey "${instanceKey}"`,
+                // );
+                return existed;
+            }
+            // console.log(
+            //   `NEW ${ClassHelpers.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;
+            // 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.getName(ctor);
+        //   const allControllers = this.getClassFunByArr(Models.ClassType.CONTROLLER);
+        //   // TODO QUICK_FIX cache controllers
+        //   for (const ctrl of allControllers) {
+        //     if (ClassHelpers.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 (lib_prod_12._.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_1.Models.ClassType.CONTROLLER:
+                return this.config.controllers;
+            case models_1.Models.ClassType.ENTITY:
+                return this.config.entities;
+            case models_1.Models.ClassType.PROVIDER:
+                return this.config.providers;
+            case models_1.Models.ClassType.MIDDLEWARE:
+                return this.config.middlewares;
+            case models_1.Models.ClassType.REPOSITORY:
+                return this.config.repositories;
+            case models_1.Models.ClassType.SUBSCRIBER:
+                return this.config.subscribers;
+            case models_1.Models.ClassType.MIGRATION:
+                return this.config.migrations;
+        }
+    }
+    isCLassType(classType, classFn) {
+        return !!this.getClassFunBy(classType)[class_helpers_1.ClassHelpers.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_1.Models.ClassTypeKey[classTypeName]];
+            if (classesForInjectableType[className]) {
+                return classesForInjectableType[className];
+            }
+        }
+    }
+    getClassFunByClass(classFunction) {
+        const className = class_helpers_1.ClassHelpers.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 = di_container_1.DITaonContainer.resolve(classFn);
+            const classInstancesByNameObj = this.classInstancesByNameObj[classType];
+            const className = class_helpers_1.ClassHelpers.getName(classFn);
+            // console.log({ classFn, classType, instance, place, className, 'classInstancesByNameObj': this.classInstancesByNameObj });
+            classInstancesByNameObj[className] = instance;
+            // update config
+            this.config[models_1.Models.ClassTypeKey[classType]][className] = classFn;
+            this.objWithClassesInstancesArr[classType].push(instance);
+            this.allClassesInstances[className] = instance;
+        }
+    }
+    //#endregion
+    //#region methods & getters / init classes
+    async initClasses() {
+        if (this.isRemoteHost) {
+            return;
+        }
+        //#region @websql
+        for (const classFun of this.getClassFunByArr(models_1.Models.ClassType.ENTITY)) {
+            const repo = (await this.connection.getRepository(class_helpers_1.ClassHelpers.getOrginalClass(classFun)));
+            this.repos.set(class_helpers_1.ClassHelpers.getName(classFun), repo);
+        }
+        //#endregion
+        for (const classTypeName of [
+            models_1.Models.ClassType.MIDDLEWARE,
+            models_1.Models.ClassType.PROVIDER,
+            models_1.Models.ClassType.REPOSITORY,
+            models_1.Models.ClassType.CONTROLLER,
+            models_1.Models.ClassType.ENTITY,
+            models_1.Models.ClassType.MIGRATION,
+        ]) {
+            //#region init class static _ property
+            for (const classFun of this.getClassFunByArr(classTypeName)) {
+                if (lib_prod_12._.isFunction(classFun._)) {
+                    await classFun._();
+                }
+            }
+            //#endregion
+        }
+        for (const classTypeName of [
+            models_1.Models.ClassType.MIDDLEWARE,
+            models_1.Models.ClassType.PROVIDER,
+            models_1.Models.ClassType.REPOSITORY,
+            models_1.Models.ClassType.CONTROLLER,
+            models_1.Models.ClassType.MIGRATION,
+        ]) {
+            //#region init providers, repositories  _ property
+            // Helpers.taskStarted(
+            //   `[taon] REINITING _ INS FN ${classTypeName} ${this.contextName} STARTED`,
+            // );
+            for (const ctrl of this.getClassesInstancesArrBy(classTypeName)) {
+                if (lib_prod_12._.isFunction(ctrl._)) {
+                    await ctrl._();
+                }
+            }
+            // Helpers.taskStarted(
+            //   `[taon] REINITING _ INS FN ${classTypeName} ${this.contextName} DONE`,
+            // );
+            //#endregion
+        }
+    }
+    //#endregion
+    //#region methods & getters / is active on
+    isActiveOn(classInstance) {
+        let contextRef = classInstance[symbols_1.Symbols.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_1.URL(url.replace(/\/$/, ''));
+        return uri;
+    }
+    get uri() {
+        const url = this.host ? new url_1.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_1.Models.ClassType.SUBSCRIBER);
+        for (const subscriberClassFn of subscriberClasses) {
+            const options = Reflect.getMetadata(symbols_1.Symbols.metadata.options.subscriber, subscriberClassFn);
+            // console.log('subscriber options', options);
+            // const nameForSubscriber = ClassHelpers.getName(subscriber);
+            (0, lib_prod_4.EventSubscriber)()(subscriberClassFn);
+        }
+        //#endregion
+    }
+    //#endregion
+    //#region methods & getters / init entities
+    async initEntities() {
+        //#region @websql
+        if (this.isRemoteHost) {
+            return;
+        }
+        const entities = this.getClassFunByArr(models_1.Models.ClassType.ENTITY);
+        for (const entity of entities) {
+            const options = Reflect.getMetadata(symbols_1.Symbols.metadata.options.entity, entity);
+            const createTable = lib_prod_12._.isUndefined(options.createTable)
+                ? true
+                : options.createTable;
+            const nameForEntity = class_helpers_1.ClassHelpers.getName(entity);
+            if (createTable) {
+                this.logDb &&
+                    console.info(`[taon][typeorm] create table for entity "${nameForEntity}" ? '${createTable}'`);
+                // console.log('TypeormEntity', { TypeormEntity });
+                (0, lib_prod_5.Entity)(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 / init connection
+    async initDatabaseConnection() {
+        //#region @websqlFunc
+        if (this.isRemoteHost || !this.databaseConfig) {
+            return;
+        }
+        const entities = this.getClassFunByArr(models_1.Models.ClassType.ENTITY).map(entityFn => {
+            return class_helpers_1.ClassHelpers.getOrginalClass(entityFn);
+        });
+        const subscribers = this.getClassFunByArr(models_1.Models.ClassType.SUBSCRIBER);
+        let autoSave = false;
+        if (!lib_prod_12._.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 = lib_prod_12._.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 &&
+                lib_prod_12.Helpers.info('[taon][database] prepare typeorm connection...');
+            try {
+                const connection = new lib_prod_6.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}`);
+            }
+            //     const entityMetadata = getMetadataArgsStorage();
+            //     console.log(
+            //       `
+            // entityMetadata after connection init for ${this.contextName} - ${this.mode}
+            // `,
+            //       entityMetadata,
+            //     );
+            //     debugger;
+        }
+        else {
+            lib_prod_12.Helpers.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 = lib_prod_12._.slice(rawConfigs, 1)
+            .reverse()
+            .map(bc => {
+            if (taon_helpers_1.TaonHelpers.isGoodPath(bc.path)) {
+                return bc.path;
+            }
+            return bc.className;
+        })
+            .join('/');
+        const contextNameForCommunication = this.contextNameForCommunication;
+        if (taon_helpers_1.TaonHelpers.isGoodPath(classConfig.path)) {
+            classConfig.calculatedPath = classConfig.path;
+        }
+        else {
+            classConfig.calculatedPath = (`${this.uriPathnameOrNothingIfRoot}` +
+                `/${constants_1.apiPrefix}/${contextNameForCommunication}/tcp${parentsCalculatedPath}/` +
+                `${class_helpers_1.ClassHelpers.getName(controllerClassFn)}`)
+                .replace(/\/\//g, '/')
+                .split('/')
+                .reduce((acc, bc) => {
+                return lib_prod_12._.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;
+        lib_prod_12._.slice(rawConfigs, 1).forEach(bc => {
+            const parentControllerMethods = lib_prod_12._.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
+                    }
+                }
+            }
+        });
+    }
+    //#endregion
+    async initControllersHook(ctxStorage) {
+        if (this.isRunOrRevertOnlyMigrationAppStart) {
+            return;
+        }
+        const allControllers = this.getClassFunByArr(models_1.Models.ClassType.CONTROLLER);
+        for (const controllerClassFn of allControllers) {
+            const instance = this.getInstanceBy(controllerClassFn);
+            if (lib_prod_12._.isFunction(instance.afterAllCtxInited)) {
+                await instance.afterAllCtxInited({ ctxStorage });
+            }
+        }
+    }
+    async initControllers() {
+        if (this.isRunOrRevertOnlyMigrationAppStart) {
+            return;
+        }
+        const allControllers = this.getClassFunByArr(models_1.Models.ClassType.CONTROLLER);
+        // debugger
+        // console.log('allControllers', allControllers);
+        for (const controllerClassFn of allControllers) {
+            // console.log(ClassHelpers.getClassConfig(controllerClassFn));
+            // const controllerName = ClassHelpers.getName(controllerClassFn);
+            // console.log(
+            //   `for ${controllerName}`,
+            //   ClassHelpers.getClassConfig(controllerClassFn),
+            // );
+            controllerClassFn[symbols_1.Symbols.classMethodsNames] =
+                class_helpers_1.ClassHelpers.getMethodsNames(controllerClassFn);
+            const rawConfigs = class_helpers_1.ClassHelpers.getControllerConfigs(controllerClassFn);
+            // console.log(controllerName, { rawConfigs });
+            // console.log(`Class config for ${ClassHelpers.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 (lib_prod_12._.isFunction(rc.middlewares)) {
+                    classConfig.calculatedMiddlewaresControllerObj = rc.middlewares({
+                        parentMiddlewares: classConfig.calculatedMiddlewaresControllerObj,
+                        className(middlewareClass) {
+                            return class_helpers_1.ClassHelpers.getName(controllerClassFn);
+                        },
+                    });
+                }
+            });
+            //#endregion
+            //#region group start
+            //#region @backend
+            if (!lib_prod_12.Helpers.isRunningIn.cliMode()) {
+                //#endregion
+                this.logHttp &&
+                    console.groupCollapsed(`[taon][express-server] routes [${classConfig.className}]`);
+                //#region @backend
+            }
+            //#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 (lib_prod_12._.isFunction(parentMethodConfig.middlewares)) {
+                            calculatedMiddlewaresMethodObj = parentMethodConfig.middlewares({
+                                parentMiddlewares: calculatedMiddlewaresMethodObj,
+                                className(middlewareClass) {
+                                    return class_helpers_1.ClassHelpers.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(/\/$/, '')}/${constants_1.apiPrefix}/${this.contextName}`.replace(/\/\//, '/')
+                    : '';
+                const expressPath = methodConfig.global
+                    ? `${globalPathPart}/${methodConfig.path?.replace(/\/$/, '')}`.replace(/\/\//, '/')
+                    : taon_helpers_1.TaonHelpers.getExpressPath(classConfig, methodConfig);
+                //#endregion
+                //#region init server
+                // console.log({ expressPath });
+                if (lib_prod_12.Helpers.isNode || lib_prod_12.Helpers.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 = lib_prod_12.Helpers.isBrowser || this.isRemoteHost || lib_prod_12.Helpers.isWebSQL;
+                // console.log('shouldInitClient', shouldInitClient);
+                if (shouldInitClient) {
+                    // console.log(
+                    //   'initClient',
+                    //   ClassHelpers.getFullInternalName(controllerClassFn),
+                    //   type,
+                    //   methodConfig,
+                    //   expressPath,
+                    // );
+                    await this.initClient(controllerClassFn, httpMethodType, methodConfig, expressPath);
+                }
+                //#endregion
+            }
+            //#endregion
+            //#region group end
+            //#region @backend
+            if (!lib_prod_12.Helpers.isRunningIn.cliMode()) {
+                //#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 = lib_prod_10.Utils.uniqArray(this.activeRoutes.map(f => {
+            return `${f.method} ${f.expressPath}`;
+        })).map(f => {
+            const [method, expressPath] = f.split(' ');
+            return (`\n### ${lib_prod_12._.startCase(lib_prod_12._.last(expressPath.split('/')))}\n` +
+                taon_helpers_1.TaonHelpers.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 = (0, lib_prod_11.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 (!lib_prod_10.UtilsOs.isElectron && !this.skipWritingServerRoutes) {
+            lib_prod_12.Helpers.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_1.Models.ClassType.MIDDLEWARE)
+            .map(f => f)
+            .filter(f => lib_prod_12._.isFunction(f.interceptClient));
+        middlewares.forEach(middlewareInstanceName => {
+            const contextName = this.contextName;
+            const interceptorName = `${contextName}-${class_helpers_1.ClassHelpers.getName(middlewareInstanceName)}`;
+            lib_prod_3.Resource.request.interceptors.set(interceptorName, {
+                intercept: ({ req, next }) => {
+                    const url = new url_1.URL(req.url);
+                    if (url.pathname.startsWith(`${this.uriPathnameOrNothingIfRoot}/${constants_1.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_1.Models.ClassType.MIDDLEWARE);
+        for (const middleware of middlewares) {
+            const middlewareInstance = middleware;
+            if (lib_prod_12._.isFunction(middlewareInstance.interceptServer)) {
+                const middlewareFn = class_helpers_1.ClassHelpers.asyncHandler(async (req, res, next) => {
+                    if (req.originalUrl.startsWith(`${this.uriPathnameOrNothingIfRoot}/${constants_1.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) {
+            lib_prod_12.Helpers.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 {
+            // if(this.config?.serverLogs) {
+            this.logHttp &&
+                lib_prod_12.Helpers.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_1.Symbols.old.X_TOTAL_COUNT,
+                    symbols_1.Symbols.old.MAPPING_CONFIG_HEADER,
+                    symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_BODY,
+                    symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM,
+                ].join(', '));
+                next();
+            });
+        })();
+        //#endregion
+    }
+    //#endregion
+    //#region methods & getters / init methods node
+    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 &&
+                lib_prod_12._.isFunction(middlewareInstance.interceptServerMethod)) {
+                const middlewareFn = class_helpers_1.ClassHelpers.asyncHandler(async (req, res, next) => {
+                    await middlewareInstance.interceptServerMethod({
+                        req,
+                        res,
+                        next,
+                    }, {
+                        methodName: methodConfig.methodName,
+                        expressPath,
+                        httpRequestType: methodConfig.type,
+                    });
+                });
+                return middlewareFn;
+            }
+        })
+            .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 (0, get_response_value_1.getResponseValue)(response, { req, res });
+            return result;
+        };
+        //#endregion
+        // console.log(`BACKEND: expressPath: "${expressPath}" `);
+        //#endregion
+        if (lib_prod_12.Helpers.isElectron) {
+            //#region @backend
+            const ipcKeyName = taon_helpers_1.TaonHelpers.ipcKeyNameRequest(target, methodConfig, expressPath);
+            electron_1.ipcMain.on(ipcKeyName, async (event, paramsFromBrowser) => {
+                const responseJsonData = await getResult(paramsFromBrowser, void 0, void 0);
+                const sendToIpsMainOn = taon_helpers_1.TaonHelpers.ipcKeyNameResponse(target, methodConfig, expressPath);
+                // console.log({ sendToIpsMainOn });
+                event.sender.send(sendToIpsMainOn, responseJsonData);
+            });
+            return {
+                expressPath,
+                method: methodConfig.type,
+            };
+            //#endregion
+        }
+        if (!this.isRemoteHost) {
+            //#region apply dummy websql express routers
+            //#region @websql
+            if (lib_prod_12.Helpers.isWebSQL) {
+                if (!this.expressApp[httpMethodType.toLowerCase()]) {
+                    this.expressApp[httpMethodType.toLowerCase()] = () => { };
+                    // TODO add middlewares for WEBSQL and ELECTRON mode
+                }
+            }
+            //#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_1.Symbols.old.CIRCURAL_OBJECTS_MAP_BODY]) {
+                    try {
+                        tBody = JSON.parse(JSON.stringify(tBody), JSON.parse(taon_helpers_1.TaonHelpers.firstStringOrElemFromArray(req.headers[symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_BODY])));
+                    }
+                    catch (e) { }
+                }
+                if (req.headers[symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM]) {
+                    try {
+                        tQuery = JSON.parse(JSON.stringify(tQuery), JSON.parse(taon_helpers_1.TaonHelpers.firstStringOrElemFromArray(req.headers[symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM])));
+                    }
+                    catch (e) { }
+                }
+                // make class instance from body
+                // console.log('req.headers', req.headers)
+                if (req.headers[symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS]) {
+                    try {
+                        const entity = JSON.parse(taon_helpers_1.TaonHelpers.firstStringOrElemFromArray(req.headers[symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS]));
+                        tBody = lib_prod_3.Mapping.encode(tBody, entity);
+                    }
+                    catch (e) { }
+                }
+                else {
+                    Object.keys(tBody).forEach(paramName => {
+                        try {
+                            const entityForParam = JSON.parse(taon_helpers_1.TaonHelpers.firstStringOrElemFromArray(req.headers[`${symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS}${paramName} `]));
+                            tBody[paramName] = lib_prod_3.Mapping.encode(tBody[paramName], entityForParam);
+                        }
+                        catch (e) { }
+                    });
+                }
+                // make class instance from query params
+                // console.log('req.headers', tQuery)
+                if (req.headers[symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS]) {
+                    try {
+                        const entity = JSON.parse(taon_helpers_1.TaonHelpers.firstStringOrElemFromArray(req.headers[symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS]));
+                        tQuery = taon_helpers_1.TaonHelpers.parseJSONwithStringJSONs(lib_prod_3.Mapping.encode(tQuery, entity));
+                    }
+                    catch (e) { }
+                }
+                else {
+                    Object.keys(tQuery).forEach(queryParamName => {
+                        try {
+                            const entityForParam = JSON.parse(taon_helpers_1.TaonHelpers.firstStringOrElemFromArray(req.headers[`${symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS}${queryParamName} `]));
+                            let beforeTransofrm = tQuery[queryParamName];
+                            if (lib_prod_12._.isString(beforeTransofrm)) {
+                                try {
+                                    const paresed = taon_helpers_1.TaonHelpers.tryTransformParam(beforeTransofrm);
+                                    beforeTransofrm = paresed;
+                                }
+                                catch (e) { }
+                            }
+                            const afterEncoding = lib_prod_3.Mapping.encode(beforeTransofrm, entityForParam);
+                            tQuery[queryParamName] =
+                                taon_helpers_1.TaonHelpers.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 => taon_helpers_1.TaonHelpers.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 (lib_prod_12._.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 entity_process_1.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);
+                }
+            });
+            //#endregion
+        }
+        return {
+            expressPath: expressPath,
+            method: methodConfig.type,
+        };
+    }
+    //#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,
+            [lib_prod_8.CoreModels.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 => lib_prod_12._.isFunction(f.interceptClientMethod));
+        middlewaresInstances.forEach(instance => {
+            const middlewareName = class_helpers_1.ClassHelpers.getName(instance);
+            // middlewareName - only needed for inheritace and uniqness of interceptors
+            const interceptorKey = `${middlewareName}-${methodConfig.type?.toUpperCase()}-${expressPath}`;
+            lib_prod_3.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 (lib_prod_12.Helpers.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 } = taon_helpers_1.TaonHelpers.websqlMocks(headers);
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                });
+                received['observable'] = (0, rxjs_1.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_1.Symbols.old.ENDPOINT_META_CONFIG])
+                storage[symbols_1.Symbols.old.ENDPOINT_META_CONFIG] = {};
+            if (!storage[symbols_1.Symbols.old.ENDPOINT_META_CONFIG][ctx.uriOrigin])
+                storage[symbols_1.Symbols.old.ENDPOINT_META_CONFIG][ctx.uriOrigin] = {};
+            const endpoints = storage[symbols_1.Symbols.old.ENDPOINT_META_CONFIG];
+            let rest;
+            if (!endpoints[ctx.uriOrigin][expressPath]) {
+                let headers = {};
+                if (methodConfig.contentType && !methodConfig.responseType) {
+                    rest = lib_prod_3.Resource.create(ctx.uriOrigin, expressPath, symbols_1.Symbols.old.MAPPING_CONFIG_HEADER, symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, lib_prod_3.RestHeaders.from({
+                        'Content-Type': methodConfig.contentType,
+                        Accept: methodConfig.contentType,
+                    }));
+                }
+                else if (methodConfig.contentType && methodConfig.responseType) {
+                    rest = lib_prod_3.Resource.create(ctx.uriOrigin, expressPath, symbols_1.Symbols.old.MAPPING_CONFIG_HEADER, symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, lib_prod_3.RestHeaders.from({
+                        'Content-Type': methodConfig.contentType,
+                        Accept: methodConfig.contentType,
+                        responsetypeaxios: methodConfig.responseType,
+                    }));
+                }
+                else if (!methodConfig.contentType && methodConfig.responseType) {
+                    rest = lib_prod_3.Resource.create(ctx.uriOrigin, expressPath, symbols_1.Symbols.old.MAPPING_CONFIG_HEADER, symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, lib_prod_3.RestHeaders.from({
+                        responsetypeaxios: methodConfig.responseType,
+                    }));
+                }
+                else {
+                    rest = lib_prod_3.Resource.create(ctx.uriOrigin, expressPath, symbols_1.Symbols.old.MAPPING_CONFIG_HEADER, symbols_1.Symbols.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 = `[${lib_prod_7.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 = lib_prod_3.Mapping.decode(param, !ctx.isProductionMode);
+                        if (mapping) {
+                            rest.headers.set(`${symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS}${currentParam.paramName} `, JSON.stringify(mapping));
+                        }
+                        queryParams[currentParam.paramName] = param;
+                    }
+                    else {
+                        const mapping = lib_prod_3.Mapping.decode(param, !ctx.isProductionMode);
+                        if (mapping) {
+                            rest.headers.set(symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS, JSON.stringify(mapping));
+                        }
+                        queryParams = lib_prod_12._.cloneDeep(param);
+                    }
+                }
+                if (currentParam.paramType === 'Header') {
+                    if (currentParam.paramName) {
+                        if (currentParam.paramName === symbols_1.Symbols.old.MDC_KEY) {
+                            // parese MDC
+                            rest.headers.set(currentParam.paramName, encodeURIComponent(JSON.stringify(param)));
+                        }
+                        else {
+                            rest.headers.set(currentParam.paramName, param);
+                        }
+                    }
+                    else {
+                        for (let header in param) {
+                            rest.headers.set(header, param[header]);
+                        }
+                    }
+                }
+                if (currentParam.paramType === 'Cookie') {
+                    lib_prod_3.Resource.Cookies.write(currentParam.paramName, param, currentParam.expireInSeconds);
+                }
+                if (currentParam.paramType === 'Body') {
+                    if (currentParam.paramName) {
+                        if (class_helpers_1.ClassHelpers.getName(bodyObject) === 'FormData') {
+                            throw new Error(`[taon - framework] Don use param names when posting / putting FormData.
+              Use this:
+// ...
+(@Taon.Http.Param.Body() formData: FormData) ...
+// ...
+
+instead
+  // ...
+  (@Taon.Http.Param.Body('${currentParam.paramName}') formData: FormData) ...
+// ...
+`);
+                        }
+                        const mapping = lib_prod_3.Mapping.decode(param, !ctx.isProductionMode);
+                        if (mapping) {
+                            rest.headers.set(`${symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS}${currentParam.paramName} `, JSON.stringify(mapping));
+                        }
+                        bodyObject[currentParam.paramName] = param;
+                    }
+                    else {
+                        const mapping = lib_prod_3.Mapping.decode(param, !ctx.isProductionMode);
+                        if (mapping) {
+                            rest.headers.set(symbols_1.Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS, JSON.stringify(mapping));
+                        }
+                        bodyObject = param;
+                    }
+                }
+            });
+            if (typeof bodyObject === 'object' &&
+                class_helpers_1.ClassHelpers.getName(bodyObject) !== 'FormData') {
+                let circuralFromItem = [];
+                bodyObject = lib_prod_1.JSON10.parse(lib_prod_1.JSON10.stringify(bodyObject, void 0, void 0, circs => {
+                    circuralFromItem = circs;
+                }));
+                rest.headers.set(symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, lib_prod_1.JSON10.stringify(circuralFromItem));
+            }
+            if (typeof queryParams === 'object') {
+                let circuralFromQueryParams = [];
+                queryParams = lib_prod_1.JSON10.parse(lib_prod_1.JSON10.stringify(queryParams, void 0, void 0, circs => {
+                    circuralFromQueryParams = circs;
+                }));
+                rest.headers.set(symbols_1.Symbols.old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM, lib_prod_1.JSON10.stringify(circuralFromQueryParams));
+            }
+            //#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
+    }
+}
+exports.EndpointContext = EndpointContext;
+//# sourceMappingURL=endpoint-context.js.map