taon 21.0.3 → 21.0.9

package/websql/fesm2022/{taon.mjs → taon-websql.mjs}

@@ -1,126 +1,140 @@
 import 'reflect-metadata';
 import * as coreHelpers from 'tnp-core/websql';
 import { _, Utils, UtilsMigrations, Helpers, UtilsOs, crossPlatformPath, config, CoreModels, UtilsTerminal } from 'tnp-core/websql';
-import { __decorate, __metadata, __param } from 'tslib';
-import * as tsorm from 'taon-typeorm/websql';
-import { OrignalClassKey, Entity, Table, TableIndex, EventSubscriber, DataSource } from 'taon-typeorm/websql';
-import { SYMBOL, CLASS } from 'typescript-class-helpers/websql';
-import { walk } from 'lodash-walk-object/websql';
-import * as i0 from '@angular/core';
-import { InjectionToken, inject as inject$1, Injectable } from '@angular/core';
 import axios from 'axios';
 import { JSON10 } from 'json10/websql';
+import { walk } from 'lodash-walk-object/websql';
 import { RestResponseWrapper, Models as Models$1, Resource, RestHeaders, Mapping, HttpResponseError } from 'ng2-rest/websql';
 import { Observable, Subject, from } from 'rxjs';
+import { OrignalClassKey, Table, TableIndex, EventSubscriber, Entity, DataSource, Column, PrimaryGeneratedColumn, VersionColumn } from 'taon-typeorm/websql';
+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/websql';
+import * as i0 from '@angular/core';
+import { InjectionToken, inject as inject$1, Injectable, ViewContainerRef, ViewChild, Component } from '@angular/core';
+import { SYMBOL, CLASS } from 'typescript-class-helpers/websql';
 import * as JSON5 from 'json5';
 import { io } from 'socket.io-client';
+import { __decorate, __metadata, __param } from 'tslib';
 import { MySqlQuerySource } from 'taon-type-sql/websql';
+import * as i1 from '@ngx-formly/core';
+import { FieldWrapper, FieldArrayType } from '@ngx-formly/core';
 
