@avleon/core 0.0.25 → 0.0.26

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

@@ -38,4 +38,12 @@ export declare class ForbiddenException extends BaseHttpException {
     code: number;
     constructor(message: any);
 }
-export type HttpException = NotFoundException | BadRequestException | UnauthorizedException | InternalErrorException | ForbiddenException;
+export type HttpExceptionTypes = NotFoundException | BadRequestException | UnauthorizedException | InternalErrorException | ForbiddenException;
+export declare const 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;
+};

package/dist/exceptions/http-exceptions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ForbiddenException = exports.UnauthorizedException = exports.NotFoundException = exports.InternalErrorException = exports.ValidationErrorException = exports.BadRequestException = exports.BaseHttpException = void 0;
+exports.HttpExceptions = exports.ForbiddenException = exports.UnauthorizedException = exports.NotFoundException = exports.InternalErrorException = exports.ValidationErrorException = exports.BadRequestException = exports.BaseHttpException = void 0;
 /**
  * @copyright 2024
  * @author Tareq Hossain
@@ -73,11 +73,11 @@ exports.ForbiddenException = ForbiddenException;
 //   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)
-// }
+exports.HttpExceptions = {
+    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)
+};

package/dist/icore.d.ts

@@ -112,6 +112,8 @@ export interface IAvleonApplication {
 }
 type OpenApiConfigClass<T = any> = Constructable<IConfig<T>>;
 type OpenApiConfigInput<T = any> = OpenApiConfigClass<T> | T;
+type ConfigClass<T = any> = Constructable<IConfig<T>>;
+type ConfigInput<T = any> = ConfigClass<T> | T;
 export declare class AvleonApplication {
     private static instance;
     private static buildOptions;
@@ -134,71 +136,18 @@ export declare class AvleonApplication {
     private metaCache;
     private multipartOptions;
     private constructor();
-    private isTest;
     static getApp(): AvleonApplication;
     static getInternalApp(buildOptions: any): AvleonApplication;
     isDevelopment(): boolean;
     private initSwagger;
-    useCors(corsOptions?: FastifyCorsOptions): void;
-    useOpenApi<T = OpenApiUiOptions>(configOrClass: OpenApiConfigInput<T>, modifyConfig?: (config: T) => T): void;
-    /**
-     * Registers the fastify-multipart plugin with the Fastify instance.
-     * This enables handling of multipart/form-data requests, typically used for file uploads.
-     *
-     * @param {MultipartOptions} options - Options to configure the fastify-multipart plugin.
-     * @param {FastifyInstance} this.app - The Fastify instance to register the plugin with.
-     * @property {MultipartOptions} this.multipartOptions - Stores the provided multipart options.
-     * @see {@link https://github.com/fastify/fastify-multipart} for more details on available options.
-     */
-    useMultipart(options: MultipartOptions): void;
-    /**
-     * Configures and initializes a TypeORM DataSource based on the provided configuration class.
-     * It retrieves the configuration from the application's configuration service and allows for optional modification.
-     * The initialized DataSource is then stored and registered within a dependency injection container.
-     *
-     * @template T - A generic type extending the `IConfig` interface, representing the configuration class.
-     * @template R - A generic type representing the return type of the configuration method of the `ConfigClass`.
-     * @param {Constructable<T>} ConfigClass - The constructor of the configuration class to be used for creating the DataSource.
-     * @param {(config: R) => R} [modifyConfig] - An optional function that takes the initial configuration and returns a modified configuration.
-     * @returns {void}
-     * @property {DataSourceOptions} this.dataSourceOptions - Stores the final DataSource options after potential modification.
-     * @property {DataSource} this.dataSource - Stores the initialized TypeORM DataSource instance.
-     * @see {@link https://typeorm.io/} for more information about TypeORM.
-     */
-    useDataSource<T extends IConfig<R>, R = ReturnType<InstanceType<Constructable<T>>["config"]>>(ConfigClass: Constructable<T>, modifyConfig?: (config: R) => R): void;
-    useCache(options: any): void;
-    /**
-     * Registers an array of middleware classes to be executed before request handlers.
-     * It retrieves instances of the middleware classes from the dependency injection container
-     * and adds them as 'preHandler' hooks to the Fastify application.
-     *
-     * @template T - A generic type extending the `AppMiddleware` interface, representing the middleware class.
-     * @param {Constructor<T>[]} mclasses - An array of middleware class constructors to be registered.
-     * @returns {void}
-     * @property {Map<string, T>} this.middlewares - Stores the registered middleware instances, keyed by their class names.
-     * @see {@link https://www.fastify.io/docs/latest/Reference/Hooks/#prehandler} for more information about Fastify preHandler hooks.
-     */
+    private _isConfigClass;
+    useCors<T = FastifyCorsOptions>(corsOptions?: ConfigInput<T>): void;
+    useOpenApi<T = OpenApiUiOptions>(configOrClass: OpenApiConfigInput<T>): void;
+    useMultipart<T extends MultipartOptions>(options: ConfigInput<T>): void;
+    useDataSource<T extends DataSourceOptions>(options: ConfigInput<T>): void;
+    private _useCache;
     useMiddlewares<T extends AppMiddleware>(mclasses: Constructor<T>[]): void;
