@zenofolio/hyper-decor 0.0.3

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = who;
+const object_util_1 = require("../utils/object.util");
+function who(target, propertyKey, descriptorOrIndex) {
+    const isMethod = typeof propertyKey === "string";
+    const isProperty = typeof descriptorOrIndex === "number";
+    const Target = (0, object_util_1.$constructor)(target);
+    const Method = isMethod ? Reflect.get(target, propertyKey) : null;
+    return {
+        isMethod,
+        isProperty,
+        isClass: !!target && !isMethod && !isProperty,
+        Target,
+        Method,
+        key: propertyKey,
+        descriptorOrIndex,
+    };
+}

package/dist/__internals/store.d.ts

@@ -0,0 +1,10 @@
+export default class HyperAppStore {
+    private roles;
+    private scopes;
+    private modules;
+    private controllers;
+    private routes;
+    private middlewares;
+    addRole(role: string): void;
+    addModuleRole(module: string, role: string): void;
+}

package/dist/__internals/store.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class HyperAppStore {
+    constructor() {
+        this.roles = new Set();
+        this.scopes = new Set();
+        this.modules = new Map();
+        this.controllers = new Map();
+        this.routes = new Map();
+        this.middlewares = new Map();
+    }
+    addRole(role) {
+        this.roles.add(role);
+    }
+    addModuleRole(module, role) { }
+}
+exports.default = HyperAppStore;

package/dist/__internals/stores/index.d.ts

@@ -0,0 +1,15 @@
+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;

package/dist/__internals/stores/index.js

@@ -0,0 +1,37 @@
+"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;
+        }
+    }
+    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;

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

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+import { MiddlewareHandler } from "hyper-express";
+export declare const middlewareStore: Readonly<{
+    get(target: any): any;
+    has(target: any): boolean;
+    set(target: any, ...middlewares: MiddlewareHandler[]): void;
+}>;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.middlewareStore = void 0;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+const { MIDDLEWARES } = constants_1.METADATA_KEYS;
+exports.middlewareStore = Object.freeze({
+    get(target) {
+        return Reflect.getMetadata(MIDDLEWARES, target);
+    },
+    has(target) {
+        return !!this.get(target);
+    },
+    set(target, ...middlewares) {
+        const list = this.get(target) || [];
+        list.push(...middlewares);
+        Reflect.defineMetadata(MIDDLEWARES, list, target);
+    },
+});

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

@@ -0,0 +1,21 @@
+import { Request, Response } from "hyper-express";
+export type ByPassKeys = "req" | "res";
+export type IParamsResolver = (req: Request, res: Response) => any | Promise<any>;
+export type IStoreParams = {
+    name: string;
+    type: any;
+    index: number;
+    key: string;
+    propertyKey: string;
+    resolver: IParamsResolver;
+};
+export type IStoreParamsMap = Map<string, IStoreParams>;
+export declare const paramsStore: Readonly<{
+    has(target: any, propety: any, key: string): boolean;
+    get(target: any, propety?: any): IStoreParamsMap | undefined;
+    set(target: any, propety: any, value: IStoreParams): void;
+    delete(target: any, propety: any): void;
+    support(target: any, propety: any): boolean;
+    prepareArgs(target: any, propety: any, req: Request, res: Response): Promise<any[]>;
+    intercept(target: any, propety: any, req: Request, res: Response): Promise<void>;
+}>;

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

