@zenofolio/hyper-decor 1.0.72 → 1.0.74

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

@@ -12,259 +12,149 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerInstanceHandlers = registerInstanceHandlers;
 exports.prepareApplication = prepareApplication;
+require("reflect-metadata");
 const hyper_express_1 = require("hyper-express");
-const stores_1 = require("../../stores");
+const tsyringe_1 = require("tsyringe");
+const stores_1 = require("../stores");
+const meta_store_1 = require("../stores/meta.store");
 const role_transform_1 = __importDefault(require("../transform/role.transform"));
 const scope_transfrom_1 = __importDefault(require("../transform/scope.transfrom"));
-const object_util_1 = require("../utils/object.util");
-const decorator_base_1 = require("../decorator-base");
-const constants_1 = require("../constants");
 const middleware_transform_1 = __importDefault(require("../transform/middleware.transform"));
-const tsyringe_1 = require("tsyringe");
 const path_util_1 = require("../utils/path.util");
-const imports_helper_1 = require("./imports.helper");
+const transform_registry_1 = require("../transform/transform.registry");
 const message_bus_1 = require("../../common/message-bus");
 const transport_1 = require("../../common/transport");
-const transform_registry_1 = require("../transform/transform.registry");
-const if_router = (current) => {
-    if (!current || !((current === null || current === void 0 ? void 0 : current.prototype) instanceof hyper_express_1.Router))
+/* -------------------------------------------------------------------------- */
+/*                                  Helpers                                   */
+/* -------------------------------------------------------------------------- */
+function createRouter(target) {
+    if (!target || !(target.prototype instanceof hyper_express_1.Router)) {
         return new hyper_express_1.Router();
-    return new current();
-};
-/**
- * Extract the data from the target class.
- *
- * @param target
- * @returns
- */
-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 = (0, middleware_transform_1.default)((_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: [],
+    }
+    return new target();
+}
+function getServerMetadata(target) {
+    const root = meta_store_1.Metadata.get(target);
+    return root.server || {
+        common: { type: "controller" },
+        methods: {},
     };
-    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);
+}
+function getCommonMetadata(target) {
+    const server = getServerMetadata(target);
+    return server.common || { type: "controller" };
+}
+function getMethodMetadataMap(target) {
+    const server = getServerMetadata(target);
+    return (server.methods || {});
+}
+function getData(target) {
+    var _a, _b, _c;
+    const common = getCommonMetadata(target);
     return {
-        app,
-        module,
-        controller,
-        middlewares,
-        scopes,
-        roles,
-        routes,
-        params,
-        pass,
+        type: common.type,
+        metadata: common,
+        middlewares: (0, middleware_transform_1.default)((_a = common.middlewares) !== null && _a !== void 0 ? _a : []),
+        scopes: (_b = common.scopes) !== null && _b !== void 0 ? _b : [],
+        roles: (_c = common.roles) !== null && _c !== void 0 ? _c : [],
+        methods: getMethodMetadataMap(target),
+        pass: !!common.pass,
     };
 }
-/**
- * Prepare the application with the given options.
- *
- * @param options
- * @param Target
- * @param app
- * @param log
- */
-function prepareApplication(options, Target, app, log) {
+function logTargetType(type, namespace, prefix, log) {
+    if (type === "module") {
+        log("modules", `${namespace} { ${prefix} }`);
+    }
+    else if (type === "controller") {
+        log("controllers", `${namespace} { ${prefix} }`);
+    }
+}
+function registerInstanceHandlers(instance, target, namespace, log) {
     return __awaiter(this, void 0, void 0, function* () {
-        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 : [];
-        // Register transports if provided, otherwise fallback to internal
+        const methods = getMethodMetadataMap(target);
         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);
-                }
+        for (const propertyKey of Object.keys(methods)) {
+            const methodMeta = methods[propertyKey];
+            if (methodMeta.onMessage) {
+                yield bus.listen(methodMeta.onMessage.topic, (data) => __awaiter(this, void 0, void 0, function* () {
+                    return yield instance[propertyKey].call(instance, data);
+                }));
+                log("messaging", `${namespace}/${propertyKey} -> ${methodMeta.onMessage.topic}`);
             }
-            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
-                .map((e) => e.name)
-                .join(", ")}`);
         }
-        (0, scope_transfrom_1.default)(data.scopes, (middleware, scopes) => {
-            stores_1.ScopeStore.addAll(scopes);
-            app.use(middleware);
-            log("middleware", `${Target.name} with scopes: ${data.scopes.join(", ")}`);
+    });
+}
+function applyCommonPipeline(targetName, carrier, data, log) {
+    if (data.middlewares.length) {
+        carrier.use(...data.middlewares);
+        log === null || log === void 0 ? void 0 : log("middleware", `${targetName} with middlewares: ${data.middlewares.map(m => m.name).join(", ")}`);
+    }
+    if (data.scopes.length) {
+        (0, scope_transfrom_1.default)(data.scopes, (middleware, resolvedScopes) => {
+            stores_1.ScopeStore.addAll(resolvedScopes);
+            carrier.use(middleware);
+            log === null || log === void 0 ? void 0 : log("middleware", `${targetName} with scopes: ${data.scopes.join(", ")}`);
         });
+    }
+    if (data.roles.length) {
         (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, _c;
-            const data = getData(module);
-            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),
-                namespace: `${Target.name}/${module.name}`,
-                instance: app,
-                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);
+            carrier.use(middleware);
+            log === null || log === void 0 ? void 0 : log("middleware", `${targetName} with roles: ${data.roles.join(", ")}`);
         });
-    });
+    }
 }
-/**
- * Prepare the target class
- * HyperModule or HyperController can be used as target.
- *
- * @param param0
- * @returns
- */
-function prepareTarget(_a) {
-    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 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 : { 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
-        ////////////////////////////////
-        const context = { target: target, metadata: data, type: "target" };
-        yield (0, imports_helper_1.prepareImports)(target, imports, hooks, context);
-        ////////////////////////////////
-        /// Attach Middlewares & Security
-        ////////////////////////////////
-        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
-        ////////////////////////////////
-        yield (0, object_util_1.$each)(modules, (module) => __awaiter(this, void 0, void 0, function* () {
-            const moduleData = getData(module);
-            if (!moduleData.module)
-                return;
-            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,
-            });
-            if (res.router && _router) {
-                _router.use(res.path || "/", res.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 res = yield prepareTarget({
-                target: controller,
-                namespace: `${namespace}/${controller.name}`,
-                prefix: controllerData.path,
-                imports: controllerData.imports,
-                instance: tsyringe_1.container.resolve(controller),
-                log,
-                hooks,
+/* -------------------------------------------------------------------------- */
+/*                           Route/Handler construction                        */
+/* -------------------------------------------------------------------------- */
+function buildArgumentsResolver(paramsMeta) {
+    const sorted = [...paramsMeta].sort((a, b) => a.index - b.index);
+    const hasBody = sorted.some((p) => p.source === "body");
+    // Pre-calculate per-parameter resolution logic
+    const resolvers = sorted.map((meta) => {
+        if (meta.resolver)
+            return meta.resolver;
+        const sourceKey = meta.source;
+        if (!sourceKey)
+            return () => null;
+        const isWhole = meta.isWholeSource;
+        const picker = meta.picker;
+        const schema = meta.schema;
+        return (req, res, body) => __awaiter(this, void 0, void 0, function* () {
+            if (sourceKey === "req")
+                return req;
+            if (sourceKey === "res")
+                return res;
+            let source = sourceKey === "body" ? body : req[sourceKey];
+            if (!source)
+                return null;
+            const rawValue = isWhole ? source : picker ? source[picker] : source;
+            if (!schema)
+                return rawValue;
+            return yield transform_registry_1.transformRegistry.resolve({
+                data: rawValue,
+                schema,
+                options: {},
+                req,
+                res,
+                from: sourceKey,
             });
-            if (res.router && _router) {
-                _router.use(res.path || "/", res.router);
-            }
-        }));
-        ////////////////////////////////
-        /// Prepare Routes
-        ////////////////////////////////
-        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,
-        };
+        });
     });
-}
-/**
- * Resolves method parameters and applies adaptive transformations.
- * Optimized: Metadata is resolved once and passed here.
- */
-function resolveMethodParams(req, res, params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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 args;
+    return (req, res) => __awaiter(this, void 0, void 0, function* () {
+        if (resolvers.length === 0)
+            return [req, res];
+        const body = hasBody && typeof req.json === "function" ? yield req.json() : undefined;
+        return yield Promise.all(resolvers.map((r) => r(req, res, body)));
     });
 }
-/**
- * Handles output transformation and sends the response.
- * Optimized: outputSchema is pre-resolved outside the request hotpath.
- */
-function handleResponse(req, res, result, outputSchema) {
-    return __awaiter(this, void 0, void 0, function* () {
+function buildResponseSender(outputSchema) {
+    const needsTransform = outputSchema && outputSchema !== Object && outputSchema !== Promise;
+    return (res, result, req) => __awaiter(this, void 0, void 0, function* () {
         if (result === undefined || res.completed)
             return;
-        if (outputSchema && outputSchema !== Object && outputSchema !== Promise) {
+        if (needsTransform) {
             const transformed = yield transform_registry_1.transformRegistry.resolve({
                 data: result,
                 schema: outputSchema,
@@ -278,61 +168,216 @@ function handleResponse(req, res, result, outputSchema) {
                 return;
             }
         }
-        if (!res.completed) {
-            if (typeof result === "object" && result !== null) {
-                res.json(result);
-            }
-            else {
-                res.send(result);
-            }
+        if (res.completed)
+            return;
+        if (typeof result === "object" && result !== null) {
+            res.json(result);
+        }
+        else {
+            res.send(result);
         }
     });
 }
-/**
- * Prepare the routes for the target class.
- */
-function prepareRoutes(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ target, router, route, instance, namespace, log, }) {
-        var _b, _c, _d;
-        const { method, path, handler, propertyKey, options } = 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);
-        if (!$fn)
-            return;
-        const middlewares = [...metadata.middlewares];
-        const proto = target.prototype || target;
-        // Pre-resolve Output-Metadata
-        const outputSchema = Reflect.getMetadata(constants_1.KEY_OUTPUT_SCHEMA, proto, propertyKey) ||
-            Reflect.getMetadata(constants_1.DESIGN_RETURNTYPE, proto, propertyKey);
-        (0, role_transform_1.default)(metadata.roles, (middleware) => middlewares.push(middleware));
-        (0, scope_transfrom_1.default)(metadata.scopes, (middleware, scopes) => {
-            middlewares.push(middleware);
-            stores_1.ScopeStore.addAll(scopes);
+function prepareRoute(target, router, route, instance, namespace, log) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const { method, path, propertyKey, options } = route;
+        const methodMeta = getMethodMetadataMap(target)[propertyKey] || {};
+        const ctrlMeta = getCommonMetadata(target);
+        const roles = [...((_a = ctrlMeta.roles) !== null && _a !== void 0 ? _a : []), ...((_b = methodMeta.roles) !== null && _b !== void 0 ? _b : [])];
+        const scopes = [...((_c = ctrlMeta.scopes) !== null && _c !== void 0 ? _c : []), ...((_d = methodMeta.scopes) !== null && _d !== void 0 ? _d : [])];
+        const middlewares = (0, middleware_transform_1.default)((_e = methodMeta.middlewares) !== null && _e !== void 0 ? _e : []);
+        (0, role_transform_1.default)(roles, m => middlewares.push(m));
+        (0, scope_transfrom_1.default)(scopes, (m, s) => {
+            middlewares.push(m);
+            stores_1.ScopeStore.addAll(s);
         });
-        log("routes", `${namespace}/${propertyKey.toString()} ${method.toUpperCase()} { ${path} }`);
-        const routeHandler = (req, res) => __awaiter(this, void 0, void 0, function* () {
+        log("routes", `${namespace}/${propertyKey} ${method.toUpperCase()} { ${path} }`);
+        if (method === "ws" && options) {
+            router.ws(path, options, instance[propertyKey].bind(instance));
+            return;
+        }
+        const argumentResolver = buildArgumentsResolver(((_f = methodMeta.params) === null || _f === void 0 ? void 0 : _f.params) || []);
+        const responseSender = buildResponseSender(methodMeta.output || ((_g = methodMeta.reflection) === null || _g === void 0 ? void 0 : _g.output));
+        const handlerMethod = instance[propertyKey];
+        const handler = (req, res) => __awaiter(this, void 0, void 0, function* () {
             try {
-                const args = params.length > 0
-                    ? yield resolveMethodParams(req, res, params)
-                    : [req, res];
-                const result = yield handler.apply(instance, args);
-                yield handleResponse(req, res, result, outputSchema);
+                const args = yield argumentResolver(req, res);
+                const result = yield handlerMethod.apply(instance, args);
+                yield responseSender(res, result, req);
             }
             catch (err) {
-                if (!res.completed) {
-                    const error = err;
-                    res.status(error.status || 500).json({
-                        error: error.message || "Internal Server Error",
-                        code: error.code,
-                    });
+                if (res.completed)
+                    return;
+                const error = err;
+                res.status(error.status || 500).json({
+                    error: error.message || "Internal Server Error",
+                    code: error.code,
+                });
+            }
+        });
+        const fn = Reflect.get(router, method);
+        if (fn)
+            fn.call(router, path, ...middlewares, handler);
+    });
+}
+/* -------------------------------------------------------------------------- */
+/*                              Preparation Logic                             */
+/* -------------------------------------------------------------------------- */
+function prepareImportsInternal(imports, context, log) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield Promise.all(imports.map((item) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            let token;
+            if (typeof item === "function") {
+                token = item;
+                if (!tsyringe_1.container.isRegistered(token))
+                    tsyringe_1.container.register(token, token);
+            }
+            else if (typeof item === "object" && item !== null) {
+                const obj = item;
+                token = obj.token;
+                if (obj.useClass)
+                    tsyringe_1.container.register(token, { useClass: obj.useClass });
+                else if (obj.useValue)
+                    tsyringe_1.container.register(token, { useValue: obj.useValue });
+                else if (obj.useFactory)
+                    tsyringe_1.container.register(token, { useFactory: obj.useFactory });
+                else if (obj.useToken)
+                    tsyringe_1.container.register(token, { useToken: obj.useToken });
+            }
+            else {
+                token = item;
+            }
+            const instance = tsyringe_1.container.resolve(token);
+            if (instance) {
+                const itemContext = Object.assign(Object.assign({}, context), { type: "service", target: token });
+                if ((_a = context.hooks) === null || _a === void 0 ? void 0 : _a.onBeforeInit)
+                    yield context.hooks.onBeforeInit(instance, token, itemContext);
+                if (typeof token === "function" && token.name) {
+                    yield registerInstanceHandlers(instance, token, `imports/${token.name}`, log);
                 }
+                if (typeof instance.onInit === "function")
+                    yield instance.onInit();
+                if ((_b = context.hooks) === null || _b === void 0 ? void 0 : _b.onAfterInit)
+                    yield context.hooks.onAfterInit(instance, token, itemContext);
             }
+        })));
+    });
+}
+/**
+ * Ensures a class is resolvable by tsyringe even without @injectable()
+ */
+function ensureResolvable(target) {
+    if (!tsyringe_1.container.isRegistered(target)) {
+        // We apply injectable() at runtime to ensure metadata is picked up if not already done
+        (0, tsyringe_1.injectable)()(target);
+        tsyringe_1.container.register(target, target);
+    }
+}
+function prepareController(descriptor, context, log) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const { target, instance, metadata } = descriptor;
+        const data = getData(target);
+        const router = new hyper_express_1.Router();
+        logTargetType("controller", context.namespace, context.prefix, log);
+        yield prepareImportsInternal((_a = metadata.imports) !== null && _a !== void 0 ? _a : [], context, log);
+        yield registerInstanceHandlers(instance, target, context.namespace, log);
+        applyCommonPipeline(target.name, { use: (...args) => router.use(...args) }, data, log);
+        const methods = getMethodMetadataMap(target);
+        for (const key of Object.keys(methods)) {
+            const route = methods[key].route;
+            if (route)
+                yield prepareRoute(target, router, route, instance, context.namespace, log);
+        }
+        context.parentRouter.use(context.prefix, router);
+    });
+}
+function prepareModule(descriptor, context, log) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const { target, instance, metadata } = descriptor;
+        const data = getData(target);
+        const router = new hyper_express_1.Router();
+        logTargetType("module", context.namespace, context.prefix, log);
+        yield prepareImportsInternal((_a = metadata.imports) !== null && _a !== void 0 ? _a : [], context, log);
+        yield registerInstanceHandlers(instance, target, context.namespace, log);
+        applyCommonPipeline(target.name, { use: (...args) => router.use(...args) }, data, log);
+        // Recurse modules
+        if ((_b = metadata.modules) === null || _b === void 0 ? void 0 : _b.length) {
+            for (const m of metadata.modules) {
+                const mData = getData(m).metadata;
+                ensureResolvable(m);
+                yield prepareModule({ target: m, instance: tsyringe_1.container.resolve(m), metadata: mData }, {
+                    parentRouter: router,
+                    namespace: `${context.namespace}/${m.name}`,
+                    prefix: mData.path || "/",
+                    hooks: context.hooks,
+                    type: "module",
+                    target: m
+                }, log);
+            }
+        }
+        // Controllers
+        if ((_c = metadata.controllers) === null || _c === void 0 ? void 0 : _c.length) {
+            for (const c of metadata.controllers) {
+                const cData = getData(c).metadata;
+                ensureResolvable(c);
+                yield prepareController({ target: c, instance: tsyringe_1.container.resolve(c), metadata: cData }, {
+                    parentRouter: router,
+                    namespace: `${context.namespace}/${c.name}`,
+                    prefix: cData.path || "/",
+                    hooks: context.hooks,
+                    type: "controller",
+                    target: c
+                }, log);
+            }
+        }
+        context.parentRouter.use(context.prefix, router);
+    });
+}
+function prepareApplication(options, Target, log) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const appServer = new hyper_express_1.Server(options.uwsOptions || options.options);
+        // Register global error handler to properly handle status codes from exceptions
+        appServer.set_error_handler((req, res, error) => {
+            const status = error.status || 500;
+            res.status(status).json(Object.assign({ error: error.message || "Internal Server Error", code: error.code || "InternalServerError" }, (error instanceof Error ? { stack: error.stack } : {})));
         });
-        if (method === "ws" && options) {
-            router.ws(path, options, handler.bind(instance));
-            return;
+        ensureResolvable(Target);
+        const appInstance = tsyringe_1.container.resolve(Target);
+        const data = getData(Target);
+        const bus = tsyringe_1.container.resolve(message_bus_1.MessageBus);
+        const transports = options.transports && options.transports.length > 0 ? options.transports : [transport_1.InternalTransport];
+        transports.forEach(t => bus.registerTransport(typeof t === "function" ? tsyringe_1.container.resolve(t) : t));
+        const hooks = (options.hooks ? (typeof options.hooks === "function" ? tsyringe_1.container.resolve(options.hooks) : options.hooks) : undefined);
+        const context = {
+            parentRouter: appServer,
+            namespace: Target.name,
+            prefix: (_a = options.prefix) !== null && _a !== void 0 ? _a : "/",
+            hooks,
+            type: "app",
+            target: Target
+        };
+        yield prepareImportsInternal((_b = options.imports) !== null && _b !== void 0 ? _b : [], context, log);
+        yield registerInstanceHandlers(appInstance, Target, context.namespace, log);
+        applyCommonPipeline(Target.name, { use: (...args) => appServer.use(...args) }, data, log);
+        if ((_c = options.modules) === null || _c === void 0 ? void 0 : _c.length) {
+            for (const m of options.modules) {
+                const mData = getData(m).metadata;
+                ensureResolvable(m);
+                yield prepareModule({ target: m, instance: tsyringe_1.container.resolve(m), metadata: mData }, {
+                    parentRouter: appServer,
+                    namespace: `${Target.name}/${m.name}`,
+                    prefix: (0, path_util_1.join)(context.prefix, mData.path || "/"),
+                    hooks,
+                    type: "module",
+                    target: m
+                }, log);
+            }
         }
-        $fn.call(router, path, ...middlewares, routeHandler);
+        return appServer;
     });
 }

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>;
+};