-    /**
-     * Registers a middleware constructor to be used for authorization purposes.
-     * The specific implementation and usage of this middleware will depend on the application's authorization logic.
-     *
-     * @template T - A generic type representing the constructor of the authorization middleware.
-     * @param {Constructor<T>} middleware - The constructor of the middleware to be used for authorization.
-     * @returns {void}
-     * @property {any} this.authorizeMiddleware - Stores the constructor of the authorization middleware.
-     */
     useAuthoriztion<T extends any>(middleware: Constructor<T>): void;
-    /**
-     * Registers the `@fastify/static` plugin to serve static files.
-     * It configures the root directory and URL prefix for serving static assets.
-     *
-     * @param {StaticFileOptions} [options={ path: undefined, prefix: undefined }] - Optional configuration for serving static files.
-     * @param {string} [options.path] - The absolute path to the static files directory. Defaults to 'process.cwd()/public'.
-     * @param {string} [options.prefix] - The URL prefix for serving static files. Defaults to '/static/'.
-     * @returns {void}
-     * @see {@link https://github.com/fastify/fastify-static} for more details on available options.
-     */
     useStaticFiles(options?: StaticFileOptions): void;
     private handleMiddlewares;
     private executeMiddlewares;
@@ -262,12 +211,8 @@ export interface IAppBuilder {
     build<T extends IAvleonApplication>(): T;
 }
 export declare class AvleonTest {
-    private static instance;
-    private app;
-    private dataSourceOptions?;
     private constructor();
-    private addDatasource;
-    getController<T>(controller: Constructor<T>, deps?: any[]): T;
+    static getController<T>(controller: Constructor<T>, deps?: any[]): T;
     private getService;
     static createTestApplication(options: TestAppOptions): TestApplication;
     static from(app: AvleonApplication): TestApplication;

package/dist/icore.js

@@ -83,7 +83,6 @@ class AvleonApplication {
         this.app = (0, fastify_1.default)();
         this.appConfig = new config_1.AppConfig();
     }
-    isTest() { }
     static getApp() {
         let isTestEnv = process.env.NODE_ENV == "test";
         if (!AvleonApplication.instance) {
@@ -151,90 +150,69 @@ class AvleonApplication {
             });
         }
     }
