@avleon/core 0.0.4 → 0.0.6

package/dist/index.js

@@ -17,17 +17,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Container = exports.inject = void 0;
+exports.Container = exports.validateRequestBody = exports.inject = void 0;
 //export * from "./iqra-core";
 __exportStar(require("./icore"), exports);
 var helpers_1 = require("./helpers");
 Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return helpers_1.inject; } });
+Object.defineProperty(exports, "validateRequestBody", { enumerable: true, get: function () { return helpers_1.validateRequestBody; } });
 __exportStar(require("./decorators"), exports);
+__exportStar(require("./middleware"), exports);
 __exportStar(require("./config"), exports);
 __exportStar(require("./openapi"), exports);
 __exportStar(require("./map-types"), exports);
 __exportStar(require("./response"), exports);
 __exportStar(require("./exceptions"), exports);
 __exportStar(require("./validator-extend"), exports);
+__exportStar(require("./validation"), exports);
+__exportStar(require("./environment-variables"), exports);
+__exportStar(require("./collection"), exports);
+__exportStar(require("./queue"), exports);
 var container_1 = require("./container");
 Object.defineProperty(exports, "Container", { enumerable: true, get: function () { return __importDefault(container_1).default; } });

package/dist/map-types.js

@@ -19,8 +19,7 @@ function PartialType(BaseClass) {
             }
             // Retrieve validation metadata (class-validator)
             const validationMetadata = Reflect.getMetadataKeys(currentPrototype, key);
-            validationMetadata.forEach((metadataKey) => {
-            });
+            validationMetadata.forEach((metadataKey) => { });
         });
         currentPrototype = Object.getPrototypeOf(currentPrototype); // Move up the prototype chain
     }

package/dist/middleware.d.ts

@@ -0,0 +1,24 @@
+import { IRequest, IResponse } from "./icore";
+import { HttpException } from "./exceptions";
+export declare abstract class AppMiddleware {
+    abstract invoke(req: IRequest, res?: IResponse): Promise<IRequest | HttpException>;
+}
+export type AuthHandler = (req: IRequest, roles?: string[]) => Promise<IRequest | HttpException>;
+export type Constructor<T> = {
+    new (...args: any[]): T;
+};
+export declare abstract class AuthorizeMiddleware {
+    abstract authorize(roles: string[]): (req: IRequest, res?: IResponse) => IRequest | Promise<IRequest>;
+}
+export type AuthReturnTypes = IRequest | Promise<IRequest>;
+interface AuthorizeClass {
+    authorize(req: IRequest, options?: any): AuthReturnTypes;
+}
+export declare function Authorize(target: {
+    new (...args: any[]): AuthorizeClass;
+}): void;
+export declare function Authorized(): ClassDecorator & MethodDecorator;
+export declare function Authorized(options?: any): ClassDecorator & MethodDecorator;
+export declare function Middleware(target: Constructor<AppMiddleware>): void;
+export declare function UseMiddleware<T extends AppMiddleware | (new (...args: any[]) => AppMiddleware)>(options: T | T[]): MethodDecorator & ClassDecorator;
+export {};

