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

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

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _eventactionenum = require("../enums/event-action.enum");
+const _eventbusregistry = require("./event-bus.registry");
+const bus = {
+    publish: jest.fn(),
+    subscribe: jest.fn(),
+    close: jest.fn()
+};
+describe('EventBusRegistry', ()=>{
+    beforeEach(()=>{
+        _eventbusregistry.EventBusRegistry.reset();
+        _eventbusregistry.EventBusRegistry.setBus(bus);
+    });
+    afterEach(()=>{
+        _eventbusregistry.EventBusRegistry.reset();
+    });
+    it('should expose the registered bus', ()=>{
+        expect(_eventbusregistry.EventBusRegistry.getBus()).toBe(bus);
+    });
+    it('should answer from the module config alone, independent of any registered bus', ()=>{
+        _eventbusregistry.EventBusRegistry.reset();
+        _eventbusregistry.EventBusRegistry.configureModule('storage', {
+            enabled: true
+        });
+        expect(_eventbusregistry.EventBusRegistry.getBus()).toBeUndefined();
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'folder', _eventactionenum.EventAction.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);
+    });
+    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);
+    });
+    it('should honour an action allowlist', ()=>{
+        _eventbusregistry.EventBusRegistry.configureModule('storage', {
+            enabled: true,
+            actions: [
+                _eventactionenum.EventAction.CREATED
+            ]
+        });
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'folder', _eventactionenum.EventAction.CREATED)).toBe(true);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('storage', 'folder', _eventactionenum.EventAction.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,
+                'logged-in'
+            ]
+        });
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'appuser', _eventactionenum.EventAction.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', 'session', 'logged-out')).toBe(false);
+    });
+    it('should silence CRUD when the allowlist names only domain actions', ()=>{
+        _eventbusregistry.EventBusRegistry.configureModule('auth', {
+            enabled: true,
+            actions: [
+                'logged-in'
+            ]
+        });
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'session', 'logged-in')).toBe(true);
+        expect(_eventbusregistry.EventBusRegistry.isEnabled('auth', 'appuser', _eventactionenum.EventAction.CREATED)).toBe(false);
+    });
+    it('should honour an entity allowlist and exclusion list', ()=>{
+        _eventbusregistry.EventBusRegistry.configureModule('storage', {
+            enabled: true,
+            entities: [
+                'folder',
+                'file_manager'
+            ],
+            excludeEntities: [
+                'file_manager'
+            ]
+        });
+        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);
+    });
+    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);
+    });
+    it('should include the payload unless a module opts out', ()=>{
+        _eventbusregistry.EventBusRegistry.configureModule('storage', {
+            enabled: true
+        });
+        _eventbusregistry.EventBusRegistry.configureModule('auth', {
+            enabled: true,
+            includePayload: false
+        });
+        expect(_eventbusregistry.EventBusRegistry.shouldIncludePayload('storage')).toBe(true);
+        expect(_eventbusregistry.EventBusRegistry.shouldIncludePayload('auth')).toBe(false);
+    });
+    it('should clear everything on reset', ()=>{
+        _eventbusregistry.EventBusRegistry.configureModule('storage', {
+            enabled: true
+        });
+        _eventbusregistry.EventBusRegistry.reset();
+        expect(_eventbusregistry.EventBusRegistry.getBus()).toBeUndefined();
+        expect(_eventbusregistry.EventBusRegistry.getModuleConfig('storage')).toEqual({
+            enabled: false
+        });
+    });
+});

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EventTransportRegistry", {
+    enumerable: true,
+    get: function() {
+        return EventTransportRegistry;
+    }
+});
+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;
+}
+let EventTransportRegistry = class EventTransportRegistry {
+    static register(name, factory) {
+        this.transports.set(name.toLowerCase(), factory);
+    }
+    static get(name) {
+        return this.transports.get(name.toLowerCase());
+    }
+    static has(name) {
+        return this.transports.has(name.toLowerCase());
+    }
+    static getAll() {
+        return Array.from(this.transports.keys());
+    }
+    static clear() {
+        this.transports.clear();
+    }
+};
+_define_property(EventTransportRegistry, "transports", new Map());

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _eventtransportregistry = require("./event-transport.registry");
+const stubTransport = {};
+describe('EventTransportRegistry', ()=>{
+    afterEach(()=>{
+        _eventtransportregistry.EventTransportRegistry.clear();
+    });
+    it('should register and resolve a transport factory', ()=>{
+        _eventtransportregistry.EventTransportRegistry.register('rabbitmq', ()=>stubTransport);
+        expect(_eventtransportregistry.EventTransportRegistry.get('rabbitmq')({})).toBe(stubTransport);
+    });
+    it('should resolve case insensitively', ()=>{
+        _eventtransportregistry.EventTransportRegistry.register('Kafka', ()=>stubTransport);
+        expect(_eventtransportregistry.EventTransportRegistry.has('kafka')).toBe(true);
+    });
+    it('should return undefined for an unknown transport', ()=>{
+        expect(_eventtransportregistry.EventTransportRegistry.get('nats')).toBeUndefined();
+        expect(_eventtransportregistry.EventTransportRegistry.has('nats')).toBe(false);
+    });
+    it('should list every registered transport', ()=>{
+        _eventtransportregistry.EventTransportRegistry.register('memory', ()=>stubTransport);
+        _eventtransportregistry.EventTransportRegistry.register('kafka', ()=>stubTransport);
+        expect(_eventtransportregistry.EventTransportRegistry.getAll().sort()).toEqual([
+            'kafka',
+            'memory'
+        ]);
+    });
+});

