@avleon/core 0.0.20 → 0.0.25

package/src/application.ts

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

@@ -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/cache.ts

@@ -0,0 +1,91 @@
+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.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,42 @@
+/**
+ * @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,127 @@
+/**
+ * @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);
+  }
+
+}
+