@zenofolio/hyper-decor 0.0.3

package/dist/decorators/File.js

@@ -0,0 +1,180 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.File = void 0;
+const Http_1 = require("./Http");
+const consumers_1 = require("stream/consumers");
+const HyperFileException_1 = __importDefault(require("../exeptions/HyperFileException"));
+/**
+ * Decorator to extract file from the request
+ *
+ * @param param0
+ */
+const File = (options) => {
+    const _options = typeof options === "string" ? { fieldName: options } : options;
+    return (0, Http_1.createCustomRequestDecorator)("File", (request) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        const { allowedMimeTypes, maxFileSize } = yield resolveRestrictions(request, _options.restrictions);
+        const passTypes = allowedMimeTypes.includes("*") || allowedMimeTypes.length === 0;
+        const passSize = maxFileSize === Infinity;
+        const contentType = (_a = request.headers) === null || _a === void 0 ? void 0 : _a["content-type"];
+        const fileSize = Number((_b = request.headers) === null || _b === void 0 ? void 0 : _b["content-length"]);
+        const isMultipart = contentType === null || contentType === void 0 ? void 0 : contentType.includes("multipart/form-data");
+        if (!isMultipart) {
+            throw new HyperFileException_1.default("Invalid request, expected multipart form data", {
+                fieldName: _options.fieldName,
+            });
+        }
+        if (isNaN(fileSize) || fileSize <= 0) {
+            throw new HyperFileException_1.default(`File ${_options.fieldName} is missing or empty`, {
+                fieldName: _options.fieldName,
+                fileSize,
+            });
+        }
+        if (!passSize && fileSize > maxFileSize) {
+            throw new HyperFileException_1.default(`File ${_options.fieldName} is too large. Max size is ${maxFileSize} bytes`, {
+                fieldName: _options.fieldName,
+                maxFileSize,
+            });
+        }
+        const files = yield extractFiles(request, {
+            maxSize: passSize ? undefined : maxFileSize,
+            mimeTypes: passTypes ? undefined : allowedMimeTypes,
+            requires: _options.required
+                ? Array.isArray(_options.fieldName)
+                    ? _options.fieldName
+                    : [_options.fieldName]
+                : undefined,
+            requireName: true,
+        });
+        return Array.isArray(_options.fieldName)
+            ? files
+            : files[_options.fieldName];
+    }));
+};
+exports.File = File;
+/**
+ *
+ * Helper function to create a file decorator with options
+ *
+ * @param options
+ * @returns
+ */
+exports.File.options = (options, required = false) => {
+    return (fieldName) => {
+        return (0, exports.File)(Object.assign(Object.assign({}, options), { required, fieldName }));
+    };
+};
+/**
+ * Helper function to create a file decorator with restrictions
+ *
+ * @param restrictions
+ * @returns
+ */
+exports.File.restrictions = (restrictions) => {
+    return (fieldName, required = false) => {
+        return (0, exports.File)({ fieldName, restrictions, required });
+    };
+};
+/////////////////////////////
+// Types
+/////////////////////////////
+/////////////////////////////
+/// Utility
+/////////////////////////////
+const resolveRestrictions = (request, restrictions) => __awaiter(void 0, void 0, void 0, function* () {
+    if (typeof restrictions === "function") {
+        return yield restrictions(request);
+    }
+    return (restrictions !== null && restrictions !== void 0 ? restrictions : {
+        allowedMimeTypes: ["*"],
+        maxFileSize: Infinity,
+    });
+});
+/**
+ * Extract files from a request with validation, transformation, and required files check.
+ *
+ * @param request
+ * @param options Validation and transformation options
+ * @returns Transformed or raw file details
+ */
+const extractFiles = (request, options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const contentType = (_a = request.headers) === null || _a === void 0 ? void 0 : _a["content-type"];
+    if (!(contentType === null || contentType === void 0 ? void 0 : contentType.includes("multipart/form-data"))) {
+        throw new Error("Invalid request, expected multipart form data");
+    }
+    const filesMap = {};
+    yield request.multipart((field) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        if (field.file && field.file.stream) {
+            const bufferFile = yield (0, consumers_1.buffer)(field.file.stream);
+            const type = yield (yield import("file-type")).fileTypeFromBuffer(bufferFile);
+            if (!type) {
+                throw new HyperFileException_1.default(`Invalid file type`, {
+                    field: field.name,
+                });
+            }
+            const mimeType = type.mime;
+            const extention = type.ext;
+            // Validate MIME type early
+            if ((options === null || options === void 0 ? void 0 : options.mimeTypes) && !options.mimeTypes.includes(mimeType)) {
+                throw new HyperFileException_1.default(`Invalid file type, only ${options.mimeTypes.join(", ")} is allowed`, {
+                    field: field.name,
+                    allowedMimeTypes: options.mimeTypes,
+                    mimeType,
+                });
+            }
+            if (!type) {
+                throw new HyperFileException_1.default(`Invalid file type`, {
+                    field: field.name,
+                });
+            }
+            if ((options === null || options === void 0 ? void 0 : options.maxSize) && bufferFile.byteLength > options.maxSize) {
+                throw new HyperFileException_1.default(`File '${field.name}' size exceeds the maximum limit of ${options.maxSize} bytes`, {
+                    field: field.name,
+                    maxSize: options.maxSize,
+                });
+            }
+            if ((options === null || options === void 0 ? void 0 : options.requireName) && !((_a = field.file) === null || _a === void 0 ? void 0 : _a.name)) {
+                throw new HyperFileException_1.default(`File name is required`, {
+                    field: field.name,
+                });
+            }
+            // Derive file details
+            const name = (_d = (_c = (_b = field.file) === null || _b === void 0 ? void 0 : _b.name) === null || _c === void 0 ? void 0 : _c.split(".").shift()) !== null && _d !== void 0 ? _d : field.name;
+            const filename = `${name === null || name === void 0 ? void 0 : name.replace(extention, "")}.${extention}`;
+            filesMap[field.name] = {
+                field: field.name,
+                name: name,
+                filename: filename,
+                ext: extention,
+                size: bufferFile.byteLength,
+                mimeType: mimeType,
+                buffer: bufferFile,
+            };
+        }
+    }));
+    // Check for required files
+    if (options === null || options === void 0 ? void 0 : options.requires) {
+        for (const required of options.requires) {
+            if (!filesMap[required]) {
+                throw new HyperFileException_1.default(`File "${required}" is required`, {
+                    required,
+                });
+            }
+        }
+    }
+    return filesMap;
+});

