taon 0.0.0 → 18.0.12

package/websql/esm2022/lib/endpoint-context.mjs

@@ -0,0 +1,1506 @@
+/* eslint-disable @typescript-eslint/typedef */
+import { EventSubscriber } from 'taon-typeorm/websql';
+import { Entity as TypeormEntity } from 'taon-typeorm/websql';
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+import { TaonAdmin } from './ui/taon-admin-mode-configuration/taon-admin.service';
+import { Models } from './models';
+import { ClassHelpers } from './helpers/class-helpers';
+import { Symbols } from './symbols';
+import { _, Helpers } from 'tnp-core/websql';
+import { DITaonContainer } from './dependency-injection/di-container';
+import { TaonHelpers } from './helpers/taon-helpers';
+import { Mapping, Models as ModelsNg2Rest, Resource, RestHeaders, } from 'ng2-rest/websql'; /* */
+/* */
+/* */
+/* */
+/* */
+import { JSON10 } from 'json10/websql';
+import { path } from 'tnp-core/websql';
+import { from, Subject } from 'rxjs';
+import { getResponseValue } from './get-response-value';
+import axios from 'axios';
+import { DataSource, } from 'taon-typeorm/websql'; /* */
+import { ENV } from './env';
+import { RealtimeCore } from './realtime/realtime-core';
+import { BaseSubscriberForEntity } from './base-classes/base-subscriber-for-entity';
+export 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);
+        if (this.config.host) {
+            this.mode = 'backend-frontend(tcp+udp)';
+            this.mode = 'backend-frontend(websql)';
+        }
+        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() {
+        let databaseConfig;
+        if (Helpers.isRunningInDocker()) {
+            Helpers.info('Running in docker, using in mysql database');
+            databaseConfig = {
+                database: `tmp-db-${_.kebabCase(this.contextName)}.sqljs.db`,
+                type: 'mysql',
+                autoSave: true,
+                synchronize: true,
+                dropSchema: true,
+                logging: this.logDb,
+                databasePort: 3306,
+                databaseHost: 'localhost',
+                databaseUsername: 'root',
+                databasePassword: 'admin',
+            };
+        }
+        else {
+            this.logFramework &&
+                Helpers.info(`[taon][database] Automatically resolving database config for mode ${this.mode}`);
+            switch (this.mode) {
+                case 'backend-frontend(ipc-electron)':
+                    return {
+                        location: `tmp-db-${_.kebabCase(this.contextName)}.sqljs`,
+                        type: 'sqljs',
+                        autoSave: true,
+                        synchronize: true,
+                        dropSchema: true,
+                        logging: this.logDb,
+                    };
+                    break;
+                case 'backend-frontend(websql)':
+                    databaseConfig = {
+                        location: `tmp-db-${_.kebabCase(this.contextName)}.sqljs`,
+                        type: 'sqljs',
+                        useLocalForage: true, // !!window['localforage'], // TODO this need to be checked in runtime
+                        autoSave: true,
+                        synchronize: true,
+                        dropSchema: true,
+                        logging: this.logDb,
+                    };
+                    let keepWebsqlDbDataAfterReload = false;
+                    keepWebsqlDbDataAfterReload =
+                        TaonAdmin.Instance.keepWebsqlDbDataAfterReload;
+                    if (keepWebsqlDbDataAfterReload) {
+                        databaseConfig.dropSchema = false;
+                        delete databaseConfig.synchronize; // false is not auto synchonize - from what I understand
+                    }
+                    else {
+                        databaseConfig.dropSchema = true;
+                        databaseConfig.synchronize = true;
+                    }
+                    break;
+                case 'backend-frontend(tcp+udp)':
+                    databaseConfig = {
+                        database: `context-db-${_.kebabCase(this.contextName)}`,
+                        location: `tmp-db-${_.kebabCase(this.contextName)}.sqlite`,
+                        type: 'sqljs',
+                        autoSave: true,
+                        synchronize: true,
+                        dropSchema: true,
+                        logging: this.logDb,
+                    };
+                    break;
+            }
+        }
+        return databaseConfig;
+    }
+    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
+        if (!this.connection?.initialize) {
+            return;
+        }
+        const subscribers = this.getClassFunByArr(Models.ClassType.SUBSCRIBER);
+        for (const subscriber of subscribers) {
+            const options = Reflect.getMetadata(Symbols.metadata.options.subscriber, subscriber);
+            EventSubscriber()(subscriber);
+        }
+        console.log(this.config.subscribers);
+        return;
+        const entities = this.getClassFunByArr(Models.ClassType.ENTITY);
+        for (let index = 0; index < entities.length; index++) {
+        }
+    }
+    async initEntities() {
+        const entities = this.getClassFunByArr(Models.ClassType.ENTITY);
+        for (const entity of entities) {
+            const options = Reflect.getMetadata(Symbols.metadata.options.entity, entity);
+            const createTable = _.isUndefined(options.createTable)
+                ? true
+                : options.createTable;
+            const nameForEntity = ClassHelpers.getName(entity);
+            if (_.isUndefined(options.createTable) ? true : options.createTable) {
+                this.logDb &&
+                    console.info(`[taon][typeorm] create table for entity "${nameForEntity}" ? '${createTable}'`);
+                TypeormEntity(nameForEntity)(entity);
+            }
+            else {
+                this.logDb &&
+                    console.info(`[taon][typeorm] create table for entity "${nameForEntity}" ? '${createTable}'`);
+            }
+        }
+    }
+    async initDatabaseConnection() {
+        const entities = (this.config.override?.entities
+            ? this.config.override.entities
+            : this.getClassFunByArr(Models.ClassType.ENTITY)).map(entityFn => {
+            return ClassHelpers.getOrginalClass(entityFn);
+        });
+        const subscribers = (this.config.override?.subscribers
+            ? this.config.override.subscribers
+            : this.getClassFunByArr(Models.ClassType.SUBSCRIBER)).filter(f => f instanceof BaseSubscriberForEntity);
+        const dataSourceDbConfig = _.isObject(this.databaseConfig)
+            ? {
+                type: this.databaseConfig.type,
+                port: this.databaseConfig.databasePort,
+                host: this.databaseConfig.databaseHost,
+                database: this.databaseConfig.database,
+                username: this.databaseConfig.databaseUsername,
+                password: this.databaseConfig.databasePassword,
+                useLocalForage: this.databaseConfig.useLocalForage,
+                entities,
+                subscribers,
+                synchronize: this.databaseConfig.synchronize,
+                autoSave: this.databaseConfig.autoSave,
+                dropSchema: this.databaseConfig.dropSchema,
+                logging: !!this.databaseConfig.logging,
+                location: this.databaseConfig.location,
+            }
+            : {};
+        if (this.modeAllowsDatabaseCreation && this.databaseConfig) {
+            this.logDb &&
+                this.logFramework &&
+                Helpers.info('[taon][database] prepare typeorm connection...');
+            try {
+                const connection = new DataSource(dataSourceDbConfig);
+                this.connection = connection;
+                await this.connection.initialize();
+            }
+            catch (error) {
+                console.error(error?.message || error);
+            }
+            if (!this.connection?.isInitialized) {
+                console.log('WRONG CONFIG', dataSourceDbConfig);
+                throw new Error(`Something wrong with connection init in ${this.mode}`);
+                /* */
+                /* */
+            }
+            (this.logDb || this.logFramework) &&
+                console.info(`
+
+        CONTECTION OK for ${this.contextName} - ${this.mode}
+
+        [taon][typeorm] db prepration done.. db initialize=${this.connection?.isInitialized}
+
+
+        `, dataSourceDbConfig);
+        }
+        else {
+            Helpers.info(`[taon][typeorm] Not initing db for mode ${this.mode}`);
+        }
+    }
+    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 { routePath, method } = this.initServer(type, methodConfig, classConfig, expressPath, controllerClassFn);
+                    this.activeRoutes.push({
+                        routePath,
+                        method,
+                    });
+                }
+                const shouldInitClient = Helpers.isBrowser || this.remoteHost || Helpers.isWebSQL;
+                if (shouldInitClient) {
+                    this.initClient(controllerClassFn, type, methodConfig, expressPath);
+                }
+            });
+            /* */
+            /* */
+            this.logHttp && console.groupEnd();
+            /* */
+            /* */
+        }
+    }
+    writeActiveRoutes() {
+        const contexts = [this];
+        const troutes = this.activeRoutes.map(({ method, routePath }) => {
+            return (TaonHelpers.fillUpTo(method.toUpperCase() + ':', 10) +
+                this.uri.href.replace(/\/$/, '') +
+                routePath);
+        });
+        const routes = [
+            ...['', `---------- FOR HOST ${this.uri.href} ----------`],
+            ...troutes,
+        ];
+        const fileName = path.join(
+        /* */
+        /* */
+        `tmp-routes-${_.kebabCase(this.config.contextName)}.json`);
+        this.logFramework && console.log(`[taon] routes file: ${fileName} `);
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+    }
+    get middlewares() {
+        /* */
+        /* */
+        return (void 0);
+    }
+    initMidleware() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+    }
+    initServer(type, methodConfig, classConfig, expressPath, target) {
+        const requestHandler = methodConfig.requestHandler &&
+            typeof methodConfig.requestHandler === 'function'
+            ? methodConfig.requestHandler
+            : (req, res, next) => {
+                next();
+            };
+        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) {
+            if (Helpers.isWebSQL) {
+                if (!this.expressApp[type.toLowerCase()]) {
+                    this.expressApp[type.toLowerCase()] = () => { };
+                }
+            }
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+        }
+        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 ModelsNg2Rest.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;
+        }
+        const MIN_TIMEOUT = 500;
+        const MIN_TIMEOUT_STEP = 200;
+        const timeout = window[Symbols.old.WEBSQL_REST_PROGRESS_TIMEOUT] || MIN_TIMEOUT;
+        let updateFun = window[Symbols.old.WEBSQL_REST_PROGRESS_FUN];
+        if (!window[Symbols.old.WEBSQL_REST_PROGRESS_FUN]) {
+            window[Symbols.old.WEBSQL_REST_PROGRESS_FUN] = new Subject();
+        }
+        updateFun = window[Symbols.old.WEBSQL_REST_PROGRESS_FUN];
+        let startFun = window[Symbols.old.WEBSQL_REST_PROGRESS_FUN_START];
+        if (!window[Symbols.old.WEBSQL_REST_PROGRESS_FUN_START]) {
+            window[Symbols.old.WEBSQL_REST_PROGRESS_FUN_START] = new Subject();
+        }
+        startFun = window[Symbols.old.WEBSQL_REST_PROGRESS_FUN_START];
+        let doneFun = window[Symbols.old.WEBSQL_REST_PROGRESS_FUN_DONE];
+        if (!window[Symbols.old.WEBSQL_REST_PROGRESS_FUN_DONE]) {
+            window[Symbols.old.WEBSQL_REST_PROGRESS_FUN_DONE] = new Subject();
+        }
+        doneFun = window[Symbols.old.WEBSQL_REST_PROGRESS_FUN_DONE];
+        let periodsToUpdate = 0;
+        if (timeout >= MIN_TIMEOUT) {
+            periodsToUpdate = Math.floor(timeout / MIN_TIMEOUT_STEP);
+        }
+        const periods = async () => {
+            startFun.next();
+            for (let n = 1; n <= periodsToUpdate; n++) {
+                let upValue = Math.round(((MIN_TIMEOUT_STEP * n) / timeout) * 100);
+                if (upValue > 100) {
+                    upValue = 100;
+                }
+                updateFun.next(upValue);
+                await new Promise((resolve, reject) => {
+                    setTimeout(() => {
+                        resolve(void 0);
+                    }, MIN_TIMEOUT_STEP);
+                });
+            }
+            doneFun.next();
+        };
+        target.prototype[methodConfig.methodName] = function (...args) {
+            const received = new Promise(async (resolve, reject) => {
+                const headers = {};
+                const { request, response } = TaonHelpers.websqlMocks(headers);
+                let res;
+                try {
+                    res = await Helpers.runSyncOrAsync({
+                        functionFn: orgMethods,
+                        context: this,
+                        arrayOfParams: args,
+                    });
+                    if (typeof res === 'function') {
+                        res = await Helpers.runSyncOrAsync({
+                            functionFn: res,
+                            context: this,
+                            arrayOfParams: [request, response],
+                        });
+                    }
+                    if (typeof res === 'function') {
+                        res = await Helpers.runSyncOrAsync({
+                            functionFn: res,
+                            context: this,
+                            arrayOfParams: [request, response],
+                        });
+                    }
+                    if (typeof res === 'object' && res?.received) {
+                        res = await res.received;
+                    }
+                    const body = res;
+                    res = new ModelsNg2Rest.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);
+                    await periods();
+                    resolve(res);
+                }
+                catch (error) {
+                    await periods();
+                    console.error(error);
+                    reject(error);
+                }
+            });
+            received['observable'] = from(received);
+            if (Helpers.isWebSQL) {
+                return {
+                    received,
+                };
+            }
+        };
+        if (Helpers.isWebSQL) {
+            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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"endpoint-context.js","sourceRoot":"","sources":["../../../../tmp-libs-for-dist-websql/taon/projects/taon/src/lib/endpoint-context.ts"],"names":[],"mappings":"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K;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;QAED,CAAC;QAED,OAAO;YACL,SAAS,EAAE,WAAW;YACtB,MAAM,EAAE,YAAY,CAAC,IAAI;SAC1B,CAAC;IACJ,CAAC;IAID;;OAEG;IACK,UAAU,CAEhB,MAAgB,EAChB,IAAiC,EACjC,YAA2C,EAC3C,WAAmB;QAGnB,MAAM,GAAG,GAAG,IAAI,CAAC;QAEjB,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,WAAW,EAAE,IAAI,WAAW,GAAG,CAAC,CAAC;QAGtE,IAAI,OAAY,CAAC;QACjB,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;YACtB,OAAO,GAAG,MAAM,CAAC;QACnB,CAAC;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QAID,MAAM,UAAU,GAAG,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;QAI7D,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;YACvB,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,UAAU,CAAC,GAAG,UAAU,GAAG,IAAI;gBAC3D,MAAM,QAAQ,GAAG,IAAI,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE;oBACrD,MAAM,OAAO,GAAG,EAAE,CAAC;oBACnB,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,WAAW,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;oBAE/D,OAAO,CAAC,WAAW,CAAC,IAAI,CACtB,WAAW,CAAC,kBAAkB,CAC5B,MAAM,EACN,YAAY,EACZ,WAAW,CACZ,EACD,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE;wBACtB,IAAI,GAAG,GAAQ,YAAY,CAAC;wBAC5B,OAAO,CAAC,GAAG,CAAC,EAAE,YAAY,EAAE,CAAC,CAAC;wBAC9B,IAAI,CAAC;4BACH,MAAM,IAAI,GAAG,GAAG,CAAC;4BACjB,GAAG,GAAG,IAAI,aAAa,CAAC,YAAY,CAClC;gCACE,IAAI,EAAE,KAAK,CAAC;gCACZ,OAAO,EAAE,KAAK,CAAQ;gCACtB,MAAM,EAAE,YAAY,CAAC,IAAI;gCACzB,GAAG,EAAE,GAAG,GAAG,CAAC,GAAG,CAAC,MAAM,GACpB,EAAE,CAAC,oBAAoB;gCACzB,GAAG,YAAY,CAAC,IAAI,GAAG;6BACxB,EACD,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC;gCACtC,CAAC,CAAC,IAAI;gCACN,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EACxB,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,EACzB,KAAK,CAAC,EACN,GAAG,EAAE,CAAC,IAAI,CACX,CAAC;4BAEF,OAAO,CAAC,GAAG,CAAC,CAAC;wBACf,CAAC;wBAAC,OAAO,KAAK,EAAE,CAAC;4BACf,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;4BACrB,MAAM,CAAC,KAAK,CAAC,CAAC;wBAChB,CAAC;oBACH,CAAC,CACF,CAAC;oBACF,OAAO,CAAC,WAAW,CAAC,IAAI,CACtB,WAAW,CAAC,iBAAiB,CAAC,MAAM,EAAE,YAAY,EAAE,WAAW,CAAC,EAChE,IAAI,CACL,CAAC;gBACJ,CAAC,CAAC,CAAC;gBACH,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACxC,OAAO;oBACL,QAAQ;iBACT,CAAC;YACJ,CAAC,CAAC;YACF,OAAO;QACT,CAAC;QAOD,MAAM,WAAW,GAAG,GAAG,CAAC;QACxB,MAAM,gBAAgB,GAAG,GAAG,CAAC;QAC7B,MAAM,OAAO,GACX,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,4BAA4B,CAAC,IAAI,WAAW,CAAC;QAElE,IAAI,SAAS,GACX,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;QAC/C,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,EAAE,CAAC;YAClD,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,GAAG,IAAI,OAAO,EAAE,CAAC;QAC/D,CAAC;QACD,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;QAEzD,IAAI,QAAQ,GACV,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC,CAAC;QACrD,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC,EAAE,CAAC;YACxD,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC,GAAG,IAAI,OAAO,EAAE,CAAC;QACrE,CAAC;QACD,QAAQ,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC,CAAC;QAE9D,IAAI,OAAO,GACT,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,6BAA6B,CAAC,CAAC;QACpD,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,6BAA6B,CAAC,EAAE,CAAC;YACvD,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,6BAA6B,CAAC,GAAG,IAAI,OAAO,EAAE,CAAC;QACpE,CAAC;QACD,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,6BAA6B,CAAC,CAAC;QAE5D,IAAI,eAAe,GAAG,CAAC,CAAC;QACxB,IAAI,OAAO,IAAI,WAAW,EAAE,CAAC;YAC3B,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,gBAAgB,CAAC,CAAC;QAC3D,CAAC;QAID,MAAM,OAAO,GAAG,KAAK,IAAI,EAAE;YACzB,QAAQ,CAAC,IAAI,EAAE,CAAC;YAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,eAAe,EAAE,CAAC,EAAE,EAAE,CAAC;gBAI1C,IAAI,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,gBAAgB,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC;gBACnE,IAAI,OAAO,GAAG,GAAG,EAAE,CAAC;oBAClB,OAAO,GAAG,GAAG,CAAC;gBAChB,CAAC;gBAED,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBAExB,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;oBACpC,UAAU,CAAC,GAAG,EAAE;wBACd,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;oBAClB,CAAC,EAAE,gBAAgB,CAAC,CAAC;gBACvB,CAAC,CAAC,CAAC;YAEL,CAAC;YACD,OAAO,CAAC,IAAI,EAAE,CAAC;QACjB,CAAC,CAAC;QAGF,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,UAAU,CAAC,GAAG,UAAU,GAAG,IAAI;YAI3D,MAAM,QAAQ,GAAG,IAAI,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE;gBACrD,MAAM,OAAO,GAAG,EAAE,CAAC;gBACnB,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,WAAW,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;gBAE/D,IAAI,GAAQ,CAAC;gBACb,IAAI,CAAC;oBACH,GAAG,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC;wBACjC,UAAU,EAAE,UAAU;wBACtB,OAAO,EAAE,IAAI;wBACb,aAAa,EAAE,IAAI;qBACpB,CAAC,CAAC;oBAEH,IAAI,OAAO,GAAG,KAAK,UAAU,EAAE,CAAC;wBAC9B,GAAG,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC;4BACjC,UAAU,EAAE,GAAG;4BACf,OAAO,EAAE,IAAI;4BACb,aAAa,EAAE,CAAC,OAAO,EAAE,QAAQ,CAAC;yBACnC,CAAC,CAAC;oBACL,CAAC;oBAED,IAAI,OAAO,GAAG,KAAK,UAAU,EAAE,CAAC;wBAC9B,GAAG,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC;4BACjC,UAAU,EAAE,GAAG;4BACf,OAAO,EAAE,IAAI;4BACb,aAAa,EAAE,CAAC,OAAO,EAAE,QAAQ,CAAC;yBACnC,CAAC,CAAC;oBACL,CAAC;oBAGD,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,EAAE,QAAQ,EAAE,CAAC;wBAC7C,GAAG,GAAG,MAAM,GAAG,CAAC,QAAQ,CAAC;oBAC3B,CAAC;oBAED,MAAM,IAAI,GAAG,GAAG,CAAC;oBAEjB,GAAG,GAAG,IAAI,aAAa,CAAC,YAAY,CAClC;wBACE,IAAI,EAAE,KAAK,CAAC;wBACZ,OAAO,EAAE,KAAK,CAAQ;wBACtB,MAAM,EAAE,YAAY,CAAC,IAAI;wBACzB,GAAG,EAAE,GAAG,GAAG,CAAC,GAAG,CAAC,MAAM,GACpB,EAAE,CAAC,oBAAoB;wBACzB,GAAG,YAAY,CAAC,IAAI,GAAG;qBACxB,EACD,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC;wBACtC,CAAC,CAAC,IAAI;wBACN,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EACxB,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,EACzB,KAAK,CAAC,EACN,GAAG,EAAE,CAAC,IAAI,CACX,CAAC;oBAMF,MAAM,OAAO,EAAE,CAAC;oBAChB,OAAO,CAAC,GAAG,CAAC,CAAC;gBACf,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,OAAO,EAAE,CAAC;oBAChB,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;oBAIrB,MAAM,CAAC,KAAK,CAAC,CAAC;gBAChB,CAAC;YACH,CAAC,CAAC,CAAC;YACH,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;YAExC,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;gBACrB,OAAO;oBACL,QAAQ;iBACT,CAAC;YACJ,CAAC;QACH,CAAC,CAAC;QACF,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;YACrB,OAAO;QACT,CAAC;QAMD,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,UAAU,CAAC,GAAG,UAAoB,GAAG,IAAI;YAMrE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC;gBAC5C,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,GAAG,EAAE,CAAC;YACjD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC;gBAC1D,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YAC/D,MAAM,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;YAC5D,IAAI,IAA2C,CAAC;YAChD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,WAAW,CAAC,EAAE,CAAC;gBAC1C,IAAI,OAAO,GAAG,EAAE,CAAC;gBACjB,IAAI,YAAY,CAAC,WAAW,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC;oBAC3D,IAAI,GAAG,QAAQ,CAAC,MAAM,CACpB,GAAG,CAAC,GAAG,CAAC,IAAI,EACZ,WAAW,EACX,OAAO,CAAC,GAAG,CAAC,qBAA4B,EACxC,OAAO,CAAC,GAAG,CAAC,yBAAgC,EAC5C,WAAW,CAAC,IAAI,CAAC;wBACf,cAAc,EAAE,YAAY,CAAC,WAAW;wBACxC,MAAM,EAAE,YAAY,CAAC,WAAW;qBACjC,CAAC,CACH,CAAC;gBACJ,CAAC;qBAAM,IAAI,YAAY,CAAC,WAAW,IAAI,YAAY,CAAC,YAAY,EAAE,CAAC;oBACjE,IAAI,GAAG,QAAQ,CAAC,MAAM,CACpB,GAAG,CAAC,GAAG,CAAC,IAAI,EACZ,WAAW,EACX,OAAO,CAAC,GAAG,CAAC,qBAA4B,EACxC,OAAO,CAAC,GAAG,CAAC,yBAAgC,EAC5C,WAAW,CAAC,IAAI,CAAC;wBACf,cAAc,EAAE,YAAY,CAAC,WAAW;wBACxC,MAAM,EAAE,YAAY,CAAC,WAAW;wBAChC,iBAAiB,EAAE,YAAY,CAAC,YAAY;qBAC7C,CAAC,CACH,CAAC;gBACJ,CAAC;qBAAM,IAAI,CAAC,YAAY,CAAC,WAAW,IAAI,YAAY,CAAC,YAAY,EAAE,CAAC;oBAClE,IAAI,GAAG,QAAQ,CAAC,MAAM,CACpB,GAAG,CAAC,GAAG,CAAC,IAAI,EACZ,WAAW,EACX,OAAO,CAAC,GAAG,CAAC,qBAA4B,EACxC,OAAO,CAAC,GAAG,CAAC,yBAAgC,EAC5C,WAAW,CAAC,IAAI,CAAC;wBACf,iBAAiB,EAAE,YAAY,CAAC,YAAY;qBAC7C,CAAC,CACH,CAAC;gBACJ,CAAC;qBAAM,CAAC;oBACN,IAAI,GAAG,QAAQ,CAAC,MAAM,CACpB,GAAG,CAAC,GAAG,CAAC,IAAI,EACZ,WAAW,EACX,OAAO,CAAC,GAAG,CAAC,qBAA4B,EACxC,OAAO,CAAC,GAAG,CAAC,yBAAgC,CAC7C,CAAC;gBACJ,CAAC;gBAED,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;YAC9C,CAAC;iBAAM,CAAC;gBACN,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,WAAW,CAAQ,CAAC;YACrD,CAAC;YAED,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;YAClC,MAAM,UAAU,GAAG,MAAM,KAAK,KAAK,IAAI,MAAM,KAAK,MAAM,CAAC;YACzD,MAAM,SAAS,GAAG,EAAE,CAAC;YACrB,IAAI,WAAW,GAAG,EAAE,CAAC;YACrB,IAAI,UAAU,GAAG,EAAE,CAAC;YACpB,IAAI,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;gBACxB,IAAI,YAAY,GAAiC,KAAK,CAAQ,CAAC;gBAE/D,KAAK,IAAI,EAAE,IAAI,YAAY,CAAC,UAAU,EAAE,CAAC;oBACvC,IAAI,CAAC,GAAG,YAAY,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;oBACpC,IAAI,CAAC,CAAC,KAAK,KAAK,CAAC,EAAE,CAAC;wBAClB,YAAY,GAAG,CAAC,CAAC;wBACjB,MAAM;oBACR,CAAC;gBACH,CAAC;gBAED,IAAI,YAAY,CAAC,SAAS,KAAK,MAAM,EAAE,CAAC;oBACtC,SAAS,CAAC,YAAY,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC;gBAC5C,CAAC;gBACD,IAAI,YAAY,CAAC,SAAS,KAAK,OAAO,EAAE,CAAC;oBACvC,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC;wBAC3B,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;wBAC7D,IAAI,OAAO,EAAE,CAAC;4BACZ,IAAI,CAAC,OAAO,CAAC,GAAG,CACd,GAAG,OAAO,CAAC,GAAG,CAAC,kCAAkC,GAAG,YAAY,CAAC,SAAS,GAAG,EAC7E,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CACxB,CAAC;wBACJ,CAAC;wBACD,WAAW,CAAC,YAAY,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC;oBAC9C,CAAC;yBAAM,CAAC;wBACN,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;wBAC7D,IAAI,OAAO,EAAE,CAAC;4BACZ,IAAI,CAAC,OAAO,CAAC,GAAG,CACd,OAAO,CAAC,GAAG,CAAC,kCAAkC,EAC9C,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CACxB,CAAC;wBACJ,CAAC;wBACD,WAAW,GAAG,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;oBACnC,CAAC;gBACH,CAAC;gBACD,IAAI,YAAY,CAAC,SAAS,KAAK,QAAQ,EAAE,CAAC;oBACxC,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC;wBAC3B,IAAI,YAAY,CAAC,SAAS,KAAK,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;4BAEnD,IAAI,CAAC,OAAO,CAAC,GAAG,CACd,YAAY,CAAC,SAAS,EACtB,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAC1C,CAAC;wBACJ,CAAC;6BAAM,CAAC;4BACN,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;wBAClD,CAAC;oBACH,CAAC;yBAAM,CAAC;wBACN,KAAK,IAAI,MAAM,IAAI,KAAK,EAAE,CAAC;4BACzB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;wBAC1C,CAAC;oBACH,CAAC;gBACH,CAAC;gBACD,IAAI,YAAY,CAAC,SAAS,KAAK,QAAQ,EAAE,CAAC;oBACxC,QAAQ,CAAC,OAAO,CAAC,KAAK,CACpB,YAAY,CAAC,SAAS,EACtB,KAAK,EACL,YAAY,CAAC,eAAe,CAC7B,CAAC;gBACJ,CAAC;gBACD,IAAI,YAAY,CAAC,SAAS,KAAK,MAAM,EAAE,CAAC;oBACtC,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC;wBAC3B,IAAI,YAAY,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,UAAU,EAAE,CAAC;4BACpD,MAAM,IAAI,KAAK,CAAC;;;;;;;;4BAQF,YAAY,CAAC,SAAS;;CAEjD,CAAC,CAAC;wBACS,CAAC;wBACD,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;wBAC7D,IAAI,OAAO,EAAE,CAAC;4BACZ,IAAI,CAAC,OAAO,CAAC,GAAG,CACd,GAAG,OAAO,CAAC,GAAG,CAAC,iCAAiC,GAAG,YAAY,CAAC,SAAS,GAAG,EAC5E,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CACxB,CAAC;wBACJ,CAAC;wBACD,UAAU,CAAC,YAAY,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC;oBAC7C,CAAC;yBAAM,CAAC;wBACN,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;wBAC7D,IAAI,OAAO,EAAE,CAAC;4BACZ,IAAI,CAAC,OAAO,CAAC,GAAG,CACd,OAAO,CAAC,GAAG,CAAC,iCAAiC,EAC7C,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CACxB,CAAC;wBACJ,CAAC;wBACD,UAAU,GAAG,KAAK,CAAC;oBACrB,CAAC;gBACH,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,IACE,OAAO,UAAU,KAAK,QAAQ;gBAC9B,YAAY,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,UAAU,EAC/C,CAAC;gBACD,IAAI,gBAAgB,GAAG,EAAE,CAAC;gBAC1B,UAAU,GAAG,MAAM,CAAC,KAAK,CACvB,MAAM,CAAC,SAAS,CAAC,UAAU,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,EAAE;oBACnD,gBAAgB,GAAG,KAAK,CAAC;gBAC3B,CAAC,CAAC,CACH,CAAC;gBACF,IAAI,CAAC,OAAO,CAAC,GAAG,CACd,OAAO,CAAC,GAAG,CAAC,yBAAyB,EACrC,MAAM,CAAC,SAAS,CAAC,gBAAgB,CAAC,CACnC,CAAC;YACJ,CAAC;YAED,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE,CAAC;gBACpC,IAAI,uBAAuB,GAAG,EAAE,CAAC;gBACjC,WAAW,GAAG,MAAM,CAAC,KAAK,CACxB,MAAM,CAAC,SAAS,CAAC,WAAW,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,EAAE;oBACpD,uBAAuB,GAAG,KAAK,CAAC;gBAClC,CAAC,CAAC,CACH,CAAC;gBAEF,IAAI,CAAC,OAAO,CAAC,GAAG,CACd,OAAO,CAAC,GAAG,CAAC,gCAAgC,EAC5C,MAAM,CAAC,SAAS,CAAC,uBAAuB,CAAC,CAC1C,CAAC;YACJ,CAAC;YAGD,MAAM,aAAa,GAAG;gBACpB,QAAQ,EAAE,UAAU;oBAClB,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC,UAAU,EAAE,CAAC,WAAW,CAAC,CAAC;oBAC1D,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;aACjD,CAAC;YACF,OAAO,aAAa,CAAC;QACvB,CAAC,CAAC;IAEJ,CAAC;CAEF;AAEA,CAAC;AAAA,CAAC,EAAE,CAAC,CAAC,CAAC,yDAAyD","sourcesContent":["\n\n/* eslint-disable @typescript-eslint/typedef */\n\n\nimport { EventSubscriber } from 'taon-typeorm/websql';\nimport type {\n  TransactionRollbackEvent,\n  TransactionCommitEvent,\n  TransactionStartEvent,\n  RecoverEvent,\n  SoftRemoveEvent,\n  RemoveEvent,\n  UpdateEvent,\n  InsertEvent,\n} from 'taon-typeorm';\nimport { Entity as TypeormEntity, Tree } from 'taon-typeorm/websql';\n\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n  \n\nimport { TaonAdmin } from './ui/taon-admin-mode-configuration/taon-admin.service';\n\nimport { Models } from './models';\nimport { ClassHelpers } from './helpers/class-helpers';\nimport { Symbols } from './symbols';\nimport { _, Helpers } from 'tnp-core/websql';\nimport type { createContext } from './create-context';\nimport { DITaonContainer } from './dependency-injection/di-container';\nimport { TaonControllerOptions } from './decorators/classes/controller-decorator';\nimport { TaonHelpers } from './helpers/taon-helpers';\nimport {   Mapping,   Models as ModelsNg2Rest,   Resource,   RestHeaders, } from 'ng2-rest/websql';/* */\n/* */\n/* */\n/* */\n/* */\n\nimport { JSON10 } from 'json10/websql';\nimport { path } from 'tnp-core/websql';\nimport { from, Subject } from 'rxjs';\nimport { EntityProcess } from './entity-process';\nimport { getResponseValue } from './get-response-value';\nimport type { Application } from 'express';\nimport axios from 'axios';\nimport type { NgZone } from '@angular/core';\n\nimport {   DataSource,   DataSourceOptions,   getMetadataArgsStorage, } from 'taon-typeorm/websql';/* */\n/* */\n/* */\n/* */\n\nimport { TaonEntityOptions } from './decorators/classes/entity-decorator';\nimport type { Server } from 'http';\nimport { ENV } from './env';\nimport type { BaseClass } from './base-classes/base-class';\nimport { RealtimeCore } from './realtime/realtime-core';\nimport { TaonSubscriberOptions } from './decorators/classes/subscriber-decorator';\nimport { BaseSubscriberForEntity } from './base-classes/base-subscriber-for-entity';\n\n\nexport class EndpointContext {\n\n\n\n  private static ngZone: NgZone;\n\n  static initNgZone(ngZone: NgZone) {\n\n    this.ngZone = ngZone;\n\n  }\n  public static findForTraget(classFnOrObject: any): EndpointContext {\n    const obj = ClassHelpers.getClassFnFromObject(classFnOrObject) || {};\n    return (\n      classFnOrObject[Symbols.ctxInClassOrClassObj] ||\n      obj[Symbols.ctxInClassOrClassObj]\n    );\n  }\n\n\n\n\n\n  disabledRealtime: boolean = false;\n  /**\n   * check whether context is inited\n   * (with init() function )\n   */\n  public inited: boolean = false;\n\n\n  private readonly localInstaceObjSymbol = Symbol('localInstaceObjSymbol');\n\n\n  /**\n   * all instances of classes from context\n   * key is class name\n   */\n  public readonly allClassesInstances = {};\n\n\n\n  private readonly classInstancesByNameObj = {};\n\n\n\n  private readonly objWithClassesInstancesArr = {};\n\n\n\n  public readonly activeRoutes: {\n    routePath: string;\n    method: Models.Http.Rest.HttpMethod;\n  }[] = [];\n\n\n\n  private injectableTypesfromContexts = [\n    Models.ClassType.CONTROLLER,\n    Models.ClassType.PROVIDER,\n    Models.ClassType.REPOSITORY,\n    Models.ClassType.SUBSCRIBER,\n  ];\n\n\n  private allTypesfromContexts = [\n    ...this.injectableTypesfromContexts,\n    Models.ClassType.ENTITY,\n  ];\n\n\n  public expressApp: Application = {} as any;\n\n\n\n  public serverTcpUdp: Server;\n\n\n\n  databaseConfig?: Models.DatabaseConfig;\n  private autoGeneratedConfig?: Models.DatabaseConfig;\n\n\n\n  mode: Models.FrameworkMode;\n\n\n\n  session?: Models.ISession;\n\n\n\n  public connection: DataSource;\n\n\n\n  private entitiesTriggers = {};\n\n\n\n  private realtime: RealtimeCore;\n  get realtimeClient() {\n    return this.realtime.client;\n  }\n  get realtimeServer() {\n    return this.realtime.server;\n  }\n\n\n\n  /**\n   * available after init()\n   */\n  public config: Models.ContextOptions<any, any, any, any, any, any>;\n\n\n\n  get logHttp(): boolean {\n    if (_.isObject(this.config?.logs)) {\n      return !!(this.config.logs as Models.ContectionOptionsLogs).http;\n    }\n    return this.config?.logs === true;\n  }\n\n  get logRealtime(): boolean {\n    if (_.isObject(this.config?.logs)) {\n      return !!(this.config.logs as Models.ContectionOptionsLogs).realtime;\n    }\n    return this.config?.logs === true;\n  }\n\n  get logFramework(): boolean {\n    if (_.isObject(this.config?.logs)) {\n      return !!(this.config.logs as Models.ContectionOptionsLogs).framework;\n    }\n    return this.config?.logs === true;\n  }\n\n  get logDb(): boolean {\n    if (_.isObject(this.config?.logs)) {\n      return !!(this.config.logs as Models.ContectionOptionsLogs).db;\n    }\n    return this.config?.logs === true;\n  }\n\n\n\n\n\n  constructor(\n    private originalConfig: Models.ContextOptions<any, any, any, any, any, any>,\n    private configFn: (\n      env: any,\n    ) => Models.ContextOptions<any, any, any, any, any, any>,\n  ) {}\n\n\n\n  public async init(options?: { initFromRecrusiveContextResovle?: boolean }) {\n    const { initFromRecrusiveContextResovle } = options || {}; // TODO use it ?\n\n    this.inited = true;\n    this.config = this.configFn(ENV);\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n    if (this.config.host) {\n      this.mode = 'backend-frontend(tcp+udp)';\n\n      this.mode = 'backend-frontend(websql)';\n\n    }\n    if (this.config.remoteHost) {\n      if (this.config.host) {\n        Helpers.error(\n          `[taon] You can't have remoteHost and host at the same time`,\n          false,\n          true,\n        );\n      }\n      this.mode = 'remote-backend(tcp+udp)';\n    }\n\n    if (this.config.useIpcWhenElectron && Helpers.isElectron) {\n      this.mode = 'backend-frontend(ipc-electron)';\n    }\n\n    if (!this.mode && !this.config.abstract) {\n      Helpers.error(\n        `[taon] Context \"${this.contextName}\": You need to provide host or remoteHost or useIpcWhenElectron`,\n        false,\n        true,\n      );\n/* */\n/* */\n  \n    }\n\n\n\n    if (this.config.database === true) {\n      this.databaseConfig = this.getAutoGeneratedConfig();\n    } else if (_.isObject(this.config.database)) {\n      this.databaseConfig = _.cloneDeep(\n        this.config.database,\n      ) as Models.DatabaseConfig;\n    }\n\n\n\n    if (this.config.session) {\n      this.session = _.cloneDeep(this.config.session);\n      const oneHour = 1000 * 60 * 60 * 1; // 24;\n      if (!this.session.cookieMaxAge) {\n        this.session.cookieMaxAge = oneHour;\n      }\n\n      axios.defaults.withCredentials = true;\n    }\n\n\n\n    this.config.contexts = this.config.contexts || {};\n    this.config.entities = this.config.entities || {};\n    this.config.controllers = this.config.controllers || {};\n    this.config.repositories = this.config.repositories || {};\n    this.config.providers = this.config.providers || {};\n    this.config.subscribers = this.config.subscribers || {};\n\n    this.config.entities = {\n      ...(await this.getRecrusiveClassesfromContextsObj(\n        Models.ClassType.ENTITY,\n      )),\n      ...this.config.entities,\n    };\n\n    this.config.controllers = {\n      ...(await this.getRecrusiveClassesfromContextsObj(\n        Models.ClassType.CONTROLLER,\n      )),\n      ...this.config.controllers,\n    };\n\n    this.config.providers = {\n      ...(await this.getRecrusiveClassesfromContextsObj(\n        Models.ClassType.PROVIDER,\n      )),\n      ...this.config.providers,\n    };\n\n    this.config.subscribers = {\n      ...(await this.getRecrusiveClassesfromContextsObj(\n        Models.ClassType.SUBSCRIBER,\n      )),\n      ...this.config.subscribers,\n    };\n\n    this.config.repositories = {\n      ...(await this.getRecrusiveClassesfromContextsObj(\n        Models.ClassType.REPOSITORY,\n      )),\n      ...this.config.repositories,\n    };\n\n\n\n\n\n    this.config.controllers = this.cloneClassesObjWithNewMetadata({\n      classesInput: this.config.controllers,\n      config: this.config,\n      ctx: this,\n      classType: Models.ClassType.CONTROLLER,\n    });\n    this.config.repositories = this.cloneClassesObjWithNewMetadata({\n      classesInput: this.config.repositories,\n      config: this.config,\n      ctx: this,\n      classType: Models.ClassType.REPOSITORY,\n    });\n    this.config.providers = this.cloneClassesObjWithNewMetadata({\n      classesInput: this.config.providers,\n      config: this.config,\n      ctx: this,\n      classType: Models.ClassType.PROVIDER,\n    });\n    this.config.subscribers = this.cloneClassesObjWithNewMetadata({\n      classesInput: this.config.subscribers,\n      config: this.config,\n      ctx: this,\n      classType: Models.ClassType.SUBSCRIBER,\n    });\n\n\n\n    for (const classTypeName of this.injectableTypesfromContexts) {\n      this.classInstancesByNameObj[classTypeName] = {};\n      this.objWithClassesInstancesArr[classTypeName] = [];\n    }\n\n    for (const classTypeName of this.injectableTypesfromContexts) {\n      await this.createInstances(\n        this.config[Models.ClassTypeKey[classTypeName]],\n        classTypeName,\n      );\n    }\n\n\n\n    if (this.mode === 'backend-frontend(tcp+udp)' && !this.config.abstract) {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n  \n    }\n\n\n\n    if (!this.config.abstract) {\n      this.disabledRealtime = !!this.config.disabledRealtime;\n/* */\n/* */\n/* */\n/* */\n/* */\n  \n      this.realtime = new RealtimeCore(this);\n    }\n\n\n\n\n    if (this.config.abstract) {\n      this.logFramework &&\n        Helpers.info(\n          `[taon] Create abstract context: ${this.config.contextName}`,\n        );\n    } else {\n      if (this.config.remoteHost) {\n        this.logFramework &&\n          Helpers.info(\n            `[taon] Create context for remote host: ${this.config.remoteHost}`,\n          );\n      } else {\n        this.logFramework &&\n          Helpers.info(\n            `[taon] Create context for host: ${this.config.host}`,\n          );\n      }\n    }\n\n\n\n    Object.keys(this.config).forEach(key => {\n      this.originalConfig[key] = this.config[key];\n    });\n  }\n\n\n\n  private getAutoGeneratedConfig(): Models.DatabaseConfig {\n\n    let databaseConfig: Models.DatabaseConfig;\n    if (Helpers.isRunningInDocker()) {\n      Helpers.info('Running in docker, using in mysql database');\n\n      databaseConfig = {\n        database: `tmp-db-${_.kebabCase(this.contextName)}.sqljs.db`,\n        type: 'mysql',\n        autoSave: true,\n        synchronize: true,\n        dropSchema: true,\n        logging: this.logDb,\n        databasePort: 3306,\n        databaseHost: 'localhost',\n        databaseUsername: 'root',\n        databasePassword: 'admin',\n      };\n    } else {\n      this.logFramework &&\n        Helpers.info(\n          `[taon][database] Automatically resolving database config for mode ${this.mode}`,\n        );\n      switch (this.mode) {\n\n        case 'backend-frontend(ipc-electron)':\n          return {\n            location: `tmp-db-${_.kebabCase(this.contextName)}.sqljs`,\n            type: 'sqljs',\n            autoSave: true,\n            synchronize: true,\n            dropSchema: true,\n            logging: this.logDb,\n          };\n          break;\n\n\n\n        case 'backend-frontend(websql)':\n          databaseConfig = {\n            location: `tmp-db-${_.kebabCase(this.contextName)}.sqljs`,\n            type: 'sqljs',\n            useLocalForage: true, // !!window['localforage'], // TODO this need to be checked in runtime\n            autoSave: true,\n            synchronize: true,\n            dropSchema: true,\n            logging: this.logDb,\n          };\n\n          let keepWebsqlDbDataAfterReload = false;\n\n          keepWebsqlDbDataAfterReload =\n            TaonAdmin.Instance.keepWebsqlDbDataAfterReload;\n\n\n          if (keepWebsqlDbDataAfterReload) {\n            databaseConfig.dropSchema = false;\n            delete databaseConfig.synchronize; // false is not auto synchonize - from what I understand\n          } else {\n            databaseConfig.dropSchema = true;\n            databaseConfig.synchronize = true;\n          }\n\n          break;\n\n\n\n        case 'backend-frontend(tcp+udp)':\n          databaseConfig = {\n            database: `context-db-${_.kebabCase(this.contextName)}`,\n            location: `tmp-db-${_.kebabCase(this.contextName)}.sqlite`,\n            type: 'sqljs',\n            autoSave: true,\n            synchronize: true,\n            dropSchema: true,\n            logging: this.logDb,\n          };\n          break;\n\n      }\n    }\n    return databaseConfig;\n\n  }\n\n\n\n  get ngZone(): any {\n\n    return EndpointContext.ngZone;\n\n    return;\n  }\n\n\n\n  startServer() {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  displayRoutes(app) {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n  \n  }\n\n\n\n  get modeAllowsDatabaseCreation() {\n    return (\n      this.mode === 'backend-frontend(tcp+udp)' ||\n      this.mode === 'backend-frontend(websql)' ||\n      this.mode === 'backend-frontend(ipc-electron)'\n    );\n  }\n\n\n\n\n  private cloneClassWithNewMetadata = <\n    T extends { new (...args: any[]): any },\n  >({\n    BaseClass,\n    className,\n    config,\n    ctx,\n    classType,\n  }: {\n    BaseClass: T;\n    className: string;\n    config: Models.ContextOptions<any, any, any, any, any, any>;\n    ctx: EndpointContext;\n    classType: Models.ClassType;\n  }): T => {\n\n    const cloneClass = () => {\n      if (\n        BaseClass[Symbols.fullClassNameStaticProperty] ===\n        `${ctx.contextName}.${className}`\n      ) {\n        return BaseClass;\n      }\n      return class extends BaseClass {\n\n\n        // @ts-ignore\n        static [Symbols.orignalClass] = BaseClass;\n\n        // @ts-ignore\n        static [Symbols.fullClassNameStaticProperty] = `${ctx.contextName}.${className}`;\n\n        // @ts-ignore\n        static [Symbols.classNameStaticProperty] = className;\n\n        static [Symbols.ctxInClassOrClassObj] = ctx;\n\n        static __getFullPathForClass__(arr = []) {\n          const name = this[Symbols.fullClassNameStaticProperty];\n          arr.push(name);\n          // @ts-ignore\n          if (\n            this[Symbols.orignalClass] && // @ts-ignore\n            this[Symbols.orignalClass].__getFullPathForClass__\n          ) {\n            // @ts-ignore\n            this[Symbols.orignalClass].__getFullPathForClass__(arr);\n          }\n          return arr.join('/');\n        }\n        static get fullPathForClass(): string {\n          return this.__getFullPathForClass__();\n        }\n        [Symbols.ctxInClassOrClassObj] = ctx;\n\n\n      };\n    };\n\n    const cloneClassFunction = cloneClass();\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n    return cloneClassFunction;\n  };\n\n\n\n\n\n  private cloneClassesObjWithNewMetadata = ({\n    classesInput,\n    config,\n    ctx,\n    classType,\n  }: {\n    classesInput: any;\n    config: Models.ContextOptions<any, any, any, any, any, any>;\n    ctx: EndpointContext;\n    classType: Models.ClassType;\n  }) => {\n    const classes = {};\n\n    for (const key of Object.keys(classesInput || {})) {\n      const BaseClass = classesInput[key];\n\n      if (!BaseClass) {\n        Helpers.error(`Class ${key} is not defined in context ${ctx.contextName}\n\n        Please check if you have correct import in context file\n\n        `);\n      }\n\n      var className = Reflect.getMetadata(\n        Symbols.metadata.className,\n        BaseClass,\n      );\n\n\n\n\n\n      className = className || key;\n      BaseClass[Symbols.classNameStaticProperty] = className;\n\n      const clonedClass = this.cloneClassWithNewMetadata({\n        BaseClass,\n        className,\n        config,\n        ctx,\n        classType,\n      });\n      classes[className] = clonedClass;\n    }\n    return classes;\n  };\n\n\n\n  private async getRecrusiveClassesfromContextsObj(\n    classType: Models.ClassType,\n  ) {\n    const arr = await this.getRecrusiveClassesfromContexts(classType);\n    return arr.reduce((acc, c) => {\n      acc[ClassHelpers.getName(c)] = c;\n      return acc;\n    }, {});\n  }\n\n  private async getRecrusiveClassesfromContexts(\n    classType: Models.ClassType,\n    arr = [],\n  ) {\n    const contexts = Object.values(this.config.contexts || {}) as ReturnType<\n      typeof createContext\n    >[];\n\n\n\n    for (const ctx of contexts) {\n\n      const ref = await ctx.__ref();\n\n      const classesInput = ref.getClassFunBy(classType);\n\n\n      const clonedClasses = Object.values(\n        this.cloneClassesObjWithNewMetadata({\n          classesInput,\n          config: this.config,\n          ctx: this,\n          classType,\n        }),\n      );\n\n      clonedClasses.forEach(c => arr.push(c));\n\n      await ref.getRecrusiveClassesfromContexts(classType, arr);\n    }\n    return arr as Function[];\n  }\n\n\n\n  getClassInstanceObjBy(classType: Models.ClassType): any {\n    return this.classInstancesByNameObj[classType];\n  }\n\n\n\n  private getClassesInstancesArrBy(classType: Models.ClassType): any[] {\n    return this.objWithClassesInstancesArr[classType];\n  }\n\n\n\n  inject<T>(\n    ctor: new (...args: any[]) => T,\n    options?: {\n      localInstance?: boolean;\n      contextClassInstance?: BaseClass;\n      locaInstanceConstructorArgs?: ConstructorParameters<typeof ctor>;\n    },\n  ): T {\n    if (!options) {\n      options = {} as any;\n    }\n    const className = ClassHelpers.getName(ctor);\n\n    const locaInstanceConstructorArgs =\n      options.locaInstanceConstructorArgs || [];\n\n    if (this.isCLassType(Models.ClassType.REPOSITORY, ctor)) {\n      options.localInstance = true;\n    }\n\n    if (options?.localInstance) {\n      const ctxClassFn = this.getClassFunByClassName(className);\n      let entityName: string = '';\n\n      if (className === 'BaseRepository') {\n        const entityFn = locaInstanceConstructorArgs[0];\n        const entity = entityFn && entityFn();\n        entityName = entity && ClassHelpers.getName(entity);\n      }\n\n      if (!options.contextClassInstance[this.localInstaceObjSymbol]) {\n        options.contextClassInstance[this.localInstaceObjSymbol] = {};\n      }\n      const instanceKey = className + (entityName ? `.${entityName}` : '');\n      const existed =\n        options.contextClassInstance[this.localInstaceObjSymbol][instanceKey];\n      if (existed) {\n\n        return existed;\n      }\n\n      if (!ctxClassFn) {\n        throw new Error(`Not able to inject \"${className}\" inside context \"${this.contextName}\"\n\n        Make sure they share the same context or import context where \"${className}\" is defined.\n\n        `);\n      }\n\n      const injectedInstance = new (ctxClassFn as any)(\n        ...locaInstanceConstructorArgs,\n      );\n      options.contextClassInstance[this.localInstaceObjSymbol][instanceKey] =\n        injectedInstance;\n\n      return injectedInstance;\n    }\n\n    const contextScopeInstance = this.allClassesInstances[className];\n\n\n\n    return contextScopeInstance;\n  }\n\n  /**\n   * alias for inject\n   */\n  getInstanceBy<T>(ctor: new (...args: any[]) => T): T {\n    return this.inject(ctor, { localInstance: false });\n  }\n\n\n  checkIfContextInitialized() {\n    if (_.isUndefined(this.config)) {\n      throw new Error(`Please check if your context has been initilized.\n\n\n      await Context.initialize();\n\n\n\n      `);\n    }\n  }\n\n\n  getClassFunBy(classType: Models.ClassType) {\n    this.checkIfContextInitialized();\n    switch (classType) {\n      case Models.ClassType.CONTROLLER:\n        return this.config.controllers;\n      case Models.ClassType.ENTITY:\n        return this.config.entities;\n      case Models.ClassType.PROVIDER:\n        return this.config.providers;\n      case Models.ClassType.REPOSITORY:\n        return this.config.repositories;\n      case Models.ClassType.SUBSCRIBER:\n        return this.config.subscribers;\n    }\n  }\n\n  isCLassType(classType: Models.ClassType, classFn: Function): boolean {\n    return !!this.getClassFunBy(classType)[ClassHelpers.getName(classFn)];\n  }\n\n  /**\n   * Only for injectable types\n   * Only for classType: CONTROLLER, REPOSITORY, PROVIDER\n   */\n  getClassFunByClassName(className: string): Function {\n    for (const classTypeName of this.allTypesfromContexts) {\n      const classesForInjectableType =\n        this.config[Models.ClassTypeKey[classTypeName]];\n\n      if (classesForInjectableType[className]) {\n        return classesForInjectableType[className];\n      }\n    }\n  }\n\n  getClassFunByClass(classFunction: Function): Function {\n    const className = ClassHelpers.getName(classFunction);\n    return this.getClassFunByClassName(className);\n  }\n\n  getClassFunByArr(classType: Models.ClassType) {\n    return Object.values(this.getClassFunBy(classType) || {}) as Function[];\n  }\n\n\n\n  private async createInstances(classes: any, classType: Models.ClassType) {\n\n\n\n\n\n    for (const classFn of [\n\n      ...Object.values(classes),\n    ]) {\n      const instance = DITaonContainer.resolve(classFn as any) as any;\n      const classInstancesByNameObj = this.classInstancesByNameObj[classType];\n      const className = ClassHelpers.getName(classFn);\n\n      classInstancesByNameObj[className] = instance;\n\n      this.config[Models.ClassTypeKey[classType]][className] = classFn;\n      this.objWithClassesInstancesArr[classType].push(instance);\n      this.allClassesInstances[className] = instance;\n    }\n  }\n\n\n\n  async reinitControllers() {\n\n\n\n    const controllers = this.getClassesInstancesArrBy(\n      Models.ClassType.CONTROLLER,\n    );\n\n    for (const ctrl of controllers) {\n      if (_.isFunction(ctrl.initExampleDbData)) {\n        await Helpers.runSyncOrAsync({\n          functionFn: ctrl.initExampleDbData,\n          context: ctrl,\n        });\n      }\n    }\n\n\n\n  }\n  async initClasses() {\n    for (const classTypeName of [\n      Models.ClassType.PROVIDER,\n      Models.ClassType.REPOSITORY,\n      Models.ClassType.CONTROLLER,\n      Models.ClassType.ENTITY,\n    ]) {\n\n\n\n\n      for (const classFun of this.getClassFunByArr(classTypeName) as any[]) {\n        if (_.isFunction(classFun._)) {\n          await Helpers.runSyncOrAsync({\n            functionFn: classFun._,\n            context: classFun,\n          });\n\n\n\n\n\n\n        }\n      }\n\n\n\n\n    }\n\n    for (const classTypeName of [\n      Models.ClassType.PROVIDER,\n      Models.ClassType.REPOSITORY,\n      Models.ClassType.CONTROLLER,\n    ]) {\n\n\n\n\n      for (const ctrl of this.getClassesInstancesArrBy(classTypeName)) {\n        if (_.isFunction(ctrl._)) {\n          await Helpers.runSyncOrAsync({\n            functionFn: ctrl._,\n            context: ctrl,\n          });\n        }\n      }\n\n\n\n\n    }\n  }\n\n\n\n  isActiveOn(classInstance: object): boolean {\n    let contextRef: EndpointContext =\n      classInstance[Symbols.ctxInClassOrClassObj];\n    return this === contextRef;\n  }\n\n\n\n  get uri() {\n    const url = this.host\n      ? new URL(this.host)\n      : this.remoteHost\n        ? new URL(this.remoteHost)\n        : void 0;\n    return url;\n  }\n\n\n\n  get isHttpServer() {\n    return this.uri.protocol === 'https:';\n  }\n\n\n\n  /**\n   * ipc/udp needs this\n   */\n  public get contextName() {\n    return this.config.contextName;\n  }\n\n\n\n  public get publicAssets() {\n    return this.config?.publicAssets || [];\n  }\n\n\n\n  get isProductionMode() {\n    return this.config.productionMode;\n  }\n\n\n\n  get remoteHost() {\n    return this.config.remoteHost;\n  }\n\n\n\n  get host() {\n    return this.config.host;\n  }\n\n\n\n  get orgin() {\n    return this.uri?.origin;\n  }\n\n\n\n  async initSubscribers() {\n    return; // TODO\n\n    if (!this.connection?.initialize) {\n      return;\n    }\n    const subscribers = this.getClassFunByArr(Models.ClassType.SUBSCRIBER);\n    for (const subscriber of subscribers) {\n      const options = Reflect.getMetadata(\n        Symbols.metadata.options.subscriber,\n        subscriber,\n      ) as TaonSubscriberOptions;\n\n\n      EventSubscriber()(subscriber);\n    }\n\n    console.log(this.config.subscribers);\n\n\n\n    return;\n\n\n    const entities = this.getClassFunByArr(Models.ClassType.ENTITY);\n    for (let index = 0; index < entities.length; index++) {\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n    }\n\n  }\n\n\n\n  async initEntities() {\n\n    const entities = this.getClassFunByArr(Models.ClassType.ENTITY);\n    for (const entity of entities) {\n      const options = Reflect.getMetadata(\n        Symbols.metadata.options.entity,\n        entity,\n      ) as TaonEntityOptions;\n      const createTable = _.isUndefined(options.createTable)\n        ? true\n        : options.createTable;\n      const nameForEntity = ClassHelpers.getName(entity);\n\n      if (_.isUndefined(options.createTable) ? true : options.createTable) {\n        this.logDb &&\n          console.info(\n            `[taon][typeorm] create table for entity \"${nameForEntity}\" ? '${createTable}'`,\n          );\n\n        TypeormEntity(nameForEntity)(entity);\n      } else {\n        this.logDb &&\n          console.info(\n            `[taon][typeorm] create table for entity \"${nameForEntity}\" ? '${createTable}'`,\n          );\n      }\n    }\n\n  }\n\n\n\n\n  async initDatabaseConnection() {\n\n    const entities = (\n      this.config.override?.entities\n        ? this.config.override.entities\n        : this.getClassFunByArr(Models.ClassType.ENTITY)\n    ).map(entityFn => {\n      return ClassHelpers.getOrginalClass(entityFn);\n    });\n\n    const subscribers = (\n      this.config.override?.subscribers\n        ? this.config.override.subscribers\n        : this.getClassFunByArr(Models.ClassType.SUBSCRIBER)\n    ).filter(f => f instanceof BaseSubscriberForEntity);\n\n    const dataSourceDbConfig = _.isObject(this.databaseConfig)\n      ? ({\n          type: this.databaseConfig.type,\n          port: this.databaseConfig.databasePort,\n          host: this.databaseConfig.databaseHost,\n          database: this.databaseConfig.database as any,\n          username: this.databaseConfig.databaseUsername,\n          password: this.databaseConfig.databasePassword,\n          useLocalForage: this.databaseConfig.useLocalForage,\n          entities,\n          subscribers,\n          synchronize: this.databaseConfig.synchronize,\n          autoSave: this.databaseConfig.autoSave,\n          dropSchema: this.databaseConfig.dropSchema,\n          logging: !!this.databaseConfig.logging,\n          location: this.databaseConfig.location,\n        } as DataSourceOptions)\n      : ({} as DataSourceOptions);\n\n\n\n\n    if (this.modeAllowsDatabaseCreation && this.databaseConfig) {\n      this.logDb &&\n        this.logFramework &&\n        Helpers.info('[taon][database] prepare typeorm connection...');\n      try {\n        const connection = new DataSource(dataSourceDbConfig);\n        this.connection = connection;\n        await this.connection.initialize();\n      } catch (error) {\n        console.error(error?.message || error);\n      }\n\n      if (!this.connection?.isInitialized) {\n        console.log('WRONG CONFIG', dataSourceDbConfig);\n        throw new Error(`Something wrong with connection init in ${this.mode}`);\n/* */\n/* */\n  \n      }\n\n      (this.logDb || this.logFramework) &&\n        console.info(\n          `\n\n        CONTECTION OK for ${this.contextName} - ${this.mode}\n\n        [taon][typeorm] db prepration done.. db initialize=${this.connection?.isInitialized}\n\n\n        `,\n          dataSourceDbConfig,\n        );\n\n\n\n\n\n\n\n\n\n\n    } else {\n      Helpers.info(`[taon][typeorm] Not initing db for mode ${this.mode}`);\n    }\n\n  }\n\n\n\n\n  initMetadata() {\n    const allControllers = this.getClassFunByArr(Models.ClassType.CONTROLLER);\n\n    for (const controllerClassFn of allControllers) {\n      controllerClassFn[Symbols.classMethodsNames] =\n        ClassHelpers.getMethodsNames(controllerClassFn);\n      const configs = ClassHelpers.getControllerConfigs(controllerClassFn);\n\n      const classConfig: Models.RuntimeControllerConfig = configs[0];\n\n      const parentscalculatedPath = _.slice(configs, 1)\n        .reverse()\n        .map(bc => {\n          if (TaonHelpers.isGoodPath(bc.path)) {\n            return bc.path;\n          }\n          return bc.className;\n        })\n        .join('/');\n\n      if (TaonHelpers.isGoodPath(classConfig.path)) {\n        classConfig.calculatedPath = classConfig.path;\n      } else {\n        classConfig.calculatedPath =\n          `${parentscalculatedPath}/${ClassHelpers.getName(controllerClassFn)}`\n            .replace(/\\/\\//g, '/')\n            .split('/')\n            .reduce((acc, bc) => {\n              return _.last(acc) === bc ? acc : [...acc, bc];\n            }, [])\n            .join('/');\n      }\n\n      _.slice(configs, 1).forEach(bc => {\n        const alreadyIs = classConfig.methods;\n        const toMerge = _.cloneDeep(bc.methods);\n        for (const key in toMerge) {\n          if (toMerge.hasOwnProperty(key) && !alreadyIs[key]) {\n            const element = toMerge[key];\n            alreadyIs[key] = element;\n          }\n        }\n      });\n\n/* */\n/* */\n  \n        this.logHttp &&\n          console.groupCollapsed(\n            `[taon][express-server] routes [${classConfig.className}]`,\n          );\n/* */\n/* */\n  \n\n\n      Object.keys(classConfig.methods).forEach(methodName => {\n        const methodConfig: Models.MethodConfig =\n          classConfig.methods[methodName];\n\n        const type: Models.Http.Rest.HttpMethod = methodConfig.type;\n        const expressPath = methodConfig.global\n          ? `/${methodConfig.path?.replace(/\\//, '')}`\n          : TaonHelpers.getExpressPath(classConfig, methodConfig);\n\n\n        if (Helpers.isNode || Helpers.isWebSQL) {\n\n\n          const { routePath, method } = this.initServer(\n            type,\n            methodConfig,\n            classConfig,\n            expressPath,\n            controllerClassFn,\n          );\n\n          this.activeRoutes.push({\n            routePath,\n            method,\n          });\n\n        }\n\n        const shouldInitClient =\n          Helpers.isBrowser || this.remoteHost || Helpers.isWebSQL;\n\n        if (shouldInitClient) {\n\n\n\n\n\n\n\n          this.initClient(controllerClassFn, type, methodConfig, expressPath);\n        }\n      });\n\n/* */\n/* */\n  \n        this.logHttp && console.groupEnd();\n/* */\n/* */\n  \n    }\n  }\n\n\n\n  public writeActiveRoutes() {\n    const contexts: EndpointContext[] = [this];\n\n\n    const troutes = this.activeRoutes.map(({ method, routePath }) => {\n      return (\n        TaonHelpers.fillUpTo(method.toUpperCase() + ':', 10) +\n        this.uri.href.replace(/\\/$/, '') +\n        routePath\n      );\n\n\n\n    });\n    const routes = [\n      ...['', `---------- FOR HOST ${this.uri.href} ----------`],\n      ...troutes,\n    ];\n    const fileName = path.join(\n/* */\n/* */\n  \n      `tmp-routes-${_.kebabCase(this.config.contextName)}.json`,\n    );\n\n    this.logFramework && console.log(`[taon] routes file: ${fileName} `);\n\n/* */\n/* */\n/* */\n/* */\n/* */\n  \n\n  }\n\n\n\n  public get middlewares(): Models.MiddlewareType[] {\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  private initMidleware() {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n  \n  }\n\n\n\n  private initServer(\n\n    type: Models.Http.Rest.HttpMethod,\n    methodConfig: Models.MethodConfig,\n    classConfig: Models.RuntimeControllerConfig,\n    expressPath: string,\n    target: Function,\n\n  ): any {\n\n\n    const requestHandler =\n      methodConfig.requestHandler &&\n      typeof methodConfig.requestHandler === 'function'\n        ? methodConfig.requestHandler\n        : (req, res, next) => {\n            next();\n          };\n\n\n    const url = this.uri;\n\n\n    const getResult = async (resolvedParams, req, res) => {\n      const response: Models.Http.Response<any> =\n        methodConfig.descriptor.value.apply(\n          /**\n           * Context for method @GET,@PUT etc.\n           */\n          this.getInstanceBy(target as any),\n          /**\n           * Params for metjod @GET, @PUT etc.\n           */\n          resolvedParams,\n        );\n      let result = await getResponseValue(response, { req, res });\n      return result;\n    };\n\n\n    url.pathname = url.pathname.replace(/\\/$/, '');\n    expressPath = url.pathname.startsWith('/')\n      ? `${url.pathname}${expressPath}`\n      : expressPath;\n    expressPath = expressPath.replace(/\\/\\//g, '/');\n\n\n\n    if (Helpers.isElectron) {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n  \n    }\n\n    if (!this.remoteHost) {\n\n\n      if (Helpers.isWebSQL) {\n        if (!this.expressApp[type.toLowerCase()]) {\n          this.expressApp[type.toLowerCase()] = () => {};\n        }\n      }\n\n\n\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n  \n    }\n\n    return {\n      routePath: expressPath,\n      method: methodConfig.type,\n    };\n  }\n\n\n\n  /**\n   * client can be browser or nodejs (when remote host)\n   */\n  private initClient(\n\n    target: Function,\n    type: Models.Http.Rest.HttpMethod,\n    methodConfig: Models.Http.Rest.MethodConfig,\n    expressPath: string,\n\n  ): void {\n    const ctx = this;\n\n    this.logHttp && console.log(`${type?.toUpperCase()} ${expressPath} `);\n\n\n    let storage: any;\n    if (Helpers.isBrowser) {\n      storage = window;\n    }\n/* */\n/* */\n/* */\n/* */\n  \n\n\n    const orgMethods = target.prototype[methodConfig.methodName];\n\n\n\n    if (Helpers.isElectron) {\n      target.prototype[methodConfig.methodName] = function (...args) {\n        const received = new Promise(async (resolve, reject) => {\n          const headers = {};\n          const { request, response } = TaonHelpers.websqlMocks(headers);\n\n          Helpers.ipcRenderer.once(\n            TaonHelpers.ipcKeyNameResponse(\n              target,\n              methodConfig,\n              expressPath,\n            ),\n            (event, responseData) => {\n              let res: any = responseData;\n              console.log({ responseData });\n              try {\n                const body = res;\n                res = new ModelsNg2Rest.HttpResponse(\n                  {\n                    body: void 0,\n                    isArray: void 0 as any,\n                    method: methodConfig.type,\n                    url: `${ctx.uri.origin}${\n                      '' // TODO express path\n                    }${methodConfig.path} `,\n                  },\n                  Helpers.isBlob(body) || _.isString(body)\n                    ? body\n                    : JSON.stringify(body),\n                  RestHeaders.from(headers),\n                  void 0,\n                  () => body,\n                );\n\n                resolve(res);\n              } catch (error) {\n                console.error(error);\n                reject(error);\n              }\n            },\n          );\n          Helpers.ipcRenderer.send(\n            TaonHelpers.ipcKeyNameRequest(target, methodConfig, expressPath),\n            args,\n          );\n        });\n        received['observable'] = from(received);\n        return {\n          received,\n        };\n      };\n      return;\n    }\n\n\n\n\n\n\n    const MIN_TIMEOUT = 500;\n    const MIN_TIMEOUT_STEP = 200;\n    const timeout =\n      window[Symbols.old.WEBSQL_REST_PROGRESS_TIMEOUT] || MIN_TIMEOUT;\n\n    let updateFun: Subject<number> =\n      window[Symbols.old.WEBSQL_REST_PROGRESS_FUN];\n    if (!window[Symbols.old.WEBSQL_REST_PROGRESS_FUN]) {\n      window[Symbols.old.WEBSQL_REST_PROGRESS_FUN] = new Subject();\n    }\n    updateFun = window[Symbols.old.WEBSQL_REST_PROGRESS_FUN];\n\n    let startFun: Subject<void> =\n      window[Symbols.old.WEBSQL_REST_PROGRESS_FUN_START];\n    if (!window[Symbols.old.WEBSQL_REST_PROGRESS_FUN_START]) {\n      window[Symbols.old.WEBSQL_REST_PROGRESS_FUN_START] = new Subject();\n    }\n    startFun = window[Symbols.old.WEBSQL_REST_PROGRESS_FUN_START];\n\n    let doneFun: Subject<void> =\n      window[Symbols.old.WEBSQL_REST_PROGRESS_FUN_DONE];\n    if (!window[Symbols.old.WEBSQL_REST_PROGRESS_FUN_DONE]) {\n      window[Symbols.old.WEBSQL_REST_PROGRESS_FUN_DONE] = new Subject();\n    }\n    doneFun = window[Symbols.old.WEBSQL_REST_PROGRESS_FUN_DONE];\n\n    let periodsToUpdate = 0;\n    if (timeout >= MIN_TIMEOUT) {\n      periodsToUpdate = Math.floor(timeout / MIN_TIMEOUT_STEP);\n    }\n\n\n\n    const periods = async () => {\n      startFun.next();\n      for (let n = 1; n <= periodsToUpdate; n++) {\n\n\n\n        let upValue = Math.round(((MIN_TIMEOUT_STEP * n) / timeout) * 100);\n        if (upValue > 100) {\n          upValue = 100;\n        }\n\n        updateFun.next(upValue);\n\n        await new Promise((resolve, reject) => {\n          setTimeout(() => {\n            resolve(void 0);\n          }, MIN_TIMEOUT_STEP);\n        });\n\n      }\n      doneFun.next();\n    };\n\n\n    target.prototype[methodConfig.methodName] = function (...args) {\n\n\n\n      const received = new Promise(async (resolve, reject) => {\n        const headers = {};\n        const { request, response } = TaonHelpers.websqlMocks(headers);\n\n        let res: any;\n        try {\n          res = await Helpers.runSyncOrAsync({\n            functionFn: orgMethods,\n            context: this,\n            arrayOfParams: args,\n          });\n\n          if (typeof res === 'function') {\n            res = await Helpers.runSyncOrAsync({\n              functionFn: res,\n              context: this,\n              arrayOfParams: [request, response],\n            });\n          }\n\n          if (typeof res === 'function') {\n            res = await Helpers.runSyncOrAsync({\n              functionFn: res,\n              context: this,\n              arrayOfParams: [request, response],\n            });\n          }\n\n\n          if (typeof res === 'object' && res?.received) {\n            res = await res.received;\n          }\n\n          const body = res;\n\n          res = new ModelsNg2Rest.HttpResponse(\n            {\n              body: void 0,\n              isArray: void 0 as any,\n              method: methodConfig.type,\n              url: `${ctx.uri.origin}${\n                '' // TODO express path\n              }${methodConfig.path} `,\n            },\n            Helpers.isBlob(body) || _.isString(body)\n              ? body\n              : JSON.stringify(body),\n            RestHeaders.from(headers),\n            void 0,\n            () => body,\n          );\n\n\n\n\n\n          await periods();\n          resolve(res);\n        } catch (error) {\n          await periods();\n          console.error(error);\n\n\n\n          reject(error);\n        }\n      });\n      received['observable'] = from(received);\n\n      if (Helpers.isWebSQL) {\n        return {\n          received,\n        };\n      }\n    };\n    if (Helpers.isWebSQL) {\n      return;\n    }\n\n\n\n\n\n    target.prototype[methodConfig.methodName] = function (this: {}, ...args) {\n\n\n\n\n\n      if (!storage[Symbols.old.ENDPOINT_META_CONFIG])\n        storage[Symbols.old.ENDPOINT_META_CONFIG] = {};\n      if (!storage[Symbols.old.ENDPOINT_META_CONFIG][ctx.uri.href])\n        storage[Symbols.old.ENDPOINT_META_CONFIG][ctx.uri.href] = {};\n      const endpoints = storage[Symbols.old.ENDPOINT_META_CONFIG];\n      let rest: ModelsNg2Rest.ResourceModel<any, any>;\n      if (!endpoints[ctx.uri.href][expressPath]) {\n        let headers = {};\n        if (methodConfig.contentType && !methodConfig.responseType) {\n          rest = Resource.create(\n            ctx.uri.href,\n            expressPath,\n            Symbols.old.MAPPING_CONFIG_HEADER as any,\n            Symbols.old.CIRCURAL_OBJECTS_MAP_BODY as any,\n            RestHeaders.from({\n              'Content-Type': methodConfig.contentType,\n              Accept: methodConfig.contentType,\n            }),\n          );\n        } else if (methodConfig.contentType && methodConfig.responseType) {\n          rest = Resource.create(\n            ctx.uri.href,\n            expressPath,\n            Symbols.old.MAPPING_CONFIG_HEADER as any,\n            Symbols.old.CIRCURAL_OBJECTS_MAP_BODY as any,\n            RestHeaders.from({\n              'Content-Type': methodConfig.contentType,\n              Accept: methodConfig.contentType,\n              responsetypeaxios: methodConfig.responseType,\n            }),\n          );\n        } else if (!methodConfig.contentType && methodConfig.responseType) {\n          rest = Resource.create(\n            ctx.uri.href,\n            expressPath,\n            Symbols.old.MAPPING_CONFIG_HEADER as any,\n            Symbols.old.CIRCURAL_OBJECTS_MAP_BODY as any,\n            RestHeaders.from({\n              responsetypeaxios: methodConfig.responseType,\n            }),\n          );\n        } else {\n          rest = Resource.create(\n            ctx.uri.href,\n            expressPath,\n            Symbols.old.MAPPING_CONFIG_HEADER as any,\n            Symbols.old.CIRCURAL_OBJECTS_MAP_BODY as any,\n          );\n        }\n\n        endpoints[ctx.uri.href][expressPath] = rest;\n      } else {\n        rest = endpoints[ctx.uri.href][expressPath] as any;\n      }\n\n      const method = type.toLowerCase();\n      const isWithBody = method === 'put' || method === 'post';\n      const pathPrams = {};\n      let queryParams = {};\n      let bodyObject = {};\n      args.forEach((param, i) => {\n        let currentParam: Models.Http.Rest.ParamConfig = void 0 as any;\n\n        for (let pp in methodConfig.parameters) {\n          let v = methodConfig.parameters[pp];\n          if (v.index === i) {\n            currentParam = v;\n            break;\n          }\n        }\n\n        if (currentParam.paramType === 'Path') {\n          pathPrams[currentParam.paramName] = param;\n        }\n        if (currentParam.paramType === 'Query') {\n          if (currentParam.paramName) {\n            const mapping = Mapping.decode(param, !ctx.isProductionMode);\n            if (mapping) {\n              rest.headers.set(\n                `${Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS}${currentParam.paramName} `,\n                JSON.stringify(mapping),\n              );\n            }\n            queryParams[currentParam.paramName] = param;\n          } else {\n            const mapping = Mapping.decode(param, !ctx.isProductionMode);\n            if (mapping) {\n              rest.headers.set(\n                Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS,\n                JSON.stringify(mapping),\n              );\n            }\n            queryParams = _.cloneDeep(param);\n          }\n        }\n        if (currentParam.paramType === 'Header') {\n          if (currentParam.paramName) {\n            if (currentParam.paramName === Symbols.old.MDC_KEY) {\n\n              rest.headers.set(\n                currentParam.paramName,\n                encodeURIComponent(JSON.stringify(param)),\n              );\n            } else {\n              rest.headers.set(currentParam.paramName, param);\n            }\n          } else {\n            for (let header in param) {\n              rest.headers.set(header, param[header]);\n            }\n          }\n        }\n        if (currentParam.paramType === 'Cookie') {\n          Resource.Cookies.write(\n            currentParam.paramName,\n            param,\n            currentParam.expireInSeconds,\n          );\n        }\n        if (currentParam.paramType === 'Body') {\n          if (currentParam.paramName) {\n            if (ClassHelpers.getName(bodyObject) === 'FormData') {\n              throw new Error(`[taon - framework] Don use param names when posting / putting FormData.\n              Use this:\n\n(@Taon.Http.Param.Body() formData: FormData) ...\n\n\ninstead\n\n  (@Taon.Http.Param.Body('${currentParam.paramName}') formData: FormData) ...\n\n`);\n            }\n            const mapping = Mapping.decode(param, !ctx.isProductionMode);\n            if (mapping) {\n              rest.headers.set(\n                `${Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS}${currentParam.paramName} `,\n                JSON.stringify(mapping),\n              );\n            }\n            bodyObject[currentParam.paramName] = param;\n          } else {\n            const mapping = Mapping.decode(param, !ctx.isProductionMode);\n            if (mapping) {\n              rest.headers.set(\n                Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS,\n                JSON.stringify(mapping),\n              );\n            }\n            bodyObject = param;\n          }\n        }\n      });\n\n      if (\n        typeof bodyObject === 'object' &&\n        ClassHelpers.getName(bodyObject) !== 'FormData'\n      ) {\n        let circuralFromItem = [];\n        bodyObject = JSON10.parse(\n          JSON10.stringify(bodyObject, void 0, void 0, circs => {\n            circuralFromItem = circs;\n          }),\n        );\n        rest.headers.set(\n          Symbols.old.CIRCURAL_OBJECTS_MAP_BODY,\n          JSON10.stringify(circuralFromItem),\n        );\n      }\n\n      if (typeof queryParams === 'object') {\n        let circuralFromQueryParams = [];\n        queryParams = JSON10.parse(\n          JSON10.stringify(queryParams, void 0, void 0, circs => {\n            circuralFromQueryParams = circs;\n          }),\n        );\n\n        rest.headers.set(\n          Symbols.old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM,\n          JSON10.stringify(circuralFromQueryParams),\n        );\n      }\n\n\n      const httpResultObj = {\n        received: isWithBody\n          ? rest.model(pathPrams)[method](bodyObject, [queryParams])\n          : rest.model(pathPrams)[method]([queryParams]),\n      };\n      return httpResultObj;\n    };\n\n  }\n\n}\n\n ;({}); // @--end-of-file-for-module=taon lib/endpoint-context.ts"]}