@avleon/core 0.0.4 → 0.0.5

package/README.md

@@ -1 +1,4 @@
 # avleon-core
+
+
+# Api (V0.0.)

package/dist/authentication.d.ts

@@ -0,0 +1,9 @@
+export type CurrentUser = {};
+export declare abstract class Authetication {
+    abstract login(): void;
+    abstract register(): void;
+    abstract verifyToken(): boolean;
+    abstract currentUser(): CurrentUser;
+}
+export declare function Authorized(): void;
+export declare function CurrentUser(): void;

package/dist/authentication.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Authetication = void 0;
+exports.Authorized = Authorized;
+exports.CurrentUser = CurrentUser;
+class Authetication {
+}
+exports.Authetication = Authetication;
+function Authorized() {
+}
+function CurrentUser() { }

package/dist/collection.d.ts

@@ -0,0 +1,52 @@
+import { EntityTarget, FindOneOptions, ObjectLiteral, Repository as TypeOrmRepository } from "typeorm";
+type PaginationOptions = {
+    take: number;
+    skip?: number;
+};
+type Predicate<T> = (item: T) => boolean;
+export type PaginationResult<T> = {
+    total: number;
+    data: T[];
+    next?: number | null;
+    prev?: number | null;
+    first?: number | null;
+    last?: number | null;
+    totalPage?: number;
+};
+export declare class Repository<Entity extends ObjectLiteral> extends TypeOrmRepository<Entity> {
+    paginate(options?: PaginationOptions): Promise<PaginationResult<Entity>>;
+}
+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 declare class Collection {
+    private constructor();
+    static from<T>(items: T[]): BasicCollection<T>;
+    static fromRepositry<T extends ObjectLiteral>(entity: EntityTarget<T>): Repository<T>;
+}
+export {};

package/dist/collection.js