package/dist/decorators/Http.d.ts

@@ -0,0 +1,55 @@
+import { ParameterResolver } from "./types";
+/**
+ * Get the value of a key from the request object
+ *
+ * @param key
+ * @returns
+ */
+export declare const Query: (key?: string, transfrom?: (data: any) => any) => ParameterDecorator;
+/**
+ * Get the body of the request
+ *
+ * @param resolver
+ * @returns
+ */
+export declare const Body: <T, R>(resolver?: (data: T) => R) => ParameterDecorator;
+/**
+ * Get the params from the request
+ *
+ * @param k
+ * @returns
+ */
+export declare const Param: (k?: string, validator?: (data: any) => any) => ParameterDecorator;
+/**
+ * get the headers from the request
+ *
+ * @param key
+ * @returns
+ */
+export declare const Headers: <T extends string>(key?: T) => ParameterDecorator;
+export declare const Req: () => ParameterDecorator;
+export declare const Res: () => ParameterDecorator;
+/**
+ * Create a custom request decorator
+ * that can be used to extract data from the request object
+ *
+ *
+ * @example
+ * ```typescript
+ *
+ * interface LoginData {
+ *  username: string;
+ *  password: string;
+ * }
+ *
+ * const LoginData = createCustomRequestDecorator<LoginData>({
+ *  resolver: async (request) => {
+ *    const data = await request.json();
+ *    return [data];
+ *  }
+ * }
+ *
+ *
+ *
+ */
+export declare const createCustomRequestDecorator: (decoratorName: string, resolver: ParameterResolver) => ParameterDecorator;

