@avleon/core 0.0.29 → 0.0.30

package/src/config.ts

@@ -1,85 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-import { Container, Service, Constructable, Token } from "typedi";
-import { Environment } from "./environment-variables";
-import { inject } from "./helpers";
-
-export interface IConfig<T = any> {
-  config(env: Environment): T;
-}
-
-export function AppConfig<T extends IConfig>(target: Constructable<T>) {
-  Container.set({ id: target, type: target });
-}
-
-export class AvleonConfig {
-  get<T extends IConfig<R>, R>(configClass: Constructable<T>): R {
-    const instance = Container.get(configClass);
-    if (!instance) {
-      throw new Error(`Configuration for ${configClass.name} not found.`);
-    }
-    return instance.config(new Environment());
-  }
-}
-
-// export function GetConfig<
-//   T extends IConfig<R>,
-//   R = ReturnType<InstanceType<Constructable<T>>["config"]>,
-// >(ConfigClass: Constructable<T>): R {
-//   const instance = Container.get(ConfigClass);
-//   if (!instance) {
-//     throw new Error(
-//       `Class "${ConfigClass.name}" is not registered as a config.`,
-//     );
-//   }
-//   return instance.config(new Environment());
-// }
-
-export function GetConfig<
-  T extends IConfig<R>,
-  R = ReturnType<InstanceType<Constructable<T>>["config"]>,
->(ConfigClass: Constructable<T>): R;
-
-export function GetConfig<T = any>(config: string | symbol): T;
-
-// Implementation
-export function GetConfig<R>(token: any): R {
-  // 1. Class‐based: token.prototype.config is a function
-  if (
-    typeof token === "function" &&
-    token.prototype != null &&
-    typeof token.prototype.config === "function"
-  ) {
-    const instance = Container.get(token as Constructable<any>);
-    if (!instance) {
-      throw new Error(`Class "${token.name}" is not registered as a config.`);
-    }
-    return instance.config(inject(Environment));
-  }
-
-  // 2. Functional: token is the callback itself
-  const stored = Container.get(token);
-  if (!stored) {
-    throw new Error("Config object is not registered.");
-  }
-  return stored as R;
-}
-
-export function CreateConfig<T>(
-  token: string | symbol,
-  callback: (env: Environment) => T,
-) {
-  let env!: Environment;
-  try {
-    env = Container.get(Environment);
-  } catch (error) {
-    env = new Environment();
-  }
-
-  let config: T = callback(env);
-  Container.set<T>(token as Token<T>, config);
-}

package/src/constants.ts

@@ -1 +0,0 @@
-export const TEST_DATASOURCE_OPTIONS_KEY = Symbol("itestdatasource");

package/src/container.ts

@@ -1,54 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-import TypediContainer, { ContainerInstance, Token } from "typedi";
-import { DataSource } from "typeorm";
-
-export const FEATURE_KEY = Symbol.for("features");
-export const ROUTE_META_KEY = Symbol("iroute:options");
-export const CONTROLLER_META_KEY = Symbol("icontroller:options");
-export const PARAM_META_KEY = Symbol("iparam:options");
-export const QUERY_META_KEY = Symbol("iparam:options");
-export const REQUEST_BODY_META_KEY = Symbol("iparam:options");
-export const REQUEST_BODY_FILE_KEY = Symbol("iparam:options");
-export const REQUEST_BODY_FILES_KEY = Symbol("iparam:options");
-export const REQUEST_USER_META_KEY = Symbol("iparam:options");
-export const REQUEST_HEADER_META_KEY = Symbol("iheader:options");
-export const DATASOURCE_META_KEY = Symbol("idatasource:options");
-export const AUTHORIZATION_META_KEY = Symbol("idatasource:authorization");
-
-const controllerRegistry = new Set<Function>();
-const serviceRegistry = new Set<Function>();
-const optionsRegistry = new Map<string, any>();
-
-const Container = TypediContainer;
-
-export function registerController(controller: Function) {
-  controllerRegistry.add(controller);
-}
-export function registerService(service: Function) {
-  Container.set(service, service);
-  serviceRegistry.add(service);
-}
-
-export function getRegisteredServices(): Function[] {
-  return Array.from(serviceRegistry);
-}
-export function getRegisteredControllers(): Function[] {
-  return Array.from(controllerRegistry);
-}
-
-export const API_CONTROLLER_METADATA_KEY = Symbol("apiController");
-
-export function isApiController(target: Function): boolean {
-  return Reflect.getMetadata(API_CONTROLLER_METADATA_KEY, target) === true;
-}
-Container.set<string>("appName", "Iqra");
-
-export function registerDataSource(dataSource: any) {
-  Container.set<DataSource>("idatasource", dataSource);
-}
-export default Container;

