@zenofolio/hyper-decor 1.0.7 → 1.0.8

package/dist/__internals/stores/hyper.store.d.ts

@@ -0,0 +1,5 @@
+import { HyperCommonMetadata, HyperMethodMetadata } from "../types";
+export declare const HyperMeta: {
+    set: (target: object, propertyKey: any, data: Partial<HyperCommonMetadata> | Partial<HyperMethodMetadata>) => void;
+    get: (target: object, propertyKey?: any) => Partial<HyperCommonMetadata> | Partial<HyperMethodMetadata>;
+};

package/dist/__internals/stores/hyper.store.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperMeta = void 0;
+const meta_store_1 = require("./meta.store");
+exports.HyperMeta = meta_store_1.Metadata.prefix('server');

package/dist/__internals/stores/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./meta.store";
+export * from "./hyper.store";
+export * from "./scope.store";
+export * from "./serivces.store";

package/dist/{lib/openapi/helpers → __internals/stores}/index.js

@@ -14,10 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./method.helper"), exports);
-__exportStar(require("./parameter.helper"), exports);
-__exportStar(require("./request-body.helper"), exports);
-__exportStar(require("./response.helper"), exports);
-__exportStar(require("./security.helper"), exports);
-__exportStar(require("./tag.helper"), exports);
-__exportStar(require("./openapi.helper"), exports);
+__exportStar(require("./meta.store"), exports);
+__exportStar(require("./hyper.store"), exports);
+__exportStar(require("./scope.store"), exports);
+__exportStar(require("./serivces.store"), exports);

package/dist/__internals/stores/meta.store.d.ts

@@ -0,0 +1,34 @@
+import 'reflect-metadata';
+type MetadataRecord = Record<string, unknown>;
+export declare class Metadata {
+    /**
+     * Resolve the real metadata target.
+     * If an instance is passed, use its constructor.
+     */
+    private static resolveTarget;
+    /**
+     * Track class constructors for discovery.
+     */
+    private static track;
+    /**
+     * Get metadata for a target.
+     * Auto-initializes the metadata object if missing.
+     */
+    static get<T = MetadataRecord>(target: object): T;
+    /**
+     * Replace the full metadata object for a target.
+     */
+    static rawSet<T extends MetadataRecord>(target: object, value: T): void;
+    /**
+     * Create a scoped metadata accessor.
+     */
+    static prefix<TCommon extends object, TMember extends object>(name: string): {
+        set: (target: object, propertyKey: any, data: Partial<TCommon> | Partial<TMember>) => void;
+        get: (target: object, propertyKey?: any) => Partial<TCommon> | Partial<TMember>;
+    };
+    /**
+     * Get all tracked classes.
+     */
+    static getTrackedClasses(): object[];
+}
+export {};

package/dist/__internals/stores/meta.store.js

