@flusys/nestjs-shared 7.1.0 → 8.0.0

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

@@ -1,194 +0,0 @@
-const mockLoadOptionalModule = jest.fn();
-jest.mock('../../utils/optional-module.util', ()=>({
-        loadOptionalModule: (...args)=>mockLoadOptionalModule(...args)
-    }));
-import { InternalServerErrorException, Logger } from '@nestjs/common';
-import { KafkaTransport } from './kafka-transport.optional';
-function buildEvent() {
-    return {
-        id: 'event-1',
-        name: 'storage.folder.created',
-        module: 'storage',
-        entity: 'folder',
-        action: '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(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 KafkaTransport().connect()).rejects.toThrow(InternalServerErrorException);
-    });
-    it('should connect the producer and leave the consumer alone until a bind', async ()=>{
-        const transport = new 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 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 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 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 KafkaTransport().publish(buildEvent())).resolves.toBeUndefined();
-    });
-    it('should start the consumer only once across several binds', async ()=>{
-        const transport = new 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 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 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 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 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 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 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/fesm/classes/event-transports/memory-transport.js

@@ -1,49 +0,0 @@
-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 { EventEmitter } from 'events';
-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;
-    }
-    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(){
-        _define_property(this, "name", 'memory');
-        _define_property(this, "emitter", new EventEmitter());
-        _define_property(this, "ready", false);
-        this.emitter.setMaxListeners(MAX_LISTENERS);
-    }
-}

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

@@ -1,53 +0,0 @@
-import { MemoryTransport } from './memory-transport';
-function buildEvent(name = 'storage.folder.created') {
-    return {
-        id: 'event-1',
-        name,
-        module: 'storage',
-        entity: 'folder',
-        action: 'created',
-        payload: {
-            ids: [
-                '1'
-            ]
-        },
-        actor: {},
-        occurredAt: new Date().toISOString(),
-        version: 1
-    };
-}
-describe('MemoryTransport', ()=>{
-    let transport;
-    beforeEach(()=>{
-        transport = new 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();
-    });
-});

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