package/src/controller.ts

@@ -1,125 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-
-import Container, { Service } from "typedi";
-import container, {
-  API_CONTROLLER_METADATA_KEY,
-  CONTROLLER_META_KEY,
-  registerController,
-} from "./container";
-
-/**
- * Options for configuring a controller.
- * @remarks
- * Controller default options
- * @type {Object} ControllerOptions
- * @property {string} [name] - The name of the controller.
- * @property {string} [path] - The base path for the controller's routes.
- * @property {string} [version] - The version of the controller. If not provided, it will default to the version from `package.json`.
- * @property {string} [since] - The date or version since the controller was introduced.
- * @property {any} [meta] - Additional metadata associated with the controller.
- */
-export type ControllerOptions = {
-  /**
-   *@property {string} name
-   *@description Name of the controller. If specified it'll used as  swagger tags
-   *@default Contorller class name
-   * */
-  name?: string;
-  path?: string;
-  version?: string; // Will look at package.json if not set
-  since?: string;
-  meta?: any;
-};
-
-export function createControllerDecorator(
-  type: "api" | "web" = "web",
-): (
-  pathOrOptions?: string | ControllerOptions,
-  maybeOptions?: ControllerOptions,
-) => ClassDecorator {
-  return function (
-    pathOrOptions?: string | ControllerOptions,
-    maybeOptions?: ControllerOptions,
-  ): ClassDecorator {
-    return function (target: Function) {
-      let path = "/";
-      let options: ControllerOptions = {};
-
-      if (typeof pathOrOptions === "string") {
-        path = pathOrOptions;
-        options = maybeOptions || {};
-      } else if (typeof pathOrOptions === "object") {
-        options = pathOrOptions;
-        path = options.path || "/";
-      }
-      Reflect.defineMetadata(API_CONTROLLER_METADATA_KEY, true, target);
-      // Ensure Service is applied as a ClassDecorator
-      if (typeof Service === "function") {
-        registerController(target); // Add to custom registry
-        Service()(target); // Apply DI decorator
-        Reflect.defineMetadata(
-          CONTROLLER_META_KEY,
-          { type, path, options },
-          target,
-        );
-      } else {
-        throw new Error("Service decorator is not a function");
-      }
-    };
-  };
-}
-
-// Predefined Controller Decorators
-//export const Controller = createControllerDecorator("web");
-/**
- *@description Api controller's are used for rest . It will populate
- * json on return and all it http methods {get} {post} etc must return
- *Results.*
- * @param path {string} this will used as route prefix
- *
- **/
-
-export function ApiController(target: Function): void;
-export function ApiController(path: string): ClassDecorator;
-/**
- *@description Api controller's are used for rest . It will populate
- * json on return and all it http methods {get} {post} etc must return
- * Results.*
- * @param {ControllerOptions} options this will used as route prefix
- *
- **/
-export function ApiController(options: ControllerOptions): ClassDecorator;
-export function ApiController(
-  path: string,
-  options?: ControllerOptions,
-): ClassDecorator;
-export function ApiController(
-  pathOrOptions: Function | string | ControllerOptions = "/",
-  mayBeOptions?: ControllerOptions,
-): any {
-  if (typeof pathOrOptions == "function") {
-    Reflect.defineMetadata(API_CONTROLLER_METADATA_KEY, true, pathOrOptions);
-    // Ensure Service is applied as a ClassDecorator
-    if (typeof Service === "function") {
-      registerController(pathOrOptions); // Add to custom registry
-      Service()(pathOrOptions); // Apply DI decorator
-      Reflect.defineMetadata(
-        CONTROLLER_META_KEY,
-        { type: "api", path: "/", options: {} },
-        pathOrOptions,
-      );
-    } else {
-      throw new Error("Service decorator is not a function");
-    }
-  } else {
-    if (mayBeOptions) {
-      return createControllerDecorator("api")(pathOrOptions, mayBeOptions);
-    }
-    return createControllerDecorator("api")(pathOrOptions);
-  }
-}