-//#region @websql
-//#region orm
-var Orm;
-(function (Orm) {
-    //#region @websql
-    Orm.Repository = tsorm.Repository;
-    Orm.Connection = tsorm.Connection;
-    let ListenEvent;
-    (function (ListenEvent) {
-        ListenEvent.AfterInsert = tsorm.AfterInsert;
-        ListenEvent.AfterLoad = tsorm.AfterLoad;
-        ListenEvent.AfterRecover = tsorm.AfterRecover;
-        ListenEvent.AfterRemove = tsorm.AfterRemove;
-        ListenEvent.AfterSoftRemove = tsorm.AfterSoftRemove;
-        ListenEvent.AfterUpdate = tsorm.AfterUpdate;
-        ListenEvent.BeforeInsert = tsorm.BeforeInsert;
-        ListenEvent.BeforeRecover = tsorm.BeforeRecover;
-        ListenEvent.BeforeRemove = tsorm.BeforeRemove;
-        ListenEvent.BeforeSoftRemove = tsorm.BeforeSoftRemove;
-        ListenEvent.BeforeUpdate = tsorm.BeforeUpdate;
-    })(ListenEvent = Orm.ListenEvent || (Orm.ListenEvent = {}));
-    let Tree;
-    (function (Tree) {
-        Tree.Children = tsorm.TreeChildren;
-        Tree.Parent = tsorm.TreeParent;
-    })(Tree = Orm.Tree || (Orm.Tree = {}));
-    let Column;
-    (function (Column) {
-        Column.Generated = tsorm.PrimaryGeneratedColumn;
-        Column.Primary = tsorm.PrimaryColumn;
-        Column.Index = tsorm.Index;
-        Column.CreateDate = tsorm.CreateDateColumn;
-        Column.UpdateDate = tsorm.UpdateDateColumn;
-        Column.DeleteDate = tsorm.DeleteDateColumn;
-        Column.Custom = tsorm.Column;
-        /**
-         * 100 default characters varchar
-         */
-        Column.String = (defaultValue = null, length = 100) => tsorm.Column({
-            type: 'varchar',
-            length,
-            nullable: _.isNil(defaultValue),
-            default: defaultValue,
-        });
-        /**
-         * 100 characters varchar
-         */
-        Column.String100 = (defaultValue = null) => tsorm.Column({
-            type: 'varchar',
-            length: 100,
-            nullable: _.isNil(defaultValue),
-            default: defaultValue,
-        });
-        /**
-         * 100 characters varchar
-         */
-        Column.String45 = (defaultValue = null) => tsorm.Column({
-            type: 'varchar',
-            length: 45,
-            nullable: _.isNil(defaultValue),
-            default: defaultValue,
-        });
-        /**
-         * 500 characters varchar
-         */
-        Column.String500 = (defaultValue = null) => tsorm.Column({
-            type: 'varchar',
-            length: 500,
-            nullable: _.isNil(defaultValue),
-            default: defaultValue,
-        });
-        /**
-         * 200 characters varchar
-         */
-        Column.String200 = (defaultValue = null) => tsorm.Column({
-            type: 'varchar',
-            length: 200,
-            nullable: _.isNil(defaultValue),
-            default: defaultValue,
-        });
-        Column.Number = () => tsorm.Column({ type: 'int', nullable: true });
-        Column.DecimalNumber = () => tsorm.Column({ type: 'float', nullable: true });
-        Column.SimpleJson = () => tsorm.Column({ type: 'simple-json', nullable: true });
-        Column.Boolean = (defaultValue) => tsorm.Column({ type: 'boolean', nullable: true, default: defaultValue });
-        Column.DateTIme = (defaultValue = null) => tsorm.Column({ type: 'datetime', nullable: true, default: defaultValue });
-        // TODO has limitation => comma in name
-        // export const SimpleArray = () => tsorm.Column({ type: 'simple-array', nullable: true });
-        Column.Version = tsorm.VersionColumn;
-        Column.Virtual = tsorm.VirtualColumn;
-    })(Column = Orm.Column || (Orm.Column = {}));
-    let Join;
-    (function (Join) {
-        Join.Table = tsorm.JoinTable;
-        Join.Column = tsorm.JoinColumn;
-    })(Join = Orm.Join || (Orm.Join = {}));
-    let Relation;
-    (function (Relation) {
-        Relation.OneToMany = tsorm.OneToMany;
-        Relation.OneToOne = tsorm.OneToOne;
-        Relation.ManyToMany = tsorm.ManyToMany;
-        Relation.ManyToOne = tsorm.ManyToOne;
-    })(Relation = Orm.Relation || (Orm.Relation = {}));
-    //#endregion
-})(Orm || (Orm = {}));
+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';
+
+// ! TODO make it as a nice way to wrap normal request
+class TaonRestResponseWrapper extends RestResponseWrapper {
+}
+const BaseTaonClassesNames = [
+    'BaseCrudController',
+    'BaseController',
+    'BaseAbstractEntity',
+    'BaseEntity',
+    'BaseContext',
+    'BaseCustomRepository',
+    'BaseFileUploadMiddleware',
+    'BaseMiddleware',
+    'BaseClass',
+    'BaseInjector',
+    'BaseMigration',
+    'BaseProvider',
+    'BaseRepository',
+    'BaseSubscriberForEntity',
+    'BaseCliWorkerController',
+    'PortsController',
+    'PortsContext',
+];
+const TaonTempDatabasesFolder = 'databases';
+const TaonTempRoutesFolder = 'routes';
+var Models;
+(function (Models) {
+    Models.DatabasesFolder = TaonTempDatabasesFolder;
+    //#region models / class types
+    let ClassType;
+    (function (ClassType) {
+        ClassType["ENTITY"] = "ENTITY";
+        ClassType["CONTROLLER"] = "CONTROLLER";
+        ClassType["REPOSITORY"] = "REPOSITORY";
+        ClassType["PROVIDER"] = "PROVIDER";
+        ClassType["SUBSCRIBER"] = "SUBSCRIBER";
+        ClassType["MIGRATION"] = "MIGRATION";
+        ClassType["MIDDLEWARE"] = "MIDDLEWARE";
+    })(ClassType = Models.ClassType || (Models.ClassType = {}));
+    Models.ClassTypeKey = {
+        [ClassType.ENTITY]: 'entities',
+        [ClassType.CONTROLLER]: 'controllers',
+        [ClassType.REPOSITORY]: 'repositories',
+        [ClassType.PROVIDER]: 'providers',
+        [ClassType.SUBSCRIBER]: 'subscribers',
+        [ClassType.MIGRATION]: 'migrations',
+        [ClassType.MIDDLEWARE]: 'middlewares',
+    };
+    //#endregion
+    //#region models / database connection options
+    class DatabaseConfigTypeOrm {
+    }
+    Models.DatabaseConfigTypeOrm = DatabaseConfigTypeOrm;
+    //#endregion
+    //#region models / database config
+    class DatabaseConfig extends DatabaseConfigTypeOrm {
+        static from(databasePartialConfig) {
+            return _.merge(new DatabaseConfig(), databasePartialConfig);
+        }
+        get databaseConfigTypeORM() {
+            //#region @websqlFunc
+            const result = _.cloneDeep(this);
+            if (result.recreateMode) {
+                if (result.recreateMode === 'DROP_DB+MIGRATIONS') {
+                    result.synchronize = true;
+                    result.dropSchema = true;
+                }
+                else if (result.recreateMode === 'PRESERVE_DATA+MIGRATIONS') {
+                    result.synchronize = false;
+                    result.dropSchema = false;
+                }
+            }
+            delete result.recreateMode;
+            return result;
+            //#endregion
+        }
+    }
+    Models.DatabaseConfig = DatabaseConfig;
+    //#endregion
+    //#region models / http
+    let Http;
+    (function (Http) {
+        Http.Rest = Models$1;
+        //#endregion
+    })(Http = Models.Http || (Models.Http = {}));
+    //#endregion
+})(Models || (Models = {}));
 
 class DecoratorAbstractOpt {
 }