@@ -1,174 +0,0 @@
-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;
-}
-/**
- * Optional RabbitMQ event transport
- * Requires: npm install amqplib
- */ import { InternalServerErrorException, Logger } from '@nestjs/common';
-import { DEFAULT_EVENT_EXCHANGE, DEFAULT_EVENT_SERVICE_NAME, SYSTEM_MESSAGES } from '../../constants';
-import { isMultiWildcard } from '../../utils/event-pattern.util';
-import { loadOptionalModule } from '../../utils/optional-module.util';
-import { EventTransportRegistry } from './event-transport.registry';
-const DEFAULT_URL = 'amqp://localhost:5672';
-const DEFAULT_RECONNECT_DELAY = 5000;
-export class RabbitMqTransport {
-    async connect() {
-        let amqp;
-        try {
-            amqp = await loadOptionalModule('amqplib');
-        } catch  {
-            throw new InternalServerErrorException({
-                message: 'amqplib not found',
-                messageKey: SYSTEM_MESSAGES.SDK_NOT_INSTALLED,
-                messageVariables: {
-                    sdk: 'amqplib'
-                }
-            });
-        }
-        this.connection = await (amqp.connect ?? amqp.default.connect)(this.config.url ?? DEFAULT_URL);
-        this.channel = await this.connection.createChannel();
-        await this.channel.assertExchange(this.exchange, 'topic', {
-            durable: this.durable
-        });
-        await this.channel.assertQueue(this.queue, {
-            durable: this.durable
-        });
-        await this.channel.prefetch(this.config.prefetch ?? 10);
-        // A channel dies on its own for any protocol error - a mismatched assert, a
-        // deleted exchange, an unknown delivery tag - while the connection stays up.
-        // Watching only the connection would leave the transport holding a dead
-        // channel: publishing throws into the void and nothing ever reconnects.
-        this.connection.on('close', ()=>this.scheduleReconnect());
-        this.connection.on('error', (error)=>this.logger.warn(error.message));
-        this.channel.on('close', ()=>this.scheduleReconnect());
-        this.channel.on('error', (error)=>this.logger.warn(error.message));
-        for (const pattern of this.boundPatterns){
-            await this.channel.bindQueue(this.queue, this.exchange, this.toRoutingKey(pattern));
-        }
-        if (this.boundPatterns.size) await this.startConsuming();
-    }
-    async publish(event) {
-        if (!this.channel) return;
-        this.channel.publish(this.exchange, event.name, Buffer.from(JSON.stringify(event)), {
-            persistent: this.durable,
-            messageId: event.id,
-            appId: this.config.queue ?? DEFAULT_EVENT_SERVICE_NAME,
-            contentType: 'application/json'
-        });
-    }
-    async bind(pattern) {
-        if (this.boundPatterns.has(pattern)) return;
-        this.boundPatterns.add(pattern);
-        if (!this.channel) return;
-        await this.channel.bindQueue(this.queue, this.exchange, this.toRoutingKey(pattern));
-        await this.startConsuming();
-    }
-    onMessage(handler) {
-        this.handlers.push(handler);
-    }
-    async close() {
-        this.closed = true;
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = undefined;
-        }
-        await this.teardown();
-    }
-    isReady() {
-        return Boolean(this.channel);
-    }
-    get exchange() {
-        return this.config.exchange ?? DEFAULT_EVENT_EXCHANGE;
-    }
-    get queue() {
-        return this.config.queue ?? `${DEFAULT_EVENT_SERVICE_NAME}.events`;
-    }
-    get durable() {
-        return this.config.durable ?? true;
-    }
-    /** `**` is the FLUSYS alias for the AMQP multi word wildcard */ toRoutingKey(pattern) {
-        return pattern.split('.').map((segment)=>isMultiWildcard(segment) ? '#' : segment).join('.');
-    }
-    async startConsuming() {
-        // Captured, because a reconnect swaps `this.channel` while deliveries are in
-        // flight - a delivery tag means nothing on the new channel, and acking it
-        // there is a protocol error that kills that channel too.
-        const channel = this.channel;
-        if (this.consuming || !channel) return;
-        this.consuming = true;
-        try {
-            await channel.consume(this.queue, async (message)=>{
-                if (!message) return;
-                try {
-                    const event = JSON.parse(message.content.toString());
-                    await Promise.all(this.handlers.map((handler)=>handler(event)));
-                    channel.ack(message);
-                } catch (error) {
-                    this.logger.error(error instanceof Error ? error.message : 'Failed to handle event');
-                    channel.nack(message, false, false);
-                }
-            });
-        } catch (error) {
-            // A latch left set would keep the queue unconsumed for the process lifetime
-            this.consuming = false;
-            throw error;
-        }
-    }
-    /** A dropped connection reports itself twice - once per channel, once per connection */ scheduleReconnect() {
-        if (this.closed || this.reconnectTimer) return;
-        // Not awaited: the fields are cleared before its first await, so publishing
-        // stops using the dead channel now rather than after the sockets close.
-        void this.teardown();
-        this.reconnectTimer = setTimeout(()=>{
-            this.reconnectTimer = undefined;
-            this.connect().catch((error)=>{
-                this.logger.warn(`RabbitMQ reconnect failed: ${error.message}`);
-                this.scheduleReconnect();
-            });
-        }, this.config.reconnectDelay ?? DEFAULT_RECONNECT_DELAY);
-    }
-    /**
-   * Drops the current channel and connection. The connection is closed even when
-   * it was only the channel that died, otherwise every channel level failure
-   * would leave one more live connection behind on the broker.
-   */ async teardown() {
-        const { channel, connection } = this;
-        this.channel = undefined;
-        this.connection = undefined;
-        this.consuming = false;
-        channel?.removeAllListeners?.();
-        connection?.removeAllListeners?.();
-        await channel?.close().catch(()=>{});
-        await connection?.close().catch(()=>{});
-    }
-    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, "connection", void 0);
-        _define_property(this, "channel", void 0);
-        _define_property(this, "consuming", void 0);
-        _define_property(this, "closed", void 0);
-        _define_property(this, "reconnectTimer", void 0);
-        this.config = config;
-        this.name = 'rabbitmq';
-        this.logger = new Logger(RabbitMqTransport.name);
-        this.handlers = [];
-        this.boundPatterns = new Set();
-        this.consuming = false;
-        this.closed = false;
-    }
-}
-EventTransportRegistry.register('rabbitmq', (config)=>new RabbitMqTransport(config));