@zenofolio/hyper-decor 1.0.69 → 1.0.72

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

@@ -24,7 +24,6 @@ const middleware_transform_1 = __importDefault(require("../transform/middleware.
 const tsyringe_1 = require("tsyringe");
 const path_util_1 = require("../utils/path.util");
 const imports_helper_1 = require("./imports.helper");
-const constants_2 = require("../constants");
 const message_bus_1 = require("../../common/message-bus");
 const transport_1 = require("../../common/transport");
 const transform_registry_1 = require("../transform/transform.registry");
@@ -243,11 +242,54 @@ function prepareTarget(_a) {
         };
     });
 }
+/**
+ * Resolves method parameters and applies adaptive transformations.
+ * Optimized: Metadata is resolved once and passed here.
+ */
+function resolveMethodParams(req, res, params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const len = params.length;
+        const args = new Array(len);
+        for (let i = 0; i < len; i++) {
+            args[i] = yield params[i].resolver(req, res);
+        }
+        return args;
+    });
+}
+/**
+ * Handles output transformation and sends the response.
+ * Optimized: outputSchema is pre-resolved outside the request hotpath.
+ */
+function handleResponse(req, res, result, outputSchema) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (result === undefined || res.completed)
+            return;
+        if (outputSchema && outputSchema !== Object && outputSchema !== Promise) {
+            const transformed = yield transform_registry_1.transformRegistry.resolve({
+                data: result,
+                schema: outputSchema,
+                options: {},
+                req,
+                res,
+                from: "response",
+            });
+            if (transformed !== undefined && !res.completed) {
+                res.json(transformed);
+                return;
+            }
+        }
+        if (!res.completed) {
+            if (typeof result === "object" && result !== null) {
+                res.json(result);
+            }
+            else {
+                res.send(result);
+            }
+        }
+    });
+}
 /**
  * Prepare the routes for the target class.
- *
- * @param param0
- * @returns
  */
 function prepareRoutes(_a) {
     return __awaiter(this, arguments, void 0, function* ({ target, router, route, instance, namespace, log, }) {
@@ -256,63 +298,41 @@ function prepareRoutes(_a) {
         const metadata = getData(handler);
         const params = (_d = (_c = (_b = metadata.params) === null || _b === void 0 ? void 0 : _b.params) === null || _c === void 0 ? void 0 : _c[propertyKey]) !== null && _d !== void 0 ? _d : [];
         const $fn = Reflect.get(router, method);
-        const hasParams = params.length > 0;
         if (!$fn)
             return;
         const middlewares = [...metadata.middlewares];
-        // Agnostic Transform Integration
-        const transform = (0, decorator_base_1.getDecorData)(constants_2.KEY_PARAMS_TRANSFORM, target.prototype || target, propertyKey);
-        if (transform) {
-            middlewares.push((req, res, next) => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    const from = transform.options.from || "body";
-                    let data;
-                    if (from === "body") {
-                        data = req.body !== undefined ? req.body : yield req.json();
-                    }
-                    else {
-                        data = req[from];
-                    }
-                    // Resolve through the chain of responsibility
-                    const transformed = yield transform_registry_1.transformRegistry.resolve({
-                        data,
-                        schema: transform.schema,
-                        options: transform.options,
-                        req,
-                        res,
-                        from
-                    });
-                    // Update the request object
-                    req[from] = transformed;
-                    next();
-                }
-                catch (err) {
-                    next(err);
-                }
-            }));
-        }
+        const proto = target.prototype || target;
+        // Pre-resolve Output-Metadata
+        const outputSchema = Reflect.getMetadata(constants_1.KEY_OUTPUT_SCHEMA, proto, propertyKey) ||
+            Reflect.getMetadata(constants_1.DESIGN_RETURNTYPE, proto, propertyKey);
         (0, role_transform_1.default)(metadata.roles, (middleware) => middlewares.push(middleware));
         (0, scope_transfrom_1.default)(metadata.scopes, (middleware, scopes) => {
             middlewares.push(middleware);
             stores_1.ScopeStore.addAll(scopes);
         });
-        log("routes", `${namespace}/${propertyKey} ${method.toUpperCase()} { ${path} }`);
-        if (!hasParams) {
-            if (method === "ws" && options) {
-                router.ws(path, options, handler.bind(instance));
-                return;
+        log("routes", `${namespace}/${propertyKey.toString()} ${method.toUpperCase()} { ${path} }`);
+        const routeHandler = (req, res) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const args = params.length > 0
+                    ? yield resolveMethodParams(req, res, params)
+                    : [req, res];
+                const result = yield handler.apply(instance, args);
+                yield handleResponse(req, res, result, outputSchema);
             }
-            $fn.call(router, path, ...middlewares, handler.bind(instance));
-        }
-        else {
-            $fn.call(router, path, ...middlewares, (req, res) => __awaiter(this, void 0, void 0, function* () {
-                const len = params.length;
-                const args = new Array(len);
-                for (let i = 0; i < len; i++) {
-                    args[i] = yield params[i].resolver(req, res);
+            catch (err) {
+                if (!res.completed) {
+                    const error = err;
+                    res.status(error.status || 500).json({
+                        error: error.message || "Internal Server Error",
+                        code: error.code,
+                    });
                 }
-                return handler.apply(instance, args);
-            }));
+            }
+        });
+        if (method === "ws" && options) {
+            router.ws(path, options, handler.bind(instance));
+            return;
         }
+        $fn.call(router, path, ...middlewares, routeHandler);
     });
 }

