@nestjstools/messaging/lib/bus/in-memory-message.bus.js

Simplifies asynchronous and synchronous message handling with support for buses, handlers, channels, and consumers. Build scalable, decoupled applications with ease and reliability.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.InMemoryMessageBus = void 0;
const in_memory_channel_1 = require("../channel/in-memory.channel");
const handler_middleware_1 = require("../middleware/handler-middleware");
const middleware_context_1 = require("../middleware/middleware.context");
const decorator_extractor_1 = require("../shared/decorator-extractor");
const sealed_routing_message_1 = require("../message/sealed-routing-message");
const object_forward_message_normalizer_1 = require("../normalizer/object-forward-message.normalizer");
const message_factory_1 = require("../message/message.factory");
const routing_message_1 = require("../message/routing-message");
const default_message_options_1 = require("../message/default-message-options");
class InMemoryMessageBus {
    constructor(registry, middlewareRegistry, channel, normalizerRegistry) {
        this.registry = registry;
        this.middlewareRegistry = middlewareRegistry;
        this.channel = channel;
        this.normalizerRegistry = normalizerRegistry;
    }
    async dispatch(message) {
        const middlewares = [];
        middlewares.push(...(this.channel.config?.middlewares ?? []), ...(message.messageOptions?.middlewares ?? []), handler_middleware_1.HandlerMiddleware);
        try {
            this.registry.getByRoutingKey(message.messageRoutingKey);
        }
        catch (e) {
            let avoidErrorsForNonExistedHandlers = true;
            if (this.channel instanceof in_memory_channel_1.InMemoryChannel &&
                'default.bus' !== this.channel.config.name) {
                avoidErrorsForNonExistedHandlers =
                    this.channel.config.avoidErrorsForNotExistedHandlers ??
                        avoidErrorsForNonExistedHandlers;
            }
            else {
                avoidErrorsForNonExistedHandlers =
                    message.messageOptions?.avoidErrorsWhenNotExistedHandler ??
                        avoidErrorsForNonExistedHandlers;
            }
            if (avoidErrorsForNonExistedHandlers) {
                return Promise.resolve();
            }
            throw e;
        }
        const middlewareInstances = middlewares.map((middleware) => this.middlewareRegistry.getByName(decorator_extractor_1.DecoratorExtractor.extractMessageMiddleware(middleware)));
        const context = middleware_context_1.MiddlewareContext.createFresh(middlewareInstances);
        let messageToDispatch = message instanceof routing_message_1.RoutingMessage ? message.message : {};
        if (message instanceof sealed_routing_message_1.SealedRoutingMessage) {
            let normalizerDefinition = (message.messageOptions instanceof default_message_options_1.DefaultMessageOptions
                ? message.messageOptions.normalizer
                : object_forward_message_normalizer_1.ObjectForwardMessageNormalizer);
            messageToDispatch = await this.normalizerRegistry
                .getByName(normalizerDefinition['name'])
                .denormalize(message.message, message.messageRoutingKey);
        }
        const response = await middlewareInstances[0].process(message_factory_1.MessageFactory.creteRoutingFromMessage(messageToDispatch, message), context);
        return Promise.resolve(response);
    }
}
exports.InMemoryMessageBus = InMemoryMessageBus;
//# sourceMappingURL=in-memory-message.bus.js.map