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

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

@@ -0,0 +1,252 @@
+const mockLoadOptionalModule = jest.fn();
+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 {
+        id: 'event-1',
+        name: 'storage.folder.created',
+        module: 'storage',
+        entity: 'folder',
+        action: EventAction.CREATED,
+        payload: {
+            ids: [
+                '1'
+            ]
+        },
+        actor: {},
+        occurredAt: '2026-01-01T00:00:00.000Z',
+        version: 1
+    };
+}
+function createChannelMock() {
+    return {
+        assertExchange: jest.fn().mockResolvedValue(undefined),
+        assertQueue: jest.fn().mockResolvedValue(undefined),
+        prefetch: jest.fn().mockResolvedValue(undefined),
+        bindQueue: jest.fn().mockResolvedValue(undefined),
+        consume: jest.fn().mockResolvedValue(undefined),
+        publish: jest.fn(),
+        ack: jest.fn(),
+        nack: jest.fn(),
+        on: jest.fn(),
+        removeAllListeners: jest.fn(),
+        close: jest.fn().mockResolvedValue(undefined)
+    };
+}
+/** A reconnect must land on a fresh channel, so every createChannel yields one */ function createAmqpMock() {
+    const channels = [];
+    const connection = {
+        createChannel: jest.fn(async ()=>{
+            const channel = createChannelMock();
+            channels.push(channel);
+            return channel;
+        }),
+        on: jest.fn(),
+        removeAllListeners: jest.fn(),
+        close: jest.fn().mockResolvedValue(undefined)
+    };
+    return {
+        channels,
+        connection,
+        connect: jest.fn().mockResolvedValue(connection),
+        get channel () {
+            return channels[channels.length - 1];
+        }
+    };
+}
+function listenerFor(target, event) {
+    const registered = target.on.mock.calls.find(([name])=>name === event);
+    if (!registered) throw new Error(`No '${event}' listener was registered`);
+    return registered[1];
+}
+describe('RabbitMqTransport', ()=>{
+    let amqp;
+    let warnSpy;
+    let errorSpy;
+    beforeEach(()=>{
+        amqp = createAmqpMock();
+        mockLoadOptionalModule.mockResolvedValue({
+            connect: amqp.connect
+        });
+        warnSpy = jest.spyOn(Logger.prototype, 'warn').mockImplementation(()=>undefined);
+        errorSpy = jest.spyOn(Logger.prototype, 'error').mockImplementation(()=>undefined);
+    });
+    afterEach(()=>{
+        warnSpy.mockRestore();
+        errorSpy.mockRestore();
+        jest.clearAllMocks();
+    });
+    it('should throw a descriptive error when amqplib is not installed', async ()=>{
+        mockLoadOptionalModule.mockRejectedValue(new Error('Cannot find module'));
+        await expect(new RabbitMqTransport().connect()).rejects.toThrow(InternalServerErrorException);
+    });
+    it('should assert a topic exchange and a durable queue on connect', async ()=>{
+        const transport = new RabbitMqTransport({
+            exchange: 'ex',
+            queue: 'svc.events'
+        });
+        await transport.connect();
+        expect(amqp.channel.assertExchange).toHaveBeenCalledWith('ex', 'topic', {
+            durable: true
+        });
+        expect(amqp.channel.assertQueue).toHaveBeenCalledWith('svc.events', {
+            durable: true
+        });
+        expect(transport.isReady()).toBe(true);
+    });
+    it('should publish with the event name as the routing key', async ()=>{
+        const transport = new RabbitMqTransport({
+            exchange: 'ex'
+        });
+        await transport.connect();
+        const event = buildEvent();
+        await transport.publish(event);
+        expect(amqp.channel.publish).toHaveBeenCalledWith('ex', 'storage.folder.created', expect.any(Buffer), expect.objectContaining({
+            messageId: 'event-1',
+            contentType: 'application/json'
+        }));
+    });
+    it('should ignore publish before connect instead of throwing', async ()=>{
+        await expect(new RabbitMqTransport().publish(buildEvent())).resolves.toBeUndefined();
+    });
+    it('should translate the ** wildcard to the AMQP # wildcard when binding', async ()=>{
+        const transport = new RabbitMqTransport({
+            exchange: 'ex',
+            queue: 'q'
+        });
+        await transport.connect();
+        await transport.bind('storage.**');
+        expect(amqp.channel.bindQueue).toHaveBeenCalledWith('q', 'ex', 'storage.#');
+    });
+    it('should start consuming only once across several binds', async ()=>{
+        const transport = new RabbitMqTransport();
+        await transport.connect();
+        await transport.bind('storage.#');
+        await transport.bind('auth.#');
+        expect(amqp.channel.consume).toHaveBeenCalledTimes(1);
+    });
+    it('should hand a consumed message to its handlers and ack it', async ()=>{
+        const transport = new RabbitMqTransport();
+        const handler = jest.fn();
+        transport.onMessage(handler);
+        await transport.connect();
+        await transport.bind('storage.#');
+        const event = buildEvent();
+        const message = {
+            content: Buffer.from(JSON.stringify(event))
+        };
+        await amqp.channel.consume.mock.calls[0][1](message);
+        expect(handler).toHaveBeenCalledWith(event);
+        expect(amqp.channel.ack).toHaveBeenCalledWith(message);
+    });
+    it('should nack a message it cannot parse', async ()=>{
+        const transport = new RabbitMqTransport();
+        await transport.connect();
+        await transport.bind('storage.#');
+        const message = {
+            content: Buffer.from('not json')
+        };
+        await amqp.channel.consume.mock.calls[0][1](message);
+        expect(amqp.channel.nack).toHaveBeenCalledWith(message, false, false);
+    });
+    it('should close the channel and the connection', async ()=>{
+        const transport = new RabbitMqTransport();
+        await transport.connect();
+        await transport.close();
+        expect(amqp.channel.close).toHaveBeenCalled();
+        expect(amqp.connection.close).toHaveBeenCalled();
+        expect(transport.isReady()).toBe(false);
+    });
+    it('should reconnect when the channel dies while the connection is still up', async ()=>{
+        jest.useFakeTimers();
+        const transport = new RabbitMqTransport({
+            reconnectDelay: 10
+        });
+        await transport.connect();
+        listenerFor(amqp.channels[0], 'close')();
+        expect(transport.isReady()).toBe(false);
+        await jest.advanceTimersByTimeAsync(10);
+        expect(amqp.connect).toHaveBeenCalledTimes(2);
+        expect(transport.isReady()).toBe(true);
+        jest.useRealTimers();
+    });
+    it('should close the surviving connection rather than leak it on a channel failure', async ()=>{
+        jest.useFakeTimers();
+        const transport = new RabbitMqTransport({
+            reconnectDelay: 10
+        });
+        await transport.connect();
+        listenerFor(amqp.channels[0], 'close')();
+        await jest.advanceTimersByTimeAsync(10);
+        expect(amqp.connection.close).toHaveBeenCalledTimes(1);
+        jest.useRealTimers();
+    });
+    it('should schedule a single reconnect when the channel and the connection both close', async ()=>{
+        jest.useFakeTimers();
+        const transport = new RabbitMqTransport({
+            reconnectDelay: 10
+        });
+        await transport.connect();
+        listenerFor(amqp.channels[0], 'close')();
+        listenerFor(amqp.connection, 'close')();
+        await jest.advanceTimersByTimeAsync(10);
+        expect(amqp.connect).toHaveBeenCalledTimes(2);
+        jest.useRealTimers();
+    });
+    it('should re-bind every pattern onto the new channel after a reconnect', async ()=>{
+        jest.useFakeTimers();
+        const transport = new RabbitMqTransport({
+            exchange: 'ex',
+            queue: 'q',
+            reconnectDelay: 10
+        });
+        await transport.connect();
+        await transport.bind('storage.**');
+        listenerFor(amqp.channels[0], 'close')();
+        await jest.advanceTimersByTimeAsync(10);
+        expect(amqp.channels[1].bindQueue).toHaveBeenCalledWith('q', 'ex', 'storage.#');
+        expect(amqp.channels[1].consume).toHaveBeenCalledTimes(1);
+        jest.useRealTimers();
+    });
+    it('should ack an in-flight delivery on the channel it arrived on', async ()=>{
+        jest.useFakeTimers();
+        const transport = new RabbitMqTransport({
+            reconnectDelay: 10
+        });
+        await transport.connect();
+        await transport.bind('storage.#');
+        const deliver = amqp.channels[0].consume.mock.calls[0][1];
+        listenerFor(amqp.channels[0], 'close')();
+        await jest.advanceTimersByTimeAsync(10);
+        await deliver({
+            content: Buffer.from(JSON.stringify(buildEvent()))
+        });
+        expect(amqp.channels[0].ack).toHaveBeenCalled();
+        expect(amqp.channels[1].ack).not.toHaveBeenCalled();
+        jest.useRealTimers();
+    });
+    it('should let a later bind retry consuming after the broker rejects consume', async ()=>{
+        const transport = new RabbitMqTransport();
+        await transport.connect();
+        amqp.channel.consume.mockRejectedValueOnce(new Error('CHANNEL_ERROR'));
+        await expect(transport.bind('storage.#')).rejects.toThrow('CHANNEL_ERROR');
+        await transport.bind('auth.#');
+        expect(amqp.channel.consume).toHaveBeenCalledTimes(2);
+    });
+    it('should stop reconnecting once it has been closed', async ()=>{
+        jest.useFakeTimers();
+        const transport = new RabbitMqTransport({
+            reconnectDelay: 10
+        });
+        await transport.connect();
+        await transport.close();
+        listenerFor(amqp.channels[0], 'close')();
+        await jest.advanceTimersByTimeAsync(50);
+        expect(amqp.connect).toHaveBeenCalledTimes(1);
+        jest.useRealTimers();
+    });
+});

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

