@avleon/core 0.0.28 → 0.0.30

package/src/cache.ts

@@ -1,91 +0,0 @@
-import type { Redis } from "ioredis";
-
-type CacheEntry<T = any> = {
-  data: T;
-  timestamp: number;
-};
-
-export class CacheManager {
-  private store = new Map<string, CacheEntry>();
-  private tagsMap = new Map<string, Set<string>>();
-  private redis: Redis | null = null;
-
-  constructor(redisInstance?: Redis) {
-    this.redis = redisInstance || null;
-  }
-
-  private redisTagKey(tag: string) {
-    return `cache-tags:${tag}`;
-  }
-
-  async get<T>(key: string): Promise<T | null> {
-    if (this.redis) {
-      const val = await this.redis.get(key);
-      return val ? JSON.parse(val) : null;
-    }
-
-    const cached = this.store.get(key);
-    return cached ? cached.data : null;
-  }
-
-  async set<T>(
-    key: string,
-    value: T,
-    tags: string[] = [],
-    ttl: number = 3600,
-  ): Promise<void> {
-    const entry: CacheEntry<T> = {
-      data: value,
-      timestamp: Date.now(),
-    };
-
-    if (this.redis) {
-      await this.redis.set(key, JSON.stringify(entry.data), "EX", ttl);
-      for (const tag of tags) {
-        await this.redis.sadd(this.redisTagKey(tag), key);
-      }
-    } else {
-      this.store.set(key, entry);
-      for (const tag of tags) {
-        if (!this.tagsMap.has(tag)) this.tagsMap.set(tag, new Set());
-        this.tagsMap.get(tag)!.add(key);
-      }
-    }
-  }
-
-  async delete(key: string): Promise<void> {
-    if (this.redis) {
-      await this.redis.del(key);
-
-      // Also clean up from any tag sets
-      const tagKeys = await this.redis.keys("cache-tags:*");
-      for (const tagKey of tagKeys) {
-        await this.redis.srem(tagKey, key);
-      }
-    } else {
-      this.store.delete(key);
-      for (const keys of this.tagsMap.values()) {
-        keys.delete(key);
-      }
-    }
-  }
-
-  async invalidateTag(tag: string): Promise<void> {
-    if (this.redis) {
-      const tagKey = this.redisTagKey(tag);
-      const keys = await this.redis.smembers(tagKey);
-      if (keys.length) {
-        await this.redis.del(...keys); // delete all cached keys
-        await this.redis.del(tagKey); // delete the tag set
-      }
-    } else {
-      const keys = this.tagsMap.get(tag);
-      if (keys) {
-        for (const key of keys) {
-          this.store.delete(key);
-        }
-        this.tagsMap.delete(tag);
-      }
-    }
-  }
-}

package/src/collection.test.ts

@@ -1,71 +0,0 @@
-import Container from "typedi";
-import { CreateConfig, GetConfig } from "./config";
-import { BasicCollection, Collection } from "./collection";
-
-type Todo = {
-  id: number;
-  body: string;
-  completed: boolean;
-};
-
-describe("Collection", () => {
-  let collection!: BasicCollection<Todo>;
-  beforeEach(() => {
-    collection = Collection.from<Todo>([
-      {
-        id: 1,
-        body: "test 1",
-        completed: false,
-      },
-      {
-        id: 2,
-        body: "test 2",
-        completed: true,
-      },
-      {
-        id: 3,
-        body: "test 2",
-        completed: true,
-      },
-    ]);
-  });
-
-  afterEach(() => {
-    collection.clear();
-  });
-
-  describe("find()", () => {
-    it("should be return collection", () => {
-      const result = collection.find();
-      expect(result).toHaveProperty("length");
-      expect(result.length).toBe(3);
-    });
-
-    it("should return only completed task", () => {
-      const result = collection.find((todo) => todo.completed);
-      expect(result).toHaveProperty("length");
-      expect(result.length).toBe(2);
-      expect(result[0].id).toBe(2);
-    });
-  });
-
-  describe("findOne()", () => {
-    it("should be return todo", () => {
-      const result = collection.findOne({ where: { id: 1 } });
-      expect(result).toHaveProperty("id");
-      expect(result?.id).toBe(1);
-    });
-
-    it("should return only completed task", () => {
-      const result = collection.findOne({
-        where: {
-          id: {
-            $in: [3],
-          },
-        },
-      });
-      expect(result).toHaveProperty("id");
-      expect(result?.completed).toBe(true);
-    });
-  });
-});

package/src/collection.ts