@@ -0,0 +1,282 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = exports.Repository = void 0;
+const typedi_1 = __importDefault(require("typedi"));
+const exceptions_1 = require("./exceptions");
+const typeorm_1 = require("typeorm");
+class Repository extends typeorm_1.Repository {
+    async paginate(options = { take: 10, skip: 0 }) {
+        const total = await this.count();
+        const data = await this.find({
+            take: options.take || 10,
+            skip: options.skip || 0,
+        });
+        return { total, data };
+    }
+}
+exports.Repository = Repository;
+class BasicCollection {
+    constructor(items) {
+        this.items = items;
+    }
+    static from(items) {
+        return new BasicCollection(items);
+    }
+    findAll(predicate) {
+        const results = Array.from(this.items);
+        return results;
+    }
+    findOne(predicate) {
+        if (this.isFunction(predicate)) {
+            return this.items.find(predicate);
+        }
+        throw new Error("Invalid predicate type");
+    }
+    // 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] = Object.assign(Object.assign({}, 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 dataSource = typedi_1.default.get("idatasource");
+            const repository = dataSource.getRepository(this.model).extend({
+                paginate: this.paginate,
+            });
+            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,
+            data,
+        };
+    }
+    createQueryBuilder(alias, queryRunner) {
+        return this.getRepository().createQueryBuilder(alias, queryRunner);
+    }
+    hasId(entity) {
+        return this.getRepository().hasId(entity);
+    }
+    getId(entity) {
+        return this.getRepository().getId(entity);
+    }
+    create(entityLike) {
+        return this.getRepository().create(entityLike);
+    }
+    merge(mergeIntoEntity, ...entityLikes) {
+        return this.getRepository().merge(mergeIntoEntity, ...entityLikes);
+    }
+    async preload(entityLike) {
+        return this.getRepository().preload(entityLike);
+    }
+    async save(entities, options) {
+        return this.getRepository().save(entities, options);
+    }
+    async remove(entity) {
+        return this.getRepository().remove(entity);
+    }
+    async softRemove(entity) {
+        return this.getRepository().softRemove(entity);
+    }
+    async recover(entity) {
+        return this.getRepository().recover(entity);
+    }
+    async insert(entity) {
+        await this.getRepository().insert(entity);
+    }
+    async update(criteria, partialEntity) {
+        return this.getRepository().update(criteria, partialEntity);
+    }
+    async upsert(entityOrEntities, conflictPathsOrOptions) {
+        await this.getRepository().upsert(entityOrEntities, conflictPathsOrOptions);
+    }
+    async delete(criteria) {
+        return this.getRepository().delete(criteria);
+    }
+    async softDelete(criteria) {
+        return this.getRepository().softDelete(criteria);
+    }
+    async restore(criteria) {
+        return this.getRepository().restore(criteria);
+    }
+    async exist(options) {
+        return (await this.getRepository().count(options)) > 0;
+    }
+    async exists(options) {
+        return this.exist(options);
+    }
+    async existsBy(where) {
+        return (await this.getRepository().count({ where })) > 0;
+    }
+    async count(options) {
+        return this.getRepository().count(options);
+    }
+    async countBy(where) {
+        return this.getRepository().count({ where });
+    }
+    async sum(columnName, where) {
+        return this.getRepository()
+            .createQueryBuilder()
+            .select(`SUM(${columnName})`, "sum")
+            .where(where || {})
+            .getRawOne()
+            .then((res) => (res === null || res === void 0 ? void 0 : res.sum) || null);
+    }
+    async average(columnName, where) {
+        return this.getRepository()
+            .createQueryBuilder()
+            .select(`AVG(${columnName})`, "average")
+            .where(where || {})
+            .getRawOne()
+            .then((res) => (res === null || res === void 0 ? void 0 : res.average) || null);
+    }
+    async minimum(columnName, where) {
+        return this.getRepository()
+            .createQueryBuilder()
+            .select(`MIN(${columnName})`, "minimum")
+            .where(where || {})
+            .getRawOne()
+            .then((res) => (res === null || res === void 0 ? void 0 : res.minimum) || null);
+    }
+    async maximum(columnName, where) {
+        return this.getRepository().maximum(columnName, where);
+    }
+    async find(options) {
+        return await this.getRepository().find(options);
+    }
+    async findBy(where) {
+        return this.getRepository().findBy(where);
+    }
+    async findAndCount(options) {
+        return this.getRepository().findAndCount(options);
+    }
+    async findAndCountBy(where) {
+        return this.getRepository().findAndCount({ where });
+    }
+    async findByIds(ids) {
+        return this.getRepository().findBy(ids);
+    }
+    async findOne(options) {
+        return this.getRepository().findOne(options);
+    }
+    async findOneBy(where) {
+        return this.getRepository().findOneBy(where);
+    }
+    async findOneById(id) {
+        return this.getRepository().findOneBy({ id });
+    }
+    async findOneOrFail(options) {
+        return this.getRepository().findOneOrFail(options);
+    }
+    async findOneByOrFail(where) {
+        return this.getRepository().findOneByOrFail(where);
+    }
+    async query(query, parameters) {
+        return this.getRepository().query(query, parameters);
+    }
+    async clear() {
+        await this.getRepository().clear();
+    }
+    async increment(conditions, propertyPath, value) {
+        return this.getRepository().increment(conditions, propertyPath, value);
+    }
+    async decrement(conditions, propertyPath, value) {
+        return this.getRepository().decrement(conditions, propertyPath, value);
+    }
+}
+class Collection {
+    constructor() { }
+    static from(items) {
+        return BasicCollection.from(items);
+    }
+    static fromRepositry(entity) {
+        return AsynchronousCollection.fromRepository(entity);
+    }
+}
+exports.Collection = Collection;

package/dist/config.d.ts

@@ -26,5 +26,5 @@ export declare function Config(target: {
 }): void;
 export declare function GetConfig<T extends ConfigClass>(ConfigClass: {
     new (...args: any[]): T;
-}): ReturnType<T['invoke']>;
+}): ReturnType<T["invoke"]>;
 export {};

