@avleon/core 0.0.29 → 0.0.31

package/src/route-methods.ts

@@ -1,186 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-
-import { CONTROLLER_META_KEY, ROUTE_META_KEY } from "./container";
-import { OpenApiOptions } from "./openapi";
-import { HttpResponse } from "./response";
-import { Results } from "./results";
-export type RouteMethods =
-  | "GET"
-  | "POST"
-  | "PUT"
-  | "PATCH"
-  | "DELETE"
-  | "OPTIONS"
-  | "ALL";
-
-const schema: OpenApiOptions = {
-  tags: ["hello"],
-};
-
-/**
- * Options for defining a route's method and metadata.
- */
-export type RouteMethodOptions = {
-  /**
-   * HTTP method for the route (e.g., GET, POST, PUT, DELETE).
-   */
-  method?: RouteMethods;
-
-  /**
-   * The path or endpoint for the route (e.g., "/users/:id").
-   */
-  path?: string;
-
-  /**
-   * OpenAPI metadata for the route, including summary and description.
-   */
-  openapi?: OpenApiOptions;
-
-  /**
-   * Name of the route.
-   *
-   * @description If Swagger is enabled in the project, this will appear as a tag in the generated documentation.
-   */
-  name?: string;
-};
-
-// Overloads
-
-// Implementation
-export function createRouteDecorator(
-  method: RouteMethods = "GET",
-): (
-  pathOrOptions: string | RouteMethodOptions,
-  maybeOptions?: RouteMethodOptions,
-) => MethodDecorator {
-  return function (
-    pathOrOptions: string | RouteMethodOptions,
-    maybeOptions?: RouteMethodOptions,
-  ): MethodDecorator {
-    return function (
-      target,
-      propertyKey: string | symbol,
-      descriptor: PropertyDescriptor,
-    ) {
-      let path = "/";
-      let options: RouteMethodOptions = {};
-
-      if (typeof pathOrOptions === "string") {
-        path = pathOrOptions;
-        options = maybeOptions || {};
-      } else if (typeof pathOrOptions === "object") {
-        options = pathOrOptions;
-        path = options.name || "/";
-      }
-
-      // Define metadata
-      Reflect.defineMetadata("route:path", path, target, propertyKey);
-      Reflect.defineMetadata(
-        "route:method",
-        method || "GET",
-        target,
-        propertyKey,
-      );
-      Reflect.getMetadata(CONTROLLER_META_KEY, target.constructor);
-      Reflect.defineMetadata(
-        ROUTE_META_KEY,
-        { ...options, method, path, controller: target.constructor.name },
-        target,
-        propertyKey,
-      );
-
-      if (options) {
-        Reflect.defineMetadata("route:options", options, target, propertyKey);
-      }
-    };
-  };
-}
-
-// Usage Example
-/**
- * @description HTTP Get method
- * @param {string} path
- */
-export function Get(path?: string): MethodDecorator;
-export function Get(path: string | RouteMethodOptions): MethodDecorator;
-/**
- * @description HTTP Get method
- * @param {string} path
- * @param {RouteMethodOptions} options
- */
-export function Get(path: string, options: RouteMethodOptions): MethodDecorator;
-export function Get(
-  path?: string | RouteMethodOptions,
-  options?: RouteMethodOptions,
-) {
-  const parsedPath =
-    !path && !options ? "/" : (path as string | RouteMethodOptions);
-  if (options) {
-    return createRouteDecorator("GET")(parsedPath, options);
-  } else {
-    return createRouteDecorator("GET")(parsedPath);
-  }
-}
-
-export function Post(path?: string): MethodDecorator;
-export function Post(path: string | RouteMethodOptions): MethodDecorator;
-export function Post(
-  path: string,
-  options: RouteMethodOptions,
-): MethodDecorator;
-export function Post(
-  path?: string | RouteMethodOptions,
-  options?: RouteMethodOptions,
-) {
-  const parsedPath =
-    !path && !options ? "/" : (path as string | RouteMethodOptions);
-  if (options) {
-    return createRouteDecorator("POST")(parsedPath, options);
-  } else {
-    return createRouteDecorator("POST")(parsedPath);
-  }
-}
-
-export function Put(path?: string): MethodDecorator;
-export function Put(path: string | RouteMethodOptions): MethodDecorator;
-export function Put(path: string, options: RouteMethodOptions): MethodDecorator;
-export function Put(
-  path?: string | RouteMethodOptions,
-  options?: RouteMethodOptions,
-) {
-  const parsedPath =
-    !path && !options ? "/" : (path as string | RouteMethodOptions);
-  if (options) {
-    return createRouteDecorator("PUT")(parsedPath, options);
-  } else {
-    return createRouteDecorator("PUT")(parsedPath);
-  }
-}
-
-export function Delete(path?: string): MethodDecorator;
-export function Delete(path: string | RouteMethodOptions): MethodDecorator;
-export function Delete(
-  path: string,
-  options: RouteMethodOptions,
-): MethodDecorator;
-export function Delete(
-  path?: string | RouteMethodOptions,
-  options?: RouteMethodOptions,
-) {
-  const parsedPath =
-    !path && !options ? "/" : (path as string | RouteMethodOptions);
-  if (options) {
-    return createRouteDecorator("DELETE")(parsedPath, options);
-  } else {
-    return createRouteDecorator("DELETE")(parsedPath);
-  }
-}
-
-export const Patch = createRouteDecorator("PATCH");
-export const Options = createRouteDecorator("OPTIONS");
-export const All = createRouteDecorator("ALL");

package/src/swagger-schema.ts

