@zenofolio/hyper-decor 1.0.4 → 1.0.7

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

@@ -0,0 +1,33 @@
+import { Request, Response } from "hyper-express";
+export interface TransformContext<T = any, S = any> {
+    data: T;
+    schema: S;
+    options: any;
+    req: Request;
+    res: Response;
+    from: string;
+}
+export type TransformHandler<T = any, S = any> = (ctx: TransformContext<T, S>) => any | Promise<any>;
+export interface ITransformer<T = any, S = any> {
+    transform: TransformHandler<T, S>;
+    getOpenApiSchema?: (schema: S) => any;
+}
+export type TransformerInput = TransformHandler | ITransformer;
+declare class TransformRegistry {
+    private transformers;
+    /**
+     * Register a transformer (function or object with transform method).
+     */
+    register(input: TransformerInput): void;
+    /**
+     * Iterates through registered transformers to process the data.
+     * Returns the transformed data or the original data if no transformer matched.
+     */
+    resolve(ctx: TransformContext): Promise<any>;
+    /**
+     * Queries transformers to get an OpenAPI schema representation.
+     */
+    getOpenApiSchema(schema: any): any | undefined;
+}
+export declare const transformRegistry: TransformRegistry;
+export {};

package/dist/__internals/transform/transform.registry.js

@@ -0,0 +1,59 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformRegistry = void 0;
+class TransformRegistry {
+    constructor() {
+        this.transformers = [];
+    }
+    /**
+     * Register a transformer (function or object with transform method).
+     */
+    register(input) {
+        if (typeof input === 'function') {
+            this.transformers.push({ transform: input });
+        }
+        else {
+            this.transformers.push(input);
+        }
+    }
+    /**
+     * Iterates through registered transformers to process the data.
+     * Returns the transformed data or the original data if no transformer matched.
+     */
+    resolve(ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let currentData = ctx.data;
+            for (const transformer of this.transformers) {
+                const result = yield transformer.transform(Object.assign(Object.assign({}, ctx), { data: currentData }));
+                // If transformer returns non-undefined, we assume it's the new data (or unchanged but recognized)
+                if (result !== undefined) {
+                    currentData = result;
+                }
+            }
+            return currentData;
+        });
+    }
+    /**
+     * Queries transformers to get an OpenAPI schema representation.
+     */
+    getOpenApiSchema(schema) {
+        for (const transformer of this.transformers) {
+            if (transformer.getOpenApiSchema) {
+                const result = transformer.getOpenApiSchema(schema);
+                if (result !== undefined)
+                    return result;
+            }
+        }
+        return undefined;
+    }
+}
+exports.transformRegistry = new TransformRegistry();

package/dist/__internals/utils/function.util.d.ts

@@ -1,4 +1 @@
-/**
- * Extracts argument names from a function.
- */
-export declare const extreactArgsNames: (fn: (...args: any[]) => any) => string[] | null;
+export declare const extractArgsNames: (fn: (...args: any[]) => any, replacer?: string) => string[] | null;

package/dist/__internals/utils/function.util.js

@@ -1,20 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extreactArgsNames = void 0;
-/**
- * Extracts argument names from a function.
- */
-const extreactArgsNames = (fn) => {
+exports.extractArgsNames = void 0;
+const extractArgsNames = (fn, replacer = "param") => {
     try {
+        // Convertimos la función en un string
         const str = fn.toString();
-        const args = str
+        // Usamos una expresión regular para capturar los nombres de los parámetros
+        const argNames = [];
+        const regex = /(\w+|\{[^}]+\}|\[[^\]]+\])/g;
+        const matches = str
             .slice(str.indexOf("(") + 1, str.indexOf(")"))
-            .split(",")
-            .map((arg) => arg.trim());
-        return args;
+            .match(regex);
+        // Si se encuentran coincidencias, las filtramos y las limpiamos
+        if (matches) {
+            matches.forEach((arg, index) => {
+                // Si el argumento es desestructurado, asignamos un nombre genérico
+                if (arg.includes("{") || arg.includes("[")) {
+                    argNames.push(`${replacer}${index}`);
+                }
+                else {
+                    argNames.push(arg.trim());
+                }
+            });
+        }
+        return argNames.length > 0 ? argNames : null;
     }
     catch (error) {
         return null;
     }
 };
-exports.extreactArgsNames = extreactArgsNames;
+exports.extractArgsNames = extractArgsNames;

package/dist/common/bootstrap.js

@@ -12,6 +12,7 @@ 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) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
@@ -20,6 +21,9 @@ function createApplication(app) {
             yield instance.prepare();
         }
         (_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);
