taon 19.0.53 → 19.0.55

package/browser/fesm2022/taon.mjs

@@ -1,19 +1,32 @@
 import 'reflect-metadata';
 import * as coreHelpers from 'tnp-core/browser';
-import { _, Utils, Helpers, UtilsOs } from 'tnp-core/browser';
+import { _, Utils, Helpers, UtilsOs, crossPlatformPath } from 'tnp-core/browser';
 import { __decorate, __metadata, __param } from 'tslib';
 import { walk } from 'lodash-walk-object/browser';
-import { OrignalClassKey, Table } from 'taon-typeorm/browser';
 import { SYMBOL, CLASS } from 'typescript-class-helpers/browser';
-import { Models as Models$1, Resource, RestHeaders, Mapping } from 'ng2-rest/browser';
+import { OrignalClassKey, Table } from 'taon-typeorm/browser';
 import * as i0 from '@angular/core';
 import { InjectionToken, inject as inject$1, Injectable } from '@angular/core';
 import axios from 'axios';
 import { JSON10 } from 'json10/browser';
+import { Models as Models$1, Resource, RestHeaders, Mapping } from 'ng2-rest/browser';
 import { Observable, from, Subject } from 'rxjs';
 import * as JSON5 from 'json5';
 import { io } from 'socket.io-client';
 
+class DecoratorAbstractOpt {
+}
+
+class TaonControllerOptions extends DecoratorAbstractOpt {
+}
+
+class ControllerConfig extends TaonControllerOptions {
+    constructor() {
+        super(...arguments);
+        this.methods = {};
+    }
+}
+
 var Symbols;
 (function (Symbols) {
     Symbols.ctxInClassOrClassObj = Symbol();
@@ -204,127 +217,9 @@ var Validators;
     };
 })(Validators || (Validators = {}));
 
-var Models;
-(function (Models) {
-    //#region models / class types
-    let ClassType;
-    (function (ClassType) {
-        ClassType["ENTITY"] = "ENTITY";
-        ClassType["CONTROLLER"] = "CONTROLLER";
-        ClassType["REPOSITORY"] = "REPOSITORY";
-        ClassType["PROVIDER"] = "PROVIDER";
-        ClassType["SUBSCRIBER"] = "SUBSCRIBER";
-        ClassType["MIGRATION"] = "MIGRATION";
-        ClassType["MIDDLEWARE"] = "MIDDLEWARE";
-    })(ClassType = Models.ClassType || (Models.ClassType = {}));
-    Models.ClassTypeKey = {
-        [ClassType.ENTITY]: 'entities',
-        [ClassType.CONTROLLER]: 'controllers',
-        [ClassType.REPOSITORY]: 'repositories',
-        [ClassType.PROVIDER]: 'providers',
-        [ClassType.SUBSCRIBER]: 'subscribers',
-        [ClassType.MIGRATION]: 'migrations',
-        [ClassType.MIDDLEWARE]: 'middlewares',
-    };
-    //#endregion
-    //#region models / database connection options
-    class DatabaseConfigTypeOrm {
-    }
-    Models.DatabaseConfigTypeOrm = DatabaseConfigTypeOrm;
-    //#endregion
-    //#region models / database config
-    class DatabaseConfig extends DatabaseConfigTypeOrm {
-        static from(databasePartialConfig) {
-            return _.merge(new DatabaseConfig(), databasePartialConfig);
-        }
-        get databaseConfigTypeORM() {
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            return (void 0);
-        }
-    }
-    Models.DatabaseConfig = DatabaseConfig;
-    //#endregion
-    //#region models / decorator abstract options
-    class DecoratorAbstractOpt {
-    }
-    Models.DecoratorAbstractOpt = DecoratorAbstractOpt;
-    //#endregion
-    //#region models / param config
-    class ParamConfig {
-    }
-    Models.ParamConfig = ParamConfig;
-    //#endregion
-    //#region models / method config
-    class MethodConfig {
-        constructor() {
-            /* */
-            /* */
-            this.parameters = {};
-        }
-    }
-    Models.MethodConfig = MethodConfig;
-    //#endregion
-    //#region models / controller config
-    class ControllerConfig extends DecoratorAbstractOpt {
-        constructor() {
-            super(...arguments);
-            this.methods = {};
-        }
-    }
-    Models.ControllerConfig = ControllerConfig;
-    //#endregion
-    //#region models / runtime controller config
-    class RuntimeControllerConfig extends ControllerConfig {
-    }
-    Models.RuntimeControllerConfig = RuntimeControllerConfig;
-    //#endregion
-    //#region models / http
-    let Http;
-    (function (Http) {
-        Http.Rest = Models$1;
-        class Errors {
-            constructor(message, code = 400) {
-                this.message = message;
-                this.code = code;
-                this.toString = () => {
-                    return this.message;
-                };
-            }
-            static create(message, code = 400) {
-                return new Errors(message, code);
-            }
-            static entityNotFound(entity) {
-                return Errors.create(`Entity ${ClassHelpers.getName(entity)} not found`);
-            }
-            static custom(message, code = 400) {
-                return Errors.create(message, code);
-            }
-        }
-        Http.Errors = Errors;
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-    })(Http = Models.Http || (Models.Http = {}));
-    //#endregion
-})(Models || (Models = {}));
-
-/* */
+//#region imports
 /* */
