@avleon/core 0.0.20 → 0.0.25

package/src/results.ts

@@ -0,0 +1,30 @@
+export type OkOptions = {
+  streamable: boolean;
+};
+
+export class Results {
+  static code = 500;
+  message: string = "Something going wrong";
+
+  static Ok<T>(data: T): Ok<T> {
+    return new Ok<T>(data);
+  }
+  static NoContent() {
+    this.code = 204;
+  }
+  static OkStream() {}
+  static NotFound<T>(message: T) {
+    return new NotFound<T>(message);
+  }
+}
+
+export class Ok<T> {
+  constructor(public data: T) {}
+}
+
+export class NotFound<T> {
+  constructor(public message: T) {}
+}
+
+// This type ensures methods must return Results.Ok
+export type RouteResult<T = any> = typeof Results.Ok<T>;

package/src/route-methods.ts

@@ -0,0 +1,186 @@
+/**
+ * @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

@@ -0,0 +1,213 @@
+/**
+ * @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

@@ -0,0 +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');
+//   }
+// }

package/src/types/app-builder.interface.ts

@@ -0,0 +1,19 @@
+/**
+ * @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

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

package/src/utils/hash.ts

@@ -0,0 +1,5 @@
+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

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