@zenofolio/hyper-decor 1.0.61 → 1.0.63

package/dist/__internals/constants.d.ts

@@ -41,6 +41,7 @@ export declare const METADATA_KEYS: {
     SCOPES: string;
     SCOPED: string;
     MIDDLEWARES: string;
+    ON_MESSAGE: string;
 };
 export declare const METADATA_STORE_KEYS: {
     PARAMS: string;

package/dist/__internals/constants.js

@@ -52,6 +52,7 @@ exports.METADATA_KEYS = {
     SCOPES: "hyper:scopes",
     SCOPED: "hyper:scoped",
     MIDDLEWARES: "hyper:middleware",
+    ON_MESSAGE: "hyper:on_message",
 };
 exports.METADATA_STORE_KEYS = {
     PARAMS: "hyper:store:params",

package/dist/__internals/decorator-base.js

@@ -48,12 +48,17 @@ function DecoratorHelper({ key, type, options, targetResolver, onDefineData }, .
             else {
                 (0, exports.defineDecorData)(key, Object.assign({ type }, options), Target);
                 value = Reflect.decorate(transforms, Target);
+                // If the class was wrapped/replaced, apply metadata to the new class too
+                if (value && value !== Target) {
+                    (0, exports.defineDecorData)(key, Object.assign({ type }, options), value);
+                }
             }
         }
         (0, tsyringe_1.injectable)()((0, object_util_1.$constructor)(target));
         return value;
     };
 }
