@avleon/core 0.0.20 → 0.0.24

package/src/icore.ts

@@ -0,0 +1,1064 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+import fastify, {
+  FastifyInstance,
+  FastifyReply,
+  FastifyRequest,
+  HookHandlerDoneFunction,
+  preHandlerHookHandler,
+  RouteGenericInterface,
+  InjectOptions,
+  LightMyRequestResponse,
+} from "fastify";
+import Container, { Constructable } from "typedi";
+import fs from "fs/promises";
+import path from "path";
+import container, {
+  CONTROLLER_META_KEY,
+  ROUTE_META_KEY,
+  PARAM_META_KEY,
+  QUERY_META_KEY,
+  REQUEST_BODY_META_KEY,
+  REQUEST_HEADER_META_KEY,
+  getRegisteredControllers,
+  isApiController,
+  REQUEST_USER_META_KEY,
+  AUTHORIZATION_META_KEY,
+  REQUEST_BODY_FILES_KEY,
+  REQUEST_BODY_FILE_KEY,
+  FEATURE_KEY,
+} from "./container";
+import {
+  Constructor,
+  formatUrl,
+  isValidJsonString,
+  validateObjectByInstance,
+} from "./helpers";
+import { SystemUseError } from "./exceptions/system-exception";
+import { existsSync, PathLike } from "fs";
+import { DataSource, DataSourceOptions } from "typeorm";
+import { AppMiddleware } from "./middleware";
+import {
+  BadRequestException,
+  BaseHttpException,
+  ValidationErrorException,
+} from "./exceptions";
+import { OpenApiOptions, OpenApiUiOptions } from "./openapi";
+import swagger from "@fastify/swagger";
+import { AppConfig, IConfig } from "./config";
+import { Environment } from "./environment-variables";
+import cors, { FastifyCorsOptions } from "@fastify/cors";
+import fastifyMultipart, { FastifyMultipartOptions } from "@fastify/multipart";
+import { MultipartFile } from "./multipart";
+import { validateOrThrow } from "./validation";
+import { optionalRequire } from "./utils";
+
+
+export type FuncRoute = {
+  handler: any;
+  middlewares?: any[];
+  schema?: {};
+};
+
+// IRequest
+export interface IRequest extends FastifyRequest {
+  params: any;
+  query: any;
+  body: any;
+  headers: any;
+  user?: any;
+}
+
+
+
+export interface DoneFunction extends HookHandlerDoneFunction { }
+// IResponse
+export interface IResponse extends FastifyReply { }
+
+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;
+  getController?: <T>(controller: Constructor<T>) => T;
+}
+
+// ParamMetaOptions
+export interface ParamMetaOptions {
+  index: number;
+  key: string;
+  name: string;
+  required: boolean;
+  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;
+}
+
+// Method Param Meta options
+export interface MethodParamMeta {
+  params: ParamMetaOptions[];
+  query: ParamMetaOptions[];
+  body: ParamMetaOptions[];
+  headers: ParamMetaOptions[];
+  currentUser: ParamMetaOptions[];
+  swagger?: OpenApiUiOptions;
+  file?: any[];
+  files?: ParamMetaFilesOptions[];
+}
+
+interface IRoute {
+  url: string;
+  method: string;
+  controller: string;
+}
+
+const isTsNode =
+  process.env.TS_NODE_DEV ||
+  process.env.TS_NODE_PROJECT ||
+  (process as any)[Symbol.for("ts-node.register.instance")];
+const controllerDir = path.join(
+  process.cwd(),
+  isTsNode ? "./src/controllers" : "./dist/cotrollers",
+);
+
+type StaticFileOptions = {
+  path?: PathLike;
+  prefix?: string;
+};
+
+type MultipartOptions = {
+  destination: PathLike;
+} & FastifyMultipartOptions;
+
+type AvleonApp = FastifyInstance;
+
+export type TestAppOptions = {
+  controllers: Constructor[];
+};
+
+export interface AvleonTestAppliction {
+  addDataSource: (dataSourceOptions: DataSourceOptions) => void;
+  getApp: (options?: TestAppOptions) => any;
+  getController: <T>(controller: Constructor<T>) => T;
+}
+export interface IAvleonApplication {
+  isDevelopment(): boolean;
+  useCors(corsOptions?: FastifyCorsOptions): void;
+  useDataSource<
+  T extends IConfig<R>,
+  R = ReturnType<InstanceType<Constructable<T>>["config"]>,
+>(
+  ConfigClass: Constructable<T>,
+  modifyConfig?: (config: R) => R,
+): 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>; // Deprecated
+  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>;
+  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;
+  mapControllers(controllers: any[]): any;
+  useStaticFiles(options?: StaticFileOptions): void;
+  run(port?: number): Promise<void>;
+  getTestApp(): TestApplication;
+}
+
+// InternalApplication
+export class AvleonApplication {
+  private static instance: AvleonApplication;
+  private static buildOptions: any = {};
+  private app!: FastifyInstance;
+  private routeSet = new Set<string>(); // Use Set for fast duplicate detection
+  private alreadyRun = false;
+  private routes: Map<string, Function> = new Map();
+  private middlewares: Map<string, AppMiddleware> = new Map();
+  private rMap = new Map<string, FuncRoute>();
+  private hasSwagger = false;
+  private globalSwaggerOptions: any = {};
+  private dataSourceOptions?: DataSourceOptions = undefined;
+  private controllers: any[] = [];
+  private authorizeMiddleware?: any = undefined;
+  private appConfig: AppConfig;
+  private dataSource?: DataSource = undefined;
+  private isMapFeatures = false;
+
+  private metaCache = new Map<string, MethodParamMeta>();
+  private multipartOptions: FastifyMultipartOptions | undefined;
+  private constructor() {
+    this.app = fastify();
+    this.appConfig = new AppConfig();
+  }
+
+  private isTest() { }
+
+  static getApp(): AvleonApplication {
+    let isTestEnv = process.env.NODE_ENV == "test";
+    if (!AvleonApplication.instance) {
+      AvleonApplication.instance = new AvleonApplication();
+    }
+    return AvleonApplication.instance;
+  }
+
+  static getInternalApp(buildOptions: any): AvleonApplication {
+    let isTestEnv = process.env.NODE_ENV == "test";
+    if (!AvleonApplication.instance) {
+      AvleonApplication.instance = new AvleonApplication();
+    }
+    AvleonApplication.buildOptions = buildOptions;
+    if (buildOptions.dataSourceOptions) {
+      AvleonApplication.instance.dataSourceOptions =
+        buildOptions.dataSourceOptions;
+      const typeorm = require("typeorm");
+      const datasource = new typeorm.DataSource(
+        buildOptions.dataSourceOptions,
+      ) as DataSource;
+
+      Container.set<DataSource>("idatasource",
+        datasource,
+      );
+      AvleonApplication.instance.dataSource = datasource;
+    }
+    return AvleonApplication.instance;
+  }
+
+  isDevelopment() {
+    const env = container.get(Environment);
+    return env.get("NODE_ENV") == "development";
+  }
+
+
+  private async initSwagger(options: OpenApiUiOptions) {
+    const { routePrefix, logo, ui, theme, configuration, ...restOptions } =
+      options;
+
+    this.app.register(swagger, {
+      openapi: {
+        openapi: "3.0.0",
+        ...restOptions,
+      },
+    });
+    const rPrefix = routePrefix ? routePrefix : "/docs";
+
+    if (options.ui && options.ui == "scalar") {
+      const scalarPlugin = optionalRequire("@scalar/fastify-api-reference", {
+        failOnMissing: true,
+        customMessage: 'Install "@scalar/fastify-api-reference" to enable API docs.\n\n  npm install @scalar/fastify-api-reference',
+      });
+      await this.app.register(scalarPlugin, {
+        routePrefix: rPrefix as any,
+        configuration: configuration
+          ? configuration
+          : {
+            metaData: {
+              title: "Avleon Api",
+              ogTitle: "Avleon",
+            },
+            theme: options.theme ? options.theme : "kepler",
+            favicon: "/static/favicon.png",
+          },
+      });
+    } else {
+
+      const fastifySwaggerUi = optionalRequire("@fastify/swagger-ui", {
+        failOnMissing: true,
+        customMessage: 'Install "@fastify/swagger-ui" to enable API docs.\n\n  npm install @fastify/swagger-ui',
+      });
+      await this.app.register(fastifySwaggerUi, {
+        logo: logo ? logo : null,
+        theme: theme ? theme : {},
+        routePrefix: rPrefix as any,
+      });
+    }
+  }
+  useCors(corsOptions: FastifyCorsOptions = {}) {
+    this.app.register(cors, corsOptions);
+  }
+  useOpenApi<
+    T extends IConfig<R>,
+    R = ReturnType<InstanceType<Constructable<T>>["config"]>,
+  >(ConfigClass: Constructable<T>, modifyConfig?: (config: R) => R) {
+    const openApiConfig: R = this.appConfig.get(ConfigClass);
+    if (modifyConfig) {
+      const modifiedConfig: R = modifyConfig(openApiConfig);
+      this.globalSwaggerOptions = modifiedConfig;
+    } else {
+      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: MultipartOptions) {
+    this.multipartOptions = options;
+    this.app.register(fastifyMultipart, {
+      ...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<
+  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;
+  } else {
+    this.dataSourceOptions = dsConfig as unknown as DataSourceOptions;
+  }
+
+  const typeorm = require("typeorm");
+  const datasource = new typeorm.DataSource(
+    dsConfig,
+  ) as DataSource;
+
+  this.dataSource = datasource;
+
+  Container.set<DataSource>("idatasource",
+    datasource,
+  );
+}
+
+
+/**
+ * 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);
+      this.middlewares.set(mclass.name, cls);
+      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<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 },
+  ) {
+    this.app.register(require("@fastify/static"), {
+      root: options.path ? options.path : path.join(process.cwd(), "public"),
+      prefix: options.prefix ? options.prefix : "/static/",
+    });
+  }
+
+
+
+
+
+  private handleMiddlewares<T extends AppMiddleware>(
+    mclasses: Constructor<T>[],
+  ) {
+    for (const mclass of mclasses) {
+      const cls = Container.get<T>(mclass.constructor);
+      this.middlewares.set(mclass.name, cls);
+      this.app.addHook("preHandler", cls.invoke);
+    }
+  }
+
+  private executeMiddlewares(target: any, propertyKey?: string) {
+    const classMiddlewares =
+      Reflect.getMetadata("controller:middleware", target.constructor) || [];
+    const methodMiddlewares = propertyKey
+      ? Reflect.getMetadata("route:middleware", target, propertyKey) || []
+      : [];
+
+    return [...classMiddlewares, ...methodMiddlewares];
+  }
+
+  /**
+   * build controller
+   * @param controller
+   * @returns void
+   */
+  private async buildController(controller: any) {
+    const ctrl: any = Container.get(controller);
+    const controllerMeta = Reflect.getMetadata(
+      CONTROLLER_META_KEY,
+      ctrl.constructor,
+    );
+    if (!controllerMeta) return;
+    const prototype = Object.getPrototypeOf(ctrl);
+    const methods = Object.getOwnPropertyNames(prototype).filter(
+      (name) => name !== "constructor",
+    );
+    const tag = ctrl.constructor.name.replace("Controller", "");
+    const swaggerControllerMeta =
+      Reflect.getMetadata("controller:openapi", ctrl.constructor) || {};
+    const authClsMeata = Reflect.getMetadata(
+      AUTHORIZATION_META_KEY,
+      ctrl.constructor,
+    ) || { authorize: false, options: undefined };
+
+    for await (const method of methods) {
+      const methodMeta = Reflect.getMetadata(ROUTE_META_KEY, prototype, method);
+      if (!methodMeta) continue;
+      const methodmetaOptions = {
+        method: methodMeta.method.toLowerCase(),
+        path: formatUrl(controllerMeta.path + methodMeta.path),
+      };
+      const routeKey = `${methodmetaOptions.method}:${methodmetaOptions.path}`;
+      if (!this.routeSet.has(routeKey)) {
+        this.routeSet.add(routeKey);
+      }
+      const classMiddlewares = this.executeMiddlewares(ctrl, method);
+
+      // handle openapi data
+      const swaggerMeta =
+        Reflect.getMetadata("route:openapi", prototype, method) || {};
+
+      const authClsMethodMeata = Reflect.getMetadata(
+        AUTHORIZATION_META_KEY,
+        ctrl.constructor,
+        method,
+      ) || { authorize: false, options: undefined };
+      const allMeta = this._processMeta(prototype, method);
+
+      let bodySchema: any = null;
+      allMeta.body.forEach((r) => {
+        if (r.schema) {
+          bodySchema = { ...r.schema };
+        }
+      });
+
+      const routePath =
+        methodmetaOptions.path == "" ? "/" : methodmetaOptions.path;
+
+      let schema = { ...swaggerControllerMeta, ...swaggerMeta, tags: [tag] };
+      if (!swaggerMeta.body && bodySchema) {
+        schema = { ...schema, body: bodySchema };
+      }
+
+      this.app.route({
+        url: routePath,
+        method: methodmetaOptions.method.toUpperCase(),
+        schema: { ...schema },
+        handler: async (req, res) => {
+          let reqClone = req as IRequest;
+
+          
+          // class level authrization
+          if (authClsMeata.authorize && this.authorizeMiddleware) {
+            const cls = container.get(this.authorizeMiddleware) as any;
+            await cls.authorize(reqClone, authClsMeata.options);
+            if (res.sent) return;
+          }
+
+          // method level authorization
+          if (authClsMethodMeata.authorize && this.authorizeMiddleware) {
+            const cls = container.get(this.authorizeMiddleware) as any;
+            await cls.authorize(reqClone, authClsMethodMeata.options);
+            if (res.sent) return;
+          }
+          if (classMiddlewares.length > 0) {
+            for (let m of classMiddlewares) {
+              const cls = Container.get<AppMiddleware>(m.constructor);
+              reqClone = (await cls.invoke(reqClone, res)) as IRequest;
+              if (res.sent) return;
+            }
+          }
+          const args = await this._mapArgs(reqClone, allMeta);
+
+          for (let paramMeta of allMeta.params) {
+            if (paramMeta.required) {
+              validateOrThrow({ [paramMeta.key]: args[paramMeta.index] }, { [paramMeta.key]: { type: paramMeta.dataType } }, { location: 'param' })
+            }
+          }
+
+          for (let queryMeta of allMeta.query) {
+            if (queryMeta.validatorClass) {
+              const err = await validateObjectByInstance(
+                queryMeta.dataType,
+                args[queryMeta.index],
+              );
+              if (err) {
+                return await res.code(400).send({
+                  code: 400,
+                  error: "ValidationError",
+                  errors: err,
+                  message: err.message,
+                });
+              }
+            }
+            if (queryMeta.required) {
+              validateOrThrow({ [queryMeta.key]: args[queryMeta.index] }, { [queryMeta.key]: { type: queryMeta.dataType } }, { location: 'queryparam' })
+            }
+          }
+
+          for (let bodyMeta of allMeta.body) {
+            if (bodyMeta.validatorClass) {
+              const err = await validateObjectByInstance(
+                bodyMeta.dataType,
+                args[bodyMeta.index],
+              );
+              if (err) {
+                return await res.code(400).send({
+                  code: 400,
+                  error: "ValidationError",
+                  errors: err,
+                  message: err.message,
+                });
+              }
+            }
+          }
+          const result = await prototype[method].apply(ctrl, args);
+          return result;
+        },
+      });
+    }
+  }
+
+  /**
+   * map all request parameters
+   * @param req
+   * @param meta
+   * @returns
+   */
+  private async _mapArgs(req: IRequest, meta: MethodParamMeta): Promise<any[]> {
+    if (!req.hasOwnProperty("_argsCache")) {
+      Object.defineProperty(req, "_argsCache", {
+        value: new Map<string, any[]>(),
+        enumerable: false,
+      });
+    }
+
+    const cache: Map<string, any[]> = (req as any)._argsCache;
+    const cacheKey = JSON.stringify(meta); // Faster key-based lookup
+
+    if (cache.has(cacheKey)) {
+      return cache.get(cacheKey)!;
+    }
+
+    const args: any[] = 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, ...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) {
+      for await (let f of meta.file) {
+        args[f.index] = await req.file();
+      }
+    }
+
+    if (
+      meta.files &&
+      req.headers["content-type"]?.startsWith("multipart/form-data") === true
+    ) {
+      const files = await req.saveRequestFiles();
+      if (!files || files.length === 0) {
+        throw new 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,
+      }));
+      for await (let f of meta.files) {
+        const findex = fileInfo.findIndex((x) => x.fieldname == f.fieldName);
+        if (f.fieldName != "all" && findex == -1) {
+          throw new BadRequestException(
+            `${f.fieldName} doesn't exists in request files tree.`,
+          );
+        }
+        args[f.index] =
+          f.fieldName == "all"
+            ? fileInfo
+            : fileInfo.filter((x) => x.fieldname == f.fieldName);
+      }
+    }
+
+    cache.set(cacheKey, args);
+    return args;
+  }
+
+  /**
+   * Process Meta for controlelr class methods
+   * @param prototype
+   * @param method
+   * @returns
+   */
+  private _processMeta(prototype: any, method: string): MethodParamMeta {
+    const cacheKey = `${prototype.constructor.name}_${method}`;
+    if (this.metaCache.has(cacheKey)) {
+      return this.metaCache.get(cacheKey)!;
+    }
+
+    const meta: MethodParamMeta = {
+      params: Reflect.getMetadata(PARAM_META_KEY, prototype, method) || [],
+      query: Reflect.getMetadata(QUERY_META_KEY, prototype, method) || [],
+      body: Reflect.getMetadata(REQUEST_BODY_META_KEY, prototype, method) || [],
+      file: Reflect.getMetadata(REQUEST_BODY_FILE_KEY, prototype, method) || [],
+      files:
+        Reflect.getMetadata(REQUEST_BODY_FILES_KEY, prototype, method) || [],
+      headers:
+        Reflect.getMetadata(REQUEST_HEADER_META_KEY, prototype, method) || [],
+      currentUser:
+        Reflect.getMetadata(REQUEST_USER_META_KEY, prototype, method) || [],
+      // swagger: Reflect.getMetadata("route:openapi", prototype, method) || {}
+    };
+
+    this.metaCache.set(cacheKey, meta);
+    return meta;
+  }
+
+  async autoControllers() {
+    const controllers: Function[] = [];
+    const files = await fs.readdir(controllerDir);
+    for (const file of files) {
+      if (isTsNode ? file.endsWith(".ts") : file.endsWith(".js")) {
+        const filePath = path.join(controllerDir, file);
+        const module = await import(filePath);
+        for (const exported of Object.values(module)) {
+          if (typeof exported === "function" && isApiController(exported)) {
+            this.buildController(exported);
+          }
+        }
+      }
+    }
+  }
+
+  mapControllers(controllers: Function[]) {
+    this.controllers = controllers;
+  }
+
+  // addFeature(feature:{controllers:Function[]}){
+  //   feature.controllers.forEach(c=> this.controllers.push(c))
+  // }
+
+  mapFeature(){
+    if(!this.isMapFeatures){
+      this.isMapFeatures = true;
+    }
+  }
+
+  private async _mapControllers() {
+    if (this.controllers.length > 0) {
+      for (let controller of this.controllers) {
+        if (isApiController(controller)) {
+          this.buildController(controller);
+        } else {
+          throw new SystemUseError("Not a api controller.");
+        }
+      }
+    }
+  }
+
+  mapControllersAuto() {
+    const isExists = existsSync(controllerDir);
+    if (isExists) {
+      this.autoControllers();
+    }
+  }
+
+  async handleRoute(args: any) { }
+
+  private async mapFn(fn: Function) {
+    const original = fn;
+    fn = function () { };
+    return fn;
+  }
+
+
+  private _handleError(error: any): {
+    code: number;
+    error: string;
+    message: any;
+  } {
+    if (error instanceof BaseHttpException) {
+      return {
+        code: error.code,
+        error: error.name,
+        message: isValidJsonString(error.message)
+          ? JSON.parse(error.message)
+          : error.message,
+      };
+    }
+    return {
+      code: 500,
+      error: "INTERNAL_ERROR",
+      message: error.message ? error.message : "Something going wrong.",
+    };
+  }
+
+  async mapRoute<T extends (...args: any[]) => any>(
+    method: "get" | "post" | "put" | "delete",
+    path: string = "",
+    fn: T,
+  ) {
+    await this.mapFn(fn); // Assuming mapFn is needed for all methods
+
+    this.app[method](path, async (req: any, res: any) => {
+      // Dynamic method call
+      try {
+        const result = await fn.apply(this, [req, res]);
+        if (typeof result === "object" && result !== null) {
+          res.json(result); // Use res.json for objects
+        } else {
+          res.send(result); // Fallback for other types
+        }
+      } catch (error) {
+        console.error(`Error in ${method} route handler:`, error);
+        const handledErr = this._handleError(error);
+        res.status(handledErr.code).send(handledErr);
+      }
+    });
+  }
+  private _routeHandler<T extends (...args: any[]) => any>(
+    routePath: string,
+    method: string,
+    fn: T,
+  ) {
+    const routeKey = method + ":" + routePath;
+    this.rMap.set(routeKey, {
+      handler: fn,
+      middlewares: [],
+      schema: {},
+    });
+
+    this.mapFn(fn);
+
+    const route = {
+      useMiddleware: <M extends AppMiddleware>(
+        middlewares: Constructor<AppMiddleware>[],
+      ) => {
+        const midds = Array.isArray(middlewares) ? middlewares : [middlewares];
+        const ms: any[] = (midds as unknown as any[]).map((mclass) => {
+          const cls = Container.get<AppMiddleware>(mclass);
+          this.middlewares.set(mclass.name, cls);
+          return cls.invoke;
+        });
+
+        const r = this.rMap.get(routeKey);
+        if (r) {
+          r.middlewares = ms;
+        }
+        return route;
+      },
+
+      useOpenApi: (options: OpenApiOptions) => {
+        const r = this.rMap.get(routeKey);
+        if (r) {
+          r.schema = options;
+        }
+        return route;
+      },
+    };
+
+    return route;
+  }
+
+
+  mapGet<T extends (...args: any[]) => any>(path: string = "", fn: T) {
+    return this._routeHandler(path, "GET", fn);
+  }
+
+  mapPost<T extends (...args: any[]) => any>(path: string = "", fn: T) {
+    return this._routeHandler(path, "POST", fn);
+  }
+
+  mapPut<T extends (...args: any[]) => any>(path: string = "", fn: T) {
+    return this._routeHandler(path, "PUT", fn);
+  }
+
+  mapDelete<T extends (...args: any[]) => any>(path: string = "", fn: T) {
+    return this._routeHandler(path, "DELETE", fn);
+  }
+
+
+  private _mapFeatures(){
+    const features = Container.get('features');
+    console.log('Features', features);
+  }
+
+  async initializeDatabase() {
+    if (this.dataSourceOptions && this.dataSource) {
+      await this.dataSource.initialize();
+    }
+  }
+
+  async run(port: number = 4000, fn?:CallableFunction): Promise<void> {
+    if (this.alreadyRun) throw new SystemUseError("App already running");
+    this.alreadyRun = true;
+
+    if (this.hasSwagger) {
+      await this.initSwagger(this.globalSwaggerOptions);
+    }
+    await this.initializeDatabase();
+    if(this.isMapFeatures){
+      this._mapFeatures();
+    }
+    await this._mapControllers();
+
+    this.rMap.forEach((value, key) => {
+      const [m, r] = key.split(":");
+      this.app.route({
+        method: m,
+        url: r,
+        schema: value.schema || {},
+        preHandler: value.middlewares ? value.middlewares : [],
+        handler: async (req, res) => {
+          const result = await value.handler.apply(this, [req, res]);
+          return result;
+        },
+      });
+    });
+    this.app.setErrorHandler(async (error, req, res) => {
+      const handledErr = this._handleError(error);
+      if (error instanceof ValidationErrorException || error instanceof BadRequestException) {
+        return res.status(handledErr.code).send({
+          code: handledErr.code,
+          error: handledErr.error,
+          errors: handledErr.message,
+        });
+      }
+      return res.status(handledErr.code).send(handledErr);
+    });
+    await this.app.ready();
+    await this.app.listen({ port });
+    console.log(`Application running on http://127.0.0.1:${port}`);
+  }
+  getTestApp(buildOptions?: any): TestApplication {
+    try {
+      // }
+      // this.initializeDatabase();
+      this._mapControllers();
+      this.rMap.forEach((value, key) => {
+        const [m, r] = key.split(":");
+        this.app.route({
+          method: m,
+          url: r,
+          schema: value.schema || {},
+          preHandler: value.middlewares ? value.middlewares : [],
+          handler: async (req, res) => {
+            const result = await value.handler.apply(this, [req, res]);
+            return result;
+          },
+        });
+      });
+
+      this.app.setErrorHandler(async (error, req, res) => {
+        const handledErr = this._handleError(error);
+        if (error instanceof ValidationErrorException) {
+          return res.status(handledErr.code).send({
+            code: handledErr.code,
+            error: handledErr.error,
+            errors: handledErr.message,
+          });
+        }
+        return res.status(handledErr.code).send(handledErr);
+      });
+      // return this.app as any;
+      //
+      return {
+        get: async (url: string, options?: InjectOptions) =>
+          this.app.inject({ method: "GET", url, ...options }),
+        post: async (url: string, options?: InjectOptions) =>
+          this.app.inject({ method: "POST", url, ...options }),
+        put: async (url: string, options?: InjectOptions) =>
+          this.app.inject({ method: "PUT", url, ...options }),
+        patch: async (url: string, options?: InjectOptions) =>
+          this.app.inject({ method: "PATCH", url, ...options }),
+        delete: async (url: string, options?: InjectOptions) =>
+          this.app.inject({ method: "DELETE", url, ...options }),
+        options: async (url: string, options?: InjectOptions) =>
+          this.app.inject({ method: "OPTIONS", url, ...options }),
+        getController: <T>(controller: Constructor<T>) => {
+          return Container.get<T>(controller);
+        },
+      };
+    } catch (error) {
+      console.log(error);
+      throw new SystemUseError("Can't get test appliction");
+    }
+  }
+}
+
+export type Application = typeof AvleonApplication;
+
+// Applciation Builder
+export interface ITestBuilder {
+  getTestApplication(): AvleonTestAppliction;
+  createTestApplication(options: any): AvleonTestAppliction;
+}
+
+export interface IAppBuilder {
+  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;
+  build<T extends IAvleonApplication>(): T;
+}
+
+export class TestBuilder {
+  private static instance: TestBuilder;
+  private app: any;
+  private dataSourceOptions?: DataSourceOptions | undefined;
+  private constructor() {
+    process.env.NODE_ENV = "test";
+  }
+
+  static createBuilder() {
+    if (!TestBuilder.instance) {
+      TestBuilder.instance = new TestBuilder();
+    }
+    return TestBuilder.instance;
+  }
+
+  addDatasource(options: DataSourceOptions) {
+    this.dataSourceOptions = options;
+  }
+
+  private getController<T>(controller: Constructor<T>) {
+    return Container.get(controller);
+  }
+
+  private getService<T>(service: Constructor<T>) {
+    return Container.get(service);
+  }
+
+  getTestApplication(options: TestAppOptions) {
+    const app = AvleonApplication.getInternalApp({
+      dataSourceOptions: this.dataSourceOptions,
+    });
+    app.mapControllers([...options.controllers]);
+    return app.getTestApp();
+  }
+
+  build(app: IAvleonApplication) {
+    return app.getTestApp();
+  }
+
+  fromApplication(app: IAvleonApplication) {
+    return app.getTestApp();
+  }
+}
+
+export class Builder {
+
+  static createApplication(){
+    const app =  AvleonApplication.getApp();
+    return app
+  }
+
+
+}