package/src/decorators.ts

@@ -1,27 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-
-import { Service as _service } from "typedi";
-import container, { registerService } from "./container";
-export function AppService(target: any): void;
-export function AppService(): any;
-export function AppService(target?: any) {
-  if (target) {
-    _service()(target);
-  } else {
-    return function (tg: any) {
-      _service()(tg);
-    };
-  }
-}
-
-export * from "./controller";
-export * from "./route-methods";
-export * from "./openapi";
-export const Utility = _service;
-export const Helper = _service;
-export * from "./params";

package/src/environment-variables.ts

@@ -1,53 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-
-import dotenv from "dotenv";
-import path from "path";
-import fs, { existsSync } from "fs";
-import { Service } from "typedi";
-import {
-  EnvironmentVariableNotFound,
-  SystemUseError,
-} from "./exceptions/system-exception";
-
-dotenv.config({ path: path.join(process.cwd(), ".env") });
-
-@Service()
-export class Environment {
-  private parseEnvFile(filePath: string): any {
-    try {
-      const isExis = existsSync(filePath);
-      if (!isExis) {
-        return { ...process.env };
-      }
-      const fileContent = fs.readFileSync(filePath, "utf8");
-      const parsedEnv = dotenv.parse(fileContent);
-      return { ...parsedEnv, ...process.env };
-    } catch (error) {
-      console.error(`Error parsing .env file: ${error}`);
-      return {};
-    }
-  }
-
-  get<T = any>(key: string): T {
-    const parsedEnv = this.parseEnvFile(path.join(process.cwd(), ".env"));
-    return parsedEnv[key] as T;
-  }
-
-  getOrThrow<T = any>(key: string): T {
-    const parsedEnv = this.parseEnvFile(path.join(process.cwd(), ".env"));
-    if (!Object(parsedEnv).hasOwnProperty(key)) {
-      throw new EnvironmentVariableNotFound(key);
-    }
-    return parsedEnv[key] as T;
-  }
-
-  getAll<T = any>(): T {
-    const parsedEnv = this.parseEnvFile(path.join(process.cwd(), ".env"));
-    return parsedEnv as T;
-  }
-}

package/src/event-dispatcher.ts

