@avleon/core 0.0.24 → 0.0.26

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

@@ -38,4 +38,12 @@ export declare class ForbiddenException extends BaseHttpException {
     code: number;
     constructor(message: any);
 }
-export type HttpException = NotFoundException | BadRequestException | UnauthorizedException | InternalErrorException | ForbiddenException;
+export type HttpExceptionTypes = NotFoundException | BadRequestException | UnauthorizedException | InternalErrorException | ForbiddenException;
+export declare const HttpExceptions: {
+    notFound: (message?: any) => NotFoundException;
+    validationError: (message?: any) => ValidationErrorException;
+    badRequest: (message?: any) => BadRequestException;
+    unauthorized: (message?: any) => UnauthorizedException;
+    forbidden: (message?: any) => ForbiddenException;
+    internalError: (message?: any) => InternalErrorException;
+};

package/dist/exceptions/http-exceptions.js

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

package/dist/icore.d.ts

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