package/dist/decorators/Http.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCustomRequestDecorator = exports.Res = exports.Req = exports.Headers = exports.Param = exports.Body = exports.Query = void 0;
+const request_creator_1 = __importDefault(require("../__internals/creators/request.creator"));
+const object_util_1 = require("../__internals/utils/object.util");
+/**
+ * Get the value of a key from the request object
+ *
+ * @param key
+ * @returns
+ */
+const Query = (key, transfrom) => (0, request_creator_1.default)("query", "Query", (request) => {
+    const value = (0, object_util_1.$get)(request.query, key, request.query);
+    if (!transfrom)
+        return value;
+    return value;
+});
+exports.Query = Query;
+/**
+ * Get the body of the request
+ *
+ * @param resolver
+ * @returns
+ */
+const Body = (resolver) => (0, request_creator_1.default)("req", "BODY", (request) => __awaiter(void 0, void 0, void 0, function* () {
+    const value = yield request.json();
+    return resolver ? resolver(value) : value;
+}));
+exports.Body = Body;
+/**
+ * Get the params from the request
+ *
+ * @param k
+ * @returns
+ */
+const Param = (k, validator) => (0, request_creator_1.default)("params", "Param", (req) => {
+    const value = (0, object_util_1.$get)(req.params, k, req.params);
+    if (typeof validator === "function")
+        return validator(value);
+    return value;
+});
+exports.Param = Param;
+/**
+ * get the headers from the request
+ *
+ * @param key
+ * @returns
+ */
+const Headers = (key) => (0, request_creator_1.default)("headers", "Headers", (req) => (0, object_util_1.$get)(req.headers, key, req.headers));
+exports.Headers = Headers;
+const Req = () => (0, request_creator_1.default)("req", "Req", (req) => req);
+exports.Req = Req;
+const Res = () => (0, request_creator_1.default)("res", "Res", (req, res) => res);
+exports.Res = Res;
+/**
+ * Create a custom request decorator
+ * that can be used to extract data from the request object
+ *
+ *
+ * @example
+ * ```typescript
+ *
+ * interface LoginData {
+ *  username: string;
+ *  password: string;
+ * }
+ *
+ * const LoginData = createCustomRequestDecorator<LoginData>({
+ *  resolver: async (request) => {
+ *    const data = await request.json();
+ *    return [data];
+ *  }
+ * }
+ *
+ *
+ *
+ */
+const createCustomRequestDecorator = (decoratorName, resolver) => {
+    return (0, request_creator_1.default)("req", decoratorName, resolver);
+};
+exports.createCustomRequestDecorator = createCustomRequestDecorator;

package/dist/decorators/HyperApp.d.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+import { HyperAppDecorator } from "./types";
+/**
+ * Decorator to define the main application class with assigned modules.
+ * @param modules - List of modules to be used in the application.
+ */
+export declare const HyperApp: HyperAppDecorator;

package/dist/decorators/HyperApp.js

