@avleon/core 0.0.26 → 0.0.28

package/src/testing.ts

@@ -1,220 +1,220 @@
-import "reflect-metadata";
-import { Container } from "typedi";
-import { DataSource, DataSourceOptions } from "typeorm";
-import { AvleonApplication } from "./icore";
-
-// Enhanced Test Utilities
-export class AvleonTestUtility {
-  private static testDataSource: DataSource | null = null;
-  private static testContainer: typeof Container;
-
-  /**
-   * Initialize test environment
-   */
-  static async init(options?: {
-    dataSourceOptions?: DataSourceOptions;
-    resetContainer?: boolean;
-  }) {
-    // Reset container if specified
-    if (options?.resetContainer) {
-      this.testContainer = Container;
-      this.testContainer.reset();
-    }
-
-    // Initialize test database if options provided
-    if (options?.dataSourceOptions) {
-      this.testDataSource = new DataSource({
-        ...options.dataSourceOptions,
-        logging: false, // Disable logging during tests
-      });
-
-      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<T>(token: any, mockImplementation: T) {
-    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<T>(
-    ClassType: new (...args: any[]) => T,
-    overrides: Partial<T> = {},
-  ): T {
-    const instance = Container.get(ClassType);
-
-    // Apply overrides
-    Object.keys(overrides).forEach((key) => {
-      (instance as any)[key] = (overrides as any)[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
-    Container.reset();
-  }
-}
-
-// Enhanced Test Builder
-export class AvleonTestBuilder {
-  private controllers: any[] = [];
-  private testOptions: any = {};
-  private mocks: Map<any, any> = new Map();
-
-  /**
-   * Add controllers for testing
-   * @param controllers Controllers to add
-   */
-  addControllers(...controllers: any[]) {
-    this.controllers.push(...controllers);
-    return this;
-  }
-
-  /**
-   * Mock a dependency
-   * @param token Dependency token
-   * @param mockImplementation Mock implementation
-   */
-  mockDependency(token: any, mockImplementation: any) {
-    this.mocks.set(token, mockImplementation);
-    return this;
-  }
-
-  /**
-   * Set test options
-   * @param options Test configuration options
-   */
-  setOptions(options: any) {
-    this.testOptions = { ...this.testOptions, ...options };
-    return this;
-  }
-
-  /**
-   * Build test application
-   */
-  async build() {
-    // Apply mocks
-    this.mocks.forEach((mock, token) => {
-      Container.set(token, mock);
-    });
-
-    // Initialize test utility
-    await AvleonTestUtility.init({
-      dataSourceOptions: this.testOptions.dataSourceOptions,
-      resetContainer: true,
-    });
-
-    // Create test application
-    const app = AvleonApplication.getInternalApp({
-      dataSourceOptions: this.testOptions.dataSourceOptions,
-    });
-
-    // Map controllers
-    app.useControllers(this.controllers);
-
-    // Get test application
-    return app.getTestApp();
-  }
-}
-
-// Example Usage Decorator
-export function UnitTest() {
-  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
-    const originalMethod = descriptor.value;
-
-    descriptor.value = async function (...args: any[]) {
-      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');
-//   }
-// }
+import "reflect-metadata";
+import { Container } from "typedi";
+import { DataSource, DataSourceOptions } from "typeorm";
+import { AvleonApplication } from "./icore";
+
+// Enhanced Test Utilities
+export class AvleonTestUtility {
+  private static testDataSource: DataSource | null = null;
+  private static testContainer: typeof Container;
+
+  /**
+   * Initialize test environment
+   */
+  static async init(options?: {
+    dataSourceOptions?: DataSourceOptions;
+    resetContainer?: boolean;
+  }) {
+    // Reset container if specified
+    if (options?.resetContainer) {
+      this.testContainer = Container;
+      this.testContainer.reset();
+    }
+
+    // Initialize test database if options provided
+    if (options?.dataSourceOptions) {
+      this.testDataSource = new DataSource({
+        ...options.dataSourceOptions,
+        logging: false, // Disable logging during tests
+      });
+
+      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<T>(token: any, mockImplementation: T) {
+    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<T>(
+    ClassType: new (...args: any[]) => T,
+    overrides: Partial<T> = {},
+  ): T {
+    const instance = Container.get(ClassType);
+
+    // Apply overrides
+    Object.keys(overrides).forEach((key) => {
+      (instance as any)[key] = (overrides as any)[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
+    Container.reset();
+  }
+}
+
+// Enhanced Test Builder
+export class AvleonTestBuilder {
+  private controllers: any[] = [];
+  private testOptions: any = {};
+  private mocks: Map<any, any> = new Map();
+
+  /**
+   * Add controllers for testing
+   * @param controllers Controllers to add
+   */
+  addControllers(...controllers: any[]) {
+    this.controllers.push(...controllers);
+    return this;
+  }
+
+  /**
+   * Mock a dependency
+   * @param token Dependency token
+   * @param mockImplementation Mock implementation
+   */
+  mockDependency(token: any, mockImplementation: any) {
+    this.mocks.set(token, mockImplementation);
+    return this;
+  }
+
+  /**
+   * Set test options
+   * @param options Test configuration options
+   */
+  setOptions(options: any) {
+    this.testOptions = { ...this.testOptions, ...options };
+    return this;
+  }
+
+  /**
+   * Build test application
+   */
+  async build() {
+    // Apply mocks
+    this.mocks.forEach((mock, token) => {
+      Container.set(token, mock);
+    });
+
+    // Initialize test utility
+    await AvleonTestUtility.init({
+      dataSourceOptions: this.testOptions.dataSourceOptions,
+      resetContainer: true,
+    });
+
+    // Create test application
+    const app = AvleonApplication.getInternalApp({
+      dataSourceOptions: this.testOptions.dataSourceOptions,
+    });
+
+    // Map controllers
+    app.useControllers(this.controllers);
+
+    // Get test application
+    return app.getTestApp();
+  }
+}
+
+// Example Usage Decorator
+export function UnitTest() {
+  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+    const originalMethod = descriptor.value;
+
+    descriptor.value = async function (...args: any[]) {
+      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/src/types/app-builder.interface.ts

@@ -1,19 +1,18 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-
-
-import { IApplication } from "./application.interface";
-
-export interface IAppBuilder {
-  createBuilder(): IAppBuilder;
-
-  /**
-   * @description will create a application instace
-   * @returns IApplication
-   */
-  builder: () => IApplication;
-}
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+
+import { IApplication } from "./application.interface";
+
+export interface IAppBuilder {
+  createBuilder(): IAppBuilder;
+
+  /**
+   * @description will create a application instace
+   * @returns IApplication
+   */
+  builder: () => IApplication;
+}

package/src/types/application.interface.ts

@@ -1,9 +1,7 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-export interface IApplication{
-   
-}
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+export interface IApplication {}

package/src/utils/hash.ts

@@ -1,5 +1,8 @@
-import bcrypt from 'bcryptjs';
-export const hashPasswordSync = (password: string) => bcrypt.hashSync(password,12);
-export const matchPasswordSync = (password: string, hash: string) => bcrypt.compareSync(password, hash);
-export const hashPassword = (password: string) => bcrypt.hash(password,12);
-export const matchPassword = (password: string, hash: string) => bcrypt.compare(password, hash);
+import bcrypt from "bcryptjs";
+export const hashPasswordSync = (password: string) =>
+  bcrypt.hashSync(password, 12);
+export const matchPasswordSync = (password: string, hash: string) =>
+  bcrypt.compareSync(password, hash);
+export const hashPassword = (password: string) => bcrypt.hash(password, 12);
+export const matchPassword = (password: string, hash: string) =>
+  bcrypt.compare(password, hash);

package/src/utils/index.ts

@@ -1,2 +1,2 @@
-export * from './hash';
-export * from './optional-require';
+export * from "./hash";
+export * from "./optional-require";

package/src/utils/optional-require.ts

@@ -1,50 +1,50 @@
-
-export function optionalRequire<T = any>(
-    moduleName: string,
-    options: {
-      failOnMissing?: boolean;
-      customMessage?: string;
-    } = {},
-  ): T | undefined {
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-var-requires
-      return require(moduleName);
-    } catch (err: any) {
-      if (err.code === "MODULE_NOT_FOUND" && err.message.includes(moduleName)) {
-        if (options.failOnMissing) {
-          throw new Error(
-            options.customMessage ||
-              `Optional dependency "${moduleName}" is not installed.\nInstall it with:\n\n  npm install ${moduleName}`
-          );
-        }
-        return undefined;
-      }
-      throw err;
-    }
-  }
-
-  export async function optionalImport<T = any>(
-    moduleName: string,
-    options: {
-      failOnMissing?: boolean;
-      customMessage?: string;
-    } = {},
-  ): Promise<T | undefined> {
-    try {
-      const mod = await import(moduleName);
-      return mod as T;
-    } catch (err: any) {
-      if ((err.code === "ERR_MODULE_NOT_FOUND" || err.code === "MODULE_NOT_FOUND") &&
-          err.message.includes(moduleName)) {
-        if (options.failOnMissing) {
-          throw new Error(
-            options.customMessage ||
-              `Optional dependency "${moduleName}" is not installed.\nInstall it with:\n\n  npm install ${moduleName}`
-          );
-        }
-        return undefined;
-      }
-      throw err;
-    }
-  }
-  
+export function optionalRequire<T = any>(
+  moduleName: string,
+  options: {
+    failOnMissing?: boolean;
+    customMessage?: string;
+  } = {},
+): T | undefined {
+  try {
+    return require(moduleName);
+  } catch (err: any) {
+    if (err.code === "MODULE_NOT_FOUND" && err.message.includes(moduleName)) {
+      if (options.failOnMissing) {
+        throw new Error(
+          options.customMessage ||
+            `Optional dependency "${moduleName}" is not installed.\nInstall it with:\n\n  npm install ${moduleName}`,
+        );
+      }
+      return undefined;
+    }
+    throw err;
+  }
+}
+
+export async function optionalImport<T = any>(
+  moduleName: string,
+  options: {
+    failOnMissing?: boolean;
+    customMessage?: string;
+  } = {},
+): Promise<T | undefined> {
+  try {
+    const mod = await import(moduleName);
+    return mod as T;
+  } catch (err: any) {
+    if (
+      (err.code === "ERR_MODULE_NOT_FOUND" ||
+        err.code === "MODULE_NOT_FOUND") &&
+      err.message.includes(moduleName)
+    ) {
+      if (options.failOnMissing) {
+        throw new Error(
+          options.customMessage ||
+            `Optional dependency "${moduleName}" is not installed.\nInstall it with:\n\n  npm install ${moduleName}`,
+        );
+      }
+      return undefined;
+    }
+    throw err;
+  }
+}