@avleon/core 0.0.12 → 0.0.14

package/dist/classToOpenapi.js

@@ -0,0 +1 @@
+"use strict";

package/dist/exceptions/http-exceptions.d.ts

@@ -39,12 +39,3 @@ export declare class ForbiddenException extends BaseHttpException {
     constructor(message: any);
 }
 export type HttpException = NotFoundException | BadRequestException | UnauthorizedException | InternalErrorException | ForbiddenException;
-export type HttpExceptions = {
-    NotFound: (message: any) => NotFoundException;
-    ValidationError: (message: any) => ValidationErrorException;
-    BadRequest: (message: any) => BadRequestException;
-    Unauthorized: (message: any) => UnauthorizedException;
-    Forbidden: (message: any) => ForbiddenException;
-    InternalError: (message: any) => InternalErrorException;
-};
-export declare const httpExcepitoins: HttpExceptions;

package/dist/exceptions/http-exceptions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.httpExcepitoins = exports.ForbiddenException = exports.UnauthorizedException = exports.NotFoundException = exports.InternalErrorException = exports.ValidationErrorException = exports.BadRequestException = exports.BaseHttpException = void 0;
+exports.ForbiddenException = exports.UnauthorizedException = exports.NotFoundException = exports.InternalErrorException = exports.ValidationErrorException = exports.BadRequestException = exports.BaseHttpException = void 0;
 /**
  * @copyright 2024
  * @author Tareq Hossain
@@ -65,11 +65,19 @@ class ForbiddenException extends BaseHttpException {
     }
 }
 exports.ForbiddenException = ForbiddenException;
-exports.httpExcepitoins = {
-    NotFound: (message) => new NotFoundException(message),
-    ValidationError: (message) => new ValidationErrorException(message),
-    BadRequest: (message) => new BadRequestException(message),
-    Unauthorized: (message) => new UnauthorizedException(message),
-    Forbidden: (message) => new ForbiddenException(message),
-    InternalError: (message) => new InternalErrorException(message)
-};
+// export type HttpExceptions = {
+//   NotFound: (message: any) => NotFoundException,
+//   ValidationError: (message: any) =>ValidationErrorException,
+//   BadRequest: (message: any) => BadRequestException,
+//   Unauthorized: (message: any) => UnauthorizedException,
+//   Forbidden: (message: any) => ForbiddenException,
+//   InternalError: (message: any) => InternalErrorException
+// }
+// export const httpExcepitoins: HttpExceptions = {
+//   NotFound:(message:any)=>new NotFoundException(message),
+//   ValidationError:(message:any)=>new ValidationErrorException(message),
+//   BadRequest:(message:any)=>new BadRequestException(message),
+//   Unauthorized:(message:any)=>new UnauthorizedException(message),
+//   Forbidden:(message:any)=>new ForbiddenException(message),
+//   InternalError: (message:any)=> new InternalErrorException(message)
+// }

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/helpers.d.ts

@@ -23,10 +23,10 @@ export declare function jsonToJs(value: string): any;
 export declare function jsonToInstance(value: string, instance: Constructor): any;
 export declare function transformObjectByInstanceToObject(instance: Constructor, value: object): Record<string, any>;
 export declare const isClassValidatorClass: (target: Constructor) => boolean;
-export declare function validateObjectByInstance(target: Constructor, value?: object, options?: 'object' | 'array'): Promise<any>;
+export declare function validateObjectByInstance(target: Constructor, value?: object, options?: "object" | "array"): Promise<any>;
 type ValidationError = {
     count: number;
     errors: any;
 };
-export declare function validateRequestBody(target: Constructor, value: object, options?: 'object' | 'array'): ValidationError;
+export declare function validateRequestBody(target: Constructor, value: object, options?: "object" | "array"): ValidationError;
 export {};

package/dist/helpers.js

@@ -43,7 +43,7 @@ function inject(cls) {
 }
 function isConstructor(func) {
     // Check if the func is a function
-    if (typeof func !== 'function') {
+    if (typeof func !== "function") {
         return false;
     }
     // Check if it's an arrow function or a built-in JavaScript function
@@ -51,13 +51,13 @@ function isConstructor(func) {
         return false;
     }
     // Check if it has a `prototype` property
-    if (func.prototype && typeof func.prototype === 'object') {
+    if (func.prototype && typeof func.prototype === "object") {
         return true;
     }
     // If it's not a constructor, check if it can be called with the new keyword
     try {
         const instance = new func();
-        return typeof instance === 'object';
+        return typeof instance === "object";
     }
     catch (e) {
         return false;
@@ -83,8 +83,7 @@ function parsedPath(ipath) {
 const isClassValidator = (target) => {
     try {
         const clsval = require("class-validator");
-        const result = (0, class_validator_1.getMetadataStorage)()
-            .getTargetValidationMetadatas(target, '', false, false);
+        const result = (0, class_validator_1.getMetadataStorage)().getTargetValidationMetadatas(target, "", false, false);
         return result.length > 0;
     }
     catch (err) {
@@ -216,7 +215,7 @@ const isClassValidatorClass = (target) => {
     }
 };
 exports.isClassValidatorClass = isClassValidatorClass;
-async function validateObjectByInstance(target, value = {}, options = 'array') {
+async function validateObjectByInstance(target, value = {}, options = "array") {
     try {
         const { validateOrReject } = require("class-validator");
         const { plainToInstance } = require("class-transformer");
@@ -224,11 +223,16 @@ async function validateObjectByInstance(target, value = {}, options = 'array') {
     }
     catch (error) {
         if (typeof error == "object" && Array.isArray(error)) {
-            const errors = options == 'object' ? error.reduce((acc, x) => {
-                //acc[x.property] = Object.values(x.constraints);
-                acc[x.property] = x.constraints;
-                return acc;
-            }, {}) : error.map(x => ({ path: x.property, constraints: x.constraints }));
+            const errors = options == "object"
+                ? error.reduce((acc, x) => {
+                    //acc[x.property] = Object.values(x.constraints);
+                    acc[x.property] = x.constraints;
+                    return acc;
+                }, {})
+                : error.map((x) => ({
+                    path: x.property,
+                    constraints: x.constraints,
+                }));
             return errors;
         }
         else {
@@ -236,14 +240,16 @@ async function validateObjectByInstance(target, value = {}, options = 'array') {
         }
     }
 }
-function validateRequestBody(target, value, options = 'array') {
+function validateRequestBody(target, value, options = "array") {
     if (!(0, exports.isClassValidatorClass)(target))
         return { count: 0, errors: {} };
     const error = (0, class_validator_1.validateSync)((0, class_transformer_1.plainToInstance)(target, value ? value : {}));
-    const errors = options == 'object' ? error.reduce((acc, x) => {
-        //acc[x.property] = Object.values(x.constraints);
-        acc[x.property] = x.constraints;
-        return acc;
-    }, {}) : error.map(x => ({ path: x.property, constraints: x.constraints }));
+    const errors = options == "object"
+        ? error.reduce((acc, x) => {
+            //acc[x.property] = Object.values(x.constraints);
+            acc[x.property] = x.constraints;
+            return acc;
+        }, {})
+        : error.map((x) => ({ path: x.property, constraints: x.constraints }));
     return { count: error.length, errors };
 }

package/dist/icore.d.ts

@@ -4,7 +4,7 @@
  * @email xtrinsic96@gmail.com
  * @url https://github.com/xtareq
  */
