@dugongjs/nestjs/aggregate-domain-event-consumer/aggregate-domain-event-consumer-explorer.service.js

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 AggregateDomainEventConsumerExplorerService_1;
import { Injectable, Optional } from "@nestjs/common";
import { DiscoveryService, MetadataScanner } from "@nestjs/core";
import { AggregateMessageConsumerService } from "../aggregate-message-consumer/aggregate-message-consumer.service.js";
import { AGGREGATE_DOMAIN_EVENT_CONSUMER_TOKEN } from "../decorators/aggregate-domain-event-consumer.decorator.js";
import { InjectLoggerFactory } from "../decorators/inject-logger-factory.decorator.js";
import { ON_DOMAIN_EVENT_TOKEN } from "../decorators/on-domain-event.decorator.js";
let AggregateDomainEventConsumerExplorerService = AggregateDomainEventConsumerExplorerService_1 = class AggregateDomainEventConsumerExplorerService {
    constructor(discoveryService, metadataScanner, aggregateMessageConsumerService, loggerFactory) {
        this.discoveryService = discoveryService;
        this.metadataScanner = metadataScanner;
        this.aggregateMessageConsumerService = aggregateMessageConsumerService;
        this.logger = loggerFactory?.createLogger(AggregateDomainEventConsumerExplorerService_1.name);
    }
    async onModuleInit() {
        const controllers = this.discoveryService.getControllers();
        for (const wrapper of controllers) {
            const instance = wrapper.instance;
            const metatype = wrapper.metatype;
            if (!instance || !metatype) {
                continue;
            }
            const aggregateDomainEventConsumerMetadata = Reflect.getMetadata(AGGREGATE_DOMAIN_EVENT_CONSUMER_TOKEN, metatype);
            if (!aggregateDomainEventConsumerMetadata) {
                continue;
            }
            const { aggregateClass, consumerName, options } = aggregateDomainEventConsumerMetadata;
            const handlers = this.collectHandlers(instance);
            const consumer = this.aggregateMessageConsumerService.getAggregateMessageConsumer(aggregateClass);
            await consumer.registerMessageConsumerForAggregate(consumerName, async (context) => {
                const { domainEvent } = context;
                for (const [methodKey, domainEventClasses] of handlers) {
                    if (domainEventClasses.some((cls) => domainEvent instanceof cls)) {
                        const method = instance[methodKey].bind(instance);
                        const logPrefix = consumer.getLogPrefix();
                        const logContext = consumer.getMessageLogContext(consumerName, domainEvent);
                        this.logger?.log(logContext, `${logPrefix}Message received`);
                        await method(context);
                    }
                }
            }, options);
        }
    }
    collectHandlers(instance) {
        const prototype = Object.getPrototypeOf(instance);
        const map = new Map();
        const methodNames = this.metadataScanner.getAllMethodNames(prototype);
        for (const name of methodNames) {
            const domainEventClasses = Reflect.getMetadata(ON_DOMAIN_EVENT_TOKEN, prototype, name) ?? [];
            if (domainEventClasses.length > 0) {
                map.set(name, domainEventClasses);
            }
        }
        return map;
    }
};
AggregateDomainEventConsumerExplorerService = AggregateDomainEventConsumerExplorerService_1 = __decorate([
    Injectable(),
    __param(3, Optional()),
    __param(3, InjectLoggerFactory()),
    __metadata("design:paramtypes", [DiscoveryService,
        MetadataScanner,
        AggregateMessageConsumerService, Object])
], AggregateDomainEventConsumerExplorerService);
export { AggregateDomainEventConsumerExplorerService };