package/dist/config.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Config = Config;
 exports.GetConfig = GetConfig;
-const CONFIG_METADATA_KEY = Symbol('config');
+const CONFIG_METADATA_KEY = Symbol("config");
 function Config(target) {
-    if (typeof target.prototype.invoke !== 'function') {
+    if (typeof target.prototype.invoke !== "function") {
         throw new Error(`Class "${target.name}" must implement an "invoke" method.`);
     }
     Reflect.defineMetadata(CONFIG_METADATA_KEY, target, target);

package/dist/container.d.ts

@@ -1,19 +1,18 @@
-import { ContainerInstance } from "typedi";
+import TypediContainer from "typedi";
 export declare const ROUTE_META_KEY: unique symbol;
 export declare const CONTROLLER_META_KEY: unique symbol;
 export declare const PARAM_META_KEY: unique symbol;
 export declare const QUERY_META_KEY: unique symbol;
 export declare const REQUEST_BODY_META_KEY: unique symbol;
+export declare const REQUEST_USER_META_KEY: unique symbol;
 export declare const REQUEST_HEADER_META_KEY: unique symbol;
 export declare const DATASOURCE_META_KEY: unique symbol;
-export interface IContainer extends ContainerInstance {
-    registerHandler: IContainer;
-}
-declare const Container: IContainer;
+declare const Container: typeof TypediContainer;
 export declare function registerController(controller: Function): void;
 export declare function registerService(service: Function): void;
 export declare function getRegisteredServices(): Function[];
 export declare function getRegisteredControllers(): Function[];
 export declare const API_CONTROLLER_METADATA_KEY: unique symbol;
 export declare function isApiController(target: Function): boolean;
+export declare function registerDataSource(dataSource: any): void;
 export default Container;

package/dist/container.js

@@ -3,24 +3,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.API_CONTROLLER_METADATA_KEY = exports.DATASOURCE_META_KEY = exports.REQUEST_HEADER_META_KEY = exports.REQUEST_BODY_META_KEY = exports.QUERY_META_KEY = exports.PARAM_META_KEY = exports.CONTROLLER_META_KEY = exports.ROUTE_META_KEY = void 0;
+exports.API_CONTROLLER_METADATA_KEY = exports.DATASOURCE_META_KEY = exports.REQUEST_HEADER_META_KEY = exports.REQUEST_USER_META_KEY = exports.REQUEST_BODY_META_KEY = exports.QUERY_META_KEY = exports.PARAM_META_KEY = exports.CONTROLLER_META_KEY = exports.ROUTE_META_KEY = void 0;
 exports.registerController = registerController;
 exports.registerService = registerService;
 exports.getRegisteredServices = getRegisteredServices;
 exports.getRegisteredControllers = getRegisteredControllers;
 exports.isApiController = isApiController;
+exports.registerDataSource = registerDataSource;
 const typedi_1 = __importDefault(require("typedi"));
 exports.ROUTE_META_KEY = Symbol("iroute:options");
 exports.CONTROLLER_META_KEY = Symbol("icontroller:options");
 exports.PARAM_META_KEY = Symbol("iparam:options");
 exports.QUERY_META_KEY = Symbol("iparam:options");
 exports.REQUEST_BODY_META_KEY = Symbol("iparam:options");
+exports.REQUEST_USER_META_KEY = Symbol("iparam:options");
 exports.REQUEST_HEADER_META_KEY = Symbol("iheader:options");
 exports.DATASOURCE_META_KEY = Symbol("idatasource:options");
 const controllerRegistry = new Set();
 const serviceRegistry = new Set();
 const optionsRegistry = new Map();
-const Container = typedi_1.default.of("avContriner");
+const Container = typedi_1.default;
 function registerController(controller) {
     controllerRegistry.add(controller);
 }
@@ -34,18 +36,12 @@ function getRegisteredServices() {
 function getRegisteredControllers() {
     return Array.from(controllerRegistry);
 }
-// export const APP_DC_TOKEN = new Token<DataSource>();
-// Container.set(APP_DC_TOKEN, DataSource);
-exports.API_CONTROLLER_METADATA_KEY = Symbol('apiController');
-// export type DBContext = Record<string, ReturnType<DataSource['getRepository']>>;
-// export function registerDataSource(dc: DataSource) {
-//   Container.set({
-//     id: APP_DC_TOKEN,
-//     factory: () => dc,
-//   });
-// }
+exports.API_CONTROLLER_METADATA_KEY = Symbol("apiController");
 function isApiController(target) {
     return Reflect.getMetadata(exports.API_CONTROLLER_METADATA_KEY, target) === true;
 }
-Container.set('appName', 'Iqra');
+Container.set("appName", "Iqra");
+function registerDataSource(dataSource) {
+    Container.set("idatasource", dataSource);
+}
 exports.default = Container;

package/dist/decorators.d.ts

@@ -1,5 +1,6 @@
 import { Service as _service } from "typedi";
-export declare const AppService: typeof _service;
+export declare function AppService(target: any): void;
+export declare function AppService(): any;
 export * from "./controller";
 export * from "./route-methods";
 export * from "./openapi";

package/dist/decorators.js

@@ -14,9 +14,19 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Helper = exports.Utility = exports.AppService = void 0;
+exports.Helper = exports.Utility = void 0;
+exports.AppService = AppService;
 const typedi_1 = require("typedi");
-exports.AppService = typedi_1.Service;
+function AppService(target) {
+    if (target) {
+        (0, typedi_1.Service)()(target);
+    }
+    else {
+        return function (tg) {
+            (0, typedi_1.Service)()(tg);
+        };
+    }
+}
 __exportStar(require("./controller"), exports);
 __exportStar(require("./route-methods"), exports);
 __exportStar(require("./openapi"), exports);

package/dist/environment-variables.d.ts

@@ -0,0 +1,3 @@
+export declare const e: Record<string, string>;
+export type Env = typeof e;
+export declare const env: Env;

package/dist/environment-variables.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.env = exports.e = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+// Load environment variables
+dotenv_1.default.config({ path: path_1.default.join(process.cwd(), ".env") });
+// Read the .env file and infer keys dynamically
+const envFilePath = path_1.default.join(process.cwd(), ".env");
+const envContents = fs_1.default.readFileSync(envFilePath, "utf-8");
+// Parse .env file manually
+const parsedEnv = Object.fromEntries(envContents
+    .split("\n")
+    .filter((line) => line.trim() && !line.startsWith("#")) // Ignore empty lines and comments
+    .map((line) => {
+    const [key, ...valueParts] = line.split("="); // Split key and value
+    return [key.trim(), valueParts.join("=").trim()]; // Handle values with `=`
+}));
+const inferType = (value) => {
+    if (!isNaN(Number(value)))
+        return Number(value);
+    if (value.toLowerCase() === "true")
+        return true;
+    if (value.toLowerCase() === "false")
+        return false;
+    return value;
+};
+exports.e = parsedEnv;
+exports.env = exports.e;

package/dist/exceptions/http-exceptions.d.ts

@@ -1,4 +1,4 @@
-export declare class BaseHttpException extends Error {
+export declare abstract class BaseHttpException extends Error {
     code: number;
     name: string;
     constructor(message: any);
@@ -9,6 +9,9 @@ export declare class BadRequestException extends BaseHttpException {
     code: number;
     constructor(message: any);
 }
+export declare class ValidationErrorException extends BadRequestException {
+    name: string;
+}
 export declare class InternalErrorException extends BaseHttpException {
     name: string;
     code: number;
@@ -19,3 +22,23 @@ export declare class NotFoundException extends BaseHttpException {
     code: number;
     constructor(message: any);
 }
+export declare class UnauthorizedException extends BaseHttpException {
+    name: string;
+    code: number;
+    constructor(message: any);
+}
+export declare class ForbiddenException extends BaseHttpException {
+    name: string;
+    code: number;
+    constructor(message: any);
+}
+export type HttpException = NotFoundException | BadRequestException | UnauthorizedException | InternalErrorException | ForbiddenException;
+export type HttpExceptions = {
+    NotFound: (message: any) => NotFoundException;
+    ValidationError: (message: any) => ValidationErrorException;
+    BadRequest: (message: any) => BadRequestException;
+    Unauthorized: (message: any) => UnauthorizedException;
+    Forbidden: (message: any) => ForbiddenException;
+    InternalError: (message: any) => InternalErrorException;
+};
+export declare const httpExcepitoins: HttpExceptions;

package/dist/exceptions/http-exceptions.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotFoundException = exports.InternalErrorException = exports.BadRequestException = exports.BaseHttpException = void 0;
+exports.httpExcepitoins = exports.ForbiddenException = exports.UnauthorizedException = exports.NotFoundException = exports.InternalErrorException = exports.ValidationErrorException = exports.BadRequestException = exports.BaseHttpException = void 0;
 class BaseHttpException extends Error {
     constructor(message) {
-        super(message);
+        super(JSON.stringify(message));
         this.code = 500;
         this.name = "HttpException";
     }
@@ -20,6 +20,13 @@ class BadRequestException extends BaseHttpException {
     }
 }
 exports.BadRequestException = BadRequestException;
+class ValidationErrorException extends BadRequestException {
+    constructor() {
+        super(...arguments);
+        this.name = "ValidationError";
+    }
+}
+exports.ValidationErrorException = ValidationErrorException;
 class InternalErrorException extends BaseHttpException {
     constructor(message = "Something going wrong") {
         super(message);
@@ -36,3 +43,27 @@ class NotFoundException extends BaseHttpException {
     }
 }
 exports.NotFoundException = NotFoundException;
+class UnauthorizedException extends BaseHttpException {
+    constructor(message) {
+        super(message);
+        this.name = "Unauthorized";
+        this.code = 401;
+    }
+}
+exports.UnauthorizedException = UnauthorizedException;
+class ForbiddenException extends BaseHttpException {
+    constructor(message) {
+        super(message);
+        this.name = "Forbidden";
+        this.code = 403;
+    }
+}
+exports.ForbiddenException = ForbiddenException;
+exports.httpExcepitoins = {
+    NotFound: (message) => new NotFoundException(message),
+    ValidationError: (message) => new ValidationErrorException(message),
+    BadRequest: (message) => new BadRequestException(message),
+    Unauthorized: (message) => new UnauthorizedException(message),
+    Forbidden: (message) => new ForbiddenException(message),
+    InternalError: (message) => new InternalErrorException(message)
+};

package/dist/helpers.d.ts

@@ -1,3 +1,4 @@
+export declare const uuid: `${string}-${string}-${string}-${string}-${string}`;
 export declare function inject<T>(cls: new (...args: any[]) => T): T;
 export type Constructor<T = any> = new (...args: any[]) => T;
 export declare function formatUrl(path: string): string;
@@ -21,4 +22,10 @@ export declare function jsonToJs(value: string): any;
 export declare function jsonToInstance(value: string, instance: Constructor): any;
 export declare function transformObjectByInstanceToObject(instance: Constructor, value: object): Record<string, any>;
 export declare const isClassValidatorClass: (target: Constructor) => boolean;
-export declare function validateObjectByInstance(target: Constructor, value: object): Promise<any>;
+export declare function validateObjectByInstance(target: Constructor, value?: object, options?: 'object' | 'array'): Promise<any>;
+type ValidationError = {
+    count: number;
+    errors: any;
+};
+export declare function validateRequestBody(target: Constructor, value: object, options?: 'object' | 'array'): ValidationError;
+export {};