@@ -0,0 +1,107 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Metadata = void 0;
+require("reflect-metadata");
+/**
+ * Global Symbols for cross-package consistency
+ */
+const METADATA_STORE = Symbol.for('hyper:store');
+const DISCOVERY_INDEX = Symbol.for('hyper:index');
+const globalRegistry = globalThis;
+/**
+ * Global stores ensure that even different copies of the package
+ * share the same metadata and discovery registry.
+ */
+const globalStore = (_a = globalRegistry[METADATA_STORE]) !== null && _a !== void 0 ? _a : (globalRegistry[METADATA_STORE] = new WeakMap());
+const globalIndex = (_b = globalRegistry[DISCOVERY_INDEX]) !== null && _b !== void 0 ? _b : (globalRegistry[DISCOVERY_INDEX] = new Set());
+class Metadata {
+    /**
+     * Resolve the real metadata target.
+     * If an instance is passed, use its constructor.
+     */
+    static resolveTarget(target) {
+        return typeof target === 'function' ? target : target.constructor;
+    }
+    /**
+     * Track class constructors for discovery.
+     */
+    static track(target) {
+        if (typeof target === 'function') {
+            globalIndex.add(target);
+        }
+    }
+    /**
+     * Get metadata for a target.
+     * Auto-initializes the metadata object if missing.
+     */
+    static get(target) {
+        const resolved = this.resolveTarget(target);
+        let meta = globalStore.get(resolved);
+        if (!meta) {
+            meta = {};
+            globalStore.set(resolved, meta);
+            this.track(resolved);
+        }
+        return meta;
+    }
+    /**
+     * Replace the full metadata object for a target.
+     */
+    static rawSet(target, value) {
+        const resolved = this.resolveTarget(target);
+        globalStore.set(resolved, value);
+        this.track(resolved);
+    }
+    /**
+     * Create a scoped metadata accessor.
+     */
+    static prefix(name) {
+        const resolveKey = (key) => {
+            if (typeof key === 'string' || typeof key === 'symbol' || key === undefined) {
+                return key;
+            }
+            if (typeof key === 'object' && key !== null) {
+                if (key.kind === 'class')
+                    return undefined;
+                if (key.name)
+                    return key.name;
+            }
+            return undefined;
+        };
+        return {
+            set: (target, propertyKey, data) => {
+                var _a, _b, _c, _d;
+                const root = Metadata.get(target);
+                const scoped = ((_a = root[name]) !== null && _a !== void 0 ? _a : (root[name] = {}));
+                const key = resolveKey(propertyKey);
+                if (key === undefined) {
+                    Object.assign(((_b = scoped.common) !== null && _b !== void 0 ? _b : (scoped.common = {})), data);
+                    return;
+                }
+                const methods = ((_c = scoped.methods) !== null && _c !== void 0 ? _c : (scoped.methods = {}));
+                Object.assign(((_d = methods[key]) !== null && _d !== void 0 ? _d : (methods[key] = {})), data);
+            },
+            get: (target, propertyKey) => {
+                var _a, _b, _c;
+                const root = Metadata.get(target);
+                const scoped = root[name];
+                if (!scoped) {
+                    return {};
+                }
+                const key = resolveKey(propertyKey);
+                if (key === undefined) {
+                    return ((_a = scoped.common) !== null && _a !== void 0 ? _a : (scoped.common = {}));
+                }
+                return (_c = (_b = scoped.methods) === null || _b === void 0 ? void 0 : _b[key]) !== null && _c !== void 0 ? _c : {};
+            },
+        };
+    }
+    /**
+     * Get all tracked classes.
+     */
+    static getTrackedClasses() {
+        return [...globalIndex];
+    }
+}
+exports.Metadata = Metadata;

package/dist/{stores → __internals/stores}/scope.store.d.ts

