[SILO-454] chore: refactor decorator, logger packages (#7618)

* [SILO-454] chore: refactor decorator, logger packages

- add registerControllers function abstracting both rest, ws controllers
- update logger to a simple json based logger

* fix: logger instance and middleware

* fix: type and module resolutions

* fix: lodash type package update

* fix: bypass lint errors in decorators

* chore: format changes

---------

Co-authored-by: sriramveeraghanta <veeraghanta.sriram@gmail.com>

packages/decorators/.prettierrc

@@ -0,0 +1,5 @@
+{
+  "printWidth": 120,
+  "tabWidth": 2,
+  "trailingComma": "es5"
+}

packages/decorators/README.md

@@ -52,11 +52,7 @@ userController.registerRoutes(router);
 ### WebSocket Controller
 
 ```typescript
-import {
-  Controller,
-  WebSocket,
-  BaseWebSocketController,
-} from "@plane/decorators";
+import { Controller, WebSocket, BaseWebSocketController } from "@plane/decorators";
 import { Request } from "express";
 import { WebSocket as WS } from "ws";
 

packages/decorators/package.json

@@ -11,35 +11,23 @@
     "dist/**"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs --dts --external express,ws",
-    "dev": "tsup src/index.ts --format esm,cjs --watch --dts --external express,ws",
-    "check:lint": "eslint . --max-warnings 0",
+    "build": "tsc --noEmit && tsup --minify",
+    "dev": "tsup --watch",
+    "check:lint": "eslint . --max-warnings 1",
     "check:types": "tsc --noEmit",
     "check:format": "prettier --check \"**/*.{ts,tsx,md,json,css,scss}\"",
     "fix:lint": "eslint . --fix",
     "fix:format": "prettier --write \"**/*.{ts,tsx,md,json,css,scss}\"",
     "clean": "rm -rf .turbo && rm -rf .next && rm -rf node_modules && rm -rf dist"
   },
-  "dependencies": {
-    "express": "^4.21.2",
-    "reflect-metadata": "^0.2.2"
-  },
   "devDependencies": {
     "@plane/eslint-config": "workspace:*",
     "@plane/typescript-config": "workspace:*",
     "@types/express": "^4.17.21",
     "@types/node": "^20.14.9",
     "@types/ws": "^8.5.10",
+    "reflect-metadata": "^0.2.2",
     "tsup": "8.4.0",
     "typescript": "5.8.3"
-  },
-  "peerDependencies": {
-    "express": ">=4.21.2",
-    "ws": ">=8.0.0"
-  },
-  "peerDependenciesMeta": {
-    "ws": {
-      "optional": true
-    }
   }
 }

packages/decorators/src/controller.ts

@@ -1,15 +1,9 @@
-import { RequestHandler, Router } from "express";
+import type { RequestHandler, Router, Request } from "express";
+import type { WebSocket } from "ws";
+
 import "reflect-metadata";
 
-type HttpMethod =
-  | "get"
-  | "post"
-  | "put"
-  | "delete"
-  | "patch"
-  | "options"
-  | "head"
-  | "ws";
+type HttpMethod = "get" | "post" | "put" | "delete" | "patch" | "options" | "head" | "ws";
 
 interface ControllerInstance {
   [key: string]: unknown;
@@ -22,40 +16,85 @@ interface ControllerConstructor {
 
 export function registerControllers(
   router: Router,
-  Controller: ControllerConstructor,
+  controllers: ControllerConstructor[],
+  dependencies: any[] = []
 ): void {
+  controllers.forEach((Controller) => {
+    // Create the controller instance with dependencies
+    const instance = new Controller(...dependencies);
+
+    // Determine if it's a WebSocket controller or REST controller by checking
+    // if it has any methods with the "ws" method metadata
+    const isWebsocket = Object.getOwnPropertyNames(Controller.prototype).some((methodName) => {
+      if (methodName === "constructor") return false;
+      return Reflect.getMetadata("method", instance, methodName) === "ws";
+    });
+
+    if (isWebsocket) {
+      // Register as WebSocket controller
+      // Pass the existing instance with dependencies to avoid creating a new instance without them
+      registerWebSocketController(router, Controller, instance);
+    } else {
+      // Register as REST controller - doesn't accept an instance parameter
+      registerRestController(router, Controller);
+    }
+  });
+}
+
+function registerRestController(router: Router, Controller: ControllerConstructor): void {
   const instance = new Controller();
   const baseRoute = Reflect.getMetadata("baseRoute", Controller) as string;
 
   Object.getOwnPropertyNames(Controller.prototype).forEach((methodName) => {
     if (methodName === "constructor") return; // Skip the constructor
 
-    const method = Reflect.getMetadata(
-      "method",
-      instance,
-      methodName,
-    ) as HttpMethod;
+    const method = Reflect.getMetadata("method", instance, methodName) as HttpMethod;
     const route = Reflect.getMetadata("route", instance, methodName) as string;
-    const middlewares =
-      (Reflect.getMetadata(
-        "middlewares",
-        instance,
-        methodName,
-      ) as RequestHandler[]) || [];
+    const middlewares = (Reflect.getMetadata("middlewares", instance, methodName) as RequestHandler[]) || [];
 
     if (method && route) {
       const handler = instance[methodName] as unknown;
 
       if (typeof handler === "function") {
         if (method !== "ws") {
-          (
-            router[method] as (
-              path: string,
-              ...handlers: RequestHandler[]
-            ) => void
-          )(`${baseRoute}${route}`, ...middlewares, handler.bind(instance));
+          (router[method] as (path: string, ...handlers: RequestHandler[]) => void)(
+            `${baseRoute}${route}`,
+            ...middlewares,
+            handler.bind(instance)
+          );
         }
       }
     }
   });
 }
+
+function registerWebSocketController(
+  router: Router,
+  Controller: ControllerConstructor,
+  existingInstance?: ControllerInstance
+): void {
+  const instance = existingInstance || new Controller();
+  const baseRoute = Reflect.getMetadata("baseRoute", Controller) as string;
+
+  Object.getOwnPropertyNames(Controller.prototype).forEach((methodName) => {
+    if (methodName === "constructor") return; // Skip the constructor
+
+    const method = Reflect.getMetadata("method", instance, methodName) as string;
+    const route = Reflect.getMetadata("route", instance, methodName) as string;
+
+    if (method === "ws" && route) {
+      const handler = instance[methodName] as unknown;
+
+      if (typeof handler === "function" && "ws" in router && typeof router.ws === "function") {
+        router.ws(`${baseRoute}${route}`, (ws: WebSocket, req: Request) => {
+          try {
+            handler.call(instance, ws, req);
+          } catch (error) {
+            console.error(`WebSocket error in ${Controller.name}.${methodName}`, error);
+            ws.close(1011, error instanceof Error ? error.message : "Internal server error");
+          }
+        });
+      }
+    }
+  });
+}

packages/decorators/src/index.ts

@@ -3,7 +3,6 @@ export { Controller, Middleware } from "./rest";
 export { Get, Post, Put, Patch, Delete } from "./rest";
 export { WebSocket } from "./websocket";
 export { registerControllers } from "./controller";
-export { registerWebSocketControllers } from "./websocket-controller";
 
 // Also provide namespaced exports for better organization
 import * as RestDecorators from "./rest";

packages/decorators/src/rest.ts

@@ -21,9 +21,7 @@ export function Controller(baseRoute: string = ""): ClassDecorator {
  * @param method HTTP method to handle
  * @returns Method decorator
  */
-function createHttpMethodDecorator(
-  method: RestMethod,
-): (route: string) => MethodDecorator {
+function createHttpMethodDecorator(method: RestMethod): (route: string) => MethodDecorator {
   return function (route: string): MethodDecorator {
     return function (target: object, propertyKey: string | symbol) {
       Reflect.defineMetadata("method", method, target, propertyKey);
@@ -46,8 +44,7 @@ export const Delete = createHttpMethodDecorator("delete");
  */
 export function Middleware(middleware: RequestHandler): MethodDecorator {
   return function (target: object, propertyKey: string | symbol) {
-    const middlewares =
-      Reflect.getMetadata("middlewares", target, propertyKey) || [];
+    const middlewares = Reflect.getMetadata("middlewares", target, propertyKey) || [];
     middlewares.push(middleware);
     Reflect.defineMetadata("middlewares", middlewares, target, propertyKey);
   };

packages/decorators/src/websocket-controller.ts

@@ -1,81 +0,0 @@
-import { Router, Request } from "express";
-import type { WebSocket } from "ws";
-import "reflect-metadata";
-
-interface ControllerInstance {
-  [key: string]: unknown;
-}
-
-interface ControllerConstructor {
-  new (...args: unknown[]): ControllerInstance;
-  prototype: ControllerInstance;
-}
-
-export function registerWebSocketControllers(
-  router: Router,
-  Controller: ControllerConstructor,
-  existingInstance?: ControllerInstance,
-): void {
-  const instance = existingInstance || new Controller();
-  const baseRoute = Reflect.getMetadata("baseRoute", Controller) as string;
-
-  Object.getOwnPropertyNames(Controller.prototype).forEach((methodName) => {
-    if (methodName === "constructor") return; // Skip the constructor
-
-    const method = Reflect.getMetadata(
-      "method",
-      instance,
-      methodName,
-    ) as string;
-    const route = Reflect.getMetadata("route", instance, methodName) as string;
-
-    if (method === "ws" && route) {
-      const handler = instance[methodName] as unknown;
-
-      if (
-        typeof handler === "function" &&
-        "ws" in router &&
-        typeof router.ws === "function"
-      ) {
-        router.ws(`${baseRoute}${route}`, (ws: WebSocket, req: Request) => {
-          try {
-            handler.call(instance, ws, req);
-          } catch (error) {
-            console.error(
-              `WebSocket error in ${Controller.name}.${methodName}`,
-              error,
-            );
-            ws.close(
-              1011,
-              error instanceof Error ? error.message : "Internal server error",
-            );
-          }
-        });
-      }
-    }
-  });
-}
-
-/**
- * Base controller class for WebSocket endpoints
- */
-export abstract class BaseWebSocketController {
-  protected router: Router;
-
-  constructor() {
-    this.router = Router();
-  }
-
-  /**
-   * Get the base route for this controller
-   */
-  protected getBaseRoute(): string {
-    return Reflect.getMetadata("baseRoute", this.constructor) || "";
-  }
-
-  /**
-   * Abstract method to handle WebSocket connections
-   * Implement this in your derived class
-   */
-  abstract handleConnection(ws: WebSocket, req: Request): void;
-}

packages/decorators/tsconfig.json

@@ -6,7 +6,6 @@
     "lib": ["ES2020"],
     "rootDir": ".",
     "baseUrl": ".",
-
     "paths": {
       "@/*": ["./src/*"]
     }