@avleon/core 0.0.11 → 0.0.13

package/dist/collection.d.ts

@@ -47,6 +47,6 @@ declare class BasicCollection<T> implements ICollection<T> {
 export declare class Collection {
     private constructor();
     static from<T>(items: T[]): BasicCollection<T>;
-    static fromRepositry<T extends ObjectLiteral>(entity: EntityTarget<T>): Repository<T>;
+    static fromRepository<T extends ObjectLiteral>(entity: EntityTarget<T>): Repository<T>;
 }
 export {};

package/dist/collection.js

@@ -282,7 +282,7 @@ class Collection {
     static from(items) {
         return BasicCollection.from(items);
     }
-    static fromRepositry(entity) {
+    static fromRepository(entity) {
         return AsynchronousCollection.fromRepository(entity);
     }
 }

package/dist/file-storage.d.ts

@@ -1,17 +1,34 @@
-import { MultipartFile } from './multipart';
+import { PathLike } from "fs";
+import { MultipartFile } from "./multipart";
 interface TransformOptions {
     resize?: {
         width: number;
         height: number;
     };
-    format?: 'jpeg' | 'png' | 'webp' | 'avif';
+    format?: "jpeg" | "png" | "webp" | "avif";
     quality?: number;
 }
-export declare class FileStorage {
+export interface FileStorageInterface {
+    transform(options: TransformOptions): FileStorage;
+    save(file: MultipartFile, options?: SaveOptionsSingle): Promise<MultipartFile | undefined>;
+    saveAll(files: MultipartFile[], options?: SaveOptions): Promise<MultipartFile[] | undefined>;
+    remove(filepath: PathLike): Promise<void>;
+}
+export interface SaveOptions {
+    overwrite?: boolean;
+    to?: string;
+}
+export interface SaveOptionsSingle extends SaveOptions {
+    saveAs?: string;
+}
+export declare class FileStorage implements FileStorageInterface {
     private transformOptions;
     transform(options: TransformOptions): this;
-    save(f: MultipartFile, options: any): Promise<import("@fastify/multipart").MultipartFile | undefined>;
-    saveAs(f: MultipartFile, filename: string, options: any): Promise<import("@fastify/multipart").MultipartFile | undefined>;
+    private isFileExists;
+    save(f: MultipartFile, options?: SaveOptionsSingle): Promise<import("@fastify/multipart").MultipartFile | undefined>;
+    remove(filepath: PathLike): Promise<void>;
+    saveAll(files: MultipartFile[], options?: SaveOptions): Promise<MultipartFile[]>;
     private processImage;
+    private ensureDirectoryExists;
 }
 export {};

package/dist/file-storage.js

@@ -48,7 +48,7 @@ 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 os_1 = __importDefault(require("os"));
+const system_exception_1 = require("./exceptions/system-exception");
 let FileStorage = class FileStorage {
     constructor() {
         this.transformOptions = null;
@@ -57,77 +57,218 @@ let FileStorage = class FileStorage {
         this.transformOptions = options;
         return this;
     }
+    isFileExists(fpath) {
+        return fs_1.default.existsSync(fpath);
+    }
     async save(f, options) {
-        if (f && f.file) {
-            let fname = f.filename;
-            if (options) {
-                if (options.dest) {
-                    fname = options.saveAs ? options.dest + '/' + options.saveAs : options.dest + '/' + f.filename;
-                }
-                else {
-                    fname = path_1.default.join(process.cwd(), `public/${options.saveAs ? options.saveAs : f.filename}`);
+        let foptions = {
+            overwrite: options && options.overwrite ? options.overwrite : true,
+        };
+        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.");
                 }
-            }
-            else {
-                fname = path_1.default.join(process.cwd(), `public/${f.filename}`);
-            }
-            if (fs_1.default.existsSync(fname) && !options.overwrite) {
-                throw new http_exceptions_1.InternalErrorException("File already exists.");
-            }
-            if (this.transformOptions) {
-                const tempFilePath = path_1.default.join(os_1.default.tmpdir(), `temp-${Date.now()}-${f.filename}`);
-                await (0, promises_1.pipeline)(f.file, fs_1.default.createWriteStream(tempFilePath));
-                await this.processImage(fs_1.default.createReadStream(tempFilePath), fname);
-                fs_1.default.unlinkSync(tempFilePath);
-            }
-            else {
                 await (0, promises_1.pipeline)(f.file, fs_1.default.createWriteStream(fname));
+                return f;
             }
-            return Object.assign(Object.assign({}, f), { filename: (options === null || options === void 0 ? void 0 : options.saveAs) ? options.saveAs : f.filename });
+        }
+        catch (err) {
+            throw new system_exception_1.SystemUseError("Can't upload file");
         }
     }
-    async saveAs(f, filename, options) {
-        if (f && f.file) {
-            let fname = filename;
-            if (options && options.dest) {
-                fname = options.dest + '/' + filename;
-            }
-            else {
-                fname = path_1.default.join(process.cwd(), `public/${filename}`);
-            }
-            if (fs_1.default.existsSync(fname) && !options.overwrite) {
-                throw new http_exceptions_1.InternalErrorException("File already exists.");
-            }
-            if (this.transformOptions) {
-                await this.processImage(f.file, fname);
-            }
-            else {
-                await (0, promises_1.pipeline)(f.file, fs_1.default.createWriteStream(fname));
+    async remove(filepath) {
+        if (!this.isFileExists(path_1.default.join(process.cwd(), "public/" + filepath))) {
+            throw new system_exception_1.SystemUseError("File doesn't exists.");
+        }
+        return fs_1.default.unlinkSync(path_1.default.join(process.cwd(), "public/" + filepath));
+    }
+    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}`;
+                }
+                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));
+                }
+                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);
+                }
             }
-            return Object.assign(Object.assign({}, f), { filename: filename });
+            return files;
+        }
+        catch (error) {
+            console.error(error);
+            throw new system_exception_1.SystemUseError("Can't upload file");
+        }
+    }
+    /*   private async saveSingleFile(
+      f: MultipartFile,
+      options: any
+    ): Promise<MultipartFile | null> {
+      if (f && f.type == "file") {
+        let fname = f.filename;
+        if (options) {
+          if (options.dest) {
+            fname = options.saveAs
+              ? options.dest + "/" + options.saveAs
+              : options.dest + "/" + f.filename;
+          } else {
+            fname = path.join(
+              process.cwd(),
+              `public/${options.saveAs ? options.saveAs : f.filename}`
+            );
+          }
+        } else {
+          fname = path.join(process.cwd(), `public/${f.filename}`);
+        }
+        await this.ensureDirectoryExists(fname); // Ensure directory exists
+  
+        if (fs.existsSync(fname) && !options.overwrite) {
+          throw new InternalErrorException("File already exists.");
         }
+  
+        if (this.transformOptions) {
+          if (f.type == "file") {
+            const tempFilePath = path.join(
+              os.tmpdir(),
+              `temp-${Date.now()}-${f.filename}`
+            );
+            await pipeline(f.file!, fs.createWriteStream(tempFilePath));
+            await this.processImage(fs.createReadStream(tempFilePath), fname);
+            fs.unlinkSync(tempFilePath);
+          } else if (f.type == "fil") {
+            await this.processImage(fs.createReadStream(f.filepath), fname);
+          }
+        } else {
+          if (f.file) {
+            await pipeline(f.file!, fs.createWriteStream(fname));
+          } else if (f.filepath) {
+            fs.copyFileSync(f.filepath, fname);
+          }
+        }
+        return {
+          ...f,
+          filename: options?.saveAs ? options.saveAs : f.filename,
+        } as MultipartFile;
+      }
+      return null;
+    }
+  
+    async saveAs(
+      f: MultipartFile | MultipartFile[],
+      filename: string | string[],
+      options: any
+    ) {
+      if (
+        Array.isArray(f) &&
+        Array.isArray(filename) &&
+        f.length === filename.length
+      ) {
+        const savedFiles: MultipartFile[] = [];
+        for (let i = 0; i < f.length; i++) {
+          const savedFile = await this.saveSingleFileAs(
+            f[i],
+            filename[i],
+            options
+          );
+          if (savedFile) {
+            savedFiles.push(savedFile);
+          }
+        }
+        return savedFiles;
+      } else if (!Array.isArray(f) && !Array.isArray(filename)) {
+        return await this.saveSingleFileAs(f, filename as string, options);
+      } else {
+        throw new InternalErrorException(
+          "File and filename array lengths do not match."
+        );
+      }
     }
+  
+    private async saveSingleFileAs(
+      f: MultipartFile,
+      filename: string,
+      options: any
+    ): Promise<MultipartFile | null> {
+      if (f) {
+        let fname = filename;
+  
+        if (options && options.dest) {
+          fname = options.dest + "/" + filename;
+        } else {
+          fname = path.join(process.cwd(), `public/${filename}`);
+        }
+        await this.ensureDirectoryExists(fname);
+  
+        if (fs.existsSync(fname) && !options.overwrite) {
+          throw new InternalErrorException("File already exists.");
+        }
+  
+        if (this.transformOptions) {
+          if (f.file) {
+            const tempFilePath = path.join(
+              os.tmpdir(),
+              `temp-${Date.now()}-${f.filename}`
+            );
+            await pipeline(f.file!, fs.createWriteStream(tempFilePath));
+            await this.processImage(fs.createReadStream(tempFilePath), fname);
+            fs.unlinkSync(tempFilePath);
+          } else if (f.filepath) {
+            await this.processImage(fs.createReadStream(f.filepath), fname);
+          }
+        } else {
+          if (f.file) {
+            await pipeline(f.file!, fs.createWriteStream(fname));
+          } else if (f.filepath) {
+            fs.copyFileSync(f.filepath, fname);
+          }
+        }
+  
+        return { ...f, filename: filename } as MultipartFile;
+      }
+      return null;
+    }
+   */
     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"))); // Lazy import 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);
             }
             if ((_b = this.transformOptions) === null || _b === void 0 ? void 0 : _b.format) {
                 switch (this.transformOptions.format) {
-                    case 'jpeg':
-                        sharpPipeline = sharpPipeline.jpeg({ quality: this.transformOptions.quality || 80 });
+                    case "jpeg":
+                        sharpPipeline = sharpPipeline.jpeg({
+                            quality: this.transformOptions.quality || 80,
+                        });
                         break;
-                    case 'png':
-                        sharpPipeline = sharpPipeline.png({ quality: this.transformOptions.quality || 80 });
+                    case "png":
+                        sharpPipeline = sharpPipeline.png({
+                            quality: this.transformOptions.quality || 80,
+                        });
                         break;
-                    case 'webp':
-                        sharpPipeline = sharpPipeline.webp({ quality: this.transformOptions.quality || 80 });
+                    case "webp":
+                        sharpPipeline = sharpPipeline.webp({
+                            quality: this.transformOptions.quality || 80,
+                        });
                         break;
-                    case 'avif':
-                        sharpPipeline = sharpPipeline.avif({ quality: this.transformOptions.quality || 80 });
+                    case "avif":
+                        sharpPipeline = sharpPipeline.avif({
+                            quality: this.transformOptions.quality || 80,
+                        });
                         break;
                     default:
                         break;
@@ -136,16 +277,23 @@ let FileStorage = class FileStorage {
             await (0, promises_1.pipeline)(fileStream, sharpPipeline, fs_1.default.createWriteStream(outputPath));
         }
         catch (error) {
-            if (error.code === 'MODULE_NOT_FOUND' && error.message.includes('sharp')) {
-                throw new http_exceptions_1.InternalErrorException('sharp module not found. Please install sharp to use image transformations.');
+            if (error.code === "MODULE_NOT_FOUND" &&
+                error.message.includes("sharp")) {
+                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.');
+            console.error("Image processing failed:", error);
+            throw new http_exceptions_1.InternalErrorException("Image processing failed.");
         }
         finally {
             this.transformOptions = null; // Reset transform options after processing
         }
     }
+    async ensureDirectoryExists(filePath) {
+        const dir = path_1.default.dirname(filePath);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+    }
 };
 exports.FileStorage = FileStorage;
 exports.FileStorage = FileStorage = __decorate([

package/dist/icore.d.ts

@@ -41,6 +41,12 @@ export interface ParamMetaOptions {
     validatorClass: boolean;
     type: "route:param" | "route:query" | "route:body" | "route:header" | "route:user" | "route:file" | "route:files";
 }
+export interface ParamMetaFilesOptions {
+    index: number;
+    type: "route:files";
+    files: MultipartFile[];
+    fieldName: string;
+}
 export interface MethodParamMeta {
     params: ParamMetaOptions[];
     query: ParamMetaOptions[];
@@ -49,7 +55,7 @@ export interface MethodParamMeta {
     currentUser: ParamMetaOptions[];
     swagger?: OpenApiUiOptions;
     file?: any[];
-    files?: MultipartFile[];
+    files?: ParamMetaFilesOptions[];
 }
 type StaticFileOptions = {
     path?: PathLike;

package/dist/icore.js

@@ -193,7 +193,6 @@ class AvleonApplication {
             return;
         const prototype = Object.getPrototypeOf(ctrl);
         const methods = Object.getOwnPropertyNames(prototype).filter((name) => name !== "constructor");
-        let classMiddlewares = [];
         const tag = ctrl.constructor.name.replace("Controller", "");
         const swaggerControllerMeta = Reflect.getMetadata("controller:openapi", ctrl.constructor) || {};
         const authClsMeata = Reflect.getMetadata(container_1.AUTHORIZATION_META_KEY, ctrl.constructor) || { authorize: false, options: undefined };
@@ -279,7 +278,7 @@ class AvleonApplication {
      * @returns
      */
     async _mapArgs(req, meta) {
-        var _a, e_2, _b, _c;
+        var _a, e_2, _b, _c, _d, e_3, _e, _f;
         if (!req.hasOwnProperty("_argsCache")) {
             Object.defineProperty(req, "_argsCache", {
                 value: new Map(),
@@ -293,15 +292,15 @@ class AvleonApplication {
         }
         const args = meta.params.map((p) => req.params[p.key] || null);
         meta.query.forEach((q) => (args[q.index] = q.key === "all" ? req.query : req.query[q.key]));
-        meta.body.forEach((body) => (args[body.index] = req.body));
+        meta.body.forEach((body) => (args[body.index] = Object.assign(Object.assign({}, req.body), req.formData)));
         meta.currentUser.forEach((user) => (args[user.index] = req.user));
         meta.headers.forEach((header) => (args[header.index] =
             header.key === "all" ? req.headers : req.headers[header.key]));
         if (meta.file) {
             try {
-                for (var _d = true, _e = __asyncValues(meta.file), _f; _f = await _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
+                for (var _g = true, _h = __asyncValues(meta.file), _j; _j = await _h.next(), _a = _j.done, !_a; _g = true) {
+                    _c = _j.value;
+                    _g = false;
                     let f = _c;
                     args[f.index] = await req.file();
                 }
@@ -309,11 +308,48 @@ class AvleonApplication {
             catch (e_2_1) { e_2 = { error: e_2_1 }; }
             finally {
                 try {
-                    if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+                    if (!_g && !_a && (_b = _h.return)) await _b.call(_h);
                 }
                 finally { if (e_2) throw e_2.error; }
             }
         }
+        if (meta.files) {
+            const files = await req.saveRequestFiles();
+            if (!files || files.length === 0) {
+                throw new exceptions_1.BadRequestException({ error: "No files uploaded" });
+            }
+            const fileInfo = files.map((file) => ({
+                type: file.type,
+                filepath: file.filepath,
+                fieldname: file.fieldname,
+                filename: file.filename,
+                encoding: file.encoding,
+                mimetype: file.mimetype,
+                fields: file.fields,
+            }));
+            try {
+                for (var _k = true, _l = __asyncValues(meta.files), _m; _m = await _l.next(), _d = _m.done, !_d; _k = true) {
+                    _f = _m.value;
+                    _k = false;
+                    let f = _f;
+                    const findex = fileInfo.findIndex((x) => x.fieldname == f.fieldName);
+                    if (f.fieldName != "all" && findex == -1) {
+                        throw new exceptions_1.BadRequestException(`${f.fieldName} doesn't exists in request files tree.`);
+                    }
+                    args[f.index] =
+                        f.fieldName == "all"
+                            ? fileInfo
+                            : fileInfo.filter((x) => x.fieldname == f.fieldName);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (!_k && !_d && (_e = _l.return)) await _e.call(_l);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+        }
         cache.set(cacheKey, args);
         return args;
     }
@@ -579,7 +615,7 @@ class TestBuilder {
     }
     async getTestApplication(options) {
         const app = AvleonApplication.getInternalApp({
-            dataSourceOptions: this.dataSourceOptions
+            dataSourceOptions: this.dataSourceOptions,
         });
         app.mapControllers([...options.controllers]);
         const fa = await app.getTestApp();

package/dist/multipart.d.ts

@@ -4,14 +4,14 @@
  * @email xtrinsic96@gmail.com
  * @url https://github.com/xtareq
  */
-import { MultipartFile as FsM } from "@fastify/multipart";
+import { MultipartFile as FsM, SavedMultipartFile } from "@fastify/multipart";
 import { IRequest } from "./icore";
 export declare function UploadFile(fieldName: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-export declare function UploadFiles(fieldName: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare function UploadFiles(fieldName?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
 type Foptions = {
     saveAs?: string;
     dest?: true;
 };
-export type MultipartFile = FsM;
+export type MultipartFile = FsM | SavedMultipartFile;
 export declare function UploadFileFromRequest(req: IRequest, options?: Foptions): Promise<FsM | undefined>;
 export {};

package/dist/multipart.js

@@ -33,7 +33,10 @@ function UploadFiles(fieldName) {
             Reflect.defineMetadata(container_1.REQUEST_BODY_FILES_KEY, [], target, propertyKey);
         }
         const existingMetadata = Reflect.getMetadata(container_1.REQUEST_BODY_FILES_KEY, target, propertyKey);
-        existingMetadata.push({ fieldName, index: parameterIndex });
+        existingMetadata.push({
+            fieldName: fieldName ? fieldName : "all",
+            index: parameterIndex,
+        });
         Reflect.defineMetadata(container_1.REQUEST_BODY_FILES_KEY, existingMetadata, target, propertyKey);
     };
 }
@@ -43,7 +46,9 @@ function UploadFileFromRequest(req, options) {
             let fname = f.filename;
             if (options) {
                 if (options.dest) {
-                    fname = options.saveAs ? options.dest + '/' + options.saveAs : options.dest + '/' + f.filename;
+                    fname = options.saveAs
+                        ? options.dest + "/" + options.saveAs
+                        : options.dest + "/" + f.filename;
                 }
                 else {
                     fname = path_1.default.join(process.cwd(), `public/${options.saveAs ? options.saveAs : f.filename}`);

package/dist/response.d.ts

@@ -11,6 +11,15 @@ export interface IHttpResponse<T extends any> {
     data: T | null;
 }
 export declare class HttpResponse {
-    static Ok<T>(obj: any, s?: ClassConstructor<T>): any;
-    static NoContent(): void;
+    static Ok<T>(obj: any, s?: ClassConstructor<T>): IHttpResponse<T>;
+    static Created<T>(obj: any, s?: ClassConstructor<T>): IHttpResponse<T>;
+    static NoContent(): IHttpResponse<null>;
+    static BadRequest(message: string, data?: any): IHttpResponse<any>;
+    static Unauthorized(message: string, data?: any): IHttpResponse<any>;
+    static Forbidden(message: string, data?: any): IHttpResponse<any>;
+    static NotFound(message: string, data?: any): IHttpResponse<any>;
+    static InternalServerError(message?: string, data?: any): IHttpResponse<any>;
+    static Conflict(message: string, data?: any): IHttpResponse<any>;
+    static UnprocessableEntity(message: string, data?: any): IHttpResponse<any>;
+    static TooManyRequests(message: string, data?: any): IHttpResponse<any>;
 }

package/dist/response.js

@@ -22,16 +22,56 @@ class HttpResponse {
     static Ok(obj, s) {
         if (s) {
             const isPaginated = obj === null || obj === void 0 ? void 0 : obj.hasOwnProperty("total");
-            // Ensure transformation applies only allowed properties
-            const transformedData = (0, class_transformer_1.plainToInstance)(s, isPaginated ? obj.data : obj, {
+            const dataToTransform = isPaginated ? obj.data : obj;
+            const transformedData = (0, class_transformer_1.plainToInstance)(s, dataToTransform, {
                 enableImplicitConversion: true,
-                excludeExtraneousValues: true, // Ensures only @Expose() properties are included
+                excludeExtraneousValues: true,
             });
-            return Object.assign({ message: "success" }, (isPaginated
-                ? Object.assign(Object.assign({}, obj), { data: (0, class_transformer_1.instanceToPlain)(transformedData) }) : { data: (0, class_transformer_1.instanceToPlain)(transformedData) }));
+            const transformedResult = isPaginated
+                ? Object.assign(Object.assign({}, obj), { data: (0, class_transformer_1.instanceToPlain)(transformedData) }) : { data: (0, class_transformer_1.instanceToPlain)(transformedData) };
+            return Object.assign({ message: "success" }, transformedResult);
         }
         return { message: "success", data: obj };
     }
-    static NoContent() { }
+    static Created(obj, s) {
+        if (s) {
+            const transformedData = (0, class_transformer_1.plainToInstance)(s, obj, {
+                enableImplicitConversion: true,
+                excludeExtraneousValues: true,
+            });
+            return {
+                message: "created",
+                data: (0, class_transformer_1.instanceToPlain)(transformedData),
+            };
+        }
+        return { message: "created", data: obj };
+    }
+    static NoContent() {
+        return { message: "no content", data: null };
+    }
+    static BadRequest(message, data = null) {
+        return { message: message, data: data };
+    }
+    static Unauthorized(message, data = null) {
+        return { message: message, data: data };
+    }
+    static Forbidden(message, data = null) {
+        return { message: message, data: data };
+    }
+    static NotFound(message, data = null) {
+        return { message: message, data: data };
+    }
+    static InternalServerError(message = "Internal server error", data = null) {
+        return { message: message, data: data };
+    }
+    static Conflict(message, data = null) {
+        return { message: message, data: data };
+    }
+    static UnprocessableEntity(message, data = null) {
+        return { message: message, data: data };
+    }
+    static TooManyRequests(message, data = null) {
+        return { message: message, data: data };
+    }
 }
 exports.HttpResponse = HttpResponse;

package/package.json

@@ -1,54 +1,52 @@
-{
-  "name": "@avleon/core",
-  "version": "0.0.11",
-  "main": "./dist/index.js",
-  "types": [
-    "./dist/index.d.ts",
-    "./exceptions/index.d.ts"
-  ],
-  "scripts": {
-    "build": "rimraf dist && tsc",
-    "watch": "tsc-watch",
-    "test": "jest",
-    "test:watch": "jest --watch"
-  },
-  "keywords": [],
-  "author": "Tareq Hossain",
-  "license": "ISC",
-  "devDependencies": {
-    "@types/jest": "^29.5.14",
-    "class-transformer": "^0.5.1",
-    "class-validator": "^0.14.1",
-    "jest": "^29.7.0",
-    "nodemon": "^3.1.7",
-    "sharp": "^0.33.5",
-    "ts-jest": "^29.2.5",
-    "ts-node": "^10.9.2",
-    "tsc-watch": "^6.2.1",
-    "typeorm": "^0.3.20",
-    "typescript": "^5.7.2"
-  },
-  "dependencies": {
-    "@fastify/cors": "^11.0.0",
-    "@fastify/multipart": "^9.0.3",
-    "@fastify/static": "^8.1.1",
-    "@fastify/swagger": "^9.4.0",
-    "@fastify/swagger-ui": "^5.1.0",
-    "bcryptjs": "^3.0.2",
-    "dotenv": "^16.4.7",
-    "fastify": "^5.1.0",
-    "reflect-metadata": "^0.2.2",
-    "typedi": "^0.10.0"
-  },
-  "peerDependencies": {
-    "typeorm": "^0.3.20"
-  },
-  "directories": {
-    "test": "tests"
-  },
-  "description": "avleon core",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/avleonjs/avleon-core"
-  }
+{
+  "name": "@avleon/core",
+  "version": "0.0.13",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "rimraf dist && tsc",
+    "watch": "tsc-watch",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "keywords": [],
+  "author": "Tareq Hossain",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "jest": "^29.7.0",
+    "nodemon": "^3.1.7",
+    "sharp": "^0.33.5",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "tsc-watch": "^6.2.1",
+    "typeorm": "^0.3.20",
+    "typescript": "^5.7.2"
+  },
+  "dependencies": {
+    "@fastify/cors": "^11.0.0",
+    "@fastify/multipart": "^9.0.3",
+    "@fastify/static": "^8.1.1",
+    "@fastify/swagger": "^9.4.0",
+    "@fastify/swagger-ui": "^5.1.0",
+    "bcryptjs": "^3.0.2",
+    "dotenv": "^16.4.7",
+    "fastify": "^5.1.0",
+    "reflect-metadata": "^0.2.2",
+    "typedi": "^0.10.0"
+  },
+  "peerDependencies": {
+    "typeorm": "^0.3.20",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1"
+  },
+  "directories": {
+    "test": "tests"
+  },
+  "description": "avleon core",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/avleonjs/avleon-core"
+  }
 }