taon 21.0.3 → 21.0.6

package/browser/fesm2022/taon.mjs

@@ -1,1231 +1,1000 @@
 import 'reflect-metadata';
 import * as coreHelpers from 'tnp-core/browser';
 import { _, Utils, Helpers, UtilsOs, config, CoreModels, crossPlatformPath, UtilsTerminal } from 'tnp-core/browser';
-import { __decorate, __metadata, __param } from 'tslib';
-import { SYMBOL, CLASS } from 'typescript-class-helpers/browser';
-import { OrignalClassKey, Table } from 'taon-typeorm/browser';
-import { walk } from 'lodash-walk-object/browser';
-import * as i0 from '@angular/core';
-import { InjectionToken, inject as inject$1, Injectable } from '@angular/core';
 import axios from 'axios';
 import { JSON10 } from 'json10/browser';
+import { walk } from 'lodash-walk-object/browser';
 import { RestResponseWrapper, Models as Models$1, Resource, RestHeaders, Mapping, HttpResponseError } from 'ng2-rest/browser';
 import { Observable, from, Subject } from 'rxjs';
+import * as i0 from '@angular/core';
+import { InjectionToken, inject as inject$1, Injectable, ViewContainerRef, ViewChild, Component } from '@angular/core';
+import { Table, OrignalClassKey, Column } from 'taon-typeorm/browser';
+export { AfterInsert, AfterLoad, AfterRecover, AfterRemove, AfterSoftRemove, AfterUpdate, BeforeInsert, BeforeRecover, BeforeRemove, BeforeSoftRemove, BeforeUpdate, Column, Connection, CreateDateColumn, Column as CustomColumn, DeleteDateColumn, Generated, Generated as GeneratedColumn, Index, JoinColumn, JoinTable, ManyToMany, ManyToOne, OneToMany, OneToOne, PrimaryColumn, PrimaryGeneratedColumn, Repository, TreeChildren, TreeParent, UpdateDateColumn, VersionColumn, VirtualColumn } from 'taon-typeorm/browser';
+import { SYMBOL, CLASS } from 'typescript-class-helpers/browser';
 import * as JSON5 from 'json5';
 import { io } from 'socket.io-client';
+import { __decorate, __metadata, __param } from 'tslib';
+import * as i1 from '@ngx-formly/core';
+import { FieldWrapper, FieldArrayType } from '@ngx-formly/core';
 
-class DecoratorAbstractOpt {
-}
-
-class TaonControllerOptions extends DecoratorAbstractOpt {
-}
-
-// import { cloneObj } from '../helpers/clone-obj';
-// import { ParamConfig } from './param-config';
-class ControllerConfig extends TaonControllerOptions {
-}
-const controllerConfigFrom = (partial) => {
-    const newObj = partial || {};
-    newObj.methods = newObj.methods || {};
-    for (const methodName in newObj.methods) {
-        if (newObj.methods.hasOwnProperty(methodName)) {
-            // newObj.methods[methodName] = new MethodConfig().clone(
-            //   newObj.methods[methodName],
-            // );
-            newObj.methods[methodName] = newObj.methods[methodName] || {};
-            const params = newObj.methods[methodName].parameters || {};
-            newObj.methods[methodName].parameters = params
-                ? params
-                : {};
-            for (const paramName in params) {
-                if (params.hasOwnProperty(paramName)) {
-                    params[paramName] = params[paramName] || {};
-                    // params[paramName] = new ParamConfig().clone(params[paramName]);
-                }
-            }
-        }
-    }
-    return newObj;
-};
+const TaonEntityKeysToOmitArr = [
+    'ctrl',
+    'clone',
+    '__endpoint_context__',
+    'ctx',
+    'inject',
+    '_',
+    'relation',
+    'relations',
+    'inject',
+    'injectRepo',
+    'injectCustomRepository',
+    'injectCustomRepo',
+    'injectController',
+    'injectCtrl',
+    'injectProvider',
+    'injectMiddleware',
+];
+let TAON_CONTEXT;
+//#region @browser
+TAON_CONTEXT = new InjectionToken('TAON_CONTEXT');
+//#endregion
+let CURRENT_HOST_BACKEND_PORT;
+//#region @browser
+CURRENT_HOST_BACKEND_PORT = new InjectionToken('CURRENT_HOST_BACKEND_PORT');
+//#endregion
+let CURRENT_HOST_URL;
+//#region @browser
+CURRENT_HOST_URL = new InjectionToken('CURRENT_HOST_URL');
+const apiPrefix = 'api';
 
