@avleon/core 0.0.19 → 0.0.24

package/src/openapi.ts

@@ -0,0 +1,372 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+export interface InfoObject {
+  title: string;
+  description?: string;
+  termsOfService?: string;
+  contact?: ContactObject;
+  license?: LicenseObject;
+  version: string;
+}
+export interface ContactObject {
+  name?: string;
+  url?: string;
+  email?: string;
+}
+export interface LicenseObject {
+  name: string;
+  url?: string;
+}
+export interface ServerObject {
+  url: string;
+  description?: string;
+  variables?: {
+    [variable: string]: ServerVariableObject;
+  };
+}
+export interface ServerVariableObject {
+  enum?: string[];
+  default: string;
+  description?: string;
+}
+
+export type OpenApiUiOptions = {
+  logo?: any;
+  theme?: any;
+  ui?: "default" | "scalar";
+  openapi?: string;
+  configuration?: any;
+  routePrefix?: string;
+  info?: InfoObject;
+  servers?: ServerObject[];
+  paths?: PathsObject<any>;
+  components?: ComponentsObject;
+  security?: SecurityRequirementObject[];
+  tags?: TagObject[];
+  externalDocs?: any;
+  "x-express-openapi-additional-middleware"?: (
+    | ((request: any, response: any, next: any) => Promise<void>)
+    | ((request: any, response: any, next: any) => void)
+  )[];
+  "x-express-openapi-validation-strict"?: boolean;
+};
+export interface PathsObject<T extends {} = {}, P extends {} = {}> {
+  [pattern: string]: (PathItemObject<T> & P) | undefined;
+}
+enum HttpMethods {
+  GET = "get",
+  PUT = "put",
+  POST = "post",
+  DELETE = "delete",
+  OPTIONS = "options",
+  HEAD = "head",
+  PATCH = "patch",
+  TRACE = "trace",
+}
+export type PathItemObject<T extends {} = {}> = {
+  $ref?: string;
+  summary?: string;
+  description?: string;
+  servers?: ServerObject[];
+  parameters?: (ReferenceObject | ParameterObject)[];
+} & {
+  [method in HttpMethods]?: OperationObject<T>;
+};
+export type OperationObject<T extends {} = {}> = {
+  tags?: string[];
+  summary?: string;
+  description?: string;
+  externalDocs?: ExternalDocumentationObject;
+  operationId?: string;
+  parameters?: (ReferenceObject | ParameterObject)[];
+  requestBody?: ReferenceObject | RequestBodyObject;
+  responses: ResponsesObject;
+  callbacks?: {
+    [callback: string]: ReferenceObject | CallbackObject;
+  };
+  deprecated?: boolean;
+  security?: SecurityRequirementObject[];
+  servers?: ServerObject[];
+} & T;
+export interface ExternalDocumentationObject {
+  description?: string;
+  url: string;
+}
+export interface ParameterObject extends ParameterBaseObject {
+  name: string;
+  in: string;
+}
+export interface HeaderObject extends ParameterBaseObject {}
+export interface ParameterBaseObject {
+  description?: string;
+  required?: boolean;
+  deprecated?: boolean;
+  allowEmptyValue?: boolean;
+  style?: string;
+  explode?: boolean;
+  allowReserved?: boolean;
+  schema?: ReferenceObject | SchemaObject;
+  example?: any;
+  examples?: {
+    [media: string]: ReferenceObject | ExampleObject;
+  };
+  content?: {
+    [media: string]: MediaTypeObject;
+  };
+}
+export type NonArraySchemaObjectType =
+  | "boolean"
+  | "object"
+  | "number"
+  | "string"
+  | "integer";
+export type ArraySchemaObjectType = "array";
+export type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
+export interface ArraySchemaObject extends BaseSchemaObject {
+  type: ArraySchemaObjectType;
+  items: ReferenceObject | SchemaObject;
+}
+export interface NonArraySchemaObject extends BaseSchemaObject {
+  type?: NonArraySchemaObjectType;
+}
+export interface BaseSchemaObject {
+  title?: string;
+  description?: string;
+  format?: string;
+  default?: any;
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: boolean;
+  minimum?: number;
+  exclusiveMinimum?: boolean;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  additionalProperties?: boolean | ReferenceObject | SchemaObject;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  enum?: any[];
+  properties?: {
+    [name: string]: ReferenceObject | SchemaObject;
+  };
+  allOf?: (ReferenceObject | SchemaObject)[];
+  oneOf?: (ReferenceObject | SchemaObject)[];
+  anyOf?: (ReferenceObject | SchemaObject)[];
+  not?: ReferenceObject | SchemaObject;
+  nullable?: boolean;
+  discriminator?: DiscriminatorObject;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  xml?: XMLObject;
+  externalDocs?: ExternalDocumentationObject;
+  example?: any;
+  deprecated?: boolean;
+}
+export interface DiscriminatorObject {
+  propertyName: string;
+  mapping?: {
+    [value: string]: string;
+  };
+}
+export interface XMLObject {
+  name?: string;
+  namespace?: string;
+  prefix?: string;
+  attribute?: boolean;
+  wrapped?: boolean;
+}
+export interface ReferenceObject {
+  $ref: string;
+}
+export interface ExampleObject {
+  summary?: string;
+  description?: string;
+  value?: any;
+  externalValue?: string;
+}
+export interface MediaTypeObject {
+  schema?: ReferenceObject | SchemaObject;
+  example?: any;
+  examples?: {
+    [media: string]: ReferenceObject | ExampleObject;
+  };
+  encoding?: {
+    [media: string]: EncodingObject;
+  };
+}
+export interface EncodingObject {
+  contentType?: string;
+  headers?: {
+    [header: string]: ReferenceObject | HeaderObject;
+  };
+  style?: string;
+  explode?: boolean;
+  allowReserved?: boolean;
+}
+export interface RequestBodyObject {
+  description?: string;
+  content: {
+    [media: string]: MediaTypeObject;
+  };
+  required?: boolean;
+}
+export interface ResponsesObject {
+  [code: string]: ReferenceObject | ResponseObject;
+}
+export interface ResponseObject {
+  description: string;
+  headers?: {
+    [header: string]: ReferenceObject | HeaderObject;
+  };
+  content?: {
+    [media: string]: MediaTypeObject;
+  };
+  links?: {
+    [link: string]: ReferenceObject | LinkObject;
+  };
+}
+export interface LinkObject {
+  operationRef?: string;
+  operationId?: string;
+  parameters?: {
+    [parameter: string]: any;
+  };
+  requestBody?: any;
+  description?: string;
+  server?: ServerObject;
+}
+export interface CallbackObject {
+  [url: string]: PathItemObject;
+}
+export interface SecurityRequirementObject {
+  [name: string]: string[];
+}
+export interface ComponentsObject {
+  schemas?: {
+    [key: string]: ReferenceObject | SchemaObject;
+  };
+  responses?: {
+    [key: string]: ReferenceObject | ResponseObject;
+  };
+  parameters?: {
+    [key: string]: ReferenceObject | ParameterObject;
+  };
+  examples?: {
+    [key: string]: ReferenceObject | ExampleObject;
+  };
+  requestBodies?: {
+    [key: string]: ReferenceObject | RequestBodyObject;
+  };
+  headers?: {
+    [key: string]: ReferenceObject | HeaderObject;
+  };
+  securitySchemes?: {
+    [key: string]: ReferenceObject | SecuritySchemeObject;
+  };
+  links?: {
+    [key: string]: ReferenceObject | LinkObject;
+  };
+  callbacks?: {
+    [key: string]: ReferenceObject | CallbackObject;
+  };
+}
+export type SecuritySchemeObject =
+  | HttpSecurityScheme
+  | ApiKeySecurityScheme
+  | OAuth2SecurityScheme
+  | OpenIdSecurityScheme;
+export interface HttpSecurityScheme {
+  type: "http";
+  description?: string;
+  scheme: string;
+  bearerFormat?: string;
+}
+export interface ApiKeySecurityScheme {
+  type: "apiKey";
+  description?: string;
+  name: string;
+  in: string;
+}
+export interface OAuth2SecurityScheme {
+  type: "oauth2";
+  description?: string;
+  flows: {
+    implicit?: {
+      authorizationUrl: string;
+      refreshUrl?: string;
+      scopes: {
+        [scope: string]: string;
+      };
+    };
+    password?: {
+      tokenUrl: string;
+      refreshUrl?: string;
+      scopes: {
+        [scope: string]: string;
+      };
+    };
+    clientCredentials?: {
+      tokenUrl: string;
+      refreshUrl?: string;
+      scopes: {
+        [scope: string]: string;
+      };
+    };
+    authorizationCode?: {
+      authorizationUrl: string;
+      tokenUrl: string;
+      refreshUrl?: string;
+      scopes: {
+        [scope: string]: string;
+      };
+    };
+  };
+}
+export interface OpenIdSecurityScheme {
+  type: "openIdConnect";
+  description?: string;
+  openIdConnectUrl: string;
+}
+export interface TagObject {
+  name: string;
+  description?: string;
+  externalDocs?: ExternalDocumentationObject;
+}
+
+export type OpenApiOptions = {
+  exclude?: boolean;
+  deprecated?: boolean;
+  tags?: readonly string[];
+  description?: string;
+  summary?: string;
+  components?: ComponentsObject;
+  response?: any;
+  responseBody?: any;
+  requestBody?: any;
+} & any;
+
+export function OpenApi(
+  options: OpenApiOptions
+): MethodDecorator & ClassDecorator & PropertyDecorator {
+  return function (
+    target: Object | Function,
+    propertyKey?: string | symbol,
+    descriptor?: PropertyDescriptor
+  ) {
+    if (typeof target === "function" && !propertyKey) {
+      Reflect.defineMetadata("controller:openapi", options, target);
+    } else if (descriptor) {
+      Reflect.defineMetadata("route:openapi", options, target, propertyKey!);
+    } else if (propertyKey) {
+      Reflect.defineMetadata("property:openapi", options, target, propertyKey);
+    }
+  };
+}

