@zenofolio/hyper-decor 0.0.3

package/.mocharc.js

@@ -0,0 +1,5 @@
+module.exports = {
+    "extension": ["ts"],
+    "spec": "**/*.spec.ts",
+    "require": "ts-node/register"
+};

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 @zenofolio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,191 @@
+# Hyper Express Decorators  
+A simple decorators library for Hyper Express  
+
+### Why use this?  
+This is a personal library designed to make it easier for me to create fast APIs. Maybe it can be helpful for someone else too.  
+
+## Inspiration
+
+ - [NestJS](https://github.com/nestjs/nest)
+ - [HyperExpress](https://github.com/kartikk221/hyper-express)
+
+
+## Decorators  
+
+### Core  
+- `@HyperApp` – Defines the application module.  
+- `@HyperModule` – Creates a module with controllers.  
+- `@HyperController` – Defines a controller within a module.  
+
+### Request Decorators (`@Req`)  
+- `@Body(validator?)` – Retrieves and optionally validates the request body.  
+- `@Query(name?: string)` – Extracts query parameters from the request.  
+- `@Param(name?: string)` – Extracts route parameters from the request.  
+
+### Response Decorators  
+- `@Res` – Handles the response object.  
+
+### Middleware & Access Control  
+- `@Middleware` – Attaches middleware to a route or controller.  
+- `@Role(["ADMIN", "SUPERVISOR"])` – Ensures the request is valid for users with any of the specified roles.  
+- `@Scope` – Defines permissions for specific actions.  
+
+### Route Methods (`@Routes`)  
+- `@Get` – Handles GET requests.  
+- `@Post` – Handles POST requests.  
+- `@Put` – Handles PUT requests.  
+- `@Delete` – Handles DELETE requests.  
+- `@Patch` – Handles PATCH requests.  
+- `@Options` – Handles OPTIONS requests.  
+- `@Head` – Handles HEAD requests.  
+- `@Trace` – Handles TRACE requests.  
+- `@Any` – Handles any type of HTTP request.  
+- `@All` – Handles all HTTP requests.  
+- `@Connect` – Handles CONNECT requests.  
+- `@WS` – Handles WebSocket requests.  
+- `@Upgrade` – Handles HTTP upgrade requests.  
+
+### Custom Parameter Decorators  
+Use `createCustomRequestDecorator` if you want to create custom parameter decorators for requests.
+
+#### Example: Zod Schema
+
+```typescript
+const Parser = <T extends any>(schema: ZodSchema<T> | ZodEffects<any>) =>
+  createCustomRequestDecorator(
+    'Parser',
+    async (request) => schema.parse(await request.json())
+  );
+
+// Use the decorator
+
+const userScheme = z.object({
+  name: z.string(),
+  email: z.string().email(),
+});
+
+type UserScheme = z.infer<typeof userScheme>;
+
+@HyperController()
+class ParserController {
+  @Post()
+  async create(
+    @Parser(userScheme) user: UserScheme,
+    @Res response: Response
+  ) {
+    response.json(user);
+  }
+}
+```
+
+## Add Role | Scope to Request
+
+This package extends the `hyper-express/Request` class by adding methods that help manage roles and scopes for requests.
+
+### Summary of Available Methods
+- `req.setRole(role)` – Assigns a role to the request.
+- `req.hasRole(role)` – Checks if the request has the specified role.
+- `req.setScopes(scopes)` – Assigns scopes to the request.
+- `req.hasScopes(scopes)` – Checks if the request has the specified scopes.
+- `req.setRoleScopes(role, scopes)` – Sets both the role and the scopes in one method.
+
+
+### examples
+
+```typescript
+
+@Middleware((req, res, next) => {
+    
+    // Assigning a role to the request
+    req.setRole("ADMIN");
+
+    // Assigning scopes to the request
+    req.setScopes(["read", "write"]);
+
+    // set role and scopes
+    // req.setRoleScopes("ADMIN", ["read", "write"]);
+
+
+    // Check if the request has the "ADMIN" role
+    // if (req.hasRole("ADMIN")) {
+    //     res.send("Role: ADMIN is assigned");
+    // }
+
+    // Check if the request has the "write" scope
+    // if (req.hasScopes(["write"])) {
+    //     res.send("Scope: write is granted");
+    // }
+
+    next();
+})
+@HyperModule({
+    path: 'users'
+})
+class UserModule {}
+
+```
+
+## Usage/Decorators examples
+
+`@HyperController` - Simple versioned controller
+```typescript
+@HyperController("v1")
+class TestController extends CRUD<string> {
+
+  @Get("/list")
+  async index(@Query() query: any, @Res() res: Response) {
+    res.send("hello");
+  }
+
+}
+```
+
+`@HyperModule` - define module with controllers 
+```typescript
+@HyperModule({
+    path: "users",
+    controllers: [HyperController]
+})
+class UserModule {}
+```
+
+
+
+`@HyperApp` - define application
+```typescript
+@HyperApp({
+  name: "Hyper Express Decorators",
+  version: "1.0.0",
+  description: "Decorators to make development easier",
+  modules: [UserV1Module],
+  prefix: "/api",
+})
+export class Application implements IHyperApplication {
+  onPrepare() {
+    console.log("This method will be called after the app is prepared");
+  }
+}
+```
+
+## Run Application
+```typescript
+const app = await createApplication(Application)
+await app.listen(3000);
+
+```
+
+As a result, we get:
+
+- `/api/users/v1/list`
+
+
+# Examples
+
+ - [Add Roles and scopes](./examples/add-roles-and-scopes.ts)
+ - [Middleware](./examples/middleware.ts)
+ - [File](./examples//upload-file.ts)
+
+
+
+# All for now
+More documentation will be added here late.

package/dist/__internals/constants.d.ts

@@ -0,0 +1,61 @@
+export declare const KEY_TYPE_APP = "hyper:type:app";
+export declare const KEY_TYPE_CONTROLLER = "hyper:type:controller";
+export declare const KEY_TYPE_MODULE = "hyper:type:module";
+export declare const KEY_TYPE_ROUTE = "hyper:type:route";
+export declare const KEY_TYPE_SERVICE = "hyper:type:service";
+export type KeyTypes = typeof KEY_TYPE_APP | typeof KEY_TYPE_CONTROLLER | typeof KEY_TYPE_MODULE | typeof KEY_TYPE_SERVICE | typeof KEY_TYPE_ROUTE;
+export declare const KEY_PARAMS_APP = "hyper:type:app";
+export declare const KEY_PARAMS_CONTROLLER = "hyper:type:controller";
+export declare const KEY_PARAMS_MODULE = "hyper:type:module";
+export declare const KEY_PARAMS_ROUTE = "hyper:type:route";
+export declare const KEY_PARAMS_PARAM = "hyper:type:param";
+export declare const KEY_PARAMS_MIDDLEWARES = "hyper:type:middlewares";
+export declare const KEY_PARAMS_SCOPE = "hyper:type:scope";
+export declare const KEY_PARAMS_ROLE = "hyper:type:role";
+export declare const KEY_PARAMS_PASS = "hyper:type:pass";
+export type KeyParams = typeof KEY_PARAMS_APP | typeof KEY_PARAMS_CONTROLLER | typeof KEY_PARAMS_MODULE | typeof KEY_PARAMS_ROUTE | typeof KEY_PARAMS_PARAM | typeof KEY_PARAMS_MIDDLEWARES | typeof KEY_PARAMS_SCOPE | typeof KEY_PARAMS_ROLE | typeof KEY_PARAMS_PASS;
+export declare const KEY_STATE_UPDATED = "hyper:state:updated";
+export declare const KEY_STATE_CREATED = "hyper:state:created";
+export declare const KEY_STATE_PREPARED = "hyper:state:prepared";
+export declare const KEY_STATE_BY_PASS = "hyper:state:bypass";
+export type KeyState = typeof KEY_STATE_UPDATED | typeof KEY_STATE_CREATED | typeof KEY_STATE_PREPARED;
+export declare const DESIGN_PARAMTYPES = "design:paramtypes";
+export declare const DESIGN_RETURNTYPE = "design:returntype";
+export declare const DESIGN_TYPE = "design:type";
+export type DesignKeys = typeof DESIGN_PARAMTYPES | typeof DESIGN_RETURNTYPE | typeof DESIGN_TYPE;
+export declare const METADATA_HYPER_TYPE: {
+    APP: string;
+    CONTROLLER: string;
+    MODULE: string;
+    ROUTE: string;
+    PARAM: string;
+};
+export declare const METADATA_KEYS: {
+    APP_INFO: string;
+    MODULES: string;
+    PREFIX: string;
+    CONTROLLERS: string;
+    ROUTES: string;
+    ROLES: string;
+    SCOPES: string;
+    SCOPED: string;
+    MIDDLEWARES: string;
+};
+export declare const METADATA_STORE_KEYS: {
+    PARAMS: string;
+};
+export declare const METADATA_METHOD_KEYS: {
+    ARGUMENTS: string;
+    ARGUMENTS_NAMES: string;
+    ARGUMENTS_TYPE: string;
+};
+export declare const METADATA_PARAMS_KEYS: {
+    DESIGN_PARAM_TYPES: string;
+    DESIGN_TYPE: string;
+    DESIGN_RETURN_TYPE: string;
+};
+export declare const METADATA_STATE_KEYS: {
+    UPDATED: string;
+    CREATED: string;
+    PREPARED: string;
+};

package/dist/__internals/constants.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METADATA_STATE_KEYS = exports.METADATA_PARAMS_KEYS = exports.METADATA_METHOD_KEYS = exports.METADATA_STORE_KEYS = exports.METADATA_KEYS = exports.METADATA_HYPER_TYPE = exports.DESIGN_TYPE = exports.DESIGN_RETURNTYPE = exports.DESIGN_PARAMTYPES = exports.KEY_STATE_BY_PASS = exports.KEY_STATE_PREPARED = exports.KEY_STATE_CREATED = exports.KEY_STATE_UPDATED = exports.KEY_PARAMS_PASS = exports.KEY_PARAMS_ROLE = exports.KEY_PARAMS_SCOPE = exports.KEY_PARAMS_MIDDLEWARES = exports.KEY_PARAMS_PARAM = exports.KEY_PARAMS_ROUTE = exports.KEY_PARAMS_MODULE = exports.KEY_PARAMS_CONTROLLER = exports.KEY_PARAMS_APP = exports.KEY_TYPE_SERVICE = exports.KEY_TYPE_ROUTE = exports.KEY_TYPE_MODULE = exports.KEY_TYPE_CONTROLLER = exports.KEY_TYPE_APP = void 0;
+//////////////////////////////
+/// Types constants
+//////////////////////////////
+exports.KEY_TYPE_APP = "hyper:type:app";
+exports.KEY_TYPE_CONTROLLER = "hyper:type:controller";
+exports.KEY_TYPE_MODULE = "hyper:type:module";
+exports.KEY_TYPE_ROUTE = "hyper:type:route";
+exports.KEY_TYPE_SERVICE = "hyper:type:service";
+//////////////////////////////
+/// Params constants
+//////////////////////////////
+exports.KEY_PARAMS_APP = "hyper:type:app";
+exports.KEY_PARAMS_CONTROLLER = "hyper:type:controller";
+exports.KEY_PARAMS_MODULE = "hyper:type:module";
+exports.KEY_PARAMS_ROUTE = "hyper:type:route";
+exports.KEY_PARAMS_PARAM = "hyper:type:param";
+exports.KEY_PARAMS_MIDDLEWARES = "hyper:type:middlewares";
+exports.KEY_PARAMS_SCOPE = "hyper:type:scope";
+exports.KEY_PARAMS_ROLE = "hyper:type:role";
+exports.KEY_PARAMS_PASS = "hyper:type:pass";
+//////////////////////////////
+/// State constants
+//////////////////////////////
+exports.KEY_STATE_UPDATED = "hyper:state:updated";
+exports.KEY_STATE_CREATED = "hyper:state:created";
+exports.KEY_STATE_PREPARED = "hyper:state:prepared";
+exports.KEY_STATE_BY_PASS = "hyper:state:bypass";
+//////////////////////////////
+/// Metadata constants
+//////////////////////////////
+exports.DESIGN_PARAMTYPES = "design:paramtypes";
+exports.DESIGN_RETURNTYPE = "design:returntype";
+exports.DESIGN_TYPE = "design:type";
+exports.METADATA_HYPER_TYPE = {
+    APP: "hyper:app",
+    CONTROLLER: "hyper:controller",
+    MODULE: "hyper:module",
+    ROUTE: "hyper:route",
+    PARAM: "hyper:param",
+};
+exports.METADATA_KEYS = {
+    APP_INFO: "hyper:app:info",
+    MODULES: "hyper:modules",
+    PREFIX: "hyper:prefix",
+    CONTROLLERS: "hyper:controllers",
+    ROUTES: "hyper:routes",
+    ROLES: "hyper:roles",
+    SCOPES: "hyper:scopes",
+    SCOPED: "hyper:scoped",
+    MIDDLEWARES: "hyper:middleware",
+};
+exports.METADATA_STORE_KEYS = {
+    PARAMS: "hyper:store:params",
+};
+exports.METADATA_METHOD_KEYS = {
+    ARGUMENTS: "hyper:arguments",
+    ARGUMENTS_NAMES: "hyper:arguments:names",
+    ARGUMENTS_TYPE: "hyper:arguments:type",
+};
+exports.METADATA_PARAMS_KEYS = {
+    DESIGN_PARAM_TYPES: "design:paramtypes",
+    DESIGN_TYPE: "design:type",
+    DESIGN_RETURN_TYPE: "design:type",
+};
+exports.METADATA_STATE_KEYS = {
+    UPDATED: "hyper:updated",
+    CREATED: "hyper:created",
+    PREPARED: "hyper:prepared",
+};

package/dist/__internals/creators/request.creator.d.ts

@@ -0,0 +1,12 @@
+import "reflect-metadata";
+import { Request } from "hyper-express";
+import { ByPassKeys } from "../stores/params.store";
+import { ParameterResolver } from "../../decorators";
+/**
+ * Creates a parameter decorator for handling request data.
+ *
+ * @param {keyof Request | ByPassKeys} key - The key to extract from the request.
+ * @param {IParamsResolver} resolver - Resolver function to handle the parameter.
+ * @returns {ParameterDecorator} - The parameter decorator function.
+ */
+export default function createParamDecorator(key: keyof Request | ByPassKeys, decoratorName: string, resolver: ParameterResolver): ParameterDecorator;

package/dist/__internals/creators/request.creator.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createParamDecorator;
+require("reflect-metadata");
+const function_util_1 = require("../utils/function.util");
+const constants_1 = require("../constants");
+const decorator_base_1 = require("../decorator-base");
+const who_helper_1 = __importDefault(require("../helpers/who.helper"));
+const WrongPlaceException_1 = __importDefault(require("../../exeptions/WrongPlaceException"));
+/**
+ * Creates a parameter decorator for handling request data.
+ *
+ * @param {keyof Request | ByPassKeys} key - The key to extract from the request.
+ * @param {IParamsResolver} resolver - Resolver function to handle the parameter.
+ * @returns {ParameterDecorator} - The parameter decorator function.
+ */
+function createParamDecorator(key, decoratorName, resolver) {
+    const _key = key;
+    return (0, decorator_base_1.DecoratorHelper)({
+        type: constants_1.KEY_TYPE_CONTROLLER,
+        key: constants_1.KEY_PARAMS_PARAM,
+        options: (options, Target, propertyKey, parameterIndex) => {
+            const { isProperty } = (0, who_helper_1.default)(Target, propertyKey, parameterIndex);
+            if (!isProperty)
+                throw new WrongPlaceException_1.default(decoratorName, "parameter", `${Target.constructor.name}.${propertyKey}`, Target);
+            const saved = options !== null && options !== void 0 ? options : { params: {} };
+            const names = (0, function_util_1.extreactArgsNames)(Target[propertyKey]);
+            const types = Reflect.getMetadata(constants_1.DESIGN_PARAMTYPES, Target, propertyKey);
+            const name = names === null || names === void 0 ? void 0 : names[parameterIndex];
+            const type = types === null || types === void 0 ? void 0 : types[parameterIndex];
+            if (name && saved) {
+                if (!saved.params[propertyKey]) {
+                    saved.params[propertyKey] = [];
+                }
+                saved.params[propertyKey].push({
+                    name,
+                    type,
+                    index: parameterIndex,
+                    key: _key,
+                    method: propertyKey.toString(),
+                    resolver,
+                });
+                // sort by index
+                saved.params[propertyKey].sort((a, b) => a.index - b.index);
+                Reflect.defineMetadata(constants_1.KEY_PARAMS_PARAM, saved, Target[propertyKey]);
+            }
+            return saved;
+        },
+    });
+}

package/dist/__internals/creators/routes.creator.d.ts

@@ -0,0 +1,10 @@
+import { Request, Response } from "hyper-express";
+/**
+ * Helper function to create route decorators for HTTP methods.
+ *
+ * @param {string} method - The HTTP method (e.g., GET, POST).
+ * @param {(req: Request, res: Response) => any} [resolver] - Optional resolver for the route.
+ * @returns {(path?: string) => MethodDecorator} - A method decorator for defining routes.
+ *
+ */
+export default function createRouteDecorator(method: string, resolver?: (req: Request, res: Response) => any): (path?: string) => MethodDecorator & ClassDecorator;

package/dist/__internals/creators/routes.creator.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createRouteDecorator;
+const constants_1 = require("../constants");
+const decorator_base_1 = require("../decorator-base");
+/**
+ * Helper function to create route decorators for HTTP methods.
+ *
+ * @param {string} method - The HTTP method (e.g., GET, POST).
+ * @param {(req: Request, res: Response) => any} [resolver] - Optional resolver for the route.
+ * @returns {(path?: string) => MethodDecorator} - A method decorator for defining routes.
+ *
+ */
+function createRouteDecorator(method, resolver) {
+    return (path = "/") => (0, decorator_base_1.DecoratorHelper)({
+        type: constants_1.KEY_TYPE_CONTROLLER,
+        key: constants_1.KEY_PARAMS_ROUTE,
+        targetResolver: (target) => { var _a; return (_a = target.constructor) !== null && _a !== void 0 ? _a : target; },
+        options: (data, Target, propertyKey, descriptor) => {
+            var _a;
+            const handler = descriptor.value;
+            if (typeof handler !== "function")
+                return data;
+            const saved = (_a = Reflect.getMetadata(constants_1.KEY_PARAMS_ROUTE, Target)) !== null && _a !== void 0 ? _a : {
+                routes: new Set(),
+            };
+            saved.routes.add({
+                className: Target.name,
+                method,
+                path,
+                propertyKey,
+                handler: handler,
+            });
+            return saved;
+        },
+    });
+}

package/dist/__internals/decorator-base.d.ts

@@ -0,0 +1,30 @@
+import "reflect-metadata";
+export type DecoratorBaseTypes = "APP" | "MODULE" | "CONTROLLER" | "ROUTE" | "MIDDLEWARE";
+type DefineResolve<T> = (old: T, target?: any, property?: any, descriptor?: any) => T;
+interface onDefineResolve<T> {
+    (data: {
+        key: string;
+        options: T;
+        target: any;
+        property?: any;
+        descriptor?: any;
+    }, defineData: (options: T) => void): void;
+}
+interface BeseDecoratorOptions<T extends any = any> {
+    type?: DecoratorBaseTypes | string;
+    key: string;
+    options: T | DefineResolve<T>;
+    targetResolver?: (target: any, propertyKey?: any, descriptorOrIndex?: any) => any;
+    onDefineData?: onDefineResolve<T>;
+}
+interface BeseDecorator<T> {
+    (target: T): any;
+    (target: T, propertyKey?: any, descriptor?: any): any;
+}
+type TransformFunction<TOptions, T> = (options: TOptions, target: T, propertyKey?: any, descriptor?: any) => any;
+export declare function DecoratorHelper<T, Target extends any = any>({ key, type, options, targetResolver, onDefineData }: BeseDecoratorOptions<T>, ...transformers: TransformFunction<T, Target>[]): BeseDecorator<Target>;
+export declare const defineDecorData: <T>(key: string, options: T | DefineResolve<T>, target: any, property?: any, descriptor?: any) => void;
+export declare const getDecorData: <T>(key: string, target: any, property?: any) => T;
+export declare const hasDecorData: (key: string, target: any, property?: any) => boolean;
+export declare const extractDecorData: <T>(target: any) => T | undefined;
+export {};

package/dist/__internals/decorator-base.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDecorData = exports.hasDecorData = exports.getDecorData = exports.defineDecorData = void 0;
+exports.DecoratorHelper = DecoratorHelper;
+require("reflect-metadata");
+const tsyringe_1 = require("tsyringe");
+const object_util_1 = require("./utils/object.util");
+function DecoratorHelper({ key, type, options, targetResolver, onDefineData }, ...transformers) {
+    return (target, propertyKey, descriptor) => {
+        const isProperty = !!propertyKey;
+        const isMethod = !!descriptor;
+        let _options = options;
+        const Target = targetResolver
+            ? targetResolver(target, propertyKey, descriptor)
+            : target;
+        if (options instanceof Function) {
+            const data = (0, exports.getDecorData)(key, Target);
+            const optionsResolver = options;
+            const value = optionsResolver(data, Target, propertyKey, descriptor);
+            if (value)
+                _options = Object.assign(Object.assign({}, _options), value);
+        }
+        if (onDefineData) {
+            onDefineData({
+                key,
+                options: Object.assign({ type }, _options),
+                target: Target,
+                property: propertyKey,
+                descriptor,
+            }, (data) => {
+                (0, exports.defineDecorData)(key, Object.assign({ type }, data), Target);
+            });
+        }
+        else {
+            (0, exports.defineDecorData)(key, Object.assign({ type }, _options), Target);
+        }
+        let value = Target;
+        if (transformers.length) {
+            const transforms = transformers.map((fn) => fn.bind(Target, _options));
+            if (isProperty) {
+                (0, exports.defineDecorData)(key, Object.assign({ type }, options), Target, propertyKey);
+                value = Reflect.decorate(transforms, Target, propertyKey);
+            }
+            else if (isMethod) {
+                (0, exports.defineDecorData)(key, Object.assign({ type }, options), Target);
+                value = Reflect.decorate(transforms, Target, propertyKey, descriptor);
+            }
+            else {
+                (0, exports.defineDecorData)(key, Object.assign({ type }, options), Target);
+                value = Reflect.decorate(transforms, Target);
+            }
+        }
+        (0, tsyringe_1.injectable)()((0, object_util_1.$constructor)(target));
+        return value;
+    };
+}
+const defineDecorData = (key, options, target, property, descriptor) => {
+    let value = options;
+    if (typeof options === "function") {
+        const old = (0, exports.getDecorData)(key, target, property);
+        value = Object.assign(Object.assign({}, old), options(old, target, property, descriptor));
+    }
+    if (property) {
+        Reflect.defineMetadata(key, value, target, property);
+    }
+    else {
+        Reflect.defineMetadata(key, value, target);
+    }
+};
+exports.defineDecorData = defineDecorData;
+const getDecorData = (key, target, property) => property
+    ? Reflect.getMetadata(key, target, property)
+    : Reflect.getMetadata(key, target);
+exports.getDecorData = getDecorData;
+const hasDecorData = (key, target, property) => property
+    ? Reflect.hasMetadata(key, target, property)
+    : Reflect.hasMetadata(key, target);
+exports.hasDecorData = hasDecorData;
+const extractDecorData = (target) => {
+    const keys = Reflect.getMetadataKeys(target);
+    return keys.reduce((acc, key) => {
+        acc[key] = Reflect.getMetadata(key, target);
+        return acc;
+    }, {});
+};
+exports.extractDecorData = extractDecorData;

package/dist/__internals/helpers/merge-metadata.d.ts

@@ -0,0 +1,14 @@
+import "reflect-metadata";
+type MetadataKey = string | symbol;
+type MergeOptions = {
+    overwriteArrays?: boolean;
+};
+/**
+ * Performs a deep merge of metadata from source to target using reflect-metadata.
+ * @param target Object where the metadata will be merged.
+ * @param source Object from which the metadata will be copied.
+ * @param keys Metadata keys to merge.
+ * @param options Merge options (e.g., array handling).
+ */
+export declare function mergeMetadata(target: any, source: any, keys: MetadataKey[], options?: MergeOptions): void;
+export {};

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeMetadata = mergeMetadata;
+require("reflect-metadata");
+/**
+ * Performs a deep merge of metadata from source to target using reflect-metadata.
+ * @param target Object where the metadata will be merged.
+ * @param source Object from which the metadata will be copied.
+ * @param keys Metadata keys to merge.
+ * @param options Merge options (e.g., array handling).
+ */
+function mergeMetadata(target, source, keys, options = {}) {
+    for (const key of keys) {
+        const sourceMeta = Reflect.getMetadata(key, source);
+        const targetMeta = Reflect.getMetadata(key, target);
+        if (sourceMeta === undefined)
+            continue;
+        let mergedMeta = sourceMeta;
+        if (typeof sourceMeta === "object" && typeof targetMeta === "object") {
+            mergedMeta = deepMerge(targetMeta, sourceMeta, options);
+        }
+        Reflect.defineMetadata(key, mergedMeta, target);
+    }
+}
+/**
+ * Performs a deep merge of two objects.
+ * @param target Target object.
+ * @param source Source object.
+ * @param options Merge options.
+ * @returns Merged object.
+ */
+function deepMerge(target, source, options) {
+    if (Array.isArray(target) && Array.isArray(source)) {
+        return (options.overwriteArrays ? source : Array.from(new Set([...target, ...source])));
+    }
+    if (typeof target === "object" && target !== null && typeof source === "object" && source !== null) {
+        const merged = Object.assign({}, target);
+        for (const key of Object.keys(source)) {
+            merged[key] = deepMerge(target[key], source[key], options);
+        }
+        return merged;
+    }
+    return source;
+}

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

@@ -0,0 +1,9 @@
+export default function who(target: any, propertyKey?: any, descriptorOrIndex?: any): {
+    isMethod: boolean;
+    isProperty: boolean;
+    isClass: boolean;
+    Target: any;
+    Method: any;
+    key: any;
+    descriptorOrIndex: any;
+};