@avleon/core 0.0.27 → 0.0.29

package/src/params.ts

@@ -1,111 +1,111 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-
-import {
-  PARAM_META_KEY,
-  QUERY_META_KEY,
-  REQUEST_BODY_META_KEY,
-  REQUEST_HEADER_META_KEY,
-  REQUEST_USER_META_KEY,
-  ROUTE_META_KEY,
-} from "./container";
-import { getDataType, isClassValidatorClass, isValidType } from "./helpers";
-import { generateSwaggerSchema } from "./swagger-schema";
-
-type ParameterOptions = {
-  required?: boolean;
-  validate?: boolean;
-  type?: any;
-};
-
-function createParamDecorator(
-  type: string | symbol
-): (
-  key?: string | ParameterOptions,
-  options?: ParameterOptions
-) => ParameterDecorator {
-  return function (
-    key?: string | ParameterOptions,
-    options: { required?: boolean; validate?: boolean } = {}
-  ): ParameterDecorator {
-    return function (target: any, propertyKey: any, parameterIndex: number) {
-      const existingParams =
-        Reflect.getMetadata(type, target, propertyKey) || [];
-      const parameterTypes =
-        Reflect.getMetadata("design:paramtypes", target, propertyKey) || [];
-      const functionSource: any = target[propertyKey].toString();
-      const paramNames = functionSource
-        .match(/\(([^)]*)\)/)?.[1]
-        .split(",")
-        .map((name: any) => name.trim());
-      const paramDataType = parameterTypes[parameterIndex];
-      existingParams.push({
-        index: parameterIndex,
-        key: key ? key : "all",
-        name: paramNames[parameterIndex],
-        required: options.required == undefined ? true : options.required ,
-        validate: options.validate == undefined ? true: options.validate,
-        dataType: getDataType(paramDataType),
-        validatorClass: isClassValidatorClass(paramDataType),
-        schema: isClassValidatorClass(paramDataType)
-          ? generateSwaggerSchema(paramDataType)
-          : null,
-        type,
-      });
-      switch (type) {
-        case "route:param":
-          Reflect.defineMetadata(
-            PARAM_META_KEY,
-            existingParams,
-            target,
-            propertyKey
-          );
-          break;
-        case "route:query":
-          Reflect.defineMetadata(
-            QUERY_META_KEY,
-            existingParams,
-            target,
-            propertyKey
-          );
-          break;
-        case "route:body":
-          Reflect.defineMetadata(
-            REQUEST_BODY_META_KEY,
-            existingParams,
-            target,
-            propertyKey
-          );
-          break;
-        case "route:user":
-          Reflect.defineMetadata(
-            REQUEST_USER_META_KEY,
-            existingParams,
-            target,
-            propertyKey
-          );
-          break;
-        case "route:header":
-          Reflect.defineMetadata(
-            REQUEST_HEADER_META_KEY,
-            existingParams,
-            target,
-            propertyKey
-          );
-          break;
-        default:
-          break;
-      }
-    };
-  };
-}
-
-export const Param = createParamDecorator("route:param");
-export const Query = createParamDecorator("route:query");
-export const Body = createParamDecorator("route:body");
-export const Header = createParamDecorator("route:header");
-export const AuthUser = createParamDecorator("route:user");
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+
+import {
+  PARAM_META_KEY,
+  QUERY_META_KEY,
+  REQUEST_BODY_META_KEY,
+  REQUEST_HEADER_META_KEY,
+  REQUEST_USER_META_KEY,
+  ROUTE_META_KEY,
+} from "./container";
+import { getDataType, isClassValidatorClass, isValidType } from "./helpers";
+import { generateSwaggerSchema } from "./swagger-schema";
+
+type ParameterOptions = {
+  required?: boolean;
+  validate?: boolean;
+  type?: any;
+};
+
+function createParamDecorator(
+  type: string | symbol,
+): (
+  key?: string | ParameterOptions,
+  options?: ParameterOptions,
+) => ParameterDecorator {
+  return function (
+    key?: string | ParameterOptions,
+    options: { required?: boolean; validate?: boolean } = {},
+  ): ParameterDecorator {
+    return function (target: any, propertyKey: any, parameterIndex: number) {
+      const existingParams =
+        Reflect.getMetadata(type, target, propertyKey) || [];
+      const parameterTypes =
+        Reflect.getMetadata("design:paramtypes", target, propertyKey) || [];
+      const functionSource: any = target[propertyKey].toString();
+      const paramNames = functionSource
+        .match(/\(([^)]*)\)/)?.[1]
+        .split(",")
+        .map((name: any) => name.trim());
+      const paramDataType = parameterTypes[parameterIndex];
+      existingParams.push({
+        index: parameterIndex,
+        key: key ? key : "all",
+        name: paramNames[parameterIndex],
+        required: options.required == undefined ? true : options.required,
+        validate: options.validate == undefined ? true : options.validate,
+        dataType: getDataType(paramDataType),
+        validatorClass: isClassValidatorClass(paramDataType),
+        schema: isClassValidatorClass(paramDataType)
+          ? generateSwaggerSchema(paramDataType)
+          : null,
+        type,
+      });
+      switch (type) {
+        case "route:param":
+          Reflect.defineMetadata(
+            PARAM_META_KEY,
+            existingParams,
+            target,
+            propertyKey,
+          );
+          break;
+        case "route:query":
+          Reflect.defineMetadata(
+            QUERY_META_KEY,
+            existingParams,
+            target,
+            propertyKey,
+          );
+          break;
+        case "route:body":
+          Reflect.defineMetadata(
+            REQUEST_BODY_META_KEY,
+            existingParams,
+            target,
+            propertyKey,
+          );
+          break;
+        case "route:user":
+          Reflect.defineMetadata(
+            REQUEST_USER_META_KEY,
+            existingParams,
+            target,
+            propertyKey,
+          );
+          break;
+        case "route:header":
+          Reflect.defineMetadata(
+            REQUEST_HEADER_META_KEY,
+            existingParams,
+            target,
+            propertyKey,
+          );
+          break;
+        default:
+          break;
+      }
+    };
+  };
+}
+
+export const Param = createParamDecorator("route:param");
+export const Query = createParamDecorator("route:query");
+export const Body = createParamDecorator("route:body");
+export const Header = createParamDecorator("route:header");
+export const AuthUser = createParamDecorator("route:user");

