@flusys/nestjs-shared 6.4.1 → 7.0.0

package/cjs/modules/event-bus/event-bus.explorer.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EventBusExplorer", {
+    enumerable: true,
+    get: function() {
+        return EventBusExplorer;
+    }
+});
+const _common = require("@nestjs/common");
+const _core = require("@nestjs/core");
+const _constants = require("../../constants");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_decorate(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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+let EventBusExplorer = class EventBusExplorer {
+    async onApplicationBootstrap() {
+        const bus = this.eventBus;
+        if (!bus) return;
+        const wrappers = [
+            ...this.discovery.getProviders(),
+            ...this.discovery.getControllers()
+        ];
+        // The same provider is returned once per module that registers it; binding
+        // it twice would run every handler twice for a single event.
+        const seen = new Set();
+        let bound = 0;
+        for (const wrapper of wrappers){
+            const instance = wrapper.instance;
+            if (!instance || typeof instance !== 'object' || wrapper.isNotMetatype) {
+                this.warnIfUnreachableConsumer(wrapper);
+                continue;
+            }
+            if (seen.has(instance)) continue;
+            seen.add(instance);
+            bound += await this.bindInstance(instance, bus);
+        }
+        if (bound) {
+            const active = bus.getActiveTransports();
+            this.logger.log(`Bound ${bound} domain event handler(s); transport '${bus.getTransportLabel()}' ` + `live over ${active.length ? active.join(', ') : 'no transport'}`);
+        }
+    }
+    async bindInstance(instance, bus) {
+        const prototype = Object.getPrototypeOf(instance);
+        if (!prototype) return 0;
+        let bound = 0;
+        for (const methodName of this.metadataScanner.getAllMethodNames(prototype)){
+            const method = instance[methodName];
+            const patterns = this.readPatterns(method);
+            if (!patterns.length) continue;
+            const handler = method;
+            for (const pattern of patterns){
+                await bus.subscribe(pattern, (event)=>handler.call(instance, event));
+                bound++;
+            }
+        }
+        return bound;
+    }
+    /**
+   * A request scoped provider has no singleton instance to bind, so its
+   * handlers would never run - that must not fail silently.
+   */ warnIfUnreachableConsumer(wrapper) {
+        const prototype = wrapper.metatype?.prototype;
+        if (wrapper.instance || !prototype) return;
+        const hasHandler = this.metadataScanner.getAllMethodNames(prototype).some((methodName)=>this.readPatterns(prototype[methodName]).length > 0);
+        if (hasHandler) {
+            this.logger.warn(`${wrapper.name} declares @OnDomainEvent methods but has no singleton instance ` + `(request scoped providers cannot consume events) - move the handler to a default scoped provider`);
+        }
+    }
+    readPatterns(method) {
+        if (typeof method !== 'function') return [];
+        return Reflect.getMetadata(_constants.DOMAIN_EVENT_HANDLER_KEY, method) ?? [];
+    }
+    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
+    // @Optional() so nothing here is a hard dependency on EventBusModule being registered
+    constructor(eventBus, discovery, metadataScanner){
+        _define_property(this, "eventBus", void 0);
+        _define_property(this, "discovery", void 0);
+        _define_property(this, "metadataScanner", void 0);
+        _define_property(this, "logger", void 0);
+        this.eventBus = eventBus;
+        this.discovery = discovery;
+        this.metadataScanner = metadataScanner;
+        this.logger = new _common.Logger(EventBusExplorer.name);
+    }
+};
+EventBusExplorer = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_param(0, (0, _common.Optional)()),
+    _ts_param(0, (0, _common.Inject)(_constants.EVENT_BUS_INSTANCE)),
+    _ts_param(1, (0, _common.Inject)(_core.DiscoveryService)),
+    _ts_param(2, (0, _common.Inject)(_core.MetadataScanner)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Object,
+        typeof _core.DiscoveryService === "undefined" ? Object : _core.DiscoveryService,
+        typeof _core.MetadataScanner === "undefined" ? Object : _core.MetadataScanner
+    ])
+], EventBusExplorer);

