@flusys/nestjs-shared 6.4.1 → 7.0.0-beta.1

package/fesm/decorators/index.js

@@ -1,5 +1,6 @@
 export * from './api-response.decorator';
 export * from './current-user.decorator';
 export * from './log-action.decorator';
+export * from './on-domain-event.decorator';
 export * from './public.decorator';
 export * from './require-permission.decorator';

package/fesm/decorators/on-domain-event.decorator.js

@@ -0,0 +1,10 @@
+import { SetMetadata } from '@nestjs/common';
+import { DOMAIN_EVENT_HANDLER_KEY } from '../constants';
+/**
+ * Marks a provider method as a domain event consumer.
+ *
+ * `*` matches one segment, `**` (or `#`) matches the rest:
+ *   `@OnDomainEvent('storage.folder.created')`
+ *   `@OnDomainEvent('auth.*.updated')`
+ *   `@OnDomainEvent('**')`
+ */ export const OnDomainEvent = (...patterns)=>SetMetadata(DOMAIN_EVENT_HANDLER_KEY, patterns);

package/fesm/decorators/on-domain-event.decorator.spec.js

@@ -0,0 +1,46 @@
+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);
+}
+import { DOMAIN_EVENT_HANDLER_KEY } from '../constants';
+import { OnDomainEvent } from './on-domain-event.decorator';
+let TestConsumer = class TestConsumer {
+    handleCreated() {}
+    handleDeleted() {}
+    handlePlain() {}
+};
+_ts_decorate([
+    OnDomainEvent('storage.folder.created'),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", void 0)
+], TestConsumer.prototype, "handleCreated", null);
+_ts_decorate([
+    OnDomainEvent('auth.*.deleted', 'iam.*.deleted'),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", void 0)
+], TestConsumer.prototype, "handleDeleted", null);
+describe('OnDomainEvent', ()=>{
+    it('should attach a single pattern as metadata', ()=>{
+        const patterns = Reflect.getMetadata(DOMAIN_EVENT_HANDLER_KEY, TestConsumer.prototype.handleCreated);
+        expect(patterns).toEqual([
+            'storage.folder.created'
+        ]);
+    });
+    it('should attach every pattern passed to the decorator', ()=>{
+        const patterns = Reflect.getMetadata(DOMAIN_EVENT_HANDLER_KEY, TestConsumer.prototype.handleDeleted);
+        expect(patterns).toEqual([
+            'auth.*.deleted',
+            'iam.*.deleted'
+        ]);
+    });
+    it('should leave undecorated methods without metadata', ()=>{
+        expect(Reflect.getMetadata(DOMAIN_EVENT_HANDLER_KEY, TestConsumer.prototype.handlePlain)).toBeUndefined();
+    });
+});

package/fesm/entities/user-root.js

@@ -20,7 +20,7 @@ function _ts_decorate(decorators, target, key, desc) {
 function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-import { getJsonColumnType } from '@flusys/nestjs-shared';
+import { getJsonColumnType } from '../classes/handle-custome-db';
 import { Column, CreateDateColumn, DeleteDateColumn, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
 export class UserRoot {
     constructor(){

package/fesm/enums/event-action.enum.js

@@ -0,0 +1,8 @@
+export var EventAction = /*#__PURE__*/ function(EventAction) {
+    EventAction["CREATED"] = "created";
+    EventAction["UPDATED"] = "updated";
+    EventAction["DELETED"] = "deleted";
+    EventAction["RESTORED"] = "restored";
+    EventAction["PURGED"] = "purged";
+    return EventAction;
+}({});

package/fesm/enums/index.js

@@ -1,3 +1,4 @@
+export * from './event-action.enum';
 export * from './notification-type.enum';
 export * from './participant-status.enum';
 export * from './recurrence-type.enum';

package/fesm/interfaces/event-bus.interface.js

@@ -0,0 +1 @@
+export { };

package/fesm/interfaces/index.js

@@ -1,6 +1,7 @@
 export * from './ai-assistant-adapter.interface';
 export * from './api.interface';
 export * from './datasource.interface';
+export * from './event-bus.interface';
 export * from './event-manager-adapter.interface';
 export * from './identity.interface';
 export * from './logged-user-info.interface';

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

@@ -0,0 +1,114 @@
+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);
+    };
+}
+import { Inject, Injectable, Logger, Optional } from '@nestjs/common';
+import { DiscoveryService, MetadataScanner } from '@nestjs/core';
+import { DOMAIN_EVENT_HANDLER_KEY, EVENT_BUS_INSTANCE } from '../../constants';
+export 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(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 Logger(EventBusExplorer.name);
+    }
+}
+EventBusExplorer = _ts_decorate([
+    Injectable(),
+    _ts_param(0, Optional()),
+    _ts_param(0, Inject(EVENT_BUS_INSTANCE)),
+    _ts_param(1, Inject(DiscoveryService)),
+    _ts_param(2, Inject(MetadataScanner)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Object,
+        typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
+        typeof MetadataScanner === "undefined" ? Object : MetadataScanner
+    ])
+], EventBusExplorer);

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