@@ -156,6 +170,68 @@ const controllerConfigFrom = (partial) => {
     return newObj;
 };
 
+/**
+ * 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 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`;
+    }
+    //#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`;
+    }
+}
 var Symbols;
 (function (Symbols) {
     Symbols.ctxInClassOrClassObj = Symbol();
@@ -164,68 +240,6 @@ var Symbols;
     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`;
-        }
-        //#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`;
-        }
-        //#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`,
@@ -501,437 +515,73 @@ var ClassHelpers;
             .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,
-                    };
-                }
-            }
-            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;
-};
-
-//#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);
-    }
-}
-
-let EntityDecorator$1 = () => {
-    return (target) => { };
-};
-//#region @websql
-EntityDecorator$1 = Entity;
-//#endregion
-let TaonBaseEntity = class TaonBaseEntity extends TaonBaseClass {
-    /**
-     * simple check if relation is ok
-     */
-    relation(relationName) {
-        return relationName;
-    }
-    /**
-     * simple check if relation is ok
-     */
-    relations(relationNames) {
-        return relationNames;
-    }
-};
-TaonBaseEntity = __decorate([
-    EntityDecorator$1()
-], TaonBaseEntity);
-
-// empty decorator
-let EntityDecorator = () => {
-    return (target) => { };
-};
-//#region @websql
-EntityDecorator = Entity;
-//#endregion
-let TaonBaseAbstractEntity = class TaonBaseAbstractEntity extends TaonBaseEntity {
-};
-__decorate([
-    Orm.Column.Generated()
-    //#endregion
-    ,
-    __metadata("design:type", String)
-], TaonBaseAbstractEntity.prototype, "id", void 0);
-__decorate([
-    Orm.Column.Version()
-    //#endregion
-    ,
-    __metadata("design:type", Number)
-], TaonBaseAbstractEntity.prototype, "version", void 0);
-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
-    }
-    /**
-     * @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: "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: () => [] });
-
-// ! TODO make it as a nice way to wrap normal request
-class TaonRestResponseWrapper extends RestResponseWrapper {
-}
-const BaseTaonClassesNames = [
-    'BaseCrudController',
-    'BaseController',
-    'BaseAbstractEntity',
-    'BaseEntity',
-    'BaseContext',
-    'BaseCustomRepository',
-    'BaseFileUploadMiddleware',
-    'BaseMiddleware',
-    'BaseClass',
-    'BaseInjector',
-    'BaseMigration',
-    'BaseProvider',
-    'BaseRepository',
-    'BaseSubscriberForEntity',
-    'BaseCliWorkerController',
-    'PortsController',
-    'PortsContext',
-];
-const TaonTempDatabasesFolder = 'databases';
-const TaonTempRoutesFolder = 'routes';
-var Models;
-(function (Models) {
-    Models.DatabasesFolder = TaonTempDatabasesFolder;
-    //#region models / class types
-    let ClassType;
-    (function (ClassType) {
-        ClassType["ENTITY"] = "ENTITY";
-        ClassType["CONTROLLER"] = "CONTROLLER";
-        ClassType["REPOSITORY"] = "REPOSITORY";
-        ClassType["PROVIDER"] = "PROVIDER";
-        ClassType["SUBSCRIBER"] = "SUBSCRIBER";
-        ClassType["MIGRATION"] = "MIGRATION";
-        ClassType["MIDDLEWARE"] = "MIDDLEWARE";
-    })(ClassType = Models.ClassType || (Models.ClassType = {}));
-    Models.ClassTypeKey = {
-        [ClassType.ENTITY]: 'entities',
-        [ClassType.CONTROLLER]: 'controllers',
-        [ClassType.REPOSITORY]: 'repositories',
-        [ClassType.PROVIDER]: 'providers',
-        [ClassType.SUBSCRIBER]: 'subscribers',
-        [ClassType.MIGRATION]: 'migrations',
-        [ClassType.MIDDLEWARE]: 'middlewares',
+            classFun?.constructor?.name === 'Object') {
+            return Utils.uniqArray(allMethodsNames);
+        }
+        return ClassHelpers.getMethodsNames(Object.getPrototypeOf(classFun), allMethodsNames);
     };
     //#endregion
-    //#region models / database connection options
-    class DatabaseConfigTypeOrm {
-    }
-    Models.DatabaseConfigTypeOrm = DatabaseConfigTypeOrm;
-    //#endregion
-    //#region models / database config
-    class DatabaseConfig extends DatabaseConfigTypeOrm {
-        static from(databasePartialConfig) {
-            return _.merge(new DatabaseConfig(), databasePartialConfig);
+    //#region get controller configs
+    ClassHelpers.getControllerConfigs = (target, configs = [], callerTarget) => {
+        if (!_.isFunction(target)) {
+            throw `[typescript-class-helper][getControllerConfigs] Cannot get class config from: ${target}`;
         }
-        get databaseConfigTypeORM() {
-            //#region @websqlFunc
-            const result = _.cloneDeep(this);
-            if (result.recreateMode) {
-                if (result.recreateMode === 'DROP_DB+MIGRATIONS') {
-                    result.synchronize = true;
-                    result.dropSchema = true;
-                }
-                else if (result.recreateMode === 'PRESERVE_DATA+MIGRATIONS') {
-                    result.synchronize = false;
-                    result.dropSchema = false;
+        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,
+                    };
                 }
             }
-            delete result.recreateMode;
-            return result;
-            //#endregion
+            Reflect.defineMetadata(Symbols.metadata.options.controller, cfg, target);
         }
-    }
-    Models.DatabaseConfig = DatabaseConfig;
-    //#endregion
-    //#region models / http
-    let Http;
-    (function (Http) {
-        Http.Rest = Models$1;
-        //#endregion
-    })(Http = Models.Http || (Models.Http = {}));
+        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
-})(Models || (Models = {}));
+})(ClassHelpers || (ClassHelpers = {}));
 
 //#region imports
 class ContextDbMigrations {
@@ -5381,11 +5031,575 @@ const createContextFn = (configFn, cloneOptions) => {
     return res;
 };
 //#endregion
-const createContext = (configFn) => {
-    return createContextFn(configFn, { useAsRemoteContext: false });
+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);
+        }
+    }
+}
+
+/**
+ * 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 });
+
+// TODO new 5.8 typescript is not allowing this
+// export namespace Orm {
+//   export const Repository = tsorm.Repository;
+//   export import Connection = tsorm.Connection;
+//   export namespace ListenEvent {
+//     export import AfterInsert = tsorm.AfterInsert;
+//     export import AfterLoad = tsorm.AfterLoad;
+//     export import AfterRecover = tsorm.AfterRecover;
+//     export import AfterRemove = tsorm.AfterRemove;
+//     export import AfterSoftRemove = tsorm.AfterSoftRemove;
+//     export import AfterUpdate = tsorm.AfterUpdate;
+//     export import BeforeInsert = tsorm.BeforeInsert;
+//     export import BeforeRecover = tsorm.BeforeRecover;
+//     export import BeforeRemove = tsorm.BeforeRemove;
+//     export import BeforeSoftRemove = tsorm.BeforeSoftRemove;
+//     export import BeforeUpdate = tsorm.BeforeUpdate;
+//   }
+//   export namespace Tree {
+//     export import Children = tsorm.TreeChildren;
+//     export import Parent = tsorm.TreeParent;
+//   }
+//   export namespace Column {
+//     export import Generated = tsorm.PrimaryGeneratedColumn;
+//     export import Primary = tsorm.PrimaryColumn;
+//     export import Index = tsorm.Index;
+//     export import CreateDate = tsorm.CreateDateColumn;
+//     export import UpdateDate = tsorm.UpdateDateColumn;
+//     export import DeleteDate = tsorm.DeleteDateColumn;
+//     export import Custom = tsorm.Column;
+//     export import String = additionalColumns.StringColumn;
+//     export import String100 = additionalColumns.String100Column;
+//     export import String45 = additionalColumns.String45Column;
+//     export import String500 = additionalColumns.String500Column;
+//     export import String200 = additionalColumns.String200Column;
+//     export import Number = additionalColumns.NumberColumn;
+//     export import DecimalNumber = additionalColumns.DecimalNumberColumn;
+//     export import SimpleJson = additionalColumns.SimpleJsonColumn;
+//     export import Boolean = additionalColumns.BooleanColumn;
+//     export import DateTIme = additionalColumns.DateTImeColumn;
+//     // TODO has limitation => comma in name
+//     // export const SimpleArray = () => tsorm.Column({ type: 'simple-array', nullable: true });
+//     export import Version = tsorm.VersionColumn;
+//     export import Virtual = tsorm.VirtualColumn;
+//   }
+//   export namespace Join {
+//     export import Table = tsorm.JoinTable;
+//     export import Column = tsorm.JoinColumn;
+//   }
+//   export namespace Relation {
+//     export import OneToMany = tsorm.OneToMany;
+//     export import OneToOne = tsorm.OneToOne;
+//     export import ManyToMany = tsorm.ManyToMany;
+//     export import ManyToOne = tsorm.ManyToOne;
+//   }
+// }
+
+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);
+    }
+}
+
+//#region @websql
+let TaonBaseEntity = class TaonBaseEntity extends TaonBaseClass {
+    /**
+     * simple check if relation is ok
+     */
+    relation(relationName) {
+        return relationName;
+    }
+    /**
+     * simple check if relation is ok
+     */
+    relations(relationNames) {
+        return relationNames;
+    }
 };