package/cjs/classes/event-transports/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./event-transport.registry"), exports);
+_export_star(require("./memory-transport"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+ // Note: Broker transports are loaded dynamically by HybridEventBus.
+ // Import them directly when registering manually:
+ // - import { RabbitMqTransport } from '@flusys/nestjs-shared/classes/event-transports/rabbitmq-transport.optional';
+ // - import { KafkaTransport } from '@flusys/nestjs-shared/classes/event-transports/kafka-transport.optional';

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

@@ -0,0 +1,151 @@
+/**
+ * Optional Kafka event transport
+ * Requires: npm install kafkajs
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "KafkaTransport", {
+    enumerable: true,
+    get: function() {
+        return KafkaTransport;
+    }
+});
+const _common = require("@nestjs/common");
+const _constants = require("../../constants");
+const _optionalmoduleutil = require("../../utils/optional-module.util");
+const _eventtransportregistry = require("./event-transport.registry");
+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;
+}
+const DEFAULT_BROKERS = [
+    'localhost:9092'
+];
+let KafkaTransport = class KafkaTransport {
+    async connect() {
+        let kafkajs;
+        try {
+            kafkajs = await (0, _optionalmoduleutil.loadOptionalModule)('kafkajs');
+        } catch  {
+            throw new _common.InternalServerErrorException({
+                message: 'kafkajs not found',
+                messageKey: _constants.SYSTEM_MESSAGES.SDK_NOT_INSTALLED,
+                messageVariables: {
+                    sdk: 'kafkajs'
+                }
+            });
+        }
+        const Kafka = kafkajs.Kafka ?? kafkajs.default.Kafka;
+        this.client = new Kafka({
+            clientId: this.config.clientId ?? _constants.DEFAULT_EVENT_SERVICE_NAME,
+            brokers: this.config.brokers ?? DEFAULT_BROKERS,
+            ssl: this.config.ssl,
+            sasl: this.config.sasl
+        });
+        this.producer = this.client.producer();
+        await this.producer.connect();
+        // The consumer is built on the first bind, never here: subscribing to a
+        // topic that does not exist yet, or a coordinator that is not ready, would
+        // otherwise fail the whole transport and take publishing down with it - and
+        // a service that only publishes would join a consumer group for nothing.
+        if (this.boundPatterns.size) await this.startConsuming();
+    }
+    async publish(event) {
+        if (!this.producer) return;
+        await this.producer.send({
+            topic: this.topic,
+            messages: [
+                {
+                    key: event.name,
+                    value: JSON.stringify(event),
+                    headers: {
+                        eventId: event.id,
+                        module: event.module,
+                        action: String(event.action)
+                    }
+                }
+            ]
+        });
+    }
+    async bind(pattern) {
+        if (this.boundPatterns.has(pattern)) return;
+        this.boundPatterns.add(pattern);
+        await this.startConsuming();
+    }
+    onMessage(handler) {
+        this.handlers.push(handler);
+    }
+    async close() {
+        await this.consumer?.disconnect().catch(()=>{});
+        await this.producer?.disconnect().catch(()=>{});
+        this.consumer = undefined;
+        this.producer = undefined;
+        this.client = undefined;
+        this.running = false;
+    }
+    isReady() {
+        return Boolean(this.producer);
+    }
+    get topic() {
+        return this.config.topic ?? _constants.DEFAULT_EVENT_TOPIC;
+    }
+    async startConsuming() {
+        if (this.running || !this.client) return;
+        this.running = true;
+        try {
+            this.consumer = this.client.consumer({
+                groupId: this.config.groupId ?? `${_constants.DEFAULT_EVENT_SERVICE_NAME}-events`
+            });
+            await this.consumer.connect();
+            await this.consumer.subscribe({
+                topic: this.topic,
+                fromBeginning: false
+            });
+            await this.consumer.run({
+                eachMessage: async ({ message })=>{
+                    // A compacted topic delivers tombstones with no value at all
+                    if (!message?.value) return;
+                    try {
+                        const event = JSON.parse(message.value.toString());
+                        await Promise.all(this.handlers.map((handler)=>handler(event)));
+                    } catch (error) {
+                        this.logger.error(error instanceof Error ? error.message : 'Failed to handle event');
+                    }
+                }
+            });
+        } catch (error) {
+            // Released so a later bind can try again; the producer stays usable
+            this.running = false;
+            this.consumer = undefined;
+            throw error;
+        }
+    }
+    constructor(config = {}){
+        _define_property(this, "config", void 0);
+        _define_property(this, "name", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "handlers", void 0);
+        _define_property(this, "boundPatterns", void 0);
+        _define_property(this, "client", void 0);
+        _define_property(this, "producer", void 0);
+        _define_property(this, "consumer", void 0);
+        _define_property(this, "running", void 0);
+        this.config = config;
+        this.name = 'kafka';
+        this.logger = new _common.Logger(KafkaTransport.name);
+        this.handlers = [];
+        this.boundPatterns = new Set();
+        this.running = false;
+    }
+};
+_eventtransportregistry.EventTransportRegistry.register('kafka', (config)=>new KafkaTransport(config));

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

@@ -0,0 +1,199 @@
+"use strict";
+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', ()=>({
+        loadOptionalModule: (...args)=>mockLoadOptionalModule(...args)
+    }));
+function buildEvent() {
+    return {
+        id: 'event-1',
+        name: 'storage.folder.created',
+        module: 'storage',
+        entity: 'folder',
+        action: _eventactionenum.EventAction.CREATED,
+        payload: {
+            ids: [
+                '1'
+            ]
+        },
+        actor: {},
+        occurredAt: '2026-01-01T00:00:00.000Z',
+        version: 1
+    };
+}
+function createKafkaMock() {
+    const producer = {
+        connect: jest.fn().mockResolvedValue(undefined),
+        send: jest.fn().mockResolvedValue(undefined),
+        disconnect: jest.fn().mockResolvedValue(undefined)
+    };
+    const consumer = {
+        connect: jest.fn().mockResolvedValue(undefined),
+        subscribe: jest.fn().mockResolvedValue(undefined),
+        run: jest.fn().mockResolvedValue(undefined),
+        disconnect: jest.fn().mockResolvedValue(undefined)
+    };
+    const Kafka = jest.fn().mockImplementation(()=>({
+            producer: ()=>producer,
+            consumer: ()=>consumer
+        }));
+    return {
+        producer,
+        consumer,
+        Kafka
+    };
+}
+describe('KafkaTransport', ()=>{
+    let kafka;
+    let errorSpy;
+    beforeEach(()=>{
+        kafka = createKafkaMock();
+        mockLoadOptionalModule.mockResolvedValue({
+            Kafka: kafka.Kafka
+        });
+        errorSpy = jest.spyOn(_common.Logger.prototype, 'error').mockImplementation(()=>undefined);
+    });
+    afterEach(()=>{
+        errorSpy.mockRestore();
+        jest.clearAllMocks();
+    });
+    it('should throw a descriptive error when kafkajs is not installed', async ()=>{
+        mockLoadOptionalModule.mockRejectedValue(new Error('Cannot find module'));
+        await expect(new _kafkatransportoptional.KafkaTransport().connect()).rejects.toThrow(_common.InternalServerErrorException);
+    });
+    it('should connect the producer and leave the consumer alone until a bind', async ()=>{
+        const transport = new _kafkatransportoptional.KafkaTransport({
+            topic: 'events',
+            groupId: 'svc'
+        });
+        await transport.connect();
+        expect(kafka.producer.connect).toHaveBeenCalled();
+        expect(kafka.consumer.connect).not.toHaveBeenCalled();
+        expect(transport.isReady()).toBe(true);
+    });
+    it('should connect and subscribe the consumer on the first bind', async ()=>{
+        const transport = new _kafkatransportoptional.KafkaTransport({
+            topic: 'events',
+            groupId: 'svc'
+        });
+        await transport.connect();
+        await transport.bind('storage.#');
+        expect(kafka.consumer.connect).toHaveBeenCalled();
+        expect(kafka.consumer.subscribe).toHaveBeenCalledWith({
+            topic: 'events',
+            fromBeginning: false
+        });
+    });
+    it('should pass the broker list and client id through to kafkajs', async ()=>{
+        await new _kafkatransportoptional.KafkaTransport({
+            brokers: [
+                'b1:9092'
+            ],
+            clientId: 'svc'
+        }).connect();
+        expect(kafka.Kafka).toHaveBeenCalledWith(expect.objectContaining({
+            brokers: [
+                'b1:9092'
+            ],
+            clientId: 'svc'
+        }));
+    });
+    it('should send the event keyed by its name', async ()=>{
+        const transport = new _kafkatransportoptional.KafkaTransport({
+            topic: 'events'
+        });
+        await transport.connect();
+        await transport.publish(buildEvent());
+        expect(kafka.producer.send).toHaveBeenCalledWith({
+            topic: 'events',
+            messages: [
+                expect.objectContaining({
+                    key: 'storage.folder.created',
+                    headers: expect.objectContaining({
+                        eventId: 'event-1',
+                        module: 'storage'
+                    })
+                })
+            ]
+        });
+    });
+    it('should ignore publish before connect instead of throwing', async ()=>{
+        await expect(new _kafkatransportoptional.KafkaTransport().publish(buildEvent())).resolves.toBeUndefined();
+    });
+    it('should start the consumer only once across several binds', async ()=>{
+        const transport = new _kafkatransportoptional.KafkaTransport();
+        await transport.connect();
+        await transport.bind('storage.#');
+        await transport.bind('auth.#');
+        expect(kafka.consumer.run).toHaveBeenCalledTimes(1);
+    });
+    it('should hand a consumed message to its handlers', async ()=>{
+        const transport = new _kafkatransportoptional.KafkaTransport();
+        const handler = jest.fn();
+        transport.onMessage(handler);
+        await transport.connect();
+        await transport.bind('storage.#');
+        const event = buildEvent();
+        await kafka.consumer.run.mock.calls[0][0].eachMessage({
+            message: {
+                value: Buffer.from(JSON.stringify(event))
+            }
+        });
+        expect(handler).toHaveBeenCalledWith(event);
+    });
+    it('should swallow a message it cannot parse', async ()=>{
+        const transport = new _kafkatransportoptional.KafkaTransport();
+        await transport.connect();
+        await transport.bind('storage.#');
+        await expect(kafka.consumer.run.mock.calls[0][0].eachMessage({
+            message: {
+                value: Buffer.from('not json')
+            }
+        })).resolves.toBeUndefined();
+    });
+    it('should disconnect both clients on close', async ()=>{
+        const transport = new _kafkatransportoptional.KafkaTransport();
+        await transport.connect();
+        await transport.bind('storage.#');
+        await transport.close();
+        expect(kafka.producer.disconnect).toHaveBeenCalled();
+        expect(kafka.consumer.disconnect).toHaveBeenCalled();
+        expect(transport.isReady()).toBe(false);
+    });
+    it('should keep publishing when the consumer cannot subscribe', async ()=>{
+        kafka.consumer.subscribe.mockRejectedValueOnce(new Error('UNKNOWN_TOPIC_OR_PARTITION'));
+        const transport = new _kafkatransportoptional.KafkaTransport();
+        await transport.connect();
+        await expect(transport.bind('storage.#')).rejects.toThrow('UNKNOWN_TOPIC_OR_PARTITION');
+        expect(transport.isReady()).toBe(true);
+        await transport.publish(buildEvent());
+        expect(kafka.producer.send).toHaveBeenCalled();
+    });
+    it('should let a later bind retry after the consumer failed to start', async ()=>{
+        kafka.consumer.subscribe.mockRejectedValueOnce(new Error('COORDINATOR_NOT_AVAILABLE'));
+        const transport = new _kafkatransportoptional.KafkaTransport();
+        await transport.connect();
+        await expect(transport.bind('storage.#')).rejects.toThrow('COORDINATOR_NOT_AVAILABLE');
+        await transport.bind('auth.#');
+        expect(kafka.consumer.run).toHaveBeenCalledTimes(1);
+    });
+    it('should skip a message that carries no value', async ()=>{
+        const transport = new _kafkatransportoptional.KafkaTransport();
+        const handler = jest.fn();
+        transport.onMessage(handler);
+        await transport.connect();
+        await transport.bind('storage.#');
+        await kafka.consumer.run.mock.calls[0][0].eachMessage({
+            message: {
+                value: null
+            }
+        });
+        expect(handler).not.toHaveBeenCalled();
+        expect(errorSpy).not.toHaveBeenCalled();
+    });
+});

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MemoryTransport", {
+    enumerable: true,
+    get: function() {
+        return 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, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+const CHANNEL = 'domain-event';
+let MemoryTransport = class MemoryTransport {
+    async connect() {
+        this.ready = true;
+    }
+    async publish(event) {
+        this.emitter.emit(CHANNEL, event);
+    }
+    async bind(_pattern) {}
+    onMessage(handler) {
+        this.emitter.on(CHANNEL, (event)=>{
+            void handler(event);
+        });
+    }
+    async close() {
+        this.emitter.removeAllListeners();
+        this.ready = false;
+    }
+    isReady() {
+        return this.ready;
+    }
+    constructor(maxListeners = 100){
+        _define_property(this, "name", 'memory');
+        _define_property(this, "emitter", new _events.EventEmitter());
+        _define_property(this, "ready", false);
+        this.emitter.setMaxListeners(maxListeners);
+    }
+};
+_eventtransportregistry.EventTransportRegistry.register('memory', (config)=>new MemoryTransport(config['maxListeners']));

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

@@ -0,0 +1,58 @@
+"use strict";
+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 {
+        id: 'event-1',
+        name,
+        module: 'storage',
+        entity: 'folder',
+        action: _eventactionenum.EventAction.CREATED,
+        payload: {
+            ids: [
+                '1'
+            ]
+        },
+        actor: {},
+        occurredAt: new Date().toISOString(),
+        version: 1
+    };
+}
+describe('MemoryTransport', ()=>{
+    let transport;
+    beforeEach(()=>{
+        transport = new _memorytransport.MemoryTransport();
+    });
+    afterEach(async ()=>{
+        await transport.close();
+    });
+    it('should report ready only after connect', async ()=>{
+        expect(transport.isReady()).toBe(false);
+        await transport.connect();
+        expect(transport.isReady()).toBe(true);
+    });
+    it('should deliver a published event to every registered handler', async ()=>{
+        const first = jest.fn();
+        const second = jest.fn();
+        transport.onMessage(first);
+        transport.onMessage(second);
+        const event = buildEvent();
+        await transport.publish(event);
+        expect(first).toHaveBeenCalledWith(event);
+        expect(second).toHaveBeenCalledWith(event);
+    });
+    it('should not deliver anything once closed', async ()=>{
+        const handler = jest.fn();
+        transport.onMessage(handler);
+        await transport.close();
+        await transport.publish(buildEvent());
+        expect(handler).not.toHaveBeenCalled();
+        expect(transport.isReady()).toBe(false);
+    });
+    it('should accept bind calls without a broker', async ()=>{
+        await expect(transport.bind('storage.#')).resolves.toBeUndefined();
+    });
+});