@@ -1,4 +1,4 @@
-import { ScopeMap } from "../decorators";
+import { ScopeMap } from "../../lib/server/decorators";
 /**
  * This class is a store for the scopes that are defined in the application.
  *

package/dist/__internals/transform/middleware.transform.d.ts

@@ -1,3 +1,3 @@
 import { MiddlewareHandler } from "hyper-express";
-import { MiddlewareType } from "../../decorators";
+import { MiddlewareType } from "../../lib/server/decorators";
 export default function middlewareTransformer(list: MiddlewareType[]): MiddlewareHandler[];

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

@@ -4,7 +4,7 @@ exports.default = middlewareTransformer;
 const tsyringe_1 = require("tsyringe");
 function middlewareTransformer(list) {
     return list
-        .map((middleware) => {
+        .map((middleware, idx) => {
         if (isClass(middleware)) {
             const instance = tsyringe_1.container.resolve(middleware);
             return instance.handle.bind(instance);

package/dist/__internals/transform/role.transform.d.ts

@@ -1,5 +1,5 @@
 import { MiddlewareHandler } from "hyper-express";
-import { RoleType } from "../../decorators";
+import { RoleType } from "../../lib/server/decorators";
 export default function roleTransform(list: RoleType[], callback?: (middleware: MiddlewareHandler, roles: {
     role: string;
     description: string;

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

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = roleTransform;
-const exeptions_1 = require("../../exeptions");
-const helpers_1 = require("../../common/helpers");
-const constants_1 = require("../constants");
+const exeptions_1 = require("../../lib/server/exeptions");
+const role_1 = require("../../common/helpers/role");
+const constants_1 = require("../../constants");
 function roleTransform(list, callback) {
     const { roles, names, isEmtpy } = resolveRoles(list);
     const middleware = (req, res, next) => {
         var _a;
         if (isEmtpy)
             return next();
-        const requestRoles = (_a = (0, helpers_1.getRoles)(req)) !== null && _a !== void 0 ? _a : [];
+        const requestRoles = (_a = (0, role_1.getRoles)(req)) !== null && _a !== void 0 ? _a : [];
         if (requestRoles.length === 0 && isEmtpy)
             return next();
         if (requestRoles.includes(constants_1.FULL_ACCESS))

package/dist/__internals/transform/scope.transfrom.d.ts

@@ -1,5 +1,5 @@
 import { MiddlewareHandler } from "hyper-express/types";
-import { ScopeMap, ScopeType } from "../../decorators";
+import { ScopeMap, ScopeType } from "../../lib/server/decorators";
 type Callback = (middleware: MiddlewareHandler, scopes: ScopeMap[], names: Set<string>) => void;
 export default function scopeTransfrom(listScopes: ScopeType[], ...callback: Callback[]): MiddlewareHandler;
 export {};

package/dist/__internals/transform/scope.transfrom.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = scopeTransfrom;
-const exeptions_1 = require("../../exeptions");
+const exeptions_1 = require("../../lib/server/exeptions");
 const helpers_1 = require("../../common/helpers");
-const constants_1 = require("../constants");
+const constants_1 = require("../../constants");
 function scopeTransfrom(listScopes, ...callback) {
     const { scopes, scopeNames, isEmpty } = resolveScopes(listScopes);
     const middleware = (req, res, next) => {

package/dist/__internals/types.d.ts

@@ -1,7 +1,56 @@
-import { RouteMetadata } from "../decorators";
-export interface RouterList {
-    type: string;
-    routes: Set<RouteMetadata>;
+import { HyperAppMetadata, HyperModuleMetadata, HyperControllerMetadata, HyperParameterMetadata, RouteMetadata, Constructor, MiddlewareType, ScopeType, RoleType } from "../lib/server/decorators/types";
+/**
+ * 🛠️ Shared Class-Level Metadata Keys
+ */
+export interface HyperBaseCommon {
+    middlewares?: MiddlewareType[];
+    scopes?: ScopeType[];
+    roles?: RoleType[];
+    pass?: unknown;
+}
+/**
+ * 📦 Hierarchical Metadata Structure for Components
+ */
+export type HyperCommonMetadata = (HyperAppMetadata & HyperBaseCommon & {
+    type: 'app';
+}) | (HyperModuleMetadata & HyperBaseCommon & {
+    type: 'module';
+}) | (HyperControllerMetadata & HyperBaseCommon & {
+    type: 'controller';
+}) | (HyperBaseCommon & {
+    type: 'service';
+});
+/**
+ * 📡 Hierarchical Metadata Structure for Methods
+ */
+export interface HyperMethodMetadata {
+    route?: RouteMetadata;
+    params?: HyperParameterMetadata;
+    middlewares?: MiddlewareType[];
+    scopes?: ScopeType[];
+    roles?: RoleType[];
+    onMessage?: {
+        topic: string;
+    };
+    output?: unknown;
+    reflection?: {
+        params?: (Constructor | Function)[];
+        output?: Constructor | Function;
+    };
+}
+/**
+ * 🌳 Root storage for a prefix segment (e.g. 'hyper')
+ */
+export interface HyperPrefixRoot {
+    common: HyperCommonMetadata;
+    methods: Record<string, HyperMethodMetadata>;
+}
+/**
+ * 🏦 The global metadata store structure per class constructor
+ */
+export interface HyperMetadataStore {
+    server?: HyperPrefixRoot;
+    openapi?: unknown;
 }
 export type HyperApplicationPrivate<T> = T & {
     prepare(): Promise<void>;

package/dist/common/bootstrap.d.ts

@@ -1,3 +1,7 @@
 import { IHyperApp, IHyperApplication } from "../type";
-export default function createApplication<T extends IHyperApplication>(app: new (...args: any[]) => T): Promise<IHyperApp<T>>;
-export { createApplication };
+/**
+ * Creates a new HyperApplication.
+ *
+ * @param app
+ */
+export declare function createApplication<T extends IHyperApplication>(application: new (...args: any[]) => T): Promise<IHyperApp<T>>;

package/dist/common/bootstrap.js

@@ -9,21 +9,60 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = createApplication;
 exports.createApplication = createApplication;
 const tsyringe_1 = require("tsyringe");
 const message_bus_1 = require("./message-bus");
-function createApplication(app) {
+const stores_1 = require("../__internals/stores");
+const prepare_helper_1 = require("../__internals/helpers/prepare.helper");
+const transform_registry_1 = require("../__internals/transform/transform.registry");
+/**
+ * Creates a new HyperApplication.
+ *
+ * @param app
+ */
+function createApplication(application) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const instance = tsyringe_1.container.resolve(app);
-        if (instance.prepare) {
-            yield instance.prepare();
+        const metadata = stores_1.HyperMeta.get(application);
+        if (metadata.type !== "app") {
+            throw new Error("Application must be decorated with @HyperApp");
         }
-        (_a = instance === null || instance === void 0 ? void 0 : instance.onPrepare) === null || _a === void 0 ? void 0 : _a.call(instance);
-        instance.emit = (topic, data) => __awaiter(this, void 0, void 0, function* () {
-            yield message_bus_1.MessageBus.emit(topic, data);
+        const logger = metadata.logger || console.log;
+        const logWrapper = (space, msg) => {
+            var _a;
+            if ((_a = metadata.logs) === null || _a === void 0 ? void 0 : _a[space]) {
+                logger(`[${space.toUpperCase()}] ${msg}`);
+            }
+        };
+        const appServer = yield (0, prepare_helper_1.prepareApplication)(metadata, application, logWrapper);
+        const appInstance = tsyringe_1.container.resolve(application);
+        const appProxy = new Proxy(appInstance, {
+            get(target, prop) {
+                if (prop === "useTransform") {
+                    return (transformer) => {
+                        transform_registry_1.transformRegistry.register(transformer);
+                        return appProxy;
+                    };
+                }
+                if (prop === "emit") {
+                    return (topic, data) => __awaiter(this, void 0, void 0, function* () {
+                        const bus = tsyringe_1.container.resolve(message_bus_1.MessageBus);
+                        yield bus.emit(topic, data);
+                    });
+                }
+                // Prioritize application instance methods/props
+                if (prop in target) {
+                    const value = target[prop];
+                    return typeof value === "function" ? value.bind(target) : value;
+                }
+                // Fallback to hyper-express server
+                const serverValue = appServer[prop];
+                return typeof serverValue === "function" ? serverValue.bind(appServer) : serverValue;
+            },
         });
-        return instance;
+        if ("onPrepare" in appInstance && typeof appInstance.onPrepare === "function") {
+            const onPrepare = appInstance.onPrepare.bind(appInstance);
+            yield onPrepare();
+        }
+        return appProxy;
     });
 }

package/dist/common/testing.d.ts

@@ -0,0 +1,56 @@
+import "reflect-metadata";
+import { InjectionToken } from "tsyringe";
+import { Constructor, HyperAppMetadata, ImportType } from "../lib/server/decorators/types";
+export type Token<T = any> = InjectionToken<T> | Constructor<T> | string | (abstract new (...args: any[]) => T);
+/**
+ * 🧪 TestingModule
+ * Holds the context of a compiled test environment.
+ */
+export declare class TestingModule {
+    private target?;
+    constructor(target?: Constructor | undefined);
+    /**
+     * Resolves a dependency from the container and ensures it's initialized.
+     */
+    resolve<T>(token: Token<T>): Promise<T>;
+    /**
+     * Shortcut for resolve (consistent with NestJS)
+     */
+    get<T>(token: Token<T>): Promise<T>;
+    /**
+     * Creates the full HyperExpress application proxy.
+     */
+    createHyperApplication(): Promise<any>;
+}
+/**
+ * 🛠️ TestingModuleBuilder
+ * Fluent API for configuring the testing module.
+ */
+export declare class TestingModuleBuilder {
+    private metadata;
+    constructor(metadata: Partial<HyperAppMetadata>);
+    overrideProvider(token: Token): any;
+    compile(): Promise<TestingModule>;
+}
+/**
+ * 🚀 HyperTest
+ * Entry point for creating testing environments.
+ */
+export declare class HyperTest {
+    /**
+     * Ultra-simple one-liner to boot a module or app.
+     * const module = await HyperTest.create(AppModule);
+     */
+    static create(Target: Constructor, options?: {
+        providers?: ImportType[];
+    }): Promise<TestingModule>;
+    /**
+     * Full builder API for complex configurations.
+     */
+    static createTestingModule(metadata: Partial<HyperAppMetadata>): TestingModuleBuilder;
+    /**
+     * Resets the global container instances (but keeps registrations).
+     * Useful between tests when isolation is not possible.
+     */
+    static reset(): void;
+}

package/dist/common/testing.js

@@ -0,0 +1,193 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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.HyperTest = exports.TestingModuleBuilder = exports.TestingModule = void 0;
+require("reflect-metadata");
+const tsyringe_1 = require("tsyringe");
+const stores_1 = require("../__internals/stores");
+const lifecycle_helper_1 = require("../__internals/helpers/lifecycle.helper");
+const bootstrap_1 = require("./bootstrap");
+const HyperApp_1 = require("../lib/server/decorators/HyperApp");
+/**
+ * 🧪 TestingModule
+ * Holds the context of a compiled test environment.
+ */
+class TestingModule {
+    constructor(target) {
+        this.target = target;
+    }
+    /**
+     * Resolves a dependency from the container and ensures it's initialized.
+     */
+    resolve(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield deepResolve(token);
+        });
+    }
+    /**
+     * Shortcut for resolve (consistent with NestJS)
+     */
+    get(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.resolve(token);
+        });
+    }
+    /**
+     * Creates the full HyperExpress application proxy.
+     */
+    createHyperApplication() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.target) {
+                throw new Error("Cannot create application without a target module/app.");
+            }
+            return yield (0, bootstrap_1.createApplication)(this.target);
+        });
+    }
+}
+exports.TestingModule = TestingModule;
+/**
+ * 🛠️ TestingModuleBuilder
+ * Fluent API for configuring the testing module.
+ */
+class TestingModuleBuilder {
+    constructor(metadata) {
+        this.metadata = metadata;
+    }
+    overrideProvider(token) {
+        return {
+            useValue: (value) => {
+                tsyringe_1.container.register(token, { useValue: value });
+                return this;
+            },
+            useClass: (target) => {
+                tsyringe_1.container.register(token, { useClass: target });
+                return this;
+            },
+            useFactory: (factory) => {
+                tsyringe_1.container.register(token, { useFactory: factory });
+                return this;
+            }
+        };
+    }
+    compile() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 1. Create a synthetic app if needed
+            let SyntheticApp = class SyntheticApp {
+            };
+            SyntheticApp = __decorate([
+                (0, HyperApp_1.HyperApp)(this.metadata)
+            ], SyntheticApp);
+            // 2. Deep initialize all defined imports/providers
+            if (this.metadata.imports) {
+                for (const item of this.metadata.imports) {
+                    const token = typeof item === "object" && "token" in item ? item.token : item;
+                    yield deepResolve(token);
+                }
+            }
+            return new TestingModule(SyntheticApp);
+        });
+    }
+}
+exports.TestingModuleBuilder = TestingModuleBuilder;
+/**
+ * 🚀 HyperTest
+ * Entry point for creating testing environments.
+ */
+class HyperTest {
+    /**
+     * Ultra-simple one-liner to boot a module or app.
+     * const module = await HyperTest.create(AppModule);
+     */
+    static create(Target, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const builder = this.createTestingModule({
+                imports: [Target, ...((options === null || options === void 0 ? void 0 : options.providers) || [])]
+            });
+            const module = yield builder.compile();
+            // Ensure the target itself is deep-resolved
+            yield deepResolve(Target);
+            return module;
+        });
+    }
+    /**
+     * Full builder API for complex configurations.
+     */
+    static createTestingModule(metadata) {
+        return new TestingModuleBuilder(metadata);
+    }
+    /**
+     * Resets the global container instances (but keeps registrations).
+     * Useful between tests when isolation is not possible.
+     */
+    static reset() {
+        tsyringe_1.container.clearInstances();
+    }
+}
+exports.HyperTest = HyperTest;
+/**
+ * 🔄 deepResolve
+ * Recursively resolves a token and ensures its onInit chain is executed.
+ */
+function deepResolve(token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const instance = tsyringe_1.container.resolve(token);
+        // 1. Get the actual implementation constructor to inspect dependencies.
+        // We prefer instance.constructor because if token is an abstract class,
+        // dependencies are defined on the implementation.
+        const target = (instance === null || instance === void 0 ? void 0 : instance.constructor) || (typeof token === "function" ? token : null);
+        // 2. Recursive resolution of dependencies (Bottom-up initialization)
+        if (target && typeof target === "function") {
+            const paramTypes = Reflect.getMetadata("design:paramtypes", target) || [];
+            const injectionTokens = Reflect.getOwnMetadata("injectionTokens", target) || {};
+            for (let i = 0; i < paramTypes.length; i++) {
+                // Use @inject token if present, otherwise use design:paramtype
+                const dep = injectionTokens[i] || paramTypes[i];
+                // Avoid cycles or primitives
+                if (dep && typeof dep === "function" && dep !== Object && dep !== Array && dep !== String && dep !== Number && dep !== Boolean) {
+                    yield deepResolve(dep);
+                }
+            }
+        }
+        // 3. Metadata Discovery (traversing @HyperApp, @HyperModule, etc.)
+        const metadata = stores_1.HyperMeta.get(target);
+        if (metadata) {
+            // Resolve imports
+            if (metadata.imports && Array.isArray(metadata.imports)) {
+                for (const item of metadata.imports) {
+                    const depToken = typeof item === "object" && item !== null && "token" in item ? item.token : item;
+                    if (depToken)
+                        yield deepResolve(depToken);
+                }
+            }
+            // Resolve modules recursively
+            if (metadata.modules && Array.isArray(metadata.modules)) {
+                for (const m of metadata.modules) {
+                    yield deepResolve(m);
+                }
+            }
+            // Resolve controllers
+            if (metadata.controllers && Array.isArray(metadata.controllers)) {
+                for (const c of metadata.controllers) {
+                    yield deepResolve(c);
+                }
+            }
+        }
+        // 4. Initialize the instance itself
+        yield (0, lifecycle_helper_1.initializeInstance)(instance);
+        return instance;
+    });
+}

package/dist/common/transport.d.ts

@@ -4,6 +4,7 @@ export interface IMessageTransport {
 }
 export declare class InternalTransport implements IMessageTransport {
     private emitter;
+    private wildcardHandlers;
     listen(topic: string, handler: (data: any) => Promise<void> | void): Promise<void>;
     emit(topic: string, data: any): Promise<void>;
 }