@zenofolio/hyper-decor 1.0.71 → 1.0.72

package/README.md

@@ -1,254 +1,136 @@
-# 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: [TestController]
-})
-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)
-
-## Services & Dependency Injection
-You can use `@HyperService()` with `tsyringe` to inject dependencies into controllers or other services.
-
-```typescript
-import { injectable } from "tsyringe";
-
-@injectable()
-@HyperService()
-class UserService {
-  getUsers() { return ["User1", "User2"]; }
-}
-
-@HyperController("/users")
-class UserController {
-  constructor(private userService: UserService) {}
-
-  @Get("/")
-  getUsers(@Res() res: Response) {
-    res.json(this.userService.getUsers());
-  }
-}
-```
-
-## Agnostic Body Validation & Transformation (`@Transform`)
-You can use `@Transform` to validate and transform incoming requests agnostic of the validation library (like Zod) while seamlessly syncing with OpenAPI definitions.
-
-```typescript
-const ZodTransformer = {
-  transform: ({ data, schema }) => {
-    if (schema && schema._type === "zod") {
-      // Validate and return the parsed data
-      return { ...data, parsed: true };
-    }
-    return data;
-  },
-  getOpenApiSchema: (schema) => {
-    if (schema._type === "zod") {
-       return { type: "object", properties: { /* derived from schema */ } };
-    }
-  }
-};
-
-const app = await createApplication(Application);
-app.useTransform(ZodTransformer); // Register your custom transformer globally
-
-@HyperController("/users")
-class UserController {
-  @Post("/")
-  @Transform({ _type: "zod" /* pass your schema */ })
-  createUser(@Body() data: any, @Res() res: Response) {
-    res.json(data); // `data` is automatically intercepted and transformed!
-  }
-}
-```
-
-## OpenAPI Generation
-Generate a complete OpenAPI specification out-of-the-box leveraging your application tree and decorators footprint.
-
-```typescript
-import { getOpenAPI } from "@zenofolio/hyper-decor/lib/openapi";
-
-const openApiDoc = getOpenAPI(Application);
-console.log(openApiDoc.info.title, openApiDoc.paths);
-```
-
-# All for now
-More documentation will be added here late.
+# @zenofolio/hyper-decor (v1.0.71)
+
+A high-performance, ultra-secure, and indestructible decorators library for [HyperExpress](https://github.com/kartikk221/hyper-express).
+
+Built for speed and security, this library leverages a **Zero-Overhead** architecture using functional composition to ensure your API remains as fast as raw `uWS` while providing a modern development experience.
+
+---
+
+## 🚀 Why This Library?
+
+- **Zero-Overhead Architecture**: Parameter resolution, DTO validation, and transformations are pre-composed at startup. No runtime branching in the hotpath.
+- **Ultra-Secure File Handling**: Streaming validation of file sizes and types. Cuts the connection immediately if limits are breached. No memory exhaustion.
+- **Polymorphic Decorators**: Flexible parameter decorators that adapt to your needs without sacrificing performance.
+- **Automated OpenAPI**: Full OpenAPI 3.0 support with automatic DTO expansion and response documentation.
+
+---
+
+## 📦 Installation
+
+```bash
+npm install @zenofolio/hyper-decor
+```
+
+---
+
+## 🛠️ Usage
+
+### Define Your App
+```typescript
+import { HyperApp, createApplication } from "@zenofolio/hyper-decor";
+
+@HyperApp({
+  modules: [UserModule],
+  prefix: "/api"
+})
+class Application {}
+
+const app = await createApplication(Application);
+await app.listen(3000);
+```
+
+### Polymorphic Parameter Decorators
+Decorators like `@Body`, `@Query`, `@Param`, and `@Headers` are now smarter and faster.
+
+```typescript
+@HyperController("/users")
+class UserController {
+  
+  // 1. Direct DTO Validation (Auto-transformation + OpenAPI)
+  @Post("/")
+  async create(@Body(CreateUserDto) user: CreateUserDto) {
+    return user;
+  }
+
+  // 2. Key-based extraction with Functional Transformer
+  @Get("/:id")
+  async findOne(@Param("id", v => parseInt(v)) id: number) {
+    return { id };
+  }
+
+  // 3. Nested extraction + DTO
+  @Post("/settings")
+  async updateSettings(@Body("settings", SettingsDto) data: SettingsDto) {
+    return data;
+  }
+
+  // 4. Raw Extractors
+  @Get("/")
+  async list(@Query() allQuery: any, @Req req: any) {
+    return allQuery;
+  }
+}
+```
+
+---
+
+## 🔒 Indestructible File Uploader (`@File`)
+
+The `@File` decorator is designed to be ultra-secure. It processes files as **streams**, validating size and type binarily (magic numbers) *before* the file is fully buffered.
+
+- **Streaming Validation**: Connection is terminated immediately if `maxFileSize` is exceeded.
+- **Binary Verification**: Uses binary signatures to verify MIME types, ensuring security even if the extension is falsified.
+- **Automatic Sanitization**: File names are sanitized against path traversal and null bytes.
+
+```typescript
+@Post("/upload")
+async upload(
+  @File("avatar", {
+    maxFileSize: 5 * 1024 * 1024, // 5MB
+    allowedExtensions: ["png", "jpg"],
+    allowedMimeTypes: ["image/png", "image/jpeg"]
+  }) file: UploadedFile
+) {
+  // file.buffer contains the safely validated data
+  return { filename: file.filename, size: file.size };
+}
+```
+
+---
+
+## ⚡ Performance
+
+Benchmarks show that `@zenofolio/hyper-decor` introduces less than **1.8%** overhead compared to raw, manual HyperExpress handlers.
+
+| Scenario | Raw HyperExpress | @zenofolio/hyper-decor | Overhead |
+| :--- | :--- | :--- | :--- |
+| **Simple GET** | 27,150 req/s | 26,660 req/s | ~1.8% |
+| **Deep Transformation**| 18,120 req/s | 18,335 req/s | **+1.1% Gain** |
+
+> [!TIP]
+> The "Transformed" scenario actually performs better than manual implementations thanks to our optimized functional resolver composition that V8 can inline aggressively.
+
+---
+
+## 🔍 OpenAPI & DTOs
+
+Pass classes to your decorators, and they will be expanded into the OpenAPI schema automatically.
+
+```typescript
+class CreateUserDto {
+  /** @minimum 18 */
+  age: number;
+  name: string;
+}
+
+@Post("/")
+async create(@Body(CreateUserDto) data: CreateUserDto) { ... }
+```
+
+You can integrate any validation engine (Zod, Class-Validator) by registering a `Transformer` in the `transformRegistry`.
+
+---
+
+## 🛡️ License
+
+MIT

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

@@ -1,11 +1,2 @@
 import "reflect-metadata";
-import { Request } from "hyper-express/types";
-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 | "req" | "res", decoratorName: string, resolver: ParameterResolver, schema?: any, isWholeSource?: boolean): ParameterDecorator;
+export default function createParamDecorator(sourceKey: any, decoratorName: string, keyOrSchema?: string | any, schemaOrTransform?: any, isWholeSource?: boolean): ParameterDecorator;

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

