@avleon/core 0.0.46 → 0.0.48

package/package.json

@@ -1,11 +1,23 @@
 {
   "name": "@avleon/core",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "description": "TypeScript-first web framework built on Fastify",
   "author": "Tareq Hossain",
   "license": "ISC",
+  "type": "module",
   "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "files": [
     "dist",
     "README.md",
@@ -19,10 +31,9 @@
     "typescript"
   ],
   "scripts": {
-    "build": "npm run clean && tsc",
-    "clean": "rimraf dist",
+    "build": "tsdown",
+    "watch": "tsdown --watch",
     "prepublishOnly": "npm run build",
-    "watch": "tsc-watch",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier --write .",
@@ -31,111 +42,38 @@
     "husky:init": "husky install"
   },
   "dependencies": {
-    "class-transformer": "^0.5.1",
-    "class-validator": "^0.14.2",
-    "fastify": "^5.1.0",
-    "mime": "^3.0.0",
-    "reflect-metadata": "^0.2.2",
-    "typedi": "^0.10.0"
-  },
-  "peerDependencies": {
     "@fastify/cors": "^11.0.0",
     "@fastify/multipart": "^9.0.3",
     "@fastify/static": "^8.1.1",
-    "@fastify/swagger": "^9.4.0",
-    "@fastify/swagger-ui": "^5.1.0",
+    "@fastify/swagger": "^9.7.0",
+    "@fastify/swagger-ui": "^5.2.5",
     "@fastify/view": "^11.0.0",
-    "@scalar/fastify-api-reference": "*",
-    "bcryptjs": "3.0.2",
+    "@scalar/fastify-api-reference": "^1.0.0",
+    "bcryptjs": "^3.0.3",
     "bull": "^4.16.5",
-    "dotenv": "*",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.2",
+    "dotenv": "^17.3.1",
+    "fastify": "^5.1.0",
     "fastify-socket.io": "^4.0.0",
-    "highlight.js": "*",
-    "ioredis": "*",
-    "knex": "*",
-    "mssql": ">=9.0.0",
-    "mysql2": "*",
-    "pg": "*",
-    "pino": "^9.0.0",
-    "pino-pretty": "^13.0.0",
-    "sharp": "*",
-    "socket.io": "*",
-    "sqlite3": "*",
-    "typeorm": "*"
+    "ioredis": "^5.10.1",
+    "knex": "^3.1.0",
+    "mime": "^3.0.0",
+    "mysql2": "^3.0.0",
+    "pg": "^8.0.0",
+    "pino": "^9.14.0",
+    "pino-pretty": "^13.1.3",
+    "reflect-metadata": "^0.2.2",
+    "socket.io": "^4.8.3",
+    "sqlite3": "^5.0.0",
+    "typedi": "^0.10.0",
+    "typeorm": "^0.3.28"
   },
