@flusys/nestjs-shared 7.0.2 → 8.0.0-beta.1

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

@@ -1,281 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "HybridEventBus", {
-    enumerable: true,
-    get: function() {
-        return HybridEventBus;
-    }
-});
-const _config = require("@flusys/nestjs-core/config");
-const _common = require("@nestjs/common");
-const _eventpatternutil = require("../utils/event-pattern.util");
-const _eventtransportregistry = require("./event-transports/event-transport.registry");
-const _memorytransport = require("./event-transports/memory-transport");
-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;
-}
-function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {
-        __proto__: null
-    };
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-const DEFAULT_DEDUPE_SIZE = 5000;
-let HybridEventBus = 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 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;
-        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 = _config.envConfig.tryGetValue('USE_EVENT_LABEL', false) || 'memory';
-        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.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.MemoryTransport();
-                    await this.memory.connect();
-                    this.registerTransport(this.memory);
-                }
-            }
-        }
-        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;
-        try {
-            await this.loadOptionalTransport(name);
-            const factory = _eventtransportregistry.EventTransportRegistry.get(name);
-            if (!factory) {
-                this.logger.error(`Event transport '${name}' is not registered. Available: ${_eventtransportregistry.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 _config.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.EventTransportRegistry.has(name)) return;
-        if (name === 'rabbitmq') {
-            const { RabbitMqTransport } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./event-transports/rabbitmq-transport.optional")));
-            _eventtransportregistry.EventTransportRegistry.register('rabbitmq', (config)=>new RabbitMqTransport(config));
-            return;
-        }
-        if (name === 'kafka') {
-            const { KafkaTransport } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./event-transports/kafka-transport.optional")));
-            _eventtransportregistry.EventTransportRegistry.register('kafka', (config)=>new KafkaTransport(config));
-        }
-    }
-    getTransportConfig(name) {
-        if (name === 'rabbitmq') {
-            return {
-                url: _config.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(_config.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)=>(0, _eventpatternutil.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, "boundPatterns", 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 _common.Logger(HybridEventBus.name);
-        this.subscriptions = [];
-        this.transports = [];
-        this.boundPatterns = new Set();
-        this.seenIds = new Set();
-        this.seenOrder = [];
-        this.connected = false;
-        this.label = options.transport ?? this.resolveLabelFromEnv();
-        this.dedupeSize = options.dedupeSize ?? DEFAULT_DEDUPE_SIZE;
-    }
-};

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

@@ -1,218 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _eventtransportregistry = require("./event-transports/event-transport.registry");
-const _memorytransport = require("./event-transports/memory-transport");
-const _hybrideventbusclass = require("./hybrid-event-bus.class");
-function buildEvent(name = 'storage.folder.created', id = 'event-1') {
-    return {
-        id,
-        name,
-        module: 'storage',
-        entity: 'folder',
-        action: '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.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 _hybrideventbusclass.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 _hybrideventbusclass.HybridEventBus().getTransportLabel()).toBe('kafka');
-    });
-    it('should prefer an explicit transport option over the env value', ()=>{
-        process.env.USE_EVENT_LABEL = 'kafka';
-        expect(new _hybrideventbusclass.HybridEventBus({
-            transport: 'memory'
-        }).getTransportLabel()).toBe('memory');
-    });
-    it('should deliver a published event to a matching subscriber', async ()=>{
-        const bus = new _hybrideventbusclass.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 _hybrideventbusclass.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 _hybrideventbusclass.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.EventTransportRegistry.register('rabbitmq', ()=>broker);
-        const bus = new _hybrideventbusclass.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.EventTransportRegistry.register('kafka', ()=>{
-            throw new Error('kafkajs not installed');
-        });
-        const bus = new _hybrideventbusclass.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.EventTransportRegistry.register('rabbitmq', ()=>broker);
-        const bus = new _hybrideventbusclass.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.MemoryTransport.prototype, 'connect').mockRejectedValueOnce(new Error('boot failure'));
-        const bus = new _hybrideventbusclass.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.MemoryTransport.prototype, 'connect').mockRejectedValueOnce(new Error('boot failure'));
-        const bus = new _hybrideventbusclass.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.MemoryTransport.prototype, 'connect').mockRejectedValueOnce(new Error('boot failure'));
-        const bus = new _hybrideventbusclass.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 bind a subscription taken while disconnected on the broker that comes up later', async ()=>{
-        const broker = createFakeTransport('rabbitmq');
-        _eventtransportregistry.EventTransportRegistry.register('rabbitmq', ()=>broker);
-        const connectSpy = jest.spyOn(_memorytransport.MemoryTransport.prototype, 'connect').mockRejectedValueOnce(new Error('boot failure'));
-        const bus = new _hybrideventbusclass.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.EventTransportRegistry.register('rabbitmq', ()=>broker);
-        const bus = new _hybrideventbusclass.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 _hybrideventbusclass.HybridEventBus({
-            transport: 'memory'
-        });
-        await bus.connect();
-        await bus.close();
-        expect(bus.getActiveTransports()).toEqual([]);
-    });
-});

package/cjs/classes/index.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./api-controller.class"), exports);
-_export_star(require("./api-service.class"), exports);
-_export_star(require("./disabled-event-bus.class"), exports);
-_export_star(require("./domain-event.publisher"), exports);
-_export_star(require("./event-bus.registry"), exports);
-_export_star(require("./event-transports"), exports);
-_export_star(require("./handle-custome-db"), exports);
-_export_star(require("./hybrid-cache.class"), exports);
-_export_star(require("./hybrid-event-bus.class"), exports);
-_export_star(require("./winston.logger.class"), exports);
-_export_star(require("../constants/permissions"), 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;
-}