@avleon/core 0.0.24 → 0.0.26

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,11 +77,12 @@ 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();
     }
-    isTest() { }
     static getApp() {
         let isTestEnv = process.env.NODE_ENV == "test";
         if (!AvleonApplication.instance) {
@@ -150,75 +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(ConfigClass, modifyConfig) {
-        const openApiConfig = this.appConfig.get(ConfigClass);
-        if (modifyConfig) {
-            const modifiedConfig = modifyConfig(openApiConfig);
-            this.globalSwaggerOptions = modifiedConfig;
+    useOpenApi(configOrClass) {
+        let openApiConfig;
+        if (this._isConfigClass(configOrClass)) {
+            openApiConfig = this.appConfig.get(configOrClass);
         }
         else {
-            this.globalSwaggerOptions = openApiConfig;
+            openApiConfig = configOrClass;
         }
+        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);
     }
-    /**
-     * 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.
-     */
+    _useCache(options) {
+    }
     useMiddlewares(mclasses) {
         for (const mclass of mclasses) {
             const cls = typedi_1.default.get(mclass);
@@ -226,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"),
@@ -463,32 +438,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 +503,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 +555,7 @@ class AvleonApplication {
             middlewares: [],
             schema: {},
         });
-        this.mapFn(fn);
+        //    this.mapFn(fn);
         const route = {
             useMiddleware: (middlewares) => {
                 const midds = Array.isArray(middlewares) ? middlewares : [middlewares];
@@ -613,6 +612,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 +682,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 +699,39 @@ 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) {
+    static 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/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/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.26",
   "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;
 }