@@ -0,0 +1,65 @@
+"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.paramsStore = void 0;
+const no_conflict_1 = require("reflect-metadata/no-conflict");
+const constants_1 = require("../constants");
+exports.paramsStore = Object.freeze({
+    has(target, propety, key) {
+        const data = this.get(target, propety);
+        return data ? data.has(key) : false;
+    },
+    get(target, propety) {
+        if (!propety) {
+            return (0, no_conflict_1.getMetadata)(constants_1.KEY_PARAMS_PARAM, target);
+        }
+        return (0, no_conflict_1.getMetadata)(constants_1.KEY_PARAMS_PARAM, target, propety);
+    },
+    set(target, propety, value) {
+        const data = this.get(target, propety) || new Map();
+        data.set(value.key, value);
+        (0, no_conflict_1.defineMetadata)(constants_1.KEY_PARAMS_PARAM, data, target, propety);
+    },
+    delete(target, propety) {
+        (0, no_conflict_1.deleteMetadata)(constants_1.KEY_PARAMS_PARAM, target, propety);
+    },
+    support(target, propety) {
+        const params = (0, no_conflict_1.getMetadata)(constants_1.DESIGN_PARAMTYPES, target, propety) || [];
+        return params.length > 0;
+    },
+    prepareArgs(target, propety, req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = this.get(target, propety);
+            if (!data)
+                return [];
+            const args = [];
+            yield Promise.all(Array.from(data.values()).map((value) => __awaiter(this, void 0, void 0, function* () {
+                const { key, resolver } = value;
+                switch (key) {
+                    case "req":
+                        args[value.index] = req;
+                        break;
+                    case "res":
+                        args[value.index] = res;
+                        break;
+                    default: {
+                        const result = yield resolver(req, res);
+                        args[value.index] = result;
+                    }
+                }
+            })));
+            return args;
+        });
+    },
+    intercept(target, propety, req, res) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    },
+});

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

@@ -0,0 +1,17 @@
+import { IStore } from "./store.interface";
+interface IRoute {
+    className: string;
+    method: string;
+    path: string;
+    handler: (...args: any[]) => any;
+}
+export declare class RouteStore implements IStore<any> {
+    has(target: any, property?: any): boolean;
+    get(target: any, property?: any): Set<IRoute> | undefined;
+    set(target: any, property: any, value: IRoute): void;
+    create(target: any, property?: any, key?: any): Set<IRoute> | null;
+    delete(target: any, value?: IRoute): void;
+    support(target: any, property: any): boolean;
+}
+declare const routeStore: RouteStore;
+export { routeStore };

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeStore = exports.RouteStore = void 0;
+const no_conflict_1 = require("reflect-metadata/no-conflict");
+const constants_1 = require("../constants");
+class RouteStore {
+    has(target, property) {
+        return (0, no_conflict_1.hasMetadata)(constants_1.METADATA_KEYS.ROUTES, target);
+    }
+    get(target, property) {
+        return (0, no_conflict_1.getMetadata)(constants_1.METADATA_KEYS.ROUTES, target);
+    }
+    set(target, property, value) {
+        const routes = this.get(target) || new Set();
+        routes.add(value);
+        (0, no_conflict_1.defineMetadata)(constants_1.METADATA_KEYS.ROUTES, routes, target);
+    }
+    create(target, property, key) {
+        const data = this.has(target, property)
+            ? this.get(target, property)
+            : new Set();
+        (0, no_conflict_1.defineMetadata)(constants_1.METADATA_KEYS.ROUTES, data, target);
+        return data;
+    }
+    delete(target, value) {
+        const routes = this.create(target, value === null || value === void 0 ? void 0 : value.className);
+        if (!routes)
+            return;
+        if (value) {
+            routes.delete(value);
+            (0, no_conflict_1.defineMetadata)(constants_1.METADATA_KEYS.ROUTES, routes, target);
+        }
+        else {
+            (0, no_conflict_1.deleteMetadata)(constants_1.METADATA_KEYS.ROUTES, target);
+        }
+    }
+    support(target, property) {
+        return this.has(target, property);
+    }
+}
+exports.RouteStore = RouteStore;
+const routeStore = new RouteStore();
+exports.routeStore = routeStore;

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