@@ -1,344 +0,0 @@
-/**
- * @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 {}
-type Primitive = string | number | boolean | null;
-
-type ValueOperator<T> = {
-  $in?: T[];
-};
-
-type FieldCondition<T> = T | ValueOperator<T>;
-
-type WhereCondition<T> = {
-  [K in keyof T]?: FieldCondition<T[K]>;
-};
-
-type LogicalOperators<T> =
-  | { $and: Where<T>[] }
-  | { $or: Where<T>[] }
-  | { $not: Where<T> };
-
-type Where<T> = WhereCondition<T> | LogicalOperators<T>;
-
-export interface IFindOneOptions<T = any> {
-  where: Where<T>;
-}
-
-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> = {};
-
-export interface BasicCollection<T> {
-  clear(): void;
-  find(predicate?: Predicate<T>): T[];
-  findAsync(predicate?: Predicate<T>): Promise<T[]>;
-  findOne(predicate: Predicate<T> | IFindOneOptions<T>): T | undefined;
-  findOneAsync(
-    predicate: Predicate<T> | IFindOneOptions<T>,
-  ): Promise<T | undefined>;
-}
-class BasicCollectionImpl<T> implements BasicCollection<T> {
-  private items: T[];
-
-  private constructor(items: T[]) {
-    this.items = items;
-  }
-
-  static from<T>(items: T[]): BasicCollectionImpl<T> {
-    return new BasicCollectionImpl(items);
-  }
-
-  clear() {
-    this.items = [];
-  }
-
-  find(predicate?: Predicate<T>) {
-    if (this.isFunction(predicate)) {
-      return this.items.filter(predicate as Predicate<T>) as T[];
-    }
-    const results = Array.from(this.items);
-    return results;
-  }
-
-  async findAsync(predicate?: Predicate<T>): Promise<T[]> {
-    const results = Array.from(this.items);
-    return results;
-  }
-
-  private _matches<T>(item: T, where: Where<T>): boolean {
-    if ("$or" in where) {
-      return where.$or.some((cond) => this._matches(item, cond));
-    }
-
-    if ("$and" in where) {
-      return where.$and.every((cond) => this._matches(item, cond));
-    }
-
-    if ("$not" in where) {
-      return !this._matches(item, where.$not);
-    }
-
-    // Field-based matching
-    return Object.entries(where).every(([key, condition]) => {
-      const itemValue = item[key as keyof T];
-      if (
-        condition &&
-        typeof condition === "object" &&
-        !Array.isArray(condition)
-      ) {
-        const op = condition as ValueOperator<any>;
-
-        if ("$in" in op && Array.isArray(op.$in)) {
-          return op.$in.includes(itemValue);
-        }
-      }
-
-      return itemValue === condition;
-    });
-  }
-
-  findOne(predicate: Predicate<T> | IFindOneOptions<T>): T | undefined {
-    if (this.isFunction(predicate)) {
-      return this.items.find(predicate as Predicate<T>) as T;
-    }
-    const result = this.items.filter((item) =>
-      this._matches(item, predicate.where),
-    );
-    if (result.length > 0) {
-      return result[0];
-    }
-    return undefined;
-  }
-
-  async findOneAsync(
-    predicate: Predicate<T> | IFindOneOptions<T>,
-  ): Promise<T | undefined> {
-    if (this.isFunction(predicate)) {
-      return this.items.find(predicate as Predicate<T>) as T;
-    }
-    return this.items.find((item) => this._matches(item, predicate.where));
-  }
-
-  // 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 BasicCollectionImpl.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.test.ts

@@ -1,35 +0,0 @@
-import "reflect-metadata";
-import { Config, CreateConfig, GetConfig, IConfig } from "./config";
-import { Environment } from "./environment-variables";
-
-type AppConfig = { name: string; os: string };
-
-describe("Config", () => {
-  describe("class", () => {
-    it("should be call by get config", () => {
-      @Config
-      class MyConfig {
-        config(env: Environment) {
-          return {
-            name: "avleon",
-          };
-        }
-      }
-      const mConfig = GetConfig(MyConfig);
-      expect(mConfig).toHaveProperty("name");
-      expect(mConfig["name"]).toBe("avleon");
-    });
-  });
-
-  describe("createConfig()", () => {
-    it("it should create config and called with GetConfig", () => {
-      CreateConfig("myconfig", (env) => ({
-        firstname: "tareq",
-        os: env.get("name"),
-      }));
-      const mConfig = GetConfig("myconfig");
-      expect(mConfig).toHaveProperty("firstname");
-      expect(mConfig.firstname).toBe("tareq");
-    });
-  });
-});

package/src/config.ts

@@ -1,85 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-import { Container, Service, Constructable, Token } from "typedi";
-import { Environment } from "./environment-variables";
-import { inject } from "./helpers";
-
-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());
-// }
-
-export function GetConfig<
-  T extends IConfig<R>,
-  R = ReturnType<InstanceType<Constructable<T>>["config"]>,
->(ConfigClass: Constructable<T>): R;
-
-export function GetConfig<T = any>(config: string | symbol): T;
-
-// Implementation
-export function GetConfig<R>(token: any): R {
-  // 1. Class‐based: token.prototype.config is a function
-  if (
-    typeof token === "function" &&
-    token.prototype != null &&
-    typeof token.prototype.config === "function"
-  ) {
-    const instance = Container.get(token as Constructable<any>);
-    if (!instance) {
-      throw new Error(`Class "${token.name}" is not registered as a config.`);
-    }
-    return instance.config(inject(Environment));
-  }
-
-  // 2. Functional: token is the callback itself
-  const stored = Container.get(token);
-  if (!stored) {
-    throw new Error("Config object is not registered.");
-  }
-  return stored as R;
-}
-
-export function CreateConfig<T>(
-  token: string | symbol,
-  callback: (env: Environment) => T,
-) {
-  let env!: Environment;
-  try {
-    env = Container.get(Environment);
-  } catch (error) {
-    env = new Environment();
-  }
-
-  let config: T = callback(env);
-  Container.set<T>(token as Token<T>, config);
-}

package/src/constants.ts

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

package/src/container.ts

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