package/src/queue.ts

@@ -1,126 +1,126 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-
-import { promises as fs } from "fs";
-import { join } from "path";
-import { uuid } from "./helpers";
-
-interface Job {
-  id: string;
-  data: any;
-}
-
-interface QueueAdapter {
-  loadJobs(): Promise<Job[]>;
-  saveJobs(jobs: Job[]): Promise<void>;
-}
-
-export class FileQueueAdapter implements QueueAdapter {
-  private queueFile: string;
-
-  constructor(queueName: string) {
-    this.queueFile = join(__dirname, `${queueName}.json`);
-  }
-
-  async loadJobs(): Promise<Job[]> {
-    try {
-      const data = await fs.readFile(this.queueFile, "utf-8");
-      return JSON.parse(data);
-    } catch (error) {
-      return [];
-    }
-  }
-
-  async saveJobs(jobs: Job[]) {
-    await fs.writeFile(this.queueFile, JSON.stringify(jobs, null, 2), "utf-8");
-  }
-}
-
-// 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 {
-  private processing: boolean = false;
-  private jobHandler: (job: Job) => Promise<void>;
-  private adapter: QueueAdapter;
-
-  constructor(adapter: QueueAdapter, jobHandler: (job: Job) => Promise<void>) {
-    this.adapter = adapter;
-    this.jobHandler = jobHandler;
-  }
-
-  async addJob(data: any) {
-    const job: Job = { id: uuid, data };
-    const jobs = await this.adapter.loadJobs();
-    jobs.push(job);
-    await this.adapter.saveJobs(jobs);
-    this.processNext();
-  }
-
-  private 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();
-    }
-  }
-}
-
-export class QueueManager {
-  private static instance: QueueManager;
-  private adapter: QueueAdapter;
-
-  private constructor(adapter: QueueAdapter) {
-    this.adapter = adapter;
-  }
-
-  static getInstance(adapter: QueueAdapter): QueueManager {
-    if (!QueueManager.instance) {
-      QueueManager.instance = new QueueManager(adapter);
-    }
-    return QueueManager.instance;
-  }
-
-  createQueue(jobHandler: (job: Job) => Promise<void>): SimpleQueue {
-    return new SimpleQueue(this.adapter, jobHandler);
-  }
-}
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+
+import { promises as fs } from "fs";
+import { join } from "path";
+import { uuid } from "./helpers";
+
+interface Job {
+  id: string;
+  data: any;
+}
+
+interface QueueAdapter {
+  loadJobs(): Promise<Job[]>;
+  saveJobs(jobs: Job[]): Promise<void>;
+}
+
+export class FileQueueAdapter implements QueueAdapter {
+  private queueFile: string;
+
+  constructor(queueName: string) {
+    this.queueFile = join(__dirname, `${queueName}.json`);
+  }
+
+  async loadJobs(): Promise<Job[]> {
+    try {
+      const data = await fs.readFile(this.queueFile, "utf-8");
+      return JSON.parse(data);
+    } catch (error) {
+      return [];
+    }
+  }
+
+  async saveJobs(jobs: Job[]) {
+    await fs.writeFile(this.queueFile, JSON.stringify(jobs, null, 2), "utf-8");
+  }
+}
+
+// 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 {
+  private processing: boolean = false;
+  private jobHandler: (job: Job) => Promise<void>;
+  private adapter: QueueAdapter;
+
+  constructor(adapter: QueueAdapter, jobHandler: (job: Job) => Promise<void>) {
+    this.adapter = adapter;
+    this.jobHandler = jobHandler;
+  }
+
+  async addJob(data: any) {
+    const job: Job = { id: uuid, data };
+    const jobs = await this.adapter.loadJobs();
+    jobs.push(job);
+    await this.adapter.saveJobs(jobs);
+    this.processNext();
+  }
+
+  private 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();
+    }
+  }
+}
+
+export class QueueManager {
+  private static instance: QueueManager;
+  private adapter: QueueAdapter;
+
+  private constructor(adapter: QueueAdapter) {
+    this.adapter = adapter;
+  }
+
+  static getInstance(adapter: QueueAdapter): QueueManager {
+    if (!QueueManager.instance) {
+      QueueManager.instance = new QueueManager(adapter);
+    }
+    return QueueManager.instance;
+  }
+
+  createQueue(jobHandler: (job: Job) => Promise<void>): SimpleQueue {
+    return new SimpleQueue(this.adapter, jobHandler);
+  }
+}