@@ -0,0 +1,262 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperApp = void 0;
+require("reflect-metadata");
+const constants_1 = require("../__internals/constants");
+const hyper_express_1 = require("hyper-express");
+const decorator_base_1 = require("../__internals/decorator-base");
+const path_util_1 = require("../__internals/utils/path.util");
+const scope_transfrom_1 = __importDefault(require("../__internals/transform/scope.transfrom"));
+const role_transform_1 = __importDefault(require("../__internals/transform/role.transform"));
+const object_util_1 = require("../__internals/utils/object.util");
+const merge_metadata_1 = require("../__internals/helpers/merge-metadata");
+const tsyringe_1 = require("tsyringe");
+/**
+ * Decorator to define the main application class with assigned modules.
+ * @param modules - List of modules to be used in the application.
+ */
+const HyperApp = (options) => (0, decorator_base_1.DecoratorHelper)({
+    type: constants_1.KEY_TYPE_APP,
+    key: constants_1.KEY_PARAMS_APP,
+    options: options !== null && options !== void 0 ? options : { modules: [] },
+}, (options, Target) => {
+    return class extends hyper_express_1.Server {
+        constructor(...args) {
+            super(options.options);
+            this.listArguments = [];
+            this.storeLogs = {};
+            this.listArguments = args;
+        }
+        prepare() {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.mergeMetadata(Target);
+                yield this.applyOptions(Target);
+            });
+        }
+        /** Fusiona los metadatos relevantes al Target */
+        mergeMetadata(targetPrototype) {
+            (0, merge_metadata_1.mergeMetadata)(targetPrototype, this.constructor, [
+                constants_1.KEY_PARAMS_MIDDLEWARES,
+                constants_1.KEY_PARAMS_SCOPE,
+                constants_1.KEY_PARAMS_ROLE,
+                constants_1.KEY_PARAMS_PASS,
+            ]);
+        }
+        /** Aplica las opciones y prepara la instancia del Target */
+        applyOptions(Target) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                yield applyAppOptions(options, Target, this, this.log.bind(this));
+                const target = Reflect.construct(Target, this.listArguments);
+                (_a = target === null || target === void 0 ? void 0 : target.onPrepare) === null || _a === void 0 ? void 0 : _a.call(target);
+                this.showLogs();
+            });
+        }
+        /** Maneja los logs respetando las opciones configuradas */
+        log(space, message) {
+            var _a;
+            var _b;
+            if (((_a = options.logs) === null || _a === void 0 ? void 0 : _a[space]) === false)
+                return;
+            ((_b = this.storeLogs)[space] || (_b[space] = [])).push(`- ${message}`);
+        }
+        showLogs() {
+            var _a, _b, _c;
+            const content = ["\n\n"];
+            content.push("/////////////////////////////");
+            content.push(`- HyperExpress Application`);
+            content.push(`- ${(_a = options.name) !== null && _a !== void 0 ? _a : "Hyper App"} - ${(_b = options.version) !== null && _b !== void 0 ? _b : "1.0.0"}`);
+            content.push("/////////////////////////////\n");
+            content.push("\nLogs:");
+            Object.entries(this.storeLogs).forEach(([space, logs]) => {
+                if (!logs.length)
+                    return;
+                content.push(`- [${space.toUpperCase()}]`);
+                logs.forEach((log) => content.push(`  ${log}`));
+                content.push("");
+            });
+            (_c = options.logger) === null || _c === void 0 ? void 0 : _c.call(this, content.join("\n"));
+        }
+    };
+});
+exports.HyperApp = HyperApp;
+//////////////////////////////////
+/// Private methods
+//////////////////////////////////
+const if_router = (current) => {
+    if (!current || !((current === null || current === void 0 ? void 0 : current.prototype) instanceof hyper_express_1.Router))
+        return new hyper_express_1.Router();
+    return new current();
+};
+function getData(target) {
+    var _a, _b, _c, _d, _e;
+    const app = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_APP, target);
+    const module = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_MODULE, target);
+    const controller = (0, decorator_base_1.getDecorData)(constants_1.KEY_TYPE_CONTROLLER, target);
+    const middlewares = (_a = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_MIDDLEWARES, target)) !== null && _a !== void 0 ? _a : [];
+    const scopes = (_b = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_SCOPE, target)) !== null && _b !== void 0 ? _b : [];
+    const roles = (_c = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_ROLE, target)) !== null && _c !== void 0 ? _c : [];
+    const routes = (_d = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_ROUTE, target)) !== null && _d !== void 0 ? _d : {
+        routes: [],
+    };
+    const params = (_e = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_PARAM, target)) !== null && _e !== void 0 ? _e : {};
+    const pass = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_PASS, target);
+    return {
+        app,
+        module,
+        controller,
+        middlewares,
+        scopes,
+        roles,
+        routes,
+        params,
+        pass,
+    };
+}
+function applyAppOptions(options, Target, app, log) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const data = getData(Target);
+        const prefix = (_a = options.prefix) !== null && _a !== void 0 ? _a : "/";
+        const services = (_b = options.imports) !== null && _b !== void 0 ? _b : [];
+        if (data.middlewares.length) {
+            app.use(...data.middlewares);
+            log("middleware", `${Target.name} with middlewares: ${data.middlewares.map((e) => e.name).join(", ")}`);
+        }
+        (0, scope_transfrom_1.default)(data.scopes, (middleware) => {
+            app.use(middleware);
+            log("middleware", `${Target.name} with scopes: ${data.scopes.join(", ")}`);
+        });
+        (0, role_transform_1.default)(data.roles, (middleware) => {
+            app.use(middleware);
+            log("middleware", `${Target.name} with roles: ${data.roles.join(", ")}`);
+        });
+        const routers = yield Promise.all(options.modules.map((module) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const path = (_b = (_a = getData(module).module) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : "/";
+            return prepareTarget({
+                target: module,
+                router: if_router(module),
+                namespace: `${Target.name}/${module.name}`,
+                instance: app,
+                prefix: path,
+                log,
+            });
+        })));
+        routers.forEach(({ router, path }) => {
+            app.use((0, path_util_1.join)(prefix, path), router);
+        });
+    });
+}
+function prepareTarget(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ target, router, prefix = "/", namespace = "", instance, log, }) {
+        var _b, _c, _d, _e, _f, _g, _h, _j;
+        const _router = router !== null && router !== void 0 ? router : if_router(target);
+        const data = getData(target);
+        const modules = (_c = (_b = data.module) === null || _b === void 0 ? void 0 : _b.modules) !== null && _c !== void 0 ? _c : [];
+        const controllers = (_e = (_d = data.module) === null || _d === void 0 ? void 0 : _d.controllers) !== null && _e !== void 0 ? _e : [];
+        const routes = (_f = data.routes) !== null && _f !== void 0 ? _f : [];
+        const middlewares = (_g = data.middlewares) !== null && _g !== void 0 ? _g : [];
+        const scopes = (_h = data.scopes) !== null && _h !== void 0 ? _h : [];
+        const roles = (_j = data.roles) !== null && _j !== void 0 ? _j : [];
+        ////////////////////////////////
+        /// Attach Middlewares
+        ////////////////////////////////
+        _router.use(...middlewares);
+        (0, scope_transfrom_1.default)(scopes, (middleware) => _router.use(middleware));
+        (0, role_transform_1.default)(roles, (middleware) => _router.use(middleware));
+        ////////////////////////////////
+        /// Prepare Modules
+        ////////////////////////////////
+        yield (0, object_util_1.$each)(modules, (module) => __awaiter(this, void 0, void 0, function* () {
+            const moduleData = getData(module);
+            if (!moduleData.module)
+                return;
+            const router = yield prepareTarget({
+                target: module,
+                namespace: `${namespace}/${module.name}`,
+                prefix: moduleData.module.path,
+                instance: tsyringe_1.container.resolve(module),
+                log,
+            });
+            _router.use(router.path, router.router);
+        }));
+        // ////////////////////////////////
+        // /// Prepare Controllers
+        // ////////////////////////////////
+        yield (0, object_util_1.$each)(controllers, (controller) => __awaiter(this, void 0, void 0, function* () {
+            const data = getData(controller);
+            const controllerData = data.controller;
+            if (!controllerData)
+                return;
+            const router = yield prepareTarget({
+                target: controller,
+                namespace: `${namespace}/${controller.name}`,
+                prefix: controllerData.path,
+                instance: tsyringe_1.container.resolve(controller),
+                log,
+            });
+            _router.use(router.path, router.router);
+        }));
+        ////////////////////////////////
+        /// Prepare Routes
+        ////////////////////////////////
+        yield (0, object_util_1.$each)(Array.from(routes.routes), (route) => __awaiter(this, void 0, void 0, function* () {
+            if (typeof route !== "object")
+                return;
+            yield prepareRoutes({
+                target: target,
+                router: _router,
+                route,
+                namespace,
+                instance,
+                prefix,
+                log,
+            });
+        }));
+        return {
+            router: _router,
+            path: prefix,
+        };
+    });
+}
+function prepareRoutes(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ target, router, route, instance, namespace, prefix, scopes = [], roles = [], log, }) {
+        var _b, _c, _d;
+        const { method, path, handler, propertyKey } = route;
+        const metadata = getData(handler);
+        const params = (_d = (_c = (_b = metadata.params) === null || _b === void 0 ? void 0 : _b.params) === null || _c === void 0 ? void 0 : _c[propertyKey]) !== null && _d !== void 0 ? _d : [];
+        const $fn = Reflect.get(router, method);
+        const hasParams = params.length > 0;
+        if (!$fn)
+            return;
+        const middlewares = [...metadata.middlewares];
+        (0, role_transform_1.default)(metadata.roles, (middleware) => middlewares.push(middleware));
+        (0, scope_transfrom_1.default)(metadata.scopes, (middleware) => middlewares.push(middleware));
+        log("routes", `${namespace}/${propertyKey} ${method.toUpperCase()} { ${path} }`);
+        if (!hasParams) {
+            $fn.call(router, path, ...middlewares, handler.bind(instance));
+        }
+        else {
+            $fn.call(router, path, ...middlewares, (req, res) => __awaiter(this, void 0, void 0, function* () {
+                const args = yield Promise.all(params.map((param) => __awaiter(this, void 0, void 0, function* () {
+                    const { resolver, key } = param;
+                    return yield resolver(req, res);
+                })));
+                return handler.bind(instance)(...args, req, res);
+            }));
+        }
+    });
+}