@@ -1,213 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-import { getMetadataStorage } from "class-validator";
-
-export function generateSwaggerSchema(classType: any): any {
-  const metadataStorage = getMetadataStorage();
-  const validationMetadata = metadataStorage.getTargetValidationMetadatas(
-    classType,
-    "",
-    true,
-    false,
-  );
-
-  const schema: any = {
-    type: "object",
-    properties: {},
-    required: [],
-  };
-
-  const prototype = classType.prototype;
-
-  const propertyKeys = new Set([
-    ...Object.getOwnPropertyNames(prototype),
-    ...validationMetadata.map((m: any) => m.propertyName),
-  ]);
-
-  propertyKeys.forEach((propertyName) => {
-    if (!propertyName || propertyName === "constructor") return;
-
-    const openApiMeta: any = Reflect.getMetadata(
-      "property:openapi",
-      prototype,
-      propertyName,
-    );
-
-    if (openApiMeta?.exclude) return;
-
-    const propertyType = Reflect.getMetadata(
-      "design:type",
-      prototype,
-      propertyName,
-    );
-
-    let swaggerProperty: any = {};
-
-    switch (propertyType) {
-      case String:
-        swaggerProperty.type = "string";
-        break;
-      case Number:
-        swaggerProperty.type = "number";
-        break;
-      case Boolean:
-        swaggerProperty.type = "boolean";
-        break;
-      case Date:
-        swaggerProperty.type = "string";
-        swaggerProperty.format = "date-time";
-        break;
-      case Array:
-        swaggerProperty.type = "array";
-        swaggerProperty.items = { type: "string" }; // fallback
-        break;
-      case Object:
-        swaggerProperty = generateSwaggerSchema(propertyType);
-        break;
-      default:
-        swaggerProperty.type = propertyType?.name?.toLowerCase() || "string";
-    }
-
-    // Apply OpenApi metadata if present
-    if (openApiMeta) {
-      swaggerProperty = {
-        ...swaggerProperty,
-        ...extractOpenApiFields(openApiMeta),
-      };
-    }
-
-    schema.properties[propertyName] = swaggerProperty;
-  });
-
-  // Handle validation rules
-  validationMetadata.forEach((meta: any) => {
-    const propertyName = meta.propertyName;
-    switch (meta.name) {
-      case "isNotEmpty":
-        if (!schema.required.includes(propertyName)) {
-          schema.required.push(propertyName);
-        }
-        break;
-      case "isDefined":
-        if (!schema.required.includes(propertyName)) {
-          schema.required.push(propertyName);
-        }
-        break;
-      case "isOptional":
-        schema.required = schema.required.filter(
-          (item: any) => item !== propertyName,
-        );
-        break;
-      case "minLength":
-        schema.properties[propertyName].minLength = meta.constraints[0];
-        break;
-      case "maxLength":
-        schema.properties[propertyName].maxLength = meta.constraints[0];
-        break;
-      case "min":
-        schema.properties[propertyName].minimum = meta.constraints[0];
-        break;
-      case "max":
-        schema.properties[propertyName].maximum = meta.constraints[0];
-        break;
-      case "isEmail":
-        schema.properties[propertyName].format = "email";
-        break;
-      case "isDate":
-        schema.properties[propertyName].format = "date-time";
-        break;
-      case "isIn":
-        schema.properties[propertyName].enum = meta.constraints[0];
-        break;
-      case "isNumber":
-        schema.properties[propertyName].type = "number";
-        break;
-      case "isInt":
-        schema.properties[propertyName].type = "integer";
-        break;
-      case "isBoolean":
-        schema.properties[propertyName].type = "boolean";
-        break;
-      case "isString":
-        schema.properties[propertyName].type = "string";
-        break;
-    }
-  });
-  return schema;
-}
-
-function extractOpenApiFields(meta: any): any {
-  const result: any = {};
-  const fields = [
-    "description",
-    "summary",
-    "deprecated",
-    "example",
-    "enum",
-    "format",
-    "default",
-    "minimum",
-    "maximum",
-    "minLength",
-    "maxLength",
-    "pattern",
-    "oneOf",
-    "allOf",
-    "anyOf",
-  ];
-
-  fields.forEach((field) => {
-    if (meta[field] !== undefined) {
-      result[field] = meta[field];
-    }
-  });
-
-  return result;
-}
-
-// export function generateSwaggerSchema(classType: any) {
-//   const { getMetadataStorage } = require("class-validator");
-//   const { plainToInstance } = require("class-transformer");
-
-//   const metadataStorage = getMetadataStorage();
-//   const validationMetadata = metadataStorage.getTargetValidationMetadatas(
-//     classType,
-//     "",
-//     true,
-//   );
-
-//   const schema: any = {
-//     type: "object",
-//     properties: {},
-//     required: [],
-//   };
-
-//   validationMetadata.forEach((meta: any) => {
-//     const propertyName = meta.propertyName;
-
-//     // Infer the type dynamically using Reflect metadata
-//     const propertyType = Reflect.getMetadata(
-//       "design:type",
-//       classType.prototype,
-//       propertyName,
-//     );
-
-//     schema.properties[propertyName] = {
-//       type: propertyType?.name.toLowerCase() || "string", // Default to string if type cannot be inferred
-//     };
-
-//     if (meta.name === "isNotEmpty") {
-//       schema.required.push(propertyName);
-//     }
-
-//     if (meta.name === "minLength") {
-//       schema.properties[propertyName].minLength = meta.constraints[0];
-//     }
-//   });
-
-//   return schema;
-// }

package/src/testing.ts

@@ -1,220 +0,0 @@
-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,18 +0,0 @@
-/**
- * @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,7 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-export interface IApplication {}

package/src/utils/hash.ts

@@ -1,8 +0,0 @@
-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 +0,0 @@
-export * from "./hash";
-export * from "./optional-require";

package/src/utils/optional-require.ts

@@ -1,50 +0,0 @@
-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;
-  }
-}