nest-events/dist/initializer.js

Welcome to the Nest Events library! This library provides event handling and emitting capabilities for your [NestJS](https://nestjs.com/) applications. With Nest Events, you can easily manage and trigger events within your application, making it simpler t

"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);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.EventBusInitializer = void 0;
const common_1 = require("@nestjs/common");
const core_1 = require("@nestjs/core");
const decorators_1 = require("./decorators");
const definitions_1 = require("./definitions");
let EventBusInitializer = class EventBusInitializer {
    discovery;
    scanner;
    reflector;
    module;
    defaultEventEmitter;
    logger = new common_1.Logger('EventBus');
    emitters;
    constructor(discovery, scanner, reflector, module, defaultEventEmitter) {
        this.discovery = discovery;
        this.scanner = scanner;
        this.reflector = reflector;
        this.module = module;
        this.defaultEventEmitter = defaultEventEmitter;
    }
    onApplicationBootstrap() {
        this.emitters = this.findEmitters();
        this.subscribeEventListeners();
    }
    onApplicationShutdown() { }
    getEmitters() {
        return this.emitters;
    }
    findEmitters() {
        const entry = (wrapper) => {
            const name = this.reflector.get(decorators_1.emitterKey, wrapper.metatype);
            if (name) {
                return [name, wrapper.instance];
            }
        };
        const entries = this.discovery
            .getProviders()
            .filter(wrapper => wrapper.metatype)
            .map(wrapper => entry(wrapper))
            .filter(entry => entry);
        const emitters = new Map(entries);
        if (!emitters.has('default')) {
            emitters.set('default', this.defaultEventEmitter);
        }
        return emitters;
    }
    subscribeEventListeners() {
        const providers = this.discovery.getProviders();
        const controllers = this.discovery.getControllers();
        const wrappers = [...providers, ...controllers];
        wrappers
            .filter(wrapper => wrapper.instance)
            .forEach((wrapper) => {
            const { instance } = wrapper;
            const prototype = Object.getPrototypeOf(instance) || {};
            this.scanner.getAllMethodNames(prototype).forEach(methodKey => {
                this.subscribeToEventIfListener(instance, methodKey, wrapper);
            });
        });
    }
    subscribeToEventIfListener(instance, method, wrapper) {
        const fun = instance[method];
        const opts = this.reflector.get(decorators_1.onKey, fun);
        if (opts === undefined || opts.event === undefined) {
            return undefined;
        }
        // the handler function that will be called when the event is emitted
        const handler = async (...args) => {
            // global instances we just call the method with the event arguments
            if (wrapper.isDependencyTreeStatic()) {
                return this.call(instance, method, opts.options, args);
            }
            // if the listener is request scoped, for each request we will get an instance and call the method
            // with the event arguments
            const resolved = await this.module.resolve(wrapper.token, undefined, { strict: false });
            return this.call(resolved, method, opts.options, args);
        };
        const from = this.reflector.get(decorators_1.fromKey, fun) ?? 'default';
        const emitter = this.emitters.get(from);
        // register the on event handler
        return emitter.on(opts.event, handler, opts.options);
    }
    async call(instance, method, opts, args) {
        try {
            return await instance[method].call(instance, ...args);
        }
        catch (error) {
            if (opts?.rethrow === true) {
                throw error;
            }
            this.logger.error(error, error.stack);
        }
    }
};
exports.EventBusInitializer = EventBusInitializer;
exports.EventBusInitializer = EventBusInitializer = __decorate([
    (0, common_1.Injectable)(),
    __metadata("design:paramtypes", [core_1.DiscoveryService,
        core_1.MetadataScanner,
        core_1.Reflector,
        core_1.ModuleRef,
        definitions_1.DefaultEventEmitter])
], EventBusInitializer);