@avleon/core 0.0.29 → 0.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avleon/core",
-  "version": "0.0.29",
+  "version": "0.0.30",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
@@ -103,7 +103,6 @@
     "url": "git+https://github.com/avleonjs/avleon-core"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ]
 }

package/src/application.ts

@@ -1,104 +0,0 @@
-import Container from "typedi";
-import { Constructor } from "./helpers";
-import fastify, { FastifyInstance, RouteShorthandMethod } from "fastify";
-
-export interface AvleonApplication {
-  // all public
-  useCors: () => void;
-  useOpenApi: () => void;
-  useView: () => void;
-  useAuth: () => void;
-  useMultipart: () => void;
-  useDataSource: () => void;
-  useMiddlewares: () => void;
-  useControllers: () => void;
-  useAutoControllers: () => void;
-  useStaticFiles: () => void;
-  useCustomErrorHandler: () => void;
-
-  // all mapping
-  mapGroup: () => any;
-  mapGet: () => any;
-  mapPost: () => any;
-  mapPut: () => any;
-  mapPatch: () => any;
-  mapDelete: () => any;
-  mapView: () => any;
-
-  // run
-  run: (port: number) => void;
-}
-
-export interface InlineRoutes {
-  get: RouteShorthandMethod;
-  post: RouteShorthandMethod;
-  put: RouteShorthandMethod;
-  patch: RouteShorthandMethod;
-  delete: RouteShorthandMethod;
-}
-
-export interface Application {
-  inlineRoutes: () => InlineRoutes;
-  mapGroup: (path?: string | RegExp) => InlineRoutes;
-
-  /**
-   * Start the application
-   * @param port
-   * @returns void
-   */
-  start: (port?: number) => void;
-}
-
-export interface TestApplication {
-  getController: <T>(controller: Constructor<T>) => T;
-}
-
-class IqraTestApplication implements TestApplication {
-  getController<T>(controller: Constructor<T>) {
-    const con = Container.get(controller);
-    return con;
-  }
-}
-class IqraApplication implements Application {
-  private app!: FastifyInstance;
-
-  constructor() {
-    if (!this.app) {
-      this.app = fastify.prototype;
-    }
-  }
-
-  inlineRoutes() {
-    return {
-      get: this.app.get,
-      post: this.app.post,
-      put: this.app.put,
-      patch: this.app.patch,
-      delete: this.app.delete,
-    };
-  }
-
-  mapGroup(path?: string | RegExp) {
-    return this.inlineRoutes();
-  }
-
-  start(port?: number) {
-    const p = port ? port : 4000;
-    this.app.listen({ port: p });
-  }
-}
-
-export class Builder {
-  static createApplication(): Application {
-    const app = new IqraApplication();
-    return app;
-  }
-
-  static createTestApplication(app?: Application): TestApplication {
-    const testApp = new IqraTestApplication();
-    return testApp;
-  }
-}
-
-const app = Builder.createApplication();
-const route = app.inlineRoutes();

package/src/authentication.ts

@@ -1,16 +0,0 @@
-/**
- * @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/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 { AppConfig, 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", () => {
-      @AppConfig
-      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");
-    });
-  });
-});