+        });
         return instance;
     });
 }

package/dist/common/helpers/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./role";
 export * from "./scopes";
+export * from "./state";

package/dist/common/helpers/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./role"), exports);
 __exportStar(require("./scopes"), exports);
+__exportStar(require("./state"), exports);

package/dist/common/helpers/scopes.d.ts

@@ -16,8 +16,8 @@ export declare const getScopes: (request: Request) => string[] | undefined;
 /**
  * Check if request has required scopes
  *
- * @param request
- * @param scopes
- * @returns
+ * @param request - The incoming request
+ * @param scopes - Required scopes to check
+ * @returns `true` if the request has all required scopes, otherwise `false`
  */
 export declare const hasScopes: (request: Request, scopes: HyperScopeOptions) => boolean;

package/dist/common/helpers/scopes.js

@@ -33,15 +33,14 @@ exports.getScopes = getScopes;
 /**
  * Check if request has required scopes
  *
- * @param request
- * @param scopes
- * @returns
+ * @param request - The incoming request
+ * @param scopes - Required scopes to check
+ * @returns `true` if the request has all required scopes, otherwise `false`
  */
 const hasScopes = (request, scopes) => {
-    const requestScopes = (0, exports.getScopes)(request);
-    if (!requestScopes) {
-        return false;
-    }
-    return (0, object_util_1.$array)(scopes).every((scope) => requestScopes.includes(scope));
+    const requestScopes = new Set((0, exports.getScopes)(request) || []);
+    if (requestScopes.has("*"))
+        return true;
+    return (0, object_util_1.$array)(scopes).every(scope => requestScopes.has(scope));
 };
 exports.hasScopes = hasScopes;

package/dist/common/helpers/state.d.ts

@@ -0,0 +1,17 @@
+import type { Request } from "hyper-express";
+/**
+ * Save a custom value against the request directly via an internal Map
+ *
+ * @param {Request} request
+ * @param {string} key
+ * @param {any} value
+ */
+export declare const setValue: (request: Request, key: string, value: any) => void;
+/**
+ * Get a custom value from the request object directly via an internal Map
+ *
+ * @param {Request} request
+ * @param {string} key
+ * @param {any} defaultValue
+ */
+export declare const getValue: <T>(request: Request, key: string, defaultValue?: T) => T | any;

package/dist/common/helpers/state.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValue = exports.setValue = void 0;
+const STATE_SYMBOL = Symbol("HYPER_DECOR_REQUEST_STATE");
+/**
+ * Get or create the internal state map for the request
+ * @param request
+ * @returns
+ */
+function getStore(request) {
+    if (!request[STATE_SYMBOL]) {
+        request[STATE_SYMBOL] = new Map();
+    }
+    return request[STATE_SYMBOL];
+}
+/**
+ * Save a custom value against the request directly via an internal Map
+ *
+ * @param {Request} request
+ * @param {string} key
+ * @param {any} value
+ */
+const setValue = (request, key, value) => {
+    const store = getStore(request);
+    if (value === undefined) {
+        store.delete(key);
+        return;
+    }
+    store.set(key, value);
+};
+exports.setValue = setValue;
+/**
+ * Get a custom value from the request object directly via an internal Map
+ *
+ * @param {Request} request
+ * @param {string} key
+ * @param {any} defaultValue
+ */
+const getValue = (request, key, defaultValue) => {
+    const store = getStore(request);
+    const value = store.get(key);
+    return value !== undefined ? value : defaultValue;
+};
+exports.getValue = getValue;

package/dist/common/message-bus.d.ts

@@ -0,0 +1,11 @@
+import { IMessageTransport } from "./transport";
+export declare class MessageBus {
+    private transports;
+    registerTransport(transport: IMessageTransport): void;
+    emit(topic: string, data: any): Promise<void>;
+    listen(topic: string, handler: (data: any) => Promise<void> | void): Promise<void>;
+    /**
+     * Static helper to emit messages without resolving the bus manually.
+     */
+    static emit(topic: string, data: any): Promise<void>;
+}

package/dist/common/message-bus.js