package/src/params.ts

@@ -0,0 +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");

package/src/queue.ts

@@ -0,0 +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);
+  }
+}

package/src/response.ts

@@ -0,0 +1,117 @@
+/**
+ * @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 };
+  }
+}
+
+export class HttpExceptions {
+  static BadRequest(message: string, data: any = null): IHttpResponse<any> {
+    return { message: message, data: data };
+  }
+
+  static Unauthorized(message: string, data: any = null): IHttpResponse<any> {
+    return { message: message, data: data };
+  }
+
+  static Forbidden(message: string, data: any = null): IHttpResponse<any> {
+    return { message: message, data: data };
+  }
+
+  static NotFound(message: string, data: any = null): IHttpResponse<any> {
+    return { message: message, data: data };
+  }
+
+  static InternalServerError(
+    message: string = "Internal server error",
+    data: any = null
+  ): IHttpResponse<any> {
+    return { message: message, data: data };
+  }
+
+  static Conflict(message: string, data: any = null): IHttpResponse<any> {
+    return { message: message, data: data };
+  }
+
+  static UnprocessableEntity(
+    message: string,
+    data: any = null
+  ): IHttpResponse<any> {
+    return { message: message, data: data };
+  }
+
+  static TooManyRequests(
+    message: string,
+    data: any = null
+  ): IHttpResponse<any> {
+    return { message: message, data: data };
+  }
+}