@logistically/events-nestjs/dist/services/event-module-scanner.service.js

NestJS integration for @logistically/events v3 - Event-driven architecture with Redis Streams

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
var EventModuleScanner_1;
Object.defineProperty(exports, "__esModule", { value: true });
exports.EventModuleScanner = void 0;
const common_1 = require("@nestjs/common");
const event_listeners_controller_service_1 = require("./event-listeners-controller.service");
const event_discovery_service_1 = require("./event-discovery.service");
let EventModuleScanner = EventModuleScanner_1 = class EventModuleScanner {
    constructor(listenersController, eventDiscoveryService) {
        this.listenersController = listenersController;
        this.eventDiscoveryService = eventDiscoveryService;
        this.logger = new common_1.Logger(EventModuleScanner_1.name);
    }
    async onModuleInit() {
        this.logger.log('EventModuleScanner: Starting automatic event handler discovery...');
        if (!this.listenersController || !this.eventDiscoveryService) {
            this.logger.warn('EventModuleScanner: Dependencies not available, using fallback discovery');
            this.logger.log('EventModuleScanner: Handlers will be registered via @AutoEvents decorator and EventDiscoveryService');
            return;
        }
        this.logger.log('EventModuleScanner: Automatic discovery enabled - scanning for event handlers');
        // Trigger discovery immediately - the EventDiscoveryService will handle timing
        await this.scanAndRegisterAllHandlers();
    }
    /**
     * Scan all services and register their event handlers automatically
     * This is the core of the automatic discovery system
     */
    async scanAndRegisterAllHandlers() {
        try {
            this.logger.log('EventModuleScanner: Starting global scan for event handlers...');
            // Trigger registration of any pending services in the EventDiscoveryService
            if (this.eventDiscoveryService) {
                await this.eventDiscoveryService.triggerRegistration();
            }
            this.logger.log('EventModuleScanner: Global scan completed - triggered registration of pending services');
        }
        catch (error) {
            this.logger.error('EventModuleScanner: Failed to scan and register handlers:', error);
        }
    }
    /**
     * Register event handlers for an instance if it has any
     * This method can be called by other services
     */
    async registerHandlersIfFound(instance) {
        if (!this.listenersController) {
            return 0;
        }
        if (!instance || typeof instance !== 'object') {
            return 0;
        }
        // Check if this instance has any event handlers
        if (!this.listenersController.hasEventHandlers(instance)) {
            return 0;
        }
        try {
            this.logger.debug(`EventModuleScanner: Found event handlers in ${instance.constructor.name}`);
            const registeredCount = await this.listenersController.registerEventHandlers({ instance });
            if (registeredCount > 0) {
                this.logger.log(`EventModuleScanner: Auto-registered ${registeredCount} event handlers for ${instance.constructor.name}`);
            }
            return registeredCount;
        }
        catch (error) {
            this.logger.error(`EventModuleScanner: Failed to register handlers for ${instance.constructor.name}:`, error);
            return 0;
        }
    }
};
exports.EventModuleScanner = EventModuleScanner;
exports.EventModuleScanner = EventModuleScanner = EventModuleScanner_1 = __decorate([
    (0, common_1.Injectable)(),
    __param(0, (0, common_1.Optional)()),
    __param(1, (0, common_1.Optional)()),
    __metadata("design:paramtypes", [event_listeners_controller_service_1.EventListenersController,
        event_discovery_service_1.EventDiscoveryService])
], EventModuleScanner);