taon 0.0.0 → 18.0.12

package/client/fesm2022/taon.mjs

@@ -0,0 +1,4901 @@
+import 'reflect-metadata';
+import * as coreHelpers from 'tnp-core/browser';
+import { _, Helpers } from 'tnp-core/browser';
+import { Models as Models$1, RestHeaders, Resource, Mapping } from 'ng2-rest/browser';
+import { OrignalClassKey } from 'taon-typeorm/browser';
+import { SYMBOL, CLASS } from 'typescript-class-helpers/browser';
+import * as JSON5 from 'json5';
+import { __decorate, __param, __metadata } from 'tslib';
+import { JSON10 } from 'json10/browser';
+import { Observable, from, Subject } from 'rxjs';
+import axios from 'axios';
+import { io } from 'socket.io-client';
+import { Stor } from 'taon-storage/browser';
+import { config } from 'tnp-config/browser';
+import * as i0 from '@angular/core';
+import { Injectable, inject as inject$1 } from '@angular/core';
+
+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 = {
+        NAMESPACE: (contextName) => `${contextName}:taonRealtimeNsp`,
+        TABLE_CHANGE(contextName, tableName) {
+            return `${contextName}:listentablename${tableName}`;
+        },
+        /**
+         * for backendSocket.in(ROOM_NAME).emit(EVENT)
+         *
+         * Room names are uniqe..
+         * here I am limiting number of event for clients.
+         */
+        ROOM_NAME: {
+            CUSTOM(contextName, customEvent) {
+                return `${contextName}:roomcustomevnet${customEvent}`;
+            },
+            /**
+             * @LAST TODO
+             */
+            SUBSCRIBER_EVENT(contextName, className, propertyName) {
+                return `${contextName}:room${_.camelCase(className)}${propertyName}`.toLowerCase();
+            },
+            UPDATE_ENTITY(contextName, className, entityId) {
+                return `${contextName}:room${_.camelCase(className)}${entityId}`.toLowerCase();
+            },
+            UPDATE_ENTITY_PROPERTY(contextName, className, property, entityId) {
+                return `${contextName}:room${_.camelCase(className)}${_.camelCase(property)}${entityId}`.toLowerCase();
+            },
+            SUBSCRIBE: {
+                CUSTOM: (contextName) => `${contextName}:roomSubscribeCustomRoomEvent`,
+                ENTITY_UPDATE_EVENTS: (contextName) => `${contextName}:roomSubscribeEntityEvents`,
+                ENTITY_PROPERTY_UPDATE_EVENTS: (contextName) => `${contextName}:roomSubscribeEntityPropertyEvents`,
+            },
+            UNSUBSCRIBE: {
+                CUSTOM: (contextName) => `${contextName}:roomUnsubscribeCustomRoomEvent`,
+                ENTITY_UPDATE_EVENTS: (contextName) => `${contextName}:roomUnsubscribeEntityEvents`,
+                ENTITY_PROPERTY_UPDATE_EVENTS: (contextName) => `${contextName}:roomUnsubscribeEntityPropertyEvents`,
+            },
+        },
+    };
+    Symbols.metadata = {
+        className: `class:realname`,
+        options: {
+            runtimeController: `runtime:controller:options`,
+            controller: `controller:options`,
+            controllerMethod: `controller:method:options`,
+            entity: `entity:options`,
+            repository: `repository:options`,
+            provider: `provider:options`,
+            subscriber: `subscriber: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 = {}));
+;
+({}); // @--end-of-file-for-module=taon lib/symbols.ts
+
+var Validators;
+(function (Validators) {
+    Validators.classNameVlidation = (className, target) => {
+        setTimeout(() => {
+            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;
+    };
+    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.
+
+        `);
+            }
+        }
+    };
+    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(...)
+
+  `;
+        }
+    };
+    Validators.preventUndefinedModel = (model, id) => {
+        if (_.isUndefined(model)) {
+            throw `Bad update by id, config, id: ${id}`;
+        }
+    };
+})(Validators || (Validators = {}));
+;
+({}); // @--end-of-file-for-module=taon lib/validators.ts
+
+var TaonHelpers;
+(function (TaonHelpers) {
+    TaonHelpers.fillUpTo = (s, nCharacters) => {
+        return _.times(nCharacters, n => {
+            if (s.charAt(n)) {
+                return s.charAt(n);
+            }
+            return ' ';
+        }).join('');
+    };
+    TaonHelpers.isGoodPath = (p) => {
+        return p && typeof p === 'string' && p.trim() !== '';
+    };
+    TaonHelpers.tryTransformParam = param => {
+        if (typeof param === 'string') {
+            let n = Number(param);
+            if (!isNaN(n))
+                return n;
+            const bool = param.trim().toLowerCase();
+            if (bool === 'true') {
+                return true;
+            }
+            if (bool === 'false') {
+                return false;
+            }
+            try {
+                const t = JSON5.parse(param);
+                return t;
+            }
+            catch (e) {
+                return param;
+            }
+        }
+        return param;
+    };
+    TaonHelpers.getExpressPath = (c, pathOrClassConfig) => {
+        if (typeof pathOrClassConfig === 'string')
+            return `${c.calculatedPath}${pathOrClassConfig}`.replace(/\/$/, '');
+        return `${c.calculatedPath}${pathOrClassConfig.path}`.replace(/\/$/, '');
+    };
+    TaonHelpers.defaultType = value => {
+        if (typeof value === 'string')
+            return '';
+        if (typeof value === 'boolean')
+            return false;
+        if (Array.isArray(value))
+            return {};
+        if (typeof value === 'object')
+            return {};
+    };
+    TaonHelpers.parseJSONwithStringJSONs = (object, waring = false) => {
+        if (!_.isObject(object)) {
+            if (waring) {
+                console.error(`
+        parseJSONwithStringJSONs(...)
+        Parameter should be a object, but is ${typeof object}
+        `, object);
+            }
+            return object;
+        }
+        let res = _.cloneDeep(object);
+        Object.keys(res).forEach(key => {
+            let isJson = false;
+            try {
+                const possibleJSON = JSON.parse(res[key]);
+                res[key] = possibleJSON;
+                isJson = true;
+            }
+            catch (e) {
+                isJson = false;
+            }
+            if (isJson) {
+                res[key] = TaonHelpers.parseJSONwithStringJSONs(res[key], false);
+            }
+        });
+        return res;
+    };
+    TaonHelpers.isPlainFileOrFolder = filePath => {
+        return /^([a-zA-Z]|\-|\_|\@|\#|\$|\!|\^|\&|\*|\(|\))+$/.test(filePath);
+    };
+    TaonHelpers.ipcKeyNameResponse = (target, methodConfig, expressPath) => {
+        return [
+            'response',
+            ClassHelpers.getName(target),
+            methodConfig.methodName,
+            methodConfig.type,
+            expressPath,
+        ].join('--');
+    };
+    TaonHelpers.ipcKeyNameRequest = (target, methodConfig, expressPath) => {
+        return [
+            'request',
+            ClassHelpers.getName(target),
+            methodConfig.methodName,
+            methodConfig.type,
+            expressPath,
+        ].join('--');
+    };
+    TaonHelpers.websqlMocks = headers => {
+        const response = {
+            status(status) {
+                return {
+                    send(send) {
+                    },
+                };
+            },
+            setHeader(key, value) {
+                headers[key] = value;
+            },
+        };
+        const request = {};
+        return { request, response };
+    };
+})(TaonHelpers || (TaonHelpers = {}));
+;
+({}); // @--end-of-file-for-module=taon lib/helpers/taon-helpers.ts
+
+/* */
+/* */
+var ClassHelpers;
+(function (ClassHelpers) {
+    /**
+     * 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;
+    };
+    ClassHelpers.getName = (classFnOrObject) => {
+        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]) ||
+            CLASS.getName(classFnOrObject));
+    };
+    ClassHelpers.getOrginalClass = (classFnOrObject) => {
+        const org = classFnOrObject[Symbols.orignalClass];
+        if (!org) {
+            return classFnOrObject;
+        }
+        return ClassHelpers.getOrginalClass(org);
+    };
+    ClassHelpers.getFullInternalName = (classFnOrObject) => {
+        if (!classFnOrObject) {
+            throw new Error(`Cannot get name from: ${classFnOrObject}`);
+        }
+        return ((classFnOrObject[Symbols.fullClassNameStaticProperty]
+            ? classFnOrObject[Symbols.fullClassNameStaticProperty]
+            : classFnOrObject?.constructor[Symbols.fullClassNameStaticProperty]) ||
+            void 0);
+    };
+    ClassHelpers.getUniquKey = (classFnOrObject) => {
+        const classFn = _.isFunction(classFnOrObject)
+            ? classFnOrObject
+            : classFnOrObject.constructor;
+        const config = Reflect.getMetadata(Symbols.metadata.options.controller, classFn);
+        return config.uniqueKeyProp;
+    };
+    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';
+    };
+    ClassHelpers.setName = (target, className) => {
+        Validators.classNameVlidation(className, target);
+        target[Symbols.classNameStaticProperty] = className;
+    };
+    ClassHelpers.hasParentClassWithName = (target, className, targets = []) => {
+        if (!target) {
+            return false;
+        }
+        targets.push(target);
+        let targetProto = Object.getPrototypeOf(target);
+        if (_.isFunction(targetProto) &&
+            ClassHelpers.getName(targetProto) === className) {
+            return true;
+        }
+        return ClassHelpers.hasParentClassWithName(targetProto, className, targets);
+    };
+    ClassHelpers.getControllerConfig = (target) => {
+        const classMetadataOptions = Reflect.getMetadata(Symbols.metadata.options.controller, target);
+        const classMetadata = _.merge(new Models.ControllerConfig(), classMetadataOptions);
+        const methodNames = ClassHelpers.getMethodsNames(target); //  Object.getOwnPropertyNames(target.prototype);
+        for (const methodName of methodNames) {
+            const methodMetadata = Reflect.getMetadata(Symbols.metadata.options.controllerMethod, target, methodName);
+            if (methodMetadata) {
+                classMetadata.methods[methodName] = methodMetadata;
+            }
+        }
+        return classMetadata;
+    };
+    const notAllowedAsMethodName = [
+        'length',
+        'name',
+        'arguments',
+        'caller',
+        'constructor',
+        'apply',
+        'bind',
+        'call',
+        'toString',
+        '__defineGetter__',
+        '__defineSetter__',
+        'hasOwnProperty',
+        '__lookupGetter__',
+        '__lookupSetter__',
+        'isPrototypeOf',
+        'propertyIsEnumerable',
+        'valueOf',
+        '__proto__',
+        'toLocaleString',
+    ];
+    ClassHelpers.getMethodsNames = (classOrClassInstance, allMethodsNames = []) => {
+        if (!classOrClassInstance) {
+            return 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 allMethodsNames;
+        }
+        return ClassHelpers.getMethodsNames(Object.getPrototypeOf(classFun), allMethodsNames);
+    };
+    ClassHelpers.getControllerConfigs = (target, configs = [], callerTarget) => {
+        if (!_.isFunction(target)) {
+            throw `[typescript-class-helper][getClassConfig] 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 = ClassHelpers.getControllerConfig(target);
+        configs.push(config);
+        return isValidParent
+            ? ClassHelpers.getControllerConfigs(parentClass, configs, target)
+            : configs;
+    };
+    ClassHelpers.getCalculatedPathFor = (target) => {
+        const configs = ClassHelpers.getControllerConfigs(target);
+        const parentscalculatedPath = _.slice(configs, 1)
+            .reverse()
+            .map(bc => {
+            if (TaonHelpers.isGoodPath(bc.path)) {
+                return bc.path;
+            }
+            return bc.className;
+        })
+            .join('/');
+        return `/${parentscalculatedPath}/${ClassHelpers.getName(target)}`;
+    };
+})(ClassHelpers || (ClassHelpers = {}));
+;
+({}); // @--end-of-file-for-module=taon lib/helpers/class-helpers.ts
+
+/* */
+/* */
+var Models;
+(function (Models) {
+    let ClassType;
+    (function (ClassType) {
+        ClassType["ENTITY"] = "ENTITY";
+        ClassType["CONTROLLER"] = "CONTROLLER";
+        ClassType["REPOSITORY"] = "REPOSITORY";
+        ClassType["PROVIDER"] = "PROVIDER";
+        ClassType["SUBSCRIBER"] = "SUBSCRIBER";
+    })(ClassType = Models.ClassType || (Models.ClassType = {}));
+    Models.ClassTypeKey = {
+        [ClassType.ENTITY]: 'entities',
+        [ClassType.CONTROLLER]: 'controllers',
+        [ClassType.REPOSITORY]: 'repositories',
+        [ClassType.PROVIDER]: 'providers',
+        [ClassType.SUBSCRIBER]: 'subscribers',
+    };
+    class DecoratorAbstractOpt {
+    }
+    Models.DecoratorAbstractOpt = DecoratorAbstractOpt;
+    class ParamConfig {
+    }
+    Models.ParamConfig = ParamConfig;
+    class MethodConfig {
+        constructor() {
+            /* */
+            /* */
+            this.parameters = {};
+        }
+    }
+    Models.MethodConfig = MethodConfig;
+    class ControllerConfig extends DecoratorAbstractOpt {
+        constructor() {
+            super(...arguments);
+            this.methods = {};
+        }
+    }
+    Models.ControllerConfig = ControllerConfig;
+    class RuntimeControllerConfig extends ControllerConfig {
+    }
+    Models.RuntimeControllerConfig = RuntimeControllerConfig;
+    let Http;
+    (function (Http) {
+        Http.Rest = Models$1;
+        class Errors {
+            constructor(message, code = 400) {
+                this.message = message;
+                this.code = code;
+                this.toString = () => {
+                    return this.message;
+                };
+            }
+            static create(message, code = 400) {
+                return new Errors(message, code);
+            }
+            static entityNotFound(entity) {
+                return Errors.create(`Entity ${ClassHelpers.getName(entity)} not found`);
+            }
+            static custom(message, code = 400) {
+                return Errors.create(message, code);
+            }
+        }
+        Http.Errors = Errors;
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+    })(Http = Models.Http || (Models.Http = {}));
+})(Models || (Models = {}));
+;
+({}); // @--end-of-file-for-module=taon lib/models.ts
+
+const metaReq = (method, path, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal) => {
+    let options;
+    if (typeof pathOrOptions === 'object') {
+        options = pathOrOptions;
+        pathOrOptions = options.path;
+        pathIsGlobal = !!options.pathIsGlobal;
+        path = options.path;
+    }
+    else {
+        options = { pathOrOptions, pathIsGlobal };
+    }
+    const { overrideContentType, overridResponseType } = options;
+    let methodConfig = Reflect.getMetadata(Symbols.metadata.options.controllerMethod, target.constructor, propertyKey);
+    if (!methodConfig) {
+        methodConfig = new Models.MethodConfig();
+        Reflect.defineMetadata(Symbols.metadata.options.controllerMethod, methodConfig, target.constructor, propertyKey);
+    }
+    methodConfig.methodName = propertyKey;
+    methodConfig.type = method;
+    if (!path) {
+        let paramsPathConcatedPath = '';
+        for (const key in methodConfig.parameters) {
+            if (methodConfig.parameters.hasOwnProperty(key)) {
+                const element = methodConfig.parameters[key];
+                if (element.paramType === 'Path' &&
+                    _.isString(element.paramName) &&
+                    element.paramName.trim().length > 0) {
+                    paramsPathConcatedPath += `/${element.paramName}/:${element.paramName}`;
+                }
+            }
+        }
+        methodConfig.path = `/${propertyKey}${paramsPathConcatedPath}`;
+    }
+    else {
+        methodConfig.path = path;
+    }
+    methodConfig.descriptor = descriptor;
+    methodConfig.global = pathIsGlobal;
+    methodConfig.contentType = overrideContentType;
+    methodConfig.responseType = overridResponseType;
+    Reflect.defineMetadata(Symbols.metadata.options.controllerMethod, methodConfig, target.constructor, propertyKey);
+};
+function GET(pathOrOptions, pathIsGlobal = false) {
+    return function (target, propertyKey, descriptor) {
+        metaReq('get', pathOrOptions, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal);
+    };
+}
+function HEAD(pathOrOptions, pathIsGlobal = false) {
+    return function (target, propertyKey, descriptor) {
+        metaReq('head', pathOrOptions, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal);
+    };
+}
+function POST(pathOrOptions, pathIsGlobal = false) {
+    return function (target, propertyKey, descriptor) {
+        metaReq('post', pathOrOptions, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal);
+    };
+}
+function PUT(pathOrOptions, pathIsGlobal = false) {
+    return function (target, propertyKey, descriptor) {
+        metaReq('put', pathOrOptions, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal);
+    };
+}
+function PATCH(pathOrOptions, pathIsGlobal = false) {
+    return function (target, propertyKey, descriptor) {
+        metaReq('patch', pathOrOptions, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal);
+    };
+}
+function DELETE(pathOrOptions, pathIsGlobal = false) {
+    return function (target, propertyKey, descriptor) {
+        metaReq('delete', pathOrOptions, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal);
+    };
+}
+;
+({}); // @--end-of-file-for-module=taon lib/decorators/http/http-methods-decorators.ts
+
+function metaParam(param, name, expire, defaultValue = undefined, target, propertyKey, parameterIndex) {
+    let methodConfig = Reflect.getMetadata(Symbols.metadata.options.controllerMethod, target.constructor, propertyKey);
+    if (!methodConfig) {
+        methodConfig = new Models.MethodConfig();
+        Reflect.defineMetadata(Symbols.metadata.options.controllerMethod, methodConfig, target.constructor, propertyKey);
+    }
+    const nameKey = name ? name : param;
+    const p = (methodConfig.parameters[nameKey] = !methodConfig.parameters[nameKey]
+        ? new Models.ParamConfig()
+        : methodConfig.parameters[nameKey]);
+    p.index = parameterIndex;
+    p.paramName = name;
+    p.paramType = param;
+    p.defaultType = defaultValue;
+    p.expireInSeconds = expire;
+    Reflect.defineMetadata(Symbols.metadata.options.controllerMethod, methodConfig, target.constructor, propertyKey);
+}
+function Path(name) {
+    return function (target, propertyKey, parameterIndex) {
+        metaParam('Path', name, undefined, {}, target, propertyKey, parameterIndex);
+    };
+}
+function Query(name) {
+    return function (target, propertyKey, parameterIndex) {
+        metaParam('Query', name, undefined, {}, target, propertyKey, parameterIndex);
+    };
+}
+function Cookie(name, expireInSecond = 3600) {
+    return function (target, propertyKey, parameterIndex) {
+        metaParam('Cookie', name, expireInSecond, {}, target, propertyKey, parameterIndex);
+    };
+}
+function Header(name) {
+    return function (target, propertyKey, parameterIndex) {
+        metaParam('Header', name, undefined, {}, target, propertyKey, parameterIndex);
+    };
+}
+function Body(name) {
+    return function (target, propertyKey, parameterIndex) {
+        metaParam('Body', name, undefined, {}, target, propertyKey, parameterIndex);
+    };
+}
+;
+({}); // @--end-of-file-for-module=taon lib/decorators/http/http-params-decorators.ts
+
+var Http;
+(function (Http) {
+    Http.GET = GET;
+    Http.POST = POST;
+    Http.PUT = PUT;
+    Http.DELETE = DELETE;
+    Http.PATCH = PATCH;
+    Http.HEAD = HEAD;
+    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 = {}));
+;
+({}); // @--end-of-file-for-module=taon lib/decorators/http/http-decorators.ts
+
+function TaonController(options) {
+    return function (constructor) {
+        ClassHelpers.setName(constructor, options?.className);
+        Reflect.defineMetadata(Symbols.metadata.options.controller, options, constructor);
+        Reflect.defineMetadata(Symbols.metadata.className, options?.className || constructor.name, constructor);
+    };
+}
+class TaonControllerOptions extends Models.DecoratorAbstractOpt {
+}
+;
+({}); // @--end-of-file-for-module=taon lib/decorators/classes/controller-decorator.ts
+
+class BaseInjector {
+    constructor() {
+        /**
+         * Repositories to init (by controller)
+         */
+        this.__repositories_to_init__ = [];
+    }
+    /**
+     * class initialization hook
+     * taon after class instace creation
+     */
+    async _() {
+        const reposToInit = this.__repositories_to_init__;
+        for (const repo of reposToInit) {
+            await repo.__init(this);
+        }
+    }
+    /**
+     * Current endpoint context
+     */
+    get __endpoint_context__() {
+        return this[Symbols.ctxInClassOrClassObj];
+    }
+    /**
+     * inject crud repo for entity
+     */
+    injectRepo(entityForCrud) {
+        const repoProxy = this.__inject(void 0, {
+            localInstance: true,
+            resolveClassFromContext: 'BaseRepository',
+            locaInstanceConstructorArgs: [() => entityForCrud],
+        });
+        this.__repositories_to_init__.push(repoProxy);
+        return repoProxy;
+    }
+    injectCustomRepository(cutomRepositoryClass) {
+        const repoProxy = this.__inject(cutomRepositoryClass, {
+            localInstance: true,
+            locaInstanceConstructorArgs: [
+                () => cutomRepositoryClass.prototype.entityClassResolveFn(),
+            ],
+        });
+        this.__repositories_to_init__.push(repoProxy);
+        return repoProxy;
+    }
+    /**
+     * aliast to .injectRepository()
+     */
+    injectCustomRepo(cutomRepositoryClass) {
+        const repoProxy = this.injectCustomRepository(cutomRepositoryClass);
+        this.__repositories_to_init__.push(repoProxy);
+        return repoProxy;
+    }
+    injectController(ctor) {
+        return this.__inject(ctor, { localInstance: false });
+    }
+    /**
+     * aliast to .injectController()
+     */
+    injectSubscriber(ctor) {
+        return this.__inject(ctor, { localInstance: false });
+    }
+    /**
+     * aliast to .injectController()
+     */
+    injectCtrl(ctor) {
+        return this.injectController(ctor);
+    }
+    /**
+     * global provider available in every context
+     */
+    injectGlobalProvider(ctor) {
+        return this.__inject(ctor, { localInstance: false });
+    }
+    /**
+     * context scoped provider
+     * TODO
+     */
+    injectContextProvider(ctor) {
+        return this.__inject(ctor, { localInstance: false });
+    }
+    /**
+     * Inject: Controllers, Providers, Repositories, Services, etc.
+     * TODO  addd nest js injecting
+     */
+    __inject(ctor, options) {
+        if (!options) {
+            options = {};
+        }
+        const contextClassInstance = this;
+        return new Proxy({}, {
+            get: (__, propName) => {
+                const contextFromClass = ctor && ctor[Symbols.ctxInClassOrClassObj];
+                const resultContext = contextFromClass
+                    ? contextFromClass
+                    : this.__endpoint_context__;
+                if (options.resolveClassFromContext) {
+                    const resolvedClass = resultContext.getClassFunByClassName(options.resolveClassFromContext);
+                    ctor = resolvedClass;
+                }
+                if (resultContext) {
+                    var instance = resultContext.inject(ctor, {
+                        ...options,
+                        contextClassInstance,
+                    });
+                    if (!instance) {
+                        throw new Error(`Not able to inject "${ClassHelpers.getName(ctor) || ctor.name}" inside ` +
+                            `property "${propName?.toString()}" on  class "${ClassHelpers.getName(this)}".
+
+              Please add "${ClassHelpers.getName(ctor) || ctor.name}" to (entites or contorllers or providers or repositories)
+
+              `);
+                    }
+                    const result = typeof instance[propName] === 'function'
+                        ? instance[propName].bind(instance)
+                        : instance[propName];
+                    return result;
+                }
+            },
+            set: (__, propName, value) => {
+                const contextFromClass = ctor && ctor[Symbols.ctxInClassOrClassObj];
+                const resultContext = contextFromClass
+                    ? contextFromClass
+                    : this.__endpoint_context__;
+                if (options.resolveClassFromContext) {
+                    const resolvedClass = resultContext.getClassFunByClassName(options.resolveClassFromContext);
+                    ctor = resolvedClass;
+                }
+                if (resultContext) {
+                    var instance = resultContext.inject(ctor, {
+                        ...options,
+                        contextClassInstance,
+                    });
+                    if (!instance) {
+                        const classNameNotResolved = ClassHelpers.getName(ctor) || ctor.name;
+                        throw new Error(`Not able to inject "${classNameNotResolved}" inside ` +
+                            `property "${propName?.toString()}" on  class "${ClassHelpers.getName(this)}".
+
+              Please add "${ClassHelpers.getName(ctor) || ctor.name}" to (entites or contorllers or providers or repositories)
+
+              `);
+                    }
+                    instance[propName] = value;
+                }
+                return true;
+            },
+        });
+    }
+    clone(override) {
+        const classFn = ClassHelpers.getClassFnFromObject(this);
+        const result = _.merge(new classFn(), _.merge(_.cloneDeep(this), override));
+        return result;
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/base-classes/base-injector.ts
+
+let BaseController = class BaseController extends BaseInjector {
+    /**
+     * init example data for db
+     */
+    initExampleDbData() {
+        return void 0;
+    }
+};
+BaseController = __decorate([
+    TaonController({ className: 'BaseController' })
+], BaseController);
+;
+({}); // @--end-of-file-for-module=taon lib/base-classes/base-controller.ts
+
+/**
+ * Please override property entityClassFn with entity class.
+ */
+let BaseCrudController = class BaseCrudController extends BaseController {
+    async _() {
+        if (!_.isFunction(this.entityClassResolveFn)) {
+            Helpers.warn(`Skipping initing CRUD controller ${ClassHelpers.getName(this)} because entityClassResolveFn is not provided.`);
+            return;
+        }
+        let entityClassFn = this.entityClassResolveFn();
+        this.db = this.injectRepo(entityClassFn);
+        if (entityClassFn) {
+            const configEntity = Reflect.getMetadata(Symbols.metadata.options.entity, ClassHelpers.getClassFnFromObject(this));
+            if (configEntity?.createTable === false) {
+                Helpers.warn(`Table for entity ${ClassHelpers.getName(entityClassFn)} will not be created. Crud will not work properly.`);
+            }
+        }
+        else {
+            Helpers.error(`Entity class not provided for controller ${ClassHelpers.getName(this)}.
+
+      Please provide entity as class propery entityClassFn:
+
+      class ${ClassHelpers.getName(this)} extends BaseCrudController<Entity> {
+
+        entityClassResolveFn = ()=> MyEntityClass;
+
+      }
+
+      `);
+        }
+        await super._();
+    }
+    bufforedChanges(id, property, alreadyLength) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    pagination(pageNumber = 1, pageSize = 10, search = '') {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    getAll() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    getBy(id) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    updateById(id, item) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    patchById(id, item) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    bulkUpdate(items) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    deleteById(id) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    bulkDelete(ids) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    create(item) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    bulkCreate(items) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+};
+__decorate([
+    GET(`/:id/property/:property`),
+    __param(0, Path(`id`)),
+    __param(1, Path(`property`)),
+    __param(2, Query('alreadyLength')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Number]),
+    __metadata("design:returntype", Object)
+], BaseCrudController.prototype, "bufforedChanges", null);
+__decorate([
+    GET(),
+    __param(0, Query('pageNumber')),
+    __param(1, Query('pageSize')),
+    __param(2, Query('search')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Number, String]),
+    __metadata("design:returntype", Object)
+], BaseCrudController.prototype, "pagination", null);
+__decorate([
+    GET(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], BaseCrudController.prototype, "getAll", null);
+__decorate([
+    GET(`/:id`),
+    __param(0, Path(`id`)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], BaseCrudController.prototype, "getBy", null);
+__decorate([
+    PUT(`/:id`),
+    __param(0, Path(`id`)),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Object)
+], BaseCrudController.prototype, "updateById", null);
+__decorate([
+    PATCH(`/:id`),
+    __param(0, Path(`id`)),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Object)
+], BaseCrudController.prototype, "patchById", null);
+__decorate([
+    PUT(),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Object)
+], BaseCrudController.prototype, "bulkUpdate", null);
+__decorate([
+    DELETE(`/:id`),
+    __param(0, Path(`id`)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Object)
+], BaseCrudController.prototype, "deleteById", null);
+__decorate([
+    DELETE(`/bulkDelete/:ids`),
+    __param(0, Path(`ids`)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Object)
+], BaseCrudController.prototype, "bulkDelete", null);
+__decorate([
+    POST(),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], BaseCrudController.prototype, "create", null);
+__decorate([
+    POST(),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], BaseCrudController.prototype, "bulkCreate", null);
+BaseCrudController = __decorate([
+    TaonController({ className: 'BaseCrudController' })
+], BaseCrudController);
+;
+({}); // @--end-of-file-for-module=taon lib/base-classes/base-crud-controller.ts
+
+class BaseClass {
+    /**
+     * class initialization hook
+     * taon after class instace creation
+     */
+    async _() { }
+    clone(override) {
+        const classFn = ClassHelpers.getClassFnFromObject(this);
+        const result = _.merge(new classFn(), _.merge(_.cloneDeep(this), override));
+        return result;
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/base-classes/base-class.ts
+
+/* */
+/* */
+let EntityDecorator$1 = () => {
+    return (target) => { };
+};
+/* */
+/* */
+let BaseEntity = class BaseEntity extends BaseClass {
+};
+BaseEntity = __decorate([
+    EntityDecorator$1()
+], BaseEntity);
+;
+({}); // @--end-of-file-for-module=taon lib/base-classes/base-entity.ts
+
+/* */
+/* */
+let EntityDecorator = () => {
+    return (target) => { };
+};
+/* */
+/* */
+let BaseAbstractEntity = class BaseAbstractEntity extends BaseEntity {
+};
+BaseAbstractEntity = __decorate([
+    EntityDecorator()
+], BaseAbstractEntity);
+;
+({}); // @--end-of-file-for-module=taon lib/base-classes/base-abstract-entity.ts
+
+function TaonRepository(options) {
+    return function (constructor) {
+        Reflect.defineMetadata(Symbols.metadata.options.repository, options, constructor);
+        Reflect.defineMetadata(Symbols.metadata.className, options?.className || constructor.name, constructor);
+        ClassHelpers.setName(constructor, options?.className);
+    };
+}
+class TaonRepositoryOptions extends Models.DecoratorAbstractOpt {
+}
+;
+({}); // @--end-of-file-for-module=taon lib/decorators/classes/repository-decorator.ts
+
+const INDEX_KEYS_NO_FOR_UPDATE = ['id'];
+let BaseRepository = class BaseRepository extends BaseInjector {
+    constructor(__entityClassResolveFn) {
+        super();
+        this.__entityClassResolveFn = __entityClassResolveFn;
+        // @ts-ignore
+        this.entityClassResolveFn = __entityClassResolveFn;
+    }
+    get dbQuery() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    get connection() {
+        /* */
+        /* */
+        return (void 0);
+    }
+    /* */
+    /* */
+    get repository() {
+        /* */
+        /* */
+        return (void 0);
+    }
+    /**
+     * target for repository
+     */
+    get target() {
+        /* */
+        /* */
+        return (void 0);
+    }
+    /**
+     * alias to repository
+     */
+    get repo() {
+        /* */
+        /* */
+        return (void 0);
+    }
+    get repositoryExists() {
+        /* */
+        /* */
+        return (void 0);
+    }
+    async __init(context) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+    }
+    /**
+     * Checks if entity has an id.
+     * If entity composite compose ids, it will check them all.
+     */
+    hasId(entity) {
+        return this.repo.hasId(entity);
+    }
+    /**
+     * Gets entity mixed id.
+     */
+    getId(entity) {
+        return this.repo.getId(entity);
+    }
+    /**
+      Saves a given entity in the database.
+     * If entity does not exist in the database then inserts, otherwise updates.
+     */
+    async save(item, options) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    /**
+     * alias to save
+     * -> it will actuall create new entity in db
+     * in oposite to typeorm create method
+     */
+    async create(item, options) {
+        return this.save(item, options);
+    }
+    async bulkSave(items, options) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    async bulkCreate(items, options) {
+        return this.bulkSave(items, options);
+    }
+    /**
+     * Saves all given entities in the database.
+     * If entities do not exist in the database then inserts, otherwise updates.
+     */
+    /**
+     * Merges multiple entities (or entity-like objects) into a given entity.
+     */
+    merge(mergeIntoEntity, ...entityLikes) {
+        return this.repo.merge(mergeIntoEntity, ...entityLikes);
+    }
+    /**
+     * Creates a new entity from the given plain javascript object. If entity already exist in the database, then
+     * it loads it (and everything related to it), replaces all values with the new ones from the given object
+     * and returns this new entity. This new entity is actually a loaded from the db entity with all properties
+     * replaced from the new object.
+     *
+     * Note that given entity-like object must have an entity id / primary key to find entity by.
+     * Returns undefined if entity with given id was not found.
+     */
+    preload(entityLike) {
+        return this.repo.preload(entityLike);
+    }
+    /**
+     * Removes a given entities from the database.
+     */
+    async remove(idOrEntity) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    /**
+     * alias to remove
+     */
+    async delete(idOrEntity) {
+        return this.remove(idOrEntity);
+    }
+    /**
+     * alias to removeById
+     */
+    async deleteById(id) {
+        return this.remove(id);
+    }
+    async bulkRemove(idsOrEntities) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    async bulkDelete(ids) {
+        return this.bulkRemove(ids);
+    }
+    /**
+     * Records the delete date of a given entity.
+     */
+    softRemove(entity, options) {
+        return this.repo.softRemove(entity, options);
+    }
+    /**
+     * Recovers a given entity in the database.
+     */
+    recover(entity, options) {
+        return this.repo.recover(entity, options);
+    }
+    /**
+     * Inserts a given entity into the database.
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient INSERT query.
+     * Does not check if entity exist in the database, so query will fail if duplicate entity is being inserted.
+     */
+    insert(entity) {
+        return this.repo.insert(entity);
+    }
+    async update(item) {
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    async updateById(id, item) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    async bulkUpdate(items) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    /**
+     * Inserts a given entity into the database, unless a unique constraint conflicts then updates the entity
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient INSERT ... ON CONFLICT DO UPDATE/ON DUPLICATE KEY UPDATE query.
+     */
+    upsert(entityOrEntities, conflictPathsOrOptions) {
+        return this.repo.upsert(entityOrEntities, conflictPathsOrOptions);
+    }
+    /**
+     * Records the delete date of entities by a given criteria.
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient SOFT-DELETE query.
+     * Does not check if entity exist in the database.
+     */
+    softDelete(criteria) {
+        return this.repo.softDelete(criteria);
+    }
+    /**
+     * Restores entities by a given criteria.
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient SOFT-DELETE query.
+     * Does not check if entity exist in the database.
+     */
+    restore(criteria) {
+        return this.repo.restore(criteria);
+    }
+    /**
+     * Counts entities that match given options.
+     * Useful for pagination.
+     */
+    count(options) {
+        return this.repo.count(options);
+    }
+    /**
+     * Counts entities that match given conditions.
+     * Useful for pagination.
+     */
+    countBy(where) {
+        return this.repo.countBy(where);
+    }
+    /**
+     * Finds entities that match given find options.
+     */
+    find(options) {
+        return this.repo.find(options);
+    }
+    /**
+     * Finds entities that match given find options.
+     */
+    findBy(where) {
+        return this.repo.findBy(where);
+    }
+    //
+    /**
+     * Finds entities that match given find options.
+     * Also counts all entities that match given conditions,
+     * but ignores pagination settings (from and take options).
+     */
+    findAndCount(options) {
+        return this.repo.findAndCount(options);
+    }
+    /**
+     * Finds entities that match given WHERE conditions.
+     * Also counts all entities that match given conditions,
+     * but ignores pagination settings (from and take options).
+     */
+    findAndCountBy(where) {
+        return this.repo.findAndCountBy(where);
+    }
+    /**
+     * Finds entities with ids.
+     * Optionally find options or conditions can be applied.
+     *
+     * @deprecated use `findBy` method instead in conjunction with `In` operator, for example:
+     *
+     * .findBy({
+     *     id: In([1, 2, 3])
+     * })
+     */
+    findByIds(ids) {
+        return this.repo.findByIds(ids);
+    }
+    /**
+     * Finds first entity by a given find options.
+     * If entity was not found in the database - returns null.
+     */
+    findOne(options) {
+        return this.repo.findOne(options);
+    }
+    /**
+     * Finds first entity that matches given where condition.
+     * If entity was not found in the database - returns null.
+     */
+    findOneBy(where) {
+        return this.repo.findOneBy(where);
+    }
+    /**
+     * Finds first entity that matches given id.
+     * If entity was not found in the database - returns null.
+     *
+     * @deprecated use `findOneBy` method instead in conjunction with `In` operator, for example:
+     *
+     * .findOneBy({
+     *     id: 1 // where "id" is your primary column name
+     * })
+     */
+    findOneById(id) {
+        return this.repo.findOneById(id);
+    }
+    /**
+     * Finds first entity by a given find options.
+     * If entity was not found in the database - rejects with error.
+     */
+    findOneOrFail(options) {
+        return this.repo.findOneOrFail(options);
+    }
+    /**
+     * Finds first entity that matches given where condition.
+     * If entity was not found in the database - rejects with error.
+     */
+    findOneByOrFail(where) {
+        return this.repo.findOneByOrFail(where);
+    }
+    /**
+     * Executes a raw SQL query and returns a raw database results.
+     * Raw query execution is supported only by relational databases (MongoDB is not supported).
+     */
+    query(query, parameters) {
+        return this.repo.query(query, parameters);
+    }
+    /**
+     * Clears all the data from the given table/collection (truncates/drops it).
+     *
+     * Note: this method uses TRUNCATE and may not work as you expect in transactions on some platforms.
+     * @see https://stackoverflow.com/a/5972738/925151
+     */
+    clear() {
+        return this.repo.clear();
+    }
+    /**
+     * Increments some column by provided value of the entities matched given conditions.
+     */
+    increment(conditions, propertyPath, value) {
+        return this.repo.increment(conditions, propertyPath, value);
+    }
+    /**
+     * Decrements some column by provided value of the entities matched given conditions.
+     */
+    decrement(conditions, propertyPath, value) {
+        return this.repo.decrement(conditions, propertyPath, value);
+    }
+    /**
+     * @deprecated use findAndCount instead
+     */
+    async getAll() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    async getBy(id) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+};
+BaseRepository = __decorate([
+    TaonRepository({ className: 'BaseRepository' }),
+    __metadata("design:paramtypes", [Function])
+], BaseRepository);
+;
+({}); // @--end-of-file-for-module=taon lib/base-classes/base-repository.ts
+
+class BaseProvider extends BaseInjector {
+}
+;
+({}); // @--end-of-file-for-module=taon lib/base-classes/base-provider.ts
+
+class DITaonContainer {
+    static { this.instances = new Map(); }
+    static resolve(target) {
+        if (DITaonContainer.instances.has(target)) {
+            return DITaonContainer.instances.get(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;
+            },
+        });
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/dependency-injection/di-container.ts
+
+const getResponseValue = (response, options) => {
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    return (void 0);
+};
+;
+({}); // @--end-of-file-for-module=taon lib/get-response-value.ts
+
+const ENV$1 = Helpers.isBrowser ? window['ENV'] : global['ENV'];
+;
+({}); // @--end-of-file-for-module=taon lib/env.ts
+
+/* */
+/* */
+class RealtimeSubsManager {
+    constructor(options) {
+        this.options = options;
+        this.isListening = false;
+        this.observers = [];
+    }
+    startListenIfNotStarted(realtime) {
+        if (this.options.core.ctx.disabledRealtime) {
+            console.warn(`[Taon][startListenIfNotStarted] sockets are disabled`);
+            return;
+        }
+        if (!realtime) {
+            console.warn(`[Taon][startListenIfNotStarted] invalid socket connection`);
+            return;
+        }
+        if (!this.isListening) {
+            const subscribeEvent = Symbols.REALTIME.ROOM_NAME.SUBSCRIBE.CUSTOM(this.options.core.ctx.contextName);
+            this.isListening = true;
+            if (this.options.customEvent) {
+                realtime.emit(subscribeEvent, this.options.roomName);
+            }
+            else {
+                if (_.isString(this.options.property)) {
+                    realtime.emit(Symbols.REALTIME.ROOM_NAME.SUBSCRIBE.ENTITY_PROPERTY_UPDATE_EVENTS(this.options.core.ctx.contextName), this.options.roomName);
+                }
+                else {
+                    realtime.emit(Symbols.REALTIME.ROOM_NAME.SUBSCRIBE.ENTITY_UPDATE_EVENTS(this.options.core.ctx.contextName), this.options.roomName);
+                }
+            }
+            realtime.on(this.options.roomName, data => {
+                this.update(data);
+            });
+        }
+    }
+    add(observer) {
+        this.observers.push(observer);
+    }
+    remove(observer) {
+        this.observers = this.observers.filter(obs => obs !== observer);
+        if (this.observers.length === 0) {
+            this.isListening = false;
+            const { core, customEvent, roomName, property } = this.options;
+            const realtime = core.FE_REALTIME;
+            if (customEvent) {
+                realtime.emit(Symbols.REALTIME.ROOM_NAME.UNSUBSCRIBE.CUSTOM(this.options.core.ctx.contextName), roomName);
+            }
+            else {
+                if (_.isString(property)) {
+                    realtime.emit(Symbols.REALTIME.ROOM_NAME.UNSUBSCRIBE.ENTITY_PROPERTY_UPDATE_EVENTS(this.options.core.ctx.contextName), roomName);
+                }
+                else {
+                    realtime.emit(Symbols.REALTIME.ROOM_NAME.UNSUBSCRIBE.ENTITY_UPDATE_EVENTS(this.options.core.ctx.contextName), roomName);
+                }
+            }
+        }
+    }
+    update(data) {
+        const ngZone = this.options.core.ctx.ngZone;
+        this.observers.forEach(observer => {
+            if (!observer.closed) {
+                if (ngZone) {
+                    ngZone.run(() => {
+                        observer.next(data);
+                    });
+                }
+                else {
+                    observer.next(data);
+                }
+            }
+        });
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-subs-manager.ts
+
+class RealtimeClient {
+    constructor(core) {
+        this.core = core;
+        this.subsmanagers = {};
+        this.core = core;
+        if (!core.ctx.disabledRealtime) {
+            this.init();
+        }
+    }
+    init() {
+        const nspPath = {
+            global: this.core.pathFor(),
+            realtime: this.core.pathFor(Symbols.REALTIME.NAMESPACE(this.core.ctx.contextName)),
+        };
+        this.core.ctx.logRealtime &&
+            console.info('[CLIENT] NAMESPACE GLOBAL ', nspPath.global.href + ` host: ${this.core.ctx.host}`);
+        this.core.ctx.logRealtime &&
+            console.info('[CLIENT] NAMESPACE REALTIME', nspPath.realtime.href + ` host: ${this.core.ctx.host}`);
+        this.core.FE = this.core.strategy.io(nspPath.global.origin, {
+            path: nspPath.global.pathname,
+        });
+        if (this.core.FE.on) {
+            this.core.FE.on('connect', () => {
+                console.info(`[CLIENT] conented to GLOBAL namespace ${this.core.FE.id} of host: ${this.core.ctx.host}`);
+            });
+        }
+        this.core.FE_REALTIME = this.core.strategy.io(nspPath.realtime.origin, {
+            path: nspPath.realtime.pathname,
+        });
+        if (this.core.FE_REALTIME.on) {
+            this.core.FE_REALTIME.on('connect', () => {
+                console.info(`[CLIENT] conented to REALTIME namespace ${this.core.FE_REALTIME.id} host: ${this.core.ctx.host}`);
+            });
+        }
+    }
+    /**
+     * Changes trigger on backend needs to be done manually.. example code:
+     *
+     * ...
+     * Context.Realtime.Server.TrigggerEntityChanges(myEntityInstance);
+     * ...
+     */
+    listenChangesEntity(entityClassFn, idOrUniqValue, options) {
+        options = options || {};
+        const { property, customEvent } = options;
+        const className = !customEvent && ClassHelpers.getName(entityClassFn);
+        if (_.isString(property)) {
+            if (property.trim() === '') {
+                throw new Error(`[Taon][listenChangesEntity.. incorect property '' for ${className}`);
+            }
+        }
+        return new Observable(observer => {
+            if (this.core.ctx.disabledRealtime) {
+                console.error(`[Taon][realtime rxjs] remove taon config flag:
+
+        ...
+        disabledRealtime: true
+        ...
+
+to use socket realtime connection;
+        `);
+                return () => {
+                };
+            }
+            let roomName;
+            if (customEvent) {
+                roomName = Symbols.REALTIME.ROOM_NAME.CUSTOM(this.core.ctx.contextName, customEvent);
+            }
+            else {
+                roomName = _.isString(property)
+                    ? Symbols.REALTIME.ROOM_NAME.UPDATE_ENTITY_PROPERTY(this.core.ctx.contextName, className, property, idOrUniqValue)
+                    : Symbols.REALTIME.ROOM_NAME.UPDATE_ENTITY(this.core.ctx.contextName, className, idOrUniqValue);
+            }
+            const roomSubOptions = {
+                core: this.core,
+                property,
+                roomName,
+                customEvent,
+            };
+            const subManagerId = this.getRoomIdFrom(roomSubOptions);
+            if (!this.subsmanagers[subManagerId]) {
+                this.subsmanagers[subManagerId] = new RealtimeSubsManager(roomSubOptions);
+            }
+            const inst = this.subsmanagers[subManagerId];
+            inst.add(observer);
+            inst.startListenIfNotStarted(this.core.FE_REALTIME);
+            return () => {
+                inst.remove(observer);
+            };
+        });
+    }
+    listenChangesEntityTable(entityClassFn) {
+        const className = ClassHelpers.getName(entityClassFn);
+        return this.listenChangesEntity(entityClassFn, void 0, {
+            customEvent: Symbols.REALTIME.TABLE_CHANGE(this.core.ctx.contextName, className),
+        });
+    }
+    /**
+     * Changes trigger on backend needs to be done manually.. example code:
+     *
+     * ...
+     * Context.Realtime.Server.TrigggerEntityChanges(myEntityInstance);
+     * // or
+     * Context.Realtime.Server.TrigggerEntityPropertyChanges(myEntityInstance,{ property: 'geolocationX' });
+     * ...
+     */
+    listenChangesEntityObj(entity, options) {
+        const classFn = ClassHelpers.getClassFnFromObject(entity);
+        const uniqueKey = ClassHelpers.getUniquKey(classFn);
+        return this.listenChangesEntity(classFn, entity[uniqueKey], options);
+    }
+    listenChangesCustomEvent(customEvent) {
+        return this.listenChangesEntity(void 0, void 0, {
+            customEvent,
+        });
+    }
+    getRoomIdFrom(options) {
+        const url = new URL(options.core.ctx.host);
+        return `${this.core.ctx.contextName}:${url.origin}|${options.roomName}|${options.property}|${options.customEvent}`;
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-client.ts
+
+const SOCKET_EVENT_DEBOUNCE = 500;
+class RealtimeServer {
+    constructor(core) {
+        this.core = core;
+        this.jobs = {};
+        this.core = core;
+        if (!core.ctx.disabledRealtime) {
+            /* */
+            /* */
+        }
+    }
+    init() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+    }
+    triggerChanges(entityObjOrClass, property, valueOfUniquPropery, customEvent, customEventData) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+    }
+    trigggerEntityChanges(entityObjOrClass, idToTrigger) {
+        if (this.core.ctx.disabledRealtime) {
+            const className = ClassHelpers.getName(entityObjOrClass);
+            console.warn(`[Taon][TrigggerEntityChanges] Entity "${className}' is not realtime`);
+            return;
+        }
+        this.triggerChanges(entityObjOrClass, void 0, idToTrigger);
+    }
+    trigggerEntityPropertyChanges(entityObjOrClass, property, idToTrigger) {
+        if (this.core.ctx.disabledRealtime) {
+            const className = ClassHelpers.getName(entityObjOrClass);
+            console.warn(`[Taon][TrigggerEntityPropertyChanges][property=${property}] Entity "${className}' is not realtime`);
+            return;
+        }
+        if (_.isArray(property)) {
+            property.forEach(propertyFromArr => {
+                this.triggerChanges(entityObjOrClass, propertyFromArr, idToTrigger);
+            });
+        }
+        else {
+            this.triggerChanges(entityObjOrClass, property, idToTrigger);
+        }
+    }
+    triggerCustomEvent(customEvent, dataToPush) {
+        this.triggerChanges(void 0, void 0, void 0, customEvent, dataToPush);
+    }
+    trigggerEntityTableChanges(entityClass) {
+        const className = ClassHelpers.getName(entityClass);
+        if (this.core.ctx.disabledRealtime) {
+            console.warn(`[Taon][TrigggerEntityTableChanges] Entity "${className}' is not realtime`);
+            return;
+        }
+        this.triggerChanges(entityClass, void 0, void 0, Symbols.REALTIME.TABLE_CHANGE(this.core.ctx.contextName, className));
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-server.ts
+
+class RealtimeStrategy {
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    testTypes() {
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy.ts
+
+class IpcRendererNamespace {
+    constructor(name) {
+        this.name = name;
+        this.listeners = {};
+        this.ipcRenderer = window.require('electron').ipcRenderer;
+    }
+    on(eventName, callback) {
+        if (!this.listeners[eventName]) {
+            this.listeners[eventName] = [];
+        }
+        this.listeners[eventName].push(callback);
+        const listenToEvent = `(${this.name}) "${eventName}"`;
+        this.ipcRenderer.on(listenToEvent, callback);
+        if (eventName === 'connect') {
+            this.emit('connection');
+        }
+        else {
+            this.emit(eventName);
+        }
+    }
+    off(event, callback) {
+        if (!this.listeners[event])
+            return;
+        if (callback) {
+            this.listeners[event] = this.listeners[event].filter(listener => listener !== callback);
+        }
+        else {
+            delete this.listeners[event];
+        }
+        const removeListener = `(${this.name}) "${event}"`;
+        this.ipcRenderer.removeListener(removeListener, callback);
+    }
+    emit(event, ...args) {
+        const emitEvent = `(${this.name}) "${event}"`;
+        this.ipcRenderer.send(emitEvent, ...args);
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-renderer-namespace.ts
+
+class IpcRendererWrapper {
+    constructor(contextName) {
+        this.contextName = contextName;
+        this.namespaces = {
+            '/': new IpcRendererNamespace('/'),
+        };
+        this.connected = false;
+    }
+    of(namespace) {
+        if (!this.namespaces[namespace]) {
+            this.namespaces[namespace] = new IpcRendererNamespace(namespace);
+        }
+        return this.namespaces[namespace];
+    }
+    on(event, callback) {
+        this.namespaces['/'].on(event, callback);
+    }
+    emit(event, ...args) {
+        this.namespaces['/'].emit(event, ...args);
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-renderer-wrapper.ts
+
+/**
+ * Purpose:
+ * - backend-browser communication between 2 processes in electron mode
+ */
+class RealtimeStrategyIpc extends RealtimeStrategy {
+    toString() {
+        return 'ipc';
+    }
+    establishConnection() {
+        throw new Error('Method not implemented.');
+    }
+    constructor(ctx) {
+        super(ctx);
+        this.ctx = ctx;
+        this.contextsServers = {};
+        this.contextsIO = {};
+    }
+    get io() {
+        return ((__, { path: namespacePath }) => {
+            if (this.contextsIO[namespacePath]) {
+                return this.contextsIO[namespacePath];
+            }
+            const wrap = new IpcRendererWrapper(this.ctx.contextName);
+            const nsp = wrap.of(namespacePath);
+            this.contextsIO[namespacePath] = nsp;
+            return nsp;
+        });
+        return void 0;
+    }
+    get Server() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return void 0;
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-ipc.ts
+
+class MockNamespace {
+    constructor(name, contextName) {
+        this.name = name;
+        this.contextName = contextName;
+        this.rooms = {};
+        this.sockets = new Set();
+    }
+    on(event, callback) {
+        if (event === 'connection') {
+            this.sockets.forEach(socket => callback(socket));
+        }
+    }
+    emit(event, data) {
+        this.sockets.forEach(socket => socket.emit(event, data));
+    }
+    to(room) {
+        return {
+            emit: (event, data) => {
+                if (this.rooms[room]) {
+                    this.rooms[room].forEach(socket => socket.emit(event, data));
+                }
+            }
+        };
+    }
+    joinRoom(socket, room) {
+        if (!this.rooms[room]) {
+            this.rooms[room] = new Set();
+        }
+        this.rooms[room].add(socket);
+    }
+    leaveRoom(socket, room) {
+        if (this.rooms[room]) {
+            this.rooms[room].delete(socket);
+            if (this.rooms[room].size === 0) {
+                delete this.rooms[room];
+            }
+        }
+    }
+    addSocket(socket) {
+        this.sockets.add(socket);
+    }
+    removeSocket(socket) {
+        this.sockets.delete(socket);
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock-namespaces.ts
+
+class MockSocket {
+    constructor(id, namespace) {
+        this.id = id;
+        this.namespace = namespace;
+        this.listeners = {};
+        this.namespace.addSocket(this);
+    }
+    on(event, callback) {
+        if (!this.listeners[event]) {
+            this.listeners[event] = [];
+        }
+        this.listeners[event].push(callback);
+    }
+    off(event, callback) {
+        if (!this.listeners[event])
+            return;
+        if (callback) {
+            this.listeners[event] = this.listeners[event].filter(listener => listener !== callback);
+        }
+        else {
+            delete this.listeners[event];
+        }
+    }
+    emit(event, data) {
+        if (this.listeners[event]) {
+            this.listeners[event].forEach(listener => listener(data));
+        }
+    }
+    join(room) {
+        this.namespace.joinRoom(this, room);
+    }
+    leave(room) {
+        this.namespace.leaveRoom(this, room);
+    }
+    disconnect() {
+        this.emit('disconnect');
+        this.namespace.removeSocket(this);
+        this.listeners = {};
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock-socket.ts
+
+class MockServer {
+    constructor(contextName) {
+        this.contextName = contextName;
+        this.namespaces = {
+            '/': new MockNamespace('/', this.contextName)
+        };
+    }
+    of(namespace) {
+        if (!this.namespaces[namespace]) {
+            this.namespaces[namespace] = new MockNamespace(namespace, this.contextName);
+        }
+        return this.namespaces[namespace];
+    }
+    on(event, callback) {
+        if (event === 'connection') {
+            this.namespaces['/'].on('connection', callback);
+        }
+    }
+    emit(event, data) {
+        this.namespaces['/'].emit(event, data);
+    }
+    connect(id, namespace = '/') {
+        const ns = this.of(namespace);
+        const socket = new MockSocket(id, ns);
+        ns.on('connection', (socket) => {
+            socket.emit('connect');
+        });
+        return socket;
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock-server.ts
+
+class MockClientSocket {
+    constructor(serverSocket, contextName) {
+        this.serverSocket = serverSocket;
+        this.contextName = contextName;
+        this.listeners = {};
+        serverSocket.on('message', (data) => this.emit('message', data));
+    }
+    on(event, callback) {
+        if (!this.listeners[event]) {
+            this.listeners[event] = [];
+        }
+        this.listeners[event].push(callback);
+    }
+    off(event, callback) {
+        if (!this.listeners[event])
+            return;
+        if (callback) {
+            this.listeners[event] = this.listeners[event].filter(listener => listener !== callback);
+        }
+        else {
+            delete this.listeners[event];
+        }
+    }
+    emit(event, data) {
+        this.serverSocket.emit(event, data);
+        if (this.listeners[event]) {
+            this.listeners[event].forEach(listener => listener(data));
+        }
+    }
+    disconnect() {
+        this.serverSocket.disconnect();
+        this.listeners = {};
+    }
+    join(room) {
+        this.serverSocket.join(room);
+    }
+    leave(room) {
+        this.serverSocket.leave(room);
+    }
+}
+function mockIo(server) {
+    return (namespace = '/') => {
+        const socketId = Math.random().toString(36).substring(2);
+        const serverSocket = server.connect(socketId, namespace);
+        return new MockClientSocket(serverSocket, server.contextName);
+    };
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock-client.ts
+
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-mock-models/index.ts
+
+/**
+ * Purpose:
+ * - browser-browser communication mock (in websql mode)
+ */
+class RealtimeStrategyMock extends RealtimeStrategy {
+    toString() {
+        return 'mock';
+    }
+    constructor(ctx) {
+        super(ctx);
+        this.ctx = ctx;
+    }
+    get Server() {
+        return MockServer;
+    }
+    ;
+    get io() {
+        return mockIo;
+    }
+    establishConnection() {
+        throw new Error('Method not implemented.');
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-mock.ts
+
+/**
+ * Purpose:
+ * - backend-browser communication
+ * - backend-backend communication
+ */
+class RealtimeStrategySocketIO extends RealtimeStrategy {
+    toString() {
+        return 'socket-io';
+    }
+    constructor(ctx) {
+        super(ctx);
+        this.ctx = ctx;
+    }
+    get Server() {
+        /* */
+        /* */
+        return (void 0);
+    }
+    ;
+    get io() {
+        return io;
+    }
+    establishConnection() {
+        throw new Error('Method not implemented.');
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-socket-io.ts
+
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/index.ts
+
+/**
+ * Realtime class
+ * - mock (when browser-browser)
+ * - sockets (from socket io when backend-browser)
+ * - ipc (when electron is used or between processes)
+ * - webworker (when webworker is used in browser or nodejs)
+ */
+class RealtimeCore {
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.allHttpMethods = [
+            'GET',
+            'POST',
+            'PUT',
+            'DELETE',
+            'PATCH',
+            'OPTIONS',
+            'HEAD',
+        ];
+        this.strategy = this.resolveStrategy();
+        ctx.logFramework &&
+            console.log(`[taon] realtime strategy: ${this.strategy}`);
+        this.client = new RealtimeClient(this);
+        this.server = new RealtimeServer(this);
+    }
+    resolveStrategy() {
+        if (this.ctx.mode === 'backend-frontend(websql)') {
+            return new RealtimeStrategyMock(this.ctx);
+        }
+        if (this.ctx.mode === 'backend-frontend(ipc-electron)') {
+            return new RealtimeStrategyIpc(this.ctx);
+        }
+        return new RealtimeStrategySocketIO(this.ctx);
+    }
+    pathFor(namespace) {
+        const uri = this.ctx.uri;
+        let nsp = namespace ? namespace : '';
+        nsp = nsp === '/' ? '' : nsp;
+        const pathname = uri.pathname !== '/' ? uri.pathname : '';
+        let prefix = `taonContext-`;
+        if (Helpers.isElectron) {
+            prefix = ``;
+        }
+        const href = `${uri.origin}${pathname}/${prefix}${nsp}`;
+        return new URL(href);
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-core.ts
+
+/* eslint-disable @typescript-eslint/typedef */
+class EndpointContext {
+    static initNgZone(ngZone) {
+        this.ngZone = ngZone;
+    }
+    static findForTraget(classFnOrObject) {
+        const obj = ClassHelpers.getClassFnFromObject(classFnOrObject) || {};
+        return (classFnOrObject[Symbols.ctxInClassOrClassObj] ||
+            obj[Symbols.ctxInClassOrClassObj]);
+    }
+    get realtimeClient() {
+        return this.realtime.client;
+    }
+    get realtimeServer() {
+        return this.realtime.server;
+    }
+    get logHttp() {
+        if (_.isObject(this.config?.logs)) {
+            return !!this.config.logs.http;
+        }
+        return this.config?.logs === true;
+    }
+    get logRealtime() {
+        if (_.isObject(this.config?.logs)) {
+            return !!this.config.logs.realtime;
+        }
+        return this.config?.logs === true;
+    }
+    get logFramework() {
+        if (_.isObject(this.config?.logs)) {
+            return !!this.config.logs.framework;
+        }
+        return this.config?.logs === true;
+    }
+    get logDb() {
+        if (_.isObject(this.config?.logs)) {
+            return !!this.config.logs.db;
+        }
+        return this.config?.logs === true;
+    }
+    constructor(originalConfig, configFn) {
+        this.originalConfig = originalConfig;
+        this.configFn = configFn;
+        this.disabledRealtime = false;
+        /**
+         * check whether context is inited
+         * (with init() function )
+         */
+        this.inited = false;
+        this.localInstaceObjSymbol = Symbol('localInstaceObjSymbol');
+        /**
+         * all instances of classes from context
+         * key is class name
+         */
+        this.allClassesInstances = {};
+        this.classInstancesByNameObj = {};
+        this.objWithClassesInstancesArr = {};
+        this.activeRoutes = [];
+        this.injectableTypesfromContexts = [
+            Models.ClassType.CONTROLLER,
+            Models.ClassType.PROVIDER,
+            Models.ClassType.REPOSITORY,
+            Models.ClassType.SUBSCRIBER,
+        ];
+        this.allTypesfromContexts = [
+            ...this.injectableTypesfromContexts,
+            Models.ClassType.ENTITY,
+        ];
+        this.expressApp = {};
+        this.entitiesTriggers = {};
+        this.cloneClassWithNewMetadata = ({ BaseClass, className, config, ctx, classType, }) => {
+            const cloneClass = () => {
+                var _a, _b, _c, _d, _e;
+                if (BaseClass[Symbols.fullClassNameStaticProperty] ===
+                    `${ctx.contextName}.${className}`) {
+                    return BaseClass;
+                }
+                return class extends BaseClass {
+                    constructor() {
+                        super(...arguments);
+                        this[_e] = ctx;
+                    }
+                    static { _a = Symbols.orignalClass, _b = Symbols.fullClassNameStaticProperty, _c = Symbols.classNameStaticProperty, _d = Symbols.ctxInClassOrClassObj, _e = Symbols.ctxInClassOrClassObj; }
+                    // @ts-ignore
+                    static { this[_a] = BaseClass; }
+                    // @ts-ignore
+                    static { this[_b] = `${ctx.contextName}.${className}`; }
+                    // @ts-ignore
+                    static { this[_c] = className; }
+                    static { this[_d] = ctx; }
+                    static __getFullPathForClass__(arr = []) {
+                        const name = this[Symbols.fullClassNameStaticProperty];
+                        arr.push(name);
+                        // @ts-ignore
+                        if (this[Symbols.orignalClass] && // @ts-ignore
+                            this[Symbols.orignalClass].__getFullPathForClass__) {
+                            // @ts-ignore
+                            this[Symbols.orignalClass].__getFullPathForClass__(arr);
+                        }
+                        return arr.join('/');
+                    }
+                    static get fullPathForClass() {
+                        return this.__getFullPathForClass__();
+                    }
+                };
+            };
+            const cloneClassFunction = cloneClass();
+            return cloneClassFunction;
+        };
+        this.cloneClassesObjWithNewMetadata = ({ classesInput, config, ctx, classType, }) => {
+            const classes = {};
+            for (const key of Object.keys(classesInput || {})) {
+                const BaseClass = classesInput[key];
+                if (!BaseClass) {
+                    Helpers.error(`Class ${key} is not defined in context ${ctx.contextName}
+
+        Please check if you have correct import in context file
+
+        `);
+                }
+                var className = Reflect.getMetadata(Symbols.metadata.className, BaseClass);
+                className = className || key;
+                BaseClass[Symbols.classNameStaticProperty] = className;
+                const clonedClass = this.cloneClassWithNewMetadata({
+                    BaseClass,
+                    className,
+                    config,
+                    ctx,
+                    classType,
+                });
+                classes[className] = clonedClass;
+            }
+            return classes;
+        };
+    }
+    async init(options) {
+        const { initFromRecrusiveContextResovle } = options || {}; // TODO use it ?
+        this.inited = true;
+        this.config = this.configFn(ENV$1);
+        if (this.config.host) {
+            this.mode = 'backend-frontend(tcp+udp)';
+            /* */
+            /* */
+        }
+        if (this.config.remoteHost) {
+            if (this.config.host) {
+                Helpers.error(`[taon] You can't have remoteHost and host at the same time`, false, true);
+            }
+            this.mode = 'remote-backend(tcp+udp)';
+        }
+        if (this.config.useIpcWhenElectron && Helpers.isElectron) {
+            this.mode = 'backend-frontend(ipc-electron)';
+        }
+        if (!this.mode && !this.config.abstract) {
+            Helpers.error(`[taon] Context "${this.contextName}": You need to provide host or remoteHost or useIpcWhenElectron`, false, true);
+            /* */
+            /* */
+        }
+        if (this.config.database === true) {
+            this.databaseConfig = this.getAutoGeneratedConfig();
+        }
+        else if (_.isObject(this.config.database)) {
+            this.databaseConfig = _.cloneDeep(this.config.database);
+        }
+        if (this.config.session) {
+            this.session = _.cloneDeep(this.config.session);
+            const oneHour = 1000 * 60 * 60 * 1; // 24;
+            if (!this.session.cookieMaxAge) {
+                this.session.cookieMaxAge = oneHour;
+            }
+            axios.defaults.withCredentials = true;
+        }
+        this.config.contexts = this.config.contexts || {};
+        this.config.entities = this.config.entities || {};
+        this.config.controllers = this.config.controllers || {};
+        this.config.repositories = this.config.repositories || {};
+        this.config.providers = this.config.providers || {};
+        this.config.subscribers = this.config.subscribers || {};
+        this.config.entities = {
+            ...(await this.getRecrusiveClassesfromContextsObj(Models.ClassType.ENTITY)),
+            ...this.config.entities,
+        };
+        this.config.controllers = {
+            ...(await this.getRecrusiveClassesfromContextsObj(Models.ClassType.CONTROLLER)),
+            ...this.config.controllers,
+        };
+        this.config.providers = {
+            ...(await this.getRecrusiveClassesfromContextsObj(Models.ClassType.PROVIDER)),
+            ...this.config.providers,
+        };
+        this.config.subscribers = {
+            ...(await this.getRecrusiveClassesfromContextsObj(Models.ClassType.SUBSCRIBER)),
+            ...this.config.subscribers,
+        };
+        this.config.repositories = {
+            ...(await this.getRecrusiveClassesfromContextsObj(Models.ClassType.REPOSITORY)),
+            ...this.config.repositories,
+        };
+        this.config.controllers = this.cloneClassesObjWithNewMetadata({
+            classesInput: this.config.controllers,
+            config: this.config,
+            ctx: this,
+            classType: Models.ClassType.CONTROLLER,
+        });
+        this.config.repositories = this.cloneClassesObjWithNewMetadata({
+            classesInput: this.config.repositories,
+            config: this.config,
+            ctx: this,
+            classType: Models.ClassType.REPOSITORY,
+        });
+        this.config.providers = this.cloneClassesObjWithNewMetadata({
+            classesInput: this.config.providers,
+            config: this.config,
+            ctx: this,
+            classType: Models.ClassType.PROVIDER,
+        });
+        this.config.subscribers = this.cloneClassesObjWithNewMetadata({
+            classesInput: this.config.subscribers,
+            config: this.config,
+            ctx: this,
+            classType: Models.ClassType.SUBSCRIBER,
+        });
+        for (const classTypeName of this.injectableTypesfromContexts) {
+            this.classInstancesByNameObj[classTypeName] = {};
+            this.objWithClassesInstancesArr[classTypeName] = [];
+        }
+        for (const classTypeName of this.injectableTypesfromContexts) {
+            await this.createInstances(this.config[Models.ClassTypeKey[classTypeName]], classTypeName);
+        }
+        if (this.mode === 'backend-frontend(tcp+udp)' && !this.config.abstract) {
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+        }
+        if (!this.config.abstract) {
+            this.disabledRealtime = !!this.config.disabledRealtime;
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            this.realtime = new RealtimeCore(this);
+        }
+        if (this.config.abstract) {
+            this.logFramework &&
+                Helpers.info(`[taon] Create abstract context: ${this.config.contextName}`);
+        }
+        else {
+            if (this.config.remoteHost) {
+                this.logFramework &&
+                    Helpers.info(`[taon] Create context for remote host: ${this.config.remoteHost}`);
+            }
+            else {
+                this.logFramework &&
+                    Helpers.info(`[taon] Create context for host: ${this.config.host}`);
+            }
+        }
+        Object.keys(this.config).forEach(key => {
+            this.originalConfig[key] = this.config[key];
+        });
+    }
+    getAutoGeneratedConfig() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    get ngZone() {
+        return EndpointContext.ngZone;
+        return;
+    }
+    startServer() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    displayRoutes(app) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+    }
+    get modeAllowsDatabaseCreation() {
+        return (this.mode === 'backend-frontend(tcp+udp)' ||
+            this.mode === 'backend-frontend(websql)' ||
+            this.mode === 'backend-frontend(ipc-electron)');
+    }
+    async getRecrusiveClassesfromContextsObj(classType) {
+        const arr = await this.getRecrusiveClassesfromContexts(classType);
+        return arr.reduce((acc, c) => {
+            acc[ClassHelpers.getName(c)] = c;
+            return acc;
+        }, {});
+    }
+    async getRecrusiveClassesfromContexts(classType, arr = []) {
+        const contexts = Object.values(this.config.contexts || {});
+        for (const ctx of contexts) {
+            const ref = await ctx.__ref();
+            const classesInput = ref.getClassFunBy(classType);
+            const clonedClasses = Object.values(this.cloneClassesObjWithNewMetadata({
+                classesInput,
+                config: this.config,
+                ctx: this,
+                classType,
+            }));
+            clonedClasses.forEach(c => arr.push(c));
+            await ref.getRecrusiveClassesfromContexts(classType, arr);
+        }
+        return arr;
+    }
+    getClassInstanceObjBy(classType) {
+        return this.classInstancesByNameObj[classType];
+    }
+    getClassesInstancesArrBy(classType) {
+        return this.objWithClassesInstancesArr[classType];
+    }
+    inject(ctor, options) {
+        if (!options) {
+            options = {};
+        }
+        const className = ClassHelpers.getName(ctor);
+        const locaInstanceConstructorArgs = options.locaInstanceConstructorArgs || [];
+        if (this.isCLassType(Models.ClassType.REPOSITORY, ctor)) {
+            options.localInstance = true;
+        }
+        if (options?.localInstance) {
+            const ctxClassFn = this.getClassFunByClassName(className);
+            let entityName = '';
+            if (className === 'BaseRepository') {
+                const entityFn = locaInstanceConstructorArgs[0];
+                const entity = entityFn && entityFn();
+                entityName = entity && ClassHelpers.getName(entity);
+            }
+            if (!options.contextClassInstance[this.localInstaceObjSymbol]) {
+                options.contextClassInstance[this.localInstaceObjSymbol] = {};
+            }
+            const instanceKey = className + (entityName ? `.${entityName}` : '');
+            const existed = options.contextClassInstance[this.localInstaceObjSymbol][instanceKey];
+            if (existed) {
+                return existed;
+            }
+            if (!ctxClassFn) {
+                throw new Error(`Not able to inject "${className}" inside context "${this.contextName}"
+
+        Make sure they share the same context or import context where "${className}" is defined.
+
+        `);
+            }
+            const injectedInstance = new ctxClassFn(...locaInstanceConstructorArgs);
+            options.contextClassInstance[this.localInstaceObjSymbol][instanceKey] =
+                injectedInstance;
+            return injectedInstance;
+        }
+        const contextScopeInstance = this.allClassesInstances[className];
+        return contextScopeInstance;
+    }
+    /**
+     * alias for inject
+     */
+    getInstanceBy(ctor) {
+        return this.inject(ctor, { localInstance: false });
+    }
+    checkIfContextInitialized() {
+        if (_.isUndefined(this.config)) {
+            throw new Error(`Please check if your context has been initilized.
+
+
+      await Context.initialize();
+
+
+
+      `);
+        }
+    }
+    getClassFunBy(classType) {
+        this.checkIfContextInitialized();
+        switch (classType) {
+            case Models.ClassType.CONTROLLER:
+                return this.config.controllers;
+            case Models.ClassType.ENTITY:
+                return this.config.entities;
+            case Models.ClassType.PROVIDER:
+                return this.config.providers;
+            case Models.ClassType.REPOSITORY:
+                return this.config.repositories;
+            case Models.ClassType.SUBSCRIBER:
+                return this.config.subscribers;
+        }
+    }
+    isCLassType(classType, classFn) {
+        return !!this.getClassFunBy(classType)[ClassHelpers.getName(classFn)];
+    }
+    /**
+     * Only for injectable types
+     * Only for classType: CONTROLLER, REPOSITORY, PROVIDER
+     */
+    getClassFunByClassName(className) {
+        for (const classTypeName of this.allTypesfromContexts) {
+            const classesForInjectableType = this.config[Models.ClassTypeKey[classTypeName]];
+            if (classesForInjectableType[className]) {
+                return classesForInjectableType[className];
+            }
+        }
+    }
+    getClassFunByClass(classFunction) {
+        const className = ClassHelpers.getName(classFunction);
+        return this.getClassFunByClassName(className);
+    }
+    getClassFunByArr(classType) {
+        return Object.values(this.getClassFunBy(classType) || {});
+    }
+    async createInstances(classes, classType) {
+        for (const classFn of [
+            ...Object.values(classes),
+        ]) {
+            const instance = DITaonContainer.resolve(classFn);
+            const classInstancesByNameObj = this.classInstancesByNameObj[classType];
+            const className = ClassHelpers.getName(classFn);
+            classInstancesByNameObj[className] = instance;
+            this.config[Models.ClassTypeKey[classType]][className] = classFn;
+            this.objWithClassesInstancesArr[classType].push(instance);
+            this.allClassesInstances[className] = instance;
+        }
+    }
+    async reinitControllers() {
+        const controllers = this.getClassesInstancesArrBy(Models.ClassType.CONTROLLER);
+        for (const ctrl of controllers) {
+            if (_.isFunction(ctrl.initExampleDbData)) {
+                await Helpers.runSyncOrAsync({
+                    functionFn: ctrl.initExampleDbData,
+                    context: ctrl,
+                });
+            }
+        }
+    }
+    async initClasses() {
+        for (const classTypeName of [
+            Models.ClassType.PROVIDER,
+            Models.ClassType.REPOSITORY,
+            Models.ClassType.CONTROLLER,
+            Models.ClassType.ENTITY,
+        ]) {
+            for (const classFun of this.getClassFunByArr(classTypeName)) {
+                if (_.isFunction(classFun._)) {
+                    await Helpers.runSyncOrAsync({
+                        functionFn: classFun._,
+                        context: classFun,
+                    });
+                }
+            }
+        }
+        for (const classTypeName of [
+            Models.ClassType.PROVIDER,
+            Models.ClassType.REPOSITORY,
+            Models.ClassType.CONTROLLER,
+        ]) {
+            for (const ctrl of this.getClassesInstancesArrBy(classTypeName)) {
+                if (_.isFunction(ctrl._)) {
+                    await Helpers.runSyncOrAsync({
+                        functionFn: ctrl._,
+                        context: ctrl,
+                    });
+                }
+            }
+        }
+    }
+    isActiveOn(classInstance) {
+        let contextRef = classInstance[Symbols.ctxInClassOrClassObj];
+        return this === contextRef;
+    }
+    get uri() {
+        const url = this.host
+            ? new URL(this.host)
+            : this.remoteHost
+                ? new URL(this.remoteHost)
+                : void 0;
+        return url;
+    }
+    get isHttpServer() {
+        return this.uri.protocol === 'https:';
+    }
+    /**
+     * ipc/udp needs this
+     */
+    get contextName() {
+        return this.config.contextName;
+    }
+    get publicAssets() {
+        return this.config?.publicAssets || [];
+    }
+    get isProductionMode() {
+        return this.config.productionMode;
+    }
+    get remoteHost() {
+        return this.config.remoteHost;
+    }
+    get host() {
+        return this.config.host;
+    }
+    get orgin() {
+        return this.uri?.origin;
+    }
+    async initSubscribers() {
+        return; // TODO
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+    }
+    async initEntities() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+    }
+    async initDatabaseConnection() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    initMetadata() {
+        const allControllers = this.getClassFunByArr(Models.ClassType.CONTROLLER);
+        for (const controllerClassFn of allControllers) {
+            controllerClassFn[Symbols.classMethodsNames] =
+                ClassHelpers.getMethodsNames(controllerClassFn);
+            const configs = ClassHelpers.getControllerConfigs(controllerClassFn);
+            const classConfig = configs[0];
+            const parentscalculatedPath = _.slice(configs, 1)
+                .reverse()
+                .map(bc => {
+                if (TaonHelpers.isGoodPath(bc.path)) {
+                    return bc.path;
+                }
+                return bc.className;
+            })
+                .join('/');
+            if (TaonHelpers.isGoodPath(classConfig.path)) {
+                classConfig.calculatedPath = classConfig.path;
+            }
+            else {
+                classConfig.calculatedPath =
+                    `${parentscalculatedPath}/${ClassHelpers.getName(controllerClassFn)}`
+                        .replace(/\/\//g, '/')
+                        .split('/')
+                        .reduce((acc, bc) => {
+                        return _.last(acc) === bc ? acc : [...acc, bc];
+                    }, [])
+                        .join('/');
+            }
+            _.slice(configs, 1).forEach(bc => {
+                const alreadyIs = classConfig.methods;
+                const toMerge = _.cloneDeep(bc.methods);
+                for (const key in toMerge) {
+                    if (toMerge.hasOwnProperty(key) && !alreadyIs[key]) {
+                        const element = toMerge[key];
+                        alreadyIs[key] = element;
+                    }
+                }
+            });
+            /* */
+            /* */
+            this.logHttp &&
+                console.groupCollapsed(`[taon][express-server] routes [${classConfig.className}]`);
+            /* */
+            /* */
+            Object.keys(classConfig.methods).forEach(methodName => {
+                const methodConfig = classConfig.methods[methodName];
+                const type = methodConfig.type;
+                const expressPath = methodConfig.global
+                    ? `/${methodConfig.path?.replace(/\//, '')}`
+                    : TaonHelpers.getExpressPath(classConfig, methodConfig);
+                if (Helpers.isNode || Helpers.isWebSQL) {
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                    /* */
+                }
+                const shouldInitClient = Helpers.isBrowser || this.remoteHost || Helpers.isWebSQL;
+                if (shouldInitClient) {
+                    this.initClient(controllerClassFn, type, methodConfig, expressPath);
+                }
+            });
+            /* */
+            /* */
+            this.logHttp && console.groupEnd();
+            /* */
+            /* */
+        }
+    }
+    writeActiveRoutes() {
+        const contexts = [this];
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+    }
+    get middlewares() {
+        /* */
+        /* */
+        return (void 0);
+    }
+    initMidleware() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+    }
+    initServer(type, methodConfig, classConfig, expressPath, target) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        const url = this.uri;
+        const getResult = async (resolvedParams, req, res) => {
+            const response = methodConfig.descriptor.value.apply(
+            /**
+             * Context for method @GET,@PUT etc.
+             */
+            this.getInstanceBy(target), 
+            /**
+             * Params for metjod @GET, @PUT etc.
+             */
+            resolvedParams);
+            let result = await getResponseValue(response, { req, res });
+            return result;
+        };
+        url.pathname = url.pathname.replace(/\/$/, '');
+        expressPath = url.pathname.startsWith('/')
+            ? `${url.pathname}${expressPath}`
+            : expressPath;
+        expressPath = expressPath.replace(/\/\//g, '/');
+        if (Helpers.isElectron) {
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+        }
+        if (!this.remoteHost) {
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+        }
+        return {
+            routePath: expressPath,
+            method: methodConfig.type,
+        };
+    }
+    /**
+     * client can be browser or nodejs (when remote host)
+     */
+    initClient(target, type, methodConfig, expressPath) {
+        const ctx = this;
+        this.logHttp && console.log(`${type?.toUpperCase()} ${expressPath} `);
+        let storage;
+        if (Helpers.isBrowser) {
+            storage = window;
+        }
+        /* */
+        /* */
+        /* */
+        /* */
+        const orgMethods = target.prototype[methodConfig.methodName];
+        if (Helpers.isElectron) {
+            target.prototype[methodConfig.methodName] = function (...args) {
+                const received = new Promise(async (resolve, reject) => {
+                    const headers = {};
+                    const { request, response } = TaonHelpers.websqlMocks(headers);
+                    Helpers.ipcRenderer.once(TaonHelpers.ipcKeyNameResponse(target, methodConfig, expressPath), (event, responseData) => {
+                        let res = responseData;
+                        console.log({ responseData });
+                        try {
+                            const body = res;
+                            res = new Models$1.HttpResponse({
+                                body: void 0,
+                                isArray: void 0,
+                                method: methodConfig.type,
+                                url: `${ctx.uri.origin}${'' // TODO express path
+                                }${methodConfig.path} `,
+                            }, Helpers.isBlob(body) || _.isString(body)
+                                ? body
+                                : JSON.stringify(body), RestHeaders.from(headers), void 0, () => body);
+                            resolve(res);
+                        }
+                        catch (error) {
+                            console.error(error);
+                            reject(error);
+                        }
+                    });
+                    Helpers.ipcRenderer.send(TaonHelpers.ipcKeyNameRequest(target, methodConfig, expressPath), args);
+                });
+                received['observable'] = from(received);
+                return {
+                    received,
+                };
+            };
+            return;
+        }
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        target.prototype[methodConfig.methodName] = function (...args) {
+            if (!storage[Symbols.old.ENDPOINT_META_CONFIG])
+                storage[Symbols.old.ENDPOINT_META_CONFIG] = {};
+            if (!storage[Symbols.old.ENDPOINT_META_CONFIG][ctx.uri.href])
+                storage[Symbols.old.ENDPOINT_META_CONFIG][ctx.uri.href] = {};
+            const endpoints = storage[Symbols.old.ENDPOINT_META_CONFIG];
+            let rest;
+            if (!endpoints[ctx.uri.href][expressPath]) {
+                let headers = {};
+                if (methodConfig.contentType && !methodConfig.responseType) {
+                    rest = Resource.create(ctx.uri.href, expressPath, Symbols.old.MAPPING_CONFIG_HEADER, Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, RestHeaders.from({
+                        'Content-Type': methodConfig.contentType,
+                        Accept: methodConfig.contentType,
+                    }));
+                }
+                else if (methodConfig.contentType && methodConfig.responseType) {
+                    rest = Resource.create(ctx.uri.href, expressPath, Symbols.old.MAPPING_CONFIG_HEADER, Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, RestHeaders.from({
+                        'Content-Type': methodConfig.contentType,
+                        Accept: methodConfig.contentType,
+                        responsetypeaxios: methodConfig.responseType,
+                    }));
+                }
+                else if (!methodConfig.contentType && methodConfig.responseType) {
+                    rest = Resource.create(ctx.uri.href, expressPath, Symbols.old.MAPPING_CONFIG_HEADER, Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, RestHeaders.from({
+                        responsetypeaxios: methodConfig.responseType,
+                    }));
+                }
+                else {
+                    rest = Resource.create(ctx.uri.href, expressPath, Symbols.old.MAPPING_CONFIG_HEADER, Symbols.old.CIRCURAL_OBJECTS_MAP_BODY);
+                }
+                endpoints[ctx.uri.href][expressPath] = rest;
+            }
+            else {
+                rest = endpoints[ctx.uri.href][expressPath];
+            }
+            const method = type.toLowerCase();
+            const isWithBody = method === 'put' || method === 'post';
+            const pathPrams = {};
+            let queryParams = {};
+            let bodyObject = {};
+            args.forEach((param, i) => {
+                let currentParam = void 0;
+                for (let pp in methodConfig.parameters) {
+                    let v = methodConfig.parameters[pp];
+                    if (v.index === i) {
+                        currentParam = v;
+                        break;
+                    }
+                }
+                if (currentParam.paramType === 'Path') {
+                    pathPrams[currentParam.paramName] = param;
+                }
+                if (currentParam.paramType === 'Query') {
+                    if (currentParam.paramName) {
+                        const mapping = Mapping.decode(param, !ctx.isProductionMode);
+                        if (mapping) {
+                            rest.headers.set(`${Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS}${currentParam.paramName} `, JSON.stringify(mapping));
+                        }
+                        queryParams[currentParam.paramName] = param;
+                    }
+                    else {
+                        const mapping = Mapping.decode(param, !ctx.isProductionMode);
+                        if (mapping) {
+                            rest.headers.set(Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS, JSON.stringify(mapping));
+                        }
+                        queryParams = _.cloneDeep(param);
+                    }
+                }
+                if (currentParam.paramType === 'Header') {
+                    if (currentParam.paramName) {
+                        if (currentParam.paramName === Symbols.old.MDC_KEY) {
+                            rest.headers.set(currentParam.paramName, encodeURIComponent(JSON.stringify(param)));
+                        }
+                        else {
+                            rest.headers.set(currentParam.paramName, param);
+                        }
+                    }
+                    else {
+                        for (let header in param) {
+                            rest.headers.set(header, param[header]);
+                        }
+                    }
+                }
+                if (currentParam.paramType === 'Cookie') {
+                    Resource.Cookies.write(currentParam.paramName, param, currentParam.expireInSeconds);
+                }
+                if (currentParam.paramType === 'Body') {
+                    if (currentParam.paramName) {
+                        if (ClassHelpers.getName(bodyObject) === 'FormData') {
+                            throw new Error(`[taon - framework] Don use param names when posting / putting FormData.
+              Use this:
+
+(@Taon.Http.Param.Body() formData: FormData) ...
+
+
+instead
+
+  (@Taon.Http.Param.Body('${currentParam.paramName}') formData: FormData) ...
+
+`);
+                        }
+                        const mapping = Mapping.decode(param, !ctx.isProductionMode);
+                        if (mapping) {
+                            rest.headers.set(`${Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS}${currentParam.paramName} `, JSON.stringify(mapping));
+                        }
+                        bodyObject[currentParam.paramName] = param;
+                    }
+                    else {
+                        const mapping = Mapping.decode(param, !ctx.isProductionMode);
+                        if (mapping) {
+                            rest.headers.set(Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS, JSON.stringify(mapping));
+                        }
+                        bodyObject = param;
+                    }
+                }
+            });
+            if (typeof bodyObject === 'object' &&
+                ClassHelpers.getName(bodyObject) !== 'FormData') {
+                let circuralFromItem = [];
+                bodyObject = JSON10.parse(JSON10.stringify(bodyObject, void 0, void 0, circs => {
+                    circuralFromItem = circs;
+                }));
+                rest.headers.set(Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, JSON10.stringify(circuralFromItem));
+            }
+            if (typeof queryParams === 'object') {
+                let circuralFromQueryParams = [];
+                queryParams = JSON10.parse(JSON10.stringify(queryParams, void 0, void 0, circs => {
+                    circuralFromQueryParams = circs;
+                }));
+                rest.headers.set(Symbols.old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM, JSON10.stringify(circuralFromQueryParams));
+            }
+            const httpResultObj = {
+                received: isWithBody
+                    ? rest.model(pathPrams)[method](bodyObject, [queryParams])
+                    : rest.model(pathPrams)[method]([queryParams]),
+            };
+            return httpResultObj;
+        };
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/endpoint-context.ts
+
+const globalPublicStorage = Helpers.isBrowser ? window : global;
+;
+({}); // @--end-of-file-for-module=taon lib/storage.ts
+
+const ENV = Helpers.isBrowser ? window['ENV'] : global['ENV'];
+class TaonAdmin {
+    constructor() {
+        this.scrollableEnabled = false; // TOOD false by default
+        this.onEditMode = new Subject();
+        this.onEditMode$ = this.onEditMode.asObservable();
+        this.enabledTabs = [];
+        this.scrollableEnabled = !!ENV?.useGlobalNgxScrollbar;
+    }
+    static get Instance() {
+        if (!globalPublicStorage[config.frameworkNames.taon]) {
+            globalPublicStorage[config.frameworkNames.taon] = new TaonAdmin();
+        }
+        return globalPublicStorage[config.frameworkNames.taon];
+    }
+    setEditMode(value) {
+        this.onEditMode.next(value);
+    }
+    setKeepWebsqlDbDataAfterReload(value) {
+        this.keepWebsqlDbDataAfterReload = value;
+    }
+    hide() {
+        this.draggablePopupMode = false;
+        this.adminPanelIsOpen = false;
+    }
+    show() {
+        this.draggablePopupMode = false;
+        this.adminPanelIsOpen = true;
+    }
+    logout() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.5", ngImport: i0, type: TaonAdmin, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.5", ngImport: i0, type: TaonAdmin, providedIn: 'root' }); }
+}
+__decorate([
+    Stor.property.in.localstorage.for(TaonAdmin).withDefaultValue(false),
+    __metadata("design:type", Boolean)
+], TaonAdmin.prototype, "adminPanelIsOpen", void 0);
+__decorate([
+    Stor.property.in.localstorage.for(TaonAdmin).withDefaultValue(false),
+    __metadata("design:type", Boolean)
+], TaonAdmin.prototype, "draggablePopupMode", void 0);
+__decorate([
+    Stor.property.in.localstorage.for(TaonAdmin).withDefaultValue(false),
+    __metadata("design:type", Boolean)
+], TaonAdmin.prototype, "draggablePopupModeFullScreen", void 0);
+__decorate([
+    Stor.property.in.localstorage.for(TaonAdmin).withDefaultValue(false),
+    __metadata("design:type", Boolean)
+], TaonAdmin.prototype, "keepWebsqlDbDataAfterReload", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.5", ngImport: i0, type: TaonAdmin, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+;
+({}); // @--end-of-file-for-module=taon lib/ui/taon-admin-mode-configuration/taon-admin.service.ts
+
+const createContext = (configFn) => {
+    let config = configFn(ENV$1);
+    const endpointContextRef = new EndpointContext(config, configFn);
+    const res = {
+        types: {
+            get controllers() {
+                return config.controllers;
+            },
+            get repositories() {
+                return config.repositories;
+            },
+            get providers() {
+                return config.providers;
+            },
+            get subscribers() {
+                return config.subscribers;
+            },
+        },
+        get contexts() {
+            return config.contexts;
+        },
+        get contextName() {
+            return config.contextName;
+        },
+        /**
+         * - get reference to internal context
+         */
+        async __ref() {
+            if (!endpointContextRef.inited) {
+                await endpointContextRef.init({
+                    initFromRecrusiveContextResovle: true,
+                });
+            }
+            return endpointContextRef;
+        },
+        get __refSync() {
+            return endpointContextRef;
+        },
+        getClassInstance(ctor) {
+            return endpointContextRef.getInstanceBy(ctor);
+        },
+        getClass(ctor) {
+            const classFun = endpointContextRef.getClassFunByClass(ctor);
+            return classFun;
+        },
+        /**
+         * - create controller instances for context
+         * - init database (if enable) + migation scripts
+         */
+        initialize: async () => {
+            return await new Promise(async (resolve, reject) => {
+                setTimeout(async () => {
+                    await endpointContextRef.init();
+                    if (config.abstract) {
+                        throw new Error(`Abstract context can not be initialized`);
+                    }
+                    await endpointContextRef.initEntities();
+                    await endpointContextRef.initSubscribers();
+                    await endpointContextRef.initDatabaseConnection();
+                    endpointContextRef.initMetadata();
+                    endpointContextRef.startServer();
+                    /* */
+                    /* */
+                    await endpointContextRef.initClasses();
+                    let keepWebsqlDbDataAfterReload = false;
+                    keepWebsqlDbDataAfterReload =
+                        TaonAdmin.Instance.keepWebsqlDbDataAfterReload;
+                    if (!Helpers.isNode && keepWebsqlDbDataAfterReload) {
+                        Helpers.info(`[taon] Keep websql data after reload`);
+                    }
+                    else {
+                        await endpointContextRef.reinitControllers();
+                    }
+                    resolve(endpointContextRef);
+                });
+            });
+        },
+    };
+    return res;
+};
+;
+({}); // @--end-of-file-for-module=taon lib/create-context.ts
+
+const BaseContext = createContext(() => ({
+    contextName: 'BaseContext',
+    abstract: true,
+    repositories: {
+        // @ts-ignore
+        BaseRepository,
+    },
+}));
+;
+({}); // @--end-of-file-for-module=taon lib/base-classes/base-context.ts
+
+var baseContext = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    BaseContext: BaseContext
+});
+
+class TaonSubscriberOptions extends Models.DecoratorAbstractOpt {
+}
+function TaonSubscriber(options) {
+    return function (constructor) {
+        Reflect.defineMetadata(Symbols.metadata.options.repository, options, constructor);
+        Reflect.defineMetadata(Symbols.metadata.className, options?.className || constructor.name, constructor);
+        ClassHelpers.setName(constructor, options?.className);
+        return class extends constructor {
+            constructor(...args) {
+                super(...args);
+                const methodNamesAll = ClassHelpers.getMethodsNames(constructor.prototype);
+                const methodNames = methodNamesAll.filter(m => {
+                    return (!['__trigger_event__', 'clone'].includes(m) &&
+                        !m.startsWith('_') &&
+                        !m.startsWith('inject'));
+                });
+                methodNames.forEach(methodName => {
+                    const originalMethod = this[methodName];
+                    this[methodName] = async (...methodArgs) => {
+                        const result = originalMethod.apply(this, methodArgs);
+                        if (result instanceof Promise) {
+                            await result;
+                        }
+                        if (options.allowedEvents === undefined ||
+                            options.allowedEvents.includes(methodName)) {
+                            // @ts-ignore
+                            this.__trigger_event__(methodName);
+                        }
+                        return result;
+                    };
+                });
+            }
+        };
+    };
+}
+;
+({}); // @--end-of-file-for-module=taon lib/decorators/classes/subscriber-decorator.ts
+
+let BaseSubscriber = class BaseSubscriber extends BaseInjector {
+    __trigger_event__(eventName) {
+        const ctx = this.__endpoint_context__;
+        console.log('Trigger event', eventName, ctx);
+    }
+};
+BaseSubscriber = __decorate([
+    TaonSubscriber({
+        className: 'BaseSubscriber',
+    })
+], BaseSubscriber);
+;
+({}); // @--end-of-file-for-module=taon lib/base-classes/base-subscriber.ts
+
+let BaseSubscriberForEntity = class BaseSubscriberForEntity extends BaseInjector {
+    /**
+     * Called after entity is loaded.
+     */
+    afterLoad(entity) {
+        console.log(`AFTER ENTITY LOADED: `, entity);
+    }
+    /**
+     * Called before query execution.
+     */
+    beforeQuery(event) {
+        console.log(`BEFORE QUERY: `, event.query);
+    }
+    /**
+     * Called after query execution.
+     */
+    afterQuery(event) {
+        console.log(`AFTER QUERY: `, event.query);
+    }
+    /**
+     * Called before entity insertion.
+     */
+    beforeInsert(event) {
+        console.log(`BEFORE ENTITY INSERTED: `, event.entity);
+    }
+    /**
+     * Called after entity insertion.
+     */
+    afterInsert(event) {
+        console.log(`AFTER ENTITY INSERTED: `, event.entity);
+    }
+    /**
+     * Called before entity update.
+     */
+    beforeUpdate(event) {
+        console.log(`BEFORE ENTITY UPDATED: `, event.entity);
+    }
+    /**
+     * Called after entity update.
+     */
+    afterUpdate(event) {
+        console.log(`AFTER ENTITY UPDATED: `, event.entity);
+    }
+    /**
+     * Called before entity removal.
+     */
+    beforeRemove(event) {
+        console.log(`BEFORE ENTITY WITH ID ${event.entityId} REMOVED: `, event.entity);
+    }
+    /**
+     * Called after entity removal.
+     */
+    afterRemove(event) {
+        console.log(`AFTER ENTITY WITH ID ${event.entityId} REMOVED: `, event.entity);
+    }
+    /**
+     * Called before entity removal.
+     */
+    beforeSoftRemove(event) {
+        console.log(`BEFORE ENTITY WITH ID ${event.entityId} SOFT REMOVED: `, event.entity);
+    }
+    /**
+     * Called after entity removal.
+     */
+    afterSoftRemove(event) {
+        console.log(`AFTER ENTITY WITH ID ${event.entityId} SOFT REMOVED: `, event.entity);
+    }
+    /**
+     * Called before entity recovery.
+     */
+    beforeRecover(event) {
+        console.log(`BEFORE ENTITY WITH ID ${event.entityId} RECOVERED: `, event.entity);
+    }
+    /**
+     * Called after entity recovery.
+     */
+    afterRecover(event) {
+        console.log(`AFTER ENTITY WITH ID ${event.entityId} RECOVERED: `, event.entity);
+    }
+    /**
+     * Called before transaction start.
+     */
+    beforeTransactionStart(event) {
+        console.log(`BEFORE TRANSACTION STARTED: `, event);
+    }
+    /**
+     * Called after transaction start.
+     */
+    afterTransactionStart(event) {
+        console.log(`AFTER TRANSACTION STARTED: `, event);
+    }
+    /**
+     * Called before transaction commit.
+     */
+    beforeTransactionCommit(event) {
+        console.log(`BEFORE TRANSACTION COMMITTED: `, event);
+    }
+    /**
+     * Called after transaction commit.
+     */
+    afterTransactionCommit(event) {
+        console.log(`AFTER TRANSACTION COMMITTED: `, event);
+    }
+    /**
+     * Called before transaction rollback.
+     */
+    beforeTransactionRollback(event) {
+        console.log(`BEFORE TRANSACTION ROLLBACK: `, event);
+    }
+    /**
+     * Called after transaction rollback.
+     */
+    afterTransactionRollback(event) {
+        console.log(`AFTER TRANSACTION ROLLBACK: `, event);
+    }
+};
+BaseSubscriberForEntity = __decorate([
+    TaonSubscriber({
+        className: 'BaseSubscriberForEntity',
+    })
+], BaseSubscriberForEntity);
+;
+({}); // @--end-of-file-for-module=taon lib/base-classes/base-subscriber-for-entity.ts
+
+var Base;
+(function (Base) {
+    Base.Controller = BaseController;
+    Base.CrudController = BaseCrudController;
+    Base.Entity = BaseEntity;
+    Base.AbstractEntity = BaseAbstractEntity;
+    Base.Provider = BaseProvider;
+    Base.Class = BaseClass;
+    Base.Repository = BaseRepository;
+    Base.Subscriber = BaseSubscriber;
+    Base.SubscriberForEntity = BaseSubscriberForEntity;
+    Base.Context = BaseContext;
+})(Base || (Base = {}));
+;
+({}); // @--end-of-file-for-module=taon lib/base-classes/base.ts
+
+/* */
+/* */
+function TaonEntity(options) {
+    return function (constructor) {
+        options = options || {};
+        options.uniqueKeyProp = options.uniqueKeyProp || 'id';
+        ClassHelpers.setName(constructor, options?.className);
+        Mapping.DefaultModelWithMapping(options?.defaultModelValues || {}, _.merge(options?.defaultModelMapping || {}, (options?.defaultModelMappingDeep || {})))(constructor);
+        Mapping.DefaultModelWithMapping(void 0, {})(constructor);
+        Reflect.defineMetadata(Symbols.metadata.options.entity, options, constructor);
+        Reflect.defineMetadata(Symbols.metadata.className, options?.className || constructor.name, constructor);
+        /* */
+        /* */
+        CLASS.setName(constructor, options?.className); // TODO QUICK_FIX for ng2-rest
+    };
+}
+class TaonEntityOptions extends Models.DecoratorAbstractOpt {
+}
+;
+({}); // @--end-of-file-for-module=taon lib/decorators/classes/entity-decorator.ts
+
+function TaonProvider(options) {
+    return function (constructor) {
+        Reflect.defineMetadata(Symbols.metadata.options.provider, options, constructor);
+        Reflect.defineMetadata(Symbols.metadata.className, options?.className || constructor.name, constructor);
+        ClassHelpers.setName(constructor, options?.className || constructor.name);
+    };
+}
+class TaonProviderOptions extends Models.DecoratorAbstractOpt {
+}
+;
+({}); // @--end-of-file-for-module=taon lib/decorators/classes/provider-decorator.ts
+
+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);
+                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];
+                return methodOrProperty;
+            }
+            return inject$1(ctor)[propName];
+        },
+    });
+};
+const injectController = inject;
+const injectSubscriberEvents = (subscriberClassResolveFn, eventName) => {
+    const eventsSrc = new Subject();
+    const obs = eventsSrc.asObservable();
+    let isFirstSubscription = true;
+    const proxiedObservable = new Proxy(obs, {
+        get(target, prop, receiver) {
+            if (prop === 'subscribe') {
+                return (...args) => {
+                    if (isFirstSubscription) {
+                        isFirstSubscription = false;
+                        const subscriberClassFN = subscriberClassResolveFn();
+                        const ctx = subscriberClassFN[Symbols.ctxInClassOrClassObj];
+                        if (!ctx) {
+                            throw new Error(`You are trying to inject class without context. Use context like this;
+
+              Taon.injectSubscriberEvents( ()=> ` +
+                                `MyContext.getInstance(${subscriberClassFN?.name}), '${eventName}' )
+
+
+              `);
+                        }
+                        const subscriberInstance = ctx.getInstanceBy(subscriberClassFN);
+                        console.log('First subscription, you can access arguments here:', {
+                            subscriberClassFN,
+                            eventName,
+                        });
+                    }
+                    return target.subscribe(...args);
+                };
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+    return proxiedObservable;
+};
+;
+({}); // @--end-of-file-for-module=taon lib/inject.ts
+
+;
+({}); // @--end-of-file-for-module=taon lib/constants.ts
+
+var Taon;
+(function (Taon) {
+    Taon.Http = Http;
+    Taon.Base = Base;
+    Taon.getResponseValue = getResponseValue;
+    Taon.Controller = TaonController;
+    Taon.Entity = TaonEntity;
+    Taon.Provider = TaonProvider;
+    Taon.Repository = TaonRepository;
+    Taon.Subscriber = TaonSubscriber;
+    /**
+     * @deprecated
+     */
+    Taon.isBrowser = coreHelpers.Helpers.isBrowser;
+    /**
+     * @deprecated
+     */
+    Taon.isNode = coreHelpers.Helpers.isNode;
+    /**
+     * @deprecated
+     */
+    Taon.isWebSQL = coreHelpers.Helpers.isWebSQL;
+    /**
+     * @deprecated
+     */
+    Taon.isElectron = coreHelpers.Helpers.isElectron;
+    Taon.createContext = createContext;
+    Taon.inject = inject;
+    Taon.initNgZone = (ngZone) => {
+        EndpointContext.initNgZone(ngZone);
+    };
+    Taon.symbols = Symbols;
+    /**
+     * @deprecated
+     * use createContext instead
+     */
+    Taon.init = async (options) => {
+        const BaseContext = (await Promise.resolve().then(function () { return baseContext; }))
+            .BaseContext;
+        const context = Taon.createContext(() => ({
+            contextName: 'default',
+            host: options.host,
+            contexts: { BaseContext },
+            database: true,
+            entities: Array.from(options.entities),
+            controllers: Array.from(options.controllers),
+        }));
+        await context.initialize();
+        return context;
+    };
+})(Taon || (Taon = {}));
+;
+({}); // @--end-of-file-for-module=taon lib/index.ts
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BaseContext, BaseController, BaseEntity, BaseProvider, BaseRepository, BaseSubscriber, ClassHelpers, Models, Taon, createContext, inject };
+//# sourceMappingURL=taon.mjs.map