taon 19.0.53 → 19.0.54

package/websql/fesm2022/taon.mjs

@@ -6,11 +6,11 @@ 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 { Models as Models$1, Resource, RestHeaders, Mapping } from 'ng2-rest/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 * as JSON5 from 'json5';
 import { io } from 'socket.io-client';
@@ -122,6 +122,19 @@ var Orm;
 })(Orm || (Orm = {}));
 //#endregion
 
+class DecoratorAbstractOpt {
+}
+
+class TaonControllerOptions extends DecoratorAbstractOpt {
+}
+
+class ControllerConfig extends TaonControllerOptions {
+    constructor() {
+        super(...arguments);
+        this.methods = {};
+    }
+}
+
 var Symbols;
 (function (Symbols) {
     Symbols.ctxInClassOrClassObj = Symbol();
@@ -312,122 +325,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() {
-            //#region @websqlFunc
-            const result = _.cloneDeep(this);
-            if (result.recreateMode) {
-                if (result.recreateMode === 'DROP_DB+MIGRATIONS') {
-                    result.synchronize = true;
-                    result.dropSchema = true;
-                }
-                else if (result.recreateMode === 'PRESERVE_DATA+MIGRATIONS') {
-                    result.synchronize = false;
-                    result.dropSchema = false;
-                }
-            }
-            delete result.recreateMode;
-            return result;
-            //#endregion
-        }
-    }
-    Models.DatabaseConfig = DatabaseConfig;
-    //#endregion
-    //#region models / 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() {
-            //#endregion
-            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;
-        //#endregion
-    })(Http = Models.Http || (Models.Http = {}));
-    //#endregion
-})(Models || (Models = {}));
-
-/* */
+//#region imports
 /* */
+//#endregion
 var ClassHelpers;
 (function (ClassHelpers) {
     //#region get class from name
@@ -532,7 +432,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)
@@ -570,6 +470,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);
@@ -861,6 +767,103 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImpo
             type: Injectable
         }], ctorParameters: () => [] });
 
+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() {
+            //#region @websqlFunc
+            const result = _.cloneDeep(this);
+            if (result.recreateMode) {
+                if (result.recreateMode === 'DROP_DB+MIGRATIONS') {
+                    result.synchronize = true;
+                    result.dropSchema = true;
+                }
+                else if (result.recreateMode === 'PRESERVE_DATA+MIGRATIONS') {
+                    result.synchronize = false;
+                    result.dropSchema = false;
+                }
+            }
+            delete result.recreateMode;
+            return result;
+            //#endregion
+        }
+    }
+    Models.DatabaseConfig = DatabaseConfig;
+    //#endregion
+    //#region models / 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;
+        //#endregion
+    })(Http = Models.Http || (Models.Http = {}));
+    //#endregion
+})(Models || (Models = {}));
+
 //#region imports
 class ContextDbMigrations {
     //#endregion
@@ -3074,7 +3077,8 @@ class EndpointContext {
                 /* */
                 /* */
                 /* */
-                await this.initFrontnedMiddlewares();
+                /* */
+                await this.initCustomClientMiddlewares();
             }
             //#endregion
             //#region prepare realtime
@@ -3285,7 +3289,6 @@ class EndpointContext {
         /* */
         /* */
         /* */
-        /* */
         return (void 0);
     }
     //#endregion
@@ -3655,6 +3658,9 @@ class EndpointContext {
         return this.config.contextName;
     }
     //#endregion
+    get cwd() {
+        return this.config.cwd || process.cwd();
+    }
     get activeContext() {
         return this.config.activeContext || null;
     }
@@ -3858,6 +3864,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 => {
@@ -3881,6 +3888,7 @@ class EndpointContext {
                 }, [])
                     .join('/');
             }
