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

package/cjs/classes/api-service.class.spec.js

@@ -7,7 +7,6 @@ const _repositorymock = require("@test-utils/mocks/repository.mock");
 const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
 const _apiserviceclass = require("./api-service.class");
 const _eventbusregistry = require("./event-bus.registry");
-const _eventactionenum = require("../enums/event-action.enum");
 const _utilsservice = require("../modules/utils/utils.service");
 const _entities = require("../entities");
 function _define_property(obj, key, value) {
@@ -29,6 +28,14 @@ let TestEntity = class TestEntity extends _entities.Identity {
     }
 };
 let TestApiService = class TestApiService extends _apiserviceclass.ApiService {
+    /** `publishDomainAction` is protected - feature services reach it as subclasses do */ publishAction(action, metadata) {
+        return this.publishDomainAction(action, {
+            ids: [
+                '1'
+            ],
+            metadata
+        });
+    }
 };
 function createMockQueryRunner() {
     return {
@@ -56,7 +63,7 @@ describe('ApiService', ()=>{
     let errorLogSpy;
     function makeService(isCacheable = false) {
         const dataSourceProvider = (0, _repositorymock.createMockDataSourceProvider)(mockRepo);
-        return new TestApiService('test-entity', mockCache, utilsService, 'TestApiService', isCacheable, undefined, TestEntity, dataSourceProvider);
+        return new TestApiService('test-entity', mockCache, utilsService, 'TestApiService', isCacheable, 'app', dataSourceProvider, TestEntity);
     }
     beforeEach(()=>{
         mockRepo = (0, _repositorymock.createMockRepository)();
@@ -645,7 +652,7 @@ describe('ApiService', ()=>{
             function makeRawService(dbType) {
                 mockRepo.manager.connection.options.type = dbType;
                 const dataSourceProvider = (0, _repositorymock.createMockDataSourceProvider)(mockRepo);
-                return new RawTestApiService('test-entity', mockCache, utilsService, 'RawTestApiService', false, undefined, TestEntity, dataSourceProvider);
+                return new RawTestApiService('test-entity', mockCache, utilsService, 'RawTestApiService', false, 'app', dataSourceProvider, TestEntity);
             }
             function primeRawQueryBuilder(qb) {
                 qb.expressionMap = {
@@ -812,7 +819,7 @@ describe('ApiService', ()=>{
         let publish;
         function makeEventService(moduleName = 'test-module') {
             const dataSourceProvider = (0, _repositorymock.createMockDataSourceProvider)(mockRepo);
-            return new TestApiService('test-entity', mockCache, utilsService, 'TestApiService', false, moduleName, TestEntity, dataSourceProvider);
+            return new TestApiService('test-entity', mockCache, utilsService, 'TestApiService', false, moduleName, dataSourceProvider, TestEntity);
         }
         beforeEach(()=>{
             publish = jest.fn().mockResolvedValue(undefined);
@@ -843,7 +850,7 @@ describe('ApiService', ()=>{
                 name: 'test-module.test-entity.created',
                 module: 'test-module',
                 entity: 'test-entity',
-                action: _eventactionenum.EventAction.CREATED,
+                action: 'created',
                 payload: expect.objectContaining({
                     ids: [
                         'new-1'
@@ -864,6 +871,74 @@ describe('ApiService', ()=>{
                 userId: mockUser.id
             }));
         });
+        it('should publish one created event carrying every id for insertMany', async ()=>{
+            const service = makeEventService();
+            mockQueryRunner.manager.save.mockResolvedValue([
+                {
+                    id: 'new-1',
+                    name: 'A'
+                },
+                {
+                    id: 'new-2',
+                    name: 'B'
+                }
+            ]);
+            await service.insertMany([
+                {
+                    name: 'A'
+                },
+                {
+                    name: 'B'
+                }
+            ], mockUser);
+            expect(publish).toHaveBeenCalledTimes(1);
+            expect(publish.mock.calls[0][0]).toEqual(expect.objectContaining({
+                action: 'created',
+                payload: expect.objectContaining({
+                    ids: [
+                        'new-1',
+                        'new-2'
+                    ]
+                })
+            }));
+        });
+        it('should publish one updated event carrying every id for updateMany', async ()=>{
+            const service = makeEventService();
+            mockRepo.findOne.mockResolvedValue({
+                id: '1',
+                name: 'Old'
+            });
+            mockQueryRunner.manager.save.mockResolvedValue([
+                {
+                    id: '1',
+                    name: 'A'
+                },
+                {
+                    id: '2',
+                    name: 'B'
+                }
+            ]);
+            await service.updateMany([
+                {
+                    id: '1',
+                    name: 'A'
+                },
+                {
+                    id: '2',
+                    name: 'B'
+                }
+            ], mockUser);
+            expect(publish).toHaveBeenCalledTimes(1);
+            expect(publish.mock.calls[0][0]).toEqual(expect.objectContaining({
+                action: 'updated',
+                payload: expect.objectContaining({
+                    ids: [
+                        '1',
+                        '2'
+                    ]
+                })
+            }));
+        });
         it('should publish an updated event after update commits', async ()=>{
             const service = makeEventService();
             mockRepo.findOne.mockResolvedValue({
@@ -879,7 +954,7 @@ describe('ApiService', ()=>{
                 name: 'New'
             }, mockUser);
             expect(publish.mock.calls[0][0]).toEqual(expect.objectContaining({
-                action: _eventactionenum.EventAction.UPDATED
+                action: 'updated'
             }));
         });
         it('should publish created and updated separately for a bulk upsert', async ()=>{
@@ -910,22 +985,22 @@ describe('ApiService', ()=>{
                 }
             ], mockUser);
             expect(publish.mock.calls.map(([event])=>event.action)).toEqual([
-                _eventactionenum.EventAction.CREATED,
-                _eventactionenum.EventAction.UPDATED
+                'created',
+                'updated'
             ]);
         });
         it.each([
             [
                 'delete',
-                _eventactionenum.EventAction.DELETED
+                'deleted'
             ],
             [
                 'restore',
-                _eventactionenum.EventAction.RESTORED
+                'restored'
             ],
             [
                 'permanent',
-                _eventactionenum.EventAction.PURGED
+                'purged'
             ]
         ])('should publish %s as the %s action', async (type, action)=>{
             const service = makeEventService();
@@ -949,6 +1024,39 @@ describe('ApiService', ()=>{
                 ]
             });
         });
+        it('should publish a domain action under this service module and entity', async ()=>{
+            const service = makeEventService();
+            await service.publishAction('submitted', {
+                formId: 'form-1'
+            });
+            expect(publish.mock.calls[0][0]).toEqual(expect.objectContaining({
+                name: 'test-module.test-entity.submitted',
+                module: 'test-module',
+                entity: 'test-entity',
+                action: 'submitted',
+                payload: {
+                    ids: [
+                        '1'
+                    ],
+                    metadata: {
+                        formId: 'form-1'
+                    }
+                }
+            }));
+        });
+        it('should hold a domain action to the same allowlist as the CRUD actions', async ()=>{
+            _eventbusregistry.EventBusRegistry.configureModule('test-module', {
+                enabled: true,
+                actions: [
+                    'test-entity.submitted'
+                ]
+            });
+            const service = makeEventService();
+            await service.publishAction('submitted');
+            await service.publishAction('draft-saved');
+            expect(publish).toHaveBeenCalledTimes(1);
+            expect(publish.mock.calls[0][0].action).toBe('submitted');
+        });
         it('should not publish when the module has events disabled', async ()=>{
             _eventbusregistry.EventBusRegistry.configureModule('test-module', {
                 enabled: false
@@ -967,7 +1075,7 @@ describe('ApiService', ()=>{
             _eventbusregistry.EventBusRegistry.configureModule('test-module', {
                 enabled: true,
                 actions: [
-                    _eventactionenum.EventAction.DELETED
+                    'deleted'
                 ]
             });
             const service = makeEventService();

package/cjs/classes/event-bus.registry.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "EventBusRegistry", {
         return EventBusRegistry;
     }
 });
+const _eventpatternutil = require("../utils/event-pattern.util");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -48,12 +49,10 @@ let EventBusRegistry = class EventBusRegistry {
    */ static isEnabled(moduleName, entity, action) {
         const config = this.getModuleConfig(moduleName);
         if (!config.enabled) return false;
-        if (config.excludeEntities?.includes(entity)) return false;
-        if (config.entities?.length && !config.entities.includes(entity)) return false;
         // Without an explicit allowlist, CRUD lifecycle actions and every domain
         // action a package defines are all published.
         if (!config.actions?.length) return true;
-        return config.actions.includes(action);
+        return config.actions.some((entry)=>entry.includes('.') ? (0, _eventpatternutil.matchEventPattern)(entry, `${entity}.${action}`) : (0, _eventpatternutil.matchEventPattern)(entry, action));
     }
     static shouldIncludePayload(moduleName) {
         return this.getModuleConfig(moduleName).includePayload ?? true;

package/cjs/classes/event-bus.registry.spec.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _eventactionenum = require("../enums/event-action.enum");
 const _eventbusregistry = require("./event-bus.registry");
 const bus = {
     publish: jest.fn(),
@@ -26,39 +25,39 @@ describe('EventBusRegistry', ()=>{
             enabled: true
         });
         expect(_eventbusregistry.EventBusRegistry.getBus()).toBeUndefined();
-        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'folder', _eventactionenum.EventAction.CREATED)).toBe(true);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'folder', 'created')).toBe(true);
     });
     it('should report disabled for a module that never registered a config', ()=>{
-        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'folder', _eventactionenum.EventAction.CREATED)).toBe(false);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'folder', 'created')).toBe(false);
     });
     it('should enable every action of an enabled module by default', ()=>{
         _eventbusregistry.EventBusRegistry.configureModule('storage', {
             enabled: true
         });
-        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'folder', _eventactionenum.EventAction.CREATED)).toBe(true);
-        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'folder', _eventactionenum.EventAction.DELETED)).toBe(true);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'folder', 'created')).toBe(true);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'folder', 'deleted')).toBe(true);
     });
     it('should honour an action allowlist', ()=>{
         _eventbusregistry.EventBusRegistry.configureModule('storage', {
             enabled: true,
             actions: [
-                _eventactionenum.EventAction.CREATED
+                'created'
             ]
         });
-        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'folder', _eventactionenum.EventAction.CREATED)).toBe(true);
-        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'folder', _eventactionenum.EventAction.UPDATED)).toBe(false);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'folder', 'created')).toBe(true);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'folder', 'updated')).toBe(false);
     });
     it('should honour an allowlist that mixes CRUD lifecycle and domain actions', ()=>{
         _eventbusregistry.EventBusRegistry.configureModule('auth', {
             enabled: true,
             actions: [
-                _eventactionenum.EventAction.CREATED,
+                'created',
                 'logged-in'
             ]
         });
-        expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'appuser', _eventactionenum.EventAction.CREATED)).toBe(true);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'appuser', 'created')).toBe(true);
         expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'session', 'logged-in')).toBe(true);