@@ -1,4 +1,13 @@
 "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());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -7,49 +16,158 @@ exports.default = createParamDecorator;
 require("reflect-metadata");
 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"));
 const function_util_1 = require("../utils/function.util");
-/**
- * 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, schema, isWholeSource) {
-    const _key = key;
+const object_util_1 = require("../utils/object.util");
+const transform_registry_1 = require("../transform/transform.registry");
+const identitySelector = (value) => value;
+const identityTransformer = (value) => value;
+function createParamDecorator(sourceKey, decoratorName, keyOrSchema, schemaOrTransform, isWholeSource = false) {
+    const _sourceKey = sourceKey;
     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 isProperty = typeof parameterIndex === "number";
+            if (!isProperty) {
+                throw new WrongPlaceException_1.default(decoratorName, "parameter", `${Target.constructor.name}.${String(propertyKey)}`, Target);
+            }
             const saved = options !== null && options !== void 0 ? options : { params: {} };
-            const names = (0, function_util_1.extractArgsNames)(Target[propertyKey]);
+            const method = Target[propertyKey];
+            const names = (0, function_util_1.extractArgsNames)(method);
             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];
+            let key = undefined;
+            let inputSchemaOrFn = undefined;
+            let wholeSource = isWholeSource;
+            if (typeof keyOrSchema === "string") {
+                key = keyOrSchema;
+                inputSchemaOrFn = schemaOrTransform;
+            }
+            else if (keyOrSchema !== undefined) {
+                inputSchemaOrFn = keyOrSchema;
+                wholeSource = true;
+            }
+            const hasKey = key !== undefined && key !== "";
+            const hasTransform = inputSchemaOrFn !== undefined;
+            const extractor = createExtractor(_sourceKey);
+            const selector = createSelector(key);
+            const transformer = createTransformer(inputSchemaOrFn, _sourceKey, wholeSource);
+            const resolver = composeResolver(extractor, selector, transformer, hasKey, hasTransform);
             if (name && saved) {
-                if (!saved.params[propertyKey]) {
-                    saved.params[propertyKey] = [];
+                let methodParams = saved.params[propertyKey];
+                if (!methodParams) {
+                    methodParams = saved.params[propertyKey] = [];
                 }
-                saved.params[propertyKey].push({
+                methodParams.push({
                     name,
                     type,
                     index: parameterIndex,
-                    key: _key,
+                    key: _sourceKey,
                     method: propertyKey.toString(),
                     resolver,
-                    schema,
-                    isWholeSource,
+                    schema: inputSchemaOrFn,
+                    isWholeSource: wholeSource,
                 });
-                // sort by index
-                saved.params[propertyKey].sort((a, b) => a.index - b.index);
-                Reflect.defineMetadata(constants_1.KEY_PARAMS_PARAM, saved, Target[propertyKey]);
+                if (methodParams.length > 1) {
+                    methodParams.sort((a, b) => a.index - b.index);
+                }
+                Reflect.defineMetadata(constants_1.KEY_PARAMS_PARAM, saved, method);
             }
             return saved;
         },
     });
 }
+//////////////////////////
+/// Functions
+/////////////////////////
+function createBodyExtractor() {
+    return (req) => __awaiter(this, void 0, void 0, function* () {
+        const request = req;
+        const cachedBody = request.body;
+        if (cachedBody !== undefined) {
+            return cachedBody;
+        }
+        const body = yield req.json();
+        request.body = body;
+        return body;
+    });
+}
+function createReqExtractor() {
+    return (req) => __awaiter(this, void 0, void 0, function* () { return req; });
+}
+function createResExtractor() {
+    return (_req, res) => __awaiter(this, void 0, void 0, function* () { return res; });
+}
+function createGenericExtractor(sourceKey) {
+    return (req) => __awaiter(this, void 0, void 0, function* () { return req[sourceKey]; });
+}
+function createExtractor(sourceKey) {
+    switch (sourceKey) {
+        case "body":
+            return createBodyExtractor();
+        case "req":
+            return createReqExtractor();
+        case "res":
+            return createResExtractor();
+        default:
+            return createGenericExtractor(sourceKey);
+    }
+}
+function createSelector(key) {
+    if (key === undefined || key === "") {
+        return identitySelector;
+    }
+    return (value) => (0, object_util_1.$get)(value, key, value);
+}
+function createDirectTransformer(fn) {
+    return (value) => fn(value);
+}
+function createRegistryTransformer(schema, sourceKey, isWholeSource) {
+    const options = { isWholeSource };
+    const from = sourceKey;
+    return (value, req, res) => transform_registry_1.transformRegistry.resolve({
+        data: value,
+        schema,
+        options,
+        req,
+        res,
+        from,
+    });
+}
+function createTransformer(inputSchemaOrFn, sourceKey, isWholeSource) {
+    if (inputSchemaOrFn === undefined) {
+        return identityTransformer;
+    }
+    if (typeof inputSchemaOrFn === "function" &&
+        inputSchemaOrFn.prototype === undefined) {
+        return createDirectTransformer(inputSchemaOrFn);
+    }
+    if (typeof inputSchemaOrFn === "function" ||
+        typeof inputSchemaOrFn === "string") {
+        return createRegistryTransformer(inputSchemaOrFn, sourceKey, isWholeSource);
+    }
+    return identityTransformer;
+}
+function composeResolver(extractor, selector, transformer, hasKey, hasTransform) {
+    if (!hasKey && !hasTransform) {
+        return extractor;
+    }
+    if (hasKey && !hasTransform) {
+        return (req, res) => __awaiter(this, void 0, void 0, function* () {
+            const value = yield extractor(req, res);
+            return selector(value);
+        });
+    }
+    if (!hasKey && hasTransform) {
+        return (req, res) => __awaiter(this, void 0, void 0, function* () {
+            const value = yield extractor(req, res);
+            return transformer(value, req, res);
+        });
+    }
+    return (req, res) => __awaiter(this, void 0, void 0, function* () {
+        const value = yield extractor(req, res);
+        return transformer(selector(value), req, res);
+    });
+}

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

@@ -251,19 +251,7 @@ function resolveMethodParams(req, res, params) {
         const len = params.length;
         const args = new Array(len);
         for (let i = 0; i < len; i++) {
-            const param = params[i];
-            let val = yield param.resolver(req, res);
-            if (param.schema) {
-                val = yield transform_registry_1.transformRegistry.resolve({
-                    data: val,
-                    schema: param.schema,
-                    options: { isWholeSource: param.isWholeSource },
-                    req,
-                    res,
-                    from: param.key,
-                });
-            }
-            args[i] = val;
+            args[i] = yield params[i].resolver(req, res);
         }
         return args;
     });

package/dist/decorators/Http.d.ts

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

package/dist/decorators/Http.js

@@ -1,13 +1,4 @@
 "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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -18,7 +9,6 @@ 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");
 /**
  * Get the value of a key from the request object
  *
@@ -34,105 +24,21 @@ const object_util_1 = require("../__internals/utils/object.util");
  * \@Query(UserQueryDto)
  */
 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);