+const METADATA_CACHE = new WeakMap();
 const defineDecorData = (key, options, target, property, descriptor) => {
     let value = options;
     if (typeof options === "function") {
@@ -66,21 +71,52 @@ const defineDecorData = (key, options, target, property, descriptor) => {
     else {
         Reflect.defineMetadata(key, value, target);
     }
+    // Update Cache
+    let targetCache = METADATA_CACHE.get(target);
+    if (!targetCache) {
+        targetCache = new Map();
+        METADATA_CACHE.set(target, targetCache);
+    }
+    targetCache.set(property ? `${key}:${property}` : key, value);
 };
 exports.defineDecorData = defineDecorData;
-const getDecorData = (key, target, property) => property
-    ? Reflect.getMetadata(key, target, property)
-    : Reflect.getMetadata(key, target);
+const getDecorData = (key, target, property) => {
+    const cacheKey = property ? `${key}:${property}` : key;
+    const targetCache = METADATA_CACHE.get(target);
+    if (targetCache && targetCache.has(cacheKey)) {
+        return targetCache.get(cacheKey);
+    }
+    const value = property
+        ? Reflect.getMetadata(key, target, property)
+        : Reflect.getMetadata(key, target);
+    if (value !== undefined) {
+        let tc = METADATA_CACHE.get(target);
+        if (!tc) {
+            tc = new Map();
+            METADATA_CACHE.set(target, tc);
+        }
+        tc.set(cacheKey, value);
+    }
+    return value;
+};
 exports.getDecorData = getDecorData;
-const hasDecorData = (key, target, property) => property
-    ? Reflect.hasMetadata(key, target, property)
-    : Reflect.hasMetadata(key, target);
+const hasDecorData = (key, target, property) => {
+    const cacheKey = property ? `${key}:${property}` : key;
+    const targetCache = METADATA_CACHE.get(target);
+    if (targetCache && targetCache.has(cacheKey))
+        return true;
+    return property
+        ? Reflect.hasMetadata(key, target, property)
+        : Reflect.hasMetadata(key, target);
+};
 exports.hasDecorData = hasDecorData;
 const extractDecorData = (target) => {
     const keys = Reflect.getMetadataKeys(target);
-    return keys.reduce((acc, key) => {
-        acc[key] = Reflect.getMetadata(key, target);
-        return acc;
-    }, {});
+    const result = {};
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        result[key] = (0, exports.getDecorData)(key, target);
+    }
+    return result;
 };
 exports.extractDecorData = extractDecorData;

package/dist/__internals/helpers/imports.helper.d.ts

@@ -1,8 +1,8 @@
-import { ImportType } from "../../decorators/types";
+import { IHyperHooks, ImportType } from "../../decorators/types";
 /**
  * Prepare imports for the target class.
  *
  * @param target
  * @param imports
  */
-export declare function prepareImports(target: any, imports: ImportType[]): Promise<void>;
+export declare function prepareImports(_target: any, imports: ImportType[], hooks?: IHyperHooks, context?: any): Promise<void>;

package/dist/__internals/helpers/imports.helper.js

@@ -11,35 +11,82 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepareImports = prepareImports;
 const tsyringe_1 = require("tsyringe");
+const lifecycle_helper_1 = require("./lifecycle.helper");
+const decorator_base_1 = require("../decorator-base");
+const constants_1 = require("../constants");
+const message_bus_1 = require("../../common/message-bus");
 /**
  * Prepare imports for the target class.
  *
  * @param target
  * @param imports
  */
-function prepareImports(target, imports) {
+function prepareImports(_target, imports, hooks, context) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        for (const service of imports) {
-            const _class = tsyringe_1.container.resolve(service);
-            if (!_class)
-                continue;
-            const isSingleton = ((_a = _class.isSingleton) === null || _a === void 0 ? void 0 : _a.call(_class)) === true;
-            if (isSingleton) {
-                if (isInitialized(_class))
-                    continue;
-                tsyringe_1.container.registerInstance(service, _class);
+        const bus = tsyringe_1.container.resolve(message_bus_1.MessageBus);
+        yield Promise.all(imports.map((item) => __awaiter(this, void 0, void 0, function* () {
+            let token;
+            if (typeof item === "function" || typeof item === "string" || typeof item === "symbol") {
+                token = item;
             }
-            if (typeof _class.onInit === "function") {
-                yield _class.onInit();
-                if (isSingleton)
-                    setInitialized(_class);
+            else if (item && typeof item === "object" && "token" in item) {
+                token = item.token;
+                if (item.useClass) {
+                    tsyringe_1.container.register(token, { useClass: item.useClass }, item.options);
+                }
+                else if ("useValue" in item) {
+                    tsyringe_1.container.registerInstance(token, item.useValue);
+                    return;
+                }
+                else if (item.useFactory) {
+                    tsyringe_1.container.register(token, { useFactory: item.useFactory }, item.options);
+                    return;
+                }
+                else if (item.useToken) {
+                    tsyringe_1.container.register(token, { useToken: item.useToken }, item.options);
+                    return;
+                }
             }
-        }
+            if (!token)
+                return;
+            try {
+                const instance = tsyringe_1.container.resolve(token);
+                if (!instance)
+                    return;
+                // Skip if already initialized to avoid double work/double subscription
+                const alreadyDone = (0, lifecycle_helper_1.isInitialized)(instance);
+                if (!alreadyDone) {
+                    if (hooks === null || hooks === void 0 ? void 0 : hooks.onBeforeInit) {
+                        yield hooks.onBeforeInit(instance, token, context);
+                    }
+                }
+                yield (0, lifecycle_helper_1.initializeInstance)(instance);
+                if (!alreadyDone) {
+                    if (hooks === null || hooks === void 0 ? void 0 : hooks.onAfterInit) {
+                        yield hooks.onAfterInit(instance, token, context);
+                    }
+                    // Handle singleton registration if it's a constructor and not registered
+                    if (typeof token === "function" && !tsyringe_1.container.isRegistered(token)) {
+                        const isSingleton = typeof instance.isSingleton === "function" ? instance.isSingleton() : true;
+                        if (isSingleton) {
+                            tsyringe_1.container.registerInstance(token, instance);
+                        }
+                    }
+                    // Discovery: Messaging (only on first init)
+                    const messaging = (0, decorator_base_1.getDecorData)(constants_1.METADATA_KEYS.ON_MESSAGE, typeof token === "function" ? token : instance.constructor);
+                    if (messaging === null || messaging === void 0 ? void 0 : messaging.length) {
+                        messaging.forEach((msg) => {
+                            bus.listen(msg.topic, instance[msg.propertyKey].bind(instance));
+                        });
+                    }
+                }
+            }
+            catch (e) {
+                // Skip dependencies that cannot be resolved automatically
+                // Log a warning to prevent silent failures in production
+                const name = typeof token === "function" ? token.name : String(token);
+                console.warn(`[HyperDecor] Warn: Could not resolve dependency for token "${name}". It might be missing injectable() or not exported correctly.`);
+            }
+        })));
     });
 }
-////////////////////////
-/// Utils
-////////////////////////
-const isInitialized = (target) => Reflect.get(target, "____initialized") === true;
-const setInitialized = (target) => Reflect.set(target, "____initialized", true);

package/dist/__internals/helpers/lifecycle.helper.d.ts

@@ -0,0 +1,3 @@
+export declare const isInitialized: (target: any) => boolean;
+export declare const setInitialized: (target: any) => boolean;
+export declare function initializeInstance(instance: any): Promise<void>;

package/dist/__internals/helpers/lifecycle.helper.js

@@ -0,0 +1,25 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setInitialized = exports.isInitialized = void 0;
+exports.initializeInstance = initializeInstance;
+const isInitialized = (target) => Reflect.get(target, "____initialized") === true;
+exports.isInitialized = isInitialized;
+const setInitialized = (target) => Reflect.set(target, "____initialized", true);
+exports.setInitialized = setInitialized;
+function initializeInstance(instance) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (instance && typeof instance.onInit === "function" && !(0, exports.isInitialized)(instance)) {
+            yield instance.onInit();
+            (0, exports.setInitialized)(instance);
+        }
+    });
+}