package/src/response.ts

@@ -1,74 +1,74 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-import {
-  instanceToPlain,
-  plainToInstance,
-  ClassConstructor,
-  ClassTransformer,
-} from "class-transformer";
-
-export interface IHttpResponse<T extends any> {
-  message: string;
-  data: T | null;
-}
-
-function isClassTransformerClass(target: any): boolean {
-  const prototype = target.prototype;
-  const keys = Reflect.getMetadataKeys(prototype);
-
-  // Check for class-transformer metadata
-  return keys.some((key) => key.startsWith("class_transformer:"));
-}
-
-function isClassTransformerType<T>(target: new () => T): boolean {
-  return isClassTransformerClass(target);
-}
-
-export class HttpResponse {
-  static Ok<T>(obj: any, s?: ClassConstructor<T>): IHttpResponse<T> {
-    if (s) {
-      const isPaginated = obj?.hasOwnProperty("total");
-      const dataToTransform = isPaginated ? obj.data : obj;
-
-      const transformedData = plainToInstance(s, dataToTransform, {
-        enableImplicitConversion: true,
-        excludeExtraneousValues: true,
-      });
-
-      const transformedResult = isPaginated
-        ? { ...obj, data: instanceToPlain(transformedData) }
-        : { data: instanceToPlain(transformedData) };
-
-      return {
-        message: "success",
-        ...transformedResult,
-      };
-    }
-
-    return { message: "success", data: obj };
-  }
-
-  static Created<T>(obj: any, s?: ClassConstructor<T>): IHttpResponse<T> {
-    if (s) {
-      const transformedData = plainToInstance(s, obj, {
-        enableImplicitConversion: true,
-        excludeExtraneousValues: true,
-      });
-
-      return {
-        message: "created",
-        data: instanceToPlain(transformedData) as T,
-      };
-    }
-
-    return { message: "created", data: obj };
-  }
-
-  static NoContent(): IHttpResponse<null> {
-    return { message: "no content", data: null };
-  }
-}
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+import {
+  instanceToPlain,
+  plainToInstance,
+  ClassConstructor,
+  ClassTransformer,
+} from "class-transformer";
+
+export interface IHttpResponse<T extends any> {
+  message: string;
+  data: T | null;
+}
+
+function isClassTransformerClass(target: any): boolean {
+  const prototype = target.prototype;
+  const keys = Reflect.getMetadataKeys(prototype);
+
+  // Check for class-transformer metadata
+  return keys.some((key) => key.startsWith("class_transformer:"));
+}
+
+function isClassTransformerType<T>(target: new () => T): boolean {
+  return isClassTransformerClass(target);
+}
+
+export class HttpResponse {
+  static Ok<T>(obj: any, s?: ClassConstructor<T>): IHttpResponse<T> {
+    if (s) {
+      const isPaginated = obj?.hasOwnProperty("total");
+      const dataToTransform = isPaginated ? obj.data : obj;
+
+      const transformedData = plainToInstance(s, dataToTransform, {
+        enableImplicitConversion: true,
+        excludeExtraneousValues: true,
+      });
+
+      const transformedResult = isPaginated
+        ? { ...obj, data: instanceToPlain(transformedData) }
+        : { data: instanceToPlain(transformedData) };
+
+      return {
+        message: "success",
+        ...transformedResult,
+      };
+    }
+
+    return { message: "success", data: obj };
+  }
+
+  static Created<T>(obj: any, s?: ClassConstructor<T>): IHttpResponse<T> {
+    if (s) {
+      const transformedData = plainToInstance(s, obj, {
+        enableImplicitConversion: true,
+        excludeExtraneousValues: true,
+      });
+
+      return {
+        message: "created",
+        data: instanceToPlain(transformedData) as T,
+      };
+    }
+
+    return { message: "created", data: obj };
+  }
+
+  static NoContent(): IHttpResponse<null> {
+    return { message: "no content", data: null };
+  }
+}