@@ -1,100 +0,0 @@
-import { Service, Container } from "typedi";
-import { Server as SocketIOServer, Socket, ServerOptions } from "socket.io";
-import { AsyncLocalStorage } from "node:async_hooks";
-
-
-@Service()
-export class SocketContextService {
-  private readonly storage = new AsyncLocalStorage<{ socket: Socket }>();
-
-  run(socket: Socket, fn: () => void | Promise<void>) {
-    this.storage.run({ socket }, fn);
-  }
-
-  getSocket(): Socket | undefined {
-    return this.storage.getStore()?.socket;
-  }
-}
-
-export type DispatchOptions = {
-  room?: string;
-  broadcast?: boolean;
-  transports?: ("socket" | "kafka" | "rabbitmq")[];
-  retry?: number;
-  retryDelay?: number;
-};
-
-export function sleep(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-@Service()
-export class EventDispatcher {
-  constructor(private readonly _context: SocketContextService) {}
-
-  async dispatch<T = any>(
-    event: string,
-    data: T,
-    options: DispatchOptions = {}
-  ) {
-    const retryCount = options.retry ?? 0;
-    const delay = options.retryDelay ?? 300;
-
-    for (let attempt = 0; attempt <= retryCount; attempt++) {
-      try {
-        await this.dispatchToTransports(event, data, options);
-        break;
-      } catch (err) {
-        if (attempt === retryCount) throw err;
-        await sleep(delay * (attempt + 1));
-      }
-    }
-  }
-
-  private async dispatchToTransports(event: string, data: any, options: DispatchOptions) {
-    const transports = options.transports ?? ["socket"];
-
-    for (const transport of transports) {
-      if (transport === "socket") {
-        const io = Container.get(SocketIOServer);
-
-        //console.log('SOckert', Container.get(SocketContextService));
-
-        const context = Container.get(SocketContextService);
-        const socket = context.getSocket();
-
-      
-
-        if (options.broadcast && socket) {
-          if (options.room) {
-            socket.broadcast.to(options.room).emit(event, data);
-          } else {
-            socket.broadcast.emit(event, data);
-          }
-        } else {
-          if (options.room) {
-            io.to(options.room).emit(event, data);
-          } else {
-            io.emit(event, data);
-          }
-        }
-      }
-    }
-  }
-}
-
-
-export function Dispatch(event: string, options?: Omit<DispatchOptions, "transports"> & { transports?: DispatchOptions["transports"] }) {
-  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
-    const original = descriptor.value;
-
-    descriptor.value = async function (...args: any[]) {
-      const result = await original.apply(this, args);
-
-      const dispatcher = Container.get(EventDispatcher);
-      await dispatcher.dispatch(event, result, options);
-
-      return result;
-    };
-  };
-}

package/src/event-subscriber.ts

@@ -1,79 +0,0 @@
-import { Container, Service } from "typedi";
-import { Socket, Server } from "socket.io";
-import { SocketContextService } from "./event-dispatcher";
-import "reflect-metadata";
-
-const PRIVATE_META_KEY = "avleon:private";
-
-export function Private(channelResolver?: (socket: any) => string) {
-    return function (target: any, propertyKey: string) {
-        Reflect.defineMetadata(PRIVATE_META_KEY, true, target, propertyKey);
-        Reflect.defineMetadata(`private:channel:${propertyKey}`, channelResolver, target);
-    };
-}
-
-export function isPrivate(target: any, propertyKey: string): boolean {
-    return Reflect.getMetadata(PRIVATE_META_KEY, target, propertyKey) || false;
-}
-
-export function getPrivateChannelResolver(target: any, propertyKey: string): ((socket: any) => string) | undefined {
-    return Reflect.getMetadata(`private:channel:${propertyKey}`, target);
-}
-
-const socketSubscriberClasses = new Set<Function>();
-
-export function registerSocketSubscriber(target: Function) {
-    socketSubscriberClasses.add(target);
-}
-
-export function getSocketSubscribers(): Function[] {
-    return Array.from(socketSubscriberClasses);
-}
-
-
-export function Subscribe(event: string): MethodDecorator {
-    return (target, propertyKey) => {
-        Reflect.defineMetadata("socket:event", event, target, propertyKey);
-        registerSocketSubscriber(target.constructor);
-    };
-
-}
-
-
-@Service()
-export class EventSubscriberRegistry {
-    constructor(private readonly socketContext: SocketContextService) { }
-
-    register(socket: Socket) {
-        const subscriberClasses = getSocketSubscribers();
-
-        for (const SubscriberClass of subscriberClasses) {
-            const instance: any = Container.get(SubscriberClass);
-            const prototype = Object.getPrototypeOf(instance);
-
-            const methodNames = Object.getOwnPropertyNames(prototype)
-                .filter(name => typeof prototype[name] === "function");
-
-            for (const methodName of methodNames) {
-                const event = Reflect.getMetadata("socket:event", prototype, methodName);
-                const isPrivateListener = isPrivate(instance, methodName);
-                const channelResolver = getPrivateChannelResolver(instance, methodName);
-
-                if (event) {
-                    const channel = isPrivateListener && channelResolver ? channelResolver(socket) : event;
-                    console.log("Channel", channel);
-                    socket.on(channel, (payload: any) => {
-                        this.socketContext.run(socket, async () => {
-                            if (isPrivateListener) {
-                                const user = socket.data.user;
-                                if (!user) return; // unauthorized
-                                // optionally add more validation here
-                            }
-                            await instance[methodName](payload, socket.data);
-                        });
-                    });
-                }
-            }
-        }
-    }
-}

