@common-stack/store-mongo 7.2.1-alpha.16 → 7.2.1-alpha.18

package/lib/templates/repositories/moleculerEventHandler.ts.template

@@ -0,0 +1,118 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+/**
+ * @file moleculer-event-handler.ts
+ * @description Decorator for marking service methods as Moleculer event handlers
+ * 
+ * This allows event handlers to be defined directly in the service class
+ * and automatically registered as Moleculer events.
+ */
+
+import 'reflect-metadata';
+
+/**
+ * Moleculer namespace containing event handler utilities
+ */
+export namespace Moleculer {
+    /**
+     * Metadata key for storing event handler information
+     */
+    export const EVENT_HANDLER_METADATA_KEY = 'moleculer:eventHandler';
+
+    /**
+     * Event handler metadata interface
+     */
+    export interface EventHandlerMetadata {
+        eventName: string;
+        methodName: string;
+        group?: string;
+    }
+
+    /**
+     * Decorator for marking a service method as a Moleculer event handler
+     * 
+     * @param eventName - The event name to listen for
+     * @param options - Optional event configuration
+     * 
+     * @example
+     * ```typescript
+     * class OrganizationService implements IOrganizationService {
+     *     @Moleculer.EventHandler(UserBroadcasterAction.OnUserCreated)
+     *     async onUserCreated(event: IUserCreationEvent): Promise<void> {
+     *         await this.createDefaultOrganization(event.user);
+     *     }
+     * 
+     *     @Moleculer.EventHandler(OrganizationServiceAction.OnOrganizationCreated, { group: 'org-setup' })
+     *     async onOrganizationCreated(event: IOrganizationCreatedEvent): Promise<void> {
+     *         // Handle organization creation
+     *     }
+     * }
+     * ```
+     */
+    export function EventHandler(
+        eventName: string,
+        options?: { group?: string }
+    ): MethodDecorator {
+        return function moleculerEventHandlerDecorator(
+            target: object,
+            propertyKey: string | symbol,
+            descriptor: PropertyDescriptor
+        ): PropertyDescriptor {
+            // Get existing event handlers for this class
+            const existingHandlers: EventHandlerMetadata[] = 
+                Reflect.getMetadata(EVENT_HANDLER_METADATA_KEY, target.constructor) || [];
+            
+            // Add this handler to the list
+            const metadata: EventHandlerMetadata = {
+                eventName,
+                methodName: propertyKey.toString(),
+                group: options?.group,
+            };
+            
+            existingHandlers.push(metadata);
+            
+            // Store the updated list
+            Reflect.defineMetadata(EVENT_HANDLER_METADATA_KEY, existingHandlers, target.constructor);
+            
+            return descriptor;
+        };
+    }
+
+    /**
+     * Get all Moleculer event handlers defined on a service class
+     * 
+     * @param serviceClassOrInstance - The service class constructor or instance
+     * @returns Array of event handler metadata
+     * 
+     * @example
+     * ```typescript
+     * const handlers = Moleculer.getEventHandlers(OrganizationService);
+     * // Returns: [
+     * //   { eventName: 'user.created', methodName: 'onUserCreated' },
+     * //   { eventName: 'org.created', methodName: 'onOrganizationCreated' }
+     * // ]
+     * ```
+     */
+    export function getEventHandlers(
+        serviceClassOrInstance: (new (...args: unknown[]) => unknown) | object
+    ): EventHandlerMetadata[] {
+        const target = typeof serviceClassOrInstance === 'function' 
+            ? serviceClassOrInstance 
+            : (serviceClassOrInstance as { constructor: new (...args: unknown[]) => unknown }).constructor;
+        return Reflect.getMetadata(EVENT_HANDLER_METADATA_KEY, target) || [];
+    }
+
+    /**
+     * Check if a method is marked as a Moleculer event handler
+     * 
+     * @param serviceClassOrInstance - The service class constructor or instance
+     * @param methodName - The method name to check
+     * @returns Event handler metadata if found, undefined otherwise
+     */
+    export function isEventHandler(
+        serviceClassOrInstance: (new (...args: unknown[]) => unknown) | object,
+        methodName: string
+    ): EventHandlerMetadata | undefined {
+        const handlers = getEventHandlers(serviceClassOrInstance);
+        return handlers.find(h => h.methodName === methodName);
+    }
+}