package/src/results.ts

@@ -1,30 +1,30 @@
-export type OkOptions = {
-  streamable: boolean;
-};
-
-export class Results {
-  static code = 500;
-  message: string = "Something going wrong";
-
-  static Ok<T>(data: T): Ok<T> {
-    return new Ok<T>(data);
-  }
-  static NoContent() {
-    this.code = 204;
-  }
-  static OkStream() {}
-  static NotFound<T>(message: T) {
-    return new NotFound<T>(message);
-  }
-}
-
-export class Ok<T> {
-  constructor(public data: T) {}
-}
-
-export class NotFound<T> {
-  constructor(public message: T) {}
-}
-
-// This type ensures methods must return Results.Ok
-export type RouteResult<T = any> = typeof Results.Ok<T>;
+export type OkOptions = {
+  streamable: boolean;
+};
+
+export class Results {
+  static code = 500;
+  message: string = "Something going wrong";
+
+  static Ok<T>(data: T): Ok<T> {
+    return new Ok<T>(data);
+  }
+  static NoContent() {
+    this.code = 204;
+  }
+  static OkStream() {}
+  static NotFound<T>(message: T) {
+    return new NotFound<T>(message);
+  }
+}
+
+export class Ok<T> {
+  constructor(public data: T) {}
+}
+
+export class NotFound<T> {
+  constructor(public message: T) {}
+}
+
+// This type ensures methods must return Results.Ok
+export type RouteResult<T = any> = typeof Results.Ok<T>;