@zenofolio/hyper-decor 1.0.71 → 1.0.73

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/__internals/stores/index.js

@@ -0,0 +1,20 @@
+"use strict";
+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]; } };
+    }
+    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 {};

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/__internals/stores/scope.store.d.ts

@@ -0,0 +1,14 @@
+import { ScopeMap } from "../../lib/server/decorators";
+/**
+ * This class is a store for the scopes that are defined in the application.
+ *
+ */
+export declare class ScopeStore {
+    private static scopes;
+    static add(scope: ScopeMap): void;
+    static addAll(scopes: ScopeMap[]): void;
+    static getScopes(): ScopeMap[];
+    static getScopeNames(): string[];
+    static isEmpty(): boolean;
+    static clear(): void;
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScopeStore = void 0;
+/**
+ * This class is a store for the scopes that are defined in the application.
+ *
+ */
+class ScopeStore {
+    static add(scope) {
+        this.scopes.set(scope.scope, scope); // Evita duplicados basados en el nombre del scope
+    }
+    static addAll(scopes) {
+        scopes.forEach((scope) => this.add(scope));
+    }
+    static getScopes() {
+        return Array.from(this.scopes.values());
+    }
+    static getScopeNames() {
+        return Array.from(this.scopes.keys());
+    }
+    static isEmpty() {
+        return this.scopes.size === 0;
+    }
+    static clear() {
+        this.scopes.clear();
+    }
+}
+exports.ScopeStore = ScopeStore;
+ScopeStore.scopes = new Map();

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

@@ -0,0 +1 @@
+export declare const serviceStore: Set<any>;

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceStore = void 0;
+exports.serviceStore = new Set();

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,55 @@ 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) => logger(`[${space}] ${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/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>;
 }

package/dist/common/transport.js

@@ -1,4 +1,10 @@
 "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) {
@@ -10,25 +16,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InternalTransport = void 0;
+const tsyringe_1 = require("tsyringe");
 const eventemitter3_1 = require("eventemitter3");
-class InternalTransport {
+let InternalTransport = class InternalTransport {
     constructor() {
         this.emitter = new eventemitter3_1.EventEmitter();
+        this.wildcardHandlers = [];
     }
     listen(topic, handler) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Basic wildcard support: user.* -> user.created, user.updated
-            // We'll use a simple regex for this internal transport
             if (topic.includes("*")) {
-                const pattern = new RegExp("^" + topic.replace(/\*/g, ".*") + "$");
-                // We need a catch-all for wildcards in EventEmitter3? 
-                // EE3 doesn't support wildcards out of the box easily without listening to all events.
-                // For this internal implementation, we'll override emit or use a proxy.
-                // But simpler: just use a pattern-matching listener.
-                this.emitter.on("message", (t, data) => {
-                    if (pattern.test(t)) {
-                        handler(data);
-                    }
+                const patternString = topic
+                    .replace(/[+?^${}()|[\]\\]/g, "\\$&")
+                    .replace(/\./g, "\\.")
+                    .replace(/\*/g, ".*");
+                this.wildcardHandlers.push({
+                    pattern: new RegExp(`^${patternString}$`),
+                    handler,
                 });
             }
             else {
@@ -38,9 +42,18 @@ class InternalTransport {
     }
     emit(topic, data) {
         return __awaiter(this, void 0, void 0, function* () {
+            // 1. Regular emit
             this.emitter.emit(topic, data);
-            this.emitter.emit("message", topic, data); // For wildcard listeners
+            // 2. Wildcard checks
+            for (const item of this.wildcardHandlers) {
+                if (item.pattern.test(topic)) {
+                    yield item.handler(data);
+                }
+            }
         });
     }
-}
+};
 exports.InternalTransport = InternalTransport;
+exports.InternalTransport = InternalTransport = __decorate([
+    (0, tsyringe_1.singleton)()
+], InternalTransport);

package/dist/constants.d.ts

@@ -1,3 +1,4 @@
 export declare const HYPER_SCOPES_KEY = "__HYPER_SCOPES_KEY";
 export declare const HYPER_ROLE_KEY = "__HYPER_ROLE_KEY";
 export declare const HYPER_PASS_KEY = "__HYPER_PASS_KEY";
+export declare const FULL_ACCESS = "*";

package/dist/constants.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HYPER_PASS_KEY = exports.HYPER_ROLE_KEY = exports.HYPER_SCOPES_KEY = void 0;
+exports.FULL_ACCESS = exports.HYPER_PASS_KEY = exports.HYPER_ROLE_KEY = exports.HYPER_SCOPES_KEY = void 0;
 exports.HYPER_SCOPES_KEY = "__HYPER_SCOPES_KEY";
 exports.HYPER_ROLE_KEY = "__HYPER_ROLE_KEY";
 exports.HYPER_PASS_KEY = "__HYPER_PASS_KEY";
+exports.FULL_ACCESS = "*";

package/dist/decorators/Http.d.ts

@@ -14,49 +14,9 @@ import { ParameterResolver } from "./types";
  * \@Query(UserQueryDto)
  */
 export declare function Query(keyOrSchema?: string | any, schemaOrTransform?: any): any;
-/**
- * Get the body of the request or transform it via a schema.
- *
- * @example
- * \@Body()
- * \@Body(CreateUserDto)
- */
-export declare function Body(schemaOrResolver?: any): any;
-/**
- * Get the params from the request or transform via schema.
- *
- * @example
- * \@Param('id')
- * \@Param('id', IntSchema)
- */
-export declare function Param(keyOrSchema: string | any, schemaOrValidator?: any): any;
-/**
- * Get the headers from the request.
- */
-export declare function Headers(keyOrSchema?: string | any, schema?: any): any;
+export declare function Body(keyOrSchema?: string | any, schemaOrTransform?: any): any;
+export declare function Param(keyOrSchema: string | any, schemaOrTransform?: any): any;
+export declare function Headers(keyOrSchema?: string | any, schemaOrTransform?: any): any;
 export declare const Req: () => ParameterDecorator;
 export declare const Res: () => ParameterDecorator;
-/**
- * Create a custom request decorator
- * that can be used to extract data from the request object
- *
- *
- * @example
- * ```typescript
- *
- * interface LoginData {
- *  username: string;
- *  password: string;
- * }
- *
- * const LoginData = createCustomRequestDecorator<LoginData>({
- *  resolver: async (request) => {
- *    const data = await request.json();
- *    return [data];
- *  }
- * }
- *
- *
- *
- */
 export declare const createCustomRequestDecorator: (decoratorName: string, resolver: ParameterResolver) => ParameterDecorator;