+//#endregion
 var ClassHelpers;
 (function (ClassHelpers) {
     //#region get class from name
@@ -429,7 +324,7 @@ var ClassHelpers;
     //#region get all metadata for controller
     ClassHelpers.getControllerConfig = (target) => {
         const classMetadataOptions = Reflect.getMetadata(Symbols.metadata.options.controller, target);
-        const classMetadata = _.merge(new Models.ControllerConfig(), classMetadataOptions);
+        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)
@@ -467,6 +362,12 @@ var ClassHelpers;
         'toLocaleString',
     ];
     //#endregion
+    /**
+     * Express async handler for middleware functions.
+     */
+    ClassHelpers.asyncHandler = fn => (req, res, next) => {
+        Promise.resolve(fn(req, res, next)).catch(next);
+    };
     ClassHelpers.getMethodsNames = (classOrClassInstance, allMethodsNames = []) => {
         if (!classOrClassInstance) {
             return Utils.uniqArray(allMethodsNames);
@@ -1390,6 +1291,107 @@ var TaonHelpers;
     //#endregion
 })(TaonHelpers || (TaonHelpers = {}));
 
+var Models;
+(function (Models) {
+    //#region models / class types
+    let ClassType;
+    (function (ClassType) {
+        ClassType["ENTITY"] = "ENTITY";
+        ClassType["CONTROLLER"] = "CONTROLLER";
+        ClassType["REPOSITORY"] = "REPOSITORY";
+        ClassType["PROVIDER"] = "PROVIDER";
+        ClassType["SUBSCRIBER"] = "SUBSCRIBER";
+        ClassType["MIGRATION"] = "MIGRATION";
+        ClassType["MIDDLEWARE"] = "MIDDLEWARE";
+    })(ClassType = Models.ClassType || (Models.ClassType = {}));
+    Models.ClassTypeKey = {
+        [ClassType.ENTITY]: 'entities',
+        [ClassType.CONTROLLER]: 'controllers',
+        [ClassType.REPOSITORY]: 'repositories',
+        [ClassType.PROVIDER]: 'providers',
+        [ClassType.SUBSCRIBER]: 'subscribers',
+        [ClassType.MIGRATION]: 'migrations',
+        [ClassType.MIDDLEWARE]: 'middlewares',
+    };
+    //#endregion
+    //#region models / database connection options
+    class DatabaseConfigTypeOrm {
+    }
+    Models.DatabaseConfigTypeOrm = DatabaseConfigTypeOrm;
+    //#endregion
+    //#region models / database config
+    class DatabaseConfig extends DatabaseConfigTypeOrm {
+        static from(databasePartialConfig) {
+            return _.merge(new DatabaseConfig(), databasePartialConfig);
+        }
+        get databaseConfigTypeORM() {
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            return (void 0);
+        }
+    }
+    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) {
+        Http.Rest = Models$1;
+        class Errors {
+            constructor(message, code = 400) {
+                this.message = message;
+                this.code = code;
+                this.toString = () => {
+                    return this.message;
+                };
+            }
+            static create(message, code = 400) {
+                return new Errors(message, code);
+            }
+            static entityNotFound(entity) {
+                return Errors.create(`Entity ${ClassHelpers.getName(entity)} not found`);
+            }
+            static custom(message, code = 400) {
+                return Errors.create(message, code);
+            }
+        }
+        Http.Errors = Errors;
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+    })(Http = Models.Http || (Models.Http = {}));
+    //#endregion
+})(Models || (Models = {}));
+
 //#region imports
 /* */
 /* */