-        expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'appuser', _eventactionenum.EventAction.UPDATED)).toBe(false);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'appuser', 'updated')).toBe(false);
         expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'session', 'logged-out')).toBe(false);
     });
     it('should silence CRUD when the allowlist names only domain actions', ()=>{
@@ -69,28 +68,54 @@ describe('EventBusRegistry', ()=>{
             ]
         });
         expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'session', 'logged-in')).toBe(true);
-        expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'appuser', _eventactionenum.EventAction.CREATED)).toBe(false);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'appuser', 'created')).toBe(false);
     });
-    it('should honour an entity allowlist and exclusion list', ()=>{
-        _eventbusregistry.EventBusRegistry.configureModule('storage', {
+    it('should scope an action to one entity when the entry names it', ()=>{
+        _eventbusregistry.EventBusRegistry.configureModule('iam', {
+            enabled: true,
+            actions: [
+                'created',
+                'role.updated'
+            ]
+        });
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('iam', 'role', 'updated')).toBe(true);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('iam', 'action', 'updated')).toBe(false);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('iam', 'action', 'created')).toBe(true);
+    });
+    it('should treat a scoped entry as a routing pattern', ()=>{
+        _eventbusregistry.EventBusRegistry.configureModule('iam', {
             enabled: true,
-            entities: [
-                'folder',
-                'file_manager'
-            ],
-            excludeEntities: [
-                'file_manager'
+            actions: [
+                'role.*',
+                '*.purged'
             ]
         });
-        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'folder', _eventactionenum.EventAction.CREATED)).toBe(true);
-        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'file_manager', _eventactionenum.EventAction.CREATED)).toBe(false);
-        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'storageConfig', _eventactionenum.EventAction.CREATED)).toBe(false);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('iam', 'role', 'updated')).toBe(true);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('iam', 'role', 'permissions-assigned')).toBe(true);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('iam', 'action', 'purged')).toBe(true);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('iam', 'action', 'updated')).toBe(false);
+    });
+    it('should publish only the entity and action pairs an app lists', ()=>{
+        _eventbusregistry.EventBusRegistry.configureModule('auth', {
+            enabled: true,
+            actions: [
+                'company.created',
+                'company.updated',
+                'session.logged-in'
+            ]
+        });
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'company', 'created')).toBe(true);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'company', 'updated')).toBe(true);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'company', 'purged')).toBe(false);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'appuser', 'created')).toBe(false);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'session', 'logged-in')).toBe(true);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'session', 'logged-out')).toBe(false);
     });
     it('should fall back to the default config for unregistered modules', ()=>{
         _eventbusregistry.EventBusRegistry.setDefaultModuleEvents({
             enabled: true
         });
-        expect(_eventbusregistry.EventBusRegistry.isEnabled('unknown-module', 'thing', _eventactionenum.EventAction.CREATED)).toBe(true);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('unknown-module', 'thing', 'created')).toBe(true);
     });
     it('should include the payload unless a module opts out', ()=>{
         _eventbusregistry.EventBusRegistry.configureModule('storage', {

package/cjs/classes/event-transports/kafka-transport.optional.spec.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 const _common = require("@nestjs/common");
-const _eventactionenum = require("../../enums/event-action.enum");
 const _kafkatransportoptional = require("./kafka-transport.optional");
 const mockLoadOptionalModule = jest.fn();
 jest.mock('../../utils/optional-module.util', ()=>({
@@ -15,7 +14,7 @@ function buildEvent() {
         name: 'storage.folder.created',
         module: 'storage',
         entity: 'folder',
-        action: _eventactionenum.EventAction.CREATED,
+        action: 'created',
         payload: {
             ids: [
                 '1'

package/cjs/classes/event-transports/memory-transport.js

@@ -9,7 +9,6 @@ Object.defineProperty(exports, "MemoryTransport", {
     }
 });
 const _events = require("events");
-const _eventtransportregistry = require("./event-transport.registry");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -24,6 +23,7 @@ function _define_property(obj, key, value) {
     return obj;
 }
 const CHANNEL = 'domain-event';
+const MAX_LISTENERS = 100;
 let MemoryTransport = class MemoryTransport {
     async connect() {
         this.ready = true;
@@ -44,11 +44,10 @@ let MemoryTransport = class MemoryTransport {
     isReady() {
         return this.ready;
     }
-    constructor(maxListeners = 100){
+    constructor(){
         _define_property(this, "name", 'memory');
         _define_property(this, "emitter", new _events.EventEmitter());
         _define_property(this, "ready", false);
-        this.emitter.setMaxListeners(maxListeners);
+        this.emitter.setMaxListeners(MAX_LISTENERS);
     }
 };
-_eventtransportregistry.EventTransportRegistry.register('memory', (config)=>new MemoryTransport(config['maxListeners']));

package/cjs/classes/event-transports/memory-transport.spec.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _eventactionenum = require("../../enums/event-action.enum");
 const _memorytransport = require("./memory-transport");
 function buildEvent(name = 'storage.folder.created') {
     return {
@@ -10,7 +9,7 @@ function buildEvent(name = 'storage.folder.created') {
         name,
         module: 'storage',
         entity: 'folder',
-        action: _eventactionenum.EventAction.CREATED,
+        action: 'created',
         payload: {
             ids: [
                 '1'

package/cjs/classes/event-transports/rabbitmq-transport.optional.spec.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 const _common = require("@nestjs/common");
-const _eventactionenum = require("../../enums/event-action.enum");
 const _rabbitmqtransportoptional = require("./rabbitmq-transport.optional");
 const mockLoadOptionalModule = jest.fn();
 jest.mock('../../utils/optional-module.util', ()=>({
@@ -15,7 +14,7 @@ function buildEvent() {
         name: 'storage.folder.created',
         module: 'storage',
         entity: 'folder',
-        action: _eventactionenum.EventAction.CREATED,
+        action: 'created',
         payload: {
             ids: [
                 '1'

package/cjs/classes/hybrid-event-bus.class.js

@@ -99,14 +99,13 @@ let HybridEventBus = class HybridEventBus {
             handler: handler
         });
         if (!await this.ensureConnected()) return;
-        await Promise.all(this.transports.map((transport)=>transport.bind(pattern).catch((error)=>{
-                this.logger.warn(`Bind failed on ${transport.name}: ${error.message}`);
-            })));
+        await this.bindSubscriptions();
     }
     async close() {
         await Promise.allSettled(this.transports.map((transport)=>transport.close()));
         this.transports.length = 0;
         this.subscriptions.length = 0;
+        this.boundPatterns.clear();
         this.seenIds.clear();
         this.seenOrder.length = 0;
         this.memory = undefined;
@@ -132,6 +131,8 @@ let HybridEventBus = class HybridEventBus {
         return value;
     }
     async buildTransports() {
+        // Fresh transports know nothing of what was bound on the ones they replace
+        this.boundPatterns.clear();
         if (this.label === 'memory' || this.label === 'hybrid') {
             this.memory = new _memorytransport.MemoryTransport();
             await this.memory.connect();
@@ -150,6 +151,23 @@ let HybridEventBus = class HybridEventBus {
                 }
             }
         }
+        await this.bindSubscriptions();
+    }
+    /**
+   * Binds every pattern the bus knows about, skipping the ones already bound.
+   *
+   * Called once the transports are built, not only from `subscribe`: a
+   * subscription taken while the bus was down returns before any transport
+   * exists, so nothing would ever bind its routing key on the broker that
+   * finally comes up, leaving the process publishing but never consuming.
+   */ async bindSubscriptions() {
+        for (const { pattern } of this.subscriptions){
+            if (this.boundPatterns.has(pattern)) continue;
+            this.boundPatterns.add(pattern);
+            await Promise.all(this.transports.map((transport)=>transport.bind(pattern).catch((error)=>{
+                    this.logger.warn(`Bind failed on ${transport.name}: ${error.message}`);
+                })));
+        }
     }
     async createBrokerTransport(label) {
         const name = label === 'hybrid' ? this.resolveHybridBrokerName() : label;
@@ -241,6 +259,7 @@ let HybridEventBus = class HybridEventBus {
         _define_property(this, "logger", void 0);
         _define_property(this, "subscriptions", void 0);
         _define_property(this, "transports", void 0);
+        _define_property(this, "boundPatterns", void 0);
         _define_property(this, "seenIds", void 0);
         _define_property(this, "seenOrder", void 0);
         _define_property(this, "label", void 0);
@@ -252,6 +271,7 @@ let HybridEventBus = class HybridEventBus {
         this.logger = new _common.Logger(HybridEventBus.name);
         this.subscriptions = [];
         this.transports = [];
+        this.boundPatterns = new Set();
         this.seenIds = new Set();
         this.seenOrder = [];
         this.connected = false;

package/cjs/classes/hybrid-event-bus.class.spec.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _eventactionenum = require("../enums/event-action.enum");
 const _eventtransportregistry = require("./event-transports/event-transport.registry");
 const _memorytransport = require("./event-transports/memory-transport");
 const _hybrideventbusclass = require("./hybrid-event-bus.class");
@@ -12,7 +11,7 @@ function buildEvent(name = 'storage.folder.created', id = 'event-1') {
         name,
         module: 'storage',
         entity: 'folder',
-        action: _eventactionenum.EventAction.CREATED,
+        action: 'created',
         payload: {
             ids: [
                 '1'
@@ -178,6 +177,36 @@ describe('HybridEventBus', ()=>{
         expect(handler).toHaveBeenCalledTimes(1);
         await bus.close();
     });
+    it('should bind a subscription taken while disconnected on the broker that comes up later', async ()=>{
+        const broker = createFakeTransport('rabbitmq');
+        _eventtransportregistry.EventTransportRegistry.register('rabbitmq', ()=>broker);
+        const connectSpy = jest.spyOn(_memorytransport.MemoryTransport.prototype, 'connect').mockRejectedValueOnce(new Error('boot failure'));
+        const bus = new _hybrideventbusclass.HybridEventBus({
+            transport: 'hybrid'
+        });
+        await bus.subscribe('storage.#', jest.fn());
+        expect(broker.bind).not.toHaveBeenCalled();
+        connectSpy.mockRestore();
+        // Anything that reconnects must bind what is already subscribed, or the
+        // queue stays unbound and this process publishes without ever consuming
+        await bus.publish(buildEvent());
+        expect(broker.bind).toHaveBeenCalledWith('storage.#');
+        await bus.close();
+    });
+    it('should bind each pattern once, not again on every later subscribe', async ()=>{
+        const broker = createFakeTransport('rabbitmq');
+        _eventtransportregistry.EventTransportRegistry.register('rabbitmq', ()=>broker);
+        const bus = new _hybrideventbusclass.HybridEventBus({
+            transport: 'rabbitmq'
+        });
+        await bus.subscribe('storage.#', jest.fn());
+        await bus.subscribe('auth.#', jest.fn());
+        expect(broker.bind.mock.calls.map(([pattern])=>pattern)).toEqual([
+            'storage.#',
+            'auth.#'
+        ]);
+        await bus.close();
+    });
     it('should forget its transports after close', async ()=>{
         const bus = new _hybrideventbusclass.HybridEventBus({
             transport: 'memory'

package/cjs/enums/index.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-_export_star(require("./event-action.enum"), exports);
 _export_star(require("./notification-type.enum"), exports);
 _export_star(require("./participant-status.enum"), exports);
 _export_star(require("./recurrence-type.enum"), exports);

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

@@ -8,7 +8,6 @@ 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");
@@ -156,7 +155,7 @@ describe('EventBusModule (integration)', ()=>{
         await (0, _domaineventpublisher.publishDomainEvent)({
             module: 'storage',
             entity: 'folder',
-            action: _eventactionenum.EventAction.CREATED,
+            action: 'created',
             ids: [
                 'folder-1'
             ]

package/cjs/utils/event-pattern.util.js

@@ -37,9 +37,14 @@ const SENSITIVE_KEYS = [
 /**
  * Matched whole, not as a substring - `pass` must be redacted without also
  * redacting `bypassCache`, and a storage row's `key` is a path, not a secret.
+ *
+ * `config` is the provider settings blob on the storage and email config rows:
+ * S3, Azure, SFTP and SMTP credentials live in it, so it never leaves the
+ * process, even though the row itself still publishes.
  */ const SENSITIVE_EXACT_KEYS = [
     'pass',
-    'pwd'
+    'pwd',
+    'config'
 ];
 const REDACTED = '[REDACTED]';
 const CIRCULAR = '[CIRCULAR]';

package/cjs/utils/event-pattern.util.spec.js

@@ -61,10 +61,28 @@ describe('sanitizeEventPayload', ()=>{
             apiKey: '[REDACTED]'
         });
     });
-    it('should redact the credential keys used by the storage and email providers', ()=>{
+    it('should redact the whole provider settings blob of a storage or email config row', ()=>{
         const result = (0, _eventpatternutil.sanitizeEventPayload)({
             name: 'primary-s3',
+            provider: 's3',
+            isActive: true,
             config: {
+                region: 'us-east-1',
+                bucket: 'assets',
+                accessKeyId: 'AKIA...',
+                secretAccessKey: 's3cr3t'
+            }
+        });
+        expect(result).toEqual({
+            name: 'primary-s3',
+            provider: 's3',
+            isActive: true,
+            config: '[REDACTED]'
+        });
+    });
+    it('should redact the credential keys used by the storage and email providers', ()=>{
+        const result = (0, _eventpatternutil.sanitizeEventPayload)({
+            settings: {
                 region: 'us-east-1',
                 bucket: 'assets',
                 accessKeyId: 'AKIA...',
@@ -79,8 +97,7 @@ describe('sanitizeEventPayload', ()=>{
             }
         });
         expect(result).toEqual({
-            name: 'primary-s3',
-            config: {
+            settings: {
                 region: 'us-east-1',
                 bucket: 'assets',
                 accessKeyId: '[REDACTED]',