package/dist/decorators/HyperController.d.ts

@@ -0,0 +1,2 @@
+import { HyperControllerMetadata } from "./types";
+export declare const HyperController: (options?: HyperControllerMetadata | string) => ClassDecorator;

package/dist/decorators/HyperController.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperController = void 0;
+const decorator_base_1 = require("../__internals/decorator-base");
+const constants_1 = require("../__internals/constants");
+const HyperController = (options) => {
+    var _a, _b, _c;
+    const isString = typeof options === "string";
+    return (0, decorator_base_1.DecoratorHelper)({
+        type: constants_1.KEY_TYPE_CONTROLLER,
+        key: constants_1.KEY_PARAMS_CONTROLLER,
+        options: {
+            path: isString ? options : (_a = options === null || options === void 0 ? void 0 : options.path) !== null && _a !== void 0 ? _a : "/",
+            roles: isString ? [] : (_b = options === null || options === void 0 ? void 0 : options.roles) !== null && _b !== void 0 ? _b : [],
+            scopes: isString ? [] : (_c = options === null || options === void 0 ? void 0 : options.scopes) !== null && _c !== void 0 ? _c : [],
+        },
+    });
+};
+exports.HyperController = HyperController;

package/dist/decorators/HyperModule.d.ts

@@ -0,0 +1,5 @@
+import { HyperModuleDecorator } from "./types";
+/**
+ * Decorator to define a module with controllers and services.
+ */
+export declare const HyperModule: HyperModuleDecorator;

