@zenofolio/hyper-decor 1.0.4 → 1.0.8

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

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeMetadata = mergeMetadata;
-require("reflect-metadata");
+const meta_store_1 = require("../stores/meta.store");
+/**
+ * Perform a clean merge of prefixes
+ */
+const HyperMeta = meta_store_1.Metadata.prefix('server');
 /**
  * Performs a deep merge of metadata from source to target using reflect-metadata.
  * @param target Object where the metadata will be merged.
@@ -10,35 +14,51 @@ require("reflect-metadata");
  * @param options Merge options (e.g., array handling).
  */
 function mergeMetadata(target, source, keys, options = {}) {
-    for (const key of keys) {
-        const sourceMeta = Reflect.getMetadata(key, source);
-        const targetMeta = Reflect.getMetadata(key, target);
-        if (sourceMeta === undefined)
+    const sourceRoot = meta_store_1.Metadata.get(source);
+    const targetRoot = meta_store_1.Metadata.get(target);
+    const sourceServer = sourceRoot.server;
+    if (!sourceServer)
+        return;
+    const sourceCommon = sourceServer.common;
+    const targetServer = targetRoot.server || (targetRoot.server = { common: { type: 'controller' }, methods: {} });
+    const targetCommon = targetServer.common;
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = sourceCommon[key]; // Narrowing complex union access
+        if (value === undefined)
             continue;
-        let mergedMeta = sourceMeta;
-        if (typeof sourceMeta === "object" && typeof targetMeta === "object") {
-            mergedMeta = deepMerge(targetMeta, sourceMeta, options);
-        }
-        Reflect.defineMetadata(key, mergedMeta, target);
+        const current = targetCommon[key];
+        const merged = current === undefined
+            ? value
+            : deepMerge(current, value, options);
+        targetCommon[key] = merged;
+    }
+    // Also merge methods if they exist to preserve routes/params when extending
+    if (sourceServer.methods) {
+        const sourceMethods = sourceServer.methods;
+        const targetMethods = targetServer.methods || (targetServer.methods = {});
+        Object.keys(sourceMethods).forEach(methodKey => {
+            targetMethods[methodKey] = deepMerge(targetMethods[methodKey] || {}, sourceMethods[methodKey], options);
+        });
     }
 }