@@ -0,0 +1,217 @@
+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;
+}
+import { envConfig } from '@flusys/nestjs-core/config';
+import { Logger } from '@nestjs/common';
+import { matchEventPattern } from '../utils/event-pattern.util';
+import { EventTransportRegistry } from './event-transports/event-transport.registry';
+import { MemoryTransport } from './event-transports/memory-transport';
+const DEFAULT_DEDUPE_SIZE = 5000;
+/**
+ * Event counterpart of HybridCache: one wrapper, transport chosen by configuration.
+ *
+ * - `memory`   in-process only, no broker required (default)
+ * - `rabbitmq` topic exchange, cross-service
+ * - `kafka`    single topic, cross-service
+ * - `hybrid`   both, with duplicate delivery suppressed by event id
+ */ export class HybridEventBus {
+    getTransportLabel() {
+        return this.label;
+    }
+    getActiveTransports() {
+        return this.transports.map((transport)=>transport.name);
+    }
+    async connect() {
+        if (this.connected) return;
+        if (!this.connecting) {
+            this.connecting = this.buildTransports().catch((error)=>{
+                // A cached rejection would leave the bus dead for the process lifetime
+                this.connecting = undefined;
+                throw error;
+            });
+        }
+        await this.connecting;
+        this.connected = true;
+    }
+    async publish(event) {
+        if (!await this.ensureConnected()) return;
+        await Promise.all(this.transports.map((transport)=>transport.publish(event).catch((error)=>{
+                this.logger.warn(`Publish failed on ${transport.name}: ${error.message}`);
+            })));
+    }
+    async subscribe(pattern, handler) {
+        this.subscriptions.push({
+            pattern,
+            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}`);
+            })));
+    }
+    async close() {
+        await Promise.allSettled(this.transports.map((transport)=>transport.close()));
+        this.transports.length = 0;
+        this.subscriptions.length = 0;
+        this.seenIds.clear();
+        this.seenOrder.length = 0;
+        this.memory = undefined;
+        this.connecting = undefined;
+        this.connected = false;
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    /**
+   * Connecting must never throw at the call site - a bus that cannot start is
+   * a degraded system, not a failed request. The next call retries.
+   */ async ensureConnected() {
+        try {
+            await this.connect();
+            return true;
+        } catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error(`Event bus is not available: ${message}`);
+            return false;
+        }
+    }
+    resolveLabelFromEnv() {
+        const value = envConfig.tryGetValue('USE_EVENT_LABEL', false) || 'memory';
+        return value;
+    }
+    async buildTransports() {
+        if (this.label === 'memory' || this.label === 'hybrid') {
+            this.memory = new MemoryTransport();
+            await this.memory.connect();
+            this.registerTransport(this.memory);
+        }
+        if (this.label !== 'memory') {
+            const broker = await this.createBrokerTransport(this.label);
+            if (broker) {
+                this.registerTransport(broker);
+            } else {
+                this.logger.error(`Event transport '${this.label}' was requested but is unavailable - delivering ` + `in-process only, so no event will reach another service. Check the broker URL ` + `and that its driver is installed.`);
+                if (!this.memory) {
+                    this.memory = new MemoryTransport();
+                    await this.memory.connect();
+                    this.registerTransport(this.memory);
+                }
+            }
+        }
+    }
+    async createBrokerTransport(label) {
+        const name = label === 'hybrid' ? this.resolveHybridBrokerName() : label;
+        try {
+            await this.loadOptionalTransport(name);
+            const factory = EventTransportRegistry.get(name);
+            if (!factory) {
+                this.logger.error(`Event transport '${name}' is not registered. Available: ${EventTransportRegistry.getAll().join(', ')}`);
+                return undefined;
+            }
+            const transport = factory(this.getTransportConfig(name));
+            await transport.connect();
+            return transport;
+        } catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error(`Failed to start the '${name}' event transport: ${message}`);
+            return undefined;
+        }
+    }
+    resolveHybridBrokerName() {
+        return envConfig.tryGetValue('EVENT_BROKER', false) || 'rabbitmq';
+    }
+    /**
+   * Registers explicitly rather than relying on the transport file's own
+   * side effect, which a tree shaking bundler is free to drop.
+   */ async loadOptionalTransport(name) {
+        if (EventTransportRegistry.has(name)) return;
+        if (name === 'rabbitmq') {
+            const { RabbitMqTransport } = await import('./event-transports/rabbitmq-transport.optional');
+            EventTransportRegistry.register('rabbitmq', (config)=>new RabbitMqTransport(config));
+            return;
+        }
+        if (name === 'kafka') {
+            const { KafkaTransport } = await import('./event-transports/kafka-transport.optional');
+            EventTransportRegistry.register('kafka', (config)=>new KafkaTransport(config));
+        }
+    }
+    getTransportConfig(name) {
+        if (name === 'rabbitmq') {
+            return {
+                url: envConfig.tryGetValue('RABBITMQ_URL', false) || undefined,
+                queue: this.options.serviceName ? `${this.options.serviceName}.events` : undefined,
+                ...this.options.rabbitmq ?? {}
+            };
+        }
+        if (name === 'kafka') {
+            return {
+                brokers: this.parseBrokers(envConfig.tryGetValue('KAFKA_BROKERS', false)),
+                clientId: this.options.serviceName,
+                groupId: this.options.serviceName ? `${this.options.serviceName}-events` : undefined,
+                ...this.options.kafka ?? {}
+            };
+        }
+        return {};
+    }
+    parseBrokers(value) {
+        if (!value) return undefined;
+        return value.split(',').map((broker)=>broker.trim()).filter(Boolean);
+    }
+    registerTransport(transport) {
+        transport.onMessage((event)=>this.dispatch(event));
+        this.transports.push(transport);
+    }
+    async dispatch(event) {
+        if (this.isDuplicate(event.id)) return;
+        const matched = this.subscriptions.filter((subscription)=>matchEventPattern(subscription.pattern, event.name));
+        await Promise.all(matched.map(async (subscription)=>{
+            try {
+                await subscription.handler(event);
+            } catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                this.logger.error(`Handler for '${subscription.pattern}' failed: ${message}`);
+            }
+        }));
+    }
+    isDuplicate(eventId) {
+        if (!eventId) return false;
+        if (this.seenIds.has(eventId)) return true;
+        this.seenIds.add(eventId);
+        this.seenOrder.push(eventId);
+        if (this.seenOrder.length > this.dedupeSize) {
+            const evicted = this.seenOrder.shift();
+            if (evicted) this.seenIds.delete(evicted);
+        }
+        return false;
+    }
+    constructor(options = {}){
+        _define_property(this, "options", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "subscriptions", void 0);
+        _define_property(this, "transports", void 0);
+        _define_property(this, "seenIds", void 0);
+        _define_property(this, "seenOrder", void 0);
+        _define_property(this, "label", void 0);
+        _define_property(this, "dedupeSize", void 0);
+        _define_property(this, "memory", void 0);
+        _define_property(this, "connecting", void 0);
+        _define_property(this, "connected", void 0);
+        this.options = options;
+        this.logger = new Logger(HybridEventBus.name);
+        this.subscriptions = [];
+        this.transports = [];
+        this.seenIds = new Set();
+        this.seenOrder = [];
+        this.connected = false;
+        this.label = options.transport ?? this.resolveLabelFromEnv();
+        this.dedupeSize = options.dedupeSize ?? DEFAULT_DEDUPE_SIZE;
+    }
+}

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

@@ -0,0 +1,185 @@
+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';
+function buildEvent(name = 'storage.folder.created', id = 'event-1') {
+    return {
+        id,
+        name,
+        module: 'storage',
+        entity: 'folder',
+        action: EventAction.CREATED,
+        payload: {
+            ids: [
+                '1'
+            ]
+        },
+        actor: {},
+        occurredAt: new Date().toISOString(),
+        version: 1
+    };
+}
+function createFakeTransport(name) {
+    const handlers = [];
+    const transport = {
+        name,
+        connect: jest.fn().mockResolvedValue(undefined),
+        publish: jest.fn().mockResolvedValue(undefined),
+        bind: jest.fn().mockResolvedValue(undefined),
+        onMessage: (handler)=>handlers.push(handler),
+        close: jest.fn().mockResolvedValue(undefined),
+        isReady: ()=>true,
+        emit: (event)=>handlers.forEach((handler)=>handler(event))
+    };
+    return transport;
+}
+describe('HybridEventBus', ()=>{
+    const originalLabel = process.env.USE_EVENT_LABEL;
+    afterEach(async ()=>{
+        EventTransportRegistry.clear();
+        if (originalLabel === undefined) delete process.env.USE_EVENT_LABEL;
+        else process.env.USE_EVENT_LABEL = originalLabel;
+    });
+    it('should default to the memory transport', async ()=>{
+        const bus = new HybridEventBus();
+        await bus.connect();
+        expect(bus.getTransportLabel()).toBe('memory');
+        expect(bus.getActiveTransports()).toEqual([
+            'memory'
+        ]);
+        await bus.close();
+    });
+    it('should read the transport label from USE_EVENT_LABEL when not given explicitly', ()=>{
+        process.env.USE_EVENT_LABEL = 'kafka';
+        expect(new HybridEventBus().getTransportLabel()).toBe('kafka');
+    });
+    it('should prefer an explicit transport option over the env value', ()=>{
+        process.env.USE_EVENT_LABEL = 'kafka';
+        expect(new HybridEventBus({
+            transport: 'memory'
+        }).getTransportLabel()).toBe('memory');
+    });
+    it('should deliver a published event to a matching subscriber', async ()=>{
+        const bus = new HybridEventBus({
+            transport: 'memory'
+        });
+        const handler = jest.fn();
+        await bus.subscribe('storage.*.created', handler);
+        await bus.publish(buildEvent());
+        expect(handler).toHaveBeenCalledWith(expect.objectContaining({
+            name: 'storage.folder.created'
+        }));
+        await bus.close();
+    });
+    it('should not deliver an event to a non matching subscriber', async ()=>{
+        const bus = new HybridEventBus({
+            transport: 'memory'
+        });
+        const handler = jest.fn();
+        await bus.subscribe('auth.#', handler);
+        await bus.publish(buildEvent());
+        expect(handler).not.toHaveBeenCalled();
+        await bus.close();
+    });
+    it('should keep publishing when a handler throws', async ()=>{
+        const bus = new HybridEventBus({
+            transport: 'memory'
+        });
+        const failing = jest.fn().mockRejectedValue(new Error('boom'));
+        const healthy = jest.fn();
+        await bus.subscribe('**', failing);
+        await bus.subscribe('**', healthy);
+        await expect(bus.publish(buildEvent())).resolves.toBeUndefined();
+        expect(healthy).toHaveBeenCalled();
+        await bus.close();
+    });
+    it('should publish to both layers in hybrid mode and deliver each event once', async ()=>{
+        const broker = createFakeTransport('rabbitmq');
+        EventTransportRegistry.register('rabbitmq', ()=>broker);
+        const bus = new HybridEventBus({
+            transport: 'hybrid'
+        });
+        const handler = jest.fn();
+        await bus.subscribe('**', handler);
+        expect(bus.getActiveTransports()).toEqual([
+            'memory',
+            'rabbitmq'
+        ]);
+        const event = buildEvent();
+        await bus.publish(event);
+        // the broker loops the same event back to this process
+        broker.emit(event);
+        expect(broker.publish).toHaveBeenCalledWith(event);
+        expect(handler).toHaveBeenCalledTimes(1);
+        await bus.close();
+    });
+    it('should fall back to memory when the broker cannot start', async ()=>{
+        EventTransportRegistry.register('kafka', ()=>{
+            throw new Error('kafkajs not installed');
+        });
+        const bus = new HybridEventBus({
+            transport: 'kafka'
+        });
+        await bus.connect();
+        expect(bus.getActiveTransports()).toEqual([
+            'memory'
+        ]);
+        await bus.close();
+    });
+    it('should survive a transport that fails to publish', async ()=>{
+        const broker = createFakeTransport('rabbitmq');
+        broker.publish.mockRejectedValue(new Error('channel closed'));
+        EventTransportRegistry.register('rabbitmq', ()=>broker);
+        const bus = new HybridEventBus({
+            transport: 'rabbitmq'
+        });
+        await expect(bus.publish(buildEvent())).resolves.toBeUndefined();
+        await bus.close();
+    });
+    it('should not publish or throw while it has no working transport', async ()=>{
+        const connectSpy = jest.spyOn(MemoryTransport.prototype, 'connect').mockRejectedValueOnce(new Error('boot failure'));
+        const bus = new HybridEventBus({
+            transport: 'memory'
+        });
+        await expect(bus.publish(buildEvent())).resolves.toBeUndefined();
+        expect(bus.getActiveTransports()).toEqual([]);
+        connectSpy.mockRestore();
+        await bus.close();
+    });
+    it('should retry connecting after a failed attempt instead of staying dead', async ()=>{
+        const connectSpy = jest.spyOn(MemoryTransport.prototype, 'connect').mockRejectedValueOnce(new Error('boot failure'));
+        const bus = new HybridEventBus({
+            transport: 'memory'
+        });
+        const handler = jest.fn();
+        await bus.publish(buildEvent());
+        connectSpy.mockRestore();
+        await bus.subscribe('**', handler);
+        await bus.publish(buildEvent('storage.folder.created', 'event-2'));
+        expect(bus.getActiveTransports()).toEqual([
+            'memory'
+        ]);
+        expect(handler).toHaveBeenCalledTimes(1);
+        await bus.close();
+    });
+    it('should keep a subscription made while disconnected so a later connect binds it', async ()=>{
+        const connectSpy = jest.spyOn(MemoryTransport.prototype, 'connect').mockRejectedValueOnce(new Error('boot failure'));
+        const bus = new HybridEventBus({
+            transport: 'memory'
+        });
+        const handler = jest.fn();
+        await expect(bus.subscribe('**', handler)).resolves.toBeUndefined();
+        connectSpy.mockRestore();
+        await bus.publish(buildEvent());
+        expect(handler).toHaveBeenCalledTimes(1);
+        await bus.close();
+    });
+    it('should forget its transports after close', async ()=>{
+        const bus = new HybridEventBus({
+            transport: 'memory'
+        });
+        await bus.connect();
+        await bus.close();
+        expect(bus.getActiveTransports()).toEqual([]);
+    });
+});

package/fesm/classes/index.js

@@ -1,7 +1,12 @@
 export * from './api-controller.class';
 export * from './api-service.class';
+export * from './disabled-event-bus.class';
+export * from './domain-event.publisher';
+export * from './event-bus.registry';
+export * from './event-transports';
 export * from './handle-custome-db';
 export * from './hybrid-cache.class';
+export * from './hybrid-event-bus.class';
 export * from './winston.logger.class';
 // Re-export permission constants for convenience
 export * from '../constants/permissions';

package/fesm/constants/index.js

@@ -1,9 +1,12 @@
 // Metadata keys
 export const IS_PUBLIC_KEY = 'isPublic';
 export const PERMISSIONS_KEY = 'permissions';
+export const DOMAIN_EVENT_HANDLER_KEY = 'domainEventHandler';
 // Injection tokens
 export const CACHE_INSTANCE = 'CACHE_INSTANCE';
 export const PERMISSION_GUARD_CONFIG = 'PERMISSION_GUARD_CONFIG';
+export const EVENT_BUS_INSTANCE = 'EVENT_BUS_INSTANCE';
+export const EVENT_BUS_MODULE_OPTIONS = 'EVENT_BUS_MODULE_OPTIONS';
 // Header names
 export const IDEMPOTENCY_KEY_HEADER = 'x-idempotency-key';
 export const REQUEST_ID_HEADER = 'x-request-id';
@@ -11,6 +14,10 @@ export const CLIENT_TYPE_HEADER = 'x-client-type';
 // Cache key prefixes
 export const PERMISSIONS_CACHE_PREFIX = 'my-permissions';
 export const IDEMPOTENCY_CACHE_PREFIX = 'idempotency';
+// Event bus defaults
+export const DEFAULT_EVENT_EXCHANGE = 'flusys.events';
+export const DEFAULT_EVENT_TOPIC = 'flusys.domain-events';
+export const DEFAULT_EVENT_SERVICE_NAME = 'flusys';
 // Permission codes
 export * from './permissions';
 // Message keys for localization