package/dist/decorators/HyperModule.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperModule = void 0;
+const constants_1 = require("../__internals/constants");
+const decorator_base_1 = require("../__internals/decorator-base");
+/**
+ * Decorator to define a module with controllers and services.
+ */
+const HyperModule = (options) => (0, decorator_base_1.DecoratorHelper)({
+    type: constants_1.KEY_PARAMS_MODULE,
+    key: constants_1.KEY_PARAMS_MODULE,
+    options,
+});
+exports.HyperModule = HyperModule;

package/dist/decorators/Middleware.d.ts

@@ -0,0 +1,24 @@
+import "reflect-metadata";
+import { MiddlewareHandler } from "hyper-express";
+/**
+ * Middleware decorator to attach middleware to controllers, modules, and routes.
+ */
+export declare const Middleware: {
+    (...middleware: MiddlewareHandler[]): ClassDecorator & MethodDecorator;
+    /**
+     * Exclude middleware from matching paths.
+     *
+     * @param expresiosn
+     * @param middleware
+     * @returns
+     */
+    exclude(expresiosn: RegExp | RegExp[], middleware: MiddlewareHandler): ClassDecorator & MethodDecorator;
+    /**
+     * Only run middleware on matching paths.
+     *
+     * @param expresiosn
+     * @param middleware
+     * @returns
+     */
+    only(expresiosn: RegExp | RegExp[], middleware: MiddlewareHandler): ClassDecorator & MethodDecorator;
+};