@avleon/core 0.0.27 → 0.0.29

package/src/event-dispatcher.ts

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,79 @@
+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 +1,86 @@
-/**
- * @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)
-}
+/**
+ * @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 +1 @@
-export * from './http-exceptions';
+export * from "./http-exceptions";

package/src/exceptions/system-exception.ts

@@ -1,34 +1,35 @@
-/**
- * @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.`)
-    }
-}
+/**
+ * @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.`);
+  }
+}