taon 21.0.42 → 21.0.45

package/lib-prod/endpoint-context.ts

@@ -0,0 +1,3100 @@
+//#region imports
+import type { Server } from 'http';
+import { Http2Server } from 'http2'; // @backend
+import { URL } from 'url'; // @backend
+
+import axios from 'axios';
+import * as bodyParser from 'body-parser'; // @backend
+import * as cookieParser from 'cookie-parser'; // @backend
+import * as cors from 'cors'; // @backend
+import { ipcMain } from 'electron'; // @backend
+import * as express from 'express';
+import type { Application } from 'express';
+//  multer in taon middleware will do better job than express-fileupload
+// import * as fileUpload from 'express-fileupload'; // @backend
+import * as expressSession from 'express-session'; // @backend
+import { JSON10 } from 'json10/lib-prod';
+import { walk } from 'lodash-walk-object/lib-prod';
+import * as methodOverride from 'method-override'; // @backend
+import { Resource, RestErrorResponseWrapper, RestHeaders, Mapping__NS__decode, Mapping__NS__DefaultModelWithMapping, Mapping__NS__encode, Mapping__NS__getModelsMapping, Mapping__NS__Mapping, Mapping__NS__ModelValue, Models__NS__BackendError as ModelsNg2Rest__NS__BackendError, Models__NS__BaseBody as ModelsNg2Rest__NS__BaseBody, Models__NS__BaseResponse as ModelsNg2Rest__NS__BaseResponse, Models__NS__ErrorBody as ModelsNg2Rest__NS__ErrorBody, Models__NS__FnMethodsHttp as ModelsNg2Rest__NS__FnMethodsHttp, Models__NS__FnMethodsHttpWithMock as ModelsNg2Rest__NS__FnMethodsHttpWithMock, Models__NS__HandleResultOptions as ModelsNg2Rest__NS__HandleResultOptions, Models__NS__HandleResultSourceRequestOptions as ModelsNg2Rest__NS__HandleResultSourceRequestOptions, Models__NS__HttpBody as ModelsNg2Rest__NS__HttpBody, Models__NS__HttpCode as ModelsNg2Rest__NS__HttpCode, Models__NS__HttpResponse as ModelsNg2Rest__NS__HttpResponse, Models__NS__MetaRequest as ModelsNg2Rest__NS__MetaRequest, Models__NS__MethodWithBody as ModelsNg2Rest__NS__MethodWithBody, Models__NS__MockController as ModelsNg2Rest__NS__MockController, Models__NS__MockHttp as ModelsNg2Rest__NS__MockHttp, Models__NS__MockResponse as ModelsNg2Rest__NS__MockResponse, Models__NS__NestedParams as ModelsNg2Rest__NS__NestedParams, Models__NS__Ng2RestAxiosRequestConfig as ModelsNg2Rest__NS__Ng2RestAxiosRequestConfig, Models__NS__Ng2RestMethods as ModelsNg2Rest__NS__Ng2RestMethods, Models__NS__PromiseObservableMix as ModelsNg2Rest__NS__PromiseObservableMix, Models__NS__ReplayData as ModelsNg2Rest__NS__ReplayData, Models__NS__ReqParams as ModelsNg2Rest__NS__ReqParams, Models__NS__ResourceModel as ModelsNg2Rest__NS__ResourceModel, Models__NS__ResponseTypeAxios as ModelsNg2Rest__NS__ResponseTypeAxios, Models__NS__UrlParams as ModelsNg2Rest__NS__UrlParams } from 'ng2-rest/lib-prod';
+import { from, Subject } from 'rxjs';
+import type {
+  TransactionRollbackEvent,
+  TransactionCommitEvent,
+  TransactionStartEvent,
+  RecoverEvent,
+  SoftRemoveEvent,
+  RemoveEvent,
+  UpdateEvent,
+  InsertEvent,
+  Repository,
+} from 'taon-typeorm/lib-prod'; // @websql
+import { EventSubscriber } from 'taon-typeorm/lib-prod'; // @websql
+import { Entity as TypeormEntity, Tree } from 'taon-typeorm/lib-prod'; // @websql
+import {
+  DataSource,
+  DataSourceOptions,
+  getMetadataArgsStorage,
+} from 'taon-typeorm/lib-prod';
+import { config } from 'tnp-core/lib-prod';
+import { CoreModels__NS__BaseProjectType, CoreModels__NS__BaseProjectTypeArr, CoreModels__NS__CfontAlign, CoreModels__NS__CfontStyle, CoreModels__NS__ClassNameStaticProperty, CoreModels__NS__ContentType, CoreModels__NS__ContentTypeKeys, CoreModels__NS__CoreLibCategory, CoreModels__NS__CutableFileExt, CoreModels__NS__DatabaseType, CoreModels__NS__EnvironmentName, CoreModels__NS__EnvironmentNameTaon, CoreModels__NS__ExecuteOptions, CoreModels__NS__FileEvent, CoreModels__NS__FileExtension, CoreModels__NS__FrameworkVersion, CoreModels__NS__GlobalDependencies, CoreModels__NS__HttpMethod, CoreModels__NS__ImageFileExtension, CoreModels__NS__ImageFileExtensionArr, CoreModels__NS__InstalationType, CoreModels__NS__InstalationTypeArr, CoreModels__NS__LibType, CoreModels__NS__localhostDomain, CoreModels__NS__localhostIp127, CoreModels__NS__ManifestIcon, CoreModels__NS__MediaType, CoreModels__NS__MediaTypeAllArr, CoreModels__NS__MimeType, CoreModels__NS__mimeTypes, CoreModels__NS__MimeTypesObj, CoreModels__NS__NewFactoryType, CoreModels__NS__NpmInstallOptions, CoreModels__NS__NpmSpecialVersions, CoreModels__NS__OrignalClassKey, CoreModels__NS__OutFolder, CoreModels__NS__Package, CoreModels__NS__ParamType, CoreModels__NS__parentLocation, CoreModels__NS__pathToChildren, CoreModels__NS__Position, CoreModels__NS__PreReleaseVersionTag, CoreModels__NS__PROGRESS_DATA_TYPE, CoreModels__NS__PUSHTYPE, CoreModels__NS__PwaManifest, CoreModels__NS__ReleaseVersionType, CoreModels__NS__ReleaseVersionTypeEnum, CoreModels__NS__RunOptions, CoreModels__NS__Size, CoreModels__NS__SPECIAL_APP_READY_MESSAGE, CoreModels__NS__SPECIAL_WORKER_READY_MESSAGE, CoreModels__NS__tagForTaskName, CoreModels__NS__TaonHttpErrorCustomProp, CoreModels__NS__TsUsage, CoreModels__NS__UIFramework, CoreModels__NS__UploadedBackendFile, CoreModels__NS__VSCodeSettings } from 'tnp-core/lib-prod';
+import { fse, http, https, os } from 'tnp-core/lib-prod'; // @backend
+import { Utils__NS__binary__NS__base64toBlob, Utils__NS__binary__NS__base64toBuffer, Utils__NS__binary__NS__base64toDbBinaryFormat, Utils__NS__binary__NS__blobToArrayBuffer, Utils__NS__binary__NS__blobToBase64, Utils__NS__binary__NS__blobToBuffer, Utils__NS__binary__NS__blobToFile, Utils__NS__binary__NS__blobToJson, Utils__NS__binary__NS__blobToText, Utils__NS__binary__NS__bufferToBase64, Utils__NS__binary__NS__bufferToBlob, Utils__NS__binary__NS__bufferToText, Utils__NS__binary__NS__dbBinaryFormatToBase64, Utils__NS__binary__NS__dbBinaryFormatToText, Utils__NS__binary__NS__fileToBlob, Utils__NS__binary__NS__fileToText, Utils__NS__binary__NS__getBlobFrom, Utils__NS__binary__NS__jsonToBlob, Utils__NS__binary__NS__textToBlob, Utils__NS__binary__NS__textToBuffer, Utils__NS__binary__NS__textToDbBinaryFormat, Utils__NS__binary__NS__textToFile, Utils__NS__camelize, Utils__NS__css__NS__numValue, Utils__NS__DbBinaryFormat, Utils__NS__DbBinaryFormatEnum, Utils__NS__DbBinaryFormatForBackend, Utils__NS__DbBinaryFormatForBrowser, Utils__NS__escapeStringForRegEx, Utils__NS__fullDate, Utils__NS__fullDateTime, Utils__NS__getFreePort, Utils__NS__removeChalkSpecialChars, Utils__NS__requireUncached, Utils__NS__sortKeys, Utils__NS__uniqArray, Utils__NS__wait, Utils__NS__waitMilliseconds, UtilsOs__NS__commandExistsAsync, UtilsOs__NS__commandExistsSync, UtilsOs__NS__detectEditor, UtilsOs__NS__Editor, UtilsOs__NS__EDITOR_PROCESSES, UtilsOs__NS__EditorArr, UtilsOs__NS__EditorProcess, UtilsOs__NS__getEditorSettingsJsonPath, UtilsOs__NS__getRealHomeDir, UtilsOs__NS__isBrowser, UtilsOs__NS__isDockerAvailable, UtilsOs__NS__isElectron, UtilsOs__NS__isNode, UtilsOs__NS__isNodeVersionOk, UtilsOs__NS__isPortInUse, UtilsOs__NS__isRunningInBrowser, UtilsOs__NS__isRunningInCliMode, UtilsOs__NS__isRunningInDocker, UtilsOs__NS__isRunningInElectron, UtilsOs__NS__isRunningInLinuxGraphicsCapableEnvironment, UtilsOs__NS__isRunningInMochaTest, UtilsOs__NS__isRunningInNode, UtilsOs__NS__isRunningInOsWithGraphicsCapableEnvironment, UtilsOs__NS__isRunningInSSRMode, UtilsOs__NS__isRunningInVscodeExtension, UtilsOs__NS__isRunningInWebSQL, UtilsOs__NS__isRunningInWindows, UtilsOs__NS__isRunningInWindowsCmd, UtilsOs__NS__isRunningInWindowsPowerShell, UtilsOs__NS__isRunningInWsl, UtilsOs__NS__isRunningNodeDebugger, UtilsOs__NS__isSSRMode, UtilsOs__NS__isVscodeExtension, UtilsOs__NS__isWebSQL, UtilsOs__NS__killAllEditor, UtilsOs__NS__openFolderInFileExplorer, UtilsOs__NS__openFolderInVSCode, UtilsOs__NS__pipxNestedPackageExists, UtilsOs__NS__pipxPackageExists, UtilsOs__NS__pythonModuleExists, UtilsOs__NS__UnknownEditor } from 'tnp-core/lib-prod';
+import { crossPlatformPath } from 'tnp-core/lib-prod';
+import { ___NS__add, ___NS__after, ___NS__ary, ___NS__assign, ___NS__assignIn, ___NS__assignInWith, ___NS__assignWith, ___NS__at, ___NS__attempt, ___NS__before, ___NS__bind, ___NS__bindAll, ___NS__bindKey, ___NS__camelCase, ___NS__capitalize, ___NS__castArray, ___NS__ceil, ___NS__chain, ___NS__chunk, ___NS__clamp, ___NS__clone, ___NS__cloneDeep, ___NS__cloneDeepWith, ___NS__cloneWith, ___NS__compact, ___NS__concat, ___NS__cond, ___NS__conforms, ___NS__conformsTo, ___NS__constant, ___NS__countBy, ___NS__create, ___NS__curry, ___NS__curryRight, ___NS__debounce, ___NS__deburr, ___NS__defaults, ___NS__defaultsDeep, ___NS__defaultTo, ___NS__defer, ___NS__delay, ___NS__difference, ___NS__differenceBy, ___NS__differenceWith, ___NS__divide, ___NS__drop, ___NS__dropRight, ___NS__dropRightWhile, ___NS__dropWhile, ___NS__each, ___NS__eachRight, ___NS__endsWith, ___NS__entries, ___NS__entriesIn, ___NS__eq, ___NS__escape, ___NS__escapeRegExp, ___NS__every, ___NS__extend, ___NS__extendWith, ___NS__fill, ___NS__filter, ___NS__find, ___NS__findIndex, ___NS__findKey, ___NS__findLast, ___NS__findLastIndex, ___NS__findLastKey, ___NS__first, ___NS__flatMap, ___NS__flatMapDeep, ___NS__flatMapDepth, ___NS__flatten, ___NS__flattenDeep, ___NS__flattenDepth, ___NS__flip, ___NS__floor, ___NS__flow, ___NS__flowRight, ___NS__forEach, ___NS__forEachRight, ___NS__forIn, ___NS__forInRight, ___NS__forOwn, ___NS__forOwnRight, ___NS__fromPairs, ___NS__functions, ___NS__functionsIn, ___NS__get, ___NS__groupBy, ___NS__gt, ___NS__gte, ___NS__has, ___NS__hasIn, ___NS__head, ___NS__identity, ___NS__includes, ___NS__indexOf, ___NS__initial, ___NS__inRange, ___NS__intersection, ___NS__intersectionBy, ___NS__intersectionWith, ___NS__invert, ___NS__invertBy, ___NS__invoke, ___NS__invokeMap, ___NS__isArguments, ___NS__isArray, ___NS__isArrayBuffer, ___NS__isArrayLike, ___NS__isArrayLikeObject, ___NS__isBoolean, ___NS__isBuffer, ___NS__isDate, ___NS__isElement, ___NS__isEmpty, ___NS__isEqual, ___NS__isEqualWith, ___NS__isError, ___NS__isFinite, ___NS__isFunction, ___NS__isInteger, ___NS__isLength, ___NS__isMap, ___NS__isMatch, ___NS__isMatchWith, ___NS__isNaN, ___NS__isNative, ___NS__isNil, ___NS__isNull, ___NS__isNumber, ___NS__isObject, ___NS__isObjectLike, ___NS__isPlainObject, ___NS__isRegExp, ___NS__isSafeInteger, ___NS__isSet, ___NS__isString, ___NS__isSymbol, ___NS__isTypedArray, ___NS__isUndefined, ___NS__isWeakMap, ___NS__isWeakSet, ___NS__iteratee, ___NS__join, ___NS__kebabCase, ___NS__keyBy, ___NS__keys, ___NS__keysIn, ___NS__last, ___NS__lastIndexOf, ___NS__lowerCase, ___NS__lowerFirst, ___NS__lt, ___NS__lte, ___NS__map, ___NS__mapKeys, ___NS__mapValues, ___NS__matches, ___NS__matchesProperty, ___NS__max, ___NS__maxBy, ___NS__mean, ___NS__meanBy, ___NS__memoize, ___NS__merge, ___NS__mergeWith, ___NS__method, ___NS__methodOf, ___NS__min, ___NS__minBy, ___NS__mixin, ___NS__multiply, ___NS__negate, ___NS__noop, ___NS__now, ___NS__nth, ___NS__nthArg, ___NS__omit, ___NS__omitBy, ___NS__once, ___NS__orderBy, ___NS__over, ___NS__overArgs, ___NS__overEvery, ___NS__overSome, ___NS__pad, ___NS__padEnd, ___NS__padStart, ___NS__parseInt, ___NS__partial, ___NS__partialRight, ___NS__partition, ___NS__pick, ___NS__pickBy, ___NS__property, ___NS__propertyOf, ___NS__pull, ___NS__pullAll, ___NS__pullAllBy, ___NS__pullAllWith, ___NS__pullAt, ___NS__random, ___NS__range, ___NS__rangeRight, ___NS__rearg, ___NS__reduce, ___NS__reduceRight, ___NS__reject, ___NS__remove, ___NS__repeat, ___NS__replace, ___NS__rest, ___NS__result, ___NS__reverse, ___NS__round, ___NS__sample, ___NS__sampleSize, ___NS__set, ___NS__setWith, ___NS__shuffle, ___NS__size, ___NS__slice, ___NS__snakeCase, ___NS__some, ___NS__sortBy, ___NS__sortedIndex, ___NS__sortedIndexBy, ___NS__sortedIndexOf, ___NS__sortedLastIndex, ___NS__sortedLastIndexBy, ___NS__sortedLastIndexOf, ___NS__sortedUniq, ___NS__sortedUniqBy, ___NS__split, ___NS__spread, ___NS__startCase, ___NS__startsWith, ___NS__stubArray, ___NS__stubFalse, ___NS__stubObject, ___NS__stubString, ___NS__stubTrue, ___NS__subtract, ___NS__sum, ___NS__sumBy, ___NS__tail, ___NS__take, ___NS__takeRight, ___NS__takeRightWhile, ___NS__takeWhile, ___NS__tap, ___NS__template, ___NS__templateSettings, ___NS__throttle, ___NS__thru, ___NS__times, ___NS__toArray, ___NS__toFinite, ___NS__toInteger, ___NS__toLength, ___NS__toLower, ___NS__toNumber, ___NS__toPairs, ___NS__toPairsIn, ___NS__toPath, ___NS__toPlainObject, ___NS__toSafeInteger, ___NS__toString, ___NS__toUpper, ___NS__transform, ___NS__trim, ___NS__trimEnd, ___NS__trimStart, ___NS__truncate, ___NS__unary, ___NS__unescape, ___NS__union, ___NS__unionBy, ___NS__unionWith, ___NS__uniq, ___NS__uniqBy, ___NS__uniqueId, ___NS__uniqWith, ___NS__unset, ___NS__unzip, ___NS__unzipWith, ___NS__update, ___NS__updateWith, ___NS__upperCase, ___NS__upperFirst, ___NS__values, ___NS__valuesIn, ___NS__without, ___NS__words, ___NS__wrap, ___NS__xor, ___NS__xorBy, ___NS__xorWith, ___NS__zip, ___NS__zipObject, ___NS__zipObjectDeep, ___NS__zipWith, Helpers__NS___fixCommand, Helpers__NS__bigMaxBuffer, Helpers__NS__checkProcess, Helpers__NS__cleanExit, Helpers__NS__clearConsole, Helpers__NS__command, Helpers__NS__commandOutputAsString, Helpers__NS__commandOutputAsStringAsync, Helpers__NS__compilationWrapper, Helpers__NS__contain, Helpers__NS__createFolder, Helpers__NS__createSymLink, Helpers__NS__error, Helpers__NS__execute, Helpers__NS__exists, Helpers__NS__filesFrom, Helpers__NS__foldersFrom, Helpers__NS__getFilesFrom, Helpers__NS__getFoldersFrom, Helpers__NS__getIsBrowser, Helpers__NS__getIsElectron, Helpers__NS__getIsNode, Helpers__NS__getIsRunningInGitBash, Helpers__NS__getIsSupportedTaonTerminal, Helpers__NS__getIsVerboseMode, Helpers__NS__getIsWebSQL, Helpers__NS__getIsWsl, Helpers__NS__getStdio, Helpers__NS__hideNodeWarnings, Helpers__NS__info, Helpers__NS__isBlob, Helpers__NS__isBuffer, Helpers__NS__isClass, Helpers__NS__isExistedSymlink, Helpers__NS__isFile, Helpers__NS__isFolder, Helpers__NS__isRunningInDocker, Helpers__NS__isRunningInLinuxGraphicsCapableEnvironment, Helpers__NS__isSymlinkFileExitedOrUnexisted, Helpers__NS__isSymlinkThatMatchesUrl, Helpers__NS__isUnexistedLink, Helpers__NS__killOnPort, Helpers__NS__killProcess, Helpers__NS__killProcessByPort, Helpers__NS__linksToFolderFrom, Helpers__NS__linksToFoldersFrom, Helpers__NS__log, Helpers__NS__logError, Helpers__NS__logInfo, Helpers__NS__logProc, Helpers__NS__logSuccess, Helpers__NS__logWarn, Helpers__NS__mediaTypeFromSrc, Helpers__NS__mkdirp, Helpers__NS__modifyLineByLine, Helpers__NS__msgCacheClear, Helpers__NS__openFolderInFileExplorer, Helpers__NS__parse, Helpers__NS__pathContainLink, Helpers__NS__questionYesNo, Helpers__NS__readFile, Helpers__NS__readJson, Helpers__NS__readJson5, Helpers__NS__readJsonC, Helpers__NS__relative, Helpers__NS__remove, Helpers__NS__removeEmptyLineFromString, Helpers__NS__removeFileIfExists, Helpers__NS__removeFolderIfExists, Helpers__NS__removeIfExists, Helpers__NS__removeSlashAtBegin, Helpers__NS__removeSlashAtEnd, Helpers__NS__removeSymlinks, Helpers__NS__renderError, Helpers__NS__replaceLinesInFile, Helpers__NS__run, Helpers__NS__runAsyncIn, Helpers__NS__runSyncIn, Helpers__NS__runSyncOrAsync, Helpers__NS__sleep, Helpers__NS__stopApplication, Helpers__NS__stringify, Helpers__NS__success, Helpers__NS__taskDone, Helpers__NS__taskStarted, Helpers__NS__throwError, Helpers__NS__timeout, Helpers__NS__tryCatchError, Helpers__NS__tryReadFile, Helpers__NS__tryRemoveDir, Helpers__NS__values, Helpers__NS__wait, Helpers__NS__warn, Helpers__NS__writeFile, Helpers__NS__writeJson, Helpers__NS__writeJson5, Helpers__NS__writeJsonC } from 'tnp-core/lib-prod';
+import { path } from 'tnp-core/lib-prod';
+
+import type { TaonBaseClass } from './base-classes/base-class';
+import type { TaonBaseController } from './base-classes/base-controller';
+import type { TaonBaseInjector } from './base-classes/base-injector';
+import type { TaonBaseMiddleware } from './base-classes/base-middleware';
+import type { TaonBaseMigration } from './base-classes/base-migration';
+import { TaonBaseSubscriberForEntity } from './base-classes/base-subscriber-for-entity';
+import type { ControllerConfig } from './config/controller-config';
+import { MethodConfig } from './config/method-config';
+import { ParamConfig } from './config/param-config';
+import { apiPrefix } from './constants';
+import { ContextDbMigrations } from './context-db-migrations';
+import { createContext } from './create-context';
+import { TaonEntityOptions } from './decorators/classes/entity-decorator';
+import { TaonSubscriberOptions } from './decorators/classes/subscriber-decorator';
+import { DITaonContainer } from './dependency-injection/di-container';
+import type { ContextsEndpointStorage } from './endpoint-context-storage';
+import { EntityProcess } from './entity-process';
+import { getResponseValue } from './get-response-value';
+import { ClassHelpers__NS__asyncHandler, ClassHelpers__NS__ensureClassConfig, ClassHelpers__NS__ensureMethodConfig, ClassHelpers__NS__getClassConfig, ClassHelpers__NS__getClassFnFromObject, ClassHelpers__NS__getControllerConfigs, ClassHelpers__NS__getFullInternalName, ClassHelpers__NS__getMethodsNames, ClassHelpers__NS__getName, ClassHelpers__NS__getOrginalClass, ClassHelpers__NS__getUniqueKey, ClassHelpers__NS__hasParentClassWithName, ClassHelpers__NS__isContextClassObject, ClassHelpers__NS__setName } from './helpers/class-helpers';
+import { TaonHelpers__NS__defaultType, TaonHelpers__NS__fillUpTo, TaonHelpers__NS__firstStringOrElemFromArray, TaonHelpers__NS__getExpressPath, TaonHelpers__NS__ipcKeyNameRequest, TaonHelpers__NS__ipcKeyNameResponse, TaonHelpers__NS__isGoodPath, TaonHelpers__NS__isPlainFileOrFolder, TaonHelpers__NS__parseJSONwithStringJSONs, TaonHelpers__NS__tryTransformParam, TaonHelpers__NS__websqlMocks } from './helpers/taon-helpers';
+import { Models__NS__ClassType, Models__NS__ClassTypeKey, Models__NS__ConnectionOptionsLogs, Models__NS__ContextOptions, Models__NS__DatabaseConfig, Models__NS__DatabaseConfigTypeOrm, Models__NS__DatabasesFolder, Models__NS__DBRecreateMode, Models__NS__FrameworkMode, Models__NS__Http__NS__AsyncResponse, Models__NS__Http__NS__AuthCallBack, Models__NS__Http__NS__ClientAction, Models__NS__Http__NS__ContextENDPOINT, Models__NS__Http__NS__ExpressContext, Models__NS__Http__NS__FormlyFromType, Models__NS__Http__NS__MixResponse, Models__NS__Http__NS__Response, Models__NS__Http__NS__ResponseFuncOpt, Models__NS__Http__NS__SyncResponse, Models__NS__Http__NS__SyncResponseFunc, Models__NS__ISession, Models__NS__MiddlewareType, Models__NS__StartParams, Models__NS__TaonCtxCloneParams, Models__NS__TaonInitializeParams } from './models';
+import { RealtimeCore } from './realtime/realtime-core';
+import { Symbols__NS__classMethodsNames, Symbols__NS__classNameStaticProperty, Symbols__NS__ctxInClassOrClassObj, Symbols__NS__fullClassNameStaticProperty, Symbols__NS__metadata, Symbols__NS__old, Symbols__NS__orignalClass, Symbols__NS__orignalClassClonesObj, Symbols__NS__REALTIME } from './symbols';
+/* */                                                                                                 
+//#endregion
+
+export class EndpointContext {
+  //#region fields
+
+  //#region fields / use mariadb mysql in docker
+  /**
+   * JUST FOR TESTING PURPOSES
+   */
+  public readonly USE_MARIADB_MYSQL_IN_DOCKER: boolean = false;
+  //#endregion
+
+  //#region fields / flags
+  disabledRealtime: boolean = false;
+
+  /**
+   * check whether context is inited
+   * (with init() function )
+   */
+  public inited: boolean = false;
+  //#endregion
+
+  //#region fields / db migrations
+  readonly dbMigrations = new ContextDbMigrations(this);
+  //#endregion
+
+  //#region fields / local instance obj symbol
+  private readonly localInstaceObjSymbol = Symbol('localInstaceObjSymbol');
+  //#endregion
+
+  //#region fields / all instances of classes from context
+  /**
+   * all instances of classes from context
+   * key is class name
+   */
+  public readonly allClassesInstances = {};
+  //#endregion
+
+  //#region fields / class instances by name
+  private readonly classInstancesByNameObj = {};
+  //#endregion
+
+  //#region fields / obj with classes instances arr
+  private readonly objWithClassesInstancesArr = {};
+  //#endregion
+
+  //#region fields / active routes
+  public readonly activeRoutes: {
+    expressPath: string;
+    method: CoreModels__NS__HttpMethod;
+  }[] = [];
+  //#endregion
+
+  //#region fields / typeorm repositories
+  //#region @websql
+  public repos = new Map<string, Repository<any>>();
+  //#endregion
+  //#endregion
+
+  //#region fields / source context
+  get sourceContext(): EndpointContext | undefined {
+    return this.cloneOptions?.sourceContext;
+  }
+  //#endregion
+
+  //#region fields / skip writing server routes
+  public readonly skipWritingServerRoutes: boolean = false;
+  //#endregion
+
+  //#region fields / types from contexts
+  private injectableTypesfromContexts = [
+    Models__NS__ClassType.CONTROLLER,
+    Models__NS__ClassType.PROVIDER,
+    Models__NS__ClassType.MIDDLEWARE,
+    Models__NS__ClassType.REPOSITORY,
+    Models__NS__ClassType.SUBSCRIBER,
+    Models__NS__ClassType.MIGRATION,
+  ];
+  //#endregion
+
+  //#region fields / all types from contexts
+  private allTypesfromContexts = [
+    ...this.injectableTypesfromContexts,
+    Models__NS__ClassType.ENTITY,
+  ];
+  //#endregion
+
+  //#region fields / express app
+  public expressApp: Application = {} as any;
+  //#endregion
+
+  //#region fields / server tcp udp
+  public serverTcpUdp: Server;
+  //#endregion
+
+  //#region fields / database config
+  databaseConfig?: Models__NS__DatabaseConfigTypeOrm;
+  //#endregion
+
+  //#region fields /  mode
+  mode: Models__NS__FrameworkMode;
+  //#endregion
+
+  //#region fields / only migration start
+  readonly onlyMigrationRun?: boolean = false;
+
+  readonly onlyMigrationRevertToTimestamp?: number = undefined;
+
+  get isRunOrRevertOnlyMigrationAppStart(): boolean {
+    return !!(this.onlyMigrationRun || this.onlyMigrationRevertToTimestamp);
+  }
+  //#endregion
+
+  //#region fields  / session
+  session?: Models__NS__ISession;
+  //#endregion
+
+  //#region fields / connection
+  public connection: DataSource;
+  //#endregion
+
+  //#region fields / entities triggers
+  private entitiesTriggers = {};
+  //#endregion
+
+  //#region fields / realtime
+  private realtime: RealtimeCore;
+
+  get realtimeClient() {
+    return this.realtime.client;
+  }
+
+  get realtimeServer() {
+    return this.realtime.server;
+  }
+  //#endregion
+
+  //#region fields / config
+  /**
+   * available after init()
+   */
+  public config: Models__NS__ContextOptions<any, any, any, any, any, any, any, any>;
+  //#endregion
+
+  //#region fields / logs
+  get logHttp(): boolean {
+    if (___NS__isObject(this.config?.logs)) {
+      return !!(this.config.logs as Models__NS__ConnectionOptionsLogs).http;
+    }
+    return this.config?.logs === true;
+  }
+
+  get logRealtime(): boolean {
+    if (___NS__isObject(this.config?.logs)) {
+      return !!(this.config.logs as Models__NS__ConnectionOptionsLogs).realtime;
+    }
+    return this.config?.logs === true;
+  }
+
+  get logFramework(): boolean {
+    if (___NS__isObject(this.config?.logs)) {
+      return !!(this.config.logs as Models__NS__ConnectionOptionsLogs).framework;
+    }
+    return this.config?.logs === true;
+  }
+
+  get logRoutes(): boolean {
+    if (___NS__isObject(this.config?.logs)) {
+      return !!(this.config.logs as Models__NS__ConnectionOptionsLogs).routes;
+    }
+    return this.config?.logs === true;
+  }
+
+  get logDb(): boolean {
+    if (___NS__isObject(this.config?.logs)) {
+      return !!(this.config.logs as Models__NS__ConnectionOptionsLogs).db;
+    }
+    return this.config?.logs === true;
+  }
+
+  get logMigrations(): boolean {
+    if (___NS__isObject(this.config?.logs)) {
+      return !!(this.config.logs as Models__NS__ConnectionOptionsLogs).migrations;
+    }
+    return this.config?.logs === true;
+  }
+  //#endregion
+
+  //#endregion
+
+  //#region constructor
+  /**
+   * Inside docker there is not need for https secure server
+   */
+  public readonly isRunningInsideDocker: boolean = false;
+
+  constructor(
+    private originalConfig: Models__NS__ContextOptions<
+      any,
+      any,
+      any,
+      any,
+      any,
+      any,
+      any,
+      any
+    >,
+    private configFn: (
+      env: any,
+    ) => Models__NS__ContextOptions<any, any, any, any, any, any, any, any>,
+    /**
+     * (@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
+     */
+    private readonly cloneOptions: Models__NS__TaonCtxCloneParams,
+  ) {
+    this.cloneOptions = this.cloneOptions || {};
+    this.isRunningInsideDocker = UtilsOs__NS__isRunningInDocker();
+  }
+  //#endregion
+
+  //#region methods & getters / init
+  public async init(options?: {
+    initFromRecrusiveContextResovle?: boolean;
+    onlyMigrationRun?: boolean;
+    onlyMigrationRevertToTimestamp?: number;
+  }) {
+    const {
+      initFromRecrusiveContextResovle,
+      onlyMigrationRun,
+      onlyMigrationRevertToTimestamp,
+    } = options || {}; // TODO use it ?
+
+    this.inited = true;
+    // @ts-ignore
+    this.onlyMigrationRun = onlyMigrationRun;
+    // @ts-ignore
+    this.onlyMigrationRevertToTimestamp = onlyMigrationRevertToTimestamp;
+    this.config = this.configFn({});
+    if (___NS__isObject(this.config.database)) {
+      this.config.database = Models__NS__DatabaseConfig.from(
+        this.config.database as Models__NS__DatabaseConfig,
+      ).databaseConfigTypeORM;
+    }
+
+    this.config.host = this.host === null ? void 0 : this.host;
+
+    if (
+      this.cloneOptions.overrideHost &&
+      !this.cloneOptions.useAsRemoteContext
+    ) {
+      this.config.host = this.cloneOptions.overrideHost;
+    }
+
+    if (
+      this.cloneOptions.overrideRemoteHost &&
+      this.cloneOptions.useAsRemoteContext
+    ) {
+      this.config.host = this.cloneOptions.overrideRemoteHost;
+    }
+
+    if (
+      this.config.host &&
+      !this.config.host.startsWith('http://') &&
+      !this.config.host.startsWith('https://')
+    ) {
+      Helpers__NS__throwError(
+        `[taon-config] Your${this.host ? ' remote' : ''} 'host' must start with http:// or https://`,
+      );
+    }
+
+    if (___NS__isUndefined(this.config.useIpcWhenElectron)) {
+      this.config.useIpcWhenElectron = true;
+    }
+    // console.log(`config for ${this.contextName}`, this.config);
+
+    //#region resolve if skipping writing server routes
+    //@ts-expect-error overriding readonly
+    this.skipWritingServerRoutes = ___NS__isBoolean(
+      this.config.skipWritingServerRoutes,
+    )
+      ? this.config.skipWritingServerRoutes
+      : false;
+    //#endregion
+
+    //#region resolve mode
+    if (this.config.host) {
+      this.mode = 'backend-frontend(tcp+udp)';
+/* */
+/* */
+  
+    }
+
+    if (this.isRemoteHost) {
+      this.mode = 'remote-backend(tcp+udp)';
+    }
+
+    // console.log(`
+
+    //   useIpcWhenElectron: ${this.config.useIpcWhenElectron}
+    //   UtilsOs__NS__isElectron: ${UtilsOs__NS__isElectron}
+
+    //   `)
+    if (this.config.useIpcWhenElectron && UtilsOs__NS__isElectron) {
+      if (UtilsOs__NS__isWebSQL) {
+        this.mode = 'backend-frontend(websql-electron)';
+      } else {
+        this.mode = 'backend-frontend(ipc-electron)';
+      }
+    }
+
+    // mode === undefined for TaonBaseContext => ok behavior
+    // console.log(`Mode for BE/FE communication: ${this.mode}`);
+    // if(!this.mode) {
+    //   console.log(this.config)
+    // }
+
+    if (!this.mode && !this.config.abstract) {
+      const errMsg =
+        `You need to provide host property or ` +
+        `useIpcWhenElectron or mark it as abstract`;
+      Helpers__NS__error(
+        `[taon][Context=${this.contextName}]: ${errMsg}`,
+        false,
+        true,
+      );
+      //#region @backend
+      process.exit(1);
+      //#endregion
+    }
+    //#endregion
+
+    //#region resolve database config
+    if (this.config.database === true) {
+      this.logFramework &&
+        console.log(`
+
+        ASSIGNING AUTO GENERATED DATABASE CONFIG
+
+        `);
+      this.databaseConfig = this.getAutoGeneratedConfig();
+    } else if (___NS__isObject(this.config.database)) {
+      this.logFramework &&
+        console.log(`
+
+        OVERRIDE DATABASE CONFIG FROM CONFIGURATION
+
+        `);
+      this.databaseConfig = this.getAutoGeneratedConfig();
+      walk.Object(
+        this.config.database,
+        (value, lodashPath) => {
+          if (___NS__isNil(value) || ___NS__isFunction(value) || ___NS__isObject(value)) {
+            // skipping
+          } else {
+            this.logFramework &&
+              console.info(
+                `Overriding database config: ${lodashPath}=${value}`,
+              );
+            ___NS__set(this.databaseConfig, lodashPath, value);
+          }
+        },
+        {
+          walkGetters: false,
+        },
+      );
+    }
+    //#endregion
+
+    //#region resolve session
+    if (this.config.session) {
+      this.session = ___NS__cloneDeep(this.config.session);
+      const oneHour = 1000 * 60 * 60 * 1; // 24;
+      if (!this.session.cookieMaxAge) {
+        this.session.cookieMaxAge = oneHour;
+      }
+      // serever and browser cookie authentication
+      axios.defaults.withCredentials = true;
+    }
+    //#endregion
+
+    //#region prepare & gather all classes recursively
+    this.config.contexts = this.config.contexts || {};
+    this.config.entities = this.config.entities || {};
+    this.config.controllers = this.config.controllers || {};
+    this.config.repositories = this.config.repositories || {};
+    this.config.providers = this.config.providers || {};
+    this.config.subscribers = this.config.subscribers || {};
+    this.config.migrations = this.config.migrations || {};
+
+    this.config.entities = {
+      ...(await this.getRecrusiveClassesfromContextsObj(
+        Models__NS__ClassType.ENTITY,
+      )),
+      ...this.config.entities,
+    };
+
+    this.config.controllers = {
+      ...(await this.getRecrusiveClassesfromContextsObj(
+        Models__NS__ClassType.CONTROLLER,
+      )),
+      ...this.config.controllers,
+    };
+
+    this.config.providers = {
+      ...(await this.getRecrusiveClassesfromContextsObj(
+        Models__NS__ClassType.PROVIDER,
+      )),
+      ...this.config.providers,
+    };
+
+    this.config.middlewares = {
+      ...(await this.getRecrusiveClassesfromContextsObj(
+        Models__NS__ClassType.MIDDLEWARE,
+      )),
+      ...this.config.middlewares,
+    };
+
+    this.config.subscribers = {
+      ...(await this.getRecrusiveClassesfromContextsObj(
+        Models__NS__ClassType.SUBSCRIBER,
+      )),
+      ...this.config.subscribers,
+    };
+
+    this.config.repositories = {
+      ...(await this.getRecrusiveClassesfromContextsObj(
+        Models__NS__ClassType.REPOSITORY,
+      )),
+      ...this.config.repositories,
+    };
+
+    this.config.migrations = {
+      ...(await this.getRecrusiveClassesfromContextsObj(
+        Models__NS__ClassType.MIGRATION,
+      )),
+      ...this.config.migrations,
+    };
+
+    // console.log(this.config);
+    // debugger;
+    //#endregion
+
+    //#region prepare classes instances/functions clones
+    this.config.controllers = this.cloneClassesObjWithNewMetadata({
+      classesInput: this.config.controllers,
+      config: this.config,
+      ctx: this,
+      classType: Models__NS__ClassType.CONTROLLER,
+    });
+    this.config.repositories = this.cloneClassesObjWithNewMetadata({
+      classesInput: this.config.repositories,
+      config: this.config,
+      ctx: this,
+      classType: Models__NS__ClassType.REPOSITORY,
+    });
+    this.config.providers = this.cloneClassesObjWithNewMetadata({
+      classesInput: this.config.providers,
+      config: this.config,
+      ctx: this,
+      classType: Models__NS__ClassType.PROVIDER,
+    });
+    this.config.middlewares = this.cloneClassesObjWithNewMetadata({
+      classesInput: this.config.middlewares,
+      config: this.config,
+      ctx: this,
+      classType: Models__NS__ClassType.MIDDLEWARE,
+    });
+
+    this.config.subscribers = this.cloneClassesObjWithNewMetadata({
+      classesInput: this.config.subscribers,
+      config: this.config,
+      ctx: this,
+      classType: Models__NS__ClassType.SUBSCRIBER,
+    });
+
+    this.config.migrations = this.cloneClassesObjWithNewMetadata({
+      classesInput: this.config.migrations,
+      config: this.config,
+      ctx: this,
+      classType: Models__NS__ClassType.MIGRATION,
+    });
+    //#endregion
+
+    //#region prepare instances
+    for (const classTypeName of this.injectableTypesfromContexts) {
+      this.classInstancesByNameObj[classTypeName] = {};
+      this.objWithClassesInstancesArr[classTypeName] = [];
+    }
+
+    for (const classTypeName of this.injectableTypesfromContexts) {
+      await this.createInstances(
+        this.config[Models__NS__ClassTypeKey[classTypeName]],
+        classTypeName,
+      );
+    }
+    //#endregion
+
+    if (!this.isRunOrRevertOnlyMigrationAppStart) {
+      //#region prepares server
+      if (this.mode === 'backend-frontend(tcp+udp)' && !this.config.abstract) {
+        //#region @backend
+        this.expressApp = express();
+
+        if (process.env.NODE_ENV === 'production') {
+          this.expressApp.set('trust proxy', 1);
+        }
+
+        await this.initBackendMiddlewares();
+        await this.initCustomBackendMiddlewares();
+        const shouldStartHttpsSecureServer =
+          this.isHttpServer && !this.isRunningInsideDocker;
+        this.logFramework &&
+          Helpers__NS__info(`
+
+          Starting server ${
+            shouldStartHttpsSecureServer ? 'with' : 'without'
+          } HTTPS secure server
+
+          `);
+        this.serverTcpUdp = shouldStartHttpsSecureServer
+          ? new https.Server(
+              {
+                key: this.config.https?.key,
+                cert: this.config.https?.cert,
+              },
+              this.expressApp,
+            )
+          : new http.Server(this.expressApp);
+        this.publicAssets.forEach(asset => {
+          this.expressApp.use(
+            asset.serverPath,
+            express.static(asset.locationOnDisk),
+          );
+        });
+        //#endregion
+
+        await this.initCustomClientMiddlewares();
+      }
+      //#endregion
+
+      //#region prepare realtime
+      if (!this.config.abstract) {
+        this.disabledRealtime = this.config.disabledRealtime;
+        if (!this.host) {
+          throw `
+
+            host is required for context initialization..
+            (Or maybe you forgot mark ${this.config.contextName} context as abstract?)
+
+          `;
+        }
+
+        //#region @backend
+        // if (UtilsOs__NS__isRunningInCliMode() && !___NS__isNil(this.config.disabledRealtime)) {
+        //   // TODO for now...
+        //   Helpers__NS__logInfo(`Realtime disable on backend for cli mode`);
+        //   this.disabledRealtime = true;
+        // } else {
+        //   Helpers__NS__logInfo(`Realtime enabled on backend`);
+        // }
+        //#endregion
+
+        this.logRealtime &&
+          Helpers__NS__info(
+            `[ctx=${this.contextName}] Init Realtime for ${this.mode}`,
+          );
+
+        this.realtime = new RealtimeCore(this);
+      }
+      //#endregion
+    }
+
+    //#region show context info
+    // console.log({ ref })
+    if (this.config.abstract) {
+      this.logFramework &&
+        Helpers__NS__info(
+          `[taon] Create abstract context: ${this.config.contextName}`,
+        );
+    } else {
+      if (this.isRemoteHost) {
+        this.logFramework &&
+          Helpers__NS__info(
+            `[taon] Create context for remote host: ${this.config.host}`,
+          );
+      } else {
+        this.logFramework &&
+          Helpers__NS__info(`[taon] Create context for host: ${this.config.host}`);
+      }
+    }
+    //#endregion
+
+    // update first exposed config
+    Object.keys(this.config).forEach(key => {
+      this.originalConfig[key] = this.config[key];
+    });
+  }
+  //#endregion
+
+  //#region methods & getters / get auto generated config
+  private getAutoGeneratedConfig(): Models__NS__DatabaseConfigTypeOrm {
+    this.logFramework &&
+      console.log(`
+
+
+         IS RUNNING IN DOCKER: ${this.isRunningInsideDocker}
+
+    `);
+    //#region @websqlFunc
+    let databaseConfig: Models__NS__DatabaseConfig = Models__NS__DatabaseConfig.from({});
+    const tcpUdpDatabaseSqliteRelativeFileLocation = `${Models__NS__DatabasesFolder}/db-${this.contextName}.sqlite`;
+    if (this.isRunningInsideDocker) {
+      if (this.USE_MARIADB_MYSQL_IN_DOCKER) {
+        // Helpers__NS__info('Running in docker, using in mysql database');
+        // // TODO auto resolve database config in docker
+        // databaseConfig = Models__NS__DatabaseConfig.from({
+        //   database: `db-${this.contextName}.sqlite`,
+        //   type: 'mysql',
+        //   recreateMode: 'PRESERVE_DATA+MIGRATIONS',
+        //   logging: this.logDb,
+        //   databasePort: 3306,
+        //   databaseHost: 'localhost',
+        //   databaseUsername: 'root',
+        //   databasePassword: 'admin',
+        // });
+      } else {
+        // TOOD @LAST for now.. just use sqljs in docker
+        this.logFramework &&
+          console.log(`
+
+          USING GENERATED CONFIG FOR SQLJS IN DOCKER
+
+          `);
+
+        //#region @backend
+        const locationOfTheDatabase = crossPlatformPath([
+          process.cwd(),
+          `db-${this.contextName}.sqlite`,
+        ]);
+        //#endregion
+
+        databaseConfig = databaseConfig = Models__NS__DatabaseConfig.from({
+          location: tcpUdpDatabaseSqliteRelativeFileLocation,
+          type: 'sqljs',
+          useLocalForage: false,
+          recreateMode: 'PRESERVE_DATA+MIGRATIONS',
+          logging: true,
+        });
+
+        //#region @backend
+        if (!fse.existsSync(locationOfTheDatabase)) {
+          databaseConfig.recreateMode = 'DROP_DB+MIGRATIONS';
+        }
+        // TODO @LAST add same thing for mariadb/mysql
+        this.logFramework &&
+          console.log(`
+          location of database: ${locationOfTheDatabase}
+          db file exists: ${fse.existsSync(locationOfTheDatabase)}
+          synchronize: ${databaseConfig.synchronize}
+          dropSchema: ${databaseConfig.dropSchema}
+        `);
+        //#endregion
+      }
+    } else {
+      //#region auto resolve db config
+      this.logFramework &&
+        Helpers__NS__info(
+          `[taon][database] Automatically resolving database config for mode ${this.mode}`,
+        );
+      switch (this.mode) {
+        //#region resolve database config for backend-frontend(ipc-electron)
+        case 'backend-frontend(ipc-electron)':
+          let dbLocationInOs: string;
+          //#region @backend
+          if (UtilsOs__NS__isElectron) {
+            dbLocationInOs = crossPlatformPath([
+              UtilsOs__NS__getRealHomeDir(),
+              `.taon/databases-for-electron-apps/${
+                this.appId || ___NS__snakeCase(process.cwd()).replace(/\_/, '.')
+              }/${this.contextName}.sqlite`,
+            ]);
+            if (!Helpers__NS__exists(path.dirname(dbLocationInOs))) {
+              Helpers__NS__mkdirp(path.dirname(dbLocationInOs));
+            }
+          }
+          //#endregion
+
+          databaseConfig = Models__NS__DatabaseConfig.from({
+            location: UtilsOs__NS__isElectron
+              ? dbLocationInOs
+              : `db-${this.contextName}.sqlite`,
+            type: 'sqljs',
+            recreateMode: 'DROP_DB+MIGRATIONS',
+            logging: this.logDb,
+          });
+          break;
+        //#endregion
+
+        //#region  resolve database config for mode backend-frontend(websql)
+        case 'backend-frontend(websql-electron)':
+        case 'backend-frontend(websql)':
+          let keepWebsqlDbDataAfterReload = false;
+/* */
+/* */
+/* */
+  
+
+          databaseConfig = databaseConfig = Models__NS__DatabaseConfig.from({
+            location: `db-${this.contextName}.sqlite`,
+            type: 'sqljs',
+            useLocalForage: true, // !!window['localforage'], // TODO this need to be checked in runtime
+            recreateMode: keepWebsqlDbDataAfterReload
+              ? 'PRESERVE_DATA+MIGRATIONS'
+              : 'DROP_DB+MIGRATIONS',
+            logging: this.logDb,
+          });
+          break;
+        //#endregion
+
+        //#region resolve database config for mode backend-frontend(tcp+udp)
+        case 'backend-frontend(tcp+udp)':
+          databaseConfig = Models__NS__DatabaseConfig.from({
+            database: `context-db-${this.contextName}`,
+            location: tcpUdpDatabaseSqliteRelativeFileLocation,
+            type: 'sqljs',
+            recreateMode: 'DROP_DB+MIGRATIONS',
+            logging: this.logDb,
+          });
+          break;
+        //#endregion
+      }
+      //#endregion
+    }
+    return databaseConfig.databaseConfigTypeORM;
+    //#endregion
+  }
+  //#endregion
+
+  //#region methods & getters / start server
+  async startServer(): Promise<void> {
+    //#region @backendFunc
+    if (this.isRemoteHost || this.isRunOrRevertOnlyMigrationAppStart) {
+      return;
+    }
+    if (this.mode === 'backend-frontend(tcp+udp)') {
+      return await new Promise(resolve => {
+        if (this.isRunningInsideDocker) {
+          // this.displayRoutes(this.expressApp);
+          this.serverTcpUdp.listen(Number(this.uriPort), '0.0.0.0', () => {
+            this.logFramework &&
+              Helpers__NS__log(
+                `[ctx=${this.contextName}] Express server (inside docker) started 0.0.0.0:${this.uriPort}`,
+              );
+            this.logFramework &&
+              Helpers__NS__log(`[taon][express-server]listening on port: ${this.uriPort}, hostname: ${this.uriPathname},
+    address: ${this.uriProtocol}//localhost:${this.uriPort}${this.uriPathname}
+    ExpressJS mode: ${this.expressApp.settings.env}
+    `);
+            resolve(void 0);
+          });
+        } else {
+          // this.displayRoutes(this.expressApp);
+          this.serverTcpUdp.listen(Number(this.uriPort), () => {
+            this.logFramework &&
+              Helpers__NS__log(
+                `[ctx=${this.contextName}] Express server (inside nodejs app) started on localhost:${this.uriPort}`,
+              );
+            this.logFramework &&
+              Helpers__NS__log(`[taon][express-server]listening on port: ${this.uriPort}, hostname: ${this.uriPathname},
+    address: ${this.uriProtocol}//localhost:${this.uriPort}${this.uriPathname}
+    expressJS mode: ${this.expressApp.settings.env}
+            `);
+            resolve(void 0);
+          });
+        }
+      });
+    } else {
+      this.logFramework &&
+        Helpers__NS__info('Ipc communication enable instead tcp/upd');
+    }
+    //#endregion
+  }
+  //#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
+  private cloneClassWithNewMetadata = <
+    T extends { new (...args: any[]): any },
+  >({
+    TaonBaseClass,
+    className,
+    config,
+    ctx,
+    classType,
+  }: {
+    TaonBaseClass: T;
+    className: string;
+    config: Models__NS__ContextOptions<any, any, any, any, any, any, any, any>;
+    ctx: EndpointContext;
+    classType: Models__NS__ClassType;
+  }): T => {
+    // Return a new class that extends the base class
+    const cloneClass = () => {
+      if (
+        TaonBaseClass[Symbols__NS__fullClassNameStaticProperty] ===
+        `${ctx.contextName}.${className}`
+      ) {
+        return TaonBaseClass;
+      }
+      return class extends TaonBaseClass {
+        // static ['_'] = TaonBaseClass['_'];
+
+        // @ts-ignore
+        static [Symbols__NS__orignalClass] = TaonBaseClass;
+
+        // @ts-ignore
+        static [Symbols__NS__fullClassNameStaticProperty] = `${ctx.contextName}.${className}`;
+
+        // @ts-ignore
+        static [Symbols__NS__classNameStaticProperty] = className;
+
+        static [Symbols__NS__ctxInClassOrClassObj] = ctx;
+
+        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+        static __getFullPathForClass__(arr = []) {
+          const name = this[Symbols__NS__fullClassNameStaticProperty];
+          arr.push(name);
+          // @ts-ignore
+          if (
+            this[Symbols__NS__orignalClass] && // @ts-ignore
+            this[Symbols__NS__orignalClass].__getFullPathForClass__
+          ) {
+            // @ts-ignore
+            this[Symbols__NS__orignalClass].__getFullPathForClass__(arr);
+          }
+          return arr.join('/');
+        }
+
+        static get fullPathForClass(): string {
+          return this.__getFullPathForClass__();
+        }
+
+        [Symbols__NS__ctxInClassOrClassObj] = ctx;
+        // You can override prototype properties or methods here if needed
+        // static properties override allowed
+      };
+    };
+
+    const cloneClassFunction = cloneClass();
+
+    //#region gather all instances for all contexts
+    // TODO this is not needed anymore - for typeorm I use normal entities
+    // this thinng belowe is nice for debugging purpose
+    // if (___NS__isUndefined(cloneClassFunction[Symbols__NS__orignalClassClonesObj])) {
+    //   cloneClassFunction[Symbols__NS__orignalClassClonesObj] = {};
+    // }
+    // if (___NS__isUndefined(TaonBaseClass[Symbols__NS__orignalClassClonesObj])) {
+    //   TaonBaseClass[Symbols__NS__orignalClassClonesObj] = {};
+    // }
+    // const all = {
+    //   ...TaonBaseClass[Symbols__NS__orignalClassClonesObj],
+    //   ...cloneClassFunction[Symbols__NS__orignalClassClonesObj],
+    // };
+    // all[ctx.contextName] = cloneClassFunction;
+    // cloneClassFunction[Symbols__NS__orignalClassClonesObj] = all;
+    // TaonBaseClass[Symbols__NS__orignalClassClonesObj] = all;
+    //#endregion
+
+    return cloneClassFunction;
+  };
+
+  //#endregion
+
+  //#region methods & getters / clone classes obj with new metadata
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  private cloneClassesObjWithNewMetadata = ({
+    classesInput,
+    config,
+    ctx,
+    classType,
+  }: {
+    classesInput: any;
+    config: Models__NS__ContextOptions<any, any, any, any, any, any, any, any>;
+    ctx: EndpointContext;
+    classType: Models__NS__ClassType;
+  }) => {
+    const classes = {};
+    // console.log(Object.keys(classesInput))
+    for (const key of Object.keys(classesInput || {})) {
+      const TaonBaseClass = classesInput[key];
+
+      if (!TaonBaseClass) {
+        Helpers__NS__error(`Class ${key} is not defined in context ${ctx.contextName}
+
+        Please check if you have correct import in context file
+
+        `);
+      }
+
+      var className = Reflect.getMetadata(
+        Symbols__NS__metadata.className,
+        TaonBaseClass,
+      );
+
+      // console.log('Metadata className', className, TaonBaseClass);
+      // if (!className) {
+      //   console.warn(`Please provide className for ${TaonBaseClass.name} class`);
+      // }
+      className = className || key;
+      TaonBaseClass[Symbols__NS__classNameStaticProperty] = className;
+
+      const clonedClass = this.cloneClassWithNewMetadata({
+        TaonBaseClass,
+        className,
+        config,
+        ctx,
+        classType,
+      });
+      classes[className] = clonedClass;
+    }
+    return classes;
+  };
+  //#endregion
+
+  //#region methods & getters / get recursive classes from contexts
+  private async getRecrusiveClassesfromContextsObj(
+    classType: Models__NS__ClassType,
+  ) {
+    const arr = await this.getRecrusiveClassesfromContexts(classType);
+    return arr.reduce((acc, c) => {
+      acc[ClassHelpers__NS__getName(c)] = c;
+      return acc;
+    }, {});
+  }
+
+  private async getRecrusiveClassesfromContexts(
+    classType: Models__NS__ClassType,
+    arr = [],
+  ) {
+    const contexts = Object.values(this.config.contexts || {}) as ReturnType<
+      typeof createContext
+    >[];
+    // 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 as Function[];
+  }
+  //#endregion
+
+  //#region methods & getters / get class instances by class type
+  getClassInstanceObjBy(classType: Models__NS__ClassType): any {
+    return this.classInstancesByNameObj[classType];
+  }
+  //#endregion
+
+  //#region methods & getters / get class instances arr
+  private getClassesInstancesArrBy(classType: Models__NS__ClassType): any[] {
+    return this.objWithClassesInstancesArr[classType];
+  }
+  //#endregion
+
+  //#region methods & getters / inject
+  inject<T>(
+    ctor: new (...args: any[]) => T,
+    options: {
+      localInstance?: boolean;
+      contextClassInstance?: TaonBaseInjector;
+      locaInstanceConstructorArgs?: ConstructorParameters<typeof ctor>;
+      parentInstanceThatWillGetInjectedStuff: object;
+    },
+  ): T {
+    const className = ClassHelpers__NS__getName(ctor);
+
+    const locaInstanceConstructorArgs =
+      options.locaInstanceConstructorArgs || [];
+
+    if (this.isCLassType(Models__NS__ClassType.REPOSITORY, ctor)) {
+      options.localInstance = true;
+    }
+
+    if (options?.localInstance) {
+      const ctxClassFn = this.getClassFunByClassName(className);
+      let entityName: string = '';
+
+      // entity thing is only for repositories local repositories
+      // if (className === 'TaonBaseRepository') {
+      const entityFn = ___NS__first(locaInstanceConstructorArgs);
+      const entity = entityFn && entityFn();
+      entityName = (entity && ClassHelpers__NS__getName(entity)) || '';
+      // console.log(`entityName `, entityName);
+      // }
+
+      if (!options.contextClassInstance[this.localInstaceObjSymbol]) {
+        options.contextClassInstance[this.localInstaceObjSymbol] = {};
+      }
+      const instanceKey = className + (entityName ? `.${entityName}` : '');
+
+      const existed =
+        options.contextClassInstance[this.localInstaceObjSymbol][instanceKey];
+
+      if (existed) {
+        // console.log(
+        //   `EXISTED ${ClassHelpers__NS__getName(options.parentInstanceThatWillGetInjectedStuff)} Inject ${className} instanceKey "${instanceKey}"`,
+        // );
+        return existed;
+      }
+
+      // console.log(
+      //   `NEW ${ClassHelpers__NS__getName(options.parentInstanceThatWillGetInjectedStuff)} Inject ${className} instanceKey "${instanceKey}"`,
+      // );
+
+      if (!ctxClassFn) {
+        throw new Error(`Not able to inject "${className}" inside context "${this.contextName}"
+
+        Make sure they share the same context or import context where "${className}" is defined.
+
+        `);
+      }
+
+      const injectedInstance = new (ctxClassFn as any)(
+        ...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<T>(ctor: new (...args: any[]) => T): T {
+    // if (!!this.__contextForControllerInstanceAccess) {
+    //   const className = ClassHelpers__NS__getName(ctor);
+    //   const allControllers = this.getClassFunByArr(Models__NS__ClassType.CONTROLLER);
+
+    //   // TODO QUICK_FIX cache controllers
+    //   for (const ctrl of allControllers) {
+    //     if (ClassHelpers__NS__getName(ctrl) === className) {
+    //       // console.log('injecting from contextForControllerInstanceAcesss', className);
+    //       return this.__contextForControllerInstanceAccess.inject(ctor, {
+    //         localInstance: false,
+    //       });
+    //     }
+    //   }
+    // }
+
+    return this.inject(ctor, {
+      localInstance: false,
+      parentInstanceThatWillGetInjectedStuff: this,
+    });
+  }
+  //#endregion
+
+  //#region methods & getters / check if context initialized
+  checkIfContextInitialized() {
+    if (___NS__isUndefined(this.config)) {
+      throw new Error(`Please check if your context has been initialized.
+
+      // ...
+      await Context.initialize();
+      // ...
+
+
+      `);
+    }
+  }
+  //#endregion
+
+  //#region methods & getters / get class function by class type name
+  getClassFunBy(classType: Models__NS__ClassType) {
+    this.checkIfContextInitialized();
+    switch (classType) {
+      case Models__NS__ClassType.CONTROLLER:
+        return this.config.controllers;
+      case Models__NS__ClassType.ENTITY:
+        return this.config.entities;
+      case Models__NS__ClassType.PROVIDER:
+        return this.config.providers;
+      case Models__NS__ClassType.MIDDLEWARE:
+        return this.config.middlewares;
+      case Models__NS__ClassType.REPOSITORY:
+        return this.config.repositories;
+      case Models__NS__ClassType.SUBSCRIBER:
+        return this.config.subscribers;
+      case Models__NS__ClassType.MIGRATION:
+        return this.config.migrations;
+    }
+  }
+
+  isCLassType(classType: Models__NS__ClassType, classFn: Function): boolean {
+    return !!this.getClassFunBy(classType)[ClassHelpers__NS__getName(classFn)];
+  }
+
+  /**
+   * Only for injectable types
+   * Only for classType: CONTROLLER, REPOSITORY, PROVIDER, MIDDLEWARES
+   */
+  getClassFunByClassName(className: string): Function {
+    for (const classTypeName of this.allTypesfromContexts) {
+      const classesForInjectableType =
+        this.config[Models__NS__ClassTypeKey[classTypeName]];
+
+      if (classesForInjectableType[className]) {
+        return classesForInjectableType[className];
+      }
+    }
+  }
+
+  getClassFunByClass(classFunction: Function): Function {
+    const className = ClassHelpers__NS__getName(classFunction);
+    return this.getClassFunByClassName(className);
+  }
+
+  getClassFunByArr(classType: Models__NS__ClassType) {
+    return Object.values(this.getClassFunBy(classType) || {}) as Function[];
+  }
+  //#endregion
+
+  //#region methods & getters / create class instances
+  private async createInstances(classes: any, classType: Models__NS__ClassType) {
+    // const recrusiveValuesFromContext =
+    //   await this.getRecrusiveClassesfromContexts(classType);
+    // console.log(this.config.contexts);
+    // console.log('recrusiveValuesFromContext', recrusiveValuesFromContext);
+
+    for (const classFn of [
+      // ...recrusiveValuesFromContext,
+      ...Object.values(classes),
+    ]) {
+      const instance = DITaonContainer.resolve(classFn as any) as any;
+      const classInstancesByNameObj = this.classInstancesByNameObj[classType];
+      const className = ClassHelpers__NS__getName(classFn);
+      // console.log({ classFn, classType, instance, place, className, 'classInstancesByNameObj': this.classInstancesByNameObj });
+      classInstancesByNameObj[className] = instance;
+      // update config
+      this.config[Models__NS__ClassTypeKey[classType]][className] = classFn;
+      this.objWithClassesInstancesArr[classType].push(instance);
+      this.allClassesInstances[className] = instance;
+    }
+  }
+  //#endregion
+
+  //#region methods & getters / init classes
+  async initClasses(): Promise<void> {
+    if (this.isRemoteHost) {
+      return;
+    }
+
+    //#region @websql
+    for (const classFun of this.getClassFunByArr(
+      Models__NS__ClassType.ENTITY,
+    ) as any[]) {
+      const repo = (await this.connection.getRepository(
+        ClassHelpers__NS__getOrginalClass(classFun),
+      )) as any;
+      this.repos.set(ClassHelpers__NS__getName(classFun), repo);
+    }
+    //#endregion
+
+    for (const classTypeName of [
+      Models__NS__ClassType.MIDDLEWARE,
+      Models__NS__ClassType.PROVIDER,
+      Models__NS__ClassType.REPOSITORY,
+      Models__NS__ClassType.CONTROLLER,
+      Models__NS__ClassType.ENTITY,
+      Models__NS__ClassType.MIGRATION,
+    ]) {
+      //#region init class static _ property
+      for (const classFun of this.getClassFunByArr(classTypeName) as any[]) {
+        if (___NS__isFunction(classFun._)) {
+          await classFun._();
+        }
+      }
+      //#endregion
+    }
+
+    for (const classTypeName of [
+      Models__NS__ClassType.MIDDLEWARE,
+      Models__NS__ClassType.PROVIDER,
+      Models__NS__ClassType.REPOSITORY,
+      Models__NS__ClassType.CONTROLLER,
+      Models__NS__ClassType.MIGRATION,
+    ]) {
+      //#region init providers, repositories  _ property
+      // Helpers__NS__taskStarted(
+      //   `[taon] REINITING _ INS FN ${classTypeName} ${this.contextName} STARTED`,
+      // );
+      for (const ctrl of this.getClassesInstancesArrBy(classTypeName)) {
+        if (___NS__isFunction(ctrl._)) {
+          await ctrl._();
+        }
+      }
+      // Helpers__NS__taskStarted(
+      //   `[taon] REINITING _ INS FN ${classTypeName} ${this.contextName} DONE`,
+      // );
+      //#endregion
+    }
+  }
+  //#endregion
+
+  //#region methods & getters / is active on
+  isActiveOn(classInstance: object): boolean {
+    let contextRef: EndpointContext =
+      classInstance[Symbols__NS__ctxInClassOrClassObj];
+    return this === contextRef;
+  }
+  //#endregion
+
+  //#region methods & getters / uri
+  get frontendHostUri() {
+    const url = this.config?.frontendHost?.startsWith('http')
+      ? this.config.frontendHost
+      : `${globalThis?.location?.protocol || 'http:'}//${
+          this.config?.frontendHost
+        }`;
+    const uri = new URL(url.replace(/\/$/, ''));
+    return uri;
+  }
+
+  get uri(): URL | undefined {
+    const url = this.host ? new URL(this.host) : void 0;
+    return url;
+  }
+  //#endregion
+
+  //#region methods & getters / host uri protocol
+  get uriProtocol(): string | undefined {
+    return this.uri?.protocol;
+  }
+  //#endregion
+
+  //#region methods & getters / host uri origin
+  /**
+   * Examples
+   * http://localhost:3000
+   * https://localhost (from localhost:80)   *
+   */
+  get uriOrigin(): string | undefined {
+    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(): string | undefined {
+    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(): string {
+    const isNonRootProperPathName =
+      this.uri?.pathname && this.uri.pathname !== '/';
+    return isNonRootProperPathName ? this.uri.pathname.replace(/\/$/, '') : '';
+  }
+  //#endregion
+
+  //#region methods & getters / port from uri
+  get uriPort(): string | undefined {
+    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(): Number | undefined {
+    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
+   */
+  public get isRemoteHost(): boolean {
+    return !!this.cloneOptions?.useAsRemoteContext;
+  }
+  //#endregion
+
+  //#region methods & getters / context name
+  /**
+   * ipc/udp needs this
+   */
+  public get contextName(): string {
+    // console.log(this.originalConfig);
+    return this.config?.contextName || this.originalConfig?.contextName;
+  }
+  //#endregion
+
+  //#region methods & getters / context name for communication
+  /**
+   * ipc/udp needs this
+   */
+  public get contextNameForCommunication(): string {
+    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
+   */
+  public get contextType(): 'normal' | 'remote' | 'abstract' | 'invalid' {
+    if (this.config.abstract) {
+      return 'abstract';
+    }
+    if (this.host) {
+      return this.isRemoteHost ? 'remote' : 'normal';
+    }
+    return 'invalid';
+  }
+  //#endregion
+
+  //#region methods & getters / current working directory
+  public get cwd(): string {
+    return this.config.cwd || process.cwd();
+  }
+  //#endregion
+
+  //#region methods & getters / active context
+  public get activeContext(): string | null {
+    return this.config.activeContext || null;
+  }
+  //#endregion
+
+  //#region methods & getters / app id
+  public get appId(): string {
+    return this.config.appId;
+  }
+  //#endregion
+
+  //#region methods & getters / public assets
+  public 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(): string | undefined {
+    return this.config.host;
+  }
+  //#endregion
+
+  //#region methods & getters / origin
+  get origin(): string | undefined {
+    return this.uri?.origin;
+  }
+  //#endregion
+
+  //#region methods & getters / init subscribers
+  async initSubscribers() {
+    //#region @websqlFunc
+    if (this.isRemoteHost) {
+      return;
+    }
+    const subscriberClasses = this.getClassFunByArr(
+      Models__NS__ClassType.SUBSCRIBER,
+    );
+    for (const subscriberClassFn of subscriberClasses) {
+      const options = Reflect.getMetadata(
+        Symbols__NS__metadata.options.subscriber,
+        subscriberClassFn,
+      ) as TaonSubscriberOptions;
+      // console.log('subscriber options', options);
+      // const nameForSubscriber = ClassHelpers__NS__getName(subscriber);
+      EventSubscriber()(subscriberClassFn);
+    }
+    //#endregion
+  }
+  //#endregion
+
+  //#region methods & getters / init entities
+  async initEntities() {
+    //#region @websql
+    if (this.isRemoteHost) {
+      return;
+    }
+    const entities = this.getClassFunByArr(Models__NS__ClassType.ENTITY);
+
+    for (const entity of entities) {
+      const options = Reflect.getMetadata(
+        Symbols__NS__metadata.options.entity,
+        entity,
+      ) as TaonEntityOptions;
+      const createTable = ___NS__isUndefined(options.createTable)
+        ? true
+        : options.createTable;
+
+      const nameForEntity = ClassHelpers__NS__getName(entity);
+
+      if (createTable) {
+        this.logDb &&
+          console.info(
+            `[taon][typeorm] create table for entity "${nameForEntity}" ? '${createTable}'`,
+          );
+        // console.log('TypeormEntity', { TypeormEntity });
+        TypeormEntity(nameForEntity)(entity);
+      } else {
+        this.logDb &&
+          console.info(
+            `[taon][typeorm] create table for entity "${nameForEntity}" ? '${createTable}'`,
+          );
+      }
+    }
+    //#endregion
+  }
+
+  //#endregion
+
+  //#region methods & getters / destroy
+  async destroy(): Promise<void> {
+    //#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(): Promise<void> {
+    //#region @websqlFunc
+    if (this.isRemoteHost || !this.databaseConfig) {
+      return;
+    }
+    const entities = this.getClassFunByArr(Models__NS__ClassType.ENTITY).map(
+      entityFn => {
+        return ClassHelpers__NS__getOrginalClass(entityFn);
+      },
+    );
+
+    const subscribers = this.getClassFunByArr(Models__NS__ClassType.SUBSCRIBER);
+
+    let autoSave = false;
+    if (!___NS__isNil(this.databaseConfig.autoSave)) {
+      autoSave = this.databaseConfig.autoSave;
+    } else {
+      if (this.USE_MARIADB_MYSQL_IN_DOCKER) {
+        autoSave = !this.isRunningInsideDocker; // in docker I am using mysql or posgress
+      } else {
+        autoSave = true; // on docker with sqljs I need to save db
+      }
+    }
+
+    const dataSourceDbConfig = ___NS__isObject(this.databaseConfig)
+      ? ({
+          type: this.databaseConfig.type,
+          port: this.databaseConfig.databasePort,
+          host: this.databaseConfig.databaseHost,
+          database: this.databaseConfig.database as any,
+          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,
+        } as DataSourceOptions)
+      : ({} as DataSourceOptions);
+
+    // debugger;
+    this.logFramework &&
+      console.log(
+        `[Context: "${this.contextName}"] dataSourceDbConfig`,
+        dataSourceDbConfig,
+      );
+
+    if (this.modeAllowsDatabaseCreation && this.databaseConfig) {
+      this.logDb &&
+        this.logFramework &&
+        Helpers__NS__info('[taon][database] prepare typeorm connection...');
+      try {
+        const connection = new DataSource(dataSourceDbConfig);
+        this.connection = connection;
+        await this.connection.initialize();
+      } catch (error) {
+        console.error(
+          `[taon][typeorm] Error while initializing connection for ${this.contextName}, ERROR STARTED `,
+        );
+        console.error(error?.stack || '< No stack trace > ');
+        console.error(error?.message || error);
+        console.error(
+          `[taon][typeorm] Error while initializing connection for ${this.contextName}, ERROR ENDS `,
+        );
+      }
+
+      if (!this.connection?.isInitialized) {
+        console.log('WRONG CONFIG', dataSourceDbConfig);
+        throw new Error(`Something wrong with connection init in ${this.mode}`);
+        //#region @backend
+        process.exit(1);
+        //#endregion
+      }
+
+      if (this.logDb || this.logFramework) {
+        console.info(
+          `
+
+        CONTECTION OK for ${this.contextName} - ${this.mode}
+
+        [taon][typeorm] db prepration done.. db initialize=${this.connection?.isInitialized}
+
+
+        `,
+          // dataSourceDbConfig,
+          { 'this.connection': !!this.connection },
+        );
+        console.log(
+          `Database file location: ${this.connection.options.database}`,
+        );
+      }
+      //     const entityMetadata = getMetadataArgsStorage();
+      //     console.log(
+      //       `
+
+      // entityMetadata after connection init for ${this.contextName} - ${this.mode}
+
+      // `,
+      //       entityMetadata,
+      //     );
+      //     debugger;
+    } else {
+      Helpers__NS__info(`[taon][typeorm] Not initing db for mode ${this.mode}`);
+    }
+    //#endregion
+  }
+
+  //#endregion
+
+  //#region methods & getters / initialize metadata
+
+  //#region methods & getters / update class calculate path
+  private updateCalculatedPathsForControllers(
+    rawConfigs: ControllerConfig[],
+    classConfig: ControllerConfig,
+    controllerClassFn: Function,
+  ): void {
+    const parentsCalculatedPath = ___NS__slice(rawConfigs, 1)
+      .reverse()
+      .map(bc => {
+        if (TaonHelpers__NS__isGoodPath(bc.path)) {
+          return bc.path;
+        }
+        return bc.className;
+      })
+      .join('/');
+
+    const contextNameForCommunication = this.contextNameForCommunication;
+
+    if (TaonHelpers__NS__isGoodPath(classConfig.path)) {
+      classConfig.calculatedPath = classConfig.path;
+    } else {
+      classConfig.calculatedPath = (
+        `${this.uriPathnameOrNothingIfRoot}` +
+        `/${apiPrefix}/${contextNameForCommunication}/tcp${parentsCalculatedPath}/` +
+        `${ClassHelpers__NS__getName(controllerClassFn)}`
+      )
+        .replace(/\/\//g, '/')
+        .split('/')
+        .reduce((acc, bc) => {
+          return ___NS__last(acc) === bc ? acc : [...acc, bc];
+        }, [])
+        .join('/');
+    }
+
+    // console.log('calculatedPath', classConfig.calculatedPath);
+  }
+  //#endregion
+
+  //#region methods & getters / dedupe class configs
+  private mergeControllerMethodsConfigs(
+    rawConfigs: ControllerConfig[],
+    classConfig: ControllerConfig,
+    controllerClassFn: Function,
+  ): void {
+    const currentControllerMethodsConfig = classConfig.methods;
+
+    ___NS__slice(rawConfigs, 1).forEach(bc => {
+      const parentControllerMethods = ___NS__cloneDeep(bc.methods);
+
+      for (const methodsName in parentControllerMethods) {
+        if (parentControllerMethods.hasOwnProperty(methodsName)) {
+          if (!currentControllerMethodsConfig[methodsName]) {
+            //#region add non existed method
+            const methodConfig = parentControllerMethods[methodsName];
+            currentControllerMethodsConfig[methodsName] = methodConfig;
+            //#endregion
+          }
+        }
+      }
+    });
+  }
+
+  //#endregion
+  async initControllersHook(
+    ctxStorage: ContextsEndpointStorage,
+  ): Promise<void> {
+    if (this.isRunOrRevertOnlyMigrationAppStart) {
+      return;
+    }
+    const allControllers = this.getClassFunByArr(Models__NS__ClassType.CONTROLLER);
+    for (const controllerClassFn of allControllers) {
+      const instance = this.getInstanceBy(
+        controllerClassFn as any,
+      ) as TaonBaseController;
+      if (___NS__isFunction(instance.afterAllCtxInited)) {
+        await instance.afterAllCtxInited({ ctxStorage });
+      }
+    }
+  }
+
+  async initControllers(): Promise<void> {
+    if (this.isRunOrRevertOnlyMigrationAppStart) {
+      return;
+    }
+    const allControllers = this.getClassFunByArr(Models__NS__ClassType.CONTROLLER);
+    // debugger
+    // console.log('allControllers', allControllers);
+    for (const controllerClassFn of allControllers) {
+      // console.log(ClassHelpers__NS__getClassConfig(controllerClassFn));
+
+      // const controllerName = ClassHelpers__NS__getName(controllerClassFn);
+
+      // console.log(
+      //   `for ${controllerName}`,
+      //   ClassHelpers__NS__getClassConfig(controllerClassFn),
+      // );
+
+      controllerClassFn[Symbols__NS__classMethodsNames] =
+        ClassHelpers__NS__getMethodsNames(controllerClassFn);
+
+      const rawConfigs = ClassHelpers__NS__getControllerConfigs(controllerClassFn);
+      // console.log(controllerName, { rawConfigs });
+      // console.log(`Class config for ${ClassHelpers__NS__getName(controllerClassFn)}`, configs)
+      const classConfig: ControllerConfig = rawConfigs[0];
+
+      this.updateCalculatedPathsForControllers(
+        rawConfigs,
+        classConfig,
+        controllerClassFn,
+      );
+      this.mergeControllerMethodsConfigs(
+        rawConfigs,
+        classConfig,
+        controllerClassFn,
+      );
+
+      //#region combine middlewares from controllers
+      classConfig.calculatedMiddlewaresControllerObj = {};
+      [...rawConfigs].reverse().forEach(rc => {
+        if (___NS__isFunction(rc.middlewares)) {
+          classConfig.calculatedMiddlewaresControllerObj = rc.middlewares({
+            parentMiddlewares: classConfig.calculatedMiddlewaresControllerObj,
+            className(middlewareClass) {
+              return ClassHelpers__NS__getName(controllerClassFn);
+            },
+          });
+        }
+      });
+      //#endregion
+
+      //#region group start
+      //#region @backend
+      if (!UtilsOs__NS__isRunningInCliMode()) {
+        //#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: Partial<MethodConfig> =
+          classConfig.methods[methodName];
+
+        //#region combine all class methods middlewares
+        let calculatedMiddlewaresMethodObj = {};
+
+        [...rawConfigs].reverse().forEach(rc => {
+          if (rc.methods[methodName]) {
+            const parentMethodConfig = rc.methods[methodName];
+
+            if (___NS__isFunction(parentMethodConfig.middlewares)) {
+              calculatedMiddlewaresMethodObj = parentMethodConfig.middlewares({
+                parentMiddlewares: calculatedMiddlewaresMethodObj,
+                className(middlewareClass) {
+                  return ClassHelpers__NS__getName(controllerClassFn);
+                },
+              });
+            }
+          }
+        });
+
+        // add class middlewares to method middlewares
+        methodConfig.calculatedMiddlewaresMethodObj = {
+          ...calculatedMiddlewaresMethodObj,
+          ...classConfig.calculatedMiddlewaresControllerObj,
+        };
+        methodConfig.calculatedMiddlewares = Object.values(
+          methodConfig.calculatedMiddlewaresMethodObj || {},
+        );
+        //#endregion
+
+        // methodConfig.calculatedMiddlewares = TODO
+
+        //#region initialized method express path
+        const httpMethodType: CoreModels__NS__HttpMethod = methodConfig.type;
+
+        // this is quick fix - in docker global path should not be used
+        const globalPathPart =
+          this.isRunningInsideDocker ||
+          !this.frontendHostUri?.origin?.includes('localhost') // fe with domain -> is in docker
+            ? `${this.uriPathnameOrNothingIfRoot.replace(
+                /\/$/,
+                '',
+              )}/${apiPrefix}/${this.contextName}`.replace(/\/\//, '/')
+            : '';
+        const expressPath = methodConfig.global
+          ? `${globalPathPart}/${methodConfig.path?.replace(
+              /\/$/,
+              '',
+            )}`.replace(/\/\//, '/')
+          : TaonHelpers__NS__getExpressPath(classConfig, methodConfig);
+
+        //#endregion
+
+        //#region init server
+        // console.log({ expressPath });
+        if (UtilsOs__NS__isNode || UtilsOs__NS__isWebSQL) {
+          //#region @websql
+
+          const route = this.initServer(
+            httpMethodType,
+            methodConfig,
+            classConfig,
+            expressPath,
+            controllerClassFn,
+          );
+
+          this.activeRoutes.push({
+            expressPath: route.expressPath,
+            method: route.method,
+          });
+          //#endregion
+        }
+        //#endregion
+
+        //#region init client
+        const shouldInitClient =
+          UtilsOs__NS__isBrowser || this.isRemoteHost || UtilsOs__NS__isWebSQL;
+        // console.log('shouldInitClient', shouldInitClient);
+        if (shouldInitClient) {
+          // console.log(
+          //   'initClient',
+          //   ClassHelpers__NS__getFullInternalName(controllerClassFn),
+          //   type,
+          //   methodConfig,
+          //   expressPath,
+          // );
+          await this.initClient(
+            controllerClassFn,
+            httpMethodType,
+            methodConfig as any,
+            expressPath,
+          );
+        }
+        //#endregion
+      }
+      //#endregion
+
+      //#region group end
+      //#region @backend
+      if (!UtilsOs__NS__isRunningInCliMode()) {
+        //#endregion
+        this.logHttp && console.groupEnd();
+        //#region @backend
+      }
+      //#endregion
+      //#endregion
+    }
+  }
+  //#endregion
+
+  //#region methods & getters / write active routes
+  public writeActiveRoutes(): void {
+    if (this.isRemoteHost || this.isRunOrRevertOnlyMigrationAppStart) {
+      return;
+    }
+    // const contexts: EndpointContext[] = [this];
+    //#region @websql
+
+    const troutes = Utils__NS__uniqArray(
+      this.activeRoutes.map(f => {
+        return `${f.method} ${f.expressPath}`;
+      }),
+    ).map(f => {
+      const [method, expressPath] = f.split(' ');
+      return (
+        `\n### ${___NS__startCase(___NS__last(expressPath.split('/')))}\n` +
+        TaonHelpers__NS__fillUpTo(method.toUpperCase() + ' ', 10) +
+        this.uriOrigin +
+        expressPath
+      );
+
+      // return `${TaonHelpers.string(method.toUpperCase() + ':')
+      // .fillUpTo(10)}${context.uriHref.replace(/\/$/, '')}${expressPath}`
+    });
+    const routes = [
+      ...['', `#  ROUTES FOR HOST ${this.uriOrigin} `],
+      ...troutes,
+    ].join('\n');
+
+    const fileName = crossPlatformPath([
+      //#region @backend
+      process.cwd(),
+      //#endregion
+      `routes/routes-${this.config.contextName}.rest`,
+    ]);
+
+    this.logFramework && console.log(`[taon] routes file: ${fileName} `);
+    this.logRoutes && console.log(routes);
+    //#region @backend
+    if (!UtilsOs__NS__isElectron && !this.skipWritingServerRoutes) {
+      Helpers__NS__writeFile(fileName, routes);
+    }
+    //#endregion
+    //#endregion
+  }
+  //#endregion
+
+  //#region methods & getters / middlewares
+  public get middlewares(): Models__NS__MiddlewareType[] {
+    //#region @backendFunc
+    return this.config.middlewares || [];
+    //#endregion
+  }
+  //#endregion
+
+  //#region methods & getters / init middlewares
+
+  private async initCustomClientMiddlewares(): Promise<void> {
+    const middlewares = this.getClassesInstancesArrBy(
+      Models__NS__ClassType.MIDDLEWARE,
+    )
+      .map(f => f as TaonBaseMiddleware)
+      .filter(f => ___NS__isFunction(f.interceptClient));
+
+    middlewares.forEach(middlewareInstanceName => {
+      const contextName = this.contextName;
+      const interceptorName = `${contextName}-${ClassHelpers__NS__getName(
+        middlewareInstanceName,
+      )}`;
+      Resource.request.interceptors.set(interceptorName, {
+        intercept: ({ req, next }) => {
+          const url = new URL(req.url);
+          if (
+            url.pathname.startsWith(
+              `${this.uriPathnameOrNothingIfRoot}/${apiPrefix}/${contextName}/`,
+            )
+          ) {
+            // console.log('intercepting', url.pathname, req);
+            return middlewareInstanceName.interceptClient({
+              req,
+              next,
+            });
+          }
+          return next.handle(req);
+        },
+      });
+    });
+  }
+
+  private async initCustomBackendMiddlewares(): Promise<void> {
+    //#region @backend
+    const app = this.expressApp;
+    const middlewares = this.getClassesInstancesArrBy(
+      Models__NS__ClassType.MIDDLEWARE,
+    );
+
+    for (const middleware of middlewares) {
+      const middlewareInstance: TaonBaseMiddleware = middleware as any;
+      if (___NS__isFunction(middlewareInstance.interceptServer)) {
+        const middlewareFn = ClassHelpers__NS__asyncHandler(
+          async (
+            req: express.Request,
+            res: express.Response,
+            next: express.NextFunction,
+          ) => {
+            if (
+              req.originalUrl.startsWith(
+                `${this.uriPathnameOrNothingIfRoot}/${apiPrefix}/${this.contextName}/`,
+              )
+            ) {
+              await middlewareInstance.interceptServer({
+                req,
+                res,
+                next,
+              });
+            } else {
+              next();
+            }
+          },
+        );
+
+        app.use(middlewareFn);
+      }
+    }
+    //#endregion
+  }
+
+  private async initBackendMiddlewares(): Promise<void> {
+    //#region @backend
+    const app = this.expressApp;
+
+    // if (this.middlewares) {
+    //   this.middlewares.forEach(m => {
+    //     const [fun, args] = m;
+    //     app.use(fun.apply(null, args));
+    //   });
+    // }
+
+    this.expressApp.get('/helloworld', (req, res) => {
+      res.send(`Hello, world from context ${this.contextName}`);
+    });
+
+    // app.use(fileUpload());
+    app.use(bodyParser.urlencoded({ extended: true }));
+    app.use(bodyParser.json());
+    app.use(methodOverride());
+    app.use(cookieParser());
+
+    if (this.session) {
+      Helpers__NS__info(
+        '[taon][express-server] session enabled for this context ' +
+          this.contextName,
+      );
+      const { cookieMaxAge } = this.session;
+      const frontendHost = this.config.frontendHost;
+
+      const sessionObj = {
+        frontendHost,
+        secret: 'mysecretsessioncookithing',
+        saveUninitialized: true,
+        cookieMaxAge,
+        secure: frontendHost.startsWith('https://'),
+        resave: false,
+      } as Models__NS__ISession;
+
+      app.use(
+        cors({
+          credentials: true,
+          origin: frontendHost,
+        }),
+      );
+      app.use(expressSession(sessionObj));
+      console.log(`
+
+      CORS ENABLED FOR SESSION
+
+      `);
+    } else {
+      // if(this.config?.serverLogs) {
+      this.logHttp &&
+        Helpers__NS__info(
+          `[taon][express-server] session not enabled for this context '${this.contextName}'`,
+        );
+      // }
+      app.use(
+        cors({
+          // origin: "http://localhost:5555",
+          // methods: ["GET", "POST"],
+          // allowedHeaders: ["my-custom-header"],
+          // credentials: true
+        }),
+      );
+      this.logHttp &&
+        console.log(`
+
+      CORS ENABLED WITHOUT SESSION
+
+      `);
+    }
+
+    (() => {
+      app.use((req, res, next) => {
+        //#region good for cors session obj
+        // if (this.context.session) {
+        //   res.header('Access-Control-Allow-Origin', this.context.session.frontendHost);
+        //   res.header('Access-Control-Allow-Credentials', 'true');
+        //   res.header(
+        //     'Access-Control-Allow-Headers',
+        //     'Origin, X-Requested-With, Content-Type, Accept'
+        //   );
+        //   res.header("Access-Control-Allow-Methods", "PUT,POST,GET,HEAD,DELETE,OPTIONS,PATCH");
+        // // maybe this
+        // res.header("Access-Control-Allow-Headers", "Content-Type,Content-Length, Authorization, Accept,X-Requested-With");
+        // }
+        //#endregion
+
+        res.set(
+          'Access-Control-Expose-Headers',
+          [
+            'Content-Type',
+            'Authorization',
+            'X-Requested-With',
+            Symbols__NS__old.X_TOTAL_COUNT,
+            Symbols__NS__old.MAPPING_CONFIG_HEADER,
+            Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY,
+            Symbols__NS__old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM,
+          ].join(', '),
+        );
+        next();
+      });
+    })();
+
+    //#endregion
+  }
+  //#endregion
+
+  //#region methods & getters / init methods node
+  private initServer(
+    //#region parameters
+    httpMethodType: CoreModels__NS__HttpMethod,
+    methodConfig: Partial<MethodConfig>,
+    classConfig: ControllerConfig,
+    expressPath: string,
+    target: Function,
+    //#endregion
+  ): { expressPath: string; method: CoreModels__NS__HttpMethod } {
+    //#region resolve variables
+    // console.log(
+    //   `CLIENT: expressPath: "${expressPath}" interceptor for method: ${methodConfig.calculatedMiddlewares.length}`,
+    // );
+
+    const middlewareHandlers = methodConfig.calculatedMiddlewares
+      .map(middlewareClassFun => {
+        const middlewareInstance: TaonBaseMiddleware = this.getInstanceBy(
+          middlewareClassFun as any,
+        );
+        if (
+          middlewareInstance &&
+          ___NS__isFunction(middlewareInstance.interceptServerMethod)
+        ) {
+          const middlewareFn = ClassHelpers__NS__asyncHandler(
+            async (
+              req: express.Request,
+              res: express.Response,
+              next: express.NextFunction,
+            ) => {
+              await middlewareInstance.interceptServerMethod(
+                {
+                  req,
+                  res,
+                  next,
+                },
+                {
+                  methodName: methodConfig.methodName,
+                  expressPath,
+                  httpRequestType: methodConfig.type,
+                },
+              );
+            },
+          );
+          return middlewareFn;
+        }
+      })
+      .filter(f => !!f) as express.RequestHandler[];
+
+    // const url = this.uri;
+
+    //#region get result
+    const getResult = async (resolvedParams, req, res) => {
+      const response: Models__NS__Http__NS__Response<any> =
+        methodConfig.descriptor.value.apply(
+          /**
+           * Context for method @GET,@PUT etc.
+           */
+          this.getInstanceBy(target as any),
+          /**
+           * Params for method @GET, @PUT etc.
+           */
+          resolvedParams,
+        );
+      let result = await getResponseValue(response, { req, res });
+      return result;
+    };
+    //#endregion
+
+    // console.log(`BACKEND: expressPath: "${expressPath}" `);
+    //#endregion
+
+    if (UtilsOs__NS__isElectron) {
+      //#region @backend
+      const ipcKeyName = TaonHelpers__NS__ipcKeyNameRequest(
+        target,
+        methodConfig,
+        expressPath,
+      );
+      ipcMain.on(ipcKeyName, async (event, paramsFromBrowser) => {
+        const responseJsonData = await getResult(
+          paramsFromBrowser,
+          void 0,
+          void 0,
+        );
+        const sendToIpsMainOn = TaonHelpers__NS__ipcKeyNameResponse(
+          target,
+          methodConfig,
+          expressPath,
+        );
+        // console.log({ sendToIpsMainOn });
+        event.sender.send(sendToIpsMainOn, responseJsonData);
+      });
+      return {
+        expressPath,
+        method: methodConfig.type,
+      };
+      //#endregion
+    }
+
+    if (!this.isRemoteHost) {
+      //#region apply dummy websql express routers
+      //#region @websql
+      if (UtilsOs__NS__isWebSQL) {
+        if (!this.expressApp[httpMethodType.toLowerCase()]) {
+          this.expressApp[httpMethodType.toLowerCase()] = () => {};
+          // TODO add middlewares for WEBSQL and ELECTRON mode
+        }
+      }
+      //#endregion
+      //#endregion
+
+      //#region @backend
+      // this.logHttp &&
+      //   console.log(`[${httpMethodType.toUpperCase()}] ${expressPath} `);
+      this.expressApp[httpMethodType.toLowerCase()](
+        expressPath,
+        ...middlewareHandlers,
+        async (req: express.Request, res: express.Response) => {
+          // console.log(`[${type.toUpperCase()}] ${expressPath} `);
+          //#region process params
+          const args: any[] = [];
+
+          let tBody = req.body;
+          let tParams = req.params;
+          let tQuery: Object = req.query;
+
+          if (req.headers[Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY]) {
+            try {
+              tBody = JSON.parse(
+                JSON.stringify(tBody),
+                JSON.parse(
+                  TaonHelpers__NS__firstStringOrElemFromArray(
+                    req.headers[Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY],
+                  ),
+                ),
+              );
+            } catch (e) {}
+          }
+
+          if (req.headers[Symbols__NS__old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM]) {
+            try {
+              tQuery = JSON.parse(
+                JSON.stringify(tQuery),
+                JSON.parse(
+                  TaonHelpers__NS__firstStringOrElemFromArray(
+                    req.headers[Symbols__NS__old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM],
+                  ),
+                ),
+              );
+            } catch (e) {}
+          }
+
+          // make class instance from body
+          // console.log('req.headers', req.headers)
+          if (req.headers[Symbols__NS__old.MAPPING_CONFIG_HEADER_BODY_PARAMS]) {
+            try {
+              const entity = JSON.parse(
+                TaonHelpers__NS__firstStringOrElemFromArray(
+                  req.headers[Symbols__NS__old.MAPPING_CONFIG_HEADER_BODY_PARAMS],
+                ),
+              );
+              tBody = Mapping__NS__encode(tBody, entity);
+            } catch (e) {}
+          } else {
+            Object.keys(tBody).forEach(paramName => {
+              try {
+                const entityForParam = JSON.parse(
+                  TaonHelpers__NS__firstStringOrElemFromArray(
+                    req.headers[
+                      `${Symbols__NS__old.MAPPING_CONFIG_HEADER_BODY_PARAMS}${paramName} `
+                    ],
+                  ),
+                );
+                tBody[paramName] = Mapping__NS__encode(
+                  tBody[paramName],
+                  entityForParam,
+                );
+              } catch (e) {}
+            });
+          }
+
+          // make class instance from query params
+          // console.log('req.headers', tQuery)
+          if (req.headers[Symbols__NS__old.MAPPING_CONFIG_HEADER_QUERY_PARAMS]) {
+            try {
+              const entity = JSON.parse(
+                TaonHelpers__NS__firstStringOrElemFromArray(
+                  req.headers[Symbols__NS__old.MAPPING_CONFIG_HEADER_QUERY_PARAMS],
+                ),
+              );
+              tQuery = TaonHelpers__NS__parseJSONwithStringJSONs(
+                Mapping__NS__encode(tQuery, entity),
+              );
+            } catch (e) {}
+          } else {
+            Object.keys(tQuery).forEach(queryParamName => {
+              try {
+                const entityForParam = JSON.parse(
+                  TaonHelpers__NS__firstStringOrElemFromArray(
+                    req.headers[
+                      `${Symbols__NS__old.MAPPING_CONFIG_HEADER_QUERY_PARAMS}${queryParamName} `
+                    ],
+                  ),
+                );
+                let beforeTransofrm = tQuery[queryParamName];
+                if (___NS__isString(beforeTransofrm)) {
+                  try {
+                    const paresed =
+                      TaonHelpers__NS__tryTransformParam(beforeTransofrm);
+                    beforeTransofrm = paresed;
+                  } catch (e) {}
+                }
+                const afterEncoding = Mapping__NS__encode(
+                  beforeTransofrm,
+                  entityForParam,
+                );
+                tQuery[queryParamName] =
+                  TaonHelpers__NS__parseJSONwithStringJSONs(afterEncoding);
+              } catch (e) {}
+            });
+          }
+
+          Object.keys(methodConfig.parameters).forEach(paramName => {
+            let p: Partial<ParamConfig> = methodConfig.parameters[paramName];
+            if (p.paramType === 'Path' && tParams) {
+              args.push(tParams[p.paramName]);
+            }
+            if (p.paramType === 'Query' && tQuery) {
+              if (p.paramName) {
+                args.push(tQuery[p.paramName]);
+              } else {
+                args.push(tQuery);
+              }
+            }
+
+            if (p.paramType === 'Header' && req.headers) {
+              args.push(req.headers[p.paramName.toLowerCase()]);
+            }
+            if (p.paramType === 'Cookie' && req.cookies) {
+              args.push(req.cookies[p.paramName]);
+            }
+            if (p.paramType === 'Body' && tBody) {
+              if (p.paramName && typeof tBody === 'object') {
+                args.push(tBody[p.paramName]);
+              } else {
+                args.push(tBody);
+              }
+            }
+          });
+          //#endregion
+
+          const resolvedParams = args
+            .reverse()
+            .map(v => TaonHelpers__NS__tryTransformParam(v));
+
+          try {
+            let result = await getResult(resolvedParams, req, res);
+            if (methodConfig.responseType)
+              if (res.headersSent) {
+                // SKIP FURTHER PROCESSING IF RESPONSE ALREADY SENT
+                return;
+              }
+            if (methodConfig.overrideExpressSendAsHtml) {
+              res.setHeader('Content-Type', 'text/html');
+              res.send(result);
+              return;
+            }
+            if (
+              result instanceof Blob &&
+              (methodConfig.responseType as ModelsNg2Rest__NS__ResponseTypeAxios) ===
+                'blob'
+            ) {
+              // console.log('INSTANCE OF BLOB')
+              //#region processs blob result type
+              const blob = result as Blob;
+              const file = Buffer.from(await blob.arrayBuffer());
+              res.writeHead(200, {
+                'Content-Type': blob.type,
+                'Content-Length': file.length,
+              });
+              res.end(file);
+              //#endregion
+            } else if (
+              ___NS__isString(result) &&
+              (methodConfig.responseType as ModelsNg2Rest__NS__ResponseTypeAxios) ===
+                'blob'
+            ) {
+              // console.log('BASE64')
+              //#region process string buffer TODO refacetor
+              const img_base64 = result;
+              const m = /^data:(.+?);base64,(.+)$/.exec(img_base64);
+              if (!m) {
+                throw new Error(
+                  `[taon - framework] Not a base64 image[${img_base64}]`,
+                );
+              }
+              const [_, content_type, file_base64] = m;
+              const file = Buffer.from(file_base64, 'base64');
+
+              res.writeHead(200, {
+                'Content-Type': content_type,
+                'Content-Length': file.length,
+              });
+              res.end(file);
+              //#endregion
+            } else {
+              //#region process json request
+              await EntityProcess.init(result, res);
+              //#endregion
+            }
+          } catch (error) {
+            if (res.headersSent) {
+              // SKIP FURTHER PROCESSING IF RESPONSE ALREADY SENT
+              return;
+            }
+            if (methodConfig.overrideExpressSendAsHtml) {
+              res.setHeader('Content-Type', 'text/html');
+              res.send(error);
+              return;
+            }
+
+            this.sendError(res, error, req, expressPath);
+          }
+        },
+      );
+      //#endregion
+    }
+
+    return {
+      expressPath: expressPath,
+      method: methodConfig.type,
+    };
+  }
+  //#endregion
+
+  //#region methods & getters / send error
+  protected sendError(
+    res: express.Response,
+    error: unknown,
+    req: express.Request,
+    expressPath: string,
+  ): void {
+    //#region @backendFunc
+    let status = 500;
+    let message = 'Internal Server Error';
+    let details: any = undefined;
+    let success = false;
+    let code = undefined;
+    if (typeof error === 'function') {
+      const obj: RestErrorResponseWrapper = error(res) || {};
+      status = obj.status || 400;
+      message = obj.message;
+      details = obj.details;
+      code = obj.code;
+    } else if (typeof error === 'string') {
+      message = error;
+      status = 400;
+    } else if (error instanceof Error) {
+      message = error.message;
+      details = process.env.NODE_ENV !== 'production' ? error.stack : undefined;
+    } else {
+      message = 'Unexpected error';
+      details = error;
+    }
+
+    res.status(status).json({
+      success,
+      message,
+      details,
+      code,
+      [CoreModels__NS__TaonHttpErrorCustomProp]: true,
+    } as RestErrorResponseWrapper);
+    //#endregion
+  }
+  //#endregion
+
+  //#region methods & getters / init client
+  /**
+   * client can be browser or nodejs (when remote host)
+   */
+  private async initClient(
+    target: Function,
+    httpRequestType: CoreModels__NS__HttpMethod,
+    methodConfig: Partial<MethodConfig>, // Models.Http.Rest.MethodConfig,
+    expressPath: string,
+  ): Promise<void> {
+    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 as any) as TaonBaseMiddleware)
+      .filter(f => ___NS__isFunction(f.interceptClientMethod));
+
+    middlewaresInstances.forEach(instance => {
+      const middlewareName = ClassHelpers__NS__getName(instance);
+      // middlewareName - only needed for inheritace and uniqness of interceptors
+      const interceptorKey = `${middlewareName}-${methodConfig.type?.toUpperCase()}-${expressPath}`;
+      Resource.request.methodsInterceptors.set(interceptorKey, {
+        intercept: ({ req, next }) => {
+          return instance.interceptClientMethod(
+            {
+              req,
+              next,
+            },
+            {
+              methodName: methodConfig.methodName,
+              expressPath,
+              httpRequestType: httpRequestType,
+            },
+          );
+        },
+      });
+    });
+    //#endregion
+
+    // : { received: any; /* Rest<any, any>  */ }
+    // this.logHttp &&
+    //   console.log(`${httpRequestType?.toUpperCase()} ${expressPath} `);
+    // console.log('INITING', methodConfig); // TODO inject in static
+    //#region resolve storage
+    // TODO not a good idea
+    const storage = globalThis;
+    //#endregion
+
+    const orgMethods = target.prototype[methodConfig.methodName];
+
+    //#region handle electron ipc request
+
+    if (UtilsOs__NS__isElectron) {
+      const ipcRenderer = (window as any).require('electron').ipcRenderer;
+      target.prototype[methodConfig.methodName] = function (...args) {
+        const received = new Promise(async (resolve, reject) => {
+          const headers = {};
+          const { request, response } = TaonHelpers__NS__websqlMocks(headers);
+
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+  
+        });
+        received['observable'] = from(received);
+        return {
+          received,
+          request(axiosConfig: ModelsNg2Rest__NS__Ng2RestAxiosRequestConfig) {
+            return received;
+          },
+        } as Models__NS__Http__NS__ClientAction<any>;
+      };
+      return;
+    }
+    //#endregion
+
+    //#region handling web sql request
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+  
+    //#endregion
+
+    //#region handle normal request
+
+    target.prototype[methodConfig.methodName] = function (
+      this: {},
+      ...args
+    ): Models__NS__Http__NS__ClientAction<any> {
+      // console.log('[init method browser] FRONTEND expressPath', expressPath)
+      // const productionMode = FrameworkContext.isProductionMode;
+
+      //#region resolve frontend parameters
+
+      if (!storage[Symbols__NS__old.ENDPOINT_META_CONFIG])
+        storage[Symbols__NS__old.ENDPOINT_META_CONFIG] = {};
+      if (!storage[Symbols__NS__old.ENDPOINT_META_CONFIG][ctx.uriOrigin])
+        storage[Symbols__NS__old.ENDPOINT_META_CONFIG][ctx.uriOrigin] = {};
+      const endpoints = storage[Symbols__NS__old.ENDPOINT_META_CONFIG];
+      let rest: ModelsNg2Rest__NS__ResourceModel<any, any>;
+      if (!endpoints[ctx.uriOrigin][expressPath]) {
+        let headers = {};
+        if (methodConfig.contentType && !methodConfig.responseType) {
+          rest = Resource.create(
+            ctx.uriOrigin,
+            expressPath,
+            Symbols__NS__old.MAPPING_CONFIG_HEADER as any,
+            Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY as any,
+            RestHeaders.from({
+              'Content-Type': methodConfig.contentType,
+              Accept: methodConfig.contentType,
+            }),
+          );
+        } else if (methodConfig.contentType && methodConfig.responseType) {
+          rest = Resource.create(
+            ctx.uriOrigin,
+            expressPath,
+            Symbols__NS__old.MAPPING_CONFIG_HEADER as any,
+            Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY as any,
+            RestHeaders.from({
+              'Content-Type': methodConfig.contentType,
+              Accept: methodConfig.contentType,
+              responsetypeaxios: methodConfig.responseType,
+            }),
+          );
+        } else if (!methodConfig.contentType && methodConfig.responseType) {
+          rest = Resource.create(
+            ctx.uriOrigin,
+            expressPath,
+            Symbols__NS__old.MAPPING_CONFIG_HEADER as any,
+            Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY as any,
+            RestHeaders.from({
+              responsetypeaxios: methodConfig.responseType,
+            }),
+          );
+        } else {
+          rest = Resource.create(
+            ctx.uriOrigin,
+            expressPath,
+            Symbols__NS__old.MAPPING_CONFIG_HEADER as any,
+            Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY as any,
+          );
+        }
+
+        endpoints[ctx.uriOrigin][expressPath] = rest;
+      } else {
+        rest = endpoints[ctx.uriOrigin][expressPath] as any;
+      }
+
+      const method = httpRequestType.toLowerCase();
+
+      const pathPrams = {};
+      let queryParams = {};
+      let bodyObject = {};
+      args.forEach((param, i) => {
+        let currentParam: Partial<ParamConfig> = void 0 as any;
+
+        for (let pp in methodConfig.parameters) {
+          let v = methodConfig.parameters[pp];
+          if (v.index === i) {
+            currentParam = v;
+            break;
+          }
+        }
+
+        if (!currentParam) {
+          const errorMessage =
+            `[${config.frameworkName}] Unable to resolve parameter` +
+            ` at index ${i} for method ${methodConfig.methodName} at path ${expressPath}.`;
+
+          //#region @backend
+          console.error(errorMessage);
+          process.exit(0);
+          //#endregion
+          throw new Error(errorMessage);
+        }
+
+        if (currentParam.paramType === 'Path') {
+          pathPrams[currentParam.paramName] = param;
+        }
+        if (currentParam.paramType === 'Query') {
+          if (currentParam.paramName) {
+            const mapping = Mapping__NS__decode(param, !ctx.isProductionMode);
+            if (mapping) {
+              rest.headers.set(
+                `${Symbols__NS__old.MAPPING_CONFIG_HEADER_QUERY_PARAMS}${currentParam.paramName} `,
+                JSON.stringify(mapping),
+              );
+            }
+            queryParams[currentParam.paramName] = param;
+          } else {
+            const mapping = Mapping__NS__decode(param, !ctx.isProductionMode);
+            if (mapping) {
+              rest.headers.set(
+                Symbols__NS__old.MAPPING_CONFIG_HEADER_QUERY_PARAMS,
+                JSON.stringify(mapping),
+              );
+            }
+            queryParams = ___NS__cloneDeep(param);
+          }
+        }
+        if (currentParam.paramType === 'Header') {
+          if (currentParam.paramName) {
+            if (currentParam.paramName === Symbols__NS__old.MDC_KEY) {
+              // parese MDC
+              rest.headers.set(
+                currentParam.paramName,
+                encodeURIComponent(JSON.stringify(param)),
+              );
+            } else {
+              rest.headers.set(currentParam.paramName, param);
+            }
+          } else {
+            for (let header in param) {
+              rest.headers.set(header, param[header]);
+            }
+          }
+        }
+        if (currentParam.paramType === 'Cookie') {
+          Resource.Cookies.write(
+            currentParam.paramName,
+            param,
+            currentParam.expireInSeconds,
+          );
+        }
+        if (currentParam.paramType === 'Body') {
+          if (currentParam.paramName) {
+            if (ClassHelpers__NS__getName(bodyObject) === 'FormData') {
+              throw new Error(`[taon - framework] Don use param names when posting / putting FormData.
+              Use this:
+// ...
+(@Taon.Http.Param.Body() formData: FormData) ...
+// ...
+
+instead
+  // ...
+  (@Taon.Http.Param.Body('${currentParam.paramName}') formData: FormData) ...
+// ...
+`);
+            }
+            const mapping = Mapping__NS__decode(param, !ctx.isProductionMode);
+            if (mapping) {
+              rest.headers.set(
+                `${Symbols__NS__old.MAPPING_CONFIG_HEADER_BODY_PARAMS}${currentParam.paramName} `,
+                JSON.stringify(mapping),
+              );
+            }
+            bodyObject[currentParam.paramName] = param;
+          } else {
+            const mapping = Mapping__NS__decode(param, !ctx.isProductionMode);
+            if (mapping) {
+              rest.headers.set(
+                Symbols__NS__old.MAPPING_CONFIG_HEADER_BODY_PARAMS,
+                JSON.stringify(mapping),
+              );
+            }
+            bodyObject = param;
+          }
+        }
+      });
+
+      if (
+        typeof bodyObject === 'object' &&
+        ClassHelpers__NS__getName(bodyObject) !== 'FormData'
+      ) {
+        let circuralFromItem = [];
+        bodyObject = JSON10.parse(
+          JSON10.stringify(bodyObject, void 0, void 0, circs => {
+            circuralFromItem = circs;
+          }),
+        );
+        rest.headers.set(
+          Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY,
+          JSON10.stringify(circuralFromItem),
+        );
+      }
+
+      if (typeof queryParams === 'object') {
+        let circuralFromQueryParams = [];
+        queryParams = JSON10.parse(
+          JSON10.stringify(queryParams, void 0, void 0, circs => {
+            circuralFromQueryParams = circs;
+          }),
+        );
+
+        rest.headers.set(
+          Symbols__NS__old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM,
+          JSON10.stringify(circuralFromQueryParams),
+        );
+      }
+      //#endregion
+
+      const httpResultObj: Models__NS__Http__NS__ClientAction<any> = {
+        get received() {
+          return rest.model(pathPrams)[method](bodyObject, [queryParams]);
+        },
+        request(axiosConfig?: ModelsNg2Rest__NS__Ng2RestAxiosRequestConfig) {
+          return rest
+            .model(pathPrams)
+            [method](bodyObject, [queryParams], axiosConfig);
+        },
+      };
+      return httpResultObj as Models__NS__Http__NS__ClientAction<any>;
+    };
+    //#endregion
+  }
+  //#endregion
+}