package/dist/middleware.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorizeMiddleware = exports.AppMiddleware = void 0;
+exports.Authorize = Authorize;
+exports.Authorized = Authorized;
+exports.Middleware = Middleware;
+exports.UseMiddleware = UseMiddleware;
+const typedi_1 = require("typedi");
+const container_1 = require("./container");
+class AppMiddleware {
+}
+exports.AppMiddleware = AppMiddleware;
+class AuthorizeMiddleware {
+}
+exports.AuthorizeMiddleware = AuthorizeMiddleware;
+function Authorize(target) {
+    if (typeof target.prototype.authorize !== "function") {
+        throw new Error(`Class "${target.name}" must implement an "authorize" method.`);
+    }
+    (0, typedi_1.Service)()(target);
+}
+function Authorized(options = {}) {
+    return function (target, propertyKey, descriptor) {
+        if (propertyKey && descriptor) {
+            Reflect.defineMetadata(container_1.AUTHORIZATION_META_KEY, { authorize: true, options }, target.constructor, propertyKey);
+        }
+        else {
+            Reflect.defineMetadata(container_1.AUTHORIZATION_META_KEY, { authorize: true, options }, target);
+        }
+    };
+}
+function Middleware(target) {
+    if (typeof target.prototype.invoke !== "function") {
+        throw new Error(`Class "${target.name}" must implement an "invoke" method.`);
+    }
+    (0, typedi_1.Service)()(target);
+}
+// export function CurrentUser(): ParameterDecorator {
+//   return (target, propertyKey, parameterIndex) => {
+//     const existingMetadata =
+//       Reflect.getMetadata("currentUser:params", target, propertyKey!) || [];
+//     existingMetadata.push(parameterIndex);
+//     Reflect.defineMetadata("currentUser:params", existingMetadata, target, propertyKey!);
+//   };
+// }
+function UseMiddleware(options) {
+    return function (target, propertyKey, descriptor) {
+        const normalizeMiddleware = (middleware) => typeof middleware === "function" ? new middleware() : middleware;
+        const middlewareList = (Array.isArray(options) ? options : [options]).map(normalizeMiddleware);
+        if (typeof target === "function" && !propertyKey) {
+            const existingMiddlewares = Reflect.getMetadata("controller:middleware", target) || [];
+            Reflect.defineMetadata("controller:middleware", [...existingMiddlewares, ...middlewareList], target);
+        }
+        else if (descriptor) {
+            const existingMiddlewares = Reflect.getMetadata("route:middleware", target, propertyKey) || [];
+            Reflect.defineMetadata("route:middleware", [...existingMiddlewares, ...middlewareList], target, propertyKey);
+        }
+    };
+}

package/dist/params.d.ts