+    return (0, request_creator_1.default)("query", "Query", keyOrSchema, schemaOrTransform);
 }
-/**
- * Get the body of the request or transform it via a schema.
- *
- * @example
- * \@Body()
- * \@Body(CreateUserDto)
- */
-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;
-    }));
+function Body(keyOrSchema, schemaOrTransform) {
+    return (0, request_creator_1.default)("body", "Body", keyOrSchema, schemaOrTransform, true);
 }
-/**
- * Get the params from the request or transform via schema.
- *
- * @example
- * \@Param('id')
- * \@Param('id', IntSchema)
- */
-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);
+function Param(keyOrSchema, schemaOrTransform) {
+    return (0, request_creator_1.default)("params", "Param", keyOrSchema, schemaOrTransform);
 }
-/**
- * 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);
+function Headers(keyOrSchema, schemaOrTransform) {
+    return (0, request_creator_1.default)("headers", "Headers", keyOrSchema, schemaOrTransform);
 }
-const Req = () => (0, request_creator_1.default)("req", "Req", (req) => req);
+const Req = () => (0, request_creator_1.default)("req", "Req");
 exports.Req = Req;
-const Res = () => (0, request_creator_1.default)("res", "Res", (req, res) => res);
+const Res = () => (0, request_creator_1.default)("res", "Res");
 exports.Res = Res;
-/**
- * Create a custom request decorator
- * that can be used to extract data from the request object
- *
- *
- * @example
- * ```typescript
- *
- * interface LoginData {
- *  username: string;
- *  password: string;
- * }
- *
- * const LoginData = createCustomRequestDecorator<LoginData>({
- *  resolver: async (request) => {
- *    const data = await request.json();
- *    return [data];
- *  }
- * }
- *
- *
- *
- */
 const createCustomRequestDecorator = (decoratorName, resolver) => {
     return (0, request_creator_1.default)("req", decoratorName, resolver);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenofolio/hyper-decor",
-  "version": "1.0.71",
+  "version": "1.0.72",
   "description": "Project core with utilities and features",
   "main": "dist/index.js",
   "author": "zenozaga",