@@ -0,0 +1,51 @@
+"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());
+    });
+};
+var MessageBus_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageBus = void 0;
+const tsyringe_1 = require("tsyringe");
+let MessageBus = MessageBus_1 = class MessageBus {
+    constructor() {
+        this.transports = [];
+    }
+    registerTransport(transport) {
+        this.transports.push(transport);
+    }
+    emit(topic, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(this.transports.map((t) => t.emit(topic, data)));
+        });
+    }
+    listen(topic, handler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(this.transports.map((t) => t.listen(topic, handler)));
+        });
+    }
+    /**
+     * Static helper to emit messages without resolving the bus manually.
+     */
+    static emit(topic, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bus = tsyringe_1.container.resolve(MessageBus_1);
+            yield bus.emit(topic, data);
+        });
+    }
+};
+exports.MessageBus = MessageBus;
+exports.MessageBus = MessageBus = MessageBus_1 = __decorate([
+    (0, tsyringe_1.singleton)()
+], MessageBus);

package/dist/common/transport.d.ts

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

package/dist/common/transport.js

@@ -0,0 +1,46 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalTransport = void 0;
+const eventemitter3_1 = require("eventemitter3");
+class InternalTransport {
+    constructor() {
+        this.emitter = new eventemitter3_1.EventEmitter();
+    }
+    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);
+                    }
+                });
+            }
+            else {
+                this.emitter.on(topic, handler);
+            }
+        });
+    }
+    emit(topic, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.emitter.emit(topic, data);
+            this.emitter.emit("message", topic, data); // For wildcard listeners
+        });
+    }
+}
+exports.InternalTransport = InternalTransport;

package/dist/decorators/File.d.ts

@@ -1,4 +1,4 @@
-import { Request } from "hyper-express";
+import { Request } from "hyper-express/types";
 /**
  * File upload restrictions
  *

package/dist/decorators/Http.d.ts

@@ -5,28 +5,35 @@ import { ParameterResolver } from "./types";
  * @param key
  * @returns
  */
-export declare const Query: (key?: string, transfrom?: (data: any) => any) => ParameterDecorator;
 /**
- * Get the body of the request
+ * Get the value of a key from the request object or transform the entire query.
  *
- * @param resolver
- * @returns
+ * @example
+ * \@Query('id')
+ * \@Query('id', IntSchema)
+ * \@Query(UserQueryDto)
  */
-export declare const Body: <T, R>(resolver?: (data: T) => R) => ParameterDecorator;
+export declare function Query(keyOrSchema?: string | any, schemaOrTransform?: any): any;
 /**
- * Get the params from the request
+ * Get the body of the request or transform it via a schema.
  *
- * @param k
- * @returns
+ * @example
+ * \@Body()
+ * \@Body(CreateUserDto)
  */
-export declare const Param: (k?: string, validator?: (data: any) => any) => ParameterDecorator;
+export declare function Body(schemaOrResolver?: any): any;
 /**
- * get the headers from the request
+ * Get the params from the request or transform via schema.
  *
- * @param key
- * @returns
+ * @example
+ * \@Param('id')
+ * \@Param('id', IntSchema)
+ */
+export declare function Param(keyOrSchema: string | any, schemaOrValidator?: any): any;
+/**
+ * Get the headers from the request.
  */
-export declare const Headers: <T extends string>(key?: T) => ParameterDecorator;
+export declare function Headers(keyOrSchema?: string | any, schema?: any): any;
 export declare const Req: () => ParameterDecorator;
 export declare const Res: () => ParameterDecorator;
 /**

package/dist/decorators/Http.js

@@ -12,7 +12,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCustomRequestDecorator = exports.Res = exports.Req = exports.Headers = exports.Param = exports.Body = exports.Query = void 0;
+exports.createCustomRequestDecorator = exports.Res = exports.Req = void 0;
+exports.Query = Query;
+exports.Body = Body;
+exports.Param = Param;
+exports.Headers = Headers;
 const request_creator_1 = __importDefault(require("../__internals/creators/request.creator"));
 const object_util_1 = require("../__internals/utils/object.util");
 /**
@@ -21,45 +25,87 @@ const object_util_1 = require("../__internals/utils/object.util");
  * @param key
  * @returns
  */
-const Query = (key, transfrom) => (0, request_creator_1.default)("query", "Query", (request) => {
-    const value = (0, object_util_1.$get)(request.query, key, request.query);
-    if (!transfrom)
-        return value;
-    return value;
-});
-exports.Query = Query;
 /**
- * Get the body of the request
+ * Get the value of a key from the request object or transform the entire query.
  *
- * @param resolver
- * @returns
+ * @example
+ * \@Query('id')
+ * \@Query('id', IntSchema)
+ * \@Query(UserQueryDto)
  */
