redis-smq-common/dist/esm/src/event-bus/event-bus-redis.js

RedisSMQ Common Library provides many components that are mainly used by RedisSMQ and RedisSMQ Monitor.

import { async } from '../async/index.js';
import { EventEmitter } from '../event/index.js';
import { createRedisClient, } from '../redis-client/index.js';
import { EventBusNotConnectedError } from './errors/index.js';
export class EventBusRedis extends EventEmitter {
    connected = false;
    pubClient;
    subClient;
    constructor(pubClient, subClient) {
        super();
        this.pubClient = pubClient;
        this.pubClient.on('error', (err) => {
            this.eventEmitter.emit('error', err);
        });
        this.subClient = subClient;
        this.subClient.on('message', (channel, message) => {
            this.eventEmitter.emit(String(channel), ...JSON.parse(message));
        });
        this.subClient.on('error', (err) => {
            this.eventEmitter.emit('error', err);
        });
        this.connected = true;
    }
    emit(event, ...args) {
        if (!this.connected) {
            this.eventEmitter.emit('error', new EventBusNotConnectedError());
            return false;
        }
        this.pubClient.publish(String(event), JSON.stringify(args), () => void 0);
        return true;
    }
    on(event, listener) {
        if (event === 'error') {
            super.on('error', listener);
            return this;
        }
        if (!this.connected) {
            this.eventEmitter.emit('error', new EventBusNotConnectedError());
            return this;
        }
        this.subClient.subscribe(String(event));
        super.on(event, listener);
        return this;
    }
    once(event, listener) {
        if (event === 'error') {
            super.once('error', listener);
            return this;
        }
        if (!this.connected) {
            this.eventEmitter.emit('error', new EventBusNotConnectedError());
            return this;
        }
        this.subClient.subscribe(String(event));
        super.once(event, listener);
        return this;
    }
    removeAllListeners(event) {
        if (event === 'error') {
            super.removeAllListeners('error');
            return this;
        }
        if (!this.connected) {
            this.eventEmitter.emit('error', new EventBusNotConnectedError());
            return this;
        }
        if (event)
            this.subClient.unsubscribe(String(event));
        else
            this.subClient.unsubscribe();
        super.removeAllListeners(event);
        return this;
    }
    removeListener(event, listener) {
        if (event === 'error') {
            super.removeListener('error', listener);
            return this;
        }
        if (!this.connected) {
            this.eventEmitter.emit('error', new EventBusNotConnectedError());
            return this;
        }
        super.removeListener(event, listener);
        return this;
    }
    shutdown(cb) {
        if (this.connected) {
            async.series([
                (cb) => this.subClient.halt(() => cb()),
                (cb) => this.pubClient.halt(() => cb()),
            ], () => {
                this.connected = false;
                cb();
            });
        }
        else
            cb();
    }
    static createInstance(config, cb) {
        let pubClient = null;
        let subClient = null;
        async.series([
            (cb) => createRedisClient(config, (err, client) => {
                if (err)
                    cb(err);
                else {
                    pubClient = client;
                    cb();
                }
            }),
            (cb) => createRedisClient(config, (err, client) => {
                if (err)
                    cb(err);
                else {
                    subClient = client;
                    cb();
                }
            }),
        ], (err) => {
            if (err) {
                if (pubClient)
                    pubClient.halt(() => void 0);
                if (subClient)
                    subClient.halt(() => void 0);
                cb(err);
            }
            else if (!pubClient || !subClient)
                cb(new Error());
            else {
                const instance = new EventBusRedis(pubClient, subClient);
                cb(null, instance);
            }
        });
    }
}
//# sourceMappingURL=event-bus-redis.js.map