@@ -13,4 +13,5 @@ export declare const Param: (key?: string | ParameterOptions, options?: Paramete
 export declare const Query: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
 export declare const Body: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
 export declare const Header: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
+export declare const AuthUser: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
 export {};

package/dist/params.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Header = exports.Body = exports.Query = exports.Param = void 0;
+exports.AuthUser = exports.Header = exports.Body = exports.Query = exports.Param = void 0;
 const container_1 = require("./container");
 const helpers_1 = require("./helpers");
 function createParamDecorator(type) {
@@ -10,29 +10,33 @@ function createParamDecorator(type) {
             const existingParams = Reflect.getMetadata(type, target, propertyKey) || [];
             const parameterTypes = Reflect.getMetadata("design:paramtypes", target, propertyKey) || [];
             const functionSource = target[propertyKey].toString();
-            const paramNames = (_a = functionSource.match(/\(([^)]*)\)/)) === null || _a === void 0 ? void 0 : _a[1].split(',').map((name) => name.trim());
+            const paramNames = (_a = functionSource
+                .match(/\(([^)]*)\)/)) === null || _a === void 0 ? void 0 : _a[1].split(",").map((name) => name.trim());
             const paramDataType = parameterTypes[parameterIndex];
             existingParams.push({
                 index: parameterIndex,
-                key: key ? key : 'all',
+                key: key ? key : "all",
                 name: paramNames[parameterIndex],
                 required: options.required || false,
                 validate: options.validate || true,
                 dataType: (0, helpers_1.getDataType)(paramDataType),
                 validatorClass: (0, helpers_1.isClassValidatorClass)(paramDataType),
-                type
+                type,
             });
             switch (type) {
-                case 'route:param':
+                case "route:param":
                     Reflect.defineMetadata(container_1.PARAM_META_KEY, existingParams, target, propertyKey);
                     break;
-                case 'route:query':
+                case "route:query":
                     Reflect.defineMetadata(container_1.QUERY_META_KEY, existingParams, target, propertyKey);
                     break;
-                case 'route:body':
+                case "route:body":
                     Reflect.defineMetadata(container_1.REQUEST_BODY_META_KEY, existingParams, target, propertyKey);
                     break;
-                case 'route:header':
+                case "route:user":
+                    Reflect.defineMetadata(container_1.REQUEST_USER_META_KEY, existingParams, target, propertyKey);
+                    break;
+                case "route:header":
                     Reflect.defineMetadata(container_1.REQUEST_HEADER_META_KEY, existingParams, target, propertyKey);
                     break;
                 default:
@@ -45,4 +49,4 @@ exports.Param = createParamDecorator("route:param");
 exports.Query = createParamDecorator("route:query");
 exports.Body = createParamDecorator("route:body");
 exports.Header = createParamDecorator("route:header");
-``;
+exports.AuthUser = createParamDecorator("route:user");

package/dist/queue.d.ts

@@ -0,0 +1,30 @@
+interface Job {
+    id: string;
+    data: any;
+}
+interface QueueAdapter {
+    loadJobs(): Promise<Job[]>;
+    saveJobs(jobs: Job[]): Promise<void>;
+}
+export declare class FileQueueAdapter implements QueueAdapter {
+    private queueFile;
+    constructor(queueName: string);
+    loadJobs(): Promise<Job[]>;
+    saveJobs(jobs: Job[]): Promise<void>;
+}
+declare class SimpleQueue {
+    private processing;
+    private jobHandler;
+    private adapter;
+    constructor(adapter: QueueAdapter, jobHandler: (job: Job) => Promise<void>);
+    addJob(data: any): Promise<void>;
+    private processNext;
+}
+export declare class QueueManager {
+    private static instance;
+    private adapter;
+    private constructor();
+    static getInstance(adapter: QueueAdapter): QueueManager;
+    createQueue(jobHandler: (job: Job) => Promise<void>): SimpleQueue;
+}
+export {};

package/dist/queue.js

@@ -1 +1,97 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueManager = exports.FileQueueAdapter = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const helpers_1 = require("./helpers");
+class FileQueueAdapter {
+    constructor(queueName) {
+        this.queueFile = (0, path_1.join)(__dirname, `${queueName}.json`);
+    }
+    async loadJobs() {
+        try {
+            const data = await fs_1.promises.readFile(this.queueFile, "utf-8");
+            return JSON.parse(data);
+        }
+        catch (error) {
+            return [];
+        }
+    }
+    async saveJobs(jobs) {
+        await fs_1.promises.writeFile(this.queueFile, JSON.stringify(jobs, null, 2), "utf-8");
+    }
+}
+exports.FileQueueAdapter = FileQueueAdapter;
+// class RedisQueueAdapter implements QueueAdapter {
+//   private client = createClient();
+//   private queueKey: string;
+//
+//   constructor(queueName: string) {
+//     this.queueKey = `queue:${queueName}`;
+//     this.client.connect();
+//   }
+//
+//   async loadJobs(): Promise<Job[]> {
+//     const jobs = await this.client.lRange(this.queueKey, 0, -1);
+//     return jobs.map((job) => JSON.parse(job));
+//   }
+//
+//   async saveJobs(jobs: Job[]) {
+//     await this.client.del(this.queueKey);
+//     if (jobs.length > 0) {
+//       await this.client.rPush(this.queueKey, ...jobs.map(job => JSON.stringify(job)));
+//     }
+//   }
+// }
+class SimpleQueue {
+    constructor(adapter, jobHandler) {
+        this.processing = false;
+        this.adapter = adapter;
+        this.jobHandler = jobHandler;
+    }
+    async addJob(data) {
+        const job = { id: helpers_1.uuid, data };
+        const jobs = await this.adapter.loadJobs();
+        jobs.push(job);
+        await this.adapter.saveJobs(jobs);
+        this.processNext();
+    }
+    async processNext() {
+        if (this.processing)
+            return;
+        this.processing = true;
+        const jobs = await this.adapter.loadJobs();
+        if (jobs.length === 0) {
+            this.processing = false;
+            return;
+        }
+        const job = jobs.shift();
+        if (job) {
+            try {
+                await this.jobHandler(job);
+            }
+            catch (error) {
+                console.error(`Error processing job ${job.id}:`, error);
+                jobs.unshift(job);
+            }
+            await this.adapter.saveJobs(jobs);
+            this.processing = false;
+            this.processNext();
+        }
+    }
+}
+class QueueManager {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    static getInstance(adapter) {
+        if (!QueueManager.instance) {
+            QueueManager.instance = new QueueManager(adapter);
+        }
+        return QueueManager.instance;
+    }
+    createQueue(jobHandler) {
+        return new SimpleQueue(this.adapter, jobHandler);
+    }
+}
+exports.QueueManager = QueueManager;

package/dist/render.d.ts

@@ -0,0 +1 @@
+export declare function render(viewPath: string, data: any): void;

package/dist/render.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.render = render;
+function render(viewPath, data) {
+    // complie view
+    // razor
+    // export
+}

package/dist/response.d.ts

@@ -1,9 +1,10 @@
-import 'reflect-metadata';
+import "reflect-metadata";
+import { ClassConstructor } from "class-transformer";
 export interface IHttpResponse<T extends any> {
     message: string;
     data: T | null;
 }
 export declare class HttpResponse {
-    static Ok<T extends {}>(obj: any, s?: any): any;
+    static Ok<T>(obj: any, s?: ClassConstructor<T>): any;
     static NoContent(): void;
 }

package/dist/response.js

@@ -7,7 +7,7 @@ function isClassTransformerClass(target) {
     const prototype = target.prototype;
     const keys = Reflect.getMetadataKeys(prototype);
     // Check for class-transformer metadata
-    return keys.some(key => key.startsWith('class_transformer:'));
+    return keys.some((key) => key.startsWith("class_transformer:"));
 }
 function isClassTransformerType(target) {
     return isClassTransformerClass(target);
@@ -15,21 +15,15 @@ function isClassTransformerType(target) {
 class HttpResponse {
     static Ok(obj, s) {
         if (s) {
-            let pg = false;
-            if (obj.hasOwnProperty('total')) {
-                pg = true;
-            }
-            const data = (0, class_transformer_1.instanceToPlain)((0, class_transformer_1.plainToInstance)(s, pg ? obj.data : obj, { enableImplicitConversion: true, exposeUnsetFields: false }), { strategy: 'excludeAll' });
-            if (pg) {
-                return Object.assign(Object.assign({ message: "success" }, obj), { data: data });
-            }
-            else {
-                return { message: "success", data };
-            }
-        }
-        else {
-            return { message: "success", data: obj };
+            const isPaginated = obj === null || obj === void 0 ? void 0 : obj.hasOwnProperty("total");
+            // Ensure transformation applies only allowed properties
+            const transformedData = (0, class_transformer_1.plainToInstance)(s, isPaginated ? obj.data : obj, {
+                enableImplicitConversion: true,
+                excludeExtraneousValues: true, // Ensures only @Expose() properties are included
+            });
+            return Object.assign({ message: "success" }, (isPaginated ? Object.assign(Object.assign({}, obj), { data: (0, class_transformer_1.instanceToPlain)(transformedData) }) : { data: (0, class_transformer_1.instanceToPlain)(transformedData) }));
         }
+        return { message: "success", data: obj };
     }
     static NoContent() { }
 }

package/dist/types/app-builder.interface.d.ts

@@ -0,0 +1,9 @@
+import { IApplication } from "./application.interface";
+export interface IAppBuilder {
+    createBuilder(): IAppBuilder;
+    /**
+     * @description will create a application instace
+     * @returns IApplication
+     */
+    builder: () => IApplication;
+}

package/dist/types/app-builder.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/application.interface.d.ts

@@ -0,0 +1,2 @@
+export interface IApplication {
+}

package/dist/types/application.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/validation.d.ts

@@ -0,0 +1,23 @@
+type BaseRule = {
+    required?: boolean;
+    optional?: boolean;
+    message?: string;
+};
+type StringRule = BaseRule & {
+    type: "string";
+};
+type NumberRule = BaseRule & {
+    type: "number";
+    min?: number;
+    max?: number;
+    exact?: number;
+};
+type BooleanRule = BaseRule & {
+    type: "boolean";
+};
+export type ValidationRule = StringRule | NumberRule | BooleanRule;
+export type ValidationProps = {
+    [key: string]: ValidationRule;
+};
+export declare function validateOrThrow<T extends {}>(obj: T, rules: ValidationProps): any;
+export {};

package/dist/validation.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOrThrow = validateOrThrow;
+const exceptions_1 = require("./exceptions");
+class PValidationRule {
+    constructor(name, type, message) {
+        this.name = name;
+        this.type = type;
+        this.message = message;
+    }
+}
+class Validator {
+    constructor(obj) {
+        this.rules = [];
+        this.init(obj);
+    }
+    init(obj) {
+        Object.keys(obj).forEach((key) => {
+            const rule = obj[key];
+            this.rules.push(new PValidationRule(key, rule.type, rule.message));
+        });
+    }
+    validate(obj) {
+        const erors = [];
+        this.rules.forEach((k) => {
+            const r = Object.keys(obj).find((key) => key == k.name);
+            let messages = [];
+            if (!r || obj[r] == undefined || obj[r] == "") {
+                messages.push({
+                    constraint: "required",
+                    message: k.name + " is required",
+                });
+            }
+            if (k.type == "string" && typeof obj[k.name] != "string") {
+                messages.push({
+                    constraint: "type",
+                    message: `${k.name} must be type ${k.type}`,
+                });
+            }
+            if (k.type == "number" && !parseInt(obj[k.name])) {
+                messages.push({
+                    constraint: "type",
+                    message: `${k.name} must be type ${k.type}`,
+                });
+            }
+            if (k.type == "number") {
+                obj[k.name] = parseInt(obj[k.name]);
+            }
+            if (k.type == "boolean" && !isBool(obj[k.name])) {
+                messages.push({
+                    constraint: "type",
+                    message: `${k.name} must be type ${k.type}`,
+                });
+            }
+            if (k.type == "boolean") {
+                obj[k.name] = parseBoolean(obj[k.name]);
+            }
+            if (messages.length > 0) {
+                erors.push({
+                    path: k.name,
+                    messages: messages,
+                });
+            }
+        });
+        return [erors, obj];
+    }
+}
+const isBool = (val) => {
+    if (typeof val == "boolean")
+        return true;
+    if (parseInt(val) == 0 || parseInt(val) == 1)
+        return true;
+    if (val == "true" || val == "false")
+        return true;
+    return false;
+};
+const parseBoolean = (val) => {
+    if (typeof val === "boolean")
+        return val;
+    // if (typeof val === "number") {
+    //   return val !== 0; // Common convention: 0 → false, any other number → true
+    // }
+    if (parseInt(val) == 1)
+        return true;
+    if (typeof val === "string") {
+        const normalized = val.trim().toLowerCase();
+        return normalized === "true";
+    }
+    return false; // Default for unsupported types (null, undefined, objects, etc.)
+};
+function validateOrThrow(obj, rules) {
+    const valid = new Validator(rules);
+    const errors = valid.validate(obj);
+    if (errors[0].length > 0) {
+        throw new exceptions_1.BadRequestException(errors[0]);
+    }
+    return errors[1];
+}

package/dist/validator-extend.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsArrayNotEmpty = IsArrayNotEmpty;
 function IsArrayNotEmpty(validationOptions) {
-    const { registerDecorator, ValidationArguments } = require('class-validator');
+    const { registerDecorator, ValidationArguments } = require("class-validator");
     return function (object, propertyName) {
         registerDecorator({
-            name: 'isArrayWithAtLeastOneElement',
+            name: "isArrayWithAtLeastOneElement",
             target: object.constructor,
             propertyName: propertyName,
             options: validationOptions,

package/package.json

@@ -1,39 +1,45 @@
-{
-  "name": "@avleon/core",
-  "version": "0.0.4",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "scripts": {
-    "build": "rimraf dist && tsc",
-    "watch": "tsc-watch",
-    "test": "jest",
-    "test:watch": "jest --watch"
-  },
-  "keywords": [],
-  "author": "Tareq Hossain",
-  "license": "ISC",
-  "devDependencies": {
-    "@types/jest": "^29.5.14",
-    "jest": "^29.7.0",
-    "nodemon": "^3.1.7",
-    "ts-jest": "^29.2.5",
-    "tsc-watch": "^6.2.1",
-    "typescript": "^5.7.2"
-  },
-  "dependencies": {
-    "@fastify/swagger": "^9.4.0",
-    "@fastify/swagger-ui": "^5.1.0",
-    "class-transformer": "^0.5.1",
-    "fastify": "^5.1.0",
-    "reflect-metadata": "^0.2.2",
-    "typedi": "^0.10.0"
-  },
-  "directories": {
-    "test": "tests"
-  },
-  "description": "avleon core",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/xtareq/avleon-core"
-  }
-}
+{
+  "name": "@avleon/core",
+  "version": "0.0.6",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "rimraf dist && tsc",
+    "watch": "tsc-watch",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "keywords": [],
+  "author": "Tareq Hossain",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "nodemon": "^3.1.7",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "tsc-watch": "^6.2.1",
+    "typescript": "^5.7.2"
+  },
+  "dependencies": {
+    "@fastify/static": "^8.1.1",
+    "@fastify/swagger": "^9.4.0",
+    "@fastify/swagger-ui": "^5.1.0",
+    "@scalar/fastify-api-reference": "^1.25.122",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "dotenv": "^16.4.7",
+    "fastify": "^5.1.0",
+    "reflect-metadata": "^0.2.2",
+    "typedi": "^0.10.0",
+    "typeorm": "^0.3.20"
+  },
+  "directories": {
+    "test": "tests"
+  },
+  "description": "avleon core",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xtareq/avleon-core"
+  }
+}

package/dist/repository.js

@@ -1 +0,0 @@
-"use strict";