@avleon/core 0.0.24 → 0.0.25

package/dist/application.d.ts

@@ -1,5 +1,26 @@
 import { Constructor } from "./helpers";
 import { RouteShorthandMethod } from "fastify";
+export interface AvleonApplication {
+    useCors: () => void;
+    useOpenApi: () => void;
+    useView: () => void;
+    useAuth: () => void;
+    useMultipart: () => void;
+    useDataSource: () => void;
+    useMiddlewares: () => void;
+    useControllers: () => void;
+    useAutoControllers: () => void;
+    useStaticFiles: () => void;
+    useCustomErrorHandler: () => void;
+    mapGroup: () => any;
+    mapGet: () => any;
+    mapPost: () => any;
+    mapPut: () => any;
+    mapPatch: () => any;
+    mapDelete: () => any;
+    mapView: () => any;
+    run: (port: number) => void;
+}
 export interface InlineRoutes {
     get: RouteShorthandMethod;
     post: RouteShorthandMethod;

package/dist/cache.d.ts

@@ -0,0 +1,12 @@
+import type { Redis } from 'ioredis';
+export declare class CacheManager {
+    private store;
+    private tagsMap;
+    private redis;
+    constructor(redisInstance?: Redis);
+    private redisTagKey;
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, tags?: string[], ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    invalidateTag(tag: string): Promise<void>;
+}

package/dist/cache.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheManager = void 0;
+class CacheManager {
+    constructor(redisInstance) {
+        this.store = new Map();
+        this.tagsMap = new Map();
+        this.redis = null;
+        this.redis = redisInstance || null;
+    }
+    redisTagKey(tag) {
+        return `cache-tags:${tag}`;
+    }
+    async get(key) {
+        if (this.redis) {
+            const val = await this.redis.get(key);
+            return val ? JSON.parse(val) : null;
+        }
+        const cached = this.store.get(key);
+        return cached ? cached.data : null;
+    }
+    async set(key, value, tags = [], ttl = 3600) {
+        const entry = {
+            data: value,
+            timestamp: Date.now(),
+        };
+        if (this.redis) {
+            await this.redis.set(key, JSON.stringify(entry.data), 'EX', ttl);
+            for (const tag of tags) {
+                await this.redis.sadd(this.redisTagKey(tag), key);
+            }
+        }
+        else {
+            this.store.set(key, entry);
+            for (const tag of tags) {
+                if (!this.tagsMap.has(tag))
+                    this.tagsMap.set(tag, new Set());
+                this.tagsMap.get(tag).add(key);
+            }
+        }
+    }
+    async delete(key) {
+        if (this.redis) {
+            await this.redis.del(key);
+            // Also clean up from any tag sets
+            const tagKeys = await this.redis.keys('cache-tags:*');
+            for (const tagKey of tagKeys) {
+                await this.redis.srem(tagKey, key);
+            }
+        }
+        else {
+            this.store.delete(key);
+            for (const keys of this.tagsMap.values()) {
+                keys.delete(key);
+            }
+        }
+    }
+    async invalidateTag(tag) {
+        if (this.redis) {
+            const tagKey = this.redisTagKey(tag);
+            const keys = await this.redis.smembers(tagKey);
+            if (keys.length) {
+                await this.redis.del(...keys); // delete all cached keys
+                await this.redis.del(tagKey); // delete the tag set
+            }
+        }
+        else {
+            const keys = this.tagsMap.get(tag);
+            if (keys) {
+                for (const key of keys) {
+                    this.store.delete(key);
+                }
+                this.tagsMap.delete(tag);
+            }
+        }
+    }
+}
+exports.CacheManager = CacheManager;

package/dist/icore.d.ts

@@ -8,7 +8,7 @@ import { FastifyReply, FastifyRequest, HookHandlerDoneFunction, InjectOptions, L
 import { Constructable } from "typedi";
 import { Constructor } from "./helpers";
 import { PathLike } from "fs";
-import { DataSourceOptions } from "typeorm";
+import { DataSource, DataSourceOptions } from "typeorm";
 import { AppMiddleware } from "./middleware";
 import { OpenApiOptions, OpenApiUiOptions } from "./openapi";
 import { IConfig } from "./config";
@@ -78,19 +78,24 @@ type MultipartOptions = {
 } & FastifyMultipartOptions;
 export type TestAppOptions = {
     controllers: Constructor[];
+    dataSource?: DataSource;
 };
 export interface AvleonTestAppliction {
     addDataSource: (dataSourceOptions: DataSourceOptions) => void;
     getApp: (options?: TestAppOptions) => any;
-    getController: <T>(controller: Constructor<T>) => T;
+    getController: <T>(controller: Constructor<T>, deps: any[]) => T;
 }
+export type AutoControllerOptions = {
+    auto: true;
+    path?: string;
+};
 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>;
     useMultipart(options: MultipartOptions): void;
+    useCache(options: any): 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>;
@@ -98,11 +103,15 @@ export interface IAvleonApplication {
     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;
+    useControllers(controllers: any[]): any;
+    useControllers(controllersOptions: AutoControllerOptions): any;
+    useControllers(controllersOrOptions: any[] | AutoControllerOptions): any;
     useStaticFiles(options?: StaticFileOptions): void;
     run(port?: number): Promise<void>;
     getTestApp(): TestApplication;
 }
+type OpenApiConfigClass<T = any> = Constructable<IConfig<T>>;
+type OpenApiConfigInput<T = any> = OpenApiConfigClass<T> | T;
 export declare class AvleonApplication {
     private static instance;
     private static buildOptions;
@@ -120,6 +129,8 @@ export declare class AvleonApplication {
     private appConfig;
     private dataSource?;
     private isMapFeatures;
+    private registerControllerAuto;
+    private registerControllerPath;
     private metaCache;
     private multipartOptions;
     private constructor();
@@ -129,7 +140,7 @@ export declare class AvleonApplication {
     isDevelopment(): boolean;
     private initSwagger;
     useCors(corsOptions?: FastifyCorsOptions): void;
-    useOpenApi<T extends IConfig<R>, R = ReturnType<InstanceType<Constructable<T>>["config"]>>(ConfigClass: Constructable<T>, modifyConfig?: (config: R) => R): 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.
@@ -155,6 +166,7 @@ export declare class AvleonApplication {
      * @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
@@ -210,12 +222,10 @@ export declare class AvleonApplication {
      * @returns
      */
     private _processMeta;
-    autoControllers(): Promise<void>;
-    mapControllers(controllers: Function[]): void;
-    mapFeature(): void;
+    private _resolveControllerDir;
+    private autoControllers;
+    useControllers(controllers: Constructor[] | AutoControllerOptions): void;
     private _mapControllers;
-    mapControllersAuto(): void;
-    handleRoute(args: any): Promise<void>;
     private mapFn;
     private _handleError;
     mapRoute<T extends (...args: any[]) => any>(method: "get" | "post" | "put" | "delete", path: string | undefined, fn: T): Promise<void>;
@@ -251,20 +261,19 @@ export interface IAppBuilder {
     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 declare class TestBuilder {
+export declare class AvleonTest {
     private static instance;
     private app;
     private dataSourceOptions?;
     private constructor();
-    static createBuilder(): TestBuilder;
-    addDatasource(options: DataSourceOptions): void;
-    private getController;
+    private addDatasource;
+    getController<T>(controller: Constructor<T>, deps?: any[]): T;
     private getService;
-    getTestApplication(options: TestAppOptions): TestApplication;
-    build(app: IAvleonApplication): TestApplication;
-    fromApplication(app: IAvleonApplication): TestApplication;
+    static createTestApplication(options: TestAppOptions): TestApplication;
+    static from(app: AvleonApplication): TestApplication;
+    static clean(): void;
 }
-export declare class Builder {
+export declare class Avleon {
     static createApplication(): AvleonApplication;
 }
 export {};

package/dist/icore.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Builder = exports.TestBuilder = exports.AvleonApplication = void 0;
+exports.Avleon = exports.AvleonTest = exports.AvleonApplication = void 0;
 /**
  * @copyright 2024
  * @author Tareq Hossain
@@ -50,7 +50,6 @@ const path_1 = __importDefault(require("path"));
 const container_1 = __importStar(require("./container"));
 const helpers_1 = require("./helpers");
 const system_exception_1 = require("./exceptions/system-exception");
-const fs_1 = require("fs");
 const exceptions_1 = require("./exceptions");
 const swagger_1 = __importDefault(require("@fastify/swagger"));
 const config_1 = require("./config");
@@ -78,6 +77,8 @@ class AvleonApplication {
         this.authorizeMiddleware = undefined;
         this.dataSource = undefined;
         this.isMapFeatures = false;
+        this.registerControllerAuto = false;
+        this.registerControllerPath = './src';
         this.metaCache = new Map();
         this.app = (0, fastify_1.default)();
         this.appConfig = new config_1.AppConfig();
@@ -153,11 +154,24 @@ class AvleonApplication {
     useCors(corsOptions = {}) {
         this.app.register(cors_1.default, corsOptions);
     }
-    useOpenApi(ConfigClass, modifyConfig) {
-        const openApiConfig = this.appConfig.get(ConfigClass);
+    useOpenApi(configOrClass, modifyConfig) {
+        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
+            openApiConfig = this.appConfig.get(configOrClass);
+        }
+        else {
+            // It's a plain object
+            openApiConfig = configOrClass;
+        }
         if (modifyConfig) {
-            const modifiedConfig = modifyConfig(openApiConfig);
-            this.globalSwaggerOptions = modifiedConfig;
+            this.globalSwaggerOptions = modifyConfig(openApiConfig);
         }
         else {
             this.globalSwaggerOptions = openApiConfig;
@@ -208,6 +222,8 @@ class AvleonApplication {
         this.dataSource = datasource;
         typedi_1.default.set("idatasource", datasource);
     }
+    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
@@ -463,32 +479,59 @@ class AvleonApplication {
         this.metaCache.set(cacheKey, meta);
         return meta;
     }
-    async autoControllers() {
-        const controllers = [];
-        const files = await promises_1.default.readdir(controllerDir);
+    _resolveControllerDir(dir) {
+        const isTsNode = process.env.TS_NODE_DEV ||
+            process.env.TS_NODE_PROJECT ||
+            process[Symbol.for("ts-node.register.instance")];
+        const controllerDir = path_1.default.join(process.cwd(), this.registerControllerPath);
+        return isTsNode ? controllerDir : controllerDir.replace('src', 'dist');
+    }
+    async autoControllers(controllersPath) {
+        const conDir = this._resolveControllerDir(controllersPath);
+        const files = await promises_1.default.readdir(conDir, { recursive: true });
         for (const file of files) {
+            const isTestFile = /\.(test|spec|e2e-spec)\.ts$/.test(file);
+            if (isTestFile)
+                continue;
             if (isTsNode ? file.endsWith(".ts") : file.endsWith(".js")) {
-                const filePath = path_1.default.join(controllerDir, file);
+                const filePath = path_1.default.join(conDir, file);
                 const module = await Promise.resolve(`${filePath}`).then(s => __importStar(require(s)));
                 for (const exported of Object.values(module)) {
                     if (typeof exported === "function" && (0, container_1.isApiController)(exported)) {
-                        this.buildController(exported);
+                        console.log('adding', exported.name);
+                        if (!this.controllers.some(con => exported.name == con.name)) {
+                            this.controllers.push(exported);
+                        }
+                        //this.buildController(exported);
                     }
                 }
             }
         }
     }
-    mapControllers(controllers) {
-        this.controllers = controllers;
+    useControllers(controllers) {
+        if (Array.isArray(controllers)) {
+            this.controllers = controllers;
+            controllers.forEach(controller => {
+                if (!this.controllers.includes(controller)) {
+                    this.controllers.push(controller);
+                }
+            });
+        }
+        else {
+            this.registerControllerAuto = true;
+            if (controllers.path) {
+                this.registerControllerPath = controllers.path;
+            }
+        }
     }
     // addFeature(feature:{controllers:Function[]}){
     //   feature.controllers.forEach(c=> this.controllers.push(c))
     // }
-    mapFeature() {
-        if (!this.isMapFeatures) {
-            this.isMapFeatures = true;
-        }
-    }
+    // mapFeature(){
+    //   if(!this.isMapFeatures){
+    //     this.isMapFeatures = true;
+    //   }
+    // }
     async _mapControllers() {
         if (this.controllers.length > 0) {
             for (let controller of this.controllers) {
@@ -501,13 +544,10 @@ class AvleonApplication {
             }
         }
     }
-    mapControllersAuto() {
-        const isExists = (0, fs_1.existsSync)(controllerDir);
-        if (isExists) {
-            this.autoControllers();
-        }
-    }
-    async handleRoute(args) { }
+    // useControllersAuto(controllerPath?:string) {
+    //     this.registerControllerAuto = true;
+    //     //this.autoControllers();
+    // }
     async mapFn(fn) {
         const original = fn;
         fn = function () { };
@@ -556,7 +596,7 @@ class AvleonApplication {
             middlewares: [],
             schema: {},
         });
-        this.mapFn(fn);
+        //    this.mapFn(fn);
         const route = {
             useMiddleware: (middlewares) => {
                 const midds = Array.isArray(middlewares) ? middlewares : [middlewares];
@@ -613,6 +653,9 @@ class AvleonApplication {
         if (this.isMapFeatures) {
             this._mapFeatures();
         }
+        if (this.registerControllerAuto) {
+            await this.autoControllers();
+        }
         await this._mapControllers();
         this.rMap.forEach((value, key) => {
             const [m, r] = key.split(":");
@@ -680,7 +723,11 @@ class AvleonApplication {
                 patch: async (url, options) => this.app.inject({ method: "PATCH", url, ...options }),
                 delete: async (url, options) => this.app.inject({ method: "DELETE", url, ...options }),
                 options: async (url, options) => this.app.inject({ method: "OPTIONS", url, ...options }),
-                getController: (controller) => {
+                getController: (controller, deps = []) => {
+                    const paramTypes = Reflect.getMetadata('design:paramtypes', controller) || [];
+                    deps.forEach((dep, i) => {
+                        typedi_1.default.set(paramTypes[i], dep);
+                    });
                     return typedi_1.default.get(controller);
                 },
             };
@@ -693,44 +740,42 @@ class AvleonApplication {
 }
 exports.AvleonApplication = AvleonApplication;
 AvleonApplication.buildOptions = {};
-class TestBuilder {
+class AvleonTest {
     constructor() {
         process.env.NODE_ENV = "test";
     }
-    static createBuilder() {
-        if (!TestBuilder.instance) {
-            TestBuilder.instance = new TestBuilder();
-        }
-        return TestBuilder.instance;
-    }
     addDatasource(options) {
         this.dataSourceOptions = options;
     }
-    getController(controller) {
+    getController(controller, deps = []) {
+        const paramTypes = Reflect.getMetadata('design:paramtypes', controller) || [];
+        deps.forEach((dep, i) => {
+            typedi_1.default.set(paramTypes[i], dep);
+        });
         return typedi_1.default.get(controller);
     }
     getService(service) {
         return typedi_1.default.get(service);
     }
-    getTestApplication(options) {
+    static createTestApplication(options) {
         const app = AvleonApplication.getInternalApp({
-            dataSourceOptions: this.dataSourceOptions,
+            dataSourceOptions: options.dataSource ? options.dataSource : null,
         });
-        app.mapControllers([...options.controllers]);
+        app.useControllers([...options.controllers]);
         return app.getTestApp();
     }
-    build(app) {
+    static from(app) {
         return app.getTestApp();
     }
-    fromApplication(app) {
-        return app.getTestApp();
+    static clean() {
+        typedi_1.default.reset();
     }
 }
-exports.TestBuilder = TestBuilder;
-class Builder {
+exports.AvleonTest = AvleonTest;
+class Avleon {
     static createApplication() {
         const app = AvleonApplication.getApp();
         return app;
     }
 }
-exports.Builder = Builder;
+exports.Avleon = Avleon;

package/dist/testing.js

@@ -115,7 +115,7 @@ class AvleonTestBuilder {
             dataSourceOptions: this.testOptions.dataSourceOptions,
         });
         // Map controllers
-        app.mapControllers(this.controllers);
+        app.useControllers(this.controllers);
         // Get test application
         return app.getTestApp();
     }

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@avleon/core",
-  "version": "0.0.24",
+  "version": "0.0.25",
   "main": "./dist/index.js",
+  "types": ["./dist/icore.d.ts"],
   "scripts": {
     "build": "npm run clean && tsc",
-    "clean": "rm -rf dist",
+    "clean": "rimraf dist",
     "watch": "tsc-watch",
     "test": "jest",
     "test:watch": "jest --watch"
   },
-  "keywords": [],
+  "keywords": ["restapi", "avleon", "backend","fastify"],
   "author": "Tareq Hossain",
   "license": "ISC",
   "devDependencies": {
@@ -17,6 +18,7 @@
     "@types/node": "^20.17.25",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
+    "ioredis": "^5.6.1",
     "jest": "^29.7.0",
     "nodemon": "^3.1.7",
     "sharp": "^0.33.5",
@@ -42,15 +44,22 @@
     "reflect-metadata": "^0.2.2",
     "typedi": "^0.10.0"
   },
-"peerDependencies": {
-  "@scalar/fastify-api-reference": "*"
-},
-"peerDependenciesMeta": {
-  "@scalar/fastify-api-reference": {
-    "optional": true
-  }
-},
-
+  "peerDependencies": {
+    "@scalar/fastify-api-reference": "*",
+    "ioredis": "*",
+    "sharp": "*"
+  },
+  "peerDependenciesMeta": {
+    "@scalar/fastify-api-reference": {
+      "optional": true
+    },
+    "ioredis": {
+      "optional": true
+    },
+    "sharp": {
+      "optional": true
+    }
+  },
   "directories": {
     "test": "tests"
   },

package/src/application.ts

@@ -2,7 +2,36 @@ import Container from "typedi";
 import { Constructor } from "./helpers";
 import fastify, { FastifyInstance, RouteShorthandMethod } from "fastify";
 
+export interface AvleonApplication{
+    // all public
+    useCors: () => void
+    useOpenApi:() => void
+    useView:()=> void;
+    useAuth:() => void
+    useMultipart:()=> void
+    useDataSource: () => void
+    useMiddlewares: () => void
+    useControllers: () => void
+    useAutoControllers:() => void
+    useStaticFiles: () => void
+    useCustomErrorHandler: () => void
+
+
+
+
+    // all mapping
+    mapGroup:() => any;
+    mapGet:()=> any;
+    mapPost:()=> any;
+    mapPut: () => any;
+    mapPatch: () => any;
+    mapDelete: () => any;
+    mapView: () => any;
+
+    // run
+    run:(port:number) => void
 
+}
 
 
 export interface InlineRoutes{

package/src/cache.ts

@@ -0,0 +1,91 @@
+import type { Redis } from 'ioredis';
+
+type CacheEntry<T = any> = {
+  data: T;
+  timestamp: number;
+};
+
+export class CacheManager {
+  private store = new Map<string, CacheEntry>();
+  private tagsMap = new Map<string, Set<string>>();
+  private redis: Redis | null = null;
+
+  constructor(redisInstance?: Redis) {
+    this.redis = redisInstance || null;
+  }
+
+  private redisTagKey(tag: string) {
+    return `cache-tags:${tag}`;
+  }
+
+  async get<T>(key: string): Promise<T | null> {
+    if (this.redis) {
+      const val = await this.redis.get(key);
+      return val ? JSON.parse(val) : null;
+    }
+
+    const cached = this.store.get(key);
+    return cached ? cached.data : null;
+  }
+
+  async set<T>(
+    key: string,
+    value: T,
+    tags: string[] = [],
+    ttl: number = 3600
+  ): Promise<void> {
+    const entry: CacheEntry<T> = {
+      data: value,
+      timestamp: Date.now(),
+    };
+
+    if (this.redis) {
+      await this.redis.set(key, JSON.stringify(entry.data), 'EX', ttl);
+      for (const tag of tags) {
+        await this.redis.sadd(this.redisTagKey(tag), key);
+      }
+    } else {
+      this.store.set(key, entry);
+      for (const tag of tags) {
+        if (!this.tagsMap.has(tag)) this.tagsMap.set(tag, new Set());
+        this.tagsMap.get(tag)!.add(key);
+      }
+    }
+  }
+
+  async delete(key: string): Promise<void> {
+    if (this.redis) {
+      await this.redis.del(key);
+
+      // Also clean up from any tag sets
+      const tagKeys = await this.redis.keys('cache-tags:*');
+      for (const tagKey of tagKeys) {
+        await this.redis.srem(tagKey, key);
+      }
+    } else {
+      this.store.delete(key);
+      for (const keys of this.tagsMap.values()) {
+        keys.delete(key);
+      }
+    }
+  }
+
+  async invalidateTag(tag: string): Promise<void> {
+    if (this.redis) {
+      const tagKey = this.redisTagKey(tag);
+      const keys = await this.redis.smembers(tagKey);
+      if (keys.length) {
+        await this.redis.del(...keys); // delete all cached keys
+        await this.redis.del(tagKey);  // delete the tag set
+      }
+    } else {
+      const keys = this.tagsMap.get(tag);
+      if (keys) {
+        for (const key of keys) {
+          this.store.delete(key);
+        }
+        this.tagsMap.delete(tag);
+      }
+    }
+  }
+}

package/src/config.ts

@@ -7,6 +7,9 @@
 import { Container, Service, Constructable } from "typedi";
 import { Environment } from "./environment-variables";
 
+
+
+
 export interface IConfig<T = any> {
   config(env: Environment): T;
 }

package/src/controller.ts

@@ -5,7 +5,6 @@
  * @url https://github.com/xtareq
  */
 
-
 import Container, { Service } from "typedi";
 import container, {
   API_CONTROLLER_METADATA_KEY,
@@ -100,7 +99,7 @@ export function ApiController(
   options?: ControllerOptions,
 ): ClassDecorator;
 export function ApiController(
-  pathOrOptions: Function |string | ControllerOptions = "/",
+  pathOrOptions: Function | string | ControllerOptions = "/",
   mayBeOptions?: ControllerOptions,
 ): any {
   if (typeof pathOrOptions == 'function') {

package/src/exceptions/http-exceptions.ts

@@ -11,7 +11,7 @@ export abstract class BaseHttpException extends Error {
     super(JSON.stringify(message));
   }
   isCustomException() {
-    return true;
+    return true;  
   }
 }
 

package/src/icore.ts

@@ -159,23 +159,29 @@ type AvleonApp = FastifyInstance;
 
 export type TestAppOptions = {
   controllers: Constructor[];
+  dataSource?: DataSource
 };
 
 export interface AvleonTestAppliction {
   addDataSource: (dataSourceOptions: DataSourceOptions) => void;
   getApp: (options?: TestAppOptions) => any;
-  getController: <T>(controller: Constructor<T>) => T;
+  getController: <T>(controller: Constructor<T>, deps: any[]) => T;
+}
+
+export type AutoControllerOptions = {
+  auto: true,
+  path?: string
 }
 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;
+    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"]>,
@@ -183,8 +189,9 @@ export interface IAvleonApplication {
     ConfigClass: Constructable<T>,
     modifyConfig?: (config: R) => R,
   ): void;
-  useSwagger(options: OpenApiUiOptions): Promise<void>; // Deprecated
+
   useMultipart(options: MultipartOptions): void;
+  useCache(options: any): void
 
   useMiddlewares<T extends AppMiddleware>(mclasses: Constructor<T>[]): void;
   useAuthoriztion<T extends any>(middleware: Constructor<T>): void;
@@ -198,12 +205,15 @@ export interface IAvleonApplication {
   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;
+  useControllers(controllers: any[]): any;
+  useControllers(controllersOptions: AutoControllerOptions): any;
+  useControllers(controllersOrOptions: any[] | AutoControllerOptions): any;
   useStaticFiles(options?: StaticFileOptions): void;
   run(port?: number): Promise<void>;
   getTestApp(): TestApplication;
 }
-
+type OpenApiConfigClass<T = any> = Constructable<IConfig<T>>;
+type OpenApiConfigInput<T = any> = OpenApiConfigClass<T> | T;
 // InternalApplication
 export class AvleonApplication {
   private static instance: AvleonApplication;
@@ -222,6 +232,8 @@ export class AvleonApplication {
   private appConfig: AppConfig;
   private dataSource?: DataSource = undefined;
   private isMapFeatures = false;
+  private registerControllerAuto = false;
+  private registerControllerPath = './src';
 
   private metaCache = new Map<string, MethodParamMeta>();
   private multipartOptions: FastifyMultipartOptions | undefined;
@@ -314,31 +326,48 @@ export class AvleonApplication {
   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);
+
+  useOpenApi<T = OpenApiUiOptions>(
+    configOrClass: OpenApiConfigInput<T>,
+    modifyConfig?: (config: T) => 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
+      openApiConfig = this.appConfig.get(configOrClass);
+    } else {
+      // It's a plain object
+      openApiConfig = configOrClass as T;
+    }
+
     if (modifyConfig) {
-      const modifiedConfig: R = modifyConfig(openApiConfig);
-      this.globalSwaggerOptions = modifiedConfig;
+      this.globalSwaggerOptions = modifyConfig(openApiConfig);
     } 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.
- */
+  /**
+   * 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, {
@@ -348,57 +377,60 @@ export class AvleonApplication {
   }
 
 
-/**
- * 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.
- */
+  /**
+   * 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;
-  }
+    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;
+    const typeorm = require("typeorm");
+    const datasource = new typeorm.DataSource(
+      dsConfig,
+    ) as DataSource;
 
-  this.dataSource = datasource;
+    this.dataSource = datasource;
 
-  Container.set<DataSource>("idatasource",
-    datasource,
-  );
-}
+    Container.set<DataSource>("idatasource",
+      datasource,
+    );
+  }
 
+  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>[]) {
+  }
+
+  /**
+   * 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);
@@ -407,31 +439,31 @@ useMiddlewares<T extends AppMiddleware>(mclasses: Constructor<T>[]) {
   }
 
 
-/**
- * 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.
- */
+  /**
+   * 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.
- */
+  /**
+   * 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 },
   ) {
@@ -535,7 +567,7 @@ useMiddlewares<T extends AppMiddleware>(mclasses: Constructor<T>[]) {
         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;
@@ -714,37 +746,74 @@ useMiddlewares<T extends AppMiddleware>(mclasses: Constructor<T>[]) {
     return meta;
   }
 
-  async autoControllers() {
-    const controllers: Function[] = [];
-    const files = await fs.readdir(controllerDir);
+  private _resolveControllerDir(dir?: 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(),
+      this.registerControllerPath
+    );
+
+    return isTsNode ? controllerDir : controllerDir.replace('src', 'dist')
+  }
+
+  private async autoControllers(controllersPath?: string) {
+    const conDir = this._resolveControllerDir(controllersPath);
+
+    const files = await fs.readdir(conDir, { recursive: true });
     for (const file of files) {
+      const isTestFile = /\.(test|spec|e2e-spec)\.ts$/.test(file);
+      if (isTestFile) continue;
       if (isTsNode ? file.endsWith(".ts") : file.endsWith(".js")) {
-        const filePath = path.join(controllerDir, file);
+        const filePath = path.join(conDir, file);
         const module = await import(filePath);
         for (const exported of Object.values(module)) {
           if (typeof exported === "function" && isApiController(exported)) {
-            this.buildController(exported);
+            console.log('adding', exported.name)
+            if (!this.controllers.some(con => exported.name == con.name)) {
+              this.controllers.push(exported)
+            }
+
+            //this.buildController(exported);
           }
         }
       }
     }
   }
 
-  mapControllers(controllers: Function[]) {
-    this.controllers = controllers;
+  useControllers(controllers: Constructor[] | AutoControllerOptions) {
+
+    if (Array.isArray(controllers)) {
+      this.controllers = controllers;
+
+      controllers.forEach(controller => {
+        if (!this.controllers.includes(controller)) {
+          this.controllers.push(controller)
+        }
+      })
+    } else {
+      this.registerControllerAuto = true;
+      if (controllers.path) {
+        this.registerControllerPath = controllers.path;
+      }
+    }
+
   }
 
   // addFeature(feature:{controllers:Function[]}){
   //   feature.controllers.forEach(c=> this.controllers.push(c))
   // }
 
-  mapFeature(){
-    if(!this.isMapFeatures){
-      this.isMapFeatures = true;
-    }
-  }
+  // mapFeature(){
+  //   if(!this.isMapFeatures){
+  //     this.isMapFeatures = true;
+  //   }
+  // }
 
   private async _mapControllers() {
+
     if (this.controllers.length > 0) {
       for (let controller of this.controllers) {
         if (isApiController(controller)) {
@@ -756,14 +825,11 @@ useMiddlewares<T extends AppMiddleware>(mclasses: Constructor<T>[]) {
     }
   }
 
-  mapControllersAuto() {
-    const isExists = existsSync(controllerDir);
-    if (isExists) {
-      this.autoControllers();
-    }
-  }
+  // useControllersAuto(controllerPath?:string) {
+  //     this.registerControllerAuto = true;
+  //     //this.autoControllers();
+  // }
 
-  async handleRoute(args: any) { }
 
   private async mapFn(fn: Function) {
     const original = fn;
@@ -827,8 +893,7 @@ useMiddlewares<T extends AppMiddleware>(mclasses: Constructor<T>[]) {
       middlewares: [],
       schema: {},
     });
-
-    this.mapFn(fn);
+    //    this.mapFn(fn);
 
     const route = {
       useMiddleware: <M extends AppMiddleware>(
@@ -878,7 +943,7 @@ useMiddlewares<T extends AppMiddleware>(mclasses: Constructor<T>[]) {
   }
 
 
-  private _mapFeatures(){
+  private _mapFeatures() {
     const features = Container.get('features');
     console.log('Features', features);
   }
@@ -889,7 +954,7 @@ useMiddlewares<T extends AppMiddleware>(mclasses: Constructor<T>[]) {
     }
   }
 
-  async run(port: number = 4000, fn?:CallableFunction): Promise<void> {
+  async run(port: number = 4000, fn?: CallableFunction): Promise<void> {
     if (this.alreadyRun) throw new SystemUseError("App already running");
     this.alreadyRun = true;
 
@@ -897,9 +962,13 @@ useMiddlewares<T extends AppMiddleware>(mclasses: Constructor<T>[]) {
       await this.initSwagger(this.globalSwaggerOptions);
     }
     await this.initializeDatabase();
-    if(this.isMapFeatures){
+    if (this.isMapFeatures) {
       this._mapFeatures();
     }
+
+    if (this.registerControllerAuto) {
+      await this.autoControllers();
+    }
     await this._mapControllers();
 
     this.rMap.forEach((value, key) => {
@@ -975,8 +1044,15 @@ useMiddlewares<T extends AppMiddleware>(mclasses: Constructor<T>[]) {
           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);
+        getController: <T>(controller: Constructor<T>, deps: any[] = []) => {
+          const paramTypes = Reflect.getMetadata('design:paramtypes', controller) || [];
+
+          deps.forEach((dep, i) => {
+            Container.set(paramTypes[i], dep);
+          });
+
+          return Container.get(controller);
+
         },
       };
     } catch (error) {
@@ -1009,26 +1085,25 @@ export interface IAppBuilder {
   build<T extends IAvleonApplication>(): T;
 }
 
-export class TestBuilder {
-  private static instance: TestBuilder;
+export class AvleonTest {
+  private static instance: AvleonTest;
   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) {
+  private addDatasource(options: DataSourceOptions) {
     this.dataSourceOptions = options;
   }
 
-  private getController<T>(controller: Constructor<T>) {
+  getController<T>(controller: Constructor<T>, deps: any[] = []) {
+    const paramTypes = Reflect.getMetadata('design:paramtypes', controller) || [];
+
+    deps.forEach((dep, i) => {
+      Container.set(paramTypes[i], dep);
+    });
+
     return Container.get(controller);
   }
 
@@ -1036,27 +1111,28 @@ export class TestBuilder {
     return Container.get(service);
   }
 
-  getTestApplication(options: TestAppOptions) {
+
+  static createTestApplication(options: TestAppOptions) {
     const app = AvleonApplication.getInternalApp({
-      dataSourceOptions: this.dataSourceOptions,
+      dataSourceOptions: options.dataSource ? options.dataSource : null,
     });
-    app.mapControllers([...options.controllers]);
+    app.useControllers([...options.controllers]);
     return app.getTestApp();
   }
 
-  build(app: IAvleonApplication) {
+  static from(app: AvleonApplication) {
     return app.getTestApp();
   }
 
-  fromApplication(app: IAvleonApplication) {
-    return app.getTestApp();
+  static clean() {
+    Container.reset();
   }
 }
 
-export class Builder {
+export class Avleon {
 
-  static createApplication(){
-    const app =  AvleonApplication.getApp();
+  static createApplication() {
+    const app = AvleonApplication.getApp();
     return app
   }
 

package/src/testing.ts

@@ -134,7 +134,7 @@ export class AvleonTestBuilder {
     });
 
     // Map controllers
-    app.mapControllers(this.controllers);
+    app.useControllers(this.controllers);
 
     // Get test application
     return app.getTestApp();