@flusys/nestjs-shared 7.0.0 → 7.0.2

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

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

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

@@ -3,7 +3,6 @@ jest.mock('../../utils/optional-module.util', ()=>({
         loadOptionalModule: (...args)=>mockLoadOptionalModule(...args)
     }));
 import { InternalServerErrorException, Logger } from '@nestjs/common';
-import { EventAction } from '../../enums/event-action.enum';
 import { KafkaTransport } from './kafka-transport.optional';
 function buildEvent() {
     return {
@@ -11,7 +10,7 @@ function buildEvent() {
         name: 'storage.folder.created',
         module: 'storage',
         entity: 'folder',
-        action: EventAction.CREATED,
+        action: 'created',
         payload: {
             ids: [
                 '1'

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

@@ -12,10 +12,14 @@ function _define_property(obj, key, value) {
     return obj;
 }
 import { EventEmitter } from 'events';
-import { EventTransportRegistry } from './event-transport.registry';
 const CHANNEL = 'domain-event';
+const MAX_LISTENERS = 100;
 /**
  * In-process transport. Always available, needs no broker, and is the default.
+ *
+ * HybridEventBus constructs it directly rather than through
+ * EventTransportRegistry, which exists for the broker transports it must not
+ * depend on at build time.
  */ export class MemoryTransport {
     async connect() {
         this.ready = true;
@@ -36,11 +40,10 @@ const CHANNEL = 'domain-event';
     isReady() {
         return this.ready;
     }
-    constructor(maxListeners = 100){
+    constructor(){
         _define_property(this, "name", 'memory');
         _define_property(this, "emitter", new EventEmitter());
         _define_property(this, "ready", false);
-        this.emitter.setMaxListeners(maxListeners);
+        this.emitter.setMaxListeners(MAX_LISTENERS);
     }
 }
-EventTransportRegistry.register('memory', (config)=>new MemoryTransport(config['maxListeners']));

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

@@ -1,4 +1,3 @@
-import { EventAction } from '../../enums/event-action.enum';
 import { MemoryTransport } from './memory-transport';
 function buildEvent(name = 'storage.folder.created') {
     return {
@@ -6,7 +5,7 @@ function buildEvent(name = 'storage.folder.created') {
         name,
         module: 'storage',
         entity: 'folder',
-        action: EventAction.CREATED,
+        action: 'created',
         payload: {
             ids: [
                 '1'

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

@@ -3,7 +3,6 @@ jest.mock('../../utils/optional-module.util', ()=>({
         loadOptionalModule: (...args)=>mockLoadOptionalModule(...args)
     }));
 import { InternalServerErrorException, Logger } from '@nestjs/common';
-import { EventAction } from '../../enums/event-action.enum';
 import { RabbitMqTransport } from './rabbitmq-transport.optional';
 function buildEvent() {
     return {
@@ -11,7 +10,7 @@ function buildEvent() {
         name: 'storage.folder.created',
         module: 'storage',
         entity: 'folder',
-        action: EventAction.CREATED,
+        action: 'created',
         payload: {
             ids: [
                 '1'

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

@@ -55,14 +55,13 @@ const DEFAULT_DEDUPE_SIZE = 5000;
             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;
@@ -88,6 +87,8 @@ const DEFAULT_DEDUPE_SIZE = 5000;
         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();
             await this.memory.connect();
@@ -106,6 +107,23 @@ const DEFAULT_DEDUPE_SIZE = 5000;
                 }
             }
         }
+        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;
@@ -197,6 +215,7 @@ const DEFAULT_DEDUPE_SIZE = 5000;
         _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);
@@ -208,6 +227,7 @@ const DEFAULT_DEDUPE_SIZE = 5000;
         this.logger = new Logger(HybridEventBus.name);
         this.subscriptions = [];
         this.transports = [];
+        this.boundPatterns = new Set();
         this.seenIds = new Set();
         this.seenOrder = [];
         this.connected = false;

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

@@ -1,4 +1,3 @@
-import { EventAction } from '../enums/event-action.enum';
 import { EventTransportRegistry } from './event-transports/event-transport.registry';
 import { MemoryTransport } from './event-transports/memory-transport';
 import { HybridEventBus } from './hybrid-event-bus.class';
@@ -8,7 +7,7 @@ function buildEvent(name = 'storage.folder.created', id = 'event-1') {
         name,
         module: 'storage',
         entity: 'folder',
-        action: EventAction.CREATED,
+        action: 'created',
         payload: {
             ids: [
                 '1'
@@ -174,6 +173,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.register('rabbitmq', ()=>broker);
+        const connectSpy = jest.spyOn(MemoryTransport.prototype, 'connect').mockRejectedValueOnce(new Error('boot failure'));
+        const bus = new 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.register('rabbitmq', ()=>broker);
+        const bus = new 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 HybridEventBus({
             transport: 'memory'

package/fesm/enums/index.js

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

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

@@ -26,7 +26,6 @@ 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';
@@ -152,7 +151,7 @@ describe('EventBusModule (integration)', ()=>{
         await publishDomainEvent({
             module: 'storage',
             entity: 'folder',
-            action: EventAction.CREATED,
+            action: 'created',
             ids: [
                 'folder-1'
             ]

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

@@ -16,9 +16,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/fesm/utils/event-pattern.util.spec.js

@@ -57,10 +57,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 = 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 = sanitizeEventPayload({
+            settings: {
                 region: 'us-east-1',
                 bucket: 'assets',
                 accessKeyId: 'AKIA...',
@@ -75,8 +93,7 @@ describe('sanitizeEventPayload', ()=>{
             }
         });
         expect(result).toEqual({
-            name: 'primary-s3',
-            config: {
+            settings: {
                 region: 'us-east-1',
                 bucket: 'assets',
                 accessKeyId: '[REDACTED]',

package/interfaces/event-bus.interface.d.ts

@@ -1,6 +1,5 @@
-import { EventAction } from '../enums/event-action.enum';
 export type EventTransportLabel = 'memory' | 'rabbitmq' | 'kafka' | 'hybrid';
-export type DomainEventActionName = EventAction | string;
+export type CrudEventActionName = 'created' | 'updated' | 'deleted' | 'restored' | 'purged';
 export interface IDomainEventActor {
     userId?: string | null;
     companyId?: string | null;
@@ -17,7 +16,7 @@ export interface IDomainEvent<T = unknown> {
     name: string;
     module: string;
     entity: string;
-    action: DomainEventActionName;
+    action: string;
     payload: T;
     actor: IDomainEventActor;
     occurredAt: string;
@@ -41,10 +40,8 @@ export interface IEventBus {
 }
 export interface IModuleEventsConfig {
     enabled?: boolean;
-    actions?: DomainEventActionName[];
+    actions?: string[];
     includePayload?: boolean;
-    entities?: string[];
-    excludeEntities?: string[];
 }
 export interface IRabbitMqTransportConfig {
     url?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-shared",
-  "version": "7.0.0",
+  "version": "7.0.2",
   "description": "Common shared utilities for Flusys NestJS applications",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -112,6 +112,6 @@
     "rxjs": "^7.8.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "7.0.0"
+    "@flusys/nestjs-core": "7.0.2"
   }
 }

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

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "EventAction", {
-    enumerable: true,
-    get: function() {
-        return EventAction;
-    }
-});
-var EventAction = /*#__PURE__*/ function(EventAction) {
-    EventAction["CREATED"] = "created";
-    EventAction["UPDATED"] = "updated";
-    EventAction["DELETED"] = "deleted";
-    EventAction["RESTORED"] = "restored";
-    EventAction["PURGED"] = "purged";
-    return EventAction;
-}({});

package/enums/event-action.enum.d.ts

@@ -1,7 +0,0 @@
-export declare enum EventAction {
-    CREATED = "created",
-    UPDATED = "updated",
-    DELETED = "deleted",
-    RESTORED = "restored",
-    PURGED = "purged"
-}

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

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