-const Body = (resolver) => (0, request_creator_1.default)("req", "BODY", (request) => __awaiter(void 0, void 0, void 0, function* () {
-    const value = yield request.json();
-    return resolver ? resolver(value) : value;
-}));
-exports.Body = Body;
+function Query(keyOrSchema, schemaOrTransform) {
+    // Case: @Query(UserQueryDto)
+    if (typeof keyOrSchema === 'function' && !schemaOrTransform) {
+        return (0, request_creator_1.default)("query", "Query", (request) => request.query, keyOrSchema, true);
+    }
+    // Case: @Query('id', IntSchema) or @Query('id', data => ...)
+    const key = keyOrSchema;
+    const resolver = (request) => (0, object_util_1.$get)(request.query, key, request.query);
+    if (typeof schemaOrTransform === 'function' && schemaOrTransform.prototype === undefined) {
+        // It's a legacy transform function: data => ...
+        return (0, request_creator_1.default)("query", "Query", (request) => {
+            const value = resolver(request);
+            return schemaOrTransform(value);
+        });
+    }
+    // It's either a schema/DTO class or just a key
+    return (0, request_creator_1.default)("query", "Query", resolver, schemaOrTransform, false);
+}
 /**
- * Get the params from the request
+ * Get the body of the request or transform it via a schema.
  *
- * @param k
- * @returns
+ * @example
+ * \@Body()
+ * \@Body(CreateUserDto)
  */
-const Param = (k, validator) => (0, request_creator_1.default)("params", "Param", (req) => {
-    const value = (0, object_util_1.$get)(req.params, k, req.params);
-    if (typeof validator === "function")
-        return validator(value);
-    return value;
-});
-exports.Param = Param;
+function Body(schemaOrResolver) {
+    const resolver = (request) => __awaiter(this, void 0, void 0, function* () {
+        return request.body !== undefined ? request.body : yield request.json();
+    });
+    if (typeof schemaOrResolver === 'function' && schemaOrResolver.prototype !== undefined) {
+        // Case: @Body(CreateUserDto)
+        return (0, request_creator_1.default)("req", "BODY", resolver, schemaOrResolver, true);
+    }
+    // Case: @Body(data => ...) (Legacy) or @Body()
+    return (0, request_creator_1.default)("req", "BODY", (request) => __awaiter(this, void 0, void 0, function* () {
+        const value = yield resolver(request);
+        return typeof schemaOrResolver === 'function' ? schemaOrResolver(value) : value;
+    }));
+}
 /**
- * get the headers from the request
+ * Get the params from the request or transform via schema.
  *
- * @param key
- * @returns
+ * @example
+ * \@Param('id')
+ * \@Param('id', IntSchema)
  */
-const Headers = (key) => (0, request_creator_1.default)("headers", "Headers", (req) => (0, object_util_1.$get)(req.headers, key, req.headers));
-exports.Headers = Headers;
+function Param(keyOrSchema, schemaOrValidator) {
+    // Case: @Param(ParamsDto)
+    if (typeof keyOrSchema === 'function' && !schemaOrValidator) {
+        return (0, request_creator_1.default)("params", "Param", (req) => req.params, keyOrSchema, true);
+    }
+    const key = keyOrSchema;
+    const resolver = (req) => (0, object_util_1.$get)(req.params, key, req.params);
+    if (typeof schemaOrValidator === 'function' && schemaOrValidator.prototype === undefined) {
+        // Legacy validator function
+        return (0, request_creator_1.default)("params", "Param", (req) => {
+            const value = resolver(req);
+            return schemaOrValidator(value);
+        });
+    }
+    return (0, request_creator_1.default)("params", "Param", resolver, schemaOrValidator, false);
+}
+/**
+ * Get the headers from the request.
+ */
+function Headers(keyOrSchema, schema) {
+    if (typeof keyOrSchema === 'function' && !schema) {
+        return (0, request_creator_1.default)("headers", "Headers", (req) => req.headers, keyOrSchema, true);
+    }
+    const key = keyOrSchema;
+    const resolver = (req) => (0, object_util_1.$get)(req.headers, key, req.headers);
+    return (0, request_creator_1.default)("headers", "Headers", resolver, schema, false);
+}
 const Req = () => (0, request_creator_1.default)("req", "Req", (req) => req);
 exports.Req = Req;
 const Res = () => (0, request_creator_1.default)("res", "Res", (req, res) => res);

package/dist/decorators/HyperApp.d.ts

@@ -1,7 +1,3 @@
 import "reflect-metadata";
 import { HyperAppDecorator } from "./types";
-/**
- * Decorator to define the main application class with assigned modules.
- * @param modules - List of modules to be used in the application.
- */
 export declare const HyperApp: HyperAppDecorator;