@avleon/core 0.0.40 → 0.0.42-rc0.1

package/dist/file-storage.js

@@ -38,111 +38,226 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileStorage = void 0;
-const fs_1 = __importDefault(require("fs"));
+const fs_1 = __importStar(require("fs"));
 const path_1 = __importDefault(require("path"));
 const promises_1 = require("stream/promises");
-const http_exceptions_1 = require("./exceptions/http-exceptions");
 const decorators_1 = require("./decorators");
 const system_exception_1 = require("./exceptions/system-exception");
+const http_exceptions_1 = require("./exceptions/http-exceptions");
 let FileStorage = class FileStorage {
     constructor() {
         this.transformOptions = null;
+        this.maxFileSize = 50 * 1024 * 1024; // 50MB default
+        this.baseDir = path_1.default.join(process.cwd(), "public");
+        this.ensureDirectoryExists(this.baseDir);
     }
+    /**
+     * Set transformation options for the next save operation
+     */
     transform(options) {
         this.transformOptions = options;
         return this;
     }
-    isFileExists(fpath) {
-        return fs_1.default.existsSync(fpath);
+    async getUploadFile(fliePath) {
+        const f = await fs_1.default.promises.readFile(path_1.default.join(this.baseDir, fliePath));
+        return f;
+    }
+    async download(filepath) {
+        const filename = filepath
+            .toString()
+            .split(/[\/\\]/)
+            .pop() || "file";
+        const s = (0, fs_1.createReadStream)(filepath);
+        return {
+            download: true,
+            stream: s,
+            filename,
+        };
     }
+    async downloadAs(filepath, filename) {
+        const s = (0, fs_1.createReadStream)(filepath);
+        return {
+            download: true,
+            stream: s,
+            filename,
+        };
+    }
+    /**
+     * Save a single file with optional transformations
+     */
     async save(f, options) {
-        let foptions = {
-            overwrite: options && options.overwrite ? options.overwrite : true,
+        var _a;
+        const opts = {
+            overwrite: (_a = options === null || options === void 0 ? void 0 : options.overwrite) !== null && _a !== void 0 ? _a : true,
+            to: options === null || options === void 0 ? void 0 : options.to,
+            saveAs: options === null || options === void 0 ? void 0 : options.saveAs,
         };
+        if (f.type !== "file") {
+            throw new system_exception_1.SystemUseError("Invalid file type");
+        }
         try {
-            if (f.type == "file") {
-                const fname = path_1.default.join(process.cwd(), `public/${f.filename}`);
-                if (!foptions.overwrite && this.isFileExists(fname)) {
-                    throw new system_exception_1.SystemUseError("File already exits.");
-                }
-                await (0, promises_1.pipeline)(f.file, fs_1.default.createWriteStream(fname));
-                return f;
+            const filename = opts.saveAs || f.filename;
+            this.validateFilename(filename);
+            const uploadDir = opts.to
+                ? path_1.default.join(this.baseDir, opts.to)
+                : this.baseDir;
+            const fullPath = path_1.default.join(uploadDir, filename);
+            if (!fullPath.startsWith(this.baseDir)) {
+                throw new system_exception_1.SystemUseError("Invalid file path");
+            }
+            // Check if file exists
+            if (!opts.overwrite && this.isFileExists(fullPath)) {
+                throw new system_exception_1.SystemUseError("File already exists");
+            }
+            await this.ensureDirectoryExists(uploadDir);
+            let sourceStream;
+            const savedFile = f;
+            if (savedFile.filepath && !f.file) {
+                sourceStream = fs_1.default.createReadStream(savedFile.filepath);
             }
+            else if (f.file) {
+                sourceStream = f.file;
+            }
+            else {
+                throw new system_exception_1.SystemUseError("No file stream or filepath available");
+            }
+            if (this.transformOptions && this.isImageFile(filename)) {
+                await this.processImage(sourceStream, fullPath);
+            }
+            else {
+                await (0, promises_1.pipeline)(sourceStream, fs_1.default.createWriteStream(fullPath));
+            }
+            if (savedFile.filepath && fs_1.default.existsSync(savedFile.filepath)) {
+                this.removeFileSync(savedFile.filepath);
+            }
+            if (opts.saveAs) {
+                f.filename = opts.saveAs;
+            }
+            return {
+                uploadPath: (options === null || options === void 0 ? void 0 : options.to) ? '/uploads/' + options.to + "/" + f.filename : '/uploads/' + f.filename,
+                staticPath: (options === null || options === void 0 ? void 0 : options.to) ? '/static/' + options.to + "/" + f.filename : '/static/' + f.filename
+            };
         }
         catch (err) {
-            throw new system_exception_1.SystemUseError("Can't upload file");
-        }
-    }
-    async remove(filepath) {
-        if (!this.isFileExists(path_1.default.join(process.cwd(), "public/" + filepath))) {
-            throw new system_exception_1.SystemUseError("File doesn't exists.");
+            if (err instanceof system_exception_1.SystemUseError ||
+                err instanceof http_exceptions_1.InternalErrorException) {
+                throw err;
+            }
+            console.error("File save error:", err);
+            throw new system_exception_1.SystemUseError("Failed to upload file");
         }
-        return fs_1.default.unlinkSync(path_1.default.join(process.cwd(), "public/" + filepath));
     }
+    /**
+     * Save multiple files
+     */
     async saveAll(files, options) {
-        try {
-            let foptions = {
-                overwrite: options && options.overwrite ? options.overwrite : true,
-            };
-            for (let f of files) {
-                let uploadPath = "public";
-                if (options === null || options === void 0 ? void 0 : options.to) {
-                    uploadPath = `public/${options.to}`;
+        var _a;
+        if (!files || files.length === 0) {
+            return [];
+        }
+        const opts = {
+            overwrite: (_a = options === null || options === void 0 ? void 0 : options.overwrite) !== null && _a !== void 0 ? _a : true,
+            to: options === null || options === void 0 ? void 0 : options.to,
+        };
+        const uploadDir = opts.to ? path_1.default.join(this.baseDir, opts.to) : this.baseDir;
+        await this.ensureDirectoryExists(uploadDir);
+        const results = [];
+        for (const f of files) {
+            try {
+                this.validateFilename(f.filename);
+                const fullPath = path_1.default.join(uploadDir, f.filename);
+                if (!fullPath.startsWith(this.baseDir)) {
+                    throw new system_exception_1.SystemUseError(`Invalid file path for ${f.filename}`);
+                }
+                if (!opts.overwrite && this.isFileExists(fullPath)) {
+                    throw new system_exception_1.SystemUseError(`File ${f.filename} already exists`);
                 }
-                const fname = path_1.default.join(process.cwd(), `${uploadPath}/${f.filename}`);
-                await this.ensureDirectoryExists(fname);
                 if (f.file) {
-                    await (0, promises_1.pipeline)(f.file, fs_1.default.createWriteStream(fname));
+                    if (this.transformOptions && this.isImageFile(f.filename)) {
+                        await this.processImage(f.file, fullPath);
+                    }
+                    else {
+                        await (0, promises_1.pipeline)(f.file, fs_1.default.createWriteStream(fullPath));
+                    }
                 }
                 else {
                     const fp = f;
-                    await (0, promises_1.pipeline)(fs_1.default.createReadStream(fp.filepath), fs_1.default.createWriteStream(fname));
-                    fs_1.default.unlinkSync(fp.filepath);
+                    if (!fp.filepath) {
+                        throw new system_exception_1.SystemUseError(`No filepath for ${f.filename}`);
+                    }
+                    if (this.transformOptions && this.isImageFile(f.filename)) {
+                        await this.processImage(fs_1.default.createReadStream(fp.filepath), fullPath);
+                    }
+                    else {
+                        await (0, promises_1.pipeline)(fs_1.default.createReadStream(fp.filepath), fs_1.default.createWriteStream(fullPath));
+                    }
+                    this.removeFileSync(fp.filepath);
                 }
+                results.push({
+                    uploadPath: (options === null || options === void 0 ? void 0 : options.to) ? '/uploads/' + options.to + "/" + f.filename : '/uploads/' + f.filename,
+                    staticPath: (options === null || options === void 0 ? void 0 : options.to) ? '/static/' + options.to + "/" + f.filename : '/static/' + f.filename
+                });
+            }
+            catch (error) {
+                console.error(`Failed to save file ${f.filename}:`, error);
+                throw new system_exception_1.SystemUseError(`Failed to upload file ${f.filename}`);
             }
-            return files;
+        }
+        return results;
+    }
+    /**
+     * Remove a file from storage
+     */
+    async remove(filepath) {
+        const fullPath = path_1.default.join(this.baseDir, filepath);
+        // Security check
+        if (!fullPath.startsWith(this.baseDir)) {
+            throw new system_exception_1.SystemUseError("Invalid file path");
+        }
+        if (!this.isFileExists(fullPath)) {
+            throw new system_exception_1.SystemUseError("File doesn't exist");
+        }
+        try {
+            fs_1.default.unlinkSync(fullPath);
         }
         catch (error) {
-            console.error(error);
-            throw new system_exception_1.SystemUseError("Can't upload file");
+            console.error("File removal error:", error);
+            throw new system_exception_1.SystemUseError("Failed to remove file");
         }
     }
+    /**
+     * Process image with transformations using sharp
+     */
     async processImage(fileStream, outputPath) {
         var _a, _b;
         try {
-            const sharp = await Promise.resolve().then(() => __importStar(require("sharp"))); // Lazy import sharp
+            const sharp = await Promise.resolve().then(() => __importStar(require("sharp")));
             let sharpPipeline = sharp.default();
             if ((_a = this.transformOptions) === null || _a === void 0 ? void 0 : _a.resize) {
-                sharpPipeline = sharpPipeline.resize(this.transformOptions.resize.width, this.transformOptions.resize.height);
+                sharpPipeline = sharpPipeline.resize(this.transformOptions.resize.width, this.transformOptions.resize.height, { fit: "inside", withoutEnlargement: true });
             }
             if ((_b = this.transformOptions) === null || _b === void 0 ? void 0 : _b.format) {
+                const quality = this.transformOptions.quality || 80;
                 switch (this.transformOptions.format) {
                     case "jpeg":
-                        sharpPipeline = sharpPipeline.jpeg({
-                            quality: this.transformOptions.quality || 80,
-                        });
+                        sharpPipeline = sharpPipeline.jpeg({ quality });
                         break;
                     case "png":
-                        sharpPipeline = sharpPipeline.png({
-                            quality: this.transformOptions.quality || 80,
-                        });
+                        sharpPipeline = sharpPipeline.png({ quality });
                         break;
                     case "webp":
-                        sharpPipeline = sharpPipeline.webp({
-                            quality: this.transformOptions.quality || 80,
-                        });
+                        sharpPipeline = sharpPipeline.webp({ quality });
                         break;
                     case "avif":
-                        sharpPipeline = sharpPipeline.avif({
-                            quality: this.transformOptions.quality || 80,
-                        });
-                        break;
-                    default:
+                        sharpPipeline = sharpPipeline.avif({ quality });
                         break;
                 }
             }
@@ -154,20 +269,55 @@ let FileStorage = class FileStorage {
                 throw new http_exceptions_1.InternalErrorException("sharp module not found. Please install sharp to use image transformations.");
             }
             console.error("Image processing failed:", error);
-            throw new http_exceptions_1.InternalErrorException("Image processing failed.");
+            throw new http_exceptions_1.InternalErrorException("Image processing failed");
         }
         finally {
-            this.transformOptions = null; // Reset transform options after processing
+            this.transformOptions = null;
         }
     }
-    async ensureDirectoryExists(filePath) {
-        const dir = path_1.default.dirname(filePath);
-        if (!fs_1.default.existsSync(dir)) {
-            fs_1.default.mkdirSync(dir, { recursive: true });
+    /**
+     * Helper methods
+     */
+    isFileExists(fpath) {
+        return fs_1.default.existsSync(fpath);
+    }
+    async ensureDirectoryExists(dirPath) {
+        if (!fs_1.default.existsSync(dirPath)) {
+            fs_1.default.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+    removeFileSync(filepath) {
+        try {
+            if (fs_1.default.existsSync(filepath)) {
+                fs_1.default.unlinkSync(filepath);
+            }
+        }
+        catch (error) {
+            console.error("Failed to remove temp file:", error);
+        }
+    }
+    isImageFile(filename) {
+        const ext = path_1.default.extname(filename).toLowerCase();
+        return [".jpg", ".jpeg", ".png", ".webp", ".avif", ".gif", ".bmp"].includes(ext);
+    }
+    validateFilename(filename) {
+        if (!filename || filename.trim() === "") {
+            throw new system_exception_1.SystemUseError("Invalid filename");
+        }
+        // Check for path traversal attempts
+        if (filename.includes("..") ||
+            filename.includes("/") ||
+            filename.includes("\\")) {
+            throw new system_exception_1.SystemUseError("Invalid filename: path traversal detected");
+        }
+        // Check for null bytes
+        if (filename.includes("\0")) {
+            throw new system_exception_1.SystemUseError("Invalid filename: null byte detected");
         }
     }
 };
 exports.FileStorage = FileStorage;
 exports.FileStorage = FileStorage = __decorate([
-    decorators_1.AppService
+    decorators_1.AppService,
+    __metadata("design:paramtypes", [])
 ], FileStorage);

package/dist/file-storage.test.d.ts

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

package/dist/file-storage.test.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const stream_1 = require("stream");
+const file_storage_1 = require("./file-storage");
+const system_exception_1 = require("./exceptions/system-exception");
+const promises_1 = require("stream/promises");
+jest.mock("fs");
+jest.mock("stream/promises", () => ({
+    pipeline: jest.fn((...args) => Promise.resolve()),
+}));
+const mockFs = fs_1.default;
+describe("FileStorage", () => {
+    let fileStorage;
+    const testFile = {
+        type: "file",
+        filename: "test.txt",
+        file: new stream_1.Readable({ read() { } }),
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        fileStorage = new file_storage_1.FileStorage();
+        mockFs.existsSync.mockReturnValue(false);
+        mockFs.createWriteStream.mockReturnValue({});
+        mockFs.createReadStream.mockReturnValue({});
+        mockFs.unlinkSync.mockImplementation(() => { });
+        mockFs.mkdirSync.mockImplementation(() => undefined);
+    });
+    describe("save", () => {
+        it("should save a file successfully", async () => {
+            await expect(fileStorage.save(testFile)).resolves.toEqual(testFile);
+        });
+        it("should throw SystemUseError if file exists and overwrite is false", async () => {
+            mockFs.existsSync.mockReturnValue(true);
+            await expect(fileStorage.save(testFile, { overwrite: false })).rejects.toThrow(system_exception_1.SystemUseError);
+        });
+        it("should throw SystemUseError on pipeline error", async () => {
+            promises_1.pipeline.mockImplementationOnce(() => {
+                throw new Error("Pipeline failed");
+            });
+            await expect(fileStorage.save(testFile)).rejects.toThrow(system_exception_1.SystemUseError);
+        });
+    });
+    describe("remove", () => {
+        it("should remove a file successfully", async () => {
+            mockFs.existsSync.mockReturnValue(true);
+            await expect(fileStorage.remove("test.txt")).resolves.toBeUndefined();
+            expect(mockFs.unlinkSync).toHaveBeenCalled();
+        });
+        it("should throw SystemUseError if file does not exist", async () => {
+            mockFs.existsSync.mockReturnValue(false);
+            await expect(fileStorage.remove("test.txt")).rejects.toThrow(system_exception_1.SystemUseError);
+        });
+    });
+    describe("saveAll", () => {
+        it("should save multiple files successfully", async () => {
+            const files = [
+                { ...testFile, filename: "a.txt" },
+                { ...testFile, filename: "b.txt" },
+            ];
+            await expect(fileStorage.saveAll(files)).resolves.toEqual(files);
+        });
+        it("should throw SystemUseError on error", async () => {
+            promises_1.pipeline.mockImplementationOnce(() => {
+                throw new Error("Pipeline failed");
+            });
+            await expect(fileStorage.saveAll([testFile])).rejects.toThrow(system_exception_1.SystemUseError);
+        });
+    });
+    describe("transform", () => {
+        it("should set transform options and return itself", () => {
+            const options = { resize: { width: 100, height: 100 }, format: "jpeg" };
+            const result = fileStorage.transform(options);
+            expect(result).toBe(fileStorage);
+            // @ts-ignore
+            expect(fileStorage.transformOptions).toEqual(options);
+        });
+    });
+    // describe("processImage", () => {
+    //     it("should throw InternalErrorException if sharp is not installed", async () => {
+    //         jest.resetModules();
+    //         const fileStorage = new (require("./file-storage").FileStorage)();
+    //         fileStorage.transform({ format: "jpeg" });
+    //         await expect(
+    //             fileStorage["processImage"](new Readable({ read() {} }), "output.jpg"),
+    //         ).rejects.toThrow(InternalErrorException);
+    //     });
+    // });
+    describe("ensureDirectoryExists", () => {
+        it("should create directory if not exists", async () => {
+            mockFs.existsSync.mockReturnValue(false);
+            await fileStorage["ensureDirectoryExists"]("public/test.txt");
+            expect(mockFs.mkdirSync).toHaveBeenCalled();
+        });
+        it("should not create directory if exists", async () => {
+            mockFs.existsSync.mockReturnValue(true);
+            await fileStorage["ensureDirectoryExists"]("public/test.txt");
+            expect(mockFs.mkdirSync).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/helpers.test.d.ts

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

package/dist/helpers.test.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+describe("helpers.ts", () => {
+    describe("formatUrl", () => {
+        it("should format URLs correctly", () => {
+            expect((0, helpers_1.formatUrl)("test")).toBe("/test");
+            expect((0, helpers_1.formatUrl)("/test")).toBe("/test");
+            expect((0, helpers_1.formatUrl)("///test//")).toBe("/test");
+            expect(() => (0, helpers_1.formatUrl)(123)).toThrow();
+        });
+    });
+    describe("parsedPath", () => {
+        it("should ensure path starts with /", () => {
+            expect((0, helpers_1.parsedPath)("abc")).toBe("/abc");
+            expect((0, helpers_1.parsedPath)("/abc")).toBe("/abc");
+        });
+    });
+    describe("findDuplicates", () => {
+        it("should find duplicates in array", () => {
+            expect((0, helpers_1.findDuplicates)(["a", "b", "a", "c", "b"])).toEqual(["a", "b"]);
+            expect((0, helpers_1.findDuplicates)(["a", "b", "c"])).toEqual([]);
+        });
+    });
+    describe("getDataType", () => {
+        it("should return correct data type", () => {
+            expect((0, helpers_1.getDataType)(String)).toBe("string");
+            expect((0, helpers_1.getDataType)(Number)).toBe("number");
+            expect((0, helpers_1.getDataType)(Boolean)).toBe("boolean");
+            expect((0, helpers_1.getDataType)(Object)).toBe("object");
+            expect((0, helpers_1.getDataType)(Array)).toBe(Array);
+        });
+    });
+    describe("isValidType", () => {
+        it("should validate types correctly", () => {
+            expect((0, helpers_1.isValidType)("abc", String)).toBe(true);
+            expect((0, helpers_1.isValidType)(123, Number)).toBe(true);
+            expect((0, helpers_1.isValidType)(true, Boolean)).toBe(true);
+            expect((0, helpers_1.isValidType)({}, Object)).toBe(true);
+            expect((0, helpers_1.isValidType)(undefined, String)).toBe(true);
+            expect((0, helpers_1.isValidType)(null, Number)).toBe(true);
+            expect((0, helpers_1.isValidType)("123", Number)).toBe(true);
+            expect((0, helpers_1.isValidType)("abc", Number)).toBe(false);
+        });
+    });
+    describe("isValidJsonString", () => {
+        it("should validate JSON strings", () => {
+            expect((0, helpers_1.isValidJsonString)('{"a":1}')).toEqual({ a: 1 });
+            expect((0, helpers_1.isValidJsonString)("not json")).toBe(false);
+        });
+    });
+    describe("jsonToJs", () => {
+        it("should parse JSON to JS object", () => {
+            expect((0, helpers_1.jsonToJs)('{"a":1}')).toEqual({ a: 1 });
+            expect((0, helpers_1.jsonToJs)("bad json")).toBe(false);
+        });
+    });
+    // describe("normalizePath", () => {
+    //     it("should normalize paths", () => {
+    //         expect(normalizePath("api", "v1")).toBe("/api/v1");
+    //         expect(normalizePath("/", "/")).toBe("/");
+    //         expect(normalizePath("api/", "/v1/")).toBe("/api/v1");
+    //     });
+    // });
+    describe("extrctParamFromUrl", () => {
+        it("should extract params from URL", () => {
+            expect((0, helpers_1.extrctParamFromUrl)("/user/:id/:name")).toEqual([
+                { key: "id", required: true },
+                { key: "name", required: true },
+            ]);
+            expect((0, helpers_1.extrctParamFromUrl)("/user/?:id")).toEqual([
+                { key: "id", required: false },
+            ]);
+        });
+    });
+    describe("pick", () => {
+        it("should pick properties from object", () => {
+            const obj = { a: 1, b: { c: 2, d: 3 }, e: 4 };
+            expect((0, helpers_1.pick)(obj, ["a"])).toEqual({ a: 1 });
+            expect((0, helpers_1.pick)(obj, ["b.c"])).toEqual({ b: { c: 2 } });
+            expect((0, helpers_1.pick)(obj, ["b.d", "e"])).toEqual({ b: { d: 3 }, e: 4 });
+        });
+    });
+    describe("exclude", () => {
+        it("should exclude properties from object", () => {
+            const obj = { a: 1, b: { c: 2, d: 3 }, e: 4 };
+            expect((0, helpers_1.exclude)(obj, ["a"])).toEqual({ b: { c: 2, d: 3 }, e: 4 });
+            expect((0, helpers_1.exclude)(obj, ["b.c"])).toEqual({ a: 1, b: { d: 3 }, e: 4 });
+            expect((0, helpers_1.exclude)([obj, obj], ["e"])).toEqual([
+                { a: 1, b: { c: 2, d: 3 } },
+                { a: 1, b: { c: 2, d: 3 } },
+            ]);
+        });
+    });
+});

package/dist/icore.d.ts

@@ -4,7 +4,7 @@
  * @email xtrinsic96@gmail.com
  * @url https://github.com/xtareq
  */
-import { FastifyReply, FastifyRequest, HookHandlerDoneFunction, InjectOptions, LightMyRequestResponse } from "fastify";
+import { FastifyReply, FastifyRequest, HookHandlerDoneFunction, InjectOptions, LightMyRequestResponse, FastifyLoggerOptions } from "fastify";
 import { Constructable } from "typedi";
 import { Constructor } from "./helpers";
 import { PathLike } from "fs";
@@ -62,6 +62,7 @@ export interface ParamMetaFilesOptions {
     fieldName: string;
 }
 export interface MethodParamMeta {
+    request: any[];
     params: ParamMetaOptions[];
     query: ParamMetaOptions[];
     body: ParamMetaOptions[];
@@ -141,6 +142,7 @@ export declare class AvleonApplication {
     private constructor();
     static getApp(): AvleonApplication;
     static getInternalApp(buildOptions: any): AvleonApplication;
+    useLogger<T = FastifyLoggerOptions>(corsOptions?: ConfigInput<T>): void;
     isDevelopment(): boolean;
     private initSwagger;
     private _isConfigClass;
@@ -164,10 +166,10 @@ export declare class AvleonApplication {
      */
     private buildController;
     /**
-     * map all request parameters
-     * @param req
-     * @param meta
-     * @returns
+     * Maps request data to controller method arguments based on decorators
+     * @param req - The incoming request object
+     * @param meta - Metadata about method parameters
+     * @returns Array of arguments to pass to the controller method
      */
     private _mapArgs;
     /**