@@ -0,0 +1,8 @@
+export interface IStore<T> {
+    has(target: any, property: any): boolean;
+    get(target: any, property: any): T | undefined;
+    set(target: any, property: any, value: T): void;
+    create(target: any, property: any, extra?: Partial<T>): T | null;
+    delete(target: any, property?: any): void;
+    support(target: any, property: any): boolean;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+import "reflect-metadata";
+export default function methodTransformer(target: any, key: string | symbol, transfrom?: (...args: any[]) => any): void;

package/dist/__internals/transform/method.transform.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = methodTransformer;
+require("reflect-metadata");
+function methodTransformer(target, key, transfrom) {
+    const prototype = target.constructor.prototype;
+    if (!prototype || prototype.__transformed)
+        return;
+    prototype.__transformed = true;
+    const original = Reflect.getOwnMetadata(key, target);
+    if (!(original === null || original === void 0 ? void 0 : original.value))
+        return;
+    console.log(original, "original");
+    original.value = function (...args) {
+        console.log("Before method call", args);
+    };
+    // const descriptor = Object.getOwnPropertyDescriptor(prototype, key);
+    // if(!descriptor) return;
+    // console.log(descriptor, "descriptor");
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/__internals/transform/pass.transfrom.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,7 @@
+import { MiddlewareHandler } from "hyper-express";
+import { RoleType } from "../../decorators";
+export default function roleTransform(list: RoleType[], callback?: (middleware: MiddlewareHandler, roles: {
+    role: string;
+    description: string;
+    message: string | null;
+}[], names: Set<string>) => void): MiddlewareHandler;

package/dist/__internals/transform/role.transform.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = roleTransform;
+const exeptions_1 = require("../../exeptions");
+const helpers_1 = require("../../common/helpers");
+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
+        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));
+        if (role) {
+            return next();
+        }
+        return next(new exeptions_1.NotRoleException(`Only ${Array.from(names).join(", ")} can access this resource`, requestRoles, Array.from(names)));
+    };
+    if (names.size > 0 && callback) {
+        callback(middleware, roles, names);
+    }
+    return middleware;
+}
+/**
+ *
+ * Convert list of roles to a standard format
+ *
+ * @param list
+ * @returns
+ */
+const resolveRoles = (list) => {
+    var _a, _b, _c, _d;
+    const $roles = [];
+    for (const role of list) {
+        if (typeof role === "string") {
+            $roles.push({
+                role: role,
+                description: "",
+                message: null,
+            });
+        }
+        else if (Array.isArray(role)) {
+            for (const s of role) {
+                switch (typeof s) {
+                    case "string":
+                        $roles.push({
+                            role: s,
+                            description: "",
+                            message: null,
+                        });
+                        break;
+                    case "object":
+                        $roles.push({
+                            role: s.role,
+                            description: (_a = s.description) !== null && _a !== void 0 ? _a : "",
+                            message: (_b = s.message) !== null && _b !== void 0 ? _b : null,
+                        });
+                        break;
+                }
+            }
+        }
+        else {
+            if (typeof role === "object") {
+                $roles.push({
+                    role: role.role,
+                    description: (_c = role.description) !== null && _c !== void 0 ? _c : "",
+                    message: (_d = role.message) !== null && _d !== void 0 ? _d : null,
+                });
+            }
+            else {
+                $roles.push({
+                    role: role,
+                    description: "",
+                    message: null,
+                });
+            }
+        }
+    }
+    return {
+        roles: $roles,
+        names: new Set($roles.map((s) => s.role)),
+        isEmtpy: $roles.length === 0,
+    };
+};

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

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

package/dist/__internals/transform/scope.transfrom.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = scopeTransfrom;
+const exeptions_1 = require("../../exeptions");
+const helpers_1 = require("../../common/helpers");
+function scopeTransfrom(listScopes, callback) {
+    const { scopes, scopeNames, isEmtpy } = resolveScopes(listScopes);
+    const middleware = (req, res, next) => {
+        var _a;
+        // if scopes is empty, then we don't need to check for scopes
+        if (isEmtpy)
+            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)));
+        }
+        return next();
+    };
+    if (scopeNames.size > 0 && callback) {
+        callback(middleware, scopes, scopeNames);
+    }
+    return middleware;
+}
+/**
+ *
+ * Convert list of scopes to a standard format
+ *
+ * @param scopes
+ * @returns
+ */
+const resolveScopes = (scopes) => {
+    var _a, _b;
+    const $scopes = {};
+    for (const scope of scopes) {
+        if (typeof scope === "string") {
+            $scopes[scope] = {
+                scope,
+                description: "",
+                message: null,
+            };
+        }
+        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,
+    };
+};