-  "peerDependenciesMeta": {
-    "@fastify/cors": {
-      "optional": true
-    },
-    "@fastify/multipart": {
-      "optional": true
-    },
-    "@fastify/static": {
-      "optional": true
-    },
-    "@fastify/swagger": {
-      "optional": true
-    },
-    "@fastify/swagger-ui": {
-      "optional": true
-    },
-    "@fastify/view": {
-      "optional": true
-    },
-    "@scalar/fastify-api-reference": {
-      "optional": true
-    },
-    "bcryptjs": {
-      "optional": true
-    },
-    "bull": {
-      "optional": true
-    },
-    "dotenv": {
-      "optional": true
-    },
-    "fastify-socket.io": {
-      "optional": true
-    },
-    "highlight.js": {
-      "optional": true
-    },
-    "ioredis": {
-      "optional": true
-    },
-    "knex": {
-      "optional": true
-    },
-    "mssql": {
-      "optional": true
-    },
-    "mysql2": {
-      "optional": true
-    },
-    "pg": {
-      "optional": true
-    },
-    "pino": {
-      "optional": true
-    },
-    "pino-pretty": {
-      "optional": true
-    },
-    "sharp": {
-      "optional": true
-    },
-    "socket.io": {
-      "optional": true
-    },
-    "sqlite3": {
-      "optional": true
-    },
-    "typeorm": {
-      "optional": true
-    }
+  "optionalDependencies": {
+    "mssql": "^11.0.0",
+    "sharp": "^0.33.0"
   },
   "devDependencies": {
-    "@types/bcryptjs": "^3.0.0",
     "@types/jest": "^29.5.14",
     "@types/node": "^20.19.17",
     "@typescript-eslint/eslint-plugin": "^8.44.0",
@@ -146,10 +84,10 @@
     "jest": "^29.7.0",
     "lint-staged": "^16.1.6",
     "prettier": "^3.6.2",
-    "rimraf": "^6.0.1",
     "ts-jest": "^29.4.4",
-    "tsc-watch": "^6.3.1",
-    "typescript": "^5.7.2"
+    "tsdown": "^0.12.0",
+    "typescript": "^5.7.2",
+    "unplugin-unused": "^0.5.7"
   },
   "lint-staged": {
     "*.{js,ts,json,md}": "pnpm format",

package/dist/application.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/application.test.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const testing_1 = require("./core/testing");
-const application_1 = require("./core/application");
-describe("Avleon.createApplication", () => {
-    it("should return an instance of AvleonApplication", () => {
-        const app = testing_1.Avleon.createApplication();
-        expect(app).toBeInstanceOf(application_1.AvleonApplication);
-    });
-    it("should always return the same instance (singleton)", () => {
-        const app1 = testing_1.Avleon.createApplication();
-        const app2 = testing_1.Avleon.createApplication();
-        expect(app1).toBe(app2);
-    });
-});

package/dist/authentication.d.ts

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

package/dist/authentication.js

@@ -1,16 +0,0 @@
-"use strict";
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseAuthetication = void 0;
-exports.Authorized = Authorized;
-exports.CurrentUser = CurrentUser;
-class BaseAuthetication {
-}
-exports.BaseAuthetication = BaseAuthetication;
-function Authorized() { }
-function CurrentUser() { }

package/dist/cache.d.ts

@@ -1,12 +0,0 @@
-import type { Redis } from "ioredis";
-export declare class CacheManager {
-    private store;
-    private tagsMap;
-    private redis;
-    constructor(redisInstance?: Redis);
-    private redisTagKey;
-    get<T>(key: string): Promise<T | null>;
-    set<T>(key: string, value: T, tags?: string[], ttl?: number): Promise<void>;
-    delete(key: string): Promise<void>;
-    invalidateTag(tag: string): Promise<void>;
-}

package/dist/cache.js

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CacheManager = void 0;
-class CacheManager {
-    constructor(redisInstance) {
-        this.store = new Map();
-        this.tagsMap = new Map();
-        this.redis = null;
-        this.redis = redisInstance || null;
-    }
-    redisTagKey(tag) {
-        return `cache-tags:${tag}`;
-    }
-    async get(key) {
-        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(key, value, tags = [], ttl = 3600) {
-        const entry = {
-            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) {
-        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) {
-        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);
-            }
-        }
-    }
-}
-exports.CacheManager = CacheManager;

package/dist/cache.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cache.test.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const cache_1 = require("./cache");
-describe("CacheManager (in-memory)", () => {
-    let cache;
-    beforeEach(() => {
-        cache = new cache_1.CacheManager();
-    });
-    it("should set and get a value", async () => {
-        await cache.set("foo", "bar");
-        const result = await cache.get("foo");
-        expect(result).toBe("bar");
-    });
-    it("should return null for missing key", async () => {
-        const result = await cache.get("missing");
-        expect(result).toBeNull();
-    });
-    it("should delete a key", async () => {
-        await cache.set("foo", "bar");
-        await cache.delete("foo");
-        const result = await cache.get("foo");
-        expect(result).toBeNull();
-    });
-    it("should associate keys with tags and invalidate by tag", async () => {
-        await cache.set("a", 1, ["tag1"]);
-        await cache.set("b", 2, ["tag1", "tag2"]);
-        await cache.set("c", 3, ["tag2"]);
-        await cache.invalidateTag("tag1");
-        expect(await cache.get("a")).toBeNull();
-        expect(await cache.get("b")).toBeNull();
-        expect(await cache.get("c")).toBe(3);
-    });
-    it("should not fail when invalidating a non-existent tag", async () => {
-        await expect(cache.invalidateTag("nope")).resolves.not.toThrow();
-    });
-});

package/dist/collection.d.ts

@@ -1,43 +0,0 @@
-import { EntityTarget, ObjectLiteral, Repository } from "typeorm";
-type Predicate<T> = (item: T) => boolean;
-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;
-};
-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>;
-}
-export declare class Collection {
-    private constructor();
-    static from<T>(items: T[]): BasicCollection<T>;
-    static fromRepository<T extends ObjectLiteral>(entity: EntityTarget<T>): Repository<T>;
-}
-export declare function InjectRepository<T extends Repository<T>>(model: EntityTarget<T>): (object: any, propertyName: string | undefined, index?: number) => void;
-export {};

package/dist/collection.js