-var Symbols;
-(function (Symbols) {
-    Symbols.ctxInClassOrClassObj = Symbol();
-    Symbols.classNameStaticProperty = SYMBOL.ClassNameStaticProperty;
-    Symbols.fullClassNameStaticProperty = `$$fullclassName$$`;
-    Symbols.orignalClass = OrignalClassKey;
-    Symbols.orignalClassClonesObj = `$$originalClassClonesObj$$`;
-    Symbols.classMethodsNames = `$$classMethodsNames$$`;
-    /**
-     * for backendSocket.in(ROOM_NAME).emit(EVENT)
-     *
-     * Room names are uniqe..
-     * here I am limiting number of event for clients.
-     */
-    class Realtime {
-        constructor() {
-            this.KEYroomSubscribe = `roomSubscribe`;
-            this.KEYroomUnsubscribe = `roomUnsubscribe`;
-            //#endregion
-        }
-        NAMESPACE(contextName) {
-            return `${contextName}-taonRealtimeNsp`;
-        }
-        TABLE_CHANGE(contextName, tableName) {
-            return `${contextName}:listentablename${tableName}`;
-        }
-        // /**
-        //  * TODO use it or not?
-        //  * @deprecated
-        //  */
-        // ROOM_NAME_SUBSCRIBER_EVENT(
-        //   contextName: string,
-        //   className: string,
-        //   propertyName: string,
-        // ) {
-        //   return `${contextName}:room${_.camelCase(className)}${propertyName}`.toLowerCase();
-        // }
-        //#region custom events in rooms
-        ROOM_NAME_CUSTOM(contextName, customEvent) {
-            return `${contextName}:CustomRoomEvent${customEvent}`;
-        }
-        ROOM_SUBSCRIBE_CUSTOM(contextName) {
-            return `${contextName}:${this.KEYroomSubscribe}CustomRoomEvent`;
-        }
-        ROOM_UNSUBSCRIBE_CUSTOM(contextName) {
-            return `${contextName}:${this.KEYroomUnsubscribe}CustomRoomEvent`;
-        }
+class ContextDbMigrations {
+    //#endregion
+    //#endregion
+    //#region constructor
+    constructor(ctx) {
+        this.ctx = ctx;
+        //#region fields
+        //#region fields / migration table name
+        this.DEFAULT_MIGRATION_TABLE_NAME = 'TAON_MIGRATION_META';
         //#endregion
-        //#region entity events
-        ROOM_NAME_UPDATE_ENTITY(contextName, className, entityId) {
-            return `${contextName}:room${_.camelCase(className)}${entityId}`.toLowerCase();
-        }
-        ROOM_SUBSCRIBE_ENTITY_UPDATE_EVENTS(contextName) {
-            return `${contextName}:${this.KEYroomSubscribe}EntityEvents`;
-        }
-        ROOM_UNSUBSCRIBE_ENTITY_UPDATE_EVENTS(contextName) {
-            return `${contextName}:${this.KEYroomUnsubscribe}EntityEvents`;
-        }
+        //#region fields / migration statuses
+        this.MIGRATION_STATUS_COMPLETED = 'completed';
+        this.MIGRATION_STATUS_PENDING = 'pending';
         //#endregion
-        //#region entity property events
-        ROOM_NAME_UPDATE_ENTITY_PROPERTY(contextName, className, property, entityId) {
-            return `${contextName}:room${_.camelCase(className)}${_.camelCase(property)}${entityId}`.toLowerCase();
-        }
-        ROOM_SUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(contextName) {
-            return `${contextName}:${this.KEYroomSubscribe}EntityPropertyEvents`;
-        }
-        ROOM_UNSUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(contextName) {
-            return `${contextName}:${this.KEYroomUnsubscribe}EntityPropertyEvents`;
-        }
-    }
-    Symbols.REALTIME = new Realtime();
-    Symbols.metadata = {
-        className: `class:realname`,
-        options: {
-            controller: `controller:options`,
-            entity: `entity:options`,
-            repository: `repository:options`,
-            provider: `provider:options`,
-            subscriber: `subscriber:options`,
-            migration: `migration:options`,
-        },
-    };
-    Symbols.old = {
-        HAS_TABLE_IN_DB: Symbol(),
-        MDC_KEY: `modeldataconfig`,
-        WEBSQL_REST_PROGRESS_FUN: Symbol(),
-        WEBSQL_REST_PROGRESS_FUN_START: Symbol(),
-        WEBSQL_REST_PROGRESS_FUN_DONE: Symbol(),
-        WEBSQL_REST_PROGRESS_TIMEOUT: Symbol(),
-        X_TOTAL_COUNT: `x-total-count`,
-        CIRCURAL_OBJECTS_MAP_BODY: `circuralmapbody`,
-        CIRCURAL_OBJECTS_MAP_QUERY_PARAM: `circuralmapbody`,
-        MAPPING_CONFIG_HEADER: `mappingheader`,
-        MAPPING_CONFIG_HEADER_BODY_PARAMS: `mhbodyparams`,
-        MAPPING_CONFIG_HEADER_QUERY_PARAMS: `mhqueryparams`,
-        ENDPOINT_META_CONFIG: `ng2_rest_endpoint_config`,
-        CLASS_DECORATOR_CONTEXT: `$$ng2_rest_class_context`,
-        SOCKET_MSG: `socketmessageng2rest`,
-        ANGULAR: {
-            INPUT_NAMES: Symbol(),
-        },
-        ERROR_MESSAGES: {
-            CLASS_NAME_MATCH: `Please check if your "class name" matches  @Controller( className ) or @Entity( className )`,
-        },
-    };
-})(Symbols || (Symbols = {}));
-
-var Validators;
-(function (Validators) {
-    //#region vlidate class name
-    Validators.classNameVlidation = (className, target) => {
-        setTimeout(() => {
-            // console.log(`check after timeout ${className} , production mode: ${FrameworkContext.isProductionMode}`)
-            if (_.isUndefined(className)) {
-                throw `[Taon]
-      Please provide "className" property for each Controller and Entity:
-
-          @Taon.Controller({ className: 'MyExampleCtrl'  })
-          class MyExampleCtrl {
-            ...
-          }
-
-          @Taon.Entity({ className: 'MyExampleEntity'  })
-          class MyExampleEntity {
-            ...
-          }
-
-    Notice that minified javascript code does not preserve
-    Functions/Classes names -this is only solution to preserve classes names.
-
-        `;
-            }
+        //#region fields / migration table schema
+        this.table = new Table({
+            name: this.DEFAULT_MIGRATION_TABLE_NAME,
+            columns: [
+                {
+                    name: 'id',
+                    type: 'integer',
+                    isPrimary: true, // Mark it as the primary key
+                    isGenerated: true, // Enable auto-generation
+                    generationStrategy: 'increment', // Use auto-increment strategy
+                },
+                {
+                    name: 'name',
+                    type: 'varchar',
+                    length: '255',
+                    isUnique: true, // Ensure the name is unique
+                    isNullable: false, // Ensure this field is required
+                },
+                {
+                    // context is a part of name
+                    name: 'context',
+                    type: 'varchar',
+                    length: '255',
+                    isNullable: false, // Optional context for migrations (e.g., tenant or module name)
+                },
+                {
+                    name: 'applied_at',
+                    type: 'timestamp',
+                    default: 'CURRENT_TIMESTAMP', // Automatically set the timestamp
+                    isNullable: true,
+                },
+                {
+                    name: 'status',
+                    type: 'varchar',
+                    length: '50',
+                    default: `'${this.MIGRATION_STATUS_COMPLETED}'`,
+                    isNullable: false,
+                },
+                // { // TODO not needed for now
+                //   name: 'checksum',
+                //   type: 'varchar',
+                //   length: '64',
+                //   isNullable: true, // Optional field to store a hash/checksum of migration file
+                // },
+            ],
         });
-        return _.isUndefined(className) ? target.name : className;
-    };
-    //#endregion
-    //#region validate method config
-    Validators.checkIfMethodsWithReponseTYpeAlowed = (methods, current) => {
-        const defaultResponseType = 'text or JSON';
-        if (!current.responseType) {
-            return;
-        }
-        for (let index = 0; index < methods.length; index++) {
-            const m = methods[index];
-            if (m.path === current.path && m.responseType !== current.responseType) {
-                throw new Error(`
-  [taon] you can have 2 methods with same path but differetn reponseType-s
-
-          ${m.methodName}( ... path: ${m.path} )  -> responseType: ${m.responseType || defaultResponseType}
-          ${current.methodName}( ... path: ${current.path} ) -> responseType: ${current.responseType}
-
-    Please change path name on of the methods.
-
-        `);
-            }
-        }
-    };
+    }
     //#endregion
-    //#region validate class functions
-    // TODO
-    Validators.validateClassFunctions = (controllers, entities, proviers, repositories) => {
-        if (_.isArray(controllers) &&
-            controllers.filter(f => !_.isFunction(f)).length > 0) {
-            console.error('controllers', controllers);
-            throw `
-
-  Incorect value for property "controllers" inside Taon.Init(...)
-
-  `;
-        }
-        if (_.isArray(entities) &&
-            entities.filter(f => !_.isFunction(f)).length > 0) {
-            console.error('entites', entities);
-            throw `
-
-  Incorect value for property "entities" inside Taon.Init(...)
-
-  `;
-        }
-    };
-    //#endregion
-    Validators.preventUndefinedModel = (model, id) => {
-        if (_.isUndefined(model)) {
-            throw `Bad update by id, config, id: ${id}`;
-        }
-    };
-})(Validators || (Validators = {}));
-
-//#region imports
-/* */
-//#endregion
-var ClassHelpers;
-(function (ClassHelpers) {
-    //#region get class from name
-    /**
-     * TODO - repalce in every place when getting class fn from object
-     */
-    ClassHelpers.getClassFnFromObject = (json) => {
-        if (_.isUndefined(json) || _.isNull(json)) {
-            return;
-        }
-        if (json.constructor) {
-            return json.constructor;
-        }
-        const p = Object.getPrototypeOf(json);
-        return p && p.constructor && p.constructor.name !== 'Object'
-            ? p.constructor
-            : void 0;
-    };
-    //#endregion
-    //#region get name
-    ClassHelpers.getName = (classFnOrObject) => {
-        // exception for FormData
-        if (classFnOrObject instanceof FormData) {
-            return 'FormData';
-        }
-        if (!classFnOrObject) {
-            console.error('OBJECT OR CLASS', classFnOrObject);
-            throw new Error(`Cannot get name from this object or class.`);
-        }
-        return ((classFnOrObject[Symbols.classNameStaticProperty]
-            ? classFnOrObject[Symbols.classNameStaticProperty]
-            : classFnOrObject?.constructor[Symbols.classNameStaticProperty]) ||
-            (_.isFunction(classFnOrObject) ? CLASS.getName(classFnOrObject) : void 0));
-    };
+    //#region methods & getters / make sure migration table exists
+    async ensureMigrationTableExists() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
     //#endregion
-    ClassHelpers.getOrginalClass = (classFnOrObject) => {
-        const org = classFnOrObject[Symbols.orignalClass];
-        if (!org) {
-            return classFnOrObject;
-        }
-        return ClassHelpers.getOrginalClass(org);
-    };
-    //#region get full internal name
-    ClassHelpers.getFullInternalName = (classFnOrObject) => {
-        // exception for FormData
-        if (!classFnOrObject) {
-            throw new Error(`Cannot get name from: ${classFnOrObject}`);
-        }
-        return ((classFnOrObject[Symbols.fullClassNameStaticProperty]
-            ? classFnOrObject[Symbols.fullClassNameStaticProperty]
-            : classFnOrObject?.constructor[Symbols.fullClassNameStaticProperty]) ||
-            void 0);
-    };
+    //#region methods & getters / revert migration to timestamp
+    async logSelectALl(name, queryRunner) {
+        console.log(name, (await queryRunner.query(`SELECT * FROM ${this.DEFAULT_MIGRATION_TABLE_NAME} WHERE context = $1`, [this.ctx.contextName])).map(m => m.name));
+    }
+    async revertMigrationToTimestamp(timestamp) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
     //#endregion
-    //#region get unique key
-    ClassHelpers.getUniqueKey = (classFnOrObject) => {
-        const classFn = _.isFunction(classFnOrObject)
-            ? classFnOrObject
-            : classFnOrObject.constructor;
-        const config = Reflect.getMetadata(Symbols.metadata.options.entity, classFn);
-        return config.uniqueKeyProp;
-    };
+    //#region methods & getters / clear migration table
+    async clearMigrationTable() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
     //#endregion
-    //#region is class object
-    ClassHelpers.isContextClassObject = (obj) => {
-        if (!_.isObject(obj) ||
-            _.isArray(obj) ||
-            _.isRegExp(obj) ||
-            _.isBuffer(obj) ||
-            _.isArrayBuffer(obj)) {
-            return false;
-        }
-        if (_.isDate(obj)) {
-            return true;
-        }
-        const className = ClassHelpers.getName(obj);
-        return _.isString(className) && className !== 'Object';
-    };
-    //#endregion
-    //#region get name
-    ClassHelpers.setName = (target, className) => {
-        // console.log('setName', className, target.name)
-        Validators.classNameVlidation(className, target);
-        target[Symbols.classNameStaticProperty] = className;
-    };
+    //#region methods & getters / mark all migrations as applied
+    async markAllMigrationsAsApplied() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
     //#endregion
-    //#region has parent with class name
-    ClassHelpers.hasParentClassWithName = (target, className, targets = []) => {
-        if (!target) {
-            return false;
-        }
-        targets.push(target);
-        let targetProto = Object.getPrototypeOf(target);
-        if (_.isFunction(targetProto) &&
-            ClassHelpers.getName(targetProto) === className) {
-            // console.log(`true  "${_.first(targets).name}" for ${targets.map(d => d.name).join(',')}`)
-            return true;
+    //#region methods & getters / run all migrations
+    async runAllNotCompletedMigrations() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+}
+
+class DITaonContainer {
+    static { this.instances = new Map(); }
+    static resolve(target) {
+        if (DITaonContainer.instances.has(target)) {
+            return DITaonContainer.instances.get(target);
         }
-        return ClassHelpers.hasParentClassWithName(targetProto, className, targets);
-    };
-    //#endregion
-    //#region get methods name
-    //#region not allowed as method name
-    const notAllowedAsMethodName = [
-        'length',
-        'name',
-        'arguments',
-        'caller',
-        'constructor',
-        'apply',
-        'bind',
-        'call',
-        'toString',
-        '__defineGetter__',
-        '__defineSetter__',
-        'hasOwnProperty',
-        '__lookupGetter__',
-        '__lookupSetter__',
-        'isPrototypeOf',
-        'propertyIsEnumerable',
-        'valueOf',
-        '__proto__',
-        'toLocaleString',
-    ];
-    //#endregion
-    /**
-     * Express async handler for middleware functions.
-     */
-    ClassHelpers.asyncHandler = fn => (req, res, next) => {
-        Promise.resolve(fn(req, res, next)).catch(next);
-    };
-    ClassHelpers.getMethodsNames = (classOrClassInstance, allMethodsNames = []) => {
-        if (!classOrClassInstance) {
-            return Utils.uniqArray(allMethodsNames);
-        }
-        const isClassFunction = _.isFunction(classOrClassInstance);
-        const classFun = isClassFunction
-            ? classOrClassInstance
-            : Object.getPrototypeOf(classOrClassInstance);
-        const objectToCheck = isClassFunction
-            ? classOrClassInstance?.prototype
-            : classOrClassInstance;
-        const prototypeObj = Object.getPrototypeOf(objectToCheck || {});
-        const properties = _.uniq([
-            ...Object.getOwnPropertyNames(objectToCheck || {}),
-            ...Object.getOwnPropertyNames(prototypeObj || {}),
-            ...Object.keys(objectToCheck || {}),
-            ...Object.keys(prototypeObj || {}),
-        ]).filter(f => !!f && !notAllowedAsMethodName.includes(f));
-        properties
-            .filter(methodName => typeof objectToCheck[methodName] === 'function')
-            .forEach(p => allMethodsNames.push(p));
-        if (!classFun ||
-            !classFun.constructor ||
-            classFun?.constructor?.name === 'Object') {
-            return Utils.uniqArray(allMethodsNames);
-        }
-        return ClassHelpers.getMethodsNames(Object.getPrototypeOf(classFun), allMethodsNames);
-    };
-    //#endregion
-    //#region get controller configs
-    ClassHelpers.getControllerConfigs = (target, configs = [], callerTarget) => {
-        if (!_.isFunction(target)) {
-            throw `[typescript-class-helper][getControllerConfigs] Cannot get class config from: ${target}`;
-        }
-        let config;
-        const parentClass = Object.getPrototypeOf(target);
-        const parentName = parentClass ? ClassHelpers.getName(parentClass) : void 0;
-        const isValidParent = _.isFunction(parentClass) && parentName !== '';
-        config = controllerConfigFrom(ClassHelpers.getClassConfig(target));
-        configs.push(config);
-        return isValidParent
-            ? ClassHelpers.getControllerConfigs(parentClass, configs, target)
-            : configs;
-    };
-    //#endregion
-    //#region ensure configs
-    // Ensure ClassConfig on constructor, clone parent if needed
-    ClassHelpers.ensureClassConfig = (target) => {
-        let cfg = Reflect.getOwnMetadata(Symbols.metadata.options.controller, // META_KEYS.class,
-        target);
-        if (!cfg) {
-            cfg = { methods: {} };
-            const parent = Object.getPrototypeOf(target);
-            if (parent && parent !== Function.prototype) {
-                const parentCfg = Reflect.getMetadata(Symbols.metadata.options.controller, // META_KEYS.class,
-                parent);
-                if (parentCfg) {
-                    // Deep copy each method config so child gets its own objects
-                    const clonedMethods = {};
-                    for (const [k, v] of Object.entries(parentCfg.methods)) {
-                        clonedMethods[k] = {
-                            ...v,
-                            parameters: { ...v.parameters }, // shallow clone parameters too
-                        };
-                    }
-                    cfg = {
-                        ...parentCfg,
-                        methods: clonedMethods,
-                    };
+        // const tokens = Reflect.getMetadata('design:paramtypes', target) || [];
+        const injections = []; //  tokens.map(token => Container.inject<any>(token));
+        const instance = new target(...injections);
+        DITaonContainer.instances.set(target, instance);
+        return instance;
+    }
+    static inject(target) {
+        return new Proxy({}, {
+            get: (_, propName) => {
+                let instance = DITaonContainer.instances.get(target) ||
+                    DITaonContainer.resolve(target);
+                return typeof instance[propName] === 'function'
+                    ? instance[propName].bind(instance)
+                    : instance[propName];
+            },
+            set: (_, propName, value) => {
+                let instance = DITaonContainer.instances.get(target) ||
+                    DITaonContainer.resolve(target);
+                instance[propName] = value;
+                return true;
+            },
+        });
+    }
+}
+
+const getResponseValue = (response, options) => {
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    return (void 0);
+};
+
+class DecoratorAbstractOpt {
+}
+
+class TaonControllerOptions extends DecoratorAbstractOpt {
+}
+
+// import { cloneObj } from '../helpers/clone-obj';
+// import { ParamConfig } from './param-config';
+class ControllerConfig extends TaonControllerOptions {
+}
+const controllerConfigFrom = (partial) => {
+    const newObj = partial || {};
+    newObj.methods = newObj.methods || {};
+    for (const methodName in newObj.methods) {
+        if (newObj.methods.hasOwnProperty(methodName)) {
+            // newObj.methods[methodName] = new MethodConfig().clone(
+            //   newObj.methods[methodName],
+            // );
+            newObj.methods[methodName] = newObj.methods[methodName] || {};
+            const params = newObj.methods[methodName].parameters || {};
+            newObj.methods[methodName].parameters = params
+                ? params
+                : {};
+            for (const paramName in params) {
+                if (params.hasOwnProperty(paramName)) {
+                    params[paramName] = params[paramName] || {};
+                    // params[paramName] = new ParamConfig().clone(params[paramName]);
                 }
             }
-            Reflect.defineMetadata(Symbols.metadata.options.controller, cfg, target);
-        }
-        return cfg;
-    };
-    // Ensure MethodConfig inside ClassConfig
-    ClassHelpers.ensureMethodConfig = (target, propertyKey) => {
-        const classCfg = ClassHelpers.ensureClassConfig(target.constructor);
-        let methodCfg = classCfg.methods[propertyKey?.toString()];
-        if (!methodCfg) {
-            methodCfg = { methodName: propertyKey?.toString(), parameters: {} };
-            classCfg.methods[propertyKey?.toString()] = methodCfg;
-        }
-        return methodCfg;
-    };
-    ClassHelpers.getClassConfig = (constructor) => {
-        return Reflect.getMetadata(Symbols.metadata.options.controller, constructor);
-    };
-    //#endregion
-})(ClassHelpers || (ClassHelpers = {}));
-
-const cloneObj = (override, classFn) => {
-    const result = _.merge(new classFn(), _.cloneDeep(this));
-    walk.Object(override || {}, (value, lodashPath) => {
-        if (_.isNil(value) || _.isFunction(value) || _.isObject(value)) {
-            // skipping
-        }
-        else {
-            _.set(result, lodashPath, value);
         }
-    }, {
-        walkGetters: false,
-    });
-    // console.log({result})
-    return result;
+    }
+    return newObj;
 };
 
-//#endregion
-class TaonBaseClass {
-    //#region class initialization hook
-    /**
-     * class initialization hook
-     * taon after class instance creation
-     */
-    async _() { }
+/**
+ * for backendSocket.in(ROOM_NAME).emit(EVENT)
+ *
+ * Room names are uniqe..
+ * here I am limiting number of event for clients.
+ */
+class Realtime {
+    constructor() {
+        this.KEYroomSubscribe = `roomSubscribe`;
+        this.KEYroomUnsubscribe = `roomUnsubscribe`;
+        //#endregion
+    }
+    NAMESPACE(contextName) {
+        return `${contextName}-taonRealtimeNsp`;
+    }
+    TABLE_CHANGE(contextName, tableName) {
+        return `${contextName}:listentablename${tableName}`;
+    }
+    // /**
+    //  * TODO use it or not?
+    //  * @deprecated
+    //  */
+    // ROOM_NAME_SUBSCRIBER_EVENT(
+    //   contextName: string,
+    //   className: string,
+    //   propertyName: string,
+    // ) {
+    //   return `${contextName}:room${_.camelCase(className)}${propertyName}`.toLowerCase();
+    // }
+    //#region custom events in rooms
+    ROOM_NAME_CUSTOM(contextName, customEvent) {
+        return `${contextName}:CustomRoomEvent${customEvent}`;
+    }
+    ROOM_SUBSCRIBE_CUSTOM(contextName) {
+        return `${contextName}:${this.KEYroomSubscribe}CustomRoomEvent`;
+    }
+    ROOM_UNSUBSCRIBE_CUSTOM(contextName) {
+        return `${contextName}:${this.KEYroomUnsubscribe}CustomRoomEvent`;
+    }
     //#endregion
-    //#region clone
-    /**
-     *
-     * @param overrideObjOrFn if object is provided it will override values in cloned object,
-     * if function is provided it will be called with old cloned values and should return
-     * object with values to override
-     * @returns cloned instance of the class
-     */
-    clone(overrideObjOrFn) {
-        if (_.isString(overrideObjOrFn)) {
-            console.log(overrideObjOrFn);
-            throw new Error('String is not supported as .clone() method argument');
-        }
-        const classFn = ClassHelpers.getClassFnFromObject(this);
-        if (_.isFunction(overrideObjOrFn)) {
-            // console.log('clone with fn');
-            const oldValues = (_.cloneDeep(this) || {});
-            return cloneObj(overrideObjOrFn(oldValues), classFn);
-        }
-        // console.log('clone normal');
-        return cloneObj(overrideObjOrFn, classFn);
+    //#region entity events
+    ROOM_NAME_UPDATE_ENTITY(contextName, className, entityId) {
+        return `${contextName}:room${_.camelCase(className)}${entityId}`.toLowerCase();
     }
-}
-
-let EntityDecorator$1 = () => {
-    return (target) => { };
-};
-/* */
-/* */
-let TaonBaseEntity = class TaonBaseEntity extends TaonBaseClass {
-    /**
-     * simple check if relation is ok
-     */
-    relation(relationName) {
-        return relationName;
+    ROOM_SUBSCRIBE_ENTITY_UPDATE_EVENTS(contextName) {
+        return `${contextName}:${this.KEYroomSubscribe}EntityEvents`;
     }
-    /**
-     * simple check if relation is ok
-     */
-    relations(relationNames) {
-        return relationNames;
+    ROOM_UNSUBSCRIBE_ENTITY_UPDATE_EVENTS(contextName) {
+        return `${contextName}:${this.KEYroomUnsubscribe}EntityEvents`;
     }
-};
-TaonBaseEntity = __decorate([
-    EntityDecorator$1()
-], TaonBaseEntity);
-
-/* */
-/* */
-// empty decorator
-let EntityDecorator = () => {
-    return (target) => { };
-};
-/* */
-/* */
-let TaonBaseAbstractEntity = class TaonBaseAbstractEntity extends TaonBaseEntity {
-};
-TaonBaseAbstractEntity = __decorate([
-    EntityDecorator()
-], TaonBaseAbstractEntity);
-
-const TaonEntityKeysToOmitArr = [
-    'ctrl',
-    'clone',
-    '__endpoint_context__',
-    'ctx',
-    'inject',
-    '_',
-    'relation',
-    'relations',
-    'inject',
-    'injectRepo',
-    'injectCustomRepository',
-    'injectCustomRepo',
-    'injectController',
-    'injectCtrl',
-    'injectProvider',
-    'injectMiddleware',
-];
-let TAON_CONTEXT;
-//#region @browser
-TAON_CONTEXT = new InjectionToken('TAON_CONTEXT');
-//#endregion
-let CURRENT_HOST_BACKEND_PORT;
-//#region @browser
-CURRENT_HOST_BACKEND_PORT = new InjectionToken('CURRENT_HOST_BACKEND_PORT');
-//#endregion
-let CURRENT_HOST_URL;
-//#region @browser
-CURRENT_HOST_URL = new InjectionToken('CURRENT_HOST_URL');
-const apiPrefix = 'api';
-
-const inject = (entity) => {
-    return new Proxy({}, {
-        get: (_, propName) => {
-            if (propName === 'hasOwnProperty') {
-                return () => false;
-            }
-            const ctor = entity();
-            const contextFromClass = ctor[Symbols.ctxInClassOrClassObj];
-            const resultContext = contextFromClass;
-            if (resultContext) {
-                let instance = resultContext.inject(ctor, {
-                    parentInstanceThatWillGetInjectedStuff: this,
-                });
-                // console.log('instance', instance);
-                if (propName === 'getOriginalPrototype') {
-                    return () => Object.getPrototypeOf(instance);
-                }
-                if (propName === 'getOriginalConstructor') {
-                    return () => instance.constructor;
-                }
-                const methods = ctor[Symbols.classMethodsNames] || [];
-                const isMethods = methods.includes(propName);
-                const methodOrProperty = isMethods
-                    ? instance[propName].bind(instance)
-                    : instance[propName];
-                // console.log(
-                //   `methodOrProperty from proxy ${propName?.toString()} = isMethods:${isMethods}`,
-                //   methods,
-                // );
-                return methodOrProperty;
-            }
-        },
-    });
-};
-// export const injectController = inject;
-// export type SubscriptionEvent<T> = {
-//   name: keyof T;
-//   data: any;
-// };
-/**
- * TODO
- */
-// export const injectEntityEvents = <T>(
-//   subscriberClassResolveFn: () => new (...args: any[]) => T,
-//   eventName?: keyof Omit<EntitySubscriberInterface,'listenTo'> ,
-// ): Observable<SubscriptionEvent<T>> => {
-//   const eventsSrc = new Subject<SubscriptionEvent<T>>();
-//   const obs = eventsSrc.asObservable();
-//   let isFirstSubscription = true;
-//   const proxyObservable = new Proxy(obs, {
-//     get(target, prop, receiver) {
-//       if (prop === 'subscribe') {
-//         return (...args: any[]) => {
-//           if (isFirstSubscription) {
-//             isFirstSubscription = false;
-//             const subscriberClassFN: typeof TaonBaseClass =
-//               subscriberClassResolveFn() as any;
-//             const ctx = subscriberClassFN[
-//               Symbols.ctxInClassOrClassObj
-//             ] as EndpointContext;
-//             if (!ctx) {
-//               throw new Error(
-//                 `You are trying to inject class without context. Use context like this:
-//               class MyClassSubscriber extends BaseSubscriber {
-//                   ${eventName as any}() {
-//                     \/\/ your code here
-//                   }
-//               }
-//               Taon.injectSubscriberEvents( MyContext.getInstance(()=> MyClassSubscriber), '${eventName as any}' )
-//               `,
-//               );
-//             }
-//             const subscriberInstance = ctx.getInstanceBy(subscriberClassFN);
-//             // subscriberInstance TODO @LAST subscriber event from instance
-//             // const entity = subscriberClassFN.prototype.listenTo();
-//             console.log('First subscription, you can access arguments here:', {
-//               subscriberClassFN,
-//               eventName,
-//             });
-//           }
-//           return target.subscribe(...args);
-//         };
-//       }
-//       return Reflect.get(target, prop, receiver);
-//     },
-//   });
-//   return proxyObservable as Observable<SubscriptionEvent<T>>;
-// };
-
-/**
- * TODO prevent calling methods when not initialized
- * with init(ctx)
- */
-//#region @browser
-//#endregion
-class BaseAngularsService {
     //#endregion
-    constructor() {
-        //#region @browser
-        this.currentContext = inject$1(TAON_CONTEXT);
-        //#region @browser
-        this.CURRENT_HOST_BACKEND_PORT = inject$1(CURRENT_HOST_BACKEND_PORT, {
-            optional: true,
-        });
-        this.CURRENT_HOST_URL = inject$1(CURRENT_HOST_URL, {
-            optional: true,
-        });
-        // #endregion
+    //#region entity property events
+    ROOM_NAME_UPDATE_ENTITY_PROPERTY(contextName, className, property, entityId) {
+        return `${contextName}:room${_.camelCase(className)}${_.camelCase(property)}${entityId}`.toLowerCase();
     }
-    /**
-     * @deprecated
-     * Returns the host URL for the backend service
-     * that is running on localhost (normal NodeJS/ExpressJS mode).
-     */
-    get host() {
-        //#region @browser
-        if (this.CURRENT_HOST_URL) {
-            return this.CURRENT_HOST_URL;
-        }
-        return `http://localhost:${this.CURRENT_HOST_BACKEND_PORT}`;
-        //#endregion
-        return void 0;
+    ROOM_SUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(contextName) {
+        return `${contextName}:${this.KEYroomSubscribe}EntityPropertyEvents`;
     }
-    injectController(ctor, 
-    /**
-     * optional override context
-     */
-    overrideCurrentContext) {
-        return inject(() => {
-            let currentContext;
-            //#region @browser
-            currentContext = overrideCurrentContext
-                ? overrideCurrentContext
-                : this.currentContext;
-            //#endregion
-            if (!currentContext) {
-                throw new Error('No context available. Make sure to initialize the context before injecting controllers.');
-            }
-            return currentContext ? currentContext.getClass(ctor) : void 0;
-        });
+    ROOM_UNSUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(contextName) {
+        return `${contextName}:${this.KEYroomUnsubscribe}EntityPropertyEvents`;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: BaseAngularsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: BaseAngularsService }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: BaseAngularsService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
+var Symbols;
+(function (Symbols) {
+    Symbols.ctxInClassOrClassObj = Symbol();
+    Symbols.classNameStaticProperty = SYMBOL.ClassNameStaticProperty;
+    Symbols.fullClassNameStaticProperty = `$$fullclassName$$`;
+    Symbols.orignalClass = OrignalClassKey;
+    Symbols.orignalClassClonesObj = `$$originalClassClonesObj$$`;
+    Symbols.classMethodsNames = `$$classMethodsNames$$`;
+    Symbols.REALTIME = new Realtime();
+    Symbols.metadata = {
+        className: `class:realname`,
+        options: {
+            controller: `controller:options`,
+            entity: `entity:options`,
+            repository: `repository:options`,
+            provider: `provider:options`,
+            subscriber: `subscriber:options`,
+            migration: `migration:options`,
+        },
+    };
+    Symbols.old = {
+        HAS_TABLE_IN_DB: Symbol(),
+        MDC_KEY: `modeldataconfig`,
+        WEBSQL_REST_PROGRESS_FUN: Symbol(),
+        WEBSQL_REST_PROGRESS_FUN_START: Symbol(),
+        WEBSQL_REST_PROGRESS_FUN_DONE: Symbol(),
+        WEBSQL_REST_PROGRESS_TIMEOUT: Symbol(),
+        X_TOTAL_COUNT: `x-total-count`,
+        CIRCURAL_OBJECTS_MAP_BODY: `circuralmapbody`,
+        CIRCURAL_OBJECTS_MAP_QUERY_PARAM: `circuralmapbody`,
+        MAPPING_CONFIG_HEADER: `mappingheader`,
+        MAPPING_CONFIG_HEADER_BODY_PARAMS: `mhbodyparams`,
+        MAPPING_CONFIG_HEADER_QUERY_PARAMS: `mhqueryparams`,
+        ENDPOINT_META_CONFIG: `ng2_rest_endpoint_config`,
+        CLASS_DECORATOR_CONTEXT: `$$ng2_rest_class_context`,
+        SOCKET_MSG: `socketmessageng2rest`,
+        ANGULAR: {
+            INPUT_NAMES: Symbol(),
+        },
+        ERROR_MESSAGES: {
+            CLASS_NAME_MATCH: `Please check if your "class name" matches  @Controller( className ) or @Entity( className )`,
+        },
+    };
+})(Symbols || (Symbols = {}));
 
-class ContextDbMigrations {
-    //#endregion
+var Validators;
+(function (Validators) {
+    //#region vlidate class name
+    Validators.classNameVlidation = (className, target) => {
+        setTimeout(() => {
+            // console.log(`check after timeout ${className} , production mode: ${FrameworkContext.isProductionMode}`)
+            if (_.isUndefined(className)) {
+                throw `[Taon]
+      Please provide "className" property for each Controller and Entity:
+
+          @Taon.Controller({ className: 'MyExampleCtrl'  })
+          class MyExampleCtrl {
+            ...
+          }
+
+          @Taon.Entity({ className: 'MyExampleEntity'  })
+          class MyExampleEntity {
+            ...
+          }
+
+    Notice that minified javascript code does not preserve
+    Functions/Classes names -this is only solution to preserve classes names.
+
+        `;
+            }
+        });
+        return _.isUndefined(className) ? target.name : className;
+    };
     //#endregion
-    //#region constructor
-    constructor(ctx) {
-        this.ctx = ctx;
-        //#region fields
-        //#region fields / migration table name
-        this.DEFAULT_MIGRATION_TABLE_NAME = 'TAON_MIGRATION_META';
-        //#endregion
-        //#region fields / migration statuses
-        this.MIGRATION_STATUS_COMPLETED = 'completed';
-        this.MIGRATION_STATUS_PENDING = 'pending';
-        //#endregion
-        //#region fields / migration table schema
-        this.table = new Table({
-            name: this.DEFAULT_MIGRATION_TABLE_NAME,
-            columns: [
-                {
-                    name: 'id',
-                    type: 'integer',
-                    isPrimary: true, // Mark it as the primary key
-                    isGenerated: true, // Enable auto-generation
-                    generationStrategy: 'increment', // Use auto-increment strategy
-                },
-                {
-                    name: 'name',
-                    type: 'varchar',
-                    length: '255',
-                    isUnique: true, // Ensure the name is unique
-                    isNullable: false, // Ensure this field is required
-                },
-                {
-                    // context is a part of name
-                    name: 'context',
-                    type: 'varchar',
-                    length: '255',
-                    isNullable: false, // Optional context for migrations (e.g., tenant or module name)
-                },
-                {
-                    name: 'applied_at',
-                    type: 'timestamp',
-                    default: 'CURRENT_TIMESTAMP', // Automatically set the timestamp
-                    isNullable: true,
-                },
-                {
-                    name: 'status',
-                    type: 'varchar',
-                    length: '50',
-                    default: `'${this.MIGRATION_STATUS_COMPLETED}'`,
-                    isNullable: false,
-                },
-                // { // TODO not needed for now
-                //   name: 'checksum',
-                //   type: 'varchar',
-                //   length: '64',
-                //   isNullable: true, // Optional field to store a hash/checksum of migration file
-                // },
-            ],
-        });
-    }
-    //#endregion
-    //#region methods & getters / make sure migration table exists
-    async ensureMigrationTableExists() {
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        return (void 0);
-    }
+    //#region validate method config
+    Validators.checkIfMethodsWithReponseTYpeAlowed = (methods, current) => {
+        const defaultResponseType = 'text or JSON';
+        if (!current.responseType) {
+            return;
+        }
+        for (let index = 0; index < methods.length; index++) {
+            const m = methods[index];
+            if (m.path === current.path && m.responseType !== current.responseType) {
+                throw new Error(`
+  [taon] you can have 2 methods with same path but differetn reponseType-s
+
+          ${m.methodName}( ... path: ${m.path} )  -> responseType: ${m.responseType || defaultResponseType}
+          ${current.methodName}( ... path: ${current.path} ) -> responseType: ${current.responseType}
+
+    Please change path name on of the methods.
+
+        `);
+            }
+        }
+    };
     //#endregion
-    //#region methods & getters / revert migration to timestamp
-    async logSelectALl(name, queryRunner) {
-        console.log(name, (await queryRunner.query(`SELECT * FROM ${this.DEFAULT_MIGRATION_TABLE_NAME} WHERE context = $1`, [this.ctx.contextName])).map(m => m.name));
-    }
-    async revertMigrationToTimestamp(timestamp) {
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        return (void 0);
-    }
+    //#region validate class functions
+    // TODO
+    Validators.validateClassFunctions = (controllers, entities, proviers, repositories) => {
+        if (_.isArray(controllers) &&
+            controllers.filter(f => !_.isFunction(f)).length > 0) {
+            console.error('controllers', controllers);
+            throw `
+
+  Incorect value for property "controllers" inside Taon.Init(...)
+
+  `;
+        }
+        if (_.isArray(entities) &&
+            entities.filter(f => !_.isFunction(f)).length > 0) {
+            console.error('entites', entities);
+            throw `
+
+  Incorect value for property "entities" inside Taon.Init(...)
+
+  `;
+        }
+    };
     //#endregion
-    //#region methods & getters / clear migration table
-    async clearMigrationTable() {
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        return (void 0);
-    }
+    Validators.preventUndefinedModel = (model, id) => {
+        if (_.isUndefined(model)) {
+            throw `Bad update by id, config, id: ${id}`;
+        }
+    };
+})(Validators || (Validators = {}));
+
+//#region imports
+/* */
+//#endregion
+var ClassHelpers;
+(function (ClassHelpers) {
+    //#region get class from name
+    /**
+     * TODO - repalce in every place when getting class fn from object
+     */
+    ClassHelpers.getClassFnFromObject = (json) => {
+        if (_.isUndefined(json) || _.isNull(json)) {
+            return;
+        }
+        if (json.constructor) {
+            return json.constructor;
+        }
+        const p = Object.getPrototypeOf(json);
+        return p && p.constructor && p.constructor.name !== 'Object'
+            ? p.constructor
+            : void 0;
+    };
     //#endregion
-    //#region methods & getters / mark all migrations as applied
-    async markAllMigrationsAsApplied() {
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        return (void 0);
-    }
+    //#region get name
+    ClassHelpers.getName = (classFnOrObject) => {
+        // exception for FormData
+        if (classFnOrObject instanceof FormData) {
+            return 'FormData';
+        }
+        if (!classFnOrObject) {
+            console.error('OBJECT OR CLASS', classFnOrObject);
+            throw new Error(`Cannot get name from this object or class.`);
+        }
+        return ((classFnOrObject[Symbols.classNameStaticProperty]
+            ? classFnOrObject[Symbols.classNameStaticProperty]
+            : classFnOrObject?.constructor[Symbols.classNameStaticProperty]) ||
+            (_.isFunction(classFnOrObject) ? CLASS.getName(classFnOrObject) : void 0));
+    };
     //#endregion
-    //#region methods & getters / run all migrations
-    async runAllNotCompletedMigrations() {
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        return (void 0);
-    }
-}
-
-class DITaonContainer {
-    static { this.instances = new Map(); }
-    static resolve(target) {
-        if (DITaonContainer.instances.has(target)) {
-            return DITaonContainer.instances.get(target);
+    ClassHelpers.getOrginalClass = (classFnOrObject) => {
+        const org = classFnOrObject[Symbols.orignalClass];
+        if (!org) {
+            return classFnOrObject;
+        }
+        return ClassHelpers.getOrginalClass(org);
+    };
+    //#region get full internal name
+    ClassHelpers.getFullInternalName = (classFnOrObject) => {
+        // exception for FormData
+        if (!classFnOrObject) {
+            throw new Error(`Cannot get name from: ${classFnOrObject}`);
+        }
+        return ((classFnOrObject[Symbols.fullClassNameStaticProperty]
+            ? classFnOrObject[Symbols.fullClassNameStaticProperty]
+            : classFnOrObject?.constructor[Symbols.fullClassNameStaticProperty]) ||
+            void 0);
+    };
+    //#endregion
+    //#region get unique key
+    ClassHelpers.getUniqueKey = (classFnOrObject) => {
+        const classFn = _.isFunction(classFnOrObject)
+            ? classFnOrObject
+            : classFnOrObject.constructor;
+        const config = Reflect.getMetadata(Symbols.metadata.options.entity, classFn);
+        return config.uniqueKeyProp;
+    };
+    //#endregion
+    //#region is class object
+    ClassHelpers.isContextClassObject = (obj) => {
+        if (!_.isObject(obj) ||
+            _.isArray(obj) ||
+            _.isRegExp(obj) ||
+            _.isBuffer(obj) ||
+            _.isArrayBuffer(obj)) {
+            return false;
+        }
+        if (_.isDate(obj)) {
+            return true;
+        }
+        const className = ClassHelpers.getName(obj);
+        return _.isString(className) && className !== 'Object';
+    };
+    //#endregion
+    //#region get name
+    ClassHelpers.setName = (target, className) => {
+        // console.log('setName', className, target.name)
+        Validators.classNameVlidation(className, target);
+        target[Symbols.classNameStaticProperty] = className;
+    };
+    //#endregion
+    //#region has parent with class name
+    ClassHelpers.hasParentClassWithName = (target, className, targets = []) => {
+        if (!target) {
+            return false;
+        }
+        targets.push(target);
+        let targetProto = Object.getPrototypeOf(target);
+        if (_.isFunction(targetProto) &&
+            ClassHelpers.getName(targetProto) === className) {
+            // console.log(`true  "${_.first(targets).name}" for ${targets.map(d => d.name).join(',')}`)
+            return true;
+        }
+        return ClassHelpers.hasParentClassWithName(targetProto, className, targets);
+    };
+    //#endregion
+    //#region get methods name
+    //#region not allowed as method name
+    const notAllowedAsMethodName = [
+        'length',
+        'name',
+        'arguments',
+        'caller',
+        'constructor',
+        'apply',
+        'bind',
+        'call',
+        'toString',
+        '__defineGetter__',
+        '__defineSetter__',
+        'hasOwnProperty',
+        '__lookupGetter__',
+        '__lookupSetter__',
+        'isPrototypeOf',
+        'propertyIsEnumerable',
+        'valueOf',
+        '__proto__',
+        'toLocaleString',
+    ];
+    //#endregion
+    /**
+     * Express async handler for middleware functions.
+     */
+    ClassHelpers.asyncHandler = fn => (req, res, next) => {
+        Promise.resolve(fn(req, res, next)).catch(next);
+    };
+    ClassHelpers.getMethodsNames = (classOrClassInstance, allMethodsNames = []) => {
+        if (!classOrClassInstance) {
+            return Utils.uniqArray(allMethodsNames);
+        }
+        const isClassFunction = _.isFunction(classOrClassInstance);
+        const classFun = isClassFunction
+            ? classOrClassInstance
+            : Object.getPrototypeOf(classOrClassInstance);
+        const objectToCheck = isClassFunction
+            ? classOrClassInstance?.prototype
+            : classOrClassInstance;
+        const prototypeObj = Object.getPrototypeOf(objectToCheck || {});
+        const properties = _.uniq([
+            ...Object.getOwnPropertyNames(objectToCheck || {}),
+            ...Object.getOwnPropertyNames(prototypeObj || {}),
+            ...Object.keys(objectToCheck || {}),
+            ...Object.keys(prototypeObj || {}),
+        ]).filter(f => !!f && !notAllowedAsMethodName.includes(f));
+        properties
+            .filter(methodName => typeof objectToCheck[methodName] === 'function')
+            .forEach(p => allMethodsNames.push(p));
+        if (!classFun ||
+            !classFun.constructor ||
+            classFun?.constructor?.name === 'Object') {
+            return Utils.uniqArray(allMethodsNames);
+        }
+        return ClassHelpers.getMethodsNames(Object.getPrototypeOf(classFun), allMethodsNames);
+    };
+    //#endregion
+    //#region get controller configs
+    ClassHelpers.getControllerConfigs = (target, configs = [], callerTarget) => {
+        if (!_.isFunction(target)) {
+            throw `[typescript-class-helper][getControllerConfigs] Cannot get class config from: ${target}`;
         }
-        // const tokens = Reflect.getMetadata('design:paramtypes', target) || [];
-        const injections = []; //  tokens.map(token => Container.inject<any>(token));
-        const instance = new target(...injections);
-        DITaonContainer.instances.set(target, instance);
-        return instance;
-    }
-    static inject(target) {
-        return new Proxy({}, {
-            get: (_, propName) => {
-                let instance = DITaonContainer.instances.get(target) ||
-                    DITaonContainer.resolve(target);
-                return typeof instance[propName] === 'function'
-                    ? instance[propName].bind(instance)
-                    : instance[propName];
-            },
-            set: (_, propName, value) => {
-                let instance = DITaonContainer.instances.get(target) ||
-                    DITaonContainer.resolve(target);
-                instance[propName] = value;
-                return true;
-            },
-        });
-    }
-}
-
-const getResponseValue = (response, options) => {
-    /* */
-    /* */
-    /* */
-    /* */
-    /* */
-    /* */
-    /* */
-    /* */
-    /* */
-    /* */
-    /* */
-    /* */
-    /* */
-    /* */
-    /* */
-    /* */
-    /* */
-    /* */
-    return (void 0);
-};
+        let config;
+        const parentClass = Object.getPrototypeOf(target);
+        const parentName = parentClass ? ClassHelpers.getName(parentClass) : void 0;
+        const isValidParent = _.isFunction(parentClass) && parentName !== '';
+        config = controllerConfigFrom(ClassHelpers.getClassConfig(target));
+        configs.push(config);
+        return isValidParent
+            ? ClassHelpers.getControllerConfigs(parentClass, configs, target)
+            : configs;
+    };
+    //#endregion
+    //#region ensure configs
+    // Ensure ClassConfig on constructor, clone parent if needed
+    ClassHelpers.ensureClassConfig = (target) => {
+        let cfg = Reflect.getOwnMetadata(Symbols.metadata.options.controller, // META_KEYS.class,
+        target);
+        if (!cfg) {
+            cfg = { methods: {} };
+            const parent = Object.getPrototypeOf(target);
+            if (parent && parent !== Function.prototype) {
+                const parentCfg = Reflect.getMetadata(Symbols.metadata.options.controller, // META_KEYS.class,
+                parent);
+                if (parentCfg) {
+                    // Deep copy each method config so child gets its own objects
+                    const clonedMethods = {};
+                    for (const [k, v] of Object.entries(parentCfg.methods)) {
+                        clonedMethods[k] = {
+                            ...v,
+                            parameters: { ...v.parameters }, // shallow clone parameters too
+                        };
+                    }
+                    cfg = {
+                        ...parentCfg,
+                        methods: clonedMethods,
+                    };
+                }
+            }
+            Reflect.defineMetadata(Symbols.metadata.options.controller, cfg, target);
+        }
+        return cfg;
+    };
+    // Ensure MethodConfig inside ClassConfig
+    ClassHelpers.ensureMethodConfig = (target, propertyKey) => {
+        const classCfg = ClassHelpers.ensureClassConfig(target.constructor);
+        let methodCfg = classCfg.methods[propertyKey?.toString()];
+        if (!methodCfg) {
+            methodCfg = { methodName: propertyKey?.toString(), parameters: {} };
+            classCfg.methods[propertyKey?.toString()] = methodCfg;
+        }
+        return methodCfg;
+    };
+    ClassHelpers.getClassConfig = (constructor) => {
+        return Reflect.getMetadata(Symbols.metadata.options.controller, constructor);
+    };
+    //#endregion
+})(ClassHelpers || (ClassHelpers = {}));
 
 var TaonHelpers;
 (function (TaonHelpers) {
@@ -5556,11 +5325,451 @@ const createContextFn = (configFn, cloneOptions) => {
     return res;
 };
 //#endregion
-const createContext = (configFn) => {
-    return createContextFn(configFn, { useAsRemoteContext: false });
-};
-// const AA = createContext(() => ({ contextName: 'aa' }));
-// const BB = AA.cloneAsRemoteContext();
+const createContext = (configFn) => {
+    return createContextFn(configFn, { useAsRemoteContext: false });
+};
+// const AA = createContext(() => ({ contextName: 'aa' }));
+// const BB = AA.cloneAsRemoteContext();
+
+const inject = (entity) => {
+    return new Proxy({}, {
+        get: (_, propName) => {
+            if (propName === 'hasOwnProperty') {
+                return () => false;
+            }
+            const ctor = entity();
+            const contextFromClass = ctor[Symbols.ctxInClassOrClassObj];
+            const resultContext = contextFromClass;
+            if (resultContext) {
+                let instance = resultContext.inject(ctor, {
+                    parentInstanceThatWillGetInjectedStuff: this,
+                });
+                // console.log('instance', instance);
+                if (propName === 'getOriginalPrototype') {
+                    return () => Object.getPrototypeOf(instance);
+                }
+                if (propName === 'getOriginalConstructor') {
+                    return () => instance.constructor;
+                }
+                const methods = ctor[Symbols.classMethodsNames] || [];
+                const isMethods = methods.includes(propName);
+                const methodOrProperty = isMethods
+                    ? instance[propName].bind(instance)
+                    : instance[propName];
+                // console.log(
+                //   `methodOrProperty from proxy ${propName?.toString()} = isMethods:${isMethods}`,
+                //   methods,
+                // );
+                return methodOrProperty;
+            }
+        },
+    });
+};
+// export const injectController = inject;
+// export type SubscriptionEvent<T> = {
+//   name: keyof T;
+//   data: any;
+// };
+/**
+ * TODO
+ */
+// export const injectEntityEvents = <T>(
+//   subscriberClassResolveFn: () => new (...args: any[]) => T,
+//   eventName?: keyof Omit<EntitySubscriberInterface,'listenTo'> ,
+// ): Observable<SubscriptionEvent<T>> => {
+//   const eventsSrc = new Subject<SubscriptionEvent<T>>();
+//   const obs = eventsSrc.asObservable();
+//   let isFirstSubscription = true;
+//   const proxyObservable = new Proxy(obs, {
+//     get(target, prop, receiver) {
+//       if (prop === 'subscribe') {
+//         return (...args: any[]) => {
+//           if (isFirstSubscription) {
+//             isFirstSubscription = false;
+//             const subscriberClassFN: typeof TaonBaseClass =
+//               subscriberClassResolveFn() as any;
+//             const ctx = subscriberClassFN[
+//               Symbols.ctxInClassOrClassObj
+//             ] as EndpointContext;
+//             if (!ctx) {
+//               throw new Error(
+//                 `You are trying to inject class without context. Use context like this:
+//               class MyClassSubscriber extends BaseSubscriber {
+//                   ${eventName as any}() {
+//                     \/\/ your code here
+//                   }
+//               }
+//               Taon.injectSubscriberEvents( MyContext.getInstance(()=> MyClassSubscriber), '${eventName as any}' )
+//               `,
+//               );
+//             }
+//             const subscriberInstance = ctx.getInstanceBy(subscriberClassFN);
+//             // subscriberInstance TODO @LAST subscriber event from instance
+//             // const entity = subscriberClassFN.prototype.listenTo();
+//             console.log('First subscription, you can access arguments here:', {
+//               subscriberClassFN,
+//               eventName,
+//             });
+//           }
+//           return target.subscribe(...args);
+//         };
+//       }
+//       return Reflect.get(target, prop, receiver);
+//     },
+//   });
+//   return proxyObservable as Observable<SubscriptionEvent<T>>;
+// };
+
+//#region imports
+//#endregion
+//#region get transform function
+/**
+ * @deprecated
+ */
+const getTransformFunction = (target) => {
+    if (!target) {
+        return;
+    }
+    // const className = ClassHelpers.getName(target)
+    // target = ClassHelpers.getBy(className);
+    if (!target) {
+        return void 0;
+    }
+    const configs = ClassHelpers.getControllerConfigs(target);
+    // console.log(`CONFIGS TO CHECK`, configs)
+    const functions = configs
+        .map(c => {
+        if (_.isFunction(c.browserTransformFn)) {
+            return c.browserTransformFn;
+        }
+    })
+        .filter(f => _.isFunction(f));
+    return functions.length === 0
+        ? void 0
+        : function (entity) {
+            for (let index = functions.length - 1; index >= 0; index--) {
+                const transformFun = functions[index];
+                transformFun(entity);
+            }
+            return entity;
+        };
+};
+//#endregion
+//#region single transform
+/**
+ * @deprecated
+ */
+const singleTransform = (json) => {
+    let ptarget = ClassHelpers.getClassFnFromObject(json);
+    let pbrowserTransformFn = getTransformFunction(ptarget);
+    if (pbrowserTransformFn) {
+        const newValue = pbrowserTransformFn(json);
+        if (!_.isObject(newValue)) {
+            console.error(`Please return object in transform function for class: ` +
+                `${ClassHelpers.getName(json)}`);
+        }
+        else {
+            json = newValue;
+        }
+    }
+    return json;
+};
+//#endregion
+class EntityProcess {
+    //#region init
+    static async init(result, response) {
+        return await new EntityProcess(result, response).run();
+    }
+    //#endregion
+    //#region constructor
+    constructor(
+    /**
+     * Data from backend
+     */
+    result, response) {
+        this.result = result;
+        this.response = response;
+        /**
+         * Say yes to:
+         * - circural object
+         * - transform browser fn in decorator
+         */
+        this.advancedManipulation = false;
+        this.circural = [];
+    }
+    //#endregion
+    //#region check advanced manipulation
+    checkAdvancedManiupulation() {
+        if (_.isFunction(this.result)) {
+            this.advancedManipulation = true;
+            this.result = this.result();
+        }
+    }
+    //#endregion
+    //#region run
+    async run() {
+        this.checkAdvancedManiupulation();
+        this.data = this.result;
+        if (_.isObject(this.result)) {
+            if (this.advancedManipulation) {
+                this.applayTransformFn();
+            }
+            this.setHeaders();
+        }
+        this.send();
+    }
+    //#endregion
+    //#region apply transform function
+    applayTransformFn() {
+        if (_.isObject(this.data) && !_.isArray(this.data)) {
+            this.data = singleTransform(this.data);
+        }
+        const { include } = { include: [] };
+        walk.Object(this.data, (value, lodashPath, changeValue, { skipObject, isCircural }) => {
+            // console.log(`${isCircural ? 'CIR' : 'NOT'} : ${lodashPath}`)
+            if (!isCircural) {
+                if (!_.isArray(value) && _.isObject(value)) {
+                    changeValue(singleTransform(value));
+                }
+            }
+        }, { checkCircural: true, breadthWalk: true, include });
+        const { circs } = walk.Object(this.data, void 0, {
+            checkCircural: true,
+            breadthWalk: true,
+            include,
+        });
+        this.circural = circs;
+    }
+    //#endregion
+    //#region set headers
+    setHeaders() {
+        const { include } = { include: [] };
+        const className = ClassHelpers.getName(this.data);
+        const doNothing = _.isNil(this.data) ||
+            [
+                'Object',
+                '',
+                //  void 0, null // TODO  not sure about commenting this
+            ].includes(className);
+        // console.log('doNothing', doNothing)
+        if (!doNothing) {
+            const cleaned = JSON10.cleaned(this.data, void 0, {
+                breadthWalk: true,
+                include,
+            });
+            this.entityMapping = Mapping.decode(cleaned, !this.advancedManipulation);
+            this.response.set(Symbols.old.MAPPING_CONFIG_HEADER, JSON.stringify(this.entityMapping));
+            if (this.advancedManipulation) {
+                this.response.set(Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, JSON.stringify(this.circural));
+            }
+        }
+    }
+    //#endregion
+    //#region send
+    send() {
+        if (this.advancedManipulation) {
+            const browserKey = config.folder.browser;
+            let toSend = _.isArray(this.data) ? [] : {};
+            const { include = [], exclude = [] } = { include: [], exclude: [] };
+            walk.Object(this.data, (value, lodashPath, changeVAlue, { isCircural, skipObject }) => {
+                // console.log(`${isCircural ? 'CIR' : 'NOT'} ${lodashPath}`)
+                if (isCircural) {
+                    _.set(toSend, lodashPath, null);
+                }
+                else {
+                    const fun = getTransformFunction(ClassHelpers.getClassFnFromObject(value));
+                    if (_.isFunction(fun)) {
+                        _.set(toSend, `${lodashPath}.${browserKey}`, value[browserKey]);
+                        const indexProp = ClassHelpers.getUniqueKey(value);
+                        _.set(toSend, `${lodashPath}.${indexProp}`, value[indexProp]);
+                        // skipObject()
+                    }
+                    else {
+                        _.set(toSend, lodashPath, value);
+                    }
+                }
+            }, { checkCircural: true, breadthWalk: true, include });
+            if (!_.isArray(this.data)) {
+                let funParent = getTransformFunction(ClassHelpers.getClassFnFromObject(this.data));
+                // if (this.mdc && this.mdc.exclude && this.mdc.exclude.length > 0) {
+                //   console.log(`funParent !!! have fun? ${!!funParent} `)
+                // }
+                if (_.isFunction(funParent)) {
+                    toSend = {
+                        [browserKey]: toSend[browserKey],
+                    };
+                }
+                Object.keys(this.data).forEach(prop => {
+                    if (prop !== browserKey) {
+                        const v = this.data[prop];
+                        if (!((include.length > 0 && !include.includes(prop)) ||
+                            (exclude.length > 0 && exclude.includes(prop)))) {
+                            if (ClassHelpers.isContextClassObject(v) &&
+                                _.isFunction(getTransformFunction(ClassHelpers.getClassFnFromObject(v)))) {
+                                toSend[prop] = {
+                                    [browserKey]: v[browserKey],
+                                };
+                                const indexProp = ClassHelpers.getUniqueKey(v);
+                                toSend[prop][indexProp] = this.data[prop][indexProp];
+                                for (const key in v) {
+                                    if (_.isObject(v) &&
+                                        v.hasOwnProperty(key) &&
+                                        ![indexProp, config.folder.browser].includes(key) &&
+                                        (_.isString(v[key]) ||
+                                            _.isNumber(v[key]) ||
+                                            _.isDate(v[key]) ||
+                                            _.isNull(v[key]) ||
+                                            _.isBoolean(v[key]))) {
+                                        toSend[prop][key] = v[key];
+                                    }
+                                }
+                            }
+                            else {
+                                toSend[prop] = v;
+                            }
+                        }
+                    }
+                });
+            }
+            // toSend = Helpers.JSON.cleaned(toSend, void 0, { breadthWalk: true })
+            this.response.json(toSend);
+        }
+        else {
+            this.response.json(this.data);
+        }
+    }
+}
+
+const cloneObj = (override, classFn) => {
+    const result = _.merge(new classFn(), _.cloneDeep(this));
+    walk.Object(override || {}, (value, lodashPath) => {
+        if (_.isNil(value) || _.isFunction(value) || _.isObject(value)) {
+            // skipping
+        }
+        else {
+            _.set(result, lodashPath, value);
+        }
+    }, {
+        walkGetters: false,
+    });
+    // console.log({result})
+    return result;
+};
+
+//#endregion
+class TaonBaseClass {
+    //#region class initialization hook
+    /**
+     * class initialization hook
+     * taon after class instance creation
+     */
+    async _() { }
+    //#endregion
+    //#region clone
+    /**
+     *
+     * @param overrideObjOrFn if object is provided it will override values in cloned object,
+     * if function is provided it will be called with old cloned values and should return
+     * object with values to override
+     * @returns cloned instance of the class
+     */
+    clone(overrideObjOrFn) {
+        if (_.isString(overrideObjOrFn)) {
+            console.log(overrideObjOrFn);
+            throw new Error('String is not supported as .clone() method argument');
+        }
+        const classFn = ClassHelpers.getClassFnFromObject(this);
+        if (_.isFunction(overrideObjOrFn)) {
+            // console.log('clone with fn');
+            const oldValues = (_.cloneDeep(this) || {});
+            return cloneObj(overrideObjOrFn(oldValues), classFn);
+        }
+        // console.log('clone normal');
+        return cloneObj(overrideObjOrFn, classFn);
+    }
+}
+
+/* */
+/* */
+class TaonBaseEntity extends TaonBaseClass {
+    /**
+     * simple check if relation is ok
+     */
+    relation(relationName) {
+        return relationName;
+    }
+    /**
+     * simple check if relation is ok
+     */
+    relations(relationNames) {
+        return relationNames;
+    }
+}
+
+/* */
+/* */
+/* */
+class TaonBaseAbstractEntity extends TaonBaseEntity {
+}
+
+/**
+ * TODO prevent calling methods when not initialized
+ * with init(ctx)
+ */
+//#region @browser
+//#endregion
+class TaonBaseAngularService {
+    //#endregion
+    constructor() {
+        //#region @browser
+        this.currentContext = inject$1(TAON_CONTEXT);
+        //#region @browser
+        this.CURRENT_HOST_BACKEND_PORT = inject$1(CURRENT_HOST_BACKEND_PORT, {
+            optional: true,
+        });
+        this.CURRENT_HOST_URL = inject$1(CURRENT_HOST_URL, {
+            optional: true,
+        });
+        // #endregion
+    }
+    /**
+     * @deprecated
+     * Returns the host URL for the backend service
+     * that is running on localhost (normal NodeJS/ExpressJS mode).
+     */
+    get host() {
+        //#region @browser
+        if (this.CURRENT_HOST_URL) {
+            return this.CURRENT_HOST_URL;
+        }
+        return `http://localhost:${this.CURRENT_HOST_BACKEND_PORT}`;
+        //#endregion
+        return void 0;
+    }
+    injectController(ctor, 
+    /**
+     * optional override context
+     */
+    overrideCurrentContext) {
+        return inject(() => {
+            let currentContext;
+            //#region @browser
+            currentContext = overrideCurrentContext
+                ? overrideCurrentContext
+                : this.currentContext;
+            //#endregion
+            if (!currentContext) {
+                throw new Error('No context available. Make sure to initialize the context before injecting controllers.');
+            }
+            return currentContext ? currentContext.getClass(ctor) : void 0;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: TaonBaseAngularService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: TaonBaseAngularService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: TaonBaseAngularService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
 
 /**
  * Provider decorator
@@ -7287,22 +7496,452 @@ TaonBaseSubscriberForEntity = __decorate([
     })
 ], TaonBaseSubscriberForEntity);
 
-var Base;
-(function (Base) {
-    Base.Controller = TaonBaseController;
-    Base.CrudController = TaonBaseCrudController;
-    Base.Entity = TaonBaseEntity;
-    Base.AbstractEntity = TaonBaseAbstractEntity;
-    Base.Provider = TaonBaseProvider;
-    Base.Class = TaonBaseClass;
-    Base.Repository = TaonBaseRepository;
-    Base.CustomRepository = TaonBaseCustomRepository;
-    Base.SubscriberForEntity = TaonBaseSubscriberForEntity;
-    Base.Migration = TaonBaseMigration;
-    Base.Middleware = TaonBaseMiddleware;
-    Base.AngularService = BaseAngularsService;
-    Base.Context = TaonBaseContext;
-})(Base || (Base = {}));
+//#region models / method config
+/**
+ * @link './decorators/http/http-methods-decorators.ts' TaonHttpDecoratorOptions
+ */
+class MethodConfig {
+}
+//#endregion
+
+// import { cloneObj } from '../helpers/clone-obj';
+class ParamConfig {
+}
+
+class FormlyHorizontalWrapper extends FieldWrapper {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: FormlyHorizontalWrapper, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.0.6", type: FormlyHorizontalWrapper, isStandalone: false, selector: "formly-horizontal-wrapper", viewQueries: [{ propertyName: "fieldComponent", first: true, predicate: ["fieldComponent"], descendants: true, read: ViewContainerRef }], usesInheritance: true, ngImport: i0, template: `
+    <div class="form-group row">
+      <label
+        [attr.for]="id"
+        class="col-sm-2 col-form-label"
+        *ngIf="to.label">
+        {{ to.label }}
+        <ng-container *ngIf="to.required && to.hideRequiredMarker !== true"
+          >*</ng-container
+        >
+      </label>
+      <div class="col-sm-10">
+        <ng-template #fieldComponent></ng-template>
+      </div>
+    </div>
+  `, isInline: true, styles: [":host{display:block;padding:5px;margin-bottom:5px;border:1px dotted gray}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: FormlyHorizontalWrapper, decorators: [{
+            type: Component,
+            args: [{ selector: 'formly-horizontal-wrapper', standalone: false, template: `
+    <div class="form-group row">
+      <label
+        [attr.for]="id"
+        class="col-sm-2 col-form-label"
+        *ngIf="to.label">
+        {{ to.label }}
+        <ng-container *ngIf="to.required && to.hideRequiredMarker !== true"
+          >*</ng-container
+        >
+      </label>
+      <div class="col-sm-10">
+        <ng-template #fieldComponent></ng-template>
+      </div>
+    </div>
+  `, styles: [":host{display:block;padding:5px;margin-bottom:5px;border:1px dotted gray}\n"] }]
+        }], propDecorators: { fieldComponent: [{
+                type: ViewChild,
+                args: ['fieldComponent', { read: ViewContainerRef }]
+            }] } });
+
+/*
+
+DON'T FORGET
+...
+ FormlyModule.forRoot({
+      types: [
+        { name: 'repeat', component: RepeatTypeComponent },
+      ],
+    }),
+...
+
+*/
+class RepeatTypeComponent extends FieldArrayType {
+    get labelTemplate() {
+        // @ts-ignore
+        return this.field.fieldArray.templateOptions.label; // TODO QUICK_FIX
+    }
+    constructor(builder) {
+        // TODO QUICK_FIX
+        // @ts-ignore
+        super(builder);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: RepeatTypeComponent, deps: [{ token: i1.FormlyFormBuilder }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.0.6", type: RepeatTypeComponent, isStandalone: false, selector: "formly-repeat-section", usesInheritance: true, ngImport: i0, template: `
+    <div *ngIf="field.fieldGroup && field.fieldGroup.length === 0">
+      Press button to add new element...
+    </div>
+    <div
+      *ngFor="let field of field.fieldGroup; let i = index"
+      class="taon-formly-array">
+      <formly-group
+        [model]="model[i]"
+        [field]="field"
+        [options]="options"
+        [form]="formControl">
+        <div>
+          <button
+            class="btn btn-danger"
+            type="button"
+            (click)="remove(i)">
+            Remove
+          </button>
+        </div>
+      </formly-group>
+    </div>
+    <div>
+      <button
+        class="btn btn-primary"
+        type="button"
+        (click)="add()">
+        {{ labelTemplate }}
+      </button>
+    </div>
+  `, isInline: true, styles: [":host{display:block;padding:5px;margin-bottom:5px;border:1px solid gray}formly-group{display:block;border:1px dashed gray;margin-bottom:5px;padding:5px}.taon-formly-array{padding:5px;background:#fff}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: RepeatTypeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'formly-repeat-section', standalone: false, template: `
+    <div *ngIf="field.fieldGroup && field.fieldGroup.length === 0">
+      Press button to add new element...
+    </div>
+    <div
+      *ngFor="let field of field.fieldGroup; let i = index"
+      class="taon-formly-array">
+      <formly-group
+        [model]="model[i]"
+        [field]="field"
+        [options]="options"
+        [form]="formControl">
+        <div>
+          <button
+            class="btn btn-danger"
+            type="button"
+            (click)="remove(i)">
+            Remove
+          </button>
+        </div>
+      </formly-group>
+    </div>
+    <div>
+      <button
+        class="btn btn-primary"
+        type="button"
+        (click)="add()">
+        {{ labelTemplate }}
+      </button>
+    </div>
+  `, styles: [":host{display:block;padding:5px;margin-bottom:5px;border:1px solid gray}formly-group{display:block;border:1px dashed gray;margin-bottom:5px;padding:5px}.taon-formly-array{padding:5px;background:#fff}\n"] }]
+        }], ctorParameters: () => [{ type: i1.FormlyFormBuilder }] });
+
+function findTypeForEntity(entity, isArray = false) {
+    if (!_.isArray(RegisterComponentType.prototype.types)) {
+        RegisterComponentType.prototype.types = [];
+    }
+    return getRegisteredComponents().find(c => c.entity === entity && c.isArray === isArray);
+}
+function typeFromEntity(component, entity) {
+    const isArray = _.isArray(entity);
+    if (isArray) {
+        entity = _.first(entity);
+    }
+    let name = ClassHelpers.getName(component);
+    let res = { name, component, entity, isArray };
+    // console.log(res);
+    return res;
+}
+function typeFromName(component, name) {
+    let res = { name, component };
+    return res;
+}
+function RegisterComponentTypeForEntity(entity) {
+    if (!_.isArray(RegisterComponentType.prototype.types)) {
+        RegisterComponentType.prototype.types = [];
+    }
+    return function (target, propertyKey, descriptor) {
+        RegisterComponentType.prototype.types.push(typeFromEntity(target, entity));
+    };
+}
+function RegisterComponentType(className, ...optionslNames) {
+    if (!_.isArray(RegisterComponentType.prototype.types)) {
+        RegisterComponentType.prototype.types = [];
+    }
+    return function (target, propertyKey, descriptor) {
+        ClassHelpers.setName(target, className);
+        RegisterComponentType.prototype.types.push(typeFromEntity(target));
+        optionslNames.forEach(name => {
+            RegisterComponentType.prototype.types.push(typeFromName(target, name));
+        });
+    };
+}
+// RegisterComponentType.prototype.types = []
+function getRegisteredComponents() {
+    let registered = RegisterComponentType.prototype.types;
+    if (!Array.isArray(registered)) {
+        return [];
+    }
+    // console.log(registered)
+    return registered;
+}
+
+function getFromlyConfigFor(target, options = {}) {
+    const { formType = 'material', keysPathesToExclude = [], keysPathesToInclude = [], parentModel, relativePath = '', level = 0, maxLevel = 4, } = options;
+    if (level === maxLevel) {
+        return [];
+    }
+    const mapping = Mapping.getModelsMapping(target);
+    // console.log('mapping', mapping)
+    const fieldNames = CLASS.describeProperites(target);
+    const checkExclude = _.isArray(keysPathesToExclude) && keysPathesToExclude.length > 0;
+    const checkInclude = _.isArray(keysPathesToInclude) && keysPathesToInclude.length > 0;
+    if (checkExclude && checkInclude) {
+        throw new Error(`In Taon function getFromlyConfigFor(...) please use keysPathesToInclude or keysPathesToExclude, `);
+    }
+    // if (checkInclude) {
+    //   console.log('check include', keysPathesToExclude)
+    // }
+    // if (checkExclude) {
+    //   console.log('check exclude', keysPathesToExclude)
+    // }
+    let fields = [];
+    //#region input to push
+    function inputToPush(key, type, model, inptToPushOptions) {
+        const { targetChild, selectOptions } = inptToPushOptions || {};
+        // console.log(`key(${key}) type: ${type} | model: ${model} targetChild: ${targetChild && targetChild.name}`)
+        let res;
+        if (type === 'repeat') {
+            const fieldGroup = getFromlyConfigFor(targetChild, {
+                formType,
+                keysPathesToInclude,
+                keysPathesToExclude,
+                relativePath: `${relativePath}.${key}`,
+                level: level + 1,
+                maxLevel,
+            });
+            if (fieldGroup.length > 0) {
+                res = {
+                    key,
+                    type,
+                    defaultValue: [],
+                    fieldArray: {
+                        fieldGroupClassName: 'row',
+                        templateOptions: {
+                            label: `Add new ${_.startCase(key)}`,
+                        },
+                        fieldGroup,
+                    },
+                };
+            }
+        }
+        else if (type === 'group') {
+            const fieldGroup = getFromlyConfigFor(targetChild, {
+                formType,
+                keysPathesToInclude,
+                keysPathesToExclude,
+                parentModel: model,
+                relativePath: `${relativePath}.${key}`,
+                level: level + 1,
+                maxLevel,
+            });
+            if (fieldGroup.length > 0) {
+                res = {
+                    fieldGroupClassName: 'row',
+                    templateOptions: {
+                        label: `${_.startCase(key)}`,
+                    },
+                    wrappers: ['groupwrap'],
+                    fieldGroup,
+                };
+            }
+        }
+        else {
+            res = {
+                key,
+                model,
+                type,
+                defaultValue: !_.isUndefined(target.prototype[key])
+                    ? target.prototype[key]
+                    : undefined,
+                templateOptions: {
+                    label: _.isString(model)
+                        ? `${model
+                            .split('.')
+                            .map(l => _.startCase(l))
+                            .join(' / ')} / ${_.startCase(key)}`
+                        : _.startCase(key),
+                    options: selectOptions,
+                },
+            };
+        }
+        if (res) {
+            Object.keys(res).forEach(key => res[key] === undefined ? delete res[key] : '');
+        }
+        return res;
+    }
+    //#endregion
+    //#region is allowed path
+    function isAlowedPath(key) {
+        let isAlowed = true;
+        const matchPath = relativePath === '' ? key : `${relativePath}:${key}`;
+        if (checkExclude) {
+            if (keysPathesToExclude.includes(matchPath)) {
+                // console.log(`Not allowed key: ${key}`)
+                isAlowed = false;
+            }
+            else {
+                isAlowed = true;
+            }
+        }
+        else if (checkInclude) {
+            if (keysPathesToInclude.includes(matchPath)) {
+                // console.log(`Allowed key: ${key}`)
+                isAlowed = true;
+            }
+            else {
+                isAlowed = false;
+            }
+        }
+        // console.log(`Is allowed;${matchPath} `, isAlowed)
+        return isAlowed;
+    }
+    //#endregion
+    const simpleResolved = [];
+    //#region resolve simple types
+    function resolveSimpleTypes() {
+        for (const key in target.prototype) {
+            if (target.prototype.hasOwnProperty(key) &&
+                !_.isFunction(target.prototype[key])) {
+                if (!isAlowedPath(key)) {
+                    continue;
+                }
+                if (!_.isUndefined(mapping[key])) {
+                    continue;
+                }
+                const element = target.prototype[key];
+                let type = 'input';
+                if (_.isBoolean(element)) {
+                    type = 'switch';
+                }
+                else if (_.isDate(element)) {
+                    type = 'datepicker';
+                }
+                else if (_.isFunction(target['getOptionsFor'])) {
+                    var selectOptions = target['getOptionsFor'](key);
+                    if (!_.isUndefined(selectOptions)) {
+                        type = 'select';
+                    }
+                }
+                else if (_.isFunction(target.prototype?.getOptionsFor)) {
+                    var selectOptions = target.prototype?.getOptionsFor(key);
+                    if (!_.isUndefined(selectOptions)) {
+                        type = 'select';
+                    }
+                }
+                fields.push(inputToPush(key, type, parentModel, { selectOptions }));
+                simpleResolved.push(key);
+            }
+        }
+    }
+    //#endregion
+    //#region resolve complex types
+    function resolveComplexTypes() {
+        fieldNames
+            .filter(key => !simpleResolved.includes(key))
+            .forEach(key => {
+            if (isAlowedPath(key) && !_.isUndefined(mapping[key])) {
+                let className = mapping[key];
+                const isArray = _.isArray(className);
+                className = isArray ? _.first(className) : className;
+                if (className === 'Date') {
+                    fields.push(inputToPush(key, 'datepicker', parentModel));
+                }
+                else {
+                    const targetChild = CLASS.getBy(className);
+                    if (targetChild) {
+                        const ftype = findTypeForEntity(targetChild, isArray);
+                        if (ftype) {
+                            fields = fields.concat(inputToPush(key, ftype.name, key));
+                        }
+                        else {
+                            if (isArray) {
+                                fields = fields.concat(inputToPush(key, 'repeat', key, { targetChild }));
+                            }
+                            else {
+                                fields = fields.concat(inputToPush(key, 'group', key, { targetChild }));
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    }
+    //#endregion
+    function generate() {
+        resolveSimpleTypes();
+        // console.log('after simple', fields);
+        resolveComplexTypes();
+        // console.log('after complext', fields);
+    }
+    generate();
+    return fields.filter(f => !!f);
+}
+
+/**
+ * 100 default characters varchar
+ */
+const StringColumn = (defaultValue = null, length = 100) => Column({
+    type: 'varchar',
+    length,
+    nullable: _.isNil(defaultValue),
+    default: defaultValue,
+});
+/**
+ * 100 characters varchar
+ */
+const String100Column = (defaultValue = null) => Column({
+    type: 'varchar',
+    length: 100,
+    nullable: _.isNil(defaultValue),
+    default: defaultValue,
+});
+/**
+ * 100 characters varchar
+ */
+const String45Column = (defaultValue = null) => Column({
+    type: 'varchar',
+    length: 45,
+    nullable: _.isNil(defaultValue),
+    default: defaultValue,
+});
+/**
+ * 500 characters varchar
+ */
+const String500Column = (defaultValue = null) => Column({
+    type: 'varchar',
+    length: 500,
+    nullable: _.isNil(defaultValue),
+    default: defaultValue,
+});
+/**
+ * 200 characters varchar
+ */
+const String200Column = (defaultValue = null) => Column({
+    type: 'varchar',
+    length: 200,
+    nullable: _.isNil(defaultValue),
+    default: defaultValue,
+});
+const NumberColumn = () => Column({ type: 'int', nullable: true });
+const DecimalNumberColumn = () => Column({ type: 'float', nullable: true });
+const SimpleJsonColumn = () => Column({ type: 'simple-json', nullable: true });
+const BooleanColumn = (defaultValue) => Column({ type: 'boolean', nullable: true, default: defaultValue });
+const DateTImeColumn = (defaultValue = null) => Column({ type: 'datetime', nullable: true, default: defaultValue });
 
 /**
  * Entity decorator
@@ -7351,26 +7990,6 @@ function TaonProvider(options) {
 class TaonProviderOptions extends DecoratorAbstractOpt {
 }
 
-var Http;
-(function (Http) {
-    Http.GET = GET;
-    Http.POST = POST;
-    Http.PUT = PUT;
-    Http.DELETE = DELETE;
-    Http.PATCH = PATCH;
-    Http.HEAD = HEAD;
-    Http.HTML = HTML;
-    Http.Response = Models$1.HttpResponse;
-    let Param;
-    (function (Param) {
-        Param.Query = Query;
-        Param.Path = Path;
-        Param.Body = Body;
-        Param.Cookie = Cookie;
-        Param.Header = Header;
-    })(Param = Http.Param || (Http.Param = {}));
-})(Http || (Http = {}));
-
 // TODO export all things
 var Taon;
 (function (Taon) {
@@ -7384,17 +8003,16 @@ var Taon;
             return opt;
         };
     };
-    Taon.Http = Http;
-    Taon.Base = Base;
     Taon.getResponseValue = getResponseValue;
     //#region class decorators
-    Taon.Controller = TaonController;
-    Taon.Entity = TaonEntity;
-    Taon.Provider = TaonProvider;
-    Taon.Repository = TaonRepository;
-    Taon.Subscriber = TaonSubscriber;
-    Taon.Migration = TaonMigration;
-    Taon.Middleware = TaonMiddleware;
+    // TODO new 5.8 typescript is not allowing this
+    // export import Controller = controllerDecorator.TaonController;
+    // export import Entity = entityDecorator.TaonEntity;
+    // export import Provider = providerDecorator.TaonProvider;
+    // export import Repository = repositoryDecorator.TaonRepository;
+    // export import Subscriber = subscriberDecorator.TaonSubscriber;
+    // export import Migration = migrationDecorator.TaonMigration;
+    // export import Middleware = middlewareDecorator.TaonMiddleware;
     //#endregion
     //#region aliases to helpers
     Taon.isBrowser = coreHelpers.Helpers.isBrowser;
@@ -7431,10 +8049,107 @@ var Taon;
         return context;
     };
 })(Taon || (Taon = {}));
+//#region taon flattening map
+const TAON_FLATTEN_MAPPING = {
+    'taon/src': {
+        // =====================
+        // Taon.Http.*
+        // =====================
+        'Taon.Http.GET': 'GET',
+        'Taon.Http.POST': 'POST',
+        'Taon.Http.PUT': 'PUT',
+        'Taon.Http.DELETE': 'DELETE',
+        'Taon.Http.PATCH': 'PATCH',
+        'Taon.Http.HEAD': 'HEAD',
+        'Taon.Http.HTML': 'HTML',
+        'Taon.Http.Response': 'HttpResponse',
+        'Taon.Http.Param.Query': 'Query',
+        'Taon.Http.Param.Path': 'Path',
+        'Taon.Http.Param.Body': 'Body',
+        'Taon.Http.Param.Cookie': 'Cookie',
+        'Taon.Http.Param.Header': 'Header',
+        // =====================
+        // Taon.Base.*
+        // =====================
+        'Taon.Base.Controller': 'TaonBaseController',
+        'Taon.Base.CrudController': 'TaonBaseCrudController',
+        'Taon.Base.Entity': 'TaonBaseEntity',
+        'Taon.Base.AbstractEntity': 'TaonBaseAbstractEntity',
+        'Taon.Base.AbstractEntityOmitKeys': 'AbstractEntityOmitKeys',
+        'Taon.Base.Provider': 'TaonBaseProvider',
+        'Taon.Base.Class': 'TaonBaseClass',
+        'Taon.Base.Repository': 'TaonBaseRepository',
+        'Taon.Base.CustomRepository': 'TaonBaseCustomRepository',
+        'Taon.Base.SubscriberForEntity': 'TaonBaseSubscriberForEntity',
+        'Taon.Base.Migration': 'TaonBaseMigration',
+        'Taon.Base.Middleware': 'TaonBaseMiddleware',
+        'Taon.Base.AngularService': 'TaonBaseAngularService',
+        'Taon.Base.Context': 'TaonBaseContext',
+        // =====================
+        // Taon.Controller.* (decorators)
+        // =====================
+        'Taon.Controller': 'TaonController',
+        'Taon.Entity': 'TaonEntity',
+        'Taon.Provider': 'TaonProvider',
+        'Taon.Repository': 'TaonRepository',
+        'Taon.Subscriber': 'TaonSubscriber',
+        'Taon.Migration': 'TaonMigration',
+        'Taon.Middleware': 'TaonMiddleware',
+        // =====================
+        // Taon.Orm.*
+        // =====================
+        'Taon.Orm.Repository': 'Repository',
+        'Taon.Orm.Connection': 'Connection',
+        // ListenEvent
+        'Taon.Orm.ListenEvent.AfterInsert': 'AfterInsert',
+        'Taon.Orm.ListenEvent.AfterLoad': 'AfterLoad',
+        'Taon.Orm.ListenEvent.AfterRecover': 'AfterRecover',
+        'Taon.Orm.ListenEvent.AfterRemove': 'AfterRemove',
+        'Taon.Orm.ListenEvent.AfterSoftRemove': 'AfterSoftRemove',
+        'Taon.Orm.ListenEvent.AfterUpdate': 'AfterUpdate',
+        'Taon.Orm.ListenEvent.BeforeInsert': 'BeforeInsert',
+        'Taon.Orm.ListenEvent.BeforeRecover': 'BeforeRecover',
+        'Taon.Orm.ListenEvent.BeforeRemove': 'BeforeRemove',
+        'Taon.Orm.ListenEvent.BeforeSoftRemove': 'BeforeSoftRemove',
+        'Taon.Orm.ListenEvent.BeforeUpdate': 'BeforeUpdate',
+        // Tree
+        'Taon.Orm.Tree.Children': 'TreeChildren',
+        'Taon.Orm.Tree.Parent': 'TreeParent',
+        // Column
+        'Taon.Orm.Column.Generated': 'Generated',
+        'Taon.Orm.Column.Primary': 'PrimaryColumn',
+        'Taon.Orm.Column.Index': 'Index',
+        'Taon.Orm.Column.CreateDate': 'CreateDateColumn',
+        'Taon.Orm.Column.UpdateDate': 'UpdateDateColumn',
+        'Taon.Orm.Column.DeleteDate': 'DeleteDateColumn',
+        'Taon.Orm.Column.Custom': 'Column',
+        'Taon.Orm.Column.String': 'StringColumn',
+        'Taon.Orm.Column.String100': 'String100Column',
+        'Taon.Orm.Column.String45': 'String45Column',
+        'Taon.Orm.Column.String500': 'String500Column',
+        'Taon.Orm.Column.String200': 'String200Column',
+        'Taon.Orm.Column.Number': 'NumberColumn',
+        'Taon.Orm.Column.DecimalNumber': 'DecimalNumberColumn',
+        'Taon.Orm.Column.SimpleJson': 'SimpleJsonColumn',
+        'Taon.Orm.Column.Boolean': 'BooleanColumn',
+        'Taon.Orm.Column.DateTIme': 'DateTimeColumn',
+        'Taon.Orm.Column.Version': 'VersionColumn',
+        'Taon.Orm.Column.Virtual': 'VirtualColumn',
+        // Join
+        'Taon.Orm.Join.Table': 'JoinTable',
+        'Taon.Orm.Join.Column': 'JoinColumn',
+        // Relation
+        'Taon.Orm.Relation.OneToMany': 'OneToMany',
+        'Taon.Orm.Relation.OneToOne': 'OneToOne',
+        'Taon.Orm.Relation.ManyToMany': 'ManyToMany',
+        'Taon.Orm.Relation.ManyToOne': 'ManyToOne',
+    },
+};
+//#endregion
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { BaseTaonClassesNames, CURRENT_HOST_BACKEND_PORT, CURRENT_HOST_URL, ClassHelpers, ContextsEndpointStorage, EndpointContext, Models, TAON_CONTEXT, Taon, TaonAdminService, TaonBaseClass, TaonBaseContext, TaonBaseController, TaonBaseCustomRepository, TaonBaseEntity, TaonBaseFileUploadMiddleware, TaonBaseMigration, TaonBaseProvider, TaonBaseRepository, TaonEntityKeysToOmitArr, TaonTempDatabasesFolder, TaonTempRoutesFolder, apiPrefix, createContext, inject };
+export { BaseTaonClassesNames, Body, BooleanColumn, CURRENT_HOST_BACKEND_PORT, CURRENT_HOST_URL, ClassHelpers, ContextDbMigrations, ContextsEndpointStorage, ControllerConfig, Cookie, DELETE, DITaonContainer, DateTImeColumn, DecimalNumberColumn, DecoratorAbstractOpt, EndpointContext, EntityProcess, FormlyHorizontalWrapper, GET, HEAD, HTML, Header, MethodConfig, MockNamespaceIpc, MockServerIpc, MockSocketIpc, Models, NumberColumn, PATCH, POST, PUT, ParamConfig, Path, Query, RealtimeClient, RealtimeCore, RealtimeServer, RealtimeStrategy, RealtimeStrategyIpc, RealtimeStrategyMock, RealtimeStrategySocketIO, RealtimeSubsManager, RegisterComponentType, RegisterComponentTypeForEntity, RepeatTypeComponent, SimpleJsonColumn, String100Column, String200Column, String45Column, String500Column, StringColumn, Symbols, TAON_CONTEXT, TAON_FLATTEN_MAPPING, Taon, TaonAdminService, TaonBaseAbstractEntity, TaonBaseAngularService, TaonBaseClass, TaonBaseContext, TaonBaseController, TaonBaseCrudController, TaonBaseCustomRepository, TaonBaseEntity, TaonBaseFileUploadMiddleware, TaonBaseInjector, TaonBaseMiddleware, TaonBaseMigration, TaonBaseProvider, TaonBaseRepository, TaonBaseSubscriberForEntity, TaonController, TaonControllerOptions, TaonEntity, TaonEntityKeysToOmitArr, TaonEntityOptions, TaonHelpers, TaonMiddleware, TaonMiddlewareOptions, TaonMigration, TaonMigrationOptions, TaonProvider, TaonProviderOptions, TaonRepository, TaonRepositoryOptions, TaonRestResponseWrapper, TaonSubscriber, TaonSubscriberOptions, TaonTempDatabasesFolder, TaonTempRoutesFolder, Validators, apiPrefix, cloneObj, controllerConfigFrom, createContext, createContextTemplate, findTypeForEntity, getFromlyConfigFor, getRegisteredComponents, getResponseValue, getTransformFunction, inject, singleTransform, typeFromEntity, typeFromName };
 //# sourceMappingURL=taon.mjs.map