package/src/exceptions/http-exceptions.ts

@@ -1,86 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-export abstract class BaseHttpException extends Error {
-  code: number = 500;
-  name: string = "HttpException";
-  constructor(message: any) {
-    super(JSON.stringify(message));
-  }
-  isCustomException() {
-    return true;
-  }
-}
-
-export class BadRequestException extends BaseHttpException {
-  name: string = "BadRequest";
-  code: number = 400;
-
-  constructor(message: any) {
-    super(message);
-  }
-}
-
-export class ValidationErrorException extends BadRequestException {
-  name: string = "ValidationError";
-}
-
-export class InternalErrorException extends BaseHttpException {
-  name: string = "InternalError";
-  code: number = 500;
-
-  constructor(message: any = "Something going wrong") {
-    super(message);
-  }
-}
-
-export class NotFoundException extends BaseHttpException {
-  name: string = "NotFound";
-  code: number = 404;
-  constructor(message: any) {
-    super(message);
-  }
-}
-
-export class UnauthorizedException extends BaseHttpException {
-  name: string = "Unauthorized";
-  code: number = 401;
-  constructor(message: any) {
-    super(message);
-  }
-}
-
-export class ForbiddenException extends BaseHttpException {
-  name: string = "Forbidden";
-  code: number = 403;
-  constructor(message: any) {
-    super(message);
-  }
-}
-
-export type HttpExceptionTypes =
-  | 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 const HttpExceptions = {
-  notFound: (message: any = "") => new NotFoundException(message),
-  validationError: (message: any = "") => new ValidationErrorException(message),
-  badRequest: (message: any = "") => new BadRequestException(message),
-  unauthorized: (message: any = "") => new UnauthorizedException(message),
-  forbidden: (message: any = "") => new ForbiddenException(message),
-  internalError: (message: any = "") => new InternalErrorException(message),
-};

package/src/exceptions/index.ts

@@ -1 +0,0 @@
-export * from "./http-exceptions";

package/src/exceptions/system-exception.ts

@@ -1,35 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-export interface IRouteDuplicateErr {
-  path: string;
-  mpath: string;
-  method: string;
-  controller: string;
-  inverseController?: string;
-}
-
-export class SystemUseError extends Error {
-  constructor(message: string) {
-    super(message);
-  }
-}
-export class DuplicateRouteException extends Error {
-  constructor(params: IRouteDuplicateErr) {
-    let sameController = params.controller == params.inverseController;
-    let message = `Duplicate route found for method ${params.method.toUpperCase()}:${params.path == "" ? "'/'" : params.path} `;
-    message += sameController
-      ? `in ${params.controller}`
-      : `both in ${params.controller} and ${params.inverseController}`;
-    super(message);
-  }
-}
-
-export class EnvironmentVariableNotFound extends Error {
-  constructor(key: string) {
-    super(`${key} not found in environment variables.`);
-  }
-}