package/cjs/modules/event-bus/event-bus.explorer.spec.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _common = require("@nestjs/common");
+const _core = require("@nestjs/core");
+const _ondomaineventdecorator = require("../../decorators/on-domain-event.decorator");
+const _eventbusexplorer = require("./event-bus.explorer");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_decorate(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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+let Consumer = class Consumer {
+    onCreated(event) {
+        this.received.push(event.name);
+    }
+    onAuthOrIam() {}
+    notAHandler() {}
+    constructor(){
+        _define_property(this, "received", []);
+    }
+};
+_ts_decorate([
+    (0, _ondomaineventdecorator.OnDomainEvent)('storage.*.created'),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Object
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], Consumer.prototype, "onCreated", null);
+_ts_decorate([
+    (0, _ondomaineventdecorator.OnDomainEvent)('auth.#', 'iam.#'),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", void 0)
+], Consumer.prototype, "onAuthOrIam", null);
+function createExplorer(wrappers) {
+    const eventBus = {
+        subscribe: jest.fn().mockResolvedValue(undefined),
+        getTransportLabel: ()=>'memory',
+        getActiveTransports: ()=>[
+                'memory'
+            ]
+    };
+    const discovery = {
+        getProviders: ()=>wrappers.map((wrapper)=>wrapper && typeof wrapper === 'object' && 'instance' in wrapper ? wrapper : {
+                    instance: wrapper,
+                    isNotMetatype: false
+                }),
+        getControllers: ()=>[]
+    };
+    return {
+        eventBus,
+        explorer: new _eventbusexplorer.EventBusExplorer(eventBus, discovery, new _core.MetadataScanner())
+    };
+}
+describe('EventBusExplorer', ()=>{
+    it('should subscribe every decorated method with all of its patterns', async ()=>{
+        const { eventBus, explorer } = createExplorer([
+            new Consumer()
+        ]);
+        await explorer.onApplicationBootstrap();
+        expect(eventBus.subscribe).toHaveBeenCalledTimes(3);
+        expect(eventBus.subscribe.mock.calls.map(([pattern])=>pattern)).toEqual([
+            'storage.*.created',
+            'auth.#',
+            'iam.#'
+        ]);
+    });
+    it('should bind a handler that calls back into the owning instance', async ()=>{
+        const consumer = new Consumer();
+        const { eventBus, explorer } = createExplorer([
+            consumer
+        ]);
+        await explorer.onApplicationBootstrap();
+        const [, handler] = eventBus.subscribe.mock.calls[0];
+        handler({
+            name: 'storage.folder.created'
+        });
+        expect(consumer.received).toEqual([
+            'storage.folder.created'
+        ]);
+    });
+    it('should ignore providers without decorated methods', async ()=>{
+        const { eventBus, explorer } = createExplorer([
+            {
+                plain: ()=>undefined
+            }
+        ]);
+        await explorer.onApplicationBootstrap();
+        expect(eventBus.subscribe).not.toHaveBeenCalled();
+    });
+    it('should ignore null instances', async ()=>{
+        const { eventBus, explorer } = createExplorer([
+            null,
+            undefined
+        ]);
+        await explorer.onApplicationBootstrap();
+        expect(eventBus.subscribe).not.toHaveBeenCalled();
+    });
+    it('should bind an instance once even when several modules expose it', async ()=>{
+        const consumer = new Consumer();
+        const { eventBus, explorer } = createExplorer([
+            consumer,
+            consumer
+        ]);
+        await explorer.onApplicationBootstrap();
+        expect(eventBus.subscribe).toHaveBeenCalledTimes(3);
+    });
+    it('should deliver an event once to a provider shared by several modules', async ()=>{
+        const consumer = new Consumer();
+        const { eventBus, explorer } = createExplorer([
+            consumer,
+            consumer
+        ]);
+        await explorer.onApplicationBootstrap();
+        const handlers = eventBus.subscribe.mock.calls.filter(([pattern])=>pattern === 'storage.*.created').map(([, handler])=>handler);
+        handlers.forEach((handler)=>handler({
+                name: 'storage.folder.created'
+            }));
+        expect(consumer.received).toEqual([
+            'storage.folder.created'
+        ]);
+    });
+    it('should warn about a consumer that has no singleton instance to bind', async ()=>{
+        const warn = jest.spyOn(_common.Logger.prototype, 'warn').mockImplementation(()=>undefined);
+        const { eventBus, explorer } = createExplorer([
+            {
+                instance: undefined,
+                name: 'ScopedConsumer',
+                metatype: Consumer,
+                isNotMetatype: false
+            }
+        ]);
+        await explorer.onApplicationBootstrap();
+        expect(eventBus.subscribe).not.toHaveBeenCalled();
+        expect(warn).toHaveBeenCalledWith(expect.stringContaining('ScopedConsumer'));
+        warn.mockRestore();
+    });
+    it('should stay quiet about a scoped provider that declares no handler', async ()=>{
+        const warn = jest.spyOn(_common.Logger.prototype, 'warn').mockImplementation(()=>undefined);
+        let Plain = class Plain {
+            doWork() {}
+        };
+        const { explorer } = createExplorer([
+            {
+                instance: undefined,
+                name: 'Plain',
+                metatype: Plain,
+                isNotMetatype: false
+            }
+        ]);
+        await explorer.onApplicationBootstrap();
+        expect(warn).not.toHaveBeenCalled();
+        warn.mockRestore();
+    });
+    it('should do nothing when no event bus is provided', async ()=>{
+        const discovery = {
+            getProviders: jest.fn(()=>[
+                    {
+                        instance: new Consumer(),
+                        isNotMetatype: false
+                    }
+                ]),
+            getControllers: ()=>[]
+        };
+        const explorer = new _eventbusexplorer.EventBusExplorer(undefined, discovery, new _core.MetadataScanner());
+        await expect(explorer.onApplicationBootstrap()).resolves.toBeUndefined();
+        expect(discovery.getProviders).not.toHaveBeenCalled();
+    });
+});

package/cjs/modules/event-bus/event-bus.integration.spec.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _common = require("@nestjs/common");
+const _testing = require("@nestjs/testing");
+const _domaineventpublisher = require("../../classes/domain-event.publisher");
+const _eventbusregistry = require("../../classes/event-bus.registry");
+const _constants = require("../../constants");
+const _ondomaineventdecorator = require("../../decorators/on-domain-event.decorator");
+const _eventactionenum = require("../../enums/event-action.enum");
+const _interfaces = require("../../interfaces");
+const _eventbusmodule = require("./event-bus.module");
+const _moduleeventsprovider = require("./module-events.provider");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_decorate(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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+const STORAGE_MODULE_OPTIONS = 'STORAGE_MODULE_OPTIONS';
+let AuditConsumer = class AuditConsumer {
+    onAny(event) {
+        this.everything.push(event.name);
+    }
+    onUploaded(event) {
+        this.uploads.push(String(event.payload.metadata?.location));
+    }
+    onCreated(event) {
+        this.creates.push(event.name);
+    }
+    constructor(){
+        _define_property(this, "everything", []);
+        _define_property(this, "uploads", []);
+        _define_property(this, "creates", []);
+    }
+};
+_ts_decorate([
+    (0, _ondomaineventdecorator.OnDomainEvent)('**'),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _interfaces.DomainEvent === "undefined" ? Object : _interfaces.DomainEvent
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], AuditConsumer.prototype, "onAny", null);
+_ts_decorate([
+    (0, _ondomaineventdecorator.OnDomainEvent)('storage.file_manager.uploaded'),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _interfaces.DomainEvent === "undefined" ? Object : _interfaces.DomainEvent
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], AuditConsumer.prototype, "onUploaded", null);
+_ts_decorate([
+    (0, _ondomaineventdecorator.OnDomainEvent)('storage.*.created', 'auth.*.created'),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _interfaces.DomainEvent === "undefined" ? Object : _interfaces.DomainEvent
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], AuditConsumer.prototype, "onCreated", null);
+AuditConsumer = _ts_decorate([
+    (0, _common.Injectable)()
+], AuditConsumer);
+function buildStorageModule(events) {
+    let FakeStorageModule = class FakeStorageModule {
+    };
+    FakeStorageModule = _ts_decorate([
+        (0, _common.Module)({
+            providers: [
+                {
+                    provide: STORAGE_MODULE_OPTIONS,
+                    useValue: {
+                        config: {
+                            events
+                        }
+                    }
+                },
+                (0, _moduleeventsprovider.createModuleEventsProvider)('storage', STORAGE_MODULE_OPTIONS)
+            ]
+        })
+    ], FakeStorageModule);
+    return FakeStorageModule;
+}
+async function bootstrap(events) {
+    const app = await _testing.Test.createTestingModule({
+        imports: [
+            _eventbusmodule.EventBusModule.forRoot({
+                transport: 'memory'
+            }),
+            buildStorageModule(events)
+        ],
+        providers: [
+            AuditConsumer
+        ]
+    }).compile();
+    await app.init();
+    return {
+        app,
+        consumer: app.get(AuditConsumer),
+        bus: app.get(_constants.EVENT_BUS_INSTANCE)
+    };
+}
+describe('EventBusModule (integration)', ()=>{
+    let app;
+    afterEach(async ()=>{
+        await app?.close();
+        app = undefined;
+        _eventbusregistry.EventBusRegistry.reset();
+    });
+    it('delivers a published event to every matching decorated handler', async ()=>{
+        const started = await bootstrap({
+            enabled: true
+        });
+        app = started.app;
+        await (0, _domaineventpublisher.publishDomainEvent)({
+            module: 'storage',
+            entity: 'file_manager',
+            action: 'uploaded',
+            ids: [
+                'key-1'
+            ],
+            metadata: {
+                location: 'local'
+            }
+        });
+        expect(started.consumer.uploads).toEqual([
+            'local'
+        ]);
+        expect(started.consumer.everything).toEqual([
+            'storage.file_manager.uploaded'
+        ]);
+        expect(started.consumer.creates).toEqual([]);
+    });
+    it('routes a single segment wildcard to the right handler', async ()=>{
+        const started = await bootstrap({
+            enabled: true
+        });
+        app = started.app;
+        await (0, _domaineventpublisher.publishDomainEvent)({
+            module: 'storage',
+            entity: 'folder',
+            action: _eventactionenum.EventAction.CREATED,
+            ids: [
+                'folder-1'
+            ]
+        });
+        expect(started.consumer.creates).toEqual([
+            'storage.folder.created'
+        ]);
+        expect(started.consumer.uploads).toEqual([]);
+    });
+    it('publishes nothing when the feature module did not enable events', async ()=>{
+        const started = await bootstrap({
+            enabled: false
+        });
+        app = started.app;
+        await (0, _domaineventpublisher.publishDomainEvent)({
+            module: 'storage',
+            entity: 'file_manager',
+            action: 'uploaded',
+            ids: [
+                'key-1'
+            ]
+        });
+        expect(started.consumer.everything).toEqual([]);
+    });
+    it('registers the feature module config supplied through its own options', async ()=>{
+        const started = await bootstrap({
+            enabled: true,
+            includePayload: false
+        });
+        app = started.app;
+        expect(_eventbusregistry.EventBusRegistry.getModuleConfig('storage')).toEqual({
+            enabled: true,
+            includePayload: false
+        });
+        expect(_eventbusregistry.EventBusRegistry.shouldIncludePayload('storage')).toBe(false);
+    });
+    it('exposes the bus for direct publish and subscribe', async ()=>{
+        const started = await bootstrap({
+            enabled: true
+        });
+        app = started.app;
+        const received = [];
+        await started.bus.subscribe('billing.#', (event)=>{
+            received.push(event.name);
+        });
+        await (0, _domaineventpublisher.publishDomainEvent)({
+            module: 'billing',
+            entity: 'invoice',
+            action: 'settled'
+        });
+        expect(received).toEqual([]);
+        _eventbusregistry.EventBusRegistry.configureModule('billing', {
+            enabled: true
+        });
+        await (0, _domaineventpublisher.publishDomainEvent)({
+            module: 'billing',
+            entity: 'invoice',
+            action: 'settled'
+        });
+        expect(received).toEqual([
+            'billing.invoice.settled'
+        ]);
+    });
+    it('tears the bus down when the application shuts down', async ()=>{
+        const started = await bootstrap({
+            enabled: true
+        });
+        await started.app.close();
+        expect(_eventbusregistry.EventBusRegistry.getBus()).toBeUndefined();
+    });
+    it('boots an app that never registers EventBusModule and publishes nothing', async ()=>{
+        app = await _testing.Test.createTestingModule({
+            imports: [
+                buildStorageModule({
+                    enabled: true
+                })
+            ],
+            providers: [
+                AuditConsumer
+            ]
+        }).compile();
+        await app.init();
+        const consumer = app.get(AuditConsumer);
+        await (0, _domaineventpublisher.publishDomainEvent)({
+            module: 'storage',
+            entity: 'file_manager',
+            action: 'uploaded',
+            ids: [
+                'key-1'
+            ]
+        });
+        expect(_eventbusregistry.EventBusRegistry.getBus()).toBeUndefined();
+        expect(consumer.everything).toEqual([]);
+    });
+});

package/cjs/modules/event-bus/event-bus.module.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EventBusModule", {
+    enumerable: true,
+    get: function() {
+        return EventBusModule;
+    }
+});
+const _config = require("@flusys/nestjs-core/config");
+const _common = require("@nestjs/common");
+const _core = require("@nestjs/core");
+const _disabledeventbusclass = require("../../classes/disabled-event-bus.class");
+const _eventbusregistry = require("../../classes/event-bus.registry");
+const _hybrideventbusclass = require("../../classes/hybrid-event-bus.class");
+const _constants = require("../../constants");
+const _eventbusexplorer = require("./event-bus.explorer");
+function _ts_decorate(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;
+}
+let EventBusModule = class EventBusModule {
+    static forRoot(options = {}) {
+        const enabled = options.enabled ?? _config.envConfig.getBoolean('ENABLE_DOMAIN_EVENTS', false);
+        return enabled ? this.enabledModule(options) : this.disabledModule(options);
+    }
+    static enabledModule(options) {
+        return {
+            module: EventBusModule,
+            global: options.global ?? true,
+            imports: [
+                _core.DiscoveryModule
+            ],
+            providers: [
+                {
+                    provide: _constants.EVENT_BUS_MODULE_OPTIONS,
+                    useValue: options
+                },
+                {
+                    provide: _constants.EVENT_BUS_INSTANCE,
+                    useFactory: ()=>{
+                        const bus = new _hybrideventbusclass.HybridEventBus(options);
+                        _eventbusregistry.EventBusRegistry.setBus(bus);
+                        _eventbusregistry.EventBusRegistry.setDefaultModuleEvents(options.defaultModuleEvents ?? {});
+                        return bus;
+                    }
+                },
+                _eventbusexplorer.EventBusExplorer
+            ],
+            exports: [
+                _constants.EVENT_BUS_INSTANCE,
+                _constants.EVENT_BUS_MODULE_OPTIONS
+            ]
+        };
+    }
+    /**
+   * The explorer is left out, so no handler is bound and nothing ever calls
+   * `subscribe` - which is what would otherwise open a broker connection. The
+   * bus is not registered either, so every `publishDomainEvent` call is a no-op
+   * rather than an error.
+   */ static disabledModule(options) {
+        return {
+            module: EventBusModule,
+            global: options.global ?? true,
+            providers: [
+                {
+                    provide: _constants.EVENT_BUS_MODULE_OPTIONS,
+                    useValue: options
+                },
+                {
+                    provide: _constants.EVENT_BUS_INSTANCE,
+                    useFactory: ()=>{
+                        new _common.Logger(EventBusModule.name).log('Domain events are disabled - set ENABLE_DOMAIN_EVENTS=true to publish and consume them');
+                        return new _disabledeventbusclass.DisabledEventBus();
+                    }
+                }
+            ],
+            exports: [
+                _constants.EVENT_BUS_INSTANCE,
+                _constants.EVENT_BUS_MODULE_OPTIONS
+            ]
+        };
+    }
+    async onApplicationShutdown() {
+        await _eventbusregistry.EventBusRegistry.getBus()?.close();
+        _eventbusregistry.EventBusRegistry.reset();
+    }
+};
+EventBusModule = _ts_decorate([
+    (0, _common.Module)({})
+], EventBusModule);