taon 19.0.54 → 19.0.56

package/websql/fesm2022/taon.mjs

@@ -4,14 +4,15 @@ import { _, Utils, UtilsMigrations, Helpers, UtilsOs, crossPlatformPath } from '
 import { __decorate, __metadata, __param } from 'tslib';
 import * as tsorm from 'taon-typeorm/websql';
 import { OrignalClassKey, Entity, Table, TableIndex, EventSubscriber, DataSource } from 'taon-typeorm/websql';
-import { walk } from 'lodash-walk-object/websql';
 import { SYMBOL, CLASS } from 'typescript-class-helpers/websql';
+import { walk } from 'lodash-walk-object/websql';
 import * as i0 from '@angular/core';
 import { InjectionToken, inject as inject$1, Injectable } from '@angular/core';
 import axios from 'axios';
 import { JSON10 } from 'json10/websql';
 import { Models as Models$1, Resource, RestHeaders, Mapping } from 'ng2-rest/websql';
 import { Observable, Subject, from } from 'rxjs';
+import { config } from 'tnp-config/websql';
 import * as JSON5 from 'json5';
 import { io } from 'socket.io-client';
 import { MySqlQuerySource } from 'taon-type-sql/websql';
@@ -128,12 +129,33 @@ class DecoratorAbstractOpt {
 class TaonControllerOptions extends DecoratorAbstractOpt {
 }
 
+// import { cloneObj } from '../helpers/clone-obj';
+// import { ParamConfig } from './param-config';
 class ControllerConfig extends TaonControllerOptions {
-    constructor() {
-        super(...arguments);
-        this.methods = {};
-    }
 }
+const controllerConfigFrom = (partial) => {
+    const newObj = partial || {};
+    newObj.methods = newObj.methods || {};
+    for (const methodName in newObj.methods) {
+        if (newObj.methods.hasOwnProperty(methodName)) {
+            // newObj.methods[methodName] = new MethodConfig().clone(
+            //   newObj.methods[methodName],
+            // );
+            newObj.methods[methodName] = newObj.methods[methodName] || {};
+            const params = newObj.methods[methodName].parameters || {};
+            newObj.methods[methodName].parameters = params
+                ? params
+                : {};
+            for (const paramName in params) {
+                if (params.hasOwnProperty(paramName)) {
+                    params[paramName] = params[paramName] || {};
+                    // params[paramName] = new ParamConfig().clone(params[paramName]);
+                }
+            }
+        }
+    }
+    return newObj;
+};
 
 var Symbols;
 (function (Symbols) {
@@ -209,9 +231,7 @@ var Symbols;
     Symbols.metadata = {
         className: `class:realname`,
         options: {
-            runtimeController: `runtime:controller:options`,
             controller: `controller:options`,
-            controllerMethod: `controller:method:options`,
             entity: `entity:options`,
             repository: `repository:options`,
             provider: `provider:options`,
@@ -387,7 +407,7 @@ var ClassHelpers;
         const classFn = _.isFunction(classFnOrObject)
             ? classFnOrObject
             : classFnOrObject.constructor;
-        const config = Reflect.getMetadata(Symbols.metadata.options.controller, classFn);
+        const config = Reflect.getMetadata(Symbols.metadata.options.entity, classFn);
         return config.uniqueKeyProp;
     };
     //#endregion
@@ -429,23 +449,6 @@ var ClassHelpers;
         return ClassHelpers.hasParentClassWithName(targetProto, className, targets);
     };
     //#endregion
-    //#region get all metadata for controller
-    ClassHelpers.getControllerConfig = (target) => {
-        const classMetadataOptions = Reflect.getMetadata(Symbols.metadata.options.controller, target);
-        const classMetadata = _.merge(new ControllerConfig(), classMetadataOptions);
-        // Iterate over all methods of the class
-        const methodNames = ClassHelpers.getMethodsNames(target); //  Object.getOwnPropertyNames(target.prototype);
-        // console.log(`methodNames for ${ClassHelpers.getName(target)} `, methodNames)
-        for (const methodName of methodNames) {
-            const methodMetadata = Reflect.getMetadata(Symbols.metadata.options.controllerMethod, target, methodName);
-            // console.log('methodMetadata for ' + methodName, methodMetadata)
-            if (methodMetadata) {
-                classMetadata.methods[methodName] = methodMetadata;
-            }
-        }
-        return classMetadata;
-    };
-    //#endregion
     //#region get methods name
     //#region not allowed as method name
     const notAllowedAsMethodName = [
@@ -508,37 +511,81 @@ var ClassHelpers;
     //#region get controller configs
     ClassHelpers.getControllerConfigs = (target, configs = [], callerTarget) => {
         if (!_.isFunction(target)) {
-            throw `[typescript-class-helper][getClassConfig] Cannot get class config from: ${target}`;
+            throw `[typescript-class-helper][getControllerConfigs] Cannot get class config from: ${target}`;
         }
         let config;
         const parentClass = Object.getPrototypeOf(target);
         const parentName = parentClass ? ClassHelpers.getName(parentClass) : void 0;
         const isValidParent = _.isFunction(parentClass) && parentName !== '';
-        config = ClassHelpers.getControllerConfig(target);
+        config = controllerConfigFrom(ClassHelpers.getClassConfig(target));
         configs.push(config);
         return isValidParent
             ? ClassHelpers.getControllerConfigs(parentClass, configs, target)
             : configs;
     };
     //#endregion
-    //#region get path for
-    // export const getCalculatedPathFor = (target: Function) => {
-    //   const configs = getControllerConfigs(target);
-    //   const parentscalculatedPath = _.slice(configs, 1)
-    //     .reverse()
-    //     .map(bc => {
-    //       if (TaonHelpers.isGoodPath(bc.path)) {
-    //         return bc.path;
-    //       }
-    //       return bc.className;
-    //     })
-    //     .join('/');
-    //   return `/${parentscalculatedPath}/${ClassHelpers.getName(target)}`;
-    // };
+    //#region ensure configs
+    // Ensure ClassConfig on constructor, clone parent if needed
+    ClassHelpers.ensureClassConfig = (target) => {
+        let cfg = Reflect.getOwnMetadata(Symbols.metadata.options.controller, // META_KEYS.class,
+        target);
+        if (!cfg) {
+            cfg = { methods: {} };
+            const parent = Object.getPrototypeOf(target);
+            if (parent && parent !== Function.prototype) {
+                const parentCfg = Reflect.getMetadata(Symbols.metadata.options.controller, // META_KEYS.class,
+                parent);
+                if (parentCfg) {
+                    // Deep copy each method config so child gets its own objects
+                    const clonedMethods = {};
+                    for (const [k, v] of Object.entries(parentCfg.methods)) {
+                        clonedMethods[k] = {
+                            ...v,
+                            parameters: { ...v.parameters }, // shallow clone parameters too
+                        };
+                    }
+                    cfg = {
+                        ...parentCfg,
+                        methods: clonedMethods,
+                    };
+                }
+            }
+            Reflect.defineMetadata(Symbols.metadata.options.controller, cfg, target);
+        }
+        return cfg;
+    };
+    // Ensure MethodConfig inside ClassConfig
+    ClassHelpers.ensureMethodConfig = (target, propertyKey) => {
+        const classCfg = ClassHelpers.ensureClassConfig(target.constructor);
+        let methodCfg = classCfg.methods[propertyKey?.toString()];
+        if (!methodCfg) {
+            methodCfg = { methodName: propertyKey?.toString(), parameters: {} };
+            classCfg.methods[propertyKey?.toString()] = methodCfg;
+        }
+        return methodCfg;
+    };
+    ClassHelpers.getClassConfig = (constructor) => {
+        return Reflect.getMetadata(Symbols.metadata.options.controller, constructor);
+    };
     //#endregion
 })(ClassHelpers || (ClassHelpers = {}));
 
-//#region imports
+const cloneObj = (override, classFn) => {
+    const result = _.merge(new classFn(), _.cloneDeep(this));
+    walk.Object(override || {}, (value, lodashPath) => {
+        if (_.isNil(value) || _.isFunction(value) || _.isObject(value)) {
+            // skipping
+        }
+        else {
+            _.set(result, lodashPath, value);
+        }
+    }, {
+        walkGetters: false,
+    });
+    // console.log({result})
+    return result;
+};
+
 //#endregion
 class BaseClass {
     //#region class initialization hook
@@ -551,19 +598,7 @@ class BaseClass {
     //#region clone
     clone(override) {
         const classFn = ClassHelpers.getClassFnFromObject(this);
-        const result = _.merge(new classFn(), _.cloneDeep(this));
-        walk.Object(override || {}, (value, lodashPath) => {
-            if (_.isNil(value) || _.isFunction(value) || _.isObject(value)) {
-                // skipping
-            }
-            else {
-                _.set(result, lodashPath, value);
-            }
-        }, {
-            walkGetters: false,
-        });
-        // console.log({result})
-        return result;
+        return cloneObj(override, classFn);
     }
 }
 
@@ -820,22 +855,6 @@ var Models;
     }
     Models.DatabaseConfig = DatabaseConfig;
     //#endregion
-    //#region models / param config
-    class ParamConfig {
-    }
-    Models.ParamConfig = ParamConfig;
-    //#endregion
-    //#region models / method config
-    /**
-     * @link './decorators/http/http-methods-decorators.ts' TaonHttpDecoratorOptions
-     */
-    class MethodConfig {
-        constructor() {
-            this.parameters = {};
-        }
-    }
-    Models.MethodConfig = MethodConfig;
-    //#endregion
     //#region models / http
     let Http;
     (function (Http) {
@@ -3078,6 +3097,8 @@ class EndpointContext {
                 /* */
                 /* */
                 /* */
+                /* */
+                /* */
                 await this.initCustomClientMiddlewares();
             }
             //#endregion
@@ -3598,15 +3619,12 @@ class EndpointContext {
         return url;
     }
     //#endregion
-    get uriPort() {
-        if (!this.uri?.origin?.includes('localhost')) {
-            return this.config?.hostPortNumber?.toString();
-        }
-        return this.uri?.port;
-    }
+    //#region methods & getters / host uri protocol
     get uriProtocol() {
         return this.uri?.protocol;
     }
+    //#endregion
+    //#region methods & getters / host uri origin
     /**
      * Examples
      * http://localhost:3000
@@ -3615,6 +3633,8 @@ class EndpointContext {
     get uriOrigin() {
         return this.uri?.origin;
     }
+    //#endregion
+    //#region methods & getters / host uri pathname
     /**
      * Exampels
      * http://localhost:3000/path/to/somewhere
@@ -3628,6 +3648,8 @@ class EndpointContext {
     get uriPathname() {
         return this.uri?.pathname;
     }
+    //#endregion
+    //#region methods & getters / uri pathname or nothing if root
     /**
      * Examples
      * http://localhost:3000/path/to/somewhere -> '/path/to/somewhere'
@@ -3638,6 +3660,15 @@ class EndpointContext {
         const isNonRootProperPathName = this.uri?.pathname && this.uri.pathname !== '/';
         return isNonRootProperPathName ? this.uri.pathname.replace(/\/$/, '') : '';
     }
+    //#endregion
+    //#region port from uri
+    get uriPort() {
+        if (!this.uri?.origin?.includes('localhost')) {
+            return this.config?.hostPortNumber?.toString();
+        }
+        return this.uri?.port;
+    }
+    // TODO do i need 2 getters for port?
     /**
      * Port from uri as number
      * @returns {Number | undefined}
@@ -3645,6 +3676,7 @@ class EndpointContext {
     get port() {
         return this.uri?.port ? Number(this.uriPort) : undefined;
     }
+    //#endregion
     //#region methods & getters / is https server
     get isHttpServer() {
         return this.uriProtocol === 'https:';
@@ -3658,15 +3690,21 @@ class EndpointContext {
         return this.config.contextName;
     }
     //#endregion
+    //#region methods & getters / current working directory
     get cwd() {
         return this.config.cwd || process.cwd();
     }
+    //#endregion
+    //#region methods & getters / active context
     get activeContext() {
         return this.config.activeContext || null;
     }
+    //#endregion
+    //#region methods & getters / app id
     get appId() {
         return this.config.appId;
     }
+    //#endregion
     //#region methods & getters / public assets
     get publicAssets() {
         return this.config?.publicAssets || [];
@@ -3852,66 +3890,124 @@ class EndpointContext {
     }
     //#endregion
     //#region methods & getters / initialize metadata
+    //#region methods & getters / update class calculate path
+    updateCalculatedPathsForControllers(rawConfigs, classConfig, controllerClassFn) {
+        const parentsCalculatedPath = _.slice(rawConfigs, 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 = (`${this.uriPathnameOrNothingIfRoot}` +
+                `/${apiPrefix}/${this.contextName}/tcp${parentsCalculatedPath}/` +
+                `${ClassHelpers.getName(controllerClassFn)}`)
+                .replace(/\/\//g, '/')
+                .split('/')
+                .reduce((acc, bc) => {
+                return _.last(acc) === bc ? acc : [...acc, bc];
+            }, [])
+                .join('/');
+        }
+        // console.log('calculatedPath', classConfig.calculatedPath);
+    }
+    //#endregion
+    //#region methods & getters / dedupe class configs
+    mergeControllerMethodsConfigs(rawConfigs, classConfig, controllerClassFn) {
+        const currentControllerMethodsConfig = classConfig.methods;
+        _.slice(rawConfigs, 1).forEach(bc => {
+            const parentControllerMethods = _.cloneDeep(bc.methods);
+            for (const methodsName in parentControllerMethods) {
+                if (parentControllerMethods.hasOwnProperty(methodsName)) {
+                    if (!currentControllerMethodsConfig[methodsName]) {
+                        //#region add non existed method
+                        const methodConfig = parentControllerMethods[methodsName];
+                        currentControllerMethodsConfig[methodsName] = methodConfig;
+                        //#endregion
+                    }
+                }
+            }
+        });
+    }
+    //#endregion
     async initControllers() {
         if (this.isRunOrRevertOnlyMigrationAppStart) {
             return;
         }
         const allControllers = this.getClassFunByArr(Models.ClassType.CONTROLLER);
+        // debugger
         // console.log('allControllers', allControllers);
         for (const controllerClassFn of allControllers) {
+            // console.log(ClassHelpers.getClassConfig(controllerClassFn));
+            // const controllerName = ClassHelpers.getName(controllerClassFn);
+            // console.log(
+            //   `for ${controllerName}`,
+            //   ClassHelpers.getClassConfig(controllerClassFn),
+            // );
             controllerClassFn[Symbols.classMethodsNames] =
                 ClassHelpers.getMethodsNames(controllerClassFn);
-            const configs = ClassHelpers.getControllerConfigs(controllerClassFn);
+            const rawConfigs = ClassHelpers.getControllerConfigs(controllerClassFn);
+            // console.log(controllerName, { rawConfigs });
             // console.log(`Class config for ${ClassHelpers.getName(controllerClassFn)}`, configs)
-            const classConfig = configs[0];
-            //#region update class calculate path
-            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 = (`${this.uriPathnameOrNothingIfRoot}` +
-                    `/${apiPrefix}/${this.contextName}/tcp${parentscalculatedPath}/` +
-                    `${ClassHelpers.getName(controllerClassFn)}`)
-                    .replace(/\/\//g, '/')
-                    .split('/')
-                    .reduce((acc, bc) => {
-                    return _.last(acc) === bc ? acc : [...acc, bc];
-                }, [])
-                    .join('/');
-            }
-            //#endregion
-            // console.log('calculatedPath', classConfig.calculatedPath);
-            _.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;
-                    }
+            const classConfig = rawConfigs[0];
+            this.updateCalculatedPathsForControllers(rawConfigs, classConfig, controllerClassFn);
+            this.mergeControllerMethodsConfigs(rawConfigs, classConfig, controllerClassFn);
+            //#region combine middlewares from controllers
+            classConfig.calculatedMiddlewaresControllerObj = {};
+            [...rawConfigs].reverse().forEach(rc => {
+                if (_.isFunction(rc.middlewares)) {
+                    classConfig.calculatedMiddlewaresControllerObj = rc.middlewares({
+                        parentMiddlewares: classConfig.calculatedMiddlewaresControllerObj,
+                        className(middlewareClass) {
+                            return ClassHelpers.getName(controllerClassFn);
+                        },
+                    });
                 }
             });
+            //#endregion
+            //#region group start
             /* */
             /* */
             this.logHttp &&
                 console.groupCollapsed(`[taon][express-server] routes [${classConfig.className}]`);
             /* */
             /* */
-            // console.log('methods', classConfig.methods);
+            //#endregion
+            //#region init client or server methods
             const methodNames = Object.keys(classConfig.methods);
             for (const methodName of methodNames) {
                 const methodConfig = classConfig.methods[methodName];
-                // debugger
-                const type = methodConfig.type;
+                //#region combine all class methods middlewares
+                let calculatedMiddlewaresMethodObj = {};
+                [...rawConfigs].reverse().forEach(rc => {
+                    if (rc.methods[methodName]) {
+                        const parentMethodConfig = rc.methods[methodName];
+                        if (_.isFunction(parentMethodConfig.middlewares)) {
+                            calculatedMiddlewaresMethodObj = parentMethodConfig.middlewares({
+                                parentMiddlewares: calculatedMiddlewaresMethodObj,
+                                className(middlewareClass) {
+                                    return ClassHelpers.getName(controllerClassFn);
+                                },
+                            });
+                        }
+                    }
+                });
+                // add class middlewares to method middlewares
+                methodConfig.calculatedMiddlewaresMethodObj = {
+                    ...calculatedMiddlewaresMethodObj,
+                    ...classConfig.calculatedMiddlewaresControllerObj,
+                };
+                methodConfig.calculatedMiddlewares = Object.values(methodConfig.calculatedMiddlewaresMethodObj || {});
+                //#endregion
+                // methodConfig.calculatedMiddlewares = TODO
+                //#region initialized method express path
+                const httpMethodType = methodConfig.type;
                 // this is quick fix - in docker global path should not be used
                 const globalPathPart = this.isRunningInsideDocker ||
                     !this.frontendHostUri?.origin?.includes('localhost') // fe with domain -> is in docker
@@ -3920,16 +4016,20 @@ class EndpointContext {
                 const expressPath = methodConfig.global
                     ? `${globalPathPart}/${methodConfig.path?.replace(/\/$/, '')}`.replace(/\/\//, '/')
                     : TaonHelpers.getExpressPath(classConfig, methodConfig);
+                //#endregion
+                //#region init server
                 // console.log({ expressPath });
                 if (Helpers.isNode || Helpers.isWebSQL) {
                     //#region @websql
-                    const route = this.initServer(type, methodConfig, classConfig, expressPath, controllerClassFn);
+                    const route = this.initServer(httpMethodType, methodConfig, classConfig, expressPath, controllerClassFn);
                     this.activeRoutes.push({
                         expressPath: route.expressPath,
                         method: route.method,
                     });
                     //#endregion
                 }
+                //#endregion
+                //#region init client
                 const shouldInitClient = Helpers.isBrowser || this.remoteHost || Helpers.isWebSQL;
                 // console.log('shouldInitClient', shouldInitClient);
                 if (shouldInitClient) {
@@ -3940,14 +4040,18 @@ class EndpointContext {
                     //   methodConfig,
                     //   expressPath,
                     // );
-                    await this.initClient(controllerClassFn, type, methodConfig, expressPath);
+                    await this.initClient(controllerClassFn, httpMethodType, methodConfig, expressPath);
                 }
+                //#endregion
             }
+            //#endregion
+            //#region group end
             /* */
             /* */
             this.logHttp && console.groupEnd();
             /* */
             /* */
+            //#endregion
         }
     }
     //#endregion
@@ -4001,15 +4105,15 @@ class EndpointContext {
         const middlewares = this.getClassesInstancesArrBy(Models.ClassType.MIDDLEWARE)
             .map(f => f)
             .filter(f => _.isFunction(f.interceptClient));
-        middlewares.forEach(instance => {
+        middlewares.forEach(middlewareInstanceName => {
             const contextName = this.contextName;
-            const interceptorName = `${contextName}-${ClassHelpers.getName(instance)}`;
+            const interceptorName = `${contextName}-${ClassHelpers.getName(middlewareInstanceName)}`;
             Resource.request.interceptors.set(interceptorName, {
                 intercept: ({ req, next }) => {
                     const url = new URL(req.url);
                     if (url.pathname.startsWith(`${this.uriPathnameOrNothingIfRoot}/${apiPrefix}/${contextName}/`)) {
                         // console.log('intercepting', url.pathname, req);
-                        return instance.interceptClient({
+                        return middlewareInstanceName.interceptClient({
                             req,
                             next,
                         });
@@ -4167,10 +4271,10 @@ class EndpointContext {
     //#region parameters
     httpMethodType, methodConfig, classConfig, expressPath, target) {
         //#region resolve variables
-        const middlewareHandlers = (Array.isArray(methodConfig.middlewares) &&
-            methodConfig.middlewares?.length > 0
-            ? methodConfig.middlewares
-            : [])
+        // console.log(
+        //   `CLIENT: expressPath: "${expressPath}" interceptor for method: ${methodConfig.calculatedMiddlewares.length}`,
+        // );
+        const middlewareHandlers = methodConfig.calculatedMiddlewares
             .map(middlewareClassFun => {
             const middlewareInstance = this.getInstanceBy(middlewareClassFun);
             if (middlewareInstance &&
@@ -4459,7 +4563,6 @@ class EndpointContext {
             /* */
             /* */
             /* */
-            /* */
         }
         return {
             expressPath: expressPath,
@@ -4471,17 +4574,22 @@ class EndpointContext {
     /**
      * client can be browser or nodejs (when remote host)
      */
-    async initClient(
-    //#region parameters
-    target, httpRequestType, methodConfig, // Models.Http.Rest.MethodConfig,
+    async initClient(target, httpRequestType, methodConfig, // Models.Http.Rest.MethodConfig,
     expressPath) {
         const ctx = this;
+        // console.log(
+        //   `CLIENT: expressPath: "${expressPath}" interceptor for method: ${methodConfig.calculatedMiddlewares?.length} `,
+        // );
         //#region init middlewares
-        const middlewares = methodConfig.middlewares
+        const middlewares = methodConfig.calculatedMiddlewares;
+        const middlewaresInstances = middlewares
             .map(f => this.getInstanceBy(f))
             .filter(f => _.isFunction(f.interceptClientMethod));
-        middlewares.forEach(instance => {
-            Resource.request.methodsInterceptors.set(`${methodConfig.type?.toUpperCase()}-${expressPath}`, {
+        middlewaresInstances.forEach(instance => {
+            const middlewareName = ClassHelpers.getName(instance);
+            // middlewareName - only needed for inheritace and uniqness of interceptors
+            const interceptorKey = `${middlewareName}-${methodConfig.type?.toUpperCase()}-${expressPath}`;
+            Resource.request.methodsInterceptors.set(interceptorKey, {
                 intercept: ({ req, next }) => {
                     return instance.interceptClientMethod({
                         req,
@@ -4727,6 +4835,14 @@ class EndpointContext {
                         break;
                     }
                 }
+                if (!currentParam) {
+                    const errorMessage = `[${config.frameworkName}] Unable to resolve parameter` +
+                        ` at index ${i} for method ${methodConfig.methodName} at path ${expressPath}.`;
+                    /* */
+                    /* */
+                    /* */
+                    throw new Error(errorMessage);
+                }
                 if (currentParam.paramType === 'Path') {
                     pathPrams[currentParam.paramName] = param;
                 }
@@ -4812,7 +4928,9 @@ instead
             }
             //#endregion
             const httpResultObj = {
-                received: rest.model(pathPrams)[method](bodyObject, [queryParams]),
+                get received() {
+                    return rest.model(pathPrams)[method](bodyObject, [queryParams]);
+                },
                 request(axiosConfig) {
                     return rest
                         .model(pathPrams)[method](bodyObject, [queryParams], axiosConfig);
@@ -5943,12 +6061,18 @@ var baseContext = /*#__PURE__*/Object.freeze({
 function TaonController(options) {
     return function (constructor) {
         ClassHelpers.setName(constructor, options?.className);
-        Reflect.defineMetadata(Symbols.metadata.options.controller, options, constructor);
         Reflect.defineMetadata(Symbols.metadata.className, options?.className || constructor.name, constructor);
+        const cfg = ClassHelpers.ensureClassConfig(constructor);
+        options = options || {};
+        cfg.className = options.className || constructor.name;
+        cfg.path = options.path || '';
+        cfg.realtime = options.realtime;
+        cfg.middlewares = options.middlewares;
     };
 }
 
 const metaReq = (method, path, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal) => {
+    const methodConfig = ClassHelpers.ensureMethodConfig(target, propertyKey);
     let options;
     if (typeof pathOrOptions === 'object') {
         options = pathOrOptions;
@@ -5960,13 +6084,8 @@ const metaReq = (method, path, target, propertyKey, descriptor, pathOrOptions, p
         options = { pathOrOptions, pathIsGlobal };
     }
     const { overrideContentType, overrideResponseType, middlewares } = options;
-    let methodConfig = Reflect.getMetadata(Symbols.metadata.options.controllerMethod, target.constructor, propertyKey);
-    if (!methodConfig) {
-        methodConfig = new Models.MethodConfig();
-        Reflect.defineMetadata(Symbols.metadata.options.controllerMethod, methodConfig, target.constructor, propertyKey);
-    }
     methodConfig.methodName = propertyKey;
-    methodConfig.middlewares = middlewares || [];
+    methodConfig.middlewares = middlewares;
     methodConfig.type = method;
     if (!path) {
         let paramsPathConcatedPath = '';
@@ -5989,8 +6108,6 @@ const metaReq = (method, path, target, propertyKey, descriptor, pathOrOptions, p
     methodConfig.global = pathIsGlobal;
     methodConfig.contentType = overrideContentType;
     methodConfig.responseType = overrideResponseType;
-    Reflect.defineMetadata(Symbols.metadata.options.controllerMethod, methodConfig, target.constructor, propertyKey);
-    // console.log('methods updated', methodConfig);
 };
 function GET(pathOrOptions, pathIsGlobal = false) {
     return function (target, propertyKey, descriptor) {
@@ -6024,21 +6141,16 @@ function DELETE(pathOrOptions, pathIsGlobal = false) {
 }
 
 function metaParam(param, name, expire, defaultValue = undefined, target, propertyKey, parameterIndex) {
-    let methodConfig = Reflect.getMetadata(Symbols.metadata.options.controllerMethod, target.constructor, propertyKey);
-    if (!methodConfig) {
-        methodConfig = new Models.MethodConfig();
-        Reflect.defineMetadata(Symbols.metadata.options.controllerMethod, methodConfig, target.constructor, propertyKey);
-    }
+    const methodCfg = ClassHelpers.ensureMethodConfig(target, propertyKey);
     const nameKey = name ? name : param;
-    const p = (methodConfig.parameters[nameKey] = !methodConfig.parameters[nameKey]
-        ? new Models.ParamConfig()
-        : methodConfig.parameters[nameKey]);
-    p.index = parameterIndex;
-    p.paramName = name;
-    p.paramType = param;
-    p.defaultType = defaultValue;
-    p.expireInSeconds = expire;
-    Reflect.defineMetadata(Symbols.metadata.options.controllerMethod, methodConfig, target.constructor, propertyKey);
+    // const key = name || `${param}_${parameterIndex}`;
+    methodCfg.parameters[nameKey] = {
+        index: parameterIndex,
+        paramName: name,
+        paramType: param,
+        defaultType: defaultValue,
+        expireInSeconds: expire,
+    };
     // console.log('params updated', methodConfig);
 }
 function Path(name) {
@@ -6116,7 +6228,10 @@ let BaseController = class BaseController extends BaseInjector {
 __decorate([
     POST({
         overrideContentType: 'multipart/form-data',
-        middlewares: [BaseFileUploadMiddleware],
+        middlewares: ({ parentMiddlewares }) => ({
+            ...parentMiddlewares,
+            BaseFileUploadMiddleware,
+        }),
     }),
     __param(0, Body()),
     __metadata("design:type", Function),