@avleon/core 0.0.19 → 0.0.24

package/dist/icore.js

@@ -32,24 +32,6 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -75,6 +57,8 @@ const config_1 = require("./config");
 const environment_variables_1 = require("./environment-variables");
 const cors_1 = __importDefault(require("@fastify/cors"));
 const multipart_1 = __importDefault(require("@fastify/multipart"));
+const validation_1 = require("./validation");
+const utils_1 = require("./utils");
 const isTsNode = process.env.TS_NODE_DEV ||
     process.env.TS_NODE_PROJECT ||
     process[Symbol.for("ts-node.register.instance")];
@@ -93,12 +77,19 @@ class AvleonApplication {
         this.controllers = [];
         this.authorizeMiddleware = undefined;
         this.dataSource = undefined;
+        this.isMapFeatures = false;
         this.metaCache = new Map();
         this.app = (0, fastify_1.default)();
         this.appConfig = new config_1.AppConfig();
-        // this.app.setValidatorCompiler(() => () => true);
     }
     isTest() { }
+    static getApp() {
+        let isTestEnv = process.env.NODE_ENV == "test";
+        if (!AvleonApplication.instance) {
+            AvleonApplication.instance = new AvleonApplication();
+        }
+        return AvleonApplication.instance;
+    }
     static getInternalApp(buildOptions) {
         let isTestEnv = process.env.NODE_ENV == "test";
         if (!AvleonApplication.instance) {
@@ -110,7 +101,7 @@ class AvleonApplication {
                 buildOptions.dataSourceOptions;
             const typeorm = require("typeorm");
             const datasource = new typeorm.DataSource(buildOptions.dataSourceOptions);
-            typedi_1.default.set(isTestEnv ? "itestdatasource" : "idatasource", datasource);
+            typedi_1.default.set("idatasource", datasource);
             AvleonApplication.instance.dataSource = datasource;
         }
         return AvleonApplication.instance;
@@ -120,13 +111,20 @@ class AvleonApplication {
         return env.get("NODE_ENV") == "development";
     }
     async initSwagger(options) {
-        const { routePrefix, logo, ui, theme, configuration } = options, restOptions = __rest(options, ["routePrefix", "logo", "ui", "theme", "configuration"]);
+        const { routePrefix, logo, ui, theme, configuration, ...restOptions } = options;
         this.app.register(swagger_1.default, {
-            openapi: Object.assign({ openapi: "3.0.0" }, restOptions),
+            openapi: {
+                openapi: "3.0.0",
+                ...restOptions,
+            },
         });
         const rPrefix = routePrefix ? routePrefix : "/docs";
         if (options.ui && options.ui == "scalar") {
-            await this.app.register(require("@scalar/fastify-api-reference"), {
+            const scalarPlugin = (0, utils_1.optionalRequire)("@scalar/fastify-api-reference", {
+                failOnMissing: true,
+                customMessage: 'Install "@scalar/fastify-api-reference" to enable API docs.\n\n  npm install @scalar/fastify-api-reference',
+            });
+            await this.app.register(scalarPlugin, {
                 routePrefix: rPrefix,
                 configuration: configuration
                     ? configuration
@@ -141,18 +139,14 @@ class AvleonApplication {
             });
         }
         else {
-            await this.app.register(require("@fastify/swagger-ui"), {
+            const fastifySwaggerUi = (0, utils_1.optionalRequire)("@fastify/swagger-ui", {
+                failOnMissing: true,
+                customMessage: 'Install "@fastify/swagger-ui" to enable API docs.\n\n  npm install @fastify/swagger-ui',
+            });
+            await this.app.register(fastifySwaggerUi, {
                 logo: logo ? logo : null,
                 theme: theme ? theme : {},
                 routePrefix: rPrefix,
-                configuration: {
-                    metaData: {
-                        title: "Avleon Api",
-                        ogTitle: "Avleon",
-                    },
-                    theme: "kepler",
-                    favicon: "/static/favicon.png",
-                },
             });
         }
     }
@@ -171,16 +165,94 @@ class AvleonApplication {
         this.hasSwagger = true;
     }
     /**
-     * @deprecated
-     * Will remove in next major version
+     * Registers the fastify-multipart plugin with the Fastify instance.
+     * This enables handling of multipart/form-data requests, typically used for file uploads.
+     *
+     * @param {MultipartOptions} options - Options to configure the fastify-multipart plugin.
+     * @param {FastifyInstance} this.app - The Fastify instance to register the plugin with.
+     * @property {MultipartOptions} this.multipartOptions - Stores the provided multipart options.
+     * @see {@link https://github.com/fastify/fastify-multipart} for more details on available options.
      */
-    async useSwagger(options) {
-        this.hasSwagger = true;
-        this.globalSwaggerOptions = options;
-    }
     useMultipart(options) {
         this.multipartOptions = options;
-        this.app.register(multipart_1.default, Object.assign(Object.assign({}, this.multipartOptions), { attachFieldsToBody: true }));
+        this.app.register(multipart_1.default, {
+            ...this.multipartOptions,
+            attachFieldsToBody: true,
+        });
+    }
+    /**
+     * Configures and initializes a TypeORM DataSource based on the provided configuration class.
+     * It retrieves the configuration from the application's configuration service and allows for optional modification.
+     * The initialized DataSource is then stored and registered within a dependency injection container.
+     *
+     * @template T - A generic type extending the `IConfig` interface, representing the configuration class.
+     * @template R - A generic type representing the return type of the configuration method of the `ConfigClass`.
+     * @param {Constructable<T>} ConfigClass - The constructor of the configuration class to be used for creating the DataSource.
+     * @param {(config: R) => R} [modifyConfig] - An optional function that takes the initial configuration and returns a modified configuration.
+     * @returns {void}
+     * @property {DataSourceOptions} this.dataSourceOptions - Stores the final DataSource options after potential modification.
+     * @property {DataSource} this.dataSource - Stores the initialized TypeORM DataSource instance.
+     * @see {@link https://typeorm.io/} for more information about TypeORM.
+     */
+    useDataSource(ConfigClass, modifyConfig) {
+        const dsConfig = this.appConfig.get(ConfigClass);
+        if (modifyConfig) {
+            const modifiedConfig = modifyConfig(dsConfig);
+            this.dataSourceOptions = modifiedConfig;
+        }
+        else {
+            this.dataSourceOptions = dsConfig;
+        }
+        const typeorm = require("typeorm");
+        const datasource = new typeorm.DataSource(dsConfig);
+        this.dataSource = datasource;
+        typedi_1.default.set("idatasource", datasource);
+    }
+    /**
+     * Registers an array of middleware classes to be executed before request handlers.
+     * It retrieves instances of the middleware classes from the dependency injection container
+     * and adds them as 'preHandler' hooks to the Fastify application.
+     *
+     * @template T - A generic type extending the `AppMiddleware` interface, representing the middleware class.
+     * @param {Constructor<T>[]} mclasses - An array of middleware class constructors to be registered.
+     * @returns {void}
+     * @property {Map<string, T>} this.middlewares - Stores the registered middleware instances, keyed by their class names.
+     * @see {@link https://www.fastify.io/docs/latest/Reference/Hooks/#prehandler} for more information about Fastify preHandler hooks.
+     */
+    useMiddlewares(mclasses) {
+        for (const mclass of mclasses) {
+            const cls = typedi_1.default.get(mclass);
+            this.middlewares.set(mclass.name, cls);
+            this.app.addHook("preHandler", cls.invoke);
+        }
+    }
+    /**
+     * Registers a middleware constructor to be used for authorization purposes.
+     * The specific implementation and usage of this middleware will depend on the application's authorization logic.
+     *
+     * @template T - A generic type representing the constructor of the authorization middleware.
+     * @param {Constructor<T>} middleware - The constructor of the middleware to be used for authorization.
+     * @returns {void}
+     * @property {any} this.authorizeMiddleware - Stores the constructor of the authorization middleware.
+     */
+    useAuthoriztion(middleware) {
+        this.authorizeMiddleware = middleware;
+    }
+    /**
+     * Registers the `@fastify/static` plugin to serve static files.
+     * It configures the root directory and URL prefix for serving static assets.
+     *
+     * @param {StaticFileOptions} [options={ path: undefined, prefix: undefined }] - Optional configuration for serving static files.
+     * @param {string} [options.path] - The absolute path to the static files directory. Defaults to 'process.cwd()/public'.
+     * @param {string} [options.prefix] - The URL prefix for serving static files. Defaults to '/static/'.
+     * @returns {void}
+     * @see {@link https://github.com/fastify/fastify-static} for more details on available options.
+     */
+    useStaticFiles(options = { path: undefined, prefix: undefined }) {
+        this.app.register(require("@fastify/static"), {
+            root: options.path ? options.path : path_1.default.join(process.cwd(), "public"),
+            prefix: options.prefix ? options.prefix : "/static/",
+        });
     }
     handleMiddlewares(mclasses) {
         for (const mclass of mclasses) {
@@ -202,7 +274,6 @@ class AvleonApplication {
      * @returns void
      */
     async buildController(controller) {
-        var _a, e_1, _b, _c;
         const ctrl = typedi_1.default.get(controller);
         const controllerMeta = Reflect.getMetadata(container_1.CONTROLLER_META_KEY, ctrl.constructor);
         if (!controllerMeta)
@@ -212,89 +283,101 @@ class AvleonApplication {
         const tag = ctrl.constructor.name.replace("Controller", "");
         const swaggerControllerMeta = Reflect.getMetadata("controller:openapi", ctrl.constructor) || {};
         const authClsMeata = Reflect.getMetadata(container_1.AUTHORIZATION_META_KEY, ctrl.constructor) || { authorize: false, options: undefined };
-        if (authClsMeata.authorize && this.authorizeMiddleware) {
-            this.app.addHook("preHandler", (req, res) => {
-                return this.authorizeMiddleware.authorize(req);
-            });
-        }
-        try {
-            for (var _d = true, methods_1 = __asyncValues(methods), methods_1_1; methods_1_1 = await methods_1.next(), _a = methods_1_1.done, !_a; _d = true) {
-                _c = methods_1_1.value;
-                _d = false;
-                const method = _c;
-                const methodMeta = Reflect.getMetadata(container_1.ROUTE_META_KEY, prototype, method);
-                if (!methodMeta)
-                    continue;
-                const methodmetaOptions = {
-                    method: methodMeta.method.toLowerCase(),
-                    path: (0, helpers_1.formatUrl)(controllerMeta.path + methodMeta.path),
-                };
-                const routeKey = `${methodmetaOptions.method}:${methodmetaOptions.path}`;
-                if (!this.routeSet.has(routeKey)) {
-                    this.routeSet.add(routeKey);
+        for await (const method of methods) {
+            const methodMeta = Reflect.getMetadata(container_1.ROUTE_META_KEY, prototype, method);
+            if (!methodMeta)
+                continue;
+            const methodmetaOptions = {
+                method: methodMeta.method.toLowerCase(),
+                path: (0, helpers_1.formatUrl)(controllerMeta.path + methodMeta.path),
+            };
+            const routeKey = `${methodmetaOptions.method}:${methodmetaOptions.path}`;
+            if (!this.routeSet.has(routeKey)) {
+                this.routeSet.add(routeKey);
+            }
+            const classMiddlewares = this.executeMiddlewares(ctrl, method);
+            // handle openapi data
+            const swaggerMeta = Reflect.getMetadata("route:openapi", prototype, method) || {};
+            const authClsMethodMeata = Reflect.getMetadata(container_1.AUTHORIZATION_META_KEY, ctrl.constructor, method) || { authorize: false, options: undefined };
+            const allMeta = this._processMeta(prototype, method);
+            let bodySchema = null;
+            allMeta.body.forEach((r) => {
+                if (r.schema) {
+                    bodySchema = { ...r.schema };
                 }
-                const classMiddlewares = this.executeMiddlewares(ctrl, method);
-                // handle openapi data
-                const swaggerMeta = Reflect.getMetadata("route:openapi", prototype, method) || {};
-                const authClsMethodMeata = Reflect.getMetadata(container_1.AUTHORIZATION_META_KEY, ctrl.constructor, method) || { authorize: false, options: undefined };
-                const allMeta = this._processMeta(prototype, method);
-                let bodySchema = null;
-                allMeta.body.forEach((r) => {
-                    if (r.schema) {
-                        bodySchema = Object.assign({}, r.schema);
+            });
+            const routePath = methodmetaOptions.path == "" ? "/" : methodmetaOptions.path;
+            let schema = { ...swaggerControllerMeta, ...swaggerMeta, tags: [tag] };
+            if (!swaggerMeta.body && bodySchema) {
+                schema = { ...schema, body: bodySchema };
+            }
+            this.app.route({
+                url: routePath,
+                method: methodmetaOptions.method.toUpperCase(),
+                schema: { ...schema },
+                handler: async (req, res) => {
+                    let reqClone = req;
+                    // class level authrization
+                    if (authClsMeata.authorize && this.authorizeMiddleware) {
+                        const cls = container_1.default.get(this.authorizeMiddleware);
+                        await cls.authorize(reqClone, authClsMeata.options);
+                        if (res.sent)
+                            return;
                     }
-                });
-                const routePath = methodmetaOptions.path == "" ? "/" : methodmetaOptions.path;
-                let schema = Object.assign(Object.assign(Object.assign({}, swaggerControllerMeta), swaggerMeta), { tags: [tag] });
-                if (!swaggerMeta.body && bodySchema) {
-                    schema = Object.assign(Object.assign({}, schema), { body: bodySchema });
-                }
-                this.app.route({
-                    url: routePath,
-                    method: methodmetaOptions.method.toUpperCase(),
-                    schema: Object.assign({}, schema),
-                    handler: async (req, res) => {
-                        let reqClone = req;
-                        if (authClsMethodMeata.authorize && this.authorizeMiddleware) {
-                            const cls = container_1.default.get(this.authorizeMiddleware);
-                            await cls.authorize(reqClone, authClsMethodMeata.options);
+                    // method level authorization
+                    if (authClsMethodMeata.authorize && this.authorizeMiddleware) {
+                        const cls = container_1.default.get(this.authorizeMiddleware);
+                        await cls.authorize(reqClone, authClsMethodMeata.options);
+                        if (res.sent)
+                            return;
+                    }
+                    if (classMiddlewares.length > 0) {
+                        for (let m of classMiddlewares) {
+                            const cls = typedi_1.default.get(m.constructor);
+                            reqClone = (await cls.invoke(reqClone, res));
                             if (res.sent)
                                 return;
                         }
-                        if (classMiddlewares.length > 0) {
-                            for (let m of classMiddlewares) {
-                                const cls = typedi_1.default.get(m.constructor);
-                                reqClone = (await cls.invoke(reqClone, res));
-                                if (res.sent)
-                                    return;
+                    }
+                    const args = await this._mapArgs(reqClone, allMeta);
+                    for (let paramMeta of allMeta.params) {
+                        if (paramMeta.required) {
+                            (0, validation_1.validateOrThrow)({ [paramMeta.key]: args[paramMeta.index] }, { [paramMeta.key]: { type: paramMeta.dataType } }, { location: 'param' });
+                        }
+                    }
+                    for (let queryMeta of allMeta.query) {
+                        if (queryMeta.validatorClass) {
+                            const err = await (0, helpers_1.validateObjectByInstance)(queryMeta.dataType, args[queryMeta.index]);
+                            if (err) {
+                                return await res.code(400).send({
+                                    code: 400,
+                                    error: "ValidationError",
+                                    errors: err,
+                                    message: err.message,
+                                });
                             }
                         }
-                        const args = await this._mapArgs(reqClone, allMeta);
-                        for (let bodyMeta of allMeta.body) {
-                            if (bodyMeta.validatorClass) {
-                                const err = await (0, helpers_1.validateObjectByInstance)(bodyMeta.dataType, args[bodyMeta.index]);
-                                if (err) {
-                                    return await res.code(400).send({
-                                        code: 400,
-                                        error: "ValidationError",
-                                        errors: err,
-                                        message: err.message,
-                                    });
-                                }
+                        if (queryMeta.required) {
+                            (0, validation_1.validateOrThrow)({ [queryMeta.key]: args[queryMeta.index] }, { [queryMeta.key]: { type: queryMeta.dataType } }, { location: 'queryparam' });
+                        }
+                    }
+                    for (let bodyMeta of allMeta.body) {
+                        if (bodyMeta.validatorClass) {
+                            const err = await (0, helpers_1.validateObjectByInstance)(bodyMeta.dataType, args[bodyMeta.index]);
+                            if (err) {
+                                return await res.code(400).send({
+                                    code: 400,
+                                    error: "ValidationError",
+                                    errors: err,
+                                    message: err.message,
+                                });
                             }
                         }
-                        const result = await prototype[method].apply(ctrl, args);
-                        return result;
-                    },
-                });
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = methods_1.return)) await _b.call(methods_1);
-            }
-            finally { if (e_1) throw e_1.error; }
+                    }
+                    const result = await prototype[method].apply(ctrl, args);
+                    return result;
+                },
+            });
         }
     }
     /**
@@ -304,8 +387,7 @@ class AvleonApplication {
      * @returns
      */
     async _mapArgs(req, meta) {
-        var _a, e_2, _b, _c, _d, e_3, _e, _f;
-        var _g;
+        var _a;
         if (!req.hasOwnProperty("_argsCache")) {
             Object.defineProperty(req, "_argsCache", {
                 value: new Map(),
@@ -319,29 +401,17 @@ class AvleonApplication {
         }
         const args = meta.params.map((p) => req.params[p.key] || null);
         meta.query.forEach((q) => (args[q.index] = q.key === "all" ? req.query : req.query[q.key]));
-        meta.body.forEach((body) => (args[body.index] = Object.assign(Object.assign({}, req.body), req.formData)));
+        meta.body.forEach((body) => (args[body.index] = { ...req.body, ...req.formData }));
         meta.currentUser.forEach((user) => (args[user.index] = req.user));
         meta.headers.forEach((header) => (args[header.index] =
             header.key === "all" ? req.headers : req.headers[header.key]));
         if (meta.file) {
-            try {
-                for (var _h = true, _j = __asyncValues(meta.file), _k; _k = await _j.next(), _a = _k.done, !_a; _h = true) {
-                    _c = _k.value;
-                    _h = false;
-                    let f = _c;
-                    args[f.index] = await req.file();
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (!_h && !_a && (_b = _j.return)) await _b.call(_j);
-                }
-                finally { if (e_2) throw e_2.error; }
+            for await (let f of meta.file) {
+                args[f.index] = await req.file();
             }
         }
         if (meta.files &&
-            ((_g = req.headers["content-type"]) === null || _g === void 0 ? void 0 : _g.startsWith("multipart/form-data")) === true) {
+            ((_a = req.headers["content-type"]) === null || _a === void 0 ? void 0 : _a.startsWith("multipart/form-data")) === true) {
             const files = await req.saveRequestFiles();
             if (!files || files.length === 0) {
                 throw new exceptions_1.BadRequestException({ error: "No files uploaded" });
@@ -355,27 +425,15 @@ class AvleonApplication {
                 mimetype: file.mimetype,
                 fields: file.fields,
             }));
-            try {
-                for (var _l = true, _m = __asyncValues(meta.files), _o; _o = await _m.next(), _d = _o.done, !_d; _l = true) {
-                    _f = _o.value;
-                    _l = false;
-                    let f = _f;
-                    const findex = fileInfo.findIndex((x) => x.fieldname == f.fieldName);
-                    if (f.fieldName != "all" && findex == -1) {
-                        throw new exceptions_1.BadRequestException(`${f.fieldName} doesn't exists in request files tree.`);
-                    }
-                    args[f.index] =
-                        f.fieldName == "all"
-                            ? fileInfo
-                            : fileInfo.filter((x) => x.fieldname == f.fieldName);
+            for await (let f of meta.files) {
+                const findex = fileInfo.findIndex((x) => x.fieldname == f.fieldName);
+                if (f.fieldName != "all" && findex == -1) {
+                    throw new exceptions_1.BadRequestException(`${f.fieldName} doesn't exists in request files tree.`);
                 }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (!_l && !_d && (_e = _m.return)) await _e.call(_m);
-                }
-                finally { if (e_3) throw e_3.error; }
+                args[f.index] =
+                    f.fieldName == "all"
+                        ? fileInfo
+                        : fileInfo.filter((x) => x.fieldname == f.fieldName);
             }
         }
         cache.set(cacheKey, args);
@@ -414,7 +472,6 @@ class AvleonApplication {
                 const module = await Promise.resolve(`${filePath}`).then(s => __importStar(require(s)));
                 for (const exported of Object.values(module)) {
                     if (typeof exported === "function" && (0, container_1.isApiController)(exported)) {
-                        //controllers.push(exported);
                         this.buildController(exported);
                     }
                 }
@@ -424,6 +481,14 @@ class AvleonApplication {
     mapControllers(controllers) {
         this.controllers = controllers;
     }
+    // addFeature(feature:{controllers:Function[]}){
+    //   feature.controllers.forEach(c=> this.controllers.push(c))
+    // }
+    mapFeature() {
+        if (!this.isMapFeatures) {
+            this.isMapFeatures = true;
+        }
+    }
     async _mapControllers() {
         if (this.controllers.length > 0) {
             for (let controller of this.controllers) {
@@ -448,16 +513,6 @@ class AvleonApplication {
         fn = function () { };
         return fn;
     }
-    useMiddlewares(mclasses) {
-        for (const mclass of mclasses) {
-            const cls = typedi_1.default.get(mclass);
-            this.middlewares.set(mclass.name, cls);
-            this.app.addHook("preHandler", cls.invoke);
-        }
-    }
-    useAuthoriztion(middleware) {
-        this.authorizeMiddleware = middleware;
-    }
     _handleError(error) {
         if (error instanceof exceptions_1.BaseHttpException) {
             return {
@@ -516,7 +571,7 @@ class AvleonApplication {
                 }
                 return route;
             },
-            useSwagger: (options) => {
+            useOpenApi: (options) => {
                 const r = this.rMap.get(routeKey);
                 if (r) {
                     r.schema = options;
@@ -538,18 +593,16 @@ class AvleonApplication {
     mapDelete(path = "", fn) {
         return this._routeHandler(path, "DELETE", fn);
     }
-    useStaticFiles(options = { path: undefined, prefix: undefined }) {
-        this.app.register(require("@fastify/static"), {
-            root: options.path ? options.path : path_1.default.join(process.cwd(), "public"),
-            prefix: options.prefix ? options.prefix : "/static/",
-        });
+    _mapFeatures() {
+        const features = typedi_1.default.get('features');
+        console.log('Features', features);
     }
     async initializeDatabase() {
         if (this.dataSourceOptions && this.dataSource) {
             await this.dataSource.initialize();
         }
     }
-    async run(port = 4000) {
+    async run(port = 4000, fn) {
         if (this.alreadyRun)
             throw new system_exception_1.SystemUseError("App already running");
         this.alreadyRun = true;
@@ -557,6 +610,9 @@ class AvleonApplication {
             await this.initSwagger(this.globalSwaggerOptions);
         }
         await this.initializeDatabase();
+        if (this.isMapFeatures) {
+            this._mapFeatures();
+        }
         await this._mapControllers();
         this.rMap.forEach((value, key) => {
             const [m, r] = key.split(":");
@@ -573,7 +629,7 @@ class AvleonApplication {
         });
         this.app.setErrorHandler(async (error, req, res) => {
             const handledErr = this._handleError(error);
-            if (error instanceof exceptions_1.ValidationErrorException) {
+            if (error instanceof exceptions_1.ValidationErrorException || error instanceof exceptions_1.BadRequestException) {
                 return res.status(handledErr.code).send({
                     code: handledErr.code,
                     error: handledErr.error,
@@ -618,12 +674,12 @@ class AvleonApplication {
             // return this.app as any;
             //
             return {
-                get: async (url, options) => this.app.inject(Object.assign({ method: "GET", url }, options)),
-                post: async (url, options) => this.app.inject(Object.assign({ method: "POST", url }, options)),
-                put: async (url, options) => this.app.inject(Object.assign({ method: "PUT", url }, options)),
-                patch: async (url, options) => this.app.inject(Object.assign({ method: "PATCH", url }, options)),
-                delete: async (url, options) => this.app.inject(Object.assign({ method: "DELETE", url }, options)),
-                options: async (url, options) => this.app.inject(Object.assign({ method: "OPTIONS", url }, options)),
+                get: async (url, options) => this.app.inject({ method: "GET", url, ...options }),
+                post: async (url, options) => this.app.inject({ method: "POST", url, ...options }),
+                put: async (url, options) => this.app.inject({ method: "PUT", url, ...options }),
+                patch: async (url, options) => this.app.inject({ method: "PATCH", url, ...options }),
+                delete: async (url, options) => this.app.inject({ method: "DELETE", url, ...options }),
+                options: async (url, options) => this.app.inject({ method: "OPTIONS", url, ...options }),
                 getController: (controller) => {
                     return typedi_1.default.get(controller);
                 },
@@ -672,41 +728,8 @@ class TestBuilder {
 }
 exports.TestBuilder = TestBuilder;
 class Builder {
-    constructor() {
-        this.alreadyBuilt = false;
-        this.database = false;
-        this.testBuilder = false;
-        this.appConfig = new config_1.AppConfig();
-    }
-    static createAppBuilder() {
-        if (!Builder.instance) {
-            Builder.instance = new Builder();
-        }
-        return Builder.instance;
-    }
-    async registerPlugin(plugin, options) {
-        container_1.default.set(plugin, plugin.prototype);
-    }
-    addDataSource(ConfigClass, modifyConfig) {
-        const openApiConfig = this.appConfig.get(ConfigClass);
-        if (modifyConfig) {
-            const modifiedConfig = modifyConfig(openApiConfig);
-            this.dataSourceOptions = modifiedConfig;
-        }
-        else {
-            this.dataSourceOptions = openApiConfig;
-        }
-    }
-    build() {
-        if (this.alreadyBuilt) {
-            throw new Error("Already built");
-        }
-        this.alreadyBuilt = true;
-        const app = AvleonApplication.getInternalApp({
-            database: this.database,
-            multipartOptions: this.multipartOptions,
-            dataSourceOptions: this.dataSourceOptions,
-        });
+    static createApplication() {
+        const app = AvleonApplication.getApp();
         return app;
     }
 }

package/dist/index.d.ts

@@ -7,7 +7,7 @@
 import * as sw from "./swagger-schema";
 export * from "./icore";
 export * from "./testing";
-export { inject, validateRequestBody } from "./helpers";
+export { inject, validateRequestBody, pick, exclude } from "./helpers";
 export * from "./decorators";
 export * from "./middleware";
 export * from "./config";
@@ -20,7 +20,7 @@ export * from "./validation";
 export * from "./environment-variables";
 export * from "./collection";
 export * from "./queue";
-export * from "./security";
+export * from "./utils/hash";
 export * from "./multipart";
 export * from "./file-storage";
 export * from "./logger";