@avleon/core 0.0.20 → 0.0.25

package/dist/icore.js

@@ -32,29 +32,11 @@ 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 };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Builder = exports.TestBuilder = exports.AvleonApplication = void 0;
+exports.Avleon = exports.AvleonTest = exports.AvleonApplication = void 0;
 /**
  * @copyright 2024
  * @author Tareq Hossain
@@ -68,13 +50,14 @@ const path_1 = __importDefault(require("path"));
 const container_1 = __importStar(require("./container"));
 const helpers_1 = require("./helpers");
 const system_exception_1 = require("./exceptions/system-exception");
-const fs_1 = require("fs");
 const exceptions_1 = require("./exceptions");
 const swagger_1 = __importDefault(require("@fastify/swagger"));
 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 +76,21 @@ class AvleonApplication {
         this.controllers = [];
         this.authorizeMiddleware = undefined;
         this.dataSource = undefined;
+        this.isMapFeatures = false;
+        this.registerControllerAuto = false;
+        this.registerControllerPath = './src';
         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 +102,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 +112,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,29 +140,38 @@ 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",
-                },
             });
         }
     }
     useCors(corsOptions = {}) {
         this.app.register(cors_1.default, corsOptions);
     }
-    useOpenApi(ConfigClass, modifyConfig) {
-        const openApiConfig = this.appConfig.get(ConfigClass);
+    useOpenApi(configOrClass, modifyConfig) {
+        let openApiConfig;
+        const isClass = (input) => {
+            var _a;
+            return (typeof input === 'function' &&
+                typeof input.prototype === 'object' &&
+                ((_a = input.prototype) === null || _a === void 0 ? void 0 : _a.constructor) === input);
+        };
+        if (isClass(configOrClass)) {
+            // It's a class constructor
+            openApiConfig = this.appConfig.get(configOrClass);
+        }
+        else {
+            // It's a plain object
+            openApiConfig = configOrClass;
+        }
         if (modifyConfig) {
-            const modifiedConfig = modifyConfig(openApiConfig);
-            this.globalSwaggerOptions = modifiedConfig;
+            this.globalSwaggerOptions = modifyConfig(openApiConfig);
         }
         else {
             this.globalSwaggerOptions = openApiConfig;
@@ -171,16 +179,96 @@ 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);
+    }
+    useCache(options) {
+    }
+    /**
+     * 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 +290,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 +299,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 +403,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 +417,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 +441,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);
@@ -405,25 +479,59 @@ class AvleonApplication {
         this.metaCache.set(cacheKey, meta);
         return meta;
     }
-    async autoControllers() {
-        const controllers = [];
-        const files = await promises_1.default.readdir(controllerDir);
+    _resolveControllerDir(dir) {
+        const isTsNode = process.env.TS_NODE_DEV ||
+            process.env.TS_NODE_PROJECT ||
+            process[Symbol.for("ts-node.register.instance")];
+        const controllerDir = path_1.default.join(process.cwd(), this.registerControllerPath);
+        return isTsNode ? controllerDir : controllerDir.replace('src', 'dist');
+    }
+    async autoControllers(controllersPath) {
+        const conDir = this._resolveControllerDir(controllersPath);
+        const files = await promises_1.default.readdir(conDir, { recursive: true });
         for (const file of files) {
+            const isTestFile = /\.(test|spec|e2e-spec)\.ts$/.test(file);
+            if (isTestFile)
+                continue;
             if (isTsNode ? file.endsWith(".ts") : file.endsWith(".js")) {
-                const filePath = path_1.default.join(controllerDir, file);
+                const filePath = path_1.default.join(conDir, file);
                 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);
+                        console.log('adding', exported.name);
+                        if (!this.controllers.some(con => exported.name == con.name)) {
+                            this.controllers.push(exported);
+                        }
+                        //this.buildController(exported);
                     }
                 }
             }
         }
     }
-    mapControllers(controllers) {
-        this.controllers = controllers;
+    useControllers(controllers) {
+        if (Array.isArray(controllers)) {
+            this.controllers = controllers;
+            controllers.forEach(controller => {
+                if (!this.controllers.includes(controller)) {
+                    this.controllers.push(controller);
+                }
+            });
+        }
+        else {
+            this.registerControllerAuto = true;
+            if (controllers.path) {
+                this.registerControllerPath = controllers.path;
+            }
+        }
     }
+    // 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) {
@@ -436,28 +544,15 @@ class AvleonApplication {
             }
         }
     }
-    mapControllersAuto() {
-        const isExists = (0, fs_1.existsSync)(controllerDir);
-        if (isExists) {
-            this.autoControllers();
-        }
-    }
-    async handleRoute(args) { }
+    // useControllersAuto(controllerPath?:string) {
+    //     this.registerControllerAuto = true;
+    //     //this.autoControllers();
+    // }
     async mapFn(fn) {
         const original = fn;
         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 {
@@ -501,7 +596,7 @@ class AvleonApplication {
             middlewares: [],
             schema: {},
         });
-        this.mapFn(fn);
+        //    this.mapFn(fn);
         const route = {
             useMiddleware: (middlewares) => {
                 const midds = Array.isArray(middlewares) ? middlewares : [middlewares];
@@ -516,7 +611,7 @@ class AvleonApplication {
                 }
                 return route;
             },
-            useSwagger: (options) => {
+            useOpenApi: (options) => {
                 const r = this.rMap.get(routeKey);
                 if (r) {
                     r.schema = options;
@@ -538,18 +633,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 +650,12 @@ class AvleonApplication {
             await this.initSwagger(this.globalSwaggerOptions);
         }
         await this.initializeDatabase();
+        if (this.isMapFeatures) {
+            this._mapFeatures();
+        }
+        if (this.registerControllerAuto) {
+            await this.autoControllers();
+        }
         await this._mapControllers();
         this.rMap.forEach((value, key) => {
             const [m, r] = key.split(":");
@@ -573,7 +672,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,13 +717,17 @@ 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)),
-                getController: (controller) => {
+                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, deps = []) => {
+                    const paramTypes = Reflect.getMetadata('design:paramtypes', controller) || [];
+                    deps.forEach((dep, i) => {
+                        typedi_1.default.set(paramTypes[i], dep);
+                    });
                     return typedi_1.default.get(controller);
                 },
             };
@@ -637,77 +740,42 @@ class AvleonApplication {
 }
 exports.AvleonApplication = AvleonApplication;
 AvleonApplication.buildOptions = {};
-class TestBuilder {
+class AvleonTest {
     constructor() {
         process.env.NODE_ENV = "test";
     }
-    static createBuilder() {
-        if (!TestBuilder.instance) {
-            TestBuilder.instance = new TestBuilder();
-        }
-        return TestBuilder.instance;
-    }
     addDatasource(options) {
         this.dataSourceOptions = options;
     }
-    getController(controller) {
+    getController(controller, deps = []) {
+        const paramTypes = Reflect.getMetadata('design:paramtypes', controller) || [];
+        deps.forEach((dep, i) => {
+            typedi_1.default.set(paramTypes[i], dep);
+        });
         return typedi_1.default.get(controller);
     }
     getService(service) {
         return typedi_1.default.get(service);
     }
-    getTestApplication(options) {
+    static createTestApplication(options) {
         const app = AvleonApplication.getInternalApp({
-            dataSourceOptions: this.dataSourceOptions,
+            dataSourceOptions: options.dataSource ? options.dataSource : null,
         });
-        app.mapControllers([...options.controllers]);
+        app.useControllers([...options.controllers]);
         return app.getTestApp();
     }
-    build(app) {
+    static from(app) {
         return app.getTestApp();
     }
-    fromApplication(app) {
-        return app.getTestApp();
+    static clean() {
+        typedi_1.default.reset();
     }
 }
-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,
-        });
+exports.AvleonTest = AvleonTest;
+class Avleon {
+    static createApplication() {
+        const app = AvleonApplication.getApp();
         return app;
     }
 }
-exports.Builder = Builder;
+exports.Avleon = Avleon;