@avleon/core 0.0.28 → 0.0.29

package/dist/application.js

@@ -24,7 +24,7 @@ class IqraApplication {
             post: this.app.post,
             put: this.app.put,
             patch: this.app.patch,
-            delete: this.app.delete
+            delete: this.app.delete,
         };
     }
     mapGroup(path) {

package/dist/cache.d.ts

@@ -1,4 +1,4 @@
-import type { Redis } from 'ioredis';
+import type { Redis } from "ioredis";
 export declare class CacheManager {
     private store;
     private tagsMap;

package/dist/cache.js

@@ -25,7 +25,7 @@ class CacheManager {
             timestamp: Date.now(),
         };
         if (this.redis) {
-            await this.redis.set(key, JSON.stringify(entry.data), 'EX', ttl);
+            await this.redis.set(key, JSON.stringify(entry.data), "EX", ttl);
             for (const tag of tags) {
                 await this.redis.sadd(this.redisTagKey(tag), key);
             }
@@ -43,7 +43,7 @@ class CacheManager {
         if (this.redis) {
             await this.redis.del(key);
             // Also clean up from any tag sets
-            const tagKeys = await this.redis.keys('cache-tags:*');
+            const tagKeys = await this.redis.keys("cache-tags:*");
             for (const tagKey of tagKeys) {
                 await this.redis.srem(tagKey, key);
             }

package/dist/collection.d.ts

@@ -1,9 +1,23 @@
-import { EntityTarget, FindOneOptions, ObjectLiteral, Repository } from "typeorm";
-type PaginationOptions = {
-    take: number;
-    skip?: number;
-};
+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[];
@@ -13,33 +27,12 @@ export type PaginationResult<T> = {
     last?: number | null;
     totalPage?: number;
 };
-type ICollection<T> = {
-    findAll(): T[] | Promise<T[]>;
-};
-declare class BasicCollection<T> implements ICollection<T> {
-    private items;
-    private constructor();
-    static from<T>(items: T[]): BasicCollection<T>;
-    findAll(predicate?: Predicate<T>): T[];
-    findOne(predicate: Predicate<T> | FindOneOptions<T>): T | Promise<T | null>;
-    private isFunction;
-    add(item: Partial<T>): T;
-    addAll(items: T[]): void;
-    update(predicate: (item: T) => boolean, updater: Partial<T>): void;
-    updateAll(predicate: (item: T) => boolean, updater: (item: T) => T): void;
-    delete(predicate: (item: T) => boolean): void;
-    deleteAll(predicate: (item: T) => boolean): void;
-    max<K extends keyof T>(key: K & string): number;
-    min<K extends keyof T>(key: K & string): number;
-    sum<K extends keyof T>(key: K & string): number;
-    avg<K extends keyof T>(key: K & string): number;
-    paginate(options?: PaginationOptions): {
-        total: number;
-        totalPage: number;
-        next: number | null;
-        data: T[];
-    };
-    private getDeepValue;
+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();

package/dist/collection.js

@@ -13,22 +13,66 @@ exports.InjectRepository = InjectRepository;
  */
 const typedi_1 = __importDefault(require("typedi"));
 const exceptions_1 = require("./exceptions");
-class BasicCollection {
+class BasicCollectionImpl {
     constructor(items) {
         this.items = items;
     }
     static from(items) {
-        return new BasicCollection(items);
+        return new BasicCollectionImpl(items);
     }
-    findAll(predicate) {
+    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);
         }
-        throw new Error("Invalid predicate type");
+        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) {
@@ -110,7 +154,7 @@ class AsynchronousCollection {
         if (!this.repo) {
             const dataSourceKey = "idatasource";
             const dataSource = typedi_1.default.get(dataSourceKey);
-            console.log('datasource', dataSource);
+            console.log("datasource", dataSource);
             const repository = dataSource.getRepository(this.model);
             this.repo = repository;
             return repository;
@@ -137,7 +181,7 @@ class AsynchronousCollection {
 class Collection {
     constructor() { }
     static from(items) {
-        return BasicCollection.from(items);
+        return BasicCollectionImpl.from(items);
     }
     // Example refactoring of Collection.fromRepository for better type safety
     static fromRepository(entity) {

package/dist/collection.test.d.ts

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

package/dist/collection.test.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const collection_1 = require("./collection");
+describe("Collection", () => {
+    let collection;
+    beforeEach(() => {
+        collection = collection_1.Collection.from([
+            {
+                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 === null || result === void 0 ? void 0 : result.id).toBe(1);
+        });
+        it("should return only completed task", () => {
+            const result = collection.findOne({
+                where: {
+                    id: {
+                        $in: [3],
+                    },
+                },
+            });
+            expect(result).toHaveProperty("id");
+            expect(result === null || result === void 0 ? void 0 : result.completed).toBe(true);
+        });
+    });
+});

package/dist/config.d.ts

@@ -14,3 +14,5 @@ export declare class AppConfig {
     get<T extends IConfig<R>, R>(configClass: Constructable<T>): R;
 }
 export declare function GetConfig<T extends IConfig<R>, R = ReturnType<InstanceType<Constructable<T>>["config"]>>(ConfigClass: Constructable<T>): R;
+export declare function GetConfig<T = any>(config: string | symbol): T;
+export declare function CreateConfig<T>(token: string | symbol, callback: (env: Environment) => T): void;

package/dist/config.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppConfig = void 0;
 exports.Config = Config;
 exports.GetConfig = GetConfig;
+exports.CreateConfig = CreateConfig;
 /**
  * @copyright 2024
  * @author Tareq Hossain
@@ -11,6 +12,7 @@ exports.GetConfig = GetConfig;
  */
 const typedi_1 = require("typedi");
 const environment_variables_1 = require("./environment-variables");
+const helpers_1 = require("./helpers");
 function Config(target) {
     typedi_1.Container.set({ id: target, type: target });
 }
@@ -24,10 +26,33 @@ class AppConfig {
     }
 }
 exports.AppConfig = AppConfig;
-function GetConfig(ConfigClass) {
-    const instance = typedi_1.Container.get(ConfigClass);
-    if (!instance) {
-        throw new Error(`Class "${ConfigClass.name}" is not registered as a config.`);
+// Implementation
+function GetConfig(token) {
+    // 1. Class‐based: token.prototype.config is a function
+    if (typeof token === "function" &&
+        token.prototype != null &&
+        typeof token.prototype.config === "function") {
+        const instance = typedi_1.Container.get(token);
+        if (!instance) {
+            throw new Error(`Class "${token.name}" is not registered as a config.`);
+        }
+        return instance.config((0, helpers_1.inject)(environment_variables_1.Environment));
+    }
+    // 2. Functional: token is the callback itself
+    const stored = typedi_1.Container.get(token);
+    if (!stored) {
+        throw new Error("Config object is not registered.");
+    }
+    return stored;
+}
+function CreateConfig(token, callback) {
+    let env;
+    try {
+        env = typedi_1.Container.get(environment_variables_1.Environment);
+    }
+    catch (error) {
+        env = new environment_variables_1.Environment();
     }
-    return instance.config(new environment_variables_1.Environment());
+    let config = callback(env);
+    typedi_1.Container.set(token, config);
 }

package/dist/config.test.d.ts

@@ -0,0 +1 @@
+import "reflect-metadata";

package/dist/config.test.js

@@ -0,0 +1,40 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const config_1 = require("./config");
+describe("Config", () => {
+    describe("class", () => {
+        it("should be call by get config", () => {
+            let MyConfig = class MyConfig {
+                config(env) {
+                    return {
+                        name: "avleon",
+                    };
+                }
+            };
+            MyConfig = __decorate([
+                config_1.Config
+            ], MyConfig);
+            const mConfig = (0, config_1.GetConfig)(MyConfig);
+            expect(mConfig).toHaveProperty("name");
+            expect(mConfig["name"]).toBe("avleon");
+        });
+    });
+    describe("createConfig()", () => {
+        it("it should create config and called with GetConfig", () => {
+            (0, config_1.CreateConfig)("myconfig", (env) => ({
+                firstname: "tareq",
+                os: env.get("name"),
+            }));
+            const mConfig = (0, config_1.GetConfig)("myconfig");
+            expect(mConfig).toHaveProperty("firstname");
+            expect(mConfig.firstname).toBe("tareq");
+        });
+    });
+});

package/dist/controller.js

@@ -37,13 +37,13 @@ function createControllerDecorator(type = "web") {
     };
 }
 function ApiController(pathOrOptions = "/", mayBeOptions) {
-    if (typeof pathOrOptions == 'function') {
+    if (typeof pathOrOptions == "function") {
         Reflect.defineMetadata(container_1.API_CONTROLLER_METADATA_KEY, true, pathOrOptions);
         // Ensure Service is applied as a ClassDecorator
         if (typeof typedi_1.Service === "function") {
             (0, container_1.registerController)(pathOrOptions); // Add to custom registry
             (0, typedi_1.Service)()(pathOrOptions); // Apply DI decorator
-            Reflect.defineMetadata(container_1.CONTROLLER_META_KEY, { type: 'api', path: "/", options: {} }, pathOrOptions);
+            Reflect.defineMetadata(container_1.CONTROLLER_META_KEY, { type: "api", path: "/", options: {} }, pathOrOptions);
         }
         else {
             throw new Error("Service decorator is not a function");

package/dist/environment-variables.js

@@ -5,12 +5,45 @@
  * @email xtrinsic96@gmail.com
  * @url https://github.com/xtareq
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -18,14 +51,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Environment = void 0;
 const dotenv_1 = __importDefault(require("dotenv"));
 const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
+const fs_1 = __importStar(require("fs"));
 const typedi_1 = require("typedi");
 const system_exception_1 = require("./exceptions/system-exception");
 dotenv_1.default.config({ path: path_1.default.join(process.cwd(), ".env") });
 let Environment = class Environment {
     parseEnvFile(filePath) {
         try {
-            const fileContent = fs_1.default.readFileSync(filePath, 'utf8');
+            const isExis = (0, fs_1.existsSync)(filePath);
+            if (!isExis) {
+                return { ...process.env };
+            }
+            const fileContent = fs_1.default.readFileSync(filePath, "utf8");
             const parsedEnv = dotenv_1.default.parse(fileContent);
             return { ...parsedEnv, ...process.env };
         }
@@ -35,18 +72,18 @@ let Environment = class Environment {
         }
     }
     get(key) {
-        const parsedEnv = this.parseEnvFile(path_1.default.join(process.cwd(), '.env'));
+        const parsedEnv = this.parseEnvFile(path_1.default.join(process.cwd(), ".env"));
         return parsedEnv[key];
     }
     getOrThrow(key) {
-        const parsedEnv = this.parseEnvFile(path_1.default.join(process.cwd(), '.env'));
+        const parsedEnv = this.parseEnvFile(path_1.default.join(process.cwd(), ".env"));
         if (!Object(parsedEnv).hasOwnProperty(key)) {
             throw new system_exception_1.EnvironmentVariableNotFound(key);
         }
         return parsedEnv[key];
     }
     getAll() {
-        const parsedEnv = this.parseEnvFile(path_1.default.join(process.cwd(), '.env'));
+        const parsedEnv = this.parseEnvFile(path_1.default.join(process.cwd(), ".env"));
         return parsedEnv;
     }
 };

package/dist/event-dispatcher.d.ts

@@ -0,0 +1,23 @@
+import { Socket } from 'socket.io';
+export declare class SocketContextService {
+    private readonly storage;
+    run(socket: Socket, fn: () => void | Promise<void>): void;
+    getSocket(): Socket | undefined;
+}
+export type DispatchOptions = {
+    room?: string;
+    broadcast?: boolean;
+    transports?: ('socket' | 'kafka' | 'rabbitmq')[];
+    retry?: number;
+    retryDelay?: number;
+};
+export declare function sleep(ms: number): Promise<unknown>;
+export declare class EventDispatcher {
+    private readonly _context;
+    constructor(_context: SocketContextService);
+    dispatch<T = any>(event: string, data: T, options?: DispatchOptions): Promise<void>;
+    private dispatchToTransports;
+}
+export declare function Dispatch(event: string, options?: Omit<DispatchOptions, 'transports'> & {
+    transports?: DispatchOptions['transports'];
+}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/event-dispatcher.js

@@ -0,0 +1,102 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventDispatcher = exports.SocketContextService = void 0;
+exports.sleep = sleep;
+exports.Dispatch = Dispatch;
+const typedi_1 = require("typedi");
+const socket_io_1 = require("socket.io");
+// SocketContextService.ts
+const node_async_hooks_1 = require("node:async_hooks");
+let SocketContextService = class SocketContextService {
+    constructor() {
+        this.storage = new node_async_hooks_1.AsyncLocalStorage();
+    }
+    run(socket, fn) {
+        this.storage.run({ socket }, fn);
+    }
+    getSocket() {
+        var _a;
+        return (_a = this.storage.getStore()) === null || _a === void 0 ? void 0 : _a.socket;
+    }
+};
+exports.SocketContextService = SocketContextService;
+exports.SocketContextService = SocketContextService = __decorate([
+    (0, typedi_1.Service)()
+], SocketContextService);
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+let EventDispatcher = class EventDispatcher {
+    constructor(_context) {
+        this._context = _context;
+    }
+    async dispatch(event, data, options = {}) {
+        var _a, _b;
+        const retryCount = (_a = options.retry) !== null && _a !== void 0 ? _a : 0;
+        const delay = (_b = options.retryDelay) !== null && _b !== void 0 ? _b : 300;
+        for (let attempt = 0; attempt <= retryCount; attempt++) {
+            try {
+                await this.dispatchToTransports(event, data, options);
+                break;
+            }
+            catch (err) {
+                if (attempt === retryCount)
+                    throw err;
+                await sleep(delay * (attempt + 1));
+            }
+        }
+    }
+    async dispatchToTransports(event, data, options) {
+        var _a;
+        const transports = (_a = options.transports) !== null && _a !== void 0 ? _a : ['socket'];
+        for (const transport of transports) {
+            if (transport === 'socket') {
+                const io = typedi_1.Container.get(socket_io_1.Server);
+                //console.log('SOckert', Container.get(SocketContextService));
+                const context = typedi_1.Container.get(SocketContextService);
+                const socket = context.getSocket();
+                if (options.broadcast && socket) {
+                    if (options.room) {
+                        socket.broadcast.to(options.room).emit(event, data);
+                    }
+                    else {
+                        socket.broadcast.emit(event, data);
+                    }
+                }
+                else {
+                    if (options.room) {
+                        io.to(options.room).emit(event, data);
+                    }
+                    else {
+                        io.emit(event, data);
+                    }
+                }
+            }
+        }
+    }
+};
+exports.EventDispatcher = EventDispatcher;
+exports.EventDispatcher = EventDispatcher = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [SocketContextService])
+], EventDispatcher);
+function Dispatch(event, options) {
+    return function (target, propertyKey, descriptor) {
+        const original = descriptor.value;
+        descriptor.value = async function (...args) {
+            const result = await original.apply(this, args);
+            const dispatcher = typedi_1.Container.get(EventDispatcher);
+            await dispatcher.dispatch(event, result, options);
+            return result;
+        };
+    };
+}

package/dist/event-subscriber.d.ts

@@ -0,0 +1,15 @@
+import { Socket } from 'socket.io';
+import { SocketContextService } from './event-dispatcher';
+import 'reflect-metadata';
+export declare function Private(channelResolver?: (socket: any) => string): (target: any, propertyKey: string) => void;
+export declare function isPrivate(target: any, propertyKey: string): boolean;
+export declare function getPrivateChannelResolver(target: any, propertyKey: string): ((socket: any) => string) | undefined;
+export declare function registerSocketSubscriber(target: Function): void;
+export declare function getSocketSubscribers(): Function[];
+export declare function Subscribe(event: string): MethodDecorator;
+export declare function PrivateSubscribe(resolver: (user: any, socket: any) => string): (target: any, propertyKey: string) => void;
+export declare class EventSubscriberRegistry {
+    private readonly socketContext;
+    constructor(socketContext: SocketContextService);
+    register(socket: Socket): void;
+}