-// const AA = createContext(() => ({ contextName: 'aa' }));
-// const BB = AA.cloneAsRemoteContext();
+TaonBaseEntity = __decorate([
+    Entity()
+    //#endregion
+], TaonBaseEntity);
+
+//#region @websql
+let TaonBaseAbstractEntity = class TaonBaseAbstractEntity extends TaonBaseEntity {
+};
+__decorate([
+    PrimaryGeneratedColumn()
+    //#endregion
+    ,
+    __metadata("design:type", String)
+], TaonBaseAbstractEntity.prototype, "id", void 0);
+__decorate([
+    VersionColumn()
+    //#endregion
+    ,
+    __metadata("design:type", Number)
+], TaonBaseAbstractEntity.prototype, "version", void 0);
+TaonBaseAbstractEntity = __decorate([
+    Entity()
+    //#endregion
+], TaonBaseAbstractEntity);
+
+/**
+ * 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
@@ -7075,22 +7289,401 @@ 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);
+}
 
 /**
  * Entity decorator
@@ -7140,26 +7733,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) {
@@ -7173,18 +7746,16 @@ var Taon;
             return opt;
         };
     };
-    Taon.Http = Http;
-    Taon.Base = Base;
-    Taon.Orm = Orm;
     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;
@@ -7221,10 +7792,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 };
-//# sourceMappingURL=taon.mjs.map
+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-websql.mjs.map