@dugongjs/nestjs/dugong/dugong.module.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 DugongModule_1;
import { IConsumedMessageRepository, IDomainEventRepository, IExternalOriginMap, IInboundMessageMapper, IMessageConsumer, IMessageProducer, IOutboundMessageMapper, ISnapshotRepository, ITransactionManager } from "@dugongjs/core";
import { Module } from "@nestjs/common";
import { AggregateDomainEventConsumerModule } from "../aggregate-domain-event-consumer/aggregate-domain-event-consumer.module.js";
import { EventIssuerModule } from "../event-issuer/event-issuer.module.js";
import { ILoggerFactory } from "../logger/i-logger-factory.js";
let DugongModule = DugongModule_1 = class DugongModule {
    static register(options) {
        const adapters = options.adapters ?? {};
        const includeAggregateDomainEventConsumers = options.aggregateDomainEventConsumers ?? this.canRegisterAggregateDomainEventConsumers(adapters);
        const providers = new ProviderBuilder()
            .withClassProvider(ILoggerFactory, adapters.loggerFactory)
            .withClassProvider(IDomainEventRepository, adapters.domainEventRepository)
            .withClassProvider(ISnapshotRepository, adapters.snapshotRepository)
            .withClassProvider(IConsumedMessageRepository, adapters.consumedMessageRepository)
            .withClassProvider(ITransactionManager, adapters.transactionManager)
            .withClassProvider(IMessageConsumer, adapters.messageConsumer)
            .withClassProvider(IInboundMessageMapper, adapters.inboundMessageMapper)
            .withClassProvider(IMessageProducer, adapters.messageProducer)
            .withClassProvider(IOutboundMessageMapper, adapters.outboundMessageMapper)
            .build();
        const allProviders = [
            ...providers,
            ...this.createExternalOriginMapProviders(options.externalOrigins),
            ...(options.externalOrigins?.module?.providers ?? []),
            ...(adapters.providers ?? [])
        ];
        return {
            module: DugongModule_1,
            imports: [
                EventIssuerModule.forRoot({ currentOrigin: options.currentOrigin }),
                ...(options.externalOrigins?.module?.imports ?? []),
                ...(includeAggregateDomainEventConsumers ? [AggregateDomainEventConsumerModule] : []),
                ...(adapters.imports ?? [])
            ],
            providers: allProviders,
            exports: allProviders
        };
    }
    static forRoot(options) {
        const module = this.register(options);
        return {
            ...module,
            global: true
        };
    }
    static canRegisterAggregateDomainEventConsumers(adapters) {
        return (adapters.transactionManager !== undefined &&
            adapters.domainEventRepository !== undefined &&
            adapters.consumedMessageRepository !== undefined &&
            adapters.messageConsumer !== undefined &&
            adapters.inboundMessageMapper !== undefined);
    }
    static createExternalOriginMapProviders(options) {
        if (!options) {
            return [];
        }
        return [
            {
                provide: IExternalOriginMap,
                ...options.externalOriginMap
            }
        ];
    }
};
DugongModule = DugongModule_1 = __decorate([
    Module({})
], DugongModule);
export { DugongModule };
class ProviderBuilder {
    constructor() {
        this.providers = [];
    }
    withClassProvider(token, provider) {
        if (provider) {
            this.providers.push({
                provide: token,
                useClass: provider
            });
        }
        return this;
    }
    build() {
        return this.providers;
    }
}