@@ -0,0 +1,185 @@
+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);
+}
+import { Logger } from '@nestjs/common';
+import { MetadataScanner } from '@nestjs/core';
+import { OnDomainEvent } from '../../decorators/on-domain-event.decorator';
+import { EventBusExplorer } from './event-bus.explorer';
+let Consumer = class Consumer {
+    onCreated(event) {
+        this.received.push(event.name);
+    }
+    onAuthOrIam() {}
+    notAHandler() {}
+    constructor(){
+        _define_property(this, "received", []);
+    }
+};
+_ts_decorate([
+    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([
+    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(eventBus, discovery, new 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(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(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(undefined, discovery, new MetadataScanner());
+        await expect(explorer.onApplicationBootstrap()).resolves.toBeUndefined();
+        expect(discovery.getProviders).not.toHaveBeenCalled();
+    });
+});

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

@@ -0,0 +1,250 @@
+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);
+}
+import { Injectable, Module } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { publishDomainEvent } from '../../classes/domain-event.publisher';
+import { EventBusRegistry } from '../../classes/event-bus.registry';
+import { EVENT_BUS_INSTANCE } from '../../constants';
+import { OnDomainEvent } from '../../decorators/on-domain-event.decorator';
+import { EventAction } from '../../enums/event-action.enum';
+import { DomainEvent } from '../../interfaces';
+import { EventBusModule } from './event-bus.module';
+import { createModuleEventsProvider } from './module-events.provider';
+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([
+    OnDomainEvent('**'),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof DomainEvent === "undefined" ? Object : DomainEvent
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], AuditConsumer.prototype, "onAny", null);
+_ts_decorate([
+    OnDomainEvent('storage.file_manager.uploaded'),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof DomainEvent === "undefined" ? Object : DomainEvent
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], AuditConsumer.prototype, "onUploaded", null);
+_ts_decorate([
+    OnDomainEvent('storage.*.created', 'auth.*.created'),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof DomainEvent === "undefined" ? Object : DomainEvent
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], AuditConsumer.prototype, "onCreated", null);
+AuditConsumer = _ts_decorate([
+    Injectable()
+], AuditConsumer);
+function buildStorageModule(events) {
+    let FakeStorageModule = class FakeStorageModule {
+    };
+    FakeStorageModule = _ts_decorate([
+        Module({
+            providers: [
+                {
+                    provide: STORAGE_MODULE_OPTIONS,
+                    useValue: {
+                        config: {
+                            events
+                        }
+                    }
+                },
+                createModuleEventsProvider('storage', STORAGE_MODULE_OPTIONS)
+            ]
+        })
+    ], FakeStorageModule);
+    return FakeStorageModule;
+}
+async function bootstrap(events) {
+    const app = await Test.createTestingModule({
+        imports: [
+            EventBusModule.forRoot({
+                transport: 'memory'
+            }),
+            buildStorageModule(events)
+        ],
+        providers: [
+            AuditConsumer
+        ]
+    }).compile();
+    await app.init();
+    return {
+        app,
+        consumer: app.get(AuditConsumer),
+        bus: app.get(EVENT_BUS_INSTANCE)
+    };
+}
+describe('EventBusModule (integration)', ()=>{
+    let app;
+    afterEach(async ()=>{
+        await app?.close();
+        app = undefined;
+        EventBusRegistry.reset();
+    });
+    it('delivers a published event to every matching decorated handler', async ()=>{
+        const started = await bootstrap({
+            enabled: true
+        });
+        app = started.app;
+        await 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 publishDomainEvent({
+            module: 'storage',
+            entity: 'folder',
+            action: 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 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.getModuleConfig('storage')).toEqual({
+            enabled: true,
+            includePayload: false
+        });
+        expect(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 publishDomainEvent({
+            module: 'billing',
+            entity: 'invoice',
+            action: 'settled'
+        });
+        expect(received).toEqual([]);
+        EventBusRegistry.configureModule('billing', {
+            enabled: true
+        });
+        await 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.getBus()).toBeUndefined();
+    });
+    it('boots an app that never registers EventBusModule and publishes nothing', async ()=>{
+        app = await Test.createTestingModule({
+            imports: [
+                buildStorageModule({
+                    enabled: true
+                })
+            ],
+            providers: [
+                AuditConsumer
+            ]
+        }).compile();
+        await app.init();
+        const consumer = app.get(AuditConsumer);
+        await publishDomainEvent({
+            module: 'storage',
+            entity: 'file_manager',
+            action: 'uploaded',
+            ids: [
+                'key-1'
+            ]
+        });
+        expect(EventBusRegistry.getBus()).toBeUndefined();
+        expect(consumer.everything).toEqual([]);
+    });
+});