@@ -3121,7 +3123,8 @@ class EndpointContext {
                 /* */
                 /* */
                 /* */
-                await this.initFrontnedMiddlewares();
+                /* */
+                await this.initCustomClientMiddlewares();
             }
             //#endregion
             //#region prepare realtime
@@ -3342,7 +3345,6 @@ class EndpointContext {
         /* */
         /* */
         /* */
-        /* */
         return (void 0);
     }
     //#endregion
@@ -3715,6 +3717,9 @@ class EndpointContext {
         return this.config.contextName;
     }
     //#endregion
+    get cwd() {
+        return this.config.cwd || process.cwd();
+    }
     get activeContext() {
         return this.config.activeContext || null;
     }
@@ -3951,6 +3956,7 @@ class EndpointContext {
             const configs = ClassHelpers.getControllerConfigs(controllerClassFn);
             // 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 => {
@@ -3974,6 +3980,7 @@ class EndpointContext {
                 }, [])
                     .join('/');
             }
+            //#endregion
             // console.log('calculatedPath', classConfig.calculatedPath);
             _.slice(configs, 1).forEach(bc => {
                 const alreadyIs = classConfig.methods;
@@ -4097,44 +4104,29 @@ class EndpointContext {
     }
     //#endregion
     //#region methods & getters / init middlewares
-    async initFrontnedMiddlewares() {
-        const middlewares = this.getClassesInstancesArrBy(Models.ClassType.MIDDLEWARE);
-        for (const middleware of middlewares) {
-            const middlewareInstance = middleware;
-            if (_.isFunction(middlewareInstance.intercept)) {
-                ((instance, contextName, apiPart, uriPathnameOrNothingIfRoot) => {
-                    const interceptorName = `${contextName}-${ClassHelpers.getName(instance)}`;
-                    Resource.request.interceptors.set(interceptorName, async (req) => {
-                        console.log('request', req);
-                        const url = new URL(req.url);
-                        if (url.pathname.startsWith(`${uriPathnameOrNothingIfRoot}/${apiPart}/${contextName}/`)) {
-                            await instance.intercept({
-                                client: {
-                                    req,
-                                },
-                            });
-                        }
-                        else {
-                            // console.log('not fit frontend', url.href);
-                        }
-                        return req;
-                    });
-                })(middlewareInstance, this.contextName, apiPrefix, this.uriPathnameOrNothingIfRoot);
-            }
-        }
+    async initCustomClientMiddlewares() {
+        const middlewares = this.getClassesInstancesArrBy(Models.ClassType.MIDDLEWARE)
+            .map(f => f)
+            .filter(f => _.isFunction(f.interceptClient));
+        middlewares.forEach(instance => {
+            const contextName = this.contextName;
+            const interceptorName = `${contextName}-${ClassHelpers.getName(instance)}`;
+            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({
+                            req,
+                            next,
+                        });
+                    }
+                    return next.handle(req);
+                },
+            });
+        });
     }
