@avleon/core 0.0.27 → 0.0.29

package/src/application.ts

@@ -1,125 +1,104 @@
-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();
-
-
-
+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 +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() {}
+/**
+ * @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 +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);
-      }
-    }
-  }
-}
+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

@@ -0,0 +1,71 @@
+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);
+    });
+  });
+});