package/dist/__internals/types.d.ts

@@ -0,0 +1,8 @@
+import { RouteMetadata } from "../decorators";
+export interface RouterList {
+    type: string;
+    routes: Set<RouteMetadata>;
+}
+export type HyperApplicationPrivate<T> = T & {
+    prepare(): Promise<void>;
+};

package/dist/__internals/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extreactArgsNames = void 0;
+/**
+ * Extracts argument names from a function.
+ */
+const extreactArgsNames = (fn) => {
+    try {
+        const str = fn.toString();
+        const args = str
+            .slice(str.indexOf("(") + 1, str.indexOf(")"))
+            .split(",")
+            .map((arg) => arg.trim());
+        return args;
+    }
+    catch (error) {
+        return null;
+    }
+};
+exports.extreactArgsNames = extreactArgsNames;

package/dist/__internals/utils/mixin.utils.d.ts

@@ -0,0 +1,11 @@
+import "reflect-metadata";
+type Constructor<T = any> = new (...args: any[]) => T;
+export declare class MixinBuilder<TClass extends Constructor<any>, Type = InstanceType<TClass>> {
+    private __class;
+    constructor(__class: TClass);
+    mix<NClass extends Constructor<any>>(clazz: NClass): MixinBuilder<NClass & TClass>;
+    build(): TClass;
+    construct(...args: any[]): Type;
+    static mix<NClass extends Constructor<any>>(clazz: NClass): MixinBuilder<NClass, InstanceType<NClass>>;
+}
+export {};

package/dist/__internals/utils/mixin.utils.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MixinBuilder = void 0;
+require("reflect-metadata");
+class MixinBuilder {
+    constructor(__class) {
+        this.__class = __class;
+    }
+    mix(clazz) {
+        return new MixinBuilder(Mix(this.__class, clazz));
+    }
+    build() {
+        return this.__class;
+    }
+    construct(...args) {
+        return new this.__class(...args);
+    }
+    ////////////////////////////
+    /// Static methods
+    ////////////////////////////
+    static mix(clazz) {
+        return new MixinBuilder(clazz);
+    }
+}
+exports.MixinBuilder = MixinBuilder;
+const Mix = (a, b) => {
+    return class extends a {
+        constructor(...args) {
+            super(...args);
+            Object.assign(this, new b(...args));
+            console.log(a);
+        }
+    };
+};

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

@@ -0,0 +1,27 @@
+/**
+ * Tipo recursivo para obtener claves anidadas dentro de un objeto, permitiendo solo strings.
+ */
+export type NestedKeyOf<T> = T extends (infer U)[] ? `${number}` | `${number}.${NestedKeyOf<U>}` : T extends object ? {
+    [K in keyof T]: K extends string ? K | `${K}.${NestedKeyOf<T[K]>}` : never;
+}[keyof T] : never;
+export type ObjectValue<T, K extends string> = T extends object ? K extends keyof T ? T[K] : K extends `${infer MainKey}.${infer Rest}` ? MainKey extends keyof T ? ObjectValue<T[MainKey], Rest> : never : never : T;
+/**
+ * Retrieves a value from an object using a path.
+ */
+declare const $get: <T, K extends NestedKeyOf<T>, TDefault extends ObjectValue<T, K>>(data: T, name?: K, def?: TDefault) => TDefault extends undefined ? TDefault | undefined : TDefault;
+/**
+ * Ensures the given value is returned as an array.
+ *
+ * @param {T | T[]} value - The value to ensure as an array.
+ * @returns {T[]} - The value as an array.
+ */
+declare const $array: <T>(value: T | T[]) => T[];
+/**
+ * Extract constructor from value.
+ *
+ * @param value
+ */
+declare const $constructor: (value: any) => any;
+declare const $each: <T>(data: T[] | undefined, callback: (value: T, index: number) => Promise<any>) => Promise<any[]>;
+declare const $except_slash: (message: string, length?: number, middle?: boolean) => string;
+export { $array, $get, $constructor, $each, $except_slash };