@avleon/core 0.0.4 → 0.0.5

package/dist/icore.js

@@ -32,11 +32,29 @@ 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.AppBuilder = void 0;
+exports.Builder = void 0;
 const fastify_1 = __importDefault(require("fastify"));
 const typedi_1 = __importDefault(require("typedi"));
 const promises_1 = __importDefault(require("fs/promises")); // Use promises for asynchronous file operations
@@ -44,196 +62,398 @@ 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 isTsNode = process.env.TS_NODE_DEV || process.env.TS_NODE_PROJECT || process[Symbol.for("ts-node.register.instance")];
+const fs_1 = require("fs");
+const exceptions_1 = require("./exceptions");
+const swagger_1 = __importDefault(require("@fastify/swagger"));
+const fastify_api_reference_1 = __importDefault(require("@scalar/fastify-api-reference"));
+const environment_variables_1 = require("./environment-variables");
+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(), isTsNode ? "./src/controllers" : "./dist/cotrollers");
-class _InternalApplication {
+// InternalApplication
+class AvleonApplication {
     constructor() {
         this.routeSet = new Set(); // Use Set for fast duplicate detection
         this.alreadyRun = false;
         this.routes = new Map();
+        this.middlewares = new Map();
+        this.rMap = new Map();
+        this.hasSwagger = false;
+        this.globalSwaggerOptions = {};
+        this.controllers = [];
+        this.metaCache = new Map();
         this.app = (0, fastify_1.default)();
+        // this.app.setValidatorCompiler(() => () => true);
     }
     static getInternalApp(buildOptions) {
-        if (!_InternalApplication.instance) {
-            _InternalApplication.instance = new _InternalApplication();
+        if (!AvleonApplication.instance) {
+            AvleonApplication.instance = new AvleonApplication();
+        }
+        AvleonApplication.buildOptions = buildOptions;
+        if (buildOptions.controllers) {
+        }
+        return AvleonApplication.instance;
+    }
+    isDevelopment() {
+        return environment_variables_1.env['NODE_ENV'] == "development";
+    }
+    async initSwagger(options) {
+        const { routePrefix } = options, restOptions = __rest(options, ["routePrefix"]);
+        this.app.register(swagger_1.default, {
+            openapi: Object.assign({ openapi: '3.0.0' }, restOptions)
+        });
+        const rPrefix = routePrefix ? routePrefix : "/docs";
+        //import fastifyApiReference from "@scalar/fastify-api-reference";
+        await this.app.register(fastify_api_reference_1.default, {
+            routePrefix: rPrefix,
+            configuration: {
+                metaData: {
+                    title: 'Avleon Api',
+                    ogTitle: 'Avleon'
+                },
+                theme: 'kepler',
+                favicon: '/static/favicon.png'
+            }
+        });
+    }
+    async useSwagger(options) {
+        this.hasSwagger = true;
+        this.globalSwaggerOptions = options;
+    }
+    handleMiddlewares(mclasses) {
+        for (const mclass of mclasses) {
+            const cls = typedi_1.default.get(mclass.constructor);
+            this.middlewares.set(mclass.name, cls);
+            this.app.addHook("preHandler", cls.invoke);
         }
-        _InternalApplication.buildOptions = buildOptions;
-        return _InternalApplication.instance;
+    }
+    executeMiddlewares(target, propertyKey) {
+        const classMiddlewares = Reflect.getMetadata("controller:middleware", target.constructor) || [];
+        const methodMiddlewares = propertyKey
+            ? Reflect.getMetadata("route:middleware", target, propertyKey) || []
+            : [];
+        return [...classMiddlewares, ...methodMiddlewares];
     }
     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)
             return;
         const prototype = Object.getPrototypeOf(ctrl);
         const methods = Object.getOwnPropertyNames(prototype).filter((name) => name !== "constructor");
-        for (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)) {
-                throw new system_exception_1.SystemUseError(`Duplicate Error: Duplicate route found for methoed ${methodMeta.method}: ${methodMeta.path} in ${controller.name}`);
-            }
-            this.routeSet.add(routeKey);
-            const allMeta = this._processMeta(prototype, controllerMeta, method, methodMeta);
-            this.app.route({
-                url: methodmetaOptions.path == "" ? "/" : methodmetaOptions.path,
-                method: methodmetaOptions.method.toUpperCase(),
-                preHandler: async (req, res, next) => {
-                    for (let bodyMeta of allMeta.body) {
-                        const args = await this._mapArgs(req, allMeta);
-                        if (bodyMeta.validatorClass) {
-                            const err = await (0, helpers_1.validateObjectByInstance)(bodyMeta.dataType, args[bodyMeta.index]);
-                            if (err) {
-                                console.log("Has validation error", err);
-                                return await res.code(400).send({
-                                    code: 400,
-                                    errorType: "ValidationError",
-                                    errors: err,
-                                    message: err.message
-                                });
+        let classMiddlewares = [];
+        const tag = ctrl.constructor.name.replace("Controller", "");
+        const swaggerControllerMeta = Reflect.getMetadata("controller:openapi", ctrl.constructor) || {};
+        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);
+                }
+                const classMiddlewares = this.executeMiddlewares(ctrl, method);
+                // handle openapi data
+                const swaggerMeta = Reflect.getMetadata("route:openapi", prototype, method) || {};
+                const allMeta = this._processMeta(prototype, method);
+                const routePath = methodmetaOptions.path == "" ? "/" : methodmetaOptions.path;
+                this.app.route({
+                    url: routePath,
+                    method: methodmetaOptions.method.toUpperCase(),
+                    schema: Object.assign(Object.assign(Object.assign({}, swaggerControllerMeta), swaggerMeta), { tags: [tag] }),
+                    handler: async (req, res) => {
+                        let reqClone = req;
+                        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;
                             }
                         }
-                    }
-                    next();
-                },
-                handler: async (req, res) => {
-                    const args = await this._mapArgs(req, allMeta);
-                    try {
-                        return await prototype[method].apply(ctrl, args);
-                    }
-                    catch (err) {
-                        console.error(err);
-                        return res.code(err.statusCode || 500).send({
-                            code: err.statusCode || 500,
-                            errorType: err.name || "InternalServerError",
-                            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,
+                                    });
+                                }
+                            }
+                        }
+                        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; }
         }
     }
     async _mapArgs(req, meta) {
-        const args = [];
-        if (meta.params.length > 0) {
-            meta.params.forEach((param) => {
-                const value = param.key === "all" ? req.params : req.params[param.key];
-                args[param.index] = value;
+        if (!req.hasOwnProperty("_argsCache")) {
+            Object.defineProperty(req, "_argsCache", {
+                value: new Map(),
+                enumerable: false,
             });
         }
-        if (meta.query.length > 0) {
-            meta.query.forEach((q) => {
-                const value = q.key === "all" ? req.query : req === null || req === void 0 ? void 0 : req.query[q.key];
-                args[q.index] = value;
-            });
+        const cache = req._argsCache;
+        const cacheKey = JSON.stringify(meta); // Faster key-based lookup
+        if (cache.has(cacheKey)) {
+            return cache.get(cacheKey);
         }
-        if (meta.body.length > 0) {
-            meta.body.forEach(async (body) => {
-                args[body.index] = req.body;
-            });
+        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] = req.body));
+        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]));
+        cache.set(cacheKey, args);
+        return args;
+    }
+    _processMeta(prototype, method) {
+        const cacheKey = `${prototype.constructor.name}_${method}`;
+        if (this.metaCache.has(cacheKey)) {
+            return this.metaCache.get(cacheKey);
         }
-        if (meta.headers.length > 0) {
-            meta.headers.forEach((header) => {
-                const value = header.key === "all" ? req.headers : req.headers[header.key];
-                args[header.index] = value;
-            });
+        const meta = {
+            params: Reflect.getMetadata(container_1.PARAM_META_KEY, prototype, method) || [],
+            query: Reflect.getMetadata(container_1.QUERY_META_KEY, prototype, method) || [],
+            body: Reflect.getMetadata(container_1.REQUEST_BODY_META_KEY, prototype, method) || [],
+            headers: Reflect.getMetadata(container_1.REQUEST_HEADER_META_KEY, prototype, method) || [],
+            currentUser: Reflect.getMetadata(container_1.REQUEST_USER_META_KEY, prototype, method) || [],
+            // swagger: Reflect.getMetadata("route:openapi", prototype, method) || {}
+        };
+        this.metaCache.set(cacheKey, meta);
+        return meta;
+    }
+    async autoControllers() {
+        const controllers = [];
+        const files = await promises_1.default.readdir(controllerDir);
+        for (const file of files) {
+            if (isTsNode ? file.endsWith(".ts") : file.endsWith(".js")) {
+                const filePath = path_1.default.join(controllerDir, 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);
+                    }
+                }
+            }
         }
