@avleon/core 0.0.4 → 0.0.5

package/dist/middleware.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppMiddleware = void 0;
+exports.Middleware = Middleware;
+exports.UseMiddleware = UseMiddleware;
+const typedi_1 = require("typedi");
+class AppMiddleware {
+}
+exports.AppMiddleware = AppMiddleware;
+// 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 Middleware(target) {
+    if (typeof target.prototype.invoke !== "function") {
+        throw new Error(`Class "${target.name}" must implement an "invoke" method.`);
+    }
+    (0, typedi_1.Service)()(target);
+}
+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/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.5",
+  "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";