-    async initBackendMiddlewares() {
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
+    async initCustomBackendMiddlewares() {
         /* */
         /* */
         /* */
@@ -4169,6 +4161,8 @@ class EndpointContext {
         /* */
         /* */
         /* */
+    }
+    async initBackendMiddlewares() {
         /* */
         /* */
         /* */
@@ -4278,16 +4272,31 @@ class EndpointContext {
     //#region methods & getters / init methods node
     initServer(
     //#region parameters
-    type, methodConfig, classConfig, expressPath, target) {
+    httpMethodType, methodConfig, classConfig, expressPath, target) {
         //#region resolve variables
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
+        const middlewareHandlers = (Array.isArray(methodConfig.middlewares) &&
+            methodConfig.middlewares?.length > 0
+            ? methodConfig.middlewares
+            : [])
+            .map(middlewareClassFun => {
+            const middlewareInstance = this.getInstanceBy(middlewareClassFun);
+            if (middlewareInstance &&
+                _.isFunction(middlewareInstance.interceptServerMethod)) {
+                const middlewareFn = ClassHelpers.asyncHandler(async (req, res, next) => {
+                    await middlewareInstance.interceptServerMethod({
+                        req,
+                        res,
+                        next,
+                    }, {
+                        methodName: methodConfig.methodName,
+                        expressPath,
+                        httpRequestType: methodConfig.type,
+                    });
+                });
+                return middlewareFn;
+            }
+        })
+            .filter(f => !!f);
         // const url = this.uri;
         //#region get result
         const getResult = async (resolvedParams, req, res) => {
@@ -4297,7 +4306,7 @@ class EndpointContext {
              */
             this.getInstanceBy(target), 
             /**
-             * Params for metjod @GET, @PUT etc.
+             * Params for method @GET, @PUT etc.
              */
             resolvedParams);
             let result = await getResponseValue(response, { req, res });
@@ -4340,6 +4349,7 @@ class EndpointContext {
             /* */
             /* */
             /* */
+            /* */
             //#endregion
             /* */
             /* */
@@ -4555,6 +4565,7 @@ class EndpointContext {
             /* */
             /* */
             /* */
+            /* */
         }
         return {
             expressPath: expressPath,
@@ -4568,10 +4579,31 @@ class EndpointContext {
      */
     async initClient(
     //#region parameters
-    target, type, methodConfig, expressPath) {
+    target, httpRequestType, methodConfig, // Models.Http.Rest.MethodConfig,
+    expressPath) {
         const ctx = this;
+        //#region init middlewares
+        const middlewares = methodConfig.middlewares
+            .map(f => this.getInstanceBy(f))
+            .filter(f => _.isFunction(f.interceptClientMethod));
+        middlewares.forEach(instance => {
+            Resource.request.methodsInterceptors.set(`${methodConfig.type?.toUpperCase()}-${expressPath}`, {
+                intercept: ({ req, next }) => {
+                    return instance.interceptClientMethod({
+                        req,
+                        next,
+                    }, {
+                        methodName: methodConfig.methodName,
+                        expressPath,
+                        httpRequestType: httpRequestType,
+                    });
+                },
+            });
+        });
+        //#endregion
         // : { received: any; /* Rest<any, any>  */ }
-        this.logHttp && console.log(`${type?.toUpperCase()} ${expressPath} `);
+        this.logHttp &&
+            console.log(`${httpRequestType?.toUpperCase()} ${expressPath} `);
         // console.log('INITING', methodConfig); // TODO inject in static
         //#region resolve storage
         // TODO not a good idea
@@ -4613,6 +4645,9 @@ class EndpointContext {
                 received['observable'] = from(received);
                 return {
                     received,
+                    request(axiosConfig) {
+                        return received;
+                    },
                 };
             };
             return;
@@ -4764,6 +4799,11 @@ class EndpointContext {
         /* */
         /* */
         /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
         //#endregion
         //#region handle normal request
         target.prototype[methodConfig.methodName] = function (...args) {
@@ -4804,8 +4844,7 @@ class EndpointContext {
             else {
                 rest = endpoints[ctx.uriOrigin][expressPath];
             }
-            const method = type.toLowerCase();
-            const isWithBody = method === 'put' || method === 'post';
+            const method = httpRequestType.toLowerCase();
             const pathPrams = {};
             let queryParams = {};
             let bodyObject = {};
@@ -4903,9 +4942,13 @@ instead
             }
             //#endregion
             const httpResultObj = {
-                received: isWithBody
-                    ? rest.model(pathPrams)[method](bodyObject, [queryParams])
-                    : rest.model(pathPrams)[method]([queryParams]),
+                get received() {
+                    return rest.model(pathPrams)[method](bodyObject, [queryParams]);
+                },
+                request(axiosConfig) {
+                    return rest
+                        .model(pathPrams)[method](bodyObject, [queryParams], axiosConfig);
+                },
             };
             return httpResultObj;
         };
@@ -5178,16 +5221,16 @@ const createContext = (configFn) => {
 };
 
 /**
- * Repository decorator
+ * Provider decorator
  */
-function TaonRepository(options) {
+function TaonMiddleware(options) {
     return function (constructor) {
-        Reflect.defineMetadata(Symbols.metadata.options.repository, options, constructor);
+        Reflect.defineMetadata(Symbols.metadata.options.provider, options, constructor);
         Reflect.defineMetadata(Symbols.metadata.className, options?.className || constructor.name, constructor);
-        ClassHelpers.setName(constructor, options?.className);
+        ClassHelpers.setName(constructor, options?.className || constructor.name);
     };
 }
-class TaonRepositoryOptions extends Models.DecoratorAbstractOpt {
+class TaonMiddlewareOptions extends DecoratorAbstractOpt {
 }
 
 //#endregion
@@ -5374,6 +5417,95 @@ class BaseInjector {
     }
 }
 
+/**
+ * TODO
+ * - global provider available in all contexts
+ * - provider available in own context
+ */
+class BaseMiddleware extends BaseInjector {
+}
+
+//#endregion
+/**
+ * Configurable file upload middleware (multer based)
+ */
+let BaseFileUploadMiddleware = class BaseFileUploadMiddleware extends BaseMiddleware {
+    async interceptServerMethod({ req, res, next }, { methodName, expressPath }) {
+        return this.middleware()(req, res, next);
+    }
+    //#region upload Dir
+    uploadDir() {
+        return crossPlatformPath([this.ctx.cwd, 'uploaded-files']);
+    }
+    //#endregion
+    //#region storage
+    storage() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    //#endregion
+    //#region upload
+    upload() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    //#endregion
+    //#region middleware
+    middleware() {
+        /* */
+        /* */
+        return (void 0);
+    }
+};
+BaseFileUploadMiddleware = __decorate([
+    TaonMiddleware({
+        className: 'BaseFileUploadMiddleware',
+    })
+], BaseFileUploadMiddleware);
+
+/**
+ * Repository decorator
+ */
+function TaonRepository(options) {
+    return function (constructor) {
+        Reflect.defineMetadata(Symbols.metadata.options.repository, options, constructor);
+        Reflect.defineMetadata(Symbols.metadata.className, options?.className || constructor.name, constructor);
+        ClassHelpers.setName(constructor, options?.className);
+    };
+}
+class TaonRepositoryOptions extends DecoratorAbstractOpt {
+}
+
 //#endregion
 let BaseCustomRepository = class BaseCustomRepository extends BaseInjector {
 };
@@ -5994,6 +6126,9 @@ BaseRepository = __decorate([
 const BaseContext = createContext(() => ({
     contextName: 'BaseContext',
     abstract: true,
+    middlewares: {
+        BaseFileUploadMiddleware,
+    },
     repositories: {
         // @ts-ignore
         BaseRepository,
@@ -6015,14 +6150,6 @@ function TaonController(options) {
         Reflect.defineMetadata(Symbols.metadata.className, options?.className || constructor.name, constructor);
     };
 }
-class TaonControllerOptions extends Models.DecoratorAbstractOpt {
-}
-
-let BaseController = class BaseController extends BaseInjector {
-};
-BaseController = __decorate([
-    TaonController({ className: 'BaseController' })
-], BaseController);
 
 const metaReq = (method, path, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal) => {
     let options;
@@ -6035,13 +6162,14 @@ const metaReq = (method, path, target, propertyKey, descriptor, pathOrOptions, p
     else {
         options = { pathOrOptions, pathIsGlobal };
     }
-    const { overrideContentType, overridResponseType } = options;
+    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.type = method;
     if (!path) {
         let paramsPathConcatedPath = '';
@@ -6063,7 +6191,7 @@ const metaReq = (method, path, target, propertyKey, descriptor, pathOrOptions, p
     methodConfig.descriptor = descriptor;
     methodConfig.global = pathIsGlobal;
     methodConfig.contentType = overrideContentType;
-    methodConfig.responseType = overridResponseType;
+    methodConfig.responseType = overrideResponseType;
     Reflect.defineMetadata(Symbols.metadata.options.controllerMethod, methodConfig, target.constructor, propertyKey);
     // console.log('methods updated', methodConfig);
 };
@@ -6142,6 +6270,68 @@ function Body(name) {
     };
 }
 
+/* */
+/* */
+let BaseController = class BaseController extends BaseInjector {
+    //#region upload form data to server
+    uploadFormDataToServer(formData) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    //#endregion
+    //#region upload local file to server
+    async uploadLocalFileToServer(absFilePath) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+};
+__decorate([
+    POST({
+        overrideContentType: 'multipart/form-data',
+        middlewares: [BaseFileUploadMiddleware],
+    }),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FormData]),
+    __metadata("design:returntype", Object)
+], BaseController.prototype, "uploadFormDataToServer", null);
+BaseController = __decorate([
+    TaonController({
+        className: 'BaseController',
+    })
+], BaseController);
+
 //#endregion
 /**
  * Please override property entityClassFn with entity class.
@@ -6426,14 +6616,6 @@ BaseCrudController = __decorate([
     TaonController({ className: 'BaseCrudController' })
 ], BaseCrudController);
 
-/**
- * TODO
- * - global provider available in all contexts
- * - provider available in own context
- */
-class BaseMiddleware extends BaseInjector {
-}
-
 class BaseMigration extends BaseInjector {
     /**
      * by default is READY to run
@@ -6470,7 +6652,7 @@ function TaonSubscriber(options) {
         ClassHelpers.setName(constructor, options?.className);
     };
 }
-class TaonSubscriberOptions extends Models.DecoratorAbstractOpt {
+class TaonSubscriberOptions extends DecoratorAbstractOpt {
 }
 
 let BaseSubscriberForEntity = class BaseSubscriberForEntity extends BaseInjector {
@@ -6633,8 +6815,6 @@ var Base;
     Base.Context = BaseContext;
 })(Base || (Base = {}));
 
-/* */
-/* */
 /**
  * Entity decorator
  */
@@ -6653,20 +6833,7 @@ function TaonEntity(options) {
         CLASS.setName(constructor, options?.className); // TODO QUICK_FIX for ng2-rest
     };
 }
-class TaonEntityOptions extends Models.DecoratorAbstractOpt {
-}
-
-/**
- * Provider decorator
- */
-function TaonMiddleware(options) {
-    return function (constructor) {
-        Reflect.defineMetadata(Symbols.metadata.options.provider, options, constructor);
-        Reflect.defineMetadata(Symbols.metadata.className, options?.className || constructor.name, constructor);
-        ClassHelpers.setName(constructor, options?.className || constructor.name);
-    };
-}
-class TaonMiddlewareOptions extends Models.DecoratorAbstractOpt {
+class TaonEntityOptions extends DecoratorAbstractOpt {
 }
 
 /**
@@ -6679,7 +6846,7 @@ function TaonMigration(options) {
         ClassHelpers.setName(constructor, options?.className);
     };
 }
-class TaonMigrationOptions extends Models.DecoratorAbstractOpt {
+class TaonMigrationOptions extends DecoratorAbstractOpt {
 }
 
 /**
@@ -6692,7 +6859,7 @@ function TaonProvider(options) {
         ClassHelpers.setName(constructor, options?.className || constructor.name);
     };
 }
-class TaonProviderOptions extends Models.DecoratorAbstractOpt {
+class TaonProviderOptions extends DecoratorAbstractOpt {
 }
 
 var Http;