package/dist/__internals/helpers/merge-metadata.js

@@ -10,35 +10,31 @@ require("reflect-metadata");
  * @param options Merge options (e.g., array handling).
  */
 function mergeMetadata(target, source, keys, options = {}) {
-    for (const key of keys) {
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
         const sourceMeta = Reflect.getMetadata(key, source);
-        const targetMeta = Reflect.getMetadata(key, target);
         if (sourceMeta === undefined)
             continue;
-        let mergedMeta = sourceMeta;
-        if (typeof sourceMeta === "object" && typeof targetMeta === "object") {
-            mergedMeta = deepMerge(targetMeta, sourceMeta, options);
-        }
-        Reflect.defineMetadata(key, mergedMeta, target);
+        const targetMeta = Reflect.getMetadata(key, target);
+        Reflect.defineMetadata(key, targetMeta === undefined ? sourceMeta : deepMerge(targetMeta, sourceMeta, options), target);
     }
 }
-/**
- * Performs a deep merge of two objects.
- * @param target Target object.
- * @param source Source object.
- * @param options Merge options.
- * @returns Merged object.
- */
 function deepMerge(target, source, options) {
     if (Array.isArray(target) && Array.isArray(source)) {
-        return (options.overwriteArrays ? source : Array.from(new Set([...target, ...source])));
+        if (options.overwriteArrays)
+            return source;
+        // Faster deduplication for primitive arrays
+        const combined = target.concat(source);
+        return Array.from(new Set(combined));
     }
-    if (typeof target === "object" && target !== null && typeof source === "object" && source !== null) {
-        const merged = Object.assign({}, target);
-        for (const key of Object.keys(source)) {
-            merged[key] = deepMerge(target[key], source[key], options);
+    if (source && typeof source === "object" && target && typeof target === "object") {
+        const result = Object.assign({}, target);
+        const sourceKeys = Object.keys(source);
+        for (let i = 0; i < sourceKeys.length; i++) {
+            const k = sourceKeys[i];
+            result[k] = deepMerge(result[k], source[k], options);
         }
-        return merged;
+        return result;
     }
     return source;
 }

package/dist/__internals/helpers/prepare.helper.js

@@ -24,7 +24,8 @@ const middleware_transform_1 = __importDefault(require("../transform/middleware.
 const tsyringe_1 = require("tsyringe");
 const path_util_1 = require("../utils/path.util");
 const imports_helper_1 = require("./imports.helper");
-const service_store_1 = require("../stores/service.store");
+const message_bus_1 = require("../../common/message-bus");
+const transport_1 = require("../../common/transport");
 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();
@@ -71,12 +72,29 @@ function getData(target) {
  */
 function prepareApplication(options, Target, app, log) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
+        var _a, _b, _c;
         const data = getData(Target);
         const prefix = (_a = options.prefix) !== null && _a !== void 0 ? _a : "/";
         const imports = (_b = options.imports) !== null && _b !== void 0 ? _b : [];
-        yield prepareServices(service_store_1.serviceStore);
-        yield (0, imports_helper_1.prepareImports)(Target, imports);
+        // Register transports if provided, otherwise fallback to internal
+        const bus = tsyringe_1.container.resolve(message_bus_1.MessageBus);
+        if ((_c = options === null || options === void 0 ? void 0 : options.transports) === null || _c === void 0 ? void 0 : _c.length) {
+            options.transports.forEach((t) => bus.registerTransport(t));
+        }
+        else {
+            bus.registerTransport(new transport_1.InternalTransport());
+        }
+        let hooks = options.hooks;
+        if (typeof hooks === "function" && !(hooks instanceof hyper_express_1.Router)) {
+            if (hooks && "constructor" in hooks) {
+                if (tsyringe_1.container.isRegistered(hooks)) {
+                    tsyringe_1.container.register(hooks, hooks);
+                }
+            }
+            hooks = tsyringe_1.container.resolve(hooks);
+        }
+        const context = { target: Target, metadata: options, type: "app" };
+        yield (0, imports_helper_1.prepareImports)(Target, imports, hooks, context);
         if (data.middlewares.length) {
             app.use(...data.middlewares);
             log("middleware", `${Target.name} with middlewares: ${data.middlewares
@@ -92,11 +110,11 @@ function prepareApplication(options, Target, app, log) {
             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, _c, _d;
+        const routers = (yield Promise.all(options.modules.map((module) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
             const data = getData(module);
-            const path = (_b = (_a = data.module) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : "/";
-            const imports = (_d = (_c = data.module) === null || _c === void 0 ? void 0 : _c.imports) !== null && _d !== void 0 ? _d : [];
+            const path = (_a = data.module) === null || _a === void 0 ? void 0 : _a.path;
+            const imports = (_c = (_b = data.module) === null || _b === void 0 ? void 0 : _b.imports) !== null && _c !== void 0 ? _c : [];
             return prepareTarget({
                 target: module,
                 router: if_router(module),
@@ -105,10 +123,11 @@ function prepareApplication(options, Target, app, log) {
                 prefix: path,
                 imports: imports,
                 log,
+                hooks: hooks,
             });
-        })));
+        })))).filter((r) => r.router);
         routers.forEach(({ router, path }) => {
-            app.use((0, path_util_1.join)(prefix, path), router);
+            app.use((0, path_util_1.join)(prefix, path || "/"), router);
         });
     });
 }
@@ -120,29 +139,43 @@ function prepareApplication(options, Target, app, log) {
  * @returns
  */
 function prepareTarget(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ target, router, prefix = "/", namespace = "", instance, imports = [], log, }) {
+    return __awaiter(this, arguments, void 0, function* ({ target, router, prefix, namespace = "", instance, imports = [], log, hooks, }) {
         var _b, _c, _d, _e, _f, _g, _h, _j;
-        const _router = router !== null && router !== void 0 ? router : if_router(target);
         const data = getData(target);
+        if (data.module) {
+            log("modules", `${namespace} { ${prefix || "/"} }`);
+        }
+        else if (data.controller) {
+            log("controllers", `${namespace} { ${prefix || "/"} }`);
+        }
         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 routes = (_f = data.routes) !== null && _f !== void 0 ? _f : { routes: [] };
         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 : [];
+        const needsRouter = controllers.length > 0 ||
+            routes.routes.size > 0 ||
+            middlewares.length > 0 ||
+            scopes.length > 0 ||
+            roles.length > 0;
+        const _router = router !== null && router !== void 0 ? router : (needsRouter ? if_router(target) : undefined);
         ////////////////////////////////
         /// Prepare Imports
         ////////////////////////////////
-        yield (0, imports_helper_1.prepareImports)(target, imports);
+        const context = { target: target, metadata: data, type: "target" };
+        yield (0, imports_helper_1.prepareImports)(target, imports, hooks, context);
         ////////////////////////////////
-        /// Attach Middlewares
+        /// Attach Middlewares & Security
         ////////////////////////////////
-        _router.use(...middlewares);
-        (0, scope_transfrom_1.default)(scopes, (middleware, scopes) => {
-            stores_1.ScopeStore.addAll(scopes);
-            _router.use(middleware);
-        });
-        (0, role_transform_1.default)(roles, (middleware) => _router.use(middleware));
+        if (_router) {
+            _router.use(...middlewares);
+            (0, scope_transfrom_1.default)(scopes, (middleware, scopes) => {
+                stores_1.ScopeStore.addAll(scopes);
+                _router.use(middleware);
+            });
+            (0, role_transform_1.default)(roles, (middleware) => _router.use(middleware));
+        }
         ////////////////////////////////
         /// Prepare Modules
         ////////////////////////////////
@@ -150,15 +183,18 @@ function prepareTarget(_a) {
             const moduleData = getData(module);
             if (!moduleData.module)
                 return;
-            const router = yield prepareTarget({
+            const res = yield prepareTarget({
                 target: module,
                 imports: moduleData.module.imports,
                 namespace: `${namespace}/${module.name}`,
                 prefix: moduleData.module.path,
                 instance: tsyringe_1.container.resolve(module),
                 log,
+                hooks,
             });
-            _router.use(router.path, router.router);
+            if (res.router && _router) {
+                _router.use(res.path || "/", res.router);
+            }
         }));
         // ////////////////////////////////
         // /// Prepare Controllers
@@ -168,32 +204,37 @@ function prepareTarget(_a) {
             const controllerData = data.controller;
             if (!controllerData)
                 return;
-            const router = yield prepareTarget({
+            const res = yield prepareTarget({
                 target: controller,
                 namespace: `${namespace}/${controller.name}`,
                 prefix: controllerData.path,
                 imports: controllerData.imports,
                 instance: tsyringe_1.container.resolve(controller),
                 log,
+                hooks,
             });
-            _router.use(router.path, router.router);
+            if (res.router && _router) {
+                _router.use(res.path || "/", res.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,
-            });
-        }));
+        if (_router) {
+            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: prefix || "/",
+                    log,
+                });
+            }));
+        }
         return {
             router: _router,
             path: prefix,
@@ -232,21 +273,13 @@ function prepareRoutes(_a) {
         }
         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);
+                const len = params.length;
+                const args = new Array(len);
+                for (let i = 0; i < len; i++) {
+                    args[i] = yield params[i].resolver(req, res);
+                }
+                return handler.apply(instance, args);
             }));
         }
     });
 }
-function prepareServices(list) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield Promise.all(Array.from(list).map((service) => __awaiter(this, void 0, void 0, function* () {
-            const instance = tsyringe_1.container.resolve(service);
-            if (instance.onInit)
-                yield instance.onInit();
-        })));
-    });
-}

package/dist/__internals/helpers/tree.helper.d.ts

@@ -0,0 +1,32 @@
+import { HyperAppMetadata, HyperModuleMetadata, HyperControllerMetadata, RouteMetadata } from "../../decorators/types";
+export interface AppTree {
+    app: HyperAppMetadata & {
+        target: any;
+        fullPath: string;
+    };
+    modules: ModuleNode[];
+}
+export interface ModuleNode {
+    metadata: HyperModuleMetadata;
+    target: any;
+    fullPath: string;
+    modules: ModuleNode[];
+    controllers: ControllerNode[];
+    services: any[];
+}
+export interface ControllerNode {
+    metadata: HyperControllerMetadata;
+    target: any;
+    fullPath: string;
+    routes: RouteNode[];
+    services: any[];
+}
+export interface RouteNode extends RouteMetadata {
+    fullPath: string;
+    params: any[];
+}
+/**
+ * Extracts the complete application metadata tree.
+ * This is useful for generating Swagger/OpenAPI documentation or graphing the app structure.
+ */
+export declare function getAppTree(Target: any): AppTree;

package/dist/__internals/helpers/tree.helper.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppTree = getAppTree;
+const decorator_base_1 = require("../decorator-base");
+const constants_1 = require("../constants");
+const path_util_1 = require("../utils/path.util");
+/**
+ * Extracts the complete application metadata tree.
+ * This is useful for generating Swagger/OpenAPI documentation or graphing the app structure.
+ */
+function getAppTree(Target) {
+    const appMetadata = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_APP, Target);
+    const prefix = (appMetadata === null || appMetadata === void 0 ? void 0 : appMetadata.prefix) || "/";
+    return {
+        app: Object.assign(Object.assign({}, appMetadata), { target: Target, fullPath: prefix }),
+        modules: ((appMetadata === null || appMetadata === void 0 ? void 0 : appMetadata.modules) || []).map(m => getModuleNode(m, prefix))
+    };
+}
+function getModuleNode(Target, parentPath = "") {
+    const metadata = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_MODULE, Target);
+    const currentPath = (0, path_util_1.join)(parentPath, (metadata === null || metadata === void 0 ? void 0 : metadata.path) || "");
+    return {
+        metadata,
+        target: Target,
+        fullPath: currentPath,
+        modules: ((metadata === null || metadata === void 0 ? void 0 : metadata.modules) || []).map(m => getModuleNode(m, currentPath)),
+        controllers: ((metadata === null || metadata === void 0 ? void 0 : metadata.controllers) || []).map(c => getControllerNode(c, currentPath)),
+        services: ((metadata === null || metadata === void 0 ? void 0 : metadata.imports) || [])
+    };
+}
+function getControllerNode(Target, parentPath = "") {
+    const metadata = (0, decorator_base_1.getDecorData)(constants_1.KEY_TYPE_CONTROLLER, Target);
+    const routeList = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_ROUTE, Target);
+    const paramMetadata = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_PARAM, Target);
+    const currentPath = (0, path_util_1.join)(parentPath, (metadata === null || metadata === void 0 ? void 0 : metadata.path) || "");
+    const routes = Array.from((routeList === null || routeList === void 0 ? void 0 : routeList.routes) || []).map((route) => {
+        var _a;
+        const params = ((_a = paramMetadata === null || paramMetadata === void 0 ? void 0 : paramMetadata.params) === null || _a === void 0 ? void 0 : _a[route.propertyKey]) || [];
+        return Object.assign(Object.assign({}, route), { fullPath: (0, path_util_1.join)(currentPath, route.path), params });
+    });
+    return {
+        metadata,
+        target: Target,
+        fullPath: currentPath,
+        routes,
+        services: (metadata === null || metadata === void 0 ? void 0 : metadata.imports) || []
+    };
+}

package/dist/__internals/transform/middleware.transform.js

@@ -3,8 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = middlewareTransformer;
 const tsyringe_1 = require("tsyringe");
 function middlewareTransformer(list) {
-    if (!(list === null || list === void 0 ? void 0 : list.length))
-        return [];
     return list
         .map((middleware) => {
         if (isClass(middleware)) {

package/dist/__internals/transform/role.transform.js

@@ -10,16 +10,16 @@ function roleTransform(list, callback) {
         var _a;
         if (isEmtpy)
             return next();
-        const requestRoles = new Set((_a = (0, helpers_1.getRoles)(req)) !== null && _a !== void 0 ? _a : []);
-        if (requestRoles.size === 0 && isEmtpy)
+        const requestRoles = (_a = (0, helpers_1.getRoles)(req)) !== null && _a !== void 0 ? _a : [];
+        if (requestRoles.length === 0 && isEmtpy)
             return next();
-        if (requestRoles.has(constants_1.FULL_ACCESS))
+        if (requestRoles.includes(constants_1.FULL_ACCESS))
             return next();
-        const role = roles.some((scope) => requestRoles.has(scope.role));
+        const role = roles.some((scope) => requestRoles.includes(scope.role));
         if (role) {
             return next();
         }
-        return next(new exeptions_1.NotRoleException(`Only ${Array.from(names).join(", ")} can access this resource`, Array.from(requestRoles), Array.from(names)));
+        return next(new exeptions_1.NotRoleException(`Only ${Array.from(names).join(", ")} can access this resource`, requestRoles, Array.from(names)));
     };
     if (names.size > 0 && callback) {
         callback(middleware, roles, names);