-    useCors(corsOptions = {}) {
-        this.app.register(cors_1.default, corsOptions);
+    _isConfigClass(input) {
+        var _a;
+        return (typeof input === 'function' &&
+            typeof input.prototype === 'object' &&
+            ((_a = input.prototype) === null || _a === void 0 ? void 0 : _a.constructor) === input);
+    }
+    useCors(corsOptions) {
+        let coptions = {};
+        if (corsOptions) {
+            if (this._isConfigClass(corsOptions)) {
+                coptions = this.appConfig.get(corsOptions);
+            }
+            else {
+                coptions = corsOptions;
+            }
+        }
+        this.app.register(cors_1.default, coptions);
     }
-    useOpenApi(configOrClass, modifyConfig) {
+    useOpenApi(configOrClass) {
         let openApiConfig;
-        const isClass = (input) => {
-            var _a;
-            return (typeof input === 'function' &&
-                typeof input.prototype === 'object' &&
-                ((_a = input.prototype) === null || _a === void 0 ? void 0 : _a.constructor) === input);
-        };
-        if (isClass(configOrClass)) {
-            // It's a class constructor
+        if (this._isConfigClass(configOrClass)) {
             openApiConfig = this.appConfig.get(configOrClass);
         }
         else {
-            // It's a plain object
             openApiConfig = configOrClass;
         }
-        if (modifyConfig) {
-            this.globalSwaggerOptions = modifyConfig(openApiConfig);
-        }
-        else {
-            this.globalSwaggerOptions = openApiConfig;
-        }
+        this.globalSwaggerOptions = openApiConfig;
         this.hasSwagger = true;
     }
-    /**
-     * Registers the fastify-multipart plugin with the Fastify instance.
-     * This enables handling of multipart/form-data requests, typically used for file uploads.
-     *
-     * @param {MultipartOptions} options - Options to configure the fastify-multipart plugin.
-     * @param {FastifyInstance} this.app - The Fastify instance to register the plugin with.
-     * @property {MultipartOptions} this.multipartOptions - Stores the provided multipart options.
-     * @see {@link https://github.com/fastify/fastify-multipart} for more details on available options.
-     */
     useMultipart(options) {
-        this.multipartOptions = options;
-        this.app.register(multipart_1.default, {
-            ...this.multipartOptions,
-            attachFieldsToBody: true,
-        });
+        let multipartOptions;
+        if (this._isConfigClass(options)) {
+            multipartOptions = this.appConfig.get(options);
+        }
+        else {
+            multipartOptions = options;
+        }
+        if (multipartOptions) {
+            this.multipartOptions = multipartOptions;
+            this.app.register(multipart_1.default, {
+                ...this.multipartOptions,
+                attachFieldsToBody: true,
+            });
+        }
     }
-    /**
-     * Configures and initializes a TypeORM DataSource based on the provided configuration class.
-     * It retrieves the configuration from the application's configuration service and allows for optional modification.
-     * The initialized DataSource is then stored and registered within a dependency injection container.
-     *
-     * @template T - A generic type extending the `IConfig` interface, representing the configuration class.
-     * @template R - A generic type representing the return type of the configuration method of the `ConfigClass`.
-     * @param {Constructable<T>} ConfigClass - The constructor of the configuration class to be used for creating the DataSource.
-     * @param {(config: R) => R} [modifyConfig] - An optional function that takes the initial configuration and returns a modified configuration.
-     * @returns {void}
-     * @property {DataSourceOptions} this.dataSourceOptions - Stores the final DataSource options after potential modification.
-     * @property {DataSource} this.dataSource - Stores the initialized TypeORM DataSource instance.
-     * @see {@link https://typeorm.io/} for more information about TypeORM.
-     */
-    useDataSource(ConfigClass, modifyConfig) {
-        const dsConfig = this.appConfig.get(ConfigClass);
-        if (modifyConfig) {
-            const modifiedConfig = modifyConfig(dsConfig);
-            this.dataSourceOptions = modifiedConfig;
+    useDataSource(options) {
+        let dataSourceOptions;
+        if (this._isConfigClass(options)) {
+            dataSourceOptions = this.appConfig.get(options);
         }
         else {
-            this.dataSourceOptions = dsConfig;
+            dataSourceOptions = options;
         }
+        if (!dataSourceOptions)
+            throw new system_exception_1.SystemUseError("Invlaid datasource options.");
+        this.dataSourceOptions = dataSourceOptions;
         const typeorm = require("typeorm");
-        const datasource = new typeorm.DataSource(dsConfig);
+        const datasource = new typeorm.DataSource(dataSourceOptions);
         this.dataSource = datasource;
         typedi_1.default.set("idatasource", datasource);
     }
-    useCache(options) {
+    _useCache(options) {
     }
-    /**
-     * Registers an array of middleware classes to be executed before request handlers.
-     * It retrieves instances of the middleware classes from the dependency injection container
-     * and adds them as 'preHandler' hooks to the Fastify application.
-     *
-     * @template T - A generic type extending the `AppMiddleware` interface, representing the middleware class.
-     * @param {Constructor<T>[]} mclasses - An array of middleware class constructors to be registered.
-     * @returns {void}
-     * @property {Map<string, T>} this.middlewares - Stores the registered middleware instances, keyed by their class names.
-     * @see {@link https://www.fastify.io/docs/latest/Reference/Hooks/#prehandler} for more information about Fastify preHandler hooks.
-     */
     useMiddlewares(mclasses) {
         for (const mclass of mclasses) {
             const cls = typedi_1.default.get(mclass);
@@ -242,28 +220,9 @@ class AvleonApplication {
             this.app.addHook("preHandler", cls.invoke);
         }
     }
-    /**
-     * Registers a middleware constructor to be used for authorization purposes.
-     * The specific implementation and usage of this middleware will depend on the application's authorization logic.
-     *
-     * @template T - A generic type representing the constructor of the authorization middleware.
-     * @param {Constructor<T>} middleware - The constructor of the middleware to be used for authorization.
-     * @returns {void}
-     * @property {any} this.authorizeMiddleware - Stores the constructor of the authorization middleware.
-     */
     useAuthoriztion(middleware) {
         this.authorizeMiddleware = middleware;
     }
-    /**
-     * Registers the `@fastify/static` plugin to serve static files.
-     * It configures the root directory and URL prefix for serving static assets.
-     *
-     * @param {StaticFileOptions} [options={ path: undefined, prefix: undefined }] - Optional configuration for serving static files.
-     * @param {string} [options.path] - The absolute path to the static files directory. Defaults to 'process.cwd()/public'.
-     * @param {string} [options.prefix] - The URL prefix for serving static files. Defaults to '/static/'.
-     * @returns {void}
-     * @see {@link https://github.com/fastify/fastify-static} for more details on available options.
-     */
     useStaticFiles(options = { path: undefined, prefix: undefined }) {
         this.app.register(require("@fastify/static"), {
             root: options.path ? options.path : path_1.default.join(process.cwd(), "public"),
@@ -744,10 +703,7 @@ class AvleonTest {
     constructor() {
         process.env.NODE_ENV = "test";
     }
-    addDatasource(options) {
-        this.dataSourceOptions = options;
-    }
-    getController(controller, deps = []) {
+    static getController(controller, deps = []) {
         const paramTypes = Reflect.getMetadata('design:paramtypes', controller) || [];
         deps.forEach((dep, i) => {
             typedi_1.default.set(paramTypes[i], dep);

package/dist/interfaces/avleon-application.d.ts

@@ -0,0 +1,27 @@
+interface AvleonApplication {
+    useCors: () => void;
+    /**
+     * function for register database
+     * @param options datasource options. options can be plain object or avleon config class
+     * */
+    useDatasource: () => void;
+    useMultipart: () => void;
+    useOpenApi: () => void;
+    useMiddlewares: () => void;
+    useAuthorization: () => void;
+    useSerialization: () => void;
+    useControllers: () => void;
+    useStaticFiles: () => void;
+    /**
+     * @experimental
+     * use https as defalut http protocol
+     * */
+    useHttps: () => void;
+    mapGet: () => void;
+    mapPost: () => void;
+    mapPut: () => void;
+    mapPatch: () => void;
+    mapOptions: () => void;
+    mapGroup: () => void;
+    run: () => void;
+}

package/dist/interfaces/avleon-application.js

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

package/dist/middleware.d.ts

@@ -1,5 +1,5 @@
 import { IRequest, IResponse } from "./icore";
-import { HttpException } from "./exceptions";
+import { HttpExceptionTypes as HttpException } from "./exceptions";
 export declare abstract class AppMiddleware {
     abstract invoke(req: IRequest, res?: IResponse): Promise<IRequest | HttpException>;
 }

package/dist/response.d.ts

@@ -14,13 +14,3 @@ export declare class HttpResponse {
     static Created<T>(obj: any, s?: ClassConstructor<T>): IHttpResponse<T>;
     static NoContent(): IHttpResponse<null>;
 }
-export declare class HttpExceptions {
-    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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpExceptions = exports.HttpResponse = void 0;
+exports.HttpResponse = void 0;
 /**
  * @copyright 2024
  * @author Tareq Hossain
@@ -54,30 +54,3 @@ class HttpResponse {
     }
 }
 exports.HttpResponse = HttpResponse;
-class HttpExceptions {
-    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.HttpExceptions = HttpExceptions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avleon/core",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "main": "./dist/index.js",
   "types": ["./dist/icore.d.ts"],
   "scripts": {

package/src/exceptions/http-exceptions.ts

@@ -61,7 +61,7 @@ export class ForbiddenException extends BaseHttpException {
   }
 }
 
-export type HttpException =
+export type HttpExceptionTypes =
   | NotFoundException
   | BadRequestException
   | UnauthorizedException
@@ -76,11 +76,11 @@ export type HttpException =
 //   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)
-// }
+export const 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/src/icore.ts

@@ -201,7 +201,6 @@ export interface IAvleonApplication {
     fn: T,
   ): Promise<void>;
   mapGet<T extends (...args: any[]) => any>(path: string, fn: T): any;
-
   mapPost<T extends (...args: any[]) => any>(path: string, fn: T): any;
   mapPut<T extends (...args: any[]) => any>(path: string, fn: T): any;
   mapDelete<T extends (...args: any[]) => any>(path: string, fn: T): any;
@@ -214,6 +213,9 @@ export interface IAvleonApplication {
 }
 type OpenApiConfigClass<T = any> = Constructable<IConfig<T>>;
 type OpenApiConfigInput<T = any> = OpenApiConfigClass<T> | T;
+
+type ConfigClass<T = any> = Constructable<IConfig<T>>;
+type ConfigInput<T = any> = ConfigClass<T> | T;
 // InternalApplication
 export class AvleonApplication {
   private static instance: AvleonApplication;
@@ -242,7 +244,6 @@ export class AvleonApplication {
     this.appConfig = new AppConfig();
   }
 
-  private isTest() { }
 
   static getApp(): AvleonApplication {
     let isTestEnv = process.env.NODE_ENV == "test";
@@ -323,89 +324,71 @@ export class AvleonApplication {
       });
     }
   }
-  useCors(corsOptions: FastifyCorsOptions = {}) {
-    this.app.register(cors, corsOptions);
+
+  private _isConfigClass<T>(input: any): input is ConfigClass<T> {
+    return (
+      typeof input === 'function' &&
+      typeof input.prototype === 'object' &&
+      input.prototype?.constructor === input
+    );
+  }
+  useCors<T = FastifyCorsOptions>(corsOptions?: ConfigInput<T>) {
+    let coptions: any = {};
+    if (corsOptions) {
+      if (this._isConfigClass<T>(corsOptions)) {
+        coptions = this.appConfig.get(corsOptions) as T;
+      } else {
+        coptions = corsOptions as T;
+      }
+    }
+    this.app.register(cors, coptions);
   }
 
   useOpenApi<T = OpenApiUiOptions>(
-    configOrClass: OpenApiConfigInput<T>,
-    modifyConfig?: (config: T) => T
+    configOrClass: OpenApiConfigInput<T>
   ) {
     let openApiConfig: T;
-
-    const isClass = (input: any): input is OpenApiConfigClass<T> => {
-      return (
-        typeof input === 'function' &&
-        typeof input.prototype === 'object' &&
-        input.prototype?.constructor === input
-      );
-    };
-
-    if (isClass(configOrClass)) {
-      // It's a class constructor
+    if (this._isConfigClass(configOrClass)) {
       openApiConfig = this.appConfig.get(configOrClass);
     } else {
-      // It's a plain object
       openApiConfig = configOrClass as T;
     }
+    this.globalSwaggerOptions = openApiConfig;
+    this.hasSwagger = true;
+  }
 
-    if (modifyConfig) {
-      this.globalSwaggerOptions = modifyConfig(openApiConfig);
+  useMultipart<T extends MultipartOptions>(options: ConfigInput<T>) {
+    let multipartOptions: T;
+    if (this._isConfigClass(options)) {
+      multipartOptions = this.appConfig.get(options);
     } else {
-      this.globalSwaggerOptions = openApiConfig;
+      multipartOptions = options as T;
+    }
+    if (multipartOptions) {
+      this.multipartOptions = multipartOptions;
+      this.app.register(fastifyMultipart, {
+        ...this.multipartOptions,
+        attachFieldsToBody: true,
+      });
     }
-
-    this.hasSwagger = true;
   }
 
 
-  /**
-   * Registers the fastify-multipart plugin with the Fastify instance.
-   * This enables handling of multipart/form-data requests, typically used for file uploads.
-   *
-   * @param {MultipartOptions} options - Options to configure the fastify-multipart plugin.
-   * @param {FastifyInstance} this.app - The Fastify instance to register the plugin with.
-   * @property {MultipartOptions} this.multipartOptions - Stores the provided multipart options.
-   * @see {@link https://github.com/fastify/fastify-multipart} for more details on available options.
-   */
-  useMultipart(options: MultipartOptions) {
-    this.multipartOptions = options;
-    this.app.register(fastifyMultipart, {
-      ...this.multipartOptions,
-      attachFieldsToBody: true,
-    });
-  }
+  useDataSource<T extends DataSourceOptions>(options: ConfigInput<T>) {
 
-
-  /**
-   * Configures and initializes a TypeORM DataSource based on the provided configuration class.
-   * It retrieves the configuration from the application's configuration service and allows for optional modification.
-   * The initialized DataSource is then stored and registered within a dependency injection container.
-   *
-   * @template T - A generic type extending the `IConfig` interface, representing the configuration class.
-   * @template R - A generic type representing the return type of the configuration method of the `ConfigClass`.
-   * @param {Constructable<T>} ConfigClass - The constructor of the configuration class to be used for creating the DataSource.
-   * @param {(config: R) => R} [modifyConfig] - An optional function that takes the initial configuration and returns a modified configuration.
-   * @returns {void}
-   * @property {DataSourceOptions} this.dataSourceOptions - Stores the final DataSource options after potential modification.
-   * @property {DataSource} this.dataSource - Stores the initialized TypeORM DataSource instance.
-   * @see {@link https://typeorm.io/} for more information about TypeORM.
-   */
-  useDataSource<
-    T extends IConfig<R>,
-    R = ReturnType<InstanceType<Constructable<T>>["config"]>,
-  >(ConfigClass: Constructable<T>, modifyConfig?: (config: R) => R) {
-    const dsConfig: R = this.appConfig.get(ConfigClass);
-    if (modifyConfig) {
-      const modifiedConfig: R = modifyConfig(dsConfig);
-      this.dataSourceOptions = modifiedConfig as unknown as DataSourceOptions;
+    let dataSourceOptions: T;
+    if (this._isConfigClass(options)) {
+      dataSourceOptions = this.appConfig.get(options);
     } else {
-      this.dataSourceOptions = dsConfig as unknown as DataSourceOptions;
+      dataSourceOptions = options as T;
     }
 
+    if (!dataSourceOptions) throw new SystemUseError("Invlaid datasource options.")
+
+    this.dataSourceOptions = dataSourceOptions;
     const typeorm = require("typeorm");
     const datasource = new typeorm.DataSource(
-      dsConfig,
+      dataSourceOptions,
     ) as DataSource;
 
     this.dataSource = datasource;
@@ -413,23 +396,16 @@ export class AvleonApplication {
     Container.set<DataSource>("idatasource",
       datasource,
     );
+
+
   }
 
-  useCache(options: any) {
+  private _useCache(options: any) {
 
   }
 
-  /**
-   * Registers an array of middleware classes to be executed before request handlers.
-   * It retrieves instances of the middleware classes from the dependency injection container
-   * and adds them as 'preHandler' hooks to the Fastify application.
-   *
-   * @template T - A generic type extending the `AppMiddleware` interface, representing the middleware class.
-   * @param {Constructor<T>[]} mclasses - An array of middleware class constructors to be registered.
-   * @returns {void}
-   * @property {Map<string, T>} this.middlewares - Stores the registered middleware instances, keyed by their class names.
-   * @see {@link https://www.fastify.io/docs/latest/Reference/Hooks/#prehandler} for more information about Fastify preHandler hooks.
-   */
+
+
   useMiddlewares<T extends AppMiddleware>(mclasses: Constructor<T>[]) {
     for (const mclass of mclasses) {
       const cls = Container.get<T>(mclass);
@@ -439,31 +415,11 @@ export class AvleonApplication {
   }
 
 
-  /**
-   * Registers a middleware constructor to be used for authorization purposes.
-   * The specific implementation and usage of this middleware will depend on the application's authorization logic.
-   *
-   * @template T - A generic type representing the constructor of the authorization middleware.
-   * @param {Constructor<T>} middleware - The constructor of the middleware to be used for authorization.
-   * @returns {void}
-   * @property {any} this.authorizeMiddleware - Stores the constructor of the authorization middleware.
-   */
   useAuthoriztion<T extends any>(middleware: Constructor<T>) {
     this.authorizeMiddleware = middleware as any;
   }
 
 
-
-  /**
-   * Registers the `@fastify/static` plugin to serve static files.
-   * It configures the root directory and URL prefix for serving static assets.
-   *
-   * @param {StaticFileOptions} [options={ path: undefined, prefix: undefined }] - Optional configuration for serving static files.
-   * @param {string} [options.path] - The absolute path to the static files directory. Defaults to 'process.cwd()/public'.
-   * @param {string} [options.prefix] - The URL prefix for serving static files. Defaults to '/static/'.
-   * @returns {void}
-   * @see {@link https://github.com/fastify/fastify-static} for more details on available options.
-   */
   useStaticFiles(
     options: StaticFileOptions = { path: undefined, prefix: undefined },
   ) {
@@ -473,10 +429,6 @@ export class AvleonApplication {
     });
   }
 
-
-
-
-
   private handleMiddlewares<T extends AppMiddleware>(
     mclasses: Constructor<T>[],
   ) {
@@ -1086,18 +1038,10 @@ export interface IAppBuilder {
 }
 
 export class AvleonTest {
-  private static instance: AvleonTest;
-  private app: any;
-  private dataSourceOptions?: DataSourceOptions | undefined;
   private constructor() {
     process.env.NODE_ENV = "test";
   }
-
-  private addDatasource(options: DataSourceOptions) {
-    this.dataSourceOptions = options;
-  }
-
-  getController<T>(controller: Constructor<T>, deps: any[] = []) {
+  static getController<T>(controller: Constructor<T>, deps: any[] = []) {
     const paramTypes = Reflect.getMetadata('design:paramtypes', controller) || [];
 
     deps.forEach((dep, i) => {

package/src/interfaces/avleon-application.ts

@@ -0,0 +1,40 @@
+
+
+interface AvleonApplication {
+
+  // all use
+  useCors: () => void;
+  /**
+   * function for register database 
+   * @param options datasource options. options can be plain object or avleon config class 
+   * */
+  useDatasource: () => void;
+  useMultipart: () => void;
+  useOpenApi: () => void;
+  useMiddlewares: () => void;
+  useAuthorization: () => void;
+  useSerialization: () => void;
+  useControllers: () => void;
+  useStaticFiles: () => void;
+  /**
+   * @experimental
+   * use https as defalut http protocol
+   * */
+  useHttps: () => void;
+
+
+  // all map 
+  mapGet: () => void;
+  mapPost: () => void;
+  mapPut: () => void;
+  mapPatch: () => void;
+  mapOptions: () => void;
+  mapGroup: () => void;
+  // all others 
+  // run 
+  run: () => void;
+}
+
+
+
+

package/src/middleware.ts

@@ -6,7 +6,7 @@
  */
 import { Service } from "typedi";
 import { IRequest, IResponse } from "./icore";
-import { HttpException, UnauthorizedException } from "./exceptions";
+import { HttpExceptionTypes as HttpException, UnauthorizedException } from "./exceptions";
 import Container, { AUTHORIZATION_META_KEY } from "./container";
 
 export abstract class AppMiddleware {

package/src/response.ts

@@ -72,46 +72,3 @@ export class HttpResponse {
     return { message: "no content", data: null };
   }
 }
-
-export class HttpExceptions {
-  static BadRequest(message: string, data: any = null): IHttpResponse<any> {
-    return { message: message, data: data };
-  }
-
-  static Unauthorized(message: string, data: any = null): IHttpResponse<any> {
-    return { message: message, data: data };
-  }
-
-  static Forbidden(message: string, data: any = null): IHttpResponse<any> {
-    return { message: message, data: data };
-  }
-
-  static NotFound(message: string, data: any = null): IHttpResponse<any> {
-    return { message: message, data: data };
-  }
-
-  static InternalServerError(
-    message: string = "Internal server error",
-    data: any = null
-  ): IHttpResponse<any> {
-    return { message: message, data: data };
-  }
-
-  static Conflict(message: string, data: any = null): IHttpResponse<any> {
-    return { message: message, data: data };
-  }
-
-  static UnprocessableEntity(
-    message: string,
-    data: any = null
-  ): IHttpResponse<any> {
-    return { message: message, data: data };
-  }
-
-  static TooManyRequests(
-    message: string,
-    data: any = null
-  ): IHttpResponse<any> {
-    return { message: message, data: data };
-  }
-}