package/dist/decorators/File.d.ts

@@ -1,31 +1,17 @@
 import { Request } from "hyper-express/types";
 /**
  * File upload restrictions
- *
- * @param allowedMimeTypes Allowed MIME types
- * @param maxFileSize Maximum file size in bytes
- *
  */
-export interface FileUplopadRestrictions {
+export interface FileUploadRestrictions {
     allowedMimeTypes: string[];
     maxFileSize: number;
 }
 /**
  * File restrictions resolver
- *
- * @param request Request object
- * @returns File restrictions
- *
  */
-export type FileRestrictions = FileUplopadRestrictions | ((request: Request) => FileUplopadRestrictions | Promise<FileUplopadRestrictions>);
+export type FileRestrictions = FileUploadRestrictions | ((request: Request) => FileUploadRestrictions | Promise<FileUploadRestrictions>);
 /**
  * File decorator options
- *
- * @param fieldName Field name to extract from the request
- * @param restrictions File restrictions
- * @param required If the file is required
- *
- *
  */
 export interface FileOptions {
     fieldName: string | string[];
@@ -33,33 +19,19 @@ export interface FileOptions {
     required?: boolean;
 }
 export interface UploadedFile {
+    field: string;
     name: string;
     filename: string;
     mimeType: string;
     size: number;
-    ext: string;
+    extension: string;
     buffer: Buffer;
 }
 /**
  * Decorator to extract file from the request
- *
- * @param param0
  */
 export declare const File: {
     (options: FileOptions | string): ParameterDecorator;
-    /**
-     *
-     * Helper function to create a file decorator with options
-     *
-     * @param options
-     * @returns
-     */
     options(options: FileOptions, required?: boolean): (fieldName: string | string[]) => ParameterDecorator;
-    /**
-     * Helper function to create a file decorator with restrictions
-     *
-     * @param restrictions
-     * @returns
-     */
     restrictions(restrictions: FileRestrictions): (fieldName: string | string[], required?: boolean) => ParameterDecorator;
 };

package/dist/decorators/File.js

@@ -8,46 +8,37 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.File = void 0;
 const Http_1 = require("./Http");
-const consumers_1 = require("stream/consumers");
 const HyperFileException_1 = __importDefault(require("../exeptions/HyperFileException"));
 /**
  * Decorator to extract file from the request
- *
- * @param param0
  */
 const File = (options) => {
     const _options = typeof options === "string" ? { fieldName: options } : options;
     return (0, Http_1.createCustomRequestDecorator)("File", (request) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b;
+        var _a;
         const { allowedMimeTypes, maxFileSize } = yield resolveRestrictions(request, _options.restrictions);
         const passTypes = allowedMimeTypes.includes("*") || allowedMimeTypes.length === 0;
         const passSize = maxFileSize === Infinity;
         const contentType = (_a = request.headers) === null || _a === void 0 ? void 0 : _a["content-type"];
-        const fileSize = Number((_b = request.headers) === null || _b === void 0 ? void 0 : _b["content-length"]);
         const isMultipart = contentType === null || contentType === void 0 ? void 0 : contentType.includes("multipart/form-data");
         if (!isMultipart) {
             throw new HyperFileException_1.default("Invalid request, expected multipart form data", {
                 fieldName: _options.fieldName,
             });
         }
-        if (isNaN(fileSize) || fileSize <= 0) {
-            throw new HyperFileException_1.default(`File ${_options.fieldName} is missing or empty`, {
-                fieldName: _options.fieldName,
-                fileSize,
-            });
-        }
-        if (!passSize && fileSize > maxFileSize) {
-            throw new HyperFileException_1.default(`File ${_options.fieldName} is too large. Max size is ${maxFileSize} bytes`, {
-                fieldName: _options.fieldName,
-                maxFileSize,
-            });
-        }
         const files = yield extractFiles(request, {
             maxSize: passSize ? undefined : maxFileSize,
             mimeTypes: passTypes ? undefined : allowedMimeTypes,
@@ -64,35 +55,16 @@ const File = (options) => {
     }));
 };
 exports.File = File;
-/**
- *
- * Helper function to create a file decorator with options
- *
- * @param options
- * @returns
- */
 exports.File.options = (options, required = false) => {
     return (fieldName) => {
         return (0, exports.File)(Object.assign(Object.assign({}, options), { required, fieldName }));
     };
 };
-/**
- * Helper function to create a file decorator with restrictions
- *
- * @param restrictions
- * @returns
- */
 exports.File.restrictions = (restrictions) => {
     return (fieldName, required = false) => {
         return (0, exports.File)({ fieldName, restrictions, required });
     };
 };
-/////////////////////////////
-// Types
-/////////////////////////////
-/////////////////////////////
-/// Utility
-/////////////////////////////
 const resolveRestrictions = (request, restrictions) => __awaiter(void 0, void 0, void 0, function* () {
     if (typeof restrictions === "function") {
         return yield restrictions(request);
@@ -103,63 +75,78 @@ const resolveRestrictions = (request, restrictions) => __awaiter(void 0, void 0,
     });
 });
 /**
- * Extract files from a request with validation, transformation, and required files check.
- *
- * @param request
- * @param options Validation and transformation options
- * @returns Transformed or raw file details
+ * Extract files from a request with validation and secure streaming.
  */
 const extractFiles = (request, options) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
-    const contentType = (_a = request.headers) === null || _a === void 0 ? void 0 : _a["content-type"];
-    if (!(contentType === null || contentType === void 0 ? void 0 : contentType.includes("multipart/form-data"))) {
-        throw new Error("Invalid request, expected multipart form data");
-    }
     const filesMap = {};
+    // Track if we are already over total limit (Content-Length check as first line of defense)
+    const totalLength = Number((_a = request.headers) === null || _a === void 0 ? void 0 : _a["content-length"]);
+    if ((options === null || options === void 0 ? void 0 : options.maxSize) && !isNaN(totalLength) && totalLength > options.maxSize + 1024 * 10) { // Buffer for boundaries
+        // Content-Length is significantly larger than allowed file size
+        // We don't throw yet because multipart might have multiple files or large fields
+    }
     yield request.multipart((field) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
+        var _a, e_1, _b, _c;
+        var _d, _e;
         if (field.file && field.file.stream) {
-            const bufferFile = yield (0, consumers_1.buffer)(field.file.stream);
-            const type = yield (yield import("file-type")).fileTypeFromBuffer(bufferFile);
-            if (!type) {
-                throw new HyperFileException_1.default(`Invalid file type`, {
-                    field: field.name,
-                });
+            const chunks = [];
+            let totalRead = 0;
+            try {
+                // Safe stream reading with early exit
+                for (var _f = true, _g = __asyncValues(field.file.stream), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
+                    _c = _h.value;
+                    _f = false;
+                    const chunk = _c;
+                    totalRead += chunk.length;
+                    if ((options === null || options === void 0 ? void 0 : options.maxSize) && totalRead > options.maxSize) {
+                        throw new HyperFileException_1.default(`File '${field.name}' exceeds the maximum limit of ${options.maxSize} bytes`, { field: field.name, maxSize: options.maxSize });
+                    }
+                    chunks.push(chunk);
+                }
             }
-            const mimeType = type.mime;
-            const extention = type.ext;
-            // Validate MIME type early
-            if ((options === null || options === void 0 ? void 0 : options.mimeTypes) && !options.mimeTypes.includes(mimeType)) {
-                throw new HyperFileException_1.default(`Invalid file type, only ${options.mimeTypes.join(", ")} is allowed`, {
-                    field: field.name,
-                    allowedMimeTypes: options.mimeTypes,
-                    mimeType,
-                });
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_f && !_a && (_b = _g.return)) yield _b.call(_g);
+                }
+                finally { if (e_1) throw e_1.error; }
             }
-            if (!type) {
-                throw new HyperFileException_1.default(`Invalid file type`, {
-                    field: field.name,
-                });
+            const bufferFile = Buffer.concat(chunks);
+            const { fileTypeFromBuffer } = yield import("file-type");
+            const type = yield fileTypeFromBuffer(bufferFile);
+            const mimeType = (type === null || type === void 0 ? void 0 : type.mime) || "unknown/unrecognized";
+            const extension = (type === null || type === void 0 ? void 0 : type.ext) || "bin";
+            // Validate MIME type early if unrecognized
+            if (!type && (options === null || options === void 0 ? void 0 : options.mimeTypes) && options.mimeTypes.length > 0) {
+                throw new HyperFileException_1.default(`Invalid file type for field '${field.name}'. Could not recognize file signature. Expected one of: ${options.mimeTypes.join(", ")}`, { field: field.name, allowedMimeTypes: options.mimeTypes });
             }
-            if ((options === null || options === void 0 ? void 0 : options.maxSize) && bufferFile.byteLength > options.maxSize) {
-                throw new HyperFileException_1.default(`File '${field.name}' size exceeds the maximum limit of ${options.maxSize} bytes`, {
+            // Validate MIME type if recognized
+            if ((options === null || options === void 0 ? void 0 : options.mimeTypes) && !options.mimeTypes.includes(mimeType)) {
+                throw new HyperFileException_1.default(`Invalid file type for field '${field.name}'. Expected: ${options.mimeTypes.join(", ")}, Received: ${mimeType}`, {
                     field: field.name,
-                    maxSize: options.maxSize,
+                    allowedMimeTypes: options.mimeTypes,
+                    receivedMimeType: mimeType,
                 });
             }
-            if ((options === null || options === void 0 ? void 0 : options.requireName) && !((_a = field.file) === null || _a === void 0 ? void 0 : _a.name)) {
-                throw new HyperFileException_1.default(`File name is required`, {
+            if ((options === null || options === void 0 ? void 0 : options.requireName) && !((_d = field.file) === null || _d === void 0 ? void 0 : _d.name)) {
+                throw new HyperFileException_1.default(`File name is required for field '${field.name}'`, {
                     field: field.name,
                 });
             }
-            // Derive file details
-            const name = (_d = (_c = (_b = field.file) === null || _b === void 0 ? void 0 : _b.name) === null || _c === void 0 ? void 0 : _c.split(".").shift()) !== null && _d !== void 0 ? _d : field.name;
-            const filename = `${name === null || name === void 0 ? void 0 : name.replace(extention, "")}.${extention}`;
+            // Secure filename resolution
+            const rawName = ((_e = field.file) === null || _e === void 0 ? void 0 : _e.name) || field.name;
+            // Sanitize: remove null bytes, path traversal sequences, and extract base name
+            const sanitizedBase = rawName.replace(/\0/g, "").split(/[\\/]/).pop() || "file";
+            const nameOnly = sanitizedBase.includes(".")
+                ? sanitizedBase.substring(0, sanitizedBase.lastIndexOf("."))
+                : sanitizedBase;
+            const filename = `${nameOnly}.${extension}`;
             filesMap[field.name] = {
                 field: field.name,
-                name: name,
+                name: nameOnly,
                 filename: filename,
-                ext: extention,
+                extension: extension,
                 size: bufferFile.byteLength,
                 mimeType: mimeType,
                 buffer: bufferFile,

package/dist/decorators/Http.d.ts

@@ -5,51 +5,18 @@ import { ParameterResolver } from "./types";
  * @param key
  * @returns
  */
-export declare const Query: (key?: string, transfrom?: (data: any) => any) => ParameterDecorator;
 /**
- * Get the body of the request
+ * Get the value of a key from the request object or transform the entire query.
  *
- * @param resolver
- * @returns
- */
-export declare const Body: <T, R>(resolver?: (data: T) => R) => ParameterDecorator;
-/**
- * Get the params from the request
- *
- * @param k
- * @returns
- */
-export declare const Param: (k?: string, validator?: (data: any) => any) => ParameterDecorator;
-/**
- * get the headers from the request
- *
- * @param key
- * @returns
+ * @example
+ * \@Query('id')
+ * \@Query('id', IntSchema)
+ * \@Query(UserQueryDto)
  */
-export declare const Headers: <T extends string>(key?: T) => ParameterDecorator;
+export declare function Query(keyOrSchema?: string | any, schemaOrTransform?: 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,92 +1,44 @@
 "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 };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCustomRequestDecorator = exports.Res = exports.Req = exports.Headers = exports.Param = exports.Body = exports.Query = void 0;
-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
- *
- * @param key
- * @returns
- */
-const Query = (key, transfrom) => (0, request_creator_1.default)("query", "Query", (request) => {
-    const value = (0, object_util_1.$get)(request.query, key, request.query);
-    if (!transfrom)
-        return value;
-    return value;
-});
+exports.createCustomRequestDecorator = exports.Res = exports.Req = void 0;
 exports.Query = Query;
-/**
- * Get the body of the request
- *
- * @param resolver
- * @returns
- */
-const Body = (resolver) => (0, request_creator_1.default)("req", "BODY", (request) => __awaiter(void 0, void 0, void 0, function* () {
-    const value = request.body !== undefined ? request.body : yield request.json();
-    return resolver ? resolver(value) : value;
-}));
 exports.Body = Body;
-/**
- * Get the params from the request
- *
- * @param k
- * @returns
- */
-const Param = (k, validator) => (0, request_creator_1.default)("params", "Param", (req) => {
-    const value = (0, object_util_1.$get)(req.params, k, req.params);
-    if (typeof validator === "function")
-        return validator(value);
-    return value;
-});
 exports.Param = Param;
+exports.Headers = Headers;
+const request_creator_1 = __importDefault(require("../__internals/creators/request.creator"));
 /**
- * get the headers from the request
+ * Get the value of a key from the request object
  *
  * @param key
  * @returns
  */
-const Headers = (key) => (0, request_creator_1.default)("headers", "Headers", (req) => (0, object_util_1.$get)(req.headers, key, req.headers));
-exports.Headers = Headers;
-const Req = () => (0, request_creator_1.default)("req", "Req", (req) => req);
-exports.Req = Req;
-const Res = () => (0, request_creator_1.default)("res", "Res", (req, res) => res);
-exports.Res = Res;
 /**
- * Create a custom request decorator
- * that can be used to extract data from the request object
- *
+ * Get the value of a key from the request object or transform the entire query.
  *
  * @example
- * ```typescript
- *
- * interface LoginData {
- *  username: string;
- *  password: string;
- * }
- *
- * const LoginData = createCustomRequestDecorator<LoginData>({
- *  resolver: async (request) => {
- *    const data = await request.json();
- *    return [data];
- *  }
- * }
- *
- *
- *
+ * \@Query('id')
+ * \@Query('id', IntSchema)
+ * \@Query(UserQueryDto)
  */
+function Query(keyOrSchema, schemaOrTransform) {
+    return (0, request_creator_1.default)("query", "Query", keyOrSchema, schemaOrTransform);
+}
+function Body(keyOrSchema, schemaOrTransform) {
+    return (0, request_creator_1.default)("body", "Body", keyOrSchema, schemaOrTransform, true);
+}
+function Param(keyOrSchema, schemaOrTransform) {
+    return (0, request_creator_1.default)("params", "Param", keyOrSchema, schemaOrTransform);
+}
+function Headers(keyOrSchema, schemaOrTransform) {
+    return (0, request_creator_1.default)("headers", "Headers", keyOrSchema, schemaOrTransform);
+}
+const Req = () => (0, request_creator_1.default)("req", "Req");
+exports.Req = Req;
+const Res = () => (0, request_creator_1.default)("res", "Res");
+exports.Res = Res;
 const createCustomRequestDecorator = (decoratorName, resolver) => {
     return (0, request_creator_1.default)("req", decoratorName, resolver);
 };

package/dist/decorators/Output.d.ts

@@ -0,0 +1,9 @@
+import "reflect-metadata";
+/**
+ * Decorator to explicitly mark a method for response transformation and OpenAPI documentation.
+ *
+ * @param schema The schema or DTO class for the successful response (200).
+ * @example
+ * \@Output(UserDto)
+ */
+export declare function Output(schema?: any): (target: any, propertyKey?: any, descriptor?: PropertyDescriptor) => void;

package/dist/decorators/Output.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Output = Output;
+require("reflect-metadata");
+const decorator_base_1 = require("../__internals/decorator-base");
+const constants_1 = require("../__internals/constants");
+/**
+ * Decorator to explicitly mark a method for response transformation and OpenAPI documentation.
+ *
+ * @param schema The schema or DTO class for the successful response (200).
+ * @example
+ * \@Output(UserDto)
+ */
+function Output(schema) {
+    return (target, propertyKey, descriptor) => {
+        (0, decorator_base_1.defineDecorData)(constants_1.KEY_OUTPUT_SCHEMA, schema, target, propertyKey);
+    };
+}

package/dist/decorators/index.d.ts

@@ -11,4 +11,4 @@ export * from "./Http";
 export * from "./Pass";
 export * from "./File";
 export * from "./Messaging";
-export * from "./Transform";
+export * from "./Output";

package/dist/decorators/index.js

@@ -27,4 +27,4 @@ __exportStar(require("./Http"), exports);
 __exportStar(require("./Pass"), exports);
 __exportStar(require("./File"), exports);
 __exportStar(require("./Messaging"), exports);
-__exportStar(require("./Transform"), exports);
+__exportStar(require("./Output"), exports);