+            //#endregion
             // console.log('calculatedPath', classConfig.calculatedPath);
             _.slice(configs, 1).forEach(bc => {
                 const alreadyIs = classConfig.methods;
@@ -3989,44 +3997,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() {
         /* */
         /* */
         /* */
@@ -4061,6 +4054,8 @@ class EndpointContext {
         /* */
         /* */
         /* */
+    }
+    async initBackendMiddlewares() {
         /* */
         /* */
         /* */
@@ -4170,16 +4165,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
-        //#region @websql
-        const requestHandler = methodConfig.requestHandler &&
-            typeof methodConfig.requestHandler === 'function'
-            ? methodConfig.requestHandler
-            : (req, res, next) => {
-                next();
-            };
-        //#endregion
+        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) => {
@@ -4189,7 +4199,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 });
@@ -4228,8 +4238,9 @@ class EndpointContext {
             //#region apply dummy websql express routers
             //#region @websql
             if (Helpers.isWebSQL) {
-                if (!this.expressApp[type.toLowerCase()]) {
-                    this.expressApp[type.toLowerCase()] = () => { };
+                if (!this.expressApp[httpMethodType.toLowerCase()]) {
+                    this.expressApp[httpMethodType.toLowerCase()] = () => { };
+                    // TODO add middlewares for WEBSQL and ELECTRON mode
                 }
             }
             //#endregion
@@ -4448,6 +4459,7 @@ class EndpointContext {
             /* */
             /* */
             /* */
+            /* */
         }
         return {
             expressPath: expressPath,
@@ -4461,10 +4473,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
@@ -4506,6 +4539,9 @@ class EndpointContext {
                 received['observable'] = from(received);
                 return {
                     received,
+                    request(axiosConfig) {
+                        return received;
+                    },
                 };
             };
             return;
@@ -4626,11 +4662,16 @@ class EndpointContext {
             if (Helpers.isWebSQL) {
                 return {
                     received,
+                    request(axiosConfig) {
+                        // console.log('request', axiosConfgi);
+                        return received;
+                    },
                 };
             }
         };
         if (Helpers.isWebSQL) {
-            return;
+            // @ts-ignore
+            return undefined;
         }
         //#endregion
         //#endregion
@@ -4673,8 +4714,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 = {};
@@ -4772,9 +4812,11 @@ instead
             }
             //#endregion
             const httpResultObj = {
-                received: isWithBody
-                    ? rest.model(pathPrams)[method](bodyObject, [queryParams])
-                    : rest.model(pathPrams)[method]([queryParams]),
+                received: rest.model(pathPrams)[method](bodyObject, [queryParams]),
+                request(axiosConfig) {
+                    return rest
+                        .model(pathPrams)[method](bodyObject, [queryParams], axiosConfig);
+                },
             };
             return httpResultObj;
         };
@@ -5002,16 +5044,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
@@ -5198,6 +5240,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 {
 };
@@ -5792,6 +5923,9 @@ BaseRepository = __decorate([
 const BaseContext = createContext(() => ({
     contextName: 'BaseContext',
     abstract: true,
+    middlewares: {
+        BaseFileUploadMiddleware,
+    },
     repositories: {
         // @ts-ignore
         BaseRepository,
@@ -5813,14 +5947,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;
@@ -5833,13 +5959,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 = '';
@@ -5861,7 +5988,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);
 };
@@ -5940,6 +6067,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.
@@ -6216,14 +6405,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
@@ -6260,7 +6441,7 @@ function TaonSubscriber(options) {
         ClassHelpers.setName(constructor, options?.className);
     };
 }
-class TaonSubscriberOptions extends Models.DecoratorAbstractOpt {
+class TaonSubscriberOptions extends DecoratorAbstractOpt {
 }
 
 let BaseSubscriberForEntity = class BaseSubscriberForEntity extends BaseInjector {
@@ -6423,7 +6604,6 @@ var Base;
     Base.Context = BaseContext;
 })(Base || (Base = {}));
 
-//#endregion
 /**
  * Entity decorator
  */
@@ -6443,20 +6623,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 {
 }
 
 /**
@@ -6469,7 +6636,7 @@ function TaonMigration(options) {
         ClassHelpers.setName(constructor, options?.className);
     };
 }
-class TaonMigrationOptions extends Models.DecoratorAbstractOpt {
+class TaonMigrationOptions extends DecoratorAbstractOpt {
 }
 
 /**
@@ -6482,7 +6649,7 @@ function TaonProvider(options) {
         ClassHelpers.setName(constructor, options?.className || constructor.name);
     };
 }
-class TaonProviderOptions extends Models.DecoratorAbstractOpt {
+class TaonProviderOptions extends DecoratorAbstractOpt {
 }
 
 var Http;