fix: revert to previous version 1.5.0

Author: zulfikar4568

src/frameworks/shared/controllers/rpc-extended-controller.decorator.ts

@@ -1,10 +1,27 @@
 import { UseFilters, UseInterceptors, applyDecorators } from '@nestjs/common';
 import { RpcExtendedExceptionFilter } from '../filters';
-import { RpcLoggingInterceptor } from '../interceptors';
+import { RpcContextInterceptor, RpcLoggingInterceptor } from '../interceptors';
+import { RegisterControls } from '../decorators/register-controls.decorator';
 
-export function RpcExtendedController() {
-  return applyDecorators(
+/**
+ * Extended RPC controller decorator that applies:
+ * 1. Standard RPC filters and interceptors
+ * 2. Automatic control registration
+ *
+ * @param prefix Controller prefix (optional)
+ */
+export function RpcExtendedController(handlerType?: string) {
+  const decorators = [
+    // Only add Controller with prefix if prefix is provided
     UseFilters(RpcExtendedExceptionFilter),
     UseInterceptors(RpcLoggingInterceptor),
-  );
+    UseInterceptors(RpcContextInterceptor),
+  ];
+
+  // Add RegisterControls decorator if handlerType is provided
+  if (handlerType) {
+    decorators.push(RegisterControls(handlerType));
+  }
+
+  return applyDecorators(...decorators);
 }

src/frameworks/shared/decorators/logged-message-pattern.decorator.ts

@@ -1,16 +1,33 @@
 import { MessagePattern } from '@nestjs/microservices';
 import { log } from '../utils';
+import { Control } from './register-controls.decorator';
 
-export function LoggedMessagePattern(subject: string) {
+/**
+ * Decorator that combines MessagePattern with logging and Control registration.
+ * This allows a method to be both a message handler and a registered control.
+ *
+ * @param subject The message subject pattern
+ * @param description Optional description for the Control registration
+ */
+export function LoggedMessagePattern(subject: string, description?: string) {
   return function (
     target: any,
     propertyKey: string,
     descriptor: PropertyDescriptor,
   ) {
     const className = target.constructor.name;
+
+    // Log registration
     log.info(
       `Registering message pattern for subject: ${subject} in class: ${className}`,
     );
+
+    // Apply the Control decorator if description is provided
+    if (description) {
+      Control(description)(target, propertyKey, descriptor);
+    }
+
+    // Apply the MessagePattern decorator
     return MessagePattern(subject)(target, propertyKey, descriptor);
   };
 }

src/frameworks/shared/decorators/register-control.decorator.ts

@@ -0,0 +1,102 @@
+import { SetMetadata } from '@nestjs/common';
+import { HandlerRegistryService } from '@/modules/messaging/domain/usecases/services/handler-registry.service';
+import { log } from '../utils';
+
+export const REGISTERED_CONTROLS = 'registered_controls';
+
+export interface ControlMetadata {
+  description: string;
+}
+
+/**
+ * Decorator for registering a method as a control
+ *
+ * @param description Description of what the control does
+ */
+export const Control = (description: string) =>
+  SetMetadata<string, ControlMetadata>(REGISTERED_CONTROLS, { description });
+
+/**
+ * Decorator for registering a handler class with all its control methods.
+ *
+ * This decorator automatically detects the HandlerRegistryService from the
+ * dependency injection container, so you don't need to manually inject it
+ * in your handler constructor.
+ *
+ * Usage:
+ * ```typescript
+ * @Injectable()
+ * @RegisterControls('MyHandlerType')
+ * export class MyHandler {
+ *   constructor() {
+ *     // No need to inject HandlerRegistryService
+ *   }
+ *
+ *   @Control('Does something useful')
+ *   async myMethod() {
+ *     // Implementation
+ *   }
+ * }
+ * ```
+ *
+ * @param handlerType The type of handler (SystemControl, Command, etc.)
+ */
+export function RegisterControls(handlerType: string) {
+  return function (target: any) {
+    // Store the original constructor
+    const originalConstructor = target;
+
+    // Create a new constructor function
+    const newConstructor: any = function (...args: any[]) {
+      const instance = new originalConstructor(...args);
+
+      // Get the handler registry service from the DI container
+      const handlerRegistryService = args.find(
+        (arg) => arg instanceof HandlerRegistryService,
+      ) as HandlerRegistryService;
+
+      // Ensure we have access to the registry service
+      if (!handlerRegistryService) {
+        log.warn(
+          `HandlerRegistryService not injected in ${target.name}. Controls will not be registered.`,
+        );
+        return instance;
+      }
+
+      // Get all methods from the class prototype
+      const prototype = Object.getPrototypeOf(instance);
+      const methodNames = Object.getOwnPropertyNames(prototype).filter(
+        (prop) => {
+          // Exclude constructor and private methods (starting with _)
+          return (
+            prop !== 'constructor' &&
+            !prop.startsWith('_') &&
+            typeof prototype[prop] === 'function'
+          );
+        },
+      );
+
+      // Register each method that has the @Control decorator
+      methodNames.forEach((methodName) => {
+        const method = prototype[methodName];
+        const metadata = Reflect.getMetadata(REGISTERED_CONTROLS, method);
+
+        if (metadata) {
+          handlerRegistryService.registerControl(
+            handlerType,
+            methodName,
+            metadata.description,
+          );
+        }
+      });
+
+      return instance;
+    };
+
+    // Copy prototype so instanceof operator still works
+    newConstructor.prototype = originalConstructor.prototype;
+
+    // Return the new constructor
+    return newConstructor;
+  };
+}

src/frameworks/shared/decorators/register-controls.decorator.ts

@@ -11,20 +11,20 @@ import { ConfigRegistryService } from '@/modules/messaging/domain/usecases/servi
 import { HandlerRegistryService } from '@/modules/messaging/domain/usecases/services/handler-registry.service';
 import { MessagingHandler } from './messaging.handler';
 import { SubjectFactory } from '../factories/subject.factory';
+import { SYSTEM_CONTROL_MESSAGE_TYPE } from './constant.handler';
 import {
   GetConfigurationValidator,
   GetConfigurationParameterValidator,
   GetControlListValidator,
 } from '../entities/system-control.validator';
-import { SYSTEM_CONTROL_MESSAGE_TYPE } from './constant.handler';
 
 @Injectable()
 export class SystemControlHandler extends MessagingHandler {
   constructor(
     @Inject(MESSAGING_ADAPTER)
     private readonly messagingAdapter: IMessagingAdapter,
     private readonly configRegistry: ConfigRegistryService,
-    public readonly handlerRegistry: HandlerRegistryService,
+    private readonly handlerRegistry: HandlerRegistryService,
   ) {
     super();
   }

src/modules/messaging/domain/usecases/handlers/system-control.handler.ts

@@ -2,8 +2,6 @@ import { Injectable } from '@nestjs/common';
 import { MessagingHandler } from './messaging.handler';
 import { HealthService } from '@/frameworks/health/health.service';
 import { log } from '@/frameworks';
-import { SYSTEM_MONITOR_MESSAGE_TYPE } from './constant.handler';
-import { RegisterControl } from '../../../../../frameworks/shared/decorators/register-control.decorator';
 
 interface IHealthResponse {
   data: {
@@ -18,11 +16,6 @@ export class SystemMonitorHandler extends MessagingHandler {
     super();
   }
 
-  @RegisterControl(
-    SYSTEM_MONITOR_MESSAGE_TYPE,
-    'health',
-    'Performs a health check on the system and returns the status',
-  )
   public async health() {
     try {
       log.info('Executing health check command');