@@ -1,231 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Collection = void 0;
-exports.InjectRepository = InjectRepository;
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-const typedi_1 = __importDefault(require("typedi"));
-const exceptions_1 = require("./exceptions");
-class BasicCollectionImpl {
-    constructor(items) {
-        this.items = items;
-    }
-    static from(items) {
-        return new BasicCollectionImpl(items);
-    }
-    clear() {
-        this.items = [];
-    }
-    find(predicate) {
-        if (this.isFunction(predicate)) {
-            return this.items.filter(predicate);
-        }
-        const results = Array.from(this.items);
-        return results;
-    }
-    async findAsync(predicate) {
-        const results = Array.from(this.items);
-        return results;
-    }
-    _matches(item, where) {
-        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];
-            if (condition &&
-                typeof condition === "object" &&
-                !Array.isArray(condition)) {
-                const op = condition;
-                if ("$in" in op && Array.isArray(op.$in)) {
-                    return op.$in.includes(itemValue);
-                }
-            }
-            return itemValue === condition;
-        });
-    }
-    findOne(predicate) {
-        if (this.isFunction(predicate)) {
-            return this.items.find(predicate);
-        }
-        const result = this.items.filter((item) => this._matches(item, predicate.where));
-        if (result.length > 0) {
-            return result[0];
-        }
-        return undefined;
-    }
-    async findOneAsync(predicate) {
-        if (this.isFunction(predicate)) {
-            return this.items.find(predicate);
-        }
-        return this.items.find((item) => this._matches(item, predicate.where));
-    }
-    // Utility function to check if a value is a function
-    isFunction(value) {
-        return typeof value === "function";
-    }
-    add(item) {
-        this.items.push(item);
-        return this.items[this.items.length - 1];
-    }
-    addAll(items) {
-        this.items.push(...items);
-    }
-    update(predicate, updater) {
-        const item = this.items.find(predicate);
-        if (item) {
-            const index = this.items.indexOf(item);
-            this.items[index] = { ...item, ...updater };
-        }
-        else {
-            throw new exceptions_1.NotFoundException("Item not found");
-        }
-    }
-    updateAll(predicate, updater) {
-        for (let i = 0; i < this.items.length; i++) {
-            if (predicate(this.items[i])) {
-                this.items[i] = updater(this.items[i]);
-            }
-        }
-    }
-    delete(predicate) {
-        const index = this.items.findIndex(predicate);
-        if (index !== -1) {
-            this.items.splice(index, 1);
-        }
-    }
-    deleteAll(predicate) {
-        this.items = this.items.filter((item) => !predicate(item));
-    }
-    max(key) {
-        return Math.max(...this.items.map((item) => item[key]));
-    }
-    min(key) {
-        return Math.max(...this.items.map((item) => item[key]));
-    }
-    sum(key) {
-        const nums = this.items.flatMap((x) => x[key]);
-        return nums.reduce((sum, num) => sum + num, 0);
-    }
-    avg(key) {
-        const nums = this.items.flatMap((x) => x[key]);
-        return nums.reduce((sum, num) => sum + num, 0) / nums.length;
-    }
-    paginate(options) {
-        const take = (options === null || options === void 0 ? void 0 : options.take) || 10;
-        const skip = (options === null || options === void 0 ? void 0 : 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,
-        };
-    }
-    getDeepValue(item, path) {
-        if (typeof path !== "string")
-            return item[path];
-        return path.split(".").reduce((acc, key) => acc === null || acc === void 0 ? void 0 : acc[key], item);
-    }
-}
-class AsynchronousCollection {
-    constructor(model) {
-        this.model = model;
-    }
-    static fromRepository(model) {
-        return new AsynchronousCollection(model);
-    }
-    getRepository() {
-        if (!this.repo) {
-            const dataSourceKey = "idatasource";
-            const dataSource = typedi_1.default.get(dataSourceKey);
-            console.log("datasource", dataSource);
-            const repository = dataSource.getRepository(this.model);
-            this.repo = repository;
-            return repository;
-        }
-        return this.repo;
-    }
-    // Pagination with query builder
-    async paginate(options) {
-        const take = (options === null || options === void 0 ? void 0 : options.take) || 10;
-        const skip = (options === null || options === void 0 ? void 0 : 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,
-        };
-    }
-}
-class Collection {
-    constructor() { }
-    static from(items) {
-        return BasicCollectionImpl.from(items);
-    }
-    // Example refactoring of Collection.fromRepository for better type safety
-    static fromRepository(entity) {
-        const asyncCollection = AsynchronousCollection.fromRepository(entity);
-        // Assuming AsynchronousCollection has a method to get the Repository<T>
-        return asyncCollection.getRepository();
-    }
-}
-exports.Collection = Collection;
-function InjectRepository(model) {
-    return function (object, propertyName, index) {
-        let repo;
-        try {
-            typedi_1.default.registerHandler({
-                object,
-                propertyName,
-                index,
-                value: (containerInstance) => {
-                    const dataSource = containerInstance.get("idatasource");
-                    repo = dataSource
-                        .getRepository(model)
-                        .extend({ paginate: () => { } });
-                    repo.paginate = async function (options = { take: 10, skip: 0 }) {
-                        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) {
-            if (error.name && error.name == "ServiceNotFoundError") {
-                console.log("Database didn't initialized.");
-            }
-        }
-    };
-}

package/dist/collection.test.d.ts

@@ -1 +0,0 @@
-export {};