@avleon/core 0.0.19 → 0.0.24

package/src/authentication.ts

@@ -0,0 +1,16 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+
+export type CurrentUser = {};
+
+export abstract class BaseAuthetication {
+  abstract authenticate(): Promise<Boolean>;
+  abstract authorize(): Promise<Boolean>;
+}
+
+export function Authorized() {}
+export function CurrentUser() {}

package/src/collection.ts

@@ -0,0 +1,254 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+import Container from "typedi";
+import { NotFoundException } from "./exceptions";
+import {
+  DataSource,
+  EntityTarget,
+  FindOneOptions,
+  ObjectLiteral,
+  Repository,
+} from "typeorm";
+import { UpsertOptions } from "typeorm/repository/UpsertOptions";
+
+type ObjKey<T> = keyof T;
+type ObjKeys<T> = ObjKey<T>[];
+type PaginationOptions = {
+  take: number;
+  skip?: number;
+};
+
+type Predicate<T> = (item: T) => boolean;
+interface TypeormEnitity extends ObjectLiteral {}
+
+export type PaginationResult<T> = {
+  total: number;
+  data: T[];
+  next?: number | null;
+  prev?: number | null;
+  first?: number | null;
+  last?: number | null;
+  totalPage?: number;
+};
+
+type ICollection<T> = {
+  findAll(): T[] | Promise<T[]>;
+};
+
+type EntityCollection<T extends ObjectLiteral> = {};
+
+class BasicCollection<T> implements ICollection<T> {
+  private items: T[];
+
+  private constructor(items: T[]) {
+    this.items = items;
+  }
+
+  static from<T>(items: T[]): BasicCollection<T> {
+    return new BasicCollection(items);
+  }
+
+  findAll(predicate?: Predicate<T>) {
+    const results = Array.from(this.items);
+    return results;
+  }
+
+  findOne(predicate: Predicate<T> | FindOneOptions<T>): T | Promise<T | null> {
+    if (this.isFunction(predicate)) {
+      return this.items.find(predicate as Predicate<T>) as T;
+    }
+    throw new Error("Invalid predicate type");
+  }
+
+  // Utility function to check if a value is a function
+  private isFunction(value: unknown): value is Function {
+    return typeof value === "function";
+  }
+
+  add(item: Partial<T>): T;
+  add(item: Partial<T>): T | Promise<T> {
+    this.items.push(item as T);
+    return this.items[this.items.length - 1];
+  }
+
+  addAll(items: T[]): void {
+    this.items.push(...items);
+  }
+  update(predicate: (item: T) => boolean, updater: Partial<T>): void {
+    const item = this.items.find(predicate);
+    if (item) {
+      const index = this.items.indexOf(item)!;
+      this.items[index] = { ...item, ...updater };
+    } else {
+      throw new NotFoundException("Item not found");
+    }
+  }
+
+  updateAll(predicate: (item: T) => boolean, updater: (item: T) => T): void {
+    for (let i = 0; i < this.items.length; i++) {
+      if (predicate(this.items[i])) {
+        this.items[i] = updater(this.items[i]);
+      }
+    }
+  }
+  delete(predicate: (item: T) => boolean): void {
+    const index = this.items.findIndex(predicate);
+    if (index !== -1) {
+      this.items.splice(index, 1);
+    }
+  }
+  deleteAll(predicate: (item: T) => boolean): void {
+    this.items = this.items.filter((item) => !predicate(item));
+  }
+  max<K extends keyof T>(key: K & string): number {
+    return Math.max(...this.items.map((item) => item[key] as number));
+  }
+
+  min<K extends keyof T>(key: K & string): number {
+    return Math.max(...this.items.map((item) => item[key] as number));
+  }
+
+  sum<K extends keyof T>(key: K & string): number {
+    const nums = this.items.flatMap((x) => x[key]) as number[];
+    return nums.reduce((sum, num) => sum + num, 0);
+  }
+
+  avg<K extends keyof T>(key: K & string): number {
+    const nums = this.items.flatMap((x) => x[key]) as number[];
+    return nums.reduce((sum, num) => sum + num, 0) / nums.length;
+  }
+
+  paginate(options?: PaginationOptions) {
+    const take = options?.take || 10;
+    const skip = options?.skip || 0;
+    const total = this.items.length;
+    const data = this.items.slice(skip, take);
+    return {
+      total,
+      totalPage: Math.ceil(total / take),
+      next: skip + take < total ? skip + take : null,
+      data,
+    };
+  }
+
+  private getDeepValue(item: any, path: string | keyof T): any {
+    if (typeof path !== "string") return item[path];
+    return path.split(".").reduce((acc, key) => acc?.[key], item);
+  }
+}
+
+class AsynchronousCollection<T extends ObjectLiteral> {
+  private model: EntityTarget<T>;
+  private repo?: Repository<T>;
+
+  private constructor(model: EntityTarget<T>) {
+    this.model = model;
+  }
+
+  static fromRepository<T extends ObjectLiteral>(
+    model: EntityTarget<T>,
+  ): AsynchronousCollection<T> {
+    return new AsynchronousCollection(model);
+  }
+
+  getRepository() {
+    if (!this.repo) {
+      const dataSourceKey = "idatasource";
+      const dataSource = Container.get(dataSourceKey) as DataSource;
+      console.log('datasource', dataSource);
+      const repository = dataSource.getRepository<T>(this.model);
+      this.repo = repository;
+      return repository;
+    }
+    return this.repo;
+  }
+
+  // Pagination with query builder
+  async paginate(options?: PaginationOptions): Promise<PaginationResult<T>> {
+    const take = options?.take || 10;
+    const skip = options?.skip || 0;
+
+    const [data, total] = await this.getRepository().findAndCount({
+      take,
+      skip,
+    });
+
+    return {
+      total,
+      totalPage: Math.ceil(total / take),
+      next: skip + take < total ? skip + take : null,
+      prev: skip + take < total ? skip + take : null,
+      data,
+    };
+  }
+}
+
+export class Collection {
+  private constructor() {}
+
+  static from<T>(items: T[]): BasicCollection<T> {
+    return BasicCollection.from(items);
+  }
+  // Example refactoring of Collection.fromRepository for better type safety
+  static fromRepository<T extends ObjectLiteral>(
+    entity: EntityTarget<T>,
+  ): Repository<T> {
+    const asyncCollection = AsynchronousCollection.fromRepository(entity);
+    // Assuming AsynchronousCollection has a method to get the Repository<T>
+    return asyncCollection.getRepository();
+  }
+}
+
+export function InjectRepository<T extends Repository<T>>(
+  model: EntityTarget<T>,
+) {
+  return function (
+    object: any,
+    propertyName: string | undefined,
+    index?: number,
+  ) {
+    let repo!: any | Repository<T>;
+    try {
+      Container.registerHandler({
+        object,
+        propertyName,
+        index,
+        value: (containerInstance) => {
+          const dataSource = containerInstance.get<DataSource>("idatasource");
+    
+          repo = dataSource
+            .getRepository<T>(model)
+            .extend({ paginate: () => {} });
+          repo.paginate = async function (
+            options: PaginationOptions = { take: 10, skip: 0 },
+          ): Promise<PaginationResult<T>> {
+            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: any) {
+      console.log(error);
+      if (error.name && error.name == "ServiceNotFoundError") {
+        console.log("Database didn't initialized.");
+      }
+    }
+  };
+}

package/src/config.ts

@@ -0,0 +1,39 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+import { Container, Service, Constructable } from "typedi";
+import { Environment } from "./environment-variables";
+
+export interface IConfig<T = any> {
+  config(env: Environment): T;
+}
+
+export function Config<T extends IConfig>(target: Constructable<T>) {
+  Container.set({ id: target, type: target });
+}
+
+export class AppConfig {
+  get<T extends IConfig<R>, R>(configClass: Constructable<T>): R {
+    const instance = Container.get(configClass);
+    if (!instance) {
+      throw new Error(`Configuration for ${configClass.name} not found.`);
+    }
+    return instance.config(new Environment());
+  }
+}
+
+export function GetConfig<
+  T extends IConfig<R>,
+  R = ReturnType<InstanceType<Constructable<T>>["config"]>,
+>(ConfigClass: Constructable<T>): R {
+  const instance = Container.get(ConfigClass);
+  if (!instance) {
+    throw new Error(
+      `Class "${ConfigClass.name}" is not registered as a config.`,
+    );
+  }
+  return instance.config(new Environment());
+}

package/src/constants.ts

@@ -0,0 +1 @@
+export const TEST_DATASOURCE_OPTIONS_KEY = Symbol("itestdatasource");

package/src/container.ts

@@ -0,0 +1,54 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+import TypediContainer, { ContainerInstance, Token } from "typedi";
+import { DataSource } from "typeorm";
+
+export const FEATURE_KEY = Symbol.for("features");
+export const ROUTE_META_KEY = Symbol("iroute:options");
+export const CONTROLLER_META_KEY = Symbol("icontroller:options");
+export const PARAM_META_KEY = Symbol("iparam:options");
+export const QUERY_META_KEY = Symbol("iparam:options");
+export const REQUEST_BODY_META_KEY = Symbol("iparam:options");
+export const REQUEST_BODY_FILE_KEY = Symbol("iparam:options");
+export const REQUEST_BODY_FILES_KEY = Symbol("iparam:options");
+export const REQUEST_USER_META_KEY = Symbol("iparam:options");
+export const REQUEST_HEADER_META_KEY = Symbol("iheader:options");
+export const DATASOURCE_META_KEY = Symbol("idatasource:options");
+export const AUTHORIZATION_META_KEY = Symbol("idatasource:authorization");
+
+const controllerRegistry = new Set<Function>();
+const serviceRegistry = new Set<Function>();
+const optionsRegistry = new Map<string, any>();
+
+const Container = TypediContainer;
+
+export function registerController(controller: Function) {
+  controllerRegistry.add(controller);
+}
+export function registerService(service: Function) {
+  Container.set(service, service);
+  serviceRegistry.add(service);
+}
+
+export function getRegisteredServices(): Function[] {
+  return Array.from(serviceRegistry);
+}
+export function getRegisteredControllers(): Function[] {
+  return Array.from(controllerRegistry);
+}
+
+export const API_CONTROLLER_METADATA_KEY = Symbol("apiController");
+
+export function isApiController(target: Function): boolean {
+  return Reflect.getMetadata(API_CONTROLLER_METADATA_KEY, target) === true;
+}
+Container.set<string>("appName", "Iqra");
+
+export function registerDataSource(dataSource: any) {
+  Container.set<DataSource>("idatasource", dataSource);
+}
+export default Container;

package/src/controller.ts

@@ -0,0 +1,128 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+
+
+import Container, { Service } from "typedi";
+import container, {
+  API_CONTROLLER_METADATA_KEY,
+  CONTROLLER_META_KEY,
+  registerController,
+} from "./container";
+
+/**
+ * Options for configuring a controller.
+ * @remarks
+ * Controller default options
+ * @type {Object} ControllerOptions
+ * @property {string} [name] - The name of the controller.
+ * @property {string} [path] - The base path for the controller's routes.
+ * @property {string} [version] - The version of the controller. If not provided, it will default to the version from `package.json`.
+ * @property {string} [since] - The date or version since the controller was introduced.
+ * @property {any} [meta] - Additional metadata associated with the controller.
+ */
+export type ControllerOptions = {
+  /**
+   *@property {string} name
+   *@description Name of the controller. If specified it'll used as  swagger tags
+   *@default Contorller class name
+   * */
+  name?: string;
+  path?: string;
+  version?: string; // Will look at package.json if not set
+  since?: string;
+  meta?: any;
+};
+
+export function createControllerDecorator(
+  type: "api" | "web" = "web",
+): (
+  pathOrOptions?: string | ControllerOptions,
+  maybeOptions?: ControllerOptions,
+) => ClassDecorator {
+  return function (
+    pathOrOptions?: string | ControllerOptions,
+    maybeOptions?: ControllerOptions,
+  ): ClassDecorator {
+    return function (target: Function) {
+      let path = "/";
+      let options: ControllerOptions = {};
+
+      if (typeof pathOrOptions === "string") {
+        path = pathOrOptions;
+        options = maybeOptions || {};
+      } else if (typeof pathOrOptions === "object") {
+        options = pathOrOptions;
+        path = options.path || "/";
+      }
+      Reflect.defineMetadata(API_CONTROLLER_METADATA_KEY, true, target);
+      // Ensure Service is applied as a ClassDecorator
+      if (typeof Service === "function") {
+        registerController(target); // Add to custom registry
+        Service()(target); // Apply DI decorator
+        Reflect.defineMetadata(
+          CONTROLLER_META_KEY,
+          { type, path, options },
+          target,
+        );
+      } else {
+        throw new Error("Service decorator is not a function");
+      }
+    };
+  };
+}
+
+// Predefined Controller Decorators
+//export const Controller = createControllerDecorator("web");
+/**
+ *@description Api controller's are used for rest . It will populate
+ * json on return and all it http methods {get} {post} etc must return
+ *Results.*
+ * @param path {string} this will used as route prefix
+ *
+ **/
+
+export function ApiController(target: Function): void;
+export function ApiController(path: string): ClassDecorator;
+/**
+ *@description Api controller's are used for rest . It will populate
+ * json on return and all it http methods {get} {post} etc must return
+ * Results.*
+ * @param {ControllerOptions} options this will used as route prefix
+ *
+ **/
+export function ApiController(options: ControllerOptions): ClassDecorator;
+export function ApiController(
+  path: string,
+  options?: ControllerOptions,
+): ClassDecorator;
+export function ApiController(
+  pathOrOptions: Function |string | ControllerOptions = "/",
+  mayBeOptions?: ControllerOptions,
+): any {
+  if (typeof pathOrOptions == 'function') {
+    Reflect.defineMetadata(API_CONTROLLER_METADATA_KEY, true, pathOrOptions);
+    // Ensure Service is applied as a ClassDecorator
+    if (typeof Service === "function") {
+      registerController(pathOrOptions); // Add to custom registry
+      Service()(pathOrOptions); // Apply DI decorator
+      Reflect.defineMetadata(
+        CONTROLLER_META_KEY,
+        { type: 'api', path: "/", options: {} },
+        pathOrOptions,
+      );
+    } else {
+      throw new Error("Service decorator is not a function");
+    }
+  } else {
+    if (mayBeOptions) {
+      return createControllerDecorator("api")(pathOrOptions, mayBeOptions);
+    }
+    return createControllerDecorator("api")(pathOrOptions);
+  }
+
+}
+

package/src/decorators.ts

@@ -0,0 +1,27 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+
+import { Service as _service } from "typedi";
+import container, { registerService } from "./container";
+export function AppService(target: any): void;
+export function AppService(): any;
+export function AppService(target?: any) {
+  if (target) {
+    _service()(target);
+  } else {
+    return function (tg: any) {
+      _service()(tg);
+    };
+  }
+}
+
+export * from "./controller";
+export * from "./route-methods";
+export * from "./openapi";
+export const Utility = _service;
+export const Helper = _service;
+export * from "./params";

package/src/environment-variables.ts

@@ -0,0 +1,46 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+
+import dotenv from "dotenv";
+import path from "path";
+import fs from "fs";
+import { Service } from "typedi";
+import { EnvironmentVariableNotFound, SystemUseError } from "./exceptions/system-exception";
+
+dotenv.config({ path: path.join(process.cwd(), ".env") });
+
+@Service()
+export class Environment {
+  private parseEnvFile(filePath: string): any {
+    try {
+      const fileContent = fs.readFileSync(filePath, 'utf8');
+      const parsedEnv = dotenv.parse(fileContent);
+      return { ...parsedEnv, ...process.env };
+    } catch (error) {
+      console.error(`Error parsing .env file: ${error}`);
+      return {};
+    }
+  }
+
+  get<T = any>(key: string): T {
+    const parsedEnv = this.parseEnvFile(path.join(process.cwd(), '.env'));
+    return parsedEnv[key] as T;
+  }
+
+  getOrThrow<T = any>(key: string): T {
+    const parsedEnv = this.parseEnvFile(path.join(process.cwd(), '.env'));
+    if (!Object(parsedEnv).hasOwnProperty(key)) {
+      throw new EnvironmentVariableNotFound(key)
+    }
+    return parsedEnv[key] as T;
+  }
+
+  getAll<T = any>(): T {
+    const parsedEnv = this.parseEnvFile(path.join(process.cwd(), '.env'));
+    return parsedEnv as T;
+  }
+}

package/src/exceptions/http-exceptions.ts

@@ -0,0 +1,86 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+export abstract class BaseHttpException extends Error {
+  code: number = 500;
+  name: string = "HttpException";
+  constructor(message: any) {
+    super(JSON.stringify(message));
+  }
+  isCustomException() {
+    return true;
+  }
+}
+
+export class BadRequestException extends BaseHttpException {
+  name: string = "BadRequest";
+  code: number = 400;
+
+  constructor(message: any) {
+    super(message);
+  }
+}
+
+export class ValidationErrorException extends BadRequestException {
+  name: string = "ValidationError";
+}
+
+export class InternalErrorException extends BaseHttpException {
+  name: string = "InternalError";
+  code: number = 500;
+
+  constructor(message: any = "Something going wrong") {
+    super(message);
+  }
+}
+
+export class NotFoundException extends BaseHttpException {
+  name: string = "NotFound";
+  code: number = 404;
+  constructor(message: any) {
+    super(message);
+  }
+}
+
+export class UnauthorizedException extends BaseHttpException {
+  name: string = "Unauthorized";
+  code: number = 401;
+  constructor(message: any) {
+    super(message);
+  }
+}
+
+export class ForbiddenException extends BaseHttpException {
+  name: string = "Forbidden";
+  code: number = 403;
+  constructor(message: any) {
+    super(message);
+  }
+}
+
+export type HttpException =
+  | NotFoundException
+  | BadRequestException
+  | UnauthorizedException
+  | InternalErrorException
+  | ForbiddenException;
+
+// export type 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
+// }
+// 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)
+// }

package/src/exceptions/index.ts

@@ -0,0 +1 @@
+export * from './http-exceptions';

package/src/exceptions/system-exception.ts

@@ -0,0 +1,34 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+export interface IRouteDuplicateErr {
+    path: string,
+    mpath: string,
+    method: string,
+    controller: string,
+    inverseController?: string
+}
+
+export class SystemUseError extends Error {
+    constructor(message: string) {
+        super(message);
+    }
+}
+export class DuplicateRouteException extends Error {
+    constructor(params: IRouteDuplicateErr) {
+        let sameController = params.controller == params.inverseController;
+        let message = `Duplicate route found for method ${params.method.toUpperCase()}:${params.path == "" ? "'/'" : params.path} `
+        message += sameController ? `in ${params.controller}` : `both in ${params.controller} and ${params.inverseController}`;
+        super(message);
+    }
+}
+
+
+export class EnvironmentVariableNotFound extends Error{
+    constructor(key: string) {
+        super(`${key} not found in environment variables.`)
+    }
+}