-/**
- * 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 sourceObj = source;
+        const sourceKeys = Object.keys(sourceObj);
+        for (let i = 0; i < sourceKeys.length; i++) {
+            const k = sourceKeys[i];
+            result[k] = deepMerge(result[k], sourceObj[k], options);
         }
-        return merged;
+        return result;
     }
     return source;
 }

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

@@ -0,0 +1,5 @@
+import "reflect-metadata";
+import { Server } from "hyper-express";
+import { Constructor, HyperAppMetadata, LogSpaces } from "../../lib/server/decorators/types";
+export declare function registerInstanceHandlers(instance: object, target: Constructor, namespace: string, log: (space: keyof LogSpaces, message: string) => void): Promise<void>;
+export declare function prepareApplication(options: HyperAppMetadata, Target: Constructor, log: (space: keyof LogSpaces, message: string) => void): Promise<Server>;

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

@@ -0,0 +1,392 @@
+"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.registerInstanceHandlers = registerInstanceHandlers;
+exports.prepareApplication = prepareApplication;
+require("reflect-metadata");
+const hyper_express_1 = require("hyper-express");
+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 middleware_transform_1 = __importDefault(require("../transform/middleware.transform"));
+const path_util_1 = require("../utils/path.util");
+const transform_registry_1 = require("../transform/transform.registry");
+const message_bus_1 = require("../../common/message-bus");
+const transport_1 = require("../../common/transport");
+/* -------------------------------------------------------------------------- */
+/*                                  Helpers                                   */
+/* -------------------------------------------------------------------------- */
+function createRouter(target) {
+    if (!target || !(target.prototype instanceof hyper_express_1.Router)) {
+        return new hyper_express_1.Router();
+    }
+    return new target();
+}
+function getServerMetadata(target) {
+    const root = meta_store_1.Metadata.get(target);
+    return root.server || {
+        common: { type: "controller" },
+        methods: {},
+    };
+}
+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 {
+        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,
+    };
+}
+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* () {
+        const methods = getMethodMetadataMap(target);
+        const bus = tsyringe_1.container.resolve(message_bus_1.MessageBus);
+        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}`);
+            }
+        }
+    });
+}
+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) => {
+            carrier.use(middleware);
+            log === null || log === void 0 ? void 0 : log("middleware", `${targetName} with roles: ${data.roles.join(", ")}`);
+        });
+    }
+}
+/* -------------------------------------------------------------------------- */
+/*                           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,
+            });
+        });
+    });
+    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)));
+    });
+}
+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 (needsTransform) {
+            const transformed = yield transform_registry_1.transformRegistry.resolve({
+                data: result,
+                schema: outputSchema,
+                options: {},
+                req,
+                res,
+                from: "response",
+            });
+            if (transformed !== undefined && !res.completed) {
+                res.json(transformed);
+                return;
+            }
+        }
+        if (res.completed)
+            return;
+        if (typeof result === "object" && result !== null) {
+            res.json(result);
+        }
+        else {
+            res.send(result);
+        }
+    });
+}
+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} ${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 = yield argumentResolver(req, res);
+                const result = yield handlerMethod.apply(instance, args);
+                yield responseSender(res, result, req);
+            }
+            catch (err) {
+                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 registerRoutes(target, instance, router, namespace, log) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const methods = getMethodMetadataMap(target);
+        for (const key of Object.keys(methods)) {
+            const route = methods[key].route;
+            if (route)
+                yield prepareRoute(target, router, route, instance, namespace, log);
+        }
+    });
+}
+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);
+        yield registerRoutes(target, instance, router, 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);
+            }
+        }
+        // Direct routes on module
+        yield registerRoutes(target, instance, router, context.namespace, 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 } : {})));
+        });
+        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);
+        // Direct routes on app
+        yield registerRoutes(Target, appInstance, appServer, context.namespace, 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);
+            }
+        }
+        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>;
+};

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

@@ -1,15 +1,4 @@
-interface MetadataStoreOptions {
-    target: any;
-    propertyKey?: string | symbol;
-    descriptorOrIndex?: any;
-}
-declare class MetadatStore {
-    static define(key: string | symbol, value: any, { target, propertyKey }: MetadataStoreOptions): void;
-    static get<T>(key: string | symbol, { target, propertyKey }: MetadataStoreOptions, def: T): T;
-    static list<T extends any = any>(key: string | symbol, { target, propertyKey }: MetadataStoreOptions): {
-        has: () => boolean;
-        get: () => never[];
-        set: (...value: T[]) => void;
-    };
-}
-export default MetadatStore;
+export * from "./meta.store";
+export * from "./hyper.store";
+export * from "./scope.store";
+export * from "./serivces.store";

package/dist/__internals/stores/index.js

@@ -1,37 +1,20 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const object_util_1 = require("../utils/object.util");
-class MetadatStore {
-    static define(key, value, { target, propertyKey }) {
-        if (target && typeof propertyKey === "string") {
-            Reflect.defineMetadata(key, value, Reflect.get(target, propertyKey));
-        }
-        else {
-            Reflect.defineMetadata(key, value, (0, object_util_1.$constructor)(target));
-        }
-    }
-    static get(key, { target, propertyKey }, def) {
-        if (target && typeof propertyKey === "string") {
-            return Reflect.getMetadata(key, Reflect.get(target, propertyKey)) || def;
-        }
-        else {
-            return Reflect.getMetadata(key, (0, object_util_1.$constructor)(target)) || def;
-        }
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    static list(key, { target, propertyKey }) {
-        return {
-            has: () => {
-                return this.get(key, { target, propertyKey }, []).length > 0;
-            },
-            get: () => {
-                return this.get(key, { target, propertyKey }, []);
-            },
-            set: (...value) => {
-                const list = this.get(key, { target, propertyKey }, []);
-                list.push(...value);
-                this.define(key, list, { target, propertyKey });
-            },
-        };
-    }
-}
-exports.default = MetadatStore;
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./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 {};