-        return args;
     }
-    _processMeta(prototype, controllerMeta, method, methodMeta) {
-        const paramsMetaList = Reflect.getMetadata(container_1.PARAM_META_KEY, prototype, method) || [];
-        const queryMetaList = Reflect.getMetadata(container_1.QUERY_META_KEY, prototype, method) || [];
-        const bodyMetaList = Reflect.getMetadata(container_1.REQUEST_BODY_META_KEY, prototype, method) || [];
-        const headerMetaList = Reflect.getMetadata(container_1.REQUEST_HEADER_META_KEY, prototype, method) || [];
-        return { params: paramsMetaList, query: queryMetaList, body: bodyMetaList, headers: headerMetaList };
+    mapControllers(controllers) {
+        this.controllers = controllers;
     }
-    async mapControllers() {
-        // const controllers = getRegisteredControllers();
-        // await Promise.all(controllers.map((controller) => this.buildController(controller)));
-        await this._mapControllers();
+    async _mapControllers() {
+        if (this.controllers.length > 0) {
+            for (let controller of this.controllers) {
+                if ((0, container_1.isApiController)(controller)) {
+                    this.buildController(controller);
+                }
+            }
+        }
     }
-    async mapGroup(path) {
+    mapControllersAuto() {
+        const isExists = (0, fs_1.existsSync)(controllerDir);
+        if (isExists) {
+            this.autoControllers();
+        }
     }
     async handleRoute(args) {
         console.log(args);
     }
-    async mapGet(path = '', fn) {
-        this.app.get(path, async (req, res) => {
-            const result = await fn.apply(this, [req, res]);
-            return res.send(result);
+    async mapFn(fn) {
+        const original = fn;
+        fn = function () {
+            console.log(arguments);
+        };
+        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);
+        }
+    }
+    _handleError(error) {
+        if (error instanceof exceptions_1.BaseHttpException) {
+            return { code: error.code, error: error.name, message: (0, helpers_1.isValidJsonString)(error.message) ? JSON.parse(error.message) : error.message };
+        }
+        return { code: 500, error: 'INTERNALERROR', message: error.message ? error.message : "Something going wrong." };
+    }
+    async mapRoute(method, path = "", fn) {
+        await this.mapFn(fn); // Assuming mapFn is needed for all methods
+        this.app[method](path, async (req, res) => {
+            // Dynamic method call
+            try {
+                const result = await fn.apply(this, [req, res]);
+                if (typeof result === "object" && result !== null) {
+                    res.json(result); // Use res.json for objects
+                }
+                else {
+                    res.send(result); // Fallback for other types
+                }
+            }
+            catch (error) {
+                console.error(`Error in ${method} route handler:`, error);
+                const handledErr = this._handleError(error);
+                res.status(handledErr.code).send(handledErr);
+            }
+        });
+    }
+    _routeHandler(routePath, method, fn) {
+        const routeKey = method + ":" + routePath;
+        this.rMap.set(routeKey, {
+            handler: fn,
+            middlewares: [],
+            schema: {}
         });
-        /*     this.handleRoute = fn.apply(this, arguments);
-        
-                this.routes.set(path, async (...args: any[]) => {
-                    try {
-                        const result = await fn(...args);
-                        return result;
-                    } catch (error) {
-                        console.error(`Error handling route ${path}:`, error);
-                        throw error;
-                    }
-                }); */
+        this.mapFn(fn);
+        const route = {
+            useMiddleware: (middlewares) => {
+                const midds = Array.isArray(middlewares) ? middlewares : [middlewares];
+                const ms = midds.map((mclass) => {
+                    const cls = typedi_1.default.get(mclass);
+                    this.middlewares.set(mclass.name, cls);
+                    return cls.invoke; // Ensure `invoke` runs in the correct context
+                });
+                const r = this.rMap.get(routeKey);
+                if (r) {
+                    r.middlewares = ms; // Update middlewares array
+                }
+                return route; // Ensure chaining by returning the same route object
+            },
+            useSwagger: (options) => {
+                const r = this.rMap.get(routeKey);
+                if (r) {
+                    r.schema = options; // Update schema
+                }
+                return route; // Ensure chaining
+            },
+        };
+        return route;
     }
-    async mapPost() { }
-    async mapPut() { }
-    async mapDelete() { }
-    async _mapControllers() {
-        const controllers = (0, container_1.getRegisteredControllers)();
-        await Promise.all(controllers.map((controller) => this.buildController(controller)));
+    mapGet(path = "", fn) {
+        return this._routeHandler(path, "GET", fn);
+    }
+    mapPost(path = "", fn) {
+        return this._routeHandler(path, "POST", fn);
+    }
+    mapPut(path = "", fn) {
+        return this._routeHandler(path, "PUT", fn);
+    }
+    mapDelete(path = "", fn) {
+        return this._routeHandler(path, "DELETE", fn);
     }
     async run(port = 4000) {
         if (this.alreadyRun)
             throw new system_exception_1.SystemUseError("App already running");
         this.alreadyRun = true;
-        if (_InternalApplication.buildOptions.database) {
+        if (AvleonApplication.buildOptions.database) {
+        }
+        this.app.register(require('@fastify/static'), {
+            root: path_1.default.join(process.cwd(), 'public'),
+            prefix: '/static/'
+        });
+        //this.app.swagger();
+        if (this.hasSwagger) {
+            await this.initSwagger(this.globalSwaggerOptions);
         }
-        ///await this._mapControllers();
+        await this._mapControllers();
+        // this.controllers.forEach(controller => {
+        //   this.buildController(controller)
+        // })
+        this.rMap.forEach((value, key) => {
+            const [m, r] = key.split(":");
+            this.app.route({
+                method: m,
+                url: r,
+                schema: value.schema || {},
+                preHandler: value.middlewares ? value.middlewares : [],
+                handler: async (req, res) => {
+                    const result = await value.handler.apply(this, [req, res]);
+                    return result;
+                },
+            });
+        });
+        this.app.setErrorHandler(async (error, req, res) => {
+            const handledErr = this._handleError(error);
+            if (error instanceof exceptions_1.ValidationErrorException) {
+                return res.status(handledErr.code).send({ code: handledErr.code, error: handledErr.error, errors: handledErr.message });
+            }
+            return res.status(handledErr.code).send(handledErr);
+        });
+        await this.app.ready();
         await this.app.listen({ port });
-        console.log(`Application running on port: ${port}`);
+        console.log(`Application running on port: 0.0.0.0:${port}`);
     }
 }
-_InternalApplication.buildOptions = {};
-class AppBuilder {
+AvleonApplication.buildOptions = {};
+// Applciation Builder
+class Builder {
     constructor() {
         this.alreadyBuilt = false;
-        this.databse = false;
+        this.database = false;
     }
-    static createBuilder() {
-        if (!AppBuilder.instance) {
-            AppBuilder.instance = new AppBuilder();
+    static createAppBuilder() {
+        if (!Builder.instance) {
+            Builder.instance = new Builder();
         }
-        return AppBuilder.instance;
+        return Builder.instance;
     }
     async registerPlugin(plugin, options) {
         container_1.default.set(plugin, plugin.prototype);
     }
-    async useDatabase() {
-        this.databse = true;
+    async addDataSource(config) {
+        if (this.database) {
+            throw new system_exception_1.SystemUseError("Datasource already added.");
+        }
+        this.database = true;
+        try {
+            const typeorm = await Promise.resolve().then(() => __importStar(require("typeorm")));
+            if (!typeorm) {
+                throw new system_exception_1.SystemUseError("TypeOrm not installed");
+            }
+            const datasource = new typeorm.DataSource(config);
+            typedi_1.default.set("idatasource", datasource);
+            this.dataSource = datasource;
+            await datasource.initialize();
+        }
+        catch (error) {
+            console.log(error);
+            console.error("Database Initialize Error:", error.message);
+        }
     }
-    async build() {
-        //console.log("Hello", hello())
+    build() {
         if (this.alreadyBuilt)
             throw new Error("Already built");
         this.alreadyBuilt = true;
-        const controllers = [];
-        const files = await promises_1.default.readdir(controllerDir);
-        for (const file of files) {
-            if (isTsNode ? file.endsWith(".ts") : file.endsWith(".js")) {
-                const filePath = path_1.default.join(controllerDir, 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);
-                    }
-                }
-            }
-        }
-        const app = _InternalApplication.getInternalApp({ database: this.databse });
-        controllers.forEach(container_1.registerController);
+        const app = AvleonApplication.getInternalApp({
+            database: this.database,
+        });
         return app;
     }
 }
-exports.AppBuilder = AppBuilder;
+exports.Builder = Builder;

package/dist/index.d.ts

@@ -1,10 +1,14 @@
-export * from './icore';
-export { inject } from './helpers';
+export * from "./icore";
+export { inject, validateRequestBody } from "./helpers";
 export * from "./decorators";
+export * from "./middleware";
 export * from "./config";
 export * from "./openapi";
 export * from "./map-types";
-export * from './response';
-export * from './exceptions';
-export * from './validator-extend';
-export { default as Container } from './container';
+export * from "./response";
+export * from "./exceptions";
+export * from "./validator-extend";
+export * from "./environment-variables";
+export * from "./collection";
+export * from "./queue";
+export { default as Container } from "./container";

package/dist/index.js

@@ -17,17 +17,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Container = exports.inject = void 0;
+exports.Container = exports.validateRequestBody = exports.inject = void 0;
 //export * from "./iqra-core";
 __exportStar(require("./icore"), exports);
 var helpers_1 = require("./helpers");
 Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return helpers_1.inject; } });
+Object.defineProperty(exports, "validateRequestBody", { enumerable: true, get: function () { return helpers_1.validateRequestBody; } });
 __exportStar(require("./decorators"), exports);
+__exportStar(require("./middleware"), exports);
 __exportStar(require("./config"), exports);
 __exportStar(require("./openapi"), exports);
 __exportStar(require("./map-types"), exports);
 __exportStar(require("./response"), exports);
 __exportStar(require("./exceptions"), exports);
 __exportStar(require("./validator-extend"), exports);
+__exportStar(require("./environment-variables"), exports);
+__exportStar(require("./collection"), exports);
+__exportStar(require("./queue"), exports);
 var container_1 = require("./container");
 Object.defineProperty(exports, "Container", { enumerable: true, get: function () { return __importDefault(container_1).default; } });

package/dist/map-types.js

@@ -19,8 +19,7 @@ function PartialType(BaseClass) {
             }
             // Retrieve validation metadata (class-validator)
             const validationMetadata = Reflect.getMetadataKeys(currentPrototype, key);
-            validationMetadata.forEach((metadataKey) => {
-            });
+            validationMetadata.forEach((metadataKey) => { });
         });
         currentPrototype = Object.getPrototypeOf(currentPrototype); // Move up the prototype chain
     }

package/dist/middleware.d.ts

@@ -0,0 +1,10 @@
+import { IRequest, IResponse } from "./icore";
+import { HttpException } from "./exceptions";
+export declare abstract class AppMiddleware {
+    abstract invoke(req: IRequest, res?: IResponse): Promise<IRequest | HttpException>;
+}
+export type Constructor<T> = {
+    new (...args: any[]): T;
+};
+export declare function Middleware(target: Constructor<AppMiddleware>): void;
+export declare function UseMiddleware<T extends AppMiddleware | (new (...args: any[]) => AppMiddleware)>(options: T | T[]): MethodDecorator & ClassDecorator;