@avleon/core 0.0.17 → 0.0.19

package/dist/collection.d.ts

@@ -1,4 +1,4 @@
-import { EntityTarget, FindOneOptions, ObjectLiteral, Repository as TypeOrmRepository } from "typeorm";
+import { EntityTarget, FindOneOptions, ObjectLiteral, Repository } from "typeorm";
 type PaginationOptions = {
     take: number;
     skip?: number;
@@ -13,9 +13,6 @@ export type PaginationResult<T> = {
     last?: number | null;
     totalPage?: number;
 };
-export declare class Repository<Entity extends ObjectLiteral> extends TypeOrmRepository<Entity> {
-    paginate(options?: PaginationOptions): Promise<PaginationResult<Entity>>;
-}
 type ICollection<T> = {
     findAll(): T[] | Promise<T[]>;
 };
@@ -49,4 +46,5 @@ export declare class Collection {
     static from<T>(items: T[]): BasicCollection<T>;
     static fromRepository<T extends ObjectLiteral>(entity: EntityTarget<T>): Repository<T>;
 }
+export declare function InjectRepository<T extends Repository<T>>(model: EntityTarget<T>): (object: any, propertyName: string | undefined, index?: number) => void;
 export {};

package/dist/collection.js

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Collection = exports.Repository = void 0;
+exports.Collection = void 0;
+exports.InjectRepository = InjectRepository;
 /**
  * @copyright 2024
  * @author Tareq Hossain
@@ -12,18 +13,6 @@ exports.Collection = exports.Repository = void 0;
  */
 const typedi_1 = __importDefault(require("typedi"));
 const exceptions_1 = require("./exceptions");
-const typeorm_1 = require("typeorm");
-class Repository extends typeorm_1.Repository {
-    async paginate(options = { take: 10, skip: 0 }) {
-        const total = await this.count();
-        const data = await this.find({
-            take: options.take || 10,
-            skip: options.skip || 0,
-        });
-        return { total, data };
-    }
-}
-exports.Repository = Repository;
 class BasicCollection {
     constructor(items) {
         this.items = items;
@@ -119,10 +108,9 @@ class AsynchronousCollection {
     }
     getRepository() {
         if (!this.repo) {
-            const dataSource = typedi_1.default.get("idatasource");
-            const repository = dataSource.getRepository(this.model).extend({
-                paginate: this.paginate,
-            });
+            const dataSourceKey = process.env.NODE_ENV === "test" ? "itestdatasource" : "idatasource";
+            const dataSource = typedi_1.default.get(dataSourceKey);
+            const repository = dataSource.getRepository(this.model);
             this.repo = repository;
             return repository;
         }
@@ -144,146 +132,56 @@ class AsynchronousCollection {
             data,
         };
     }
-    createQueryBuilder(alias, queryRunner) {
-        return this.getRepository().createQueryBuilder(alias, queryRunner);
-    }
-    hasId(entity) {
-        return this.getRepository().hasId(entity);
-    }
-    getId(entity) {
-        return this.getRepository().getId(entity);
-    }
-    create(entityLike) {
-        return this.getRepository().create(entityLike);
-    }
-    merge(mergeIntoEntity, ...entityLikes) {
-        return this.getRepository().merge(mergeIntoEntity, ...entityLikes);
-    }
-    async preload(entityLike) {
-        return this.getRepository().preload(entityLike);
-    }
-    async save(entities, options) {
-        return this.getRepository().save(entities, options);
-    }
-    async remove(entity) {
-        return this.getRepository().remove(entity);
-    }
-    async softRemove(entity) {
-        return this.getRepository().softRemove(entity);
-    }
-    async recover(entity) {
-        return this.getRepository().recover(entity);
-    }
-    async insert(entity) {
-        await this.getRepository().insert(entity);
-    }
-    async update(criteria, partialEntity) {
-        return this.getRepository().update(criteria, partialEntity);
-    }
-    async upsert(entityOrEntities, conflictPathsOrOptions) {
-        await this.getRepository().upsert(entityOrEntities, conflictPathsOrOptions);
-    }
-    async delete(criteria) {
-        return this.getRepository().delete(criteria);
-    }
-    async softDelete(criteria) {
-        return this.getRepository().softDelete(criteria);
-    }
-    async restore(criteria) {
-        return this.getRepository().restore(criteria);
-    }
-    async exist(options) {
-        return (await this.getRepository().count(options)) > 0;
-    }
-    async exists(options) {
-        return this.exist(options);
-    }
-    async existsBy(where) {
-        return (await this.getRepository().count({ where })) > 0;
-    }
-    async count(options) {
-        return this.getRepository().count(options);
-    }
-    async countBy(where) {
-        return this.getRepository().count({ where });
-    }
-    async sum(columnName, where) {
-        return this.getRepository()
-            .createQueryBuilder()
-            .select(`SUM(${columnName})`, "sum")
-            .where(where || {})
-            .getRawOne()
-            .then((res) => (res === null || res === void 0 ? void 0 : res.sum) || null);
-    }
-    async average(columnName, where) {
-        return this.getRepository()
-            .createQueryBuilder()
-            .select(`AVG(${columnName})`, "average")
-            .where(where || {})
-            .getRawOne()
-            .then((res) => (res === null || res === void 0 ? void 0 : res.average) || null);
-    }
-    async minimum(columnName, where) {
-        return this.getRepository()
-            .createQueryBuilder()
-            .select(`MIN(${columnName})`, "minimum")
-            .where(where || {})
-            .getRawOne()
-            .then((res) => (res === null || res === void 0 ? void 0 : res.minimum) || null);
-    }
-    async maximum(columnName, where) {
-        return this.getRepository().maximum(columnName, where);
-    }
-    async find(options) {
-        return await this.getRepository().find(options);
-    }
-    async findBy(where) {
-        return this.getRepository().findBy(where);
-    }
-    async findAndCount(options) {
-        return this.getRepository().findAndCount(options);
-    }
-    async findAndCountBy(where) {
-        return this.getRepository().findAndCount({ where });
-    }
-    async findByIds(ids) {
-        return this.getRepository().findBy(ids);
-    }
-    async findOne(options) {
-        return this.getRepository().findOne(options);
-    }
-    async findOneBy(where) {
-        return this.getRepository().findOneBy(where);
-    }
-    async findOneById(id) {
-        return this.getRepository().findOneBy({ id });
-    }
-    async findOneOrFail(options) {
-        return this.getRepository().findOneOrFail(options);
-    }
-    async findOneByOrFail(where) {
-        return this.getRepository().findOneByOrFail(where);
-    }
-    async query(query, parameters) {
-        return this.getRepository().query(query, parameters);
-    }
-    async clear() {
-        await this.getRepository().clear();
-    }
-    async increment(conditions, propertyPath, value) {
-        return this.getRepository().increment(conditions, propertyPath, value);
-    }
-    async decrement(conditions, propertyPath, value) {
-        return this.getRepository().decrement(conditions, propertyPath, value);
-    }
 }
 class Collection {
     constructor() { }
     static from(items) {
         return BasicCollection.from(items);
     }
+    // Example refactoring of Collection.fromRepository for better type safety
     static fromRepository(entity) {
-        return AsynchronousCollection.fromRepository(entity);
+        const asyncCollection = AsynchronousCollection.fromRepository(entity);
+        // Assuming AsynchronousCollection has a method to get the Repository<T>
+        return asyncCollection.getRepository();
     }
 }
 exports.Collection = Collection;
+function InjectRepository(model) {
+    return function (object, propertyName, index) {
+        let repo;
+        try {
+            typedi_1.default.registerHandler({
+                object,
+                propertyName,
+                index,
+                value: (containerInstance) => {
+                    const dataSource = containerInstance.get("idatasource");
+                    repo = dataSource
+                        .getRepository(model)
+                        .extend({ paginate: () => { } });
+                    repo.paginate = async function (options = { take: 10, skip: 0 }) {
+                        const [data, total] = await this.findAndCount({
+                            take: options.take || 10,
+                            skip: options.skip || 0,
+                        });
+                        return {
+                            total,
+                            totalPage: Math.ceil(total / (options.take || 10)),
+                            next: options.skip + options.take < total
+                                ? options.skip + options.take
+                                : null,
+                            data,
+                        };
+                    };
+                    return repo;
+                },
+            });
+        }
+        catch (error) {
+            console.log(error);
+            if (error.name && error.name == "ServiceNotFoundError") {
+                console.log("Database didn't initialized.");
+            }
+        }
+    };
+}

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const TEST_DATASOURCE_OPTIONS_KEY: unique symbol;

package/dist/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEST_DATASOURCE_OPTIONS_KEY = void 0;
+exports.TEST_DATASOURCE_OPTIONS_KEY = Symbol("itestdatasource");

package/dist/icore.d.ts

@@ -40,6 +40,7 @@ export interface TestApplication {
     patch: (url: string, options?: InjectOptions) => TestResponse;
     delete: (url: string, options?: InjectOptions) => TestResponse;
     options: (url: string, options?: InjectOptions) => TestResponse;
+    getController?: <T>(controller: Constructor<T>) => T;
 }
 export interface ParamMetaOptions {
     index: number;
@@ -101,7 +102,7 @@ export interface IAvleonApplication {
     run(port?: number): Promise<void>;
     getTestApp(): TestApplication;
 }
-declare class AvleonApplication implements IAvleonApplication {
+export declare class AvleonApplication implements IAvleonApplication {
     private static instance;
     private static buildOptions;
     private app;
@@ -120,6 +121,7 @@ declare class AvleonApplication implements IAvleonApplication {
     private metaCache;
     private multipartOptions;
     private constructor();
+    private isTest;
     static getInternalApp(buildOptions: any): AvleonApplication;
     isDevelopment(): boolean;
     private initSwagger;
@@ -202,8 +204,8 @@ export declare class TestBuilder {
     private constructor();
     static createBuilder(): TestBuilder;
     addDatasource(options: DataSourceOptions): void;
-    getController<T>(controller: Constructor<T>): T;
-    getService<T>(service: Constructor<T>): T;
+    private getController;
+    private getService;
     getTestApplication(options: TestAppOptions): TestApplication;
     build(app: IAvleonApplication): TestApplication;
     fromApplication(app: IAvleonApplication): TestApplication;

package/dist/icore.js

@@ -54,7 +54,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 = void 0;
+exports.Builder = exports.TestBuilder = exports.AvleonApplication = void 0;
 /**
  * @copyright 2024
  * @author Tareq Hossain
@@ -94,25 +94,23 @@ class AvleonApplication {
         this.authorizeMiddleware = undefined;
         this.dataSource = undefined;
         this.metaCache = new Map();
-        this.app = (0, fastify_1.default)({
-            frameworkErrors: (error, req, res) => { },
-        });
+        this.app = (0, fastify_1.default)();
         this.appConfig = new config_1.AppConfig();
         // this.app.setValidatorCompiler(() => () => true);
     }
+    isTest() { }
     static getInternalApp(buildOptions) {
+        let isTestEnv = process.env.NODE_ENV == "test";
         if (!AvleonApplication.instance) {
             AvleonApplication.instance = new AvleonApplication();
         }
         AvleonApplication.buildOptions = buildOptions;
-        if (buildOptions.controllers) {
-        }
         if (buildOptions.dataSourceOptions) {
             AvleonApplication.instance.dataSourceOptions =
                 buildOptions.dataSourceOptions;
             const typeorm = require("typeorm");
             const datasource = new typeorm.DataSource(buildOptions.dataSourceOptions);
-            typedi_1.default.set("idatasource", datasource);
+            typedi_1.default.set(isTestEnv ? "itestdatasource" : "idatasource", datasource);
             AvleonApplication.instance.dataSource = datasource;
         }
         return AvleonApplication.instance;
@@ -590,22 +588,8 @@ class AvleonApplication {
     }
     getTestApp(buildOptions) {
         try {
-            if (buildOptions && buildOptions.addDataSource) {
-                const typeorm = Promise.resolve().then(() => __importStar(require("typeorm")));
-                if (!typeorm) {
-                    throw new system_exception_1.SystemUseError("TypeOrm not installed");
-                }
-                typeorm.then(async (t) => {
-                    try {
-                        const datasource = new t.DataSource(buildOptions.addDataSource);
-                        typedi_1.default.set("idatasource", datasource);
-                        await datasource.initialize();
-                    }
-                    catch (error) {
-                        console.error("Database can't initialized.", error);
-                    }
-                });
-            }
+            // }
+            // this.initializeDatabase();
             this._mapControllers();
             this.rMap.forEach((value, key) => {
                 const [m, r] = key.split(":");
@@ -632,23 +616,31 @@ class AvleonApplication {
                 return res.status(handledErr.code).send(handledErr);
             });
             // return this.app as any;
+            //
             return {
-                get: (url, options) => this.app.inject(Object.assign({ method: "GET", url }, options)),
-                post: (url, options) => this.app.inject(Object.assign({ method: "POST", url }, options)),
-                put: (url, options) => this.app.inject(Object.assign({ method: "PUT", url }, options)),
-                patch: (url, options) => this.app.inject(Object.assign({ method: "PATCH", url }, options)),
-                delete: (url, options) => this.app.inject(Object.assign({ method: "DELETE", url }, options)),
-                options: (url, options) => this.app.inject(Object.assign({ method: "OPTIONS", url }, options)),
+                get: async (url, options) => this.app.inject(Object.assign({ method: "GET", url }, options)),
+                post: async (url, options) => this.app.inject(Object.assign({ method: "POST", url }, options)),
+                put: async (url, options) => this.app.inject(Object.assign({ method: "PUT", url }, options)),
+                patch: async (url, options) => this.app.inject(Object.assign({ method: "PATCH", url }, options)),
+                delete: async (url, options) => this.app.inject(Object.assign({ method: "DELETE", url }, options)),
+                options: async (url, options) => this.app.inject(Object.assign({ method: "OPTIONS", url }, options)),
+                getController: (controller) => {
+                    return typedi_1.default.get(controller);
+                },
             };
         }
         catch (error) {
+            console.log(error);
             throw new system_exception_1.SystemUseError("Can't get test appliction");
         }
     }
 }
+exports.AvleonApplication = AvleonApplication;
 AvleonApplication.buildOptions = {};
 class TestBuilder {
-    constructor() { }
+    constructor() {
+        process.env.NODE_ENV = "test";
+    }
     static createBuilder() {
         if (!TestBuilder.instance) {
             TestBuilder.instance = new TestBuilder();
@@ -669,8 +661,7 @@ class TestBuilder {
             dataSourceOptions: this.dataSourceOptions,
         });
         app.mapControllers([...options.controllers]);
-        const fa = app.getTestApp();
-        return fa;
+        return app.getTestApp();
     }
     build(app) {
         return app.getTestApp();

package/dist/index.d.ts

@@ -6,6 +6,7 @@
  */
 import * as sw from "./swagger-schema";
 export * from "./icore";
+export * from "./testing";
 export { inject, validateRequestBody } from "./helpers";
 export * from "./decorators";
 export * from "./middleware";

package/dist/index.js

@@ -48,6 +48,7 @@ exports.Container = exports.GetSchema = exports.validateRequestBody = exports.in
  */
 const sw = __importStar(require("./swagger-schema"));
 __exportStar(require("./icore"), exports);
+__exportStar(require("./testing"), exports);
 var helpers_1 = require("./helpers");
 Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return helpers_1.inject; } });
 Object.defineProperty(exports, "validateRequestBody", { enumerable: true, get: function () { return helpers_1.validateRequestBody; } });

package/dist/testing.d.ts

@@ -0,0 +1,55 @@
+import "reflect-metadata";
+import { DataSourceOptions } from "typeorm";
+export declare class AvleonTestUtility {
+    private static testDataSource;
+    private static testContainer;
+    /**
+     * Initialize test environment
+     */
+    static init(options?: {
+        dataSourceOptions?: DataSourceOptions;
+        resetContainer?: boolean;
+    }): Promise<typeof AvleonTestUtility>;
+    /**
+     * Mock a dependency for testing
+     * @param token Dependency token
+     * @param mockImplementation Mock implementation
+     */
+    static mockDependency<T>(token: any, mockImplementation: T): T;
+    /**
+     * Create an isolated test instance of a class
+     * @param ClassType Class to instantiate
+     * @param overrides Optional property overrides
+     */
+    static createTestInstance<T>(ClassType: new (...args: any[]) => T, overrides?: Partial<T>): T;
+    /**
+     * Cleanup test environment
+     */
+    static cleanup(): Promise<void>;
+}
+export declare class AvleonTestBuilder {
+    private controllers;
+    private testOptions;
+    private mocks;
+    /**
+     * Add controllers for testing
+     * @param controllers Controllers to add
+     */
+    addControllers(...controllers: any[]): this;
+    /**
+     * Mock a dependency
+     * @param token Dependency token
+     * @param mockImplementation Mock implementation
+     */
+    mockDependency(token: any, mockImplementation: any): this;
+    /**
+     * Set test options
+     * @param options Test configuration options
+     */
+    setOptions(options: any): this;
+    /**
+     * Build test application
+     */
+    build(): Promise<import("./icore").TestApplication>;
+}
+export declare function UnitTest(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/testing.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvleonTestBuilder = exports.AvleonTestUtility = void 0;
+exports.UnitTest = UnitTest;
+require("reflect-metadata");
+const typedi_1 = require("typedi");
+const typeorm_1 = require("typeorm");
+const icore_1 = require("./icore");
+// Enhanced Test Utilities
+class AvleonTestUtility {
+    /**
+     * Initialize test environment
+     */
+    static async init(options) {
+        // Reset container if specified
+        if (options === null || options === void 0 ? void 0 : options.resetContainer) {
+            this.testContainer = typedi_1.Container;
+            this.testContainer.reset();
+        }
+        // Initialize test database if options provided
+        if (options === null || options === void 0 ? void 0 : options.dataSourceOptions) {
+            this.testDataSource = new typeorm_1.DataSource(Object.assign(Object.assign({}, options.dataSourceOptions), { logging: false }));
+            await this.testDataSource.initialize();
+            await this.testDataSource.synchronize(true); // Create schema
+        }
+        return this;
+    }
+    /**
+     * Mock a dependency for testing
+     * @param token Dependency token
+     * @param mockImplementation Mock implementation
+     */
+    static mockDependency(token, mockImplementation) {
+        typedi_1.Container.set(token, mockImplementation);
+        return mockImplementation;
+    }
+    /**
+     * Create an isolated test instance of a class
+     * @param ClassType Class to instantiate
+     * @param overrides Optional property overrides
+     */
+    static createTestInstance(ClassType, overrides = {}) {
+        const instance = typedi_1.Container.get(ClassType);
+        // Apply overrides
+        Object.keys(overrides).forEach((key) => {
+            instance[key] = overrides[key];
+        });
+        return instance;
+    }
+    /**
+     * Cleanup test environment
+     */
+    static async cleanup() {
+        if (this.testDataSource) {
+            await this.testDataSource.dropDatabase();
+            await this.testDataSource.destroy();
+            this.testDataSource = null;
+        }
+        // Reset container
+        typedi_1.Container.reset();
+    }
+}
+exports.AvleonTestUtility = AvleonTestUtility;
+AvleonTestUtility.testDataSource = null;
+// Enhanced Test Builder
+class AvleonTestBuilder {
+    constructor() {
+        this.controllers = [];
+        this.testOptions = {};
+        this.mocks = new Map();
+    }
+    /**
+     * Add controllers for testing
+     * @param controllers Controllers to add
+     */
+    addControllers(...controllers) {
+        this.controllers.push(...controllers);
+        return this;
+    }
+    /**
+     * Mock a dependency
+     * @param token Dependency token
+     * @param mockImplementation Mock implementation
+     */
+    mockDependency(token, mockImplementation) {
+        this.mocks.set(token, mockImplementation);
+        return this;
+    }
+    /**
+     * Set test options
+     * @param options Test configuration options
+     */
+    setOptions(options) {
+        this.testOptions = Object.assign(Object.assign({}, this.testOptions), options);
+        return this;
+    }
+    /**
+     * Build test application
+     */
+    async build() {
+        // Apply mocks
+        this.mocks.forEach((mock, token) => {
+            typedi_1.Container.set(token, mock);
+        });
+        // Initialize test utility
+        await AvleonTestUtility.init({
+            dataSourceOptions: this.testOptions.dataSourceOptions,
+            resetContainer: true,
+        });
+        // Create test application
+        const app = icore_1.AvleonApplication.getInternalApp({
+            dataSourceOptions: this.testOptions.dataSourceOptions,
+        });
+        // Map controllers
+        app.mapControllers(this.controllers);
+        // Get test application
+        return app.getTestApp();
+    }
+}
+exports.AvleonTestBuilder = AvleonTestBuilder;
+// Example Usage Decorator
+function UnitTest() {
+    return (target, propertyKey, descriptor) => {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            try {
+                // Pre-test setup
+                await AvleonTestUtility.init();
+                // Execute test
+                const result = await originalMethod.apply(this, args);
+                // Post-test cleanup
+                await AvleonTestUtility.cleanup();
+                return result;
+            }
+            catch (error) {
+                // Ensure cleanup even if test fails
+                await AvleonTestUtility.cleanup();
+                throw error;
+            }
+        };
+        return descriptor;
+    };
+}
+//
+// // Example of Unit and Integration Test
+// class UserServiceTest {
+//   @UnitTest()
+//   async testUserCreation() {
+//     // Mock UserRepository
+//     const mockRepo = AvleonTestUtility.mockDependency(
+//       UserRepository,
+//       { create: jest.fn() }
+//     );
+//
+//     // Create test instance
+//     const userService = AvleonTestUtility.createTestInstance(UserService);
+//
+//     // Perform test
+//     const result = await userService.createUser({
+//       name: 'Test User',
+//       email: 'test@example.com'
+//     });
+//
+//     // Assertions
+//     expect(mockRepo.create).toHaveBeenCalledWith(expect.any(Object));
+//   }
+// }
+//
+// // Enhanced E2E Testing Example
+// class E2EUserControllerTest {
+//   async testUserRegistration() {
+//     // Build test application
+//     const testApp = await new AvleonTestBuilder()
+//       .addControllers(UserController)
+//       .mockDependency(AuthService, mockAuthService)
+//       .setOptions({
+//         dataSourceOptions: testDatabaseConfig
+//       })
+//       .build();
+//
+//     // Perform HTTP request
+//     const response = await testApp.post('/users/register', {
+//       payload: {
+//         name: 'John Doe',
+//         email: 'john@example.com'
+//       }
+//     });
+//
+//     // Assertions
+//     expect(response.statusCode).toBe(201);
+//     expect(response.json()).toHaveProperty('userId');
+//   }
+// }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avleon/core",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "main": "./dist/index.js",
   "scripts": {
     "build": "rimraf dist && tsc",