@flusys/nestjs-shared 7.1.0 → 8.0.0

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

@@ -1,151 +0,0 @@
-/**
- * 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

@@ -1,198 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _common = require("@nestjs/common");
-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: '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

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "MemoryTransport", {
-    enumerable: true,
-    get: function() {
-        return MemoryTransport;
-    }
-});
-const _events = require("events");
-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';
-const MAX_LISTENERS = 100;
-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(){
-        _define_property(this, "name", 'memory');
-        _define_property(this, "emitter", new _events.EventEmitter());
-        _define_property(this, "ready", false);
-        this.emitter.setMaxListeners(MAX_LISTENERS);
-    }
-};

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

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _memorytransport = require("./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.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();
-    });
-});