@zenofolio/hyper-decor 1.0.4 → 1.0.8

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/{store.interface.js → serivces.store.js}

@@ -1,2 +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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = middlewareTransformer;
+const tsyringe_1 = require("tsyringe");
+function middlewareTransformer(list) {
+    return list
+        .map((middleware, idx) => {
+        if (isClass(middleware)) {
+            const instance = tsyringe_1.container.resolve(middleware);
+            return instance.handle.bind(instance);
+        }
+        if (typeof middleware === "function") {
+            return middleware;
+        }
+        return null;
+    })
+        .filter((middleware) => !!middleware);
+}
+const isClass = (fn) => typeof fn === "function" && `${fn}`.indexOf("class") === 0;

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,18 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = roleTransform;
-const exeptions_1 = require("../../exeptions");
-const helpers_1 = require("../../common/helpers");
+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) => {
-        // if scopes is empty, then we don't need to check for scopes
+        var _a;
         if (isEmtpy)
             return next();
-        // get the user scopes
-        const requestRoles = (0, helpers_1.getRoles)(req);
-        // find the first scope that is not in the userScopes
-        const role = roles.find((scope) => requestRoles === null || requestRoles === void 0 ? void 0 : requestRoles.includes(scope.role));
+        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))
+            return next();
+        const role = roles.some((scope) => requestRoles.includes(scope.role));
         if (role) {
             return next();
         }

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

@@ -1,7 +1,5 @@
-import { MiddlewareHandler } from "hyper-express";
-import { ScopeType } from "../../decorators";
-export default function scopeTransfrom(listScopes: ScopeType[], callback?: (middleware: MiddlewareHandler, scopes: {
-    scope: string;
-    description: string;
-    message: string | null;
-}[], names: Set<string>) => void): MiddlewareHandler;
+import { MiddlewareHandler } from "hyper-express/types";
+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,26 +1,31 @@
 "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");
-function scopeTransfrom(listScopes, callback) {
-    const { scopes, scopeNames, isEmtpy } = resolveScopes(listScopes);
+const constants_1 = require("../../constants");
+function scopeTransfrom(listScopes, ...callback) {
+    const { scopes, scopeNames, isEmpty } = resolveScopes(listScopes);
     const middleware = (req, res, next) => {
         var _a;
-        // if scopes is empty, then we don't need to check for scopes
-        if (isEmtpy)
+        if (isEmpty)
             return next();
-        // get the user scopes
-        const userScopes = (0, helpers_1.getScopes)(req);
-        // find the first scope that is not in the userScopes
-        const error = scopes.find((scope) => !(userScopes === null || userScopes === void 0 ? void 0 : userScopes.includes(scope.scope)));
-        if (error) {
-            return next(new exeptions_1.NotScopeException((_a = error.message) !== null && _a !== void 0 ? _a : `You don't have the required scopes to access this resource`, userScopes, Array.from(scopeNames)));
+        const userScopesRaw = (0, helpers_1.getScopes)(req);
+        if (!userScopesRaw || userScopesRaw.length === 0) {
+            return next(new exeptions_1.NotScopeException(`FORBIDDEN`, [], Array.from(scopeNames)));
+        }
+        if (userScopesRaw.includes(constants_1.FULL_ACCESS))
+            return next();
+        for (const scope of scopes) {
+            if (!userScopesRaw.includes(scope.scope)) {
+                return next(new exeptions_1.NotScopeException((_a = scope.message) !== null && _a !== void 0 ? _a : `FORBIDDEN`, userScopesRaw, Array.from(scopeNames)));
+            }
         }
         return next();
     };
-    if (scopeNames.size > 0 && callback) {
-        callback(middleware, scopes, scopeNames);
+    if (!isEmpty && callback.length > 0) {
+        for (const cb of callback)
+            cb(middleware, scopes, scopeNames);
     }
     return middleware;
 }
@@ -35,38 +40,47 @@ const resolveScopes = (scopes) => {
     var _a, _b;
     const $scopes = {};
     for (const scope of scopes) {
-        if (typeof scope === "string") {
-            $scopes[scope] = {
-                scope,
-                description: "",
-                message: null,
+        const list = parseScope(scope);
+        if (list.length === 0)
+            continue;
+        for (const s of list) {
+            $scopes[s.scope] = {
+                scope: s.scope,
+                description: (_a = s.description) !== null && _a !== void 0 ? _a : "",
+                message: (_b = s.message) !== null && _b !== void 0 ? _b : `You don't have the required scopes to access this resource`,
             };
         }
-        else if (Array.isArray(scope)) {
-            for (const s of scope) {
-                switch (typeof s) {
-                    case "string":
-                        $scopes[s] = {
-                            scope: s,
-                            description: "",
-                            message: null,
-                        };
-                        break;
-                    case "object":
-                        $scopes[s.scope] = {
-                            scope: s.scope,
-                            description: (_a = s.description) !== null && _a !== void 0 ? _a : "",
-                            message: (_b = s.message) !== null && _b !== void 0 ? _b : null,
-                        };
-                        break;
-                }
-            }
-        }
     }
     const values = Object.values($scopes);
     return {
         scopes: values,
         scopeNames: new Set(Object.keys($scopes)),
-        isEmtpy: values.length === 0,
+        isEmpty: values.length === 0,
     };
 };
+/**
+ * Parse the scope to a standard format
+ *
+ * @param scope
+ * @returns
+ */
+const parseScope = (scope) => {
+    switch (typeof scope) {
+        case "string":
+            return [
+                {
+                    scope,
+                    description: "",
+                },
+            ];
+        case "object":
+            if (Array.isArray(scope)) {
+                if (scope.length === 0)
+                    return [];
+                return scope.map((s) => parseScope(s)).flat();
+            }
+            else {
+                return [scope];
+            }
+    }
+};

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/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/__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.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,17 +9,60 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = createApplication;
 exports.createApplication = createApplication;
 const tsyringe_1 = require("tsyringe");
-function createApplication(app) {
+const message_bus_1 = require("./message-bus");
+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);
-        return instance;
+        const logger = metadata.logger || console.log;
+        const logWrapper = (space, msg) => {
+            var _a;
+            if ((_a = metadata.logs) === null || _a === void 0 ? void 0 : _a[space]) {
+                logger(`[${space.toUpperCase()}] ${msg}`);
+            }
+        };
+        const appServer = yield (0, prepare_helper_1.prepareApplication)(metadata, application, logWrapper);
+        const appInstance = tsyringe_1.container.resolve(application);
+        const appProxy = new Proxy(appInstance, {
+            get(target, prop) {
+                if (prop === "useTransform") {
+                    return (transformer) => {
+                        transform_registry_1.transformRegistry.register(transformer);
+                        return appProxy;
+                    };
+                }
+                if (prop === "emit") {
+                    return (topic, data) => __awaiter(this, void 0, void 0, function* () {
+                        const bus = tsyringe_1.container.resolve(message_bus_1.MessageBus);
+                        yield bus.emit(topic, data);
+                    });
+                }
+                // Prioritize application instance methods/props
+                if (prop in target) {
+                    const value = target[prop];
+                    return typeof value === "function" ? value.bind(target) : value;
+                }
+                // Fallback to hyper-express server
+                const serverValue = appServer[prop];
+                return typeof serverValue === "function" ? serverValue.bind(appServer) : serverValue;
+            },
+        });
+        if ("onPrepare" in appInstance && typeof appInstance.onPrepare === "function") {
+            const onPrepare = appInstance.onPrepare.bind(appInstance);
+            yield onPrepare();
+        }
+        return appProxy;
     });
 }

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);