-import { FastifyInstance, FastifyReply, FastifyRequest, HookHandlerDoneFunction } from "fastify";
+import { FastifyReply, FastifyRequest, HookHandlerDoneFunction, InjectOptions, LightMyRequestResponse } from "fastify";
 import { Constructable } from "typedi";
 import { Constructor } from "./helpers";
 import { PathLike } from "fs";
@@ -27,9 +27,19 @@ export interface IRequest extends FastifyRequest {
     headers: any;
     user?: any;
 }
+export interface DoneFunction extends HookHandlerDoneFunction {
+}
 export interface IResponse extends FastifyReply {
 }
-export interface DoneFunction extends HookHandlerDoneFunction {
+export type TestResponseType = LightMyRequestResponse;
+export type TestResponse = TestResponseType | Promise<TestResponseType>;
+export interface TestApplication {
+    get: (url: string, options?: InjectOptions) => TestResponse;
+    post: (url: string, options?: InjectOptions) => TestResponse;
+    put: (url: string, options?: InjectOptions) => TestResponse;
+    patch: (url: string, options?: InjectOptions) => TestResponse;
+    delete: (url: string, options?: InjectOptions) => TestResponse;
+    options: (url: string, options?: InjectOptions) => TestResponse;
 }
 export interface ParamMetaOptions {
     index: number;
@@ -39,8 +49,15 @@ export interface ParamMetaOptions {
     validate: boolean;
     dataType: any;
     validatorClass: boolean;
+    schema?: any;
     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 +66,7 @@ export interface MethodParamMeta {
     currentUser: ParamMetaOptions[];
     swagger?: OpenApiUiOptions;
     file?: any[];
-    files?: MultipartFile[];
+    files?: ParamMetaFilesOptions[];
 }
 type StaticFileOptions = {
     path?: PathLike;
@@ -58,7 +75,6 @@ type StaticFileOptions = {
 type MultipartOptions = {
     destination: PathLike;
 } & FastifyMultipartOptions;
-type AvleonApp = FastifyInstance;
 export type TestAppOptions = {
     controllers: Constructor[];
 };
@@ -72,7 +88,7 @@ export interface IAvleonApplication {
     useCors(corsOptions?: FastifyCorsOptions): void;
     useOpenApi<T extends IConfig<R>, R = ReturnType<InstanceType<Constructable<T>>["config"]>>(ConfigClass: Constructable<T>, modifyConfig?: (config: R) => R): void;
     useSwagger(options: OpenApiUiOptions): Promise<void>;
-    useMultipart(options: MultipartOptions): IAvleonApplication;
+    useMultipart(options: MultipartOptions): void;
     useMiddlewares<T extends AppMiddleware>(mclasses: Constructor<T>[]): void;
     useAuthoriztion<T extends any>(middleware: Constructor<T>): void;
     mapRoute<T extends (...args: any[]) => any>(method: "get" | "post" | "put" | "delete", path: string, fn: T): Promise<void>;
@@ -83,7 +99,7 @@ export interface IAvleonApplication {
     mapControllers(controllers: any[]): any;
     useStaticFiles(options?: StaticFileOptions): void;
     run(port?: number): Promise<void>;
-    getTestApp(): any;
+    getTestApp(): TestApplication;
 }
 declare class AvleonApplication implements IAvleonApplication {
     private static instance;
@@ -114,7 +130,7 @@ declare class AvleonApplication implements IAvleonApplication {
      * Will remove in next major version
      */
     useSwagger(options: OpenApiUiOptions): Promise<void>;
-    useMultipart(options: MultipartOptions): this;
+    useMultipart(options: MultipartOptions): void;
     private handleMiddlewares;
     private executeMiddlewares;
     /**
@@ -167,7 +183,7 @@ declare class AvleonApplication implements IAvleonApplication {
     useStaticFiles(options?: StaticFileOptions): void;
     initializeDatabase(): Promise<void>;
     run(port?: number): Promise<void>;
-    getTestApp(buildOptions?: any): Promise<any>;
+    getTestApp(buildOptions?: any): TestApplication;
 }
 export type Application = typeof AvleonApplication;
 export interface ITestBuilder {
@@ -187,11 +203,11 @@ export declare class TestBuilder {
     static createBuilder(): TestBuilder;
     getController<T>(controller: Constructor<T>): T;
     getService<T>(service: Constructor<T>): T;
-    getTestApplication(options: TestAppOptions): Promise<AvleonApp>;
-    build(app: IAvleonApplication): any;
-    fromApplication(app: IAvleonApplication): any;
+    getTestApplication(options: TestAppOptions): TestApplication;
+    build(app: IAvleonApplication): TestApplication;
+    fromApplication(app: IAvleonApplication): TestApplication;
 }
-export declare class Builder implements ITestBuilder, IAppBuilder {
+export declare class Builder implements IAppBuilder {
     private static instance;
     private alreadyBuilt;
     private database;
@@ -201,12 +217,9 @@ export declare class Builder implements ITestBuilder, IAppBuilder {
     private testBuilder;
     private appConfig;
     private constructor();
-    getTestApplication(): AvleonTestAppliction;
     static createAppBuilder(): Builder;
-    static creatTestAppBuilder(): ITestBuilder;
     registerPlugin<T extends Function, S extends {}>(plugin: T, options: S): Promise<void>;
     addDataSource<T extends IConfig<R>, R = ReturnType<InstanceType<Constructable<T>>["config"]>>(ConfigClass: Constructable<T>, modifyConfig?: (config: R) => R): void;
-    createTestApplication<T extends AvleonTestAppliction>(buildOptions?: any): any;
     build<T extends IAvleonApplication>(): T;
 }
 export {};