redis-smq 7.0.3 → 7.0.6

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # CHANGELOG
 
+## 7.0.6 (2022-08-08)
+
+* Improve consumer/producer shutdown handling (36278ce)
+* Update docs (51dfd16)
+* Update examples (208934b)
+* Fix tests (573e340)
+* Add and use ProducerNotRunningError error class (e89facd)
+* Fix a potential MaxListenersExceededWarning exception throwing (011a21b)
+* Make producers to be run manually before producing messages (c989449)
+
+## 7.0.5 (2022-07-20)
+
+* Remove code redundancies (55eec79)
+* Update event listeners docs (e308848)
+* Refactor IEventListener interface, clean up (14dbf30)
+
+## 7.0.4 (2022-07-14)
+
+* Fix dev dependencies (e42d072)
+* Update installation info (12c6170)
+* Make redis-smq-common as a peer dependency (ade08af)
+
 ## 7.0.3 (2022-07-13)
 
 * Fix consuming-messages/test00012 (4c9dfb8)

package/README.md

@@ -76,7 +76,7 @@ things more simple to use and removing any confusions that can occur while worki
 ## Installation
 
 ```text
-npm install redis-smq --save
+npm install redis-smq-common redis-smq --save
 ```
 
 Considerations:
@@ -141,25 +141,27 @@ Before publishing a message do not forget to set the destination queue of the me
 'use strict';
 const {Message, Producer} = require('redis-smq');
 
-const message = new Message();
-
-message
-    .setBody({hello: 'world'})
-    .setTTL(3600000) // in millis
-    .setQueue('test_queue');
-
-message.getId() // null
-
 const producer = new Producer();
-producer.produce(message, (err) => {
-    if (err) console.log(err);
-    else {
-      const msgId = message.getId(); // string
-      console.log('Successfully produced. Message ID is ', msgId);
-    }
-});
+producer.run((err) => {
+   if (err) throw err;
+   const message = new Message();
+   message
+           .setBody({hello: 'world'})
+           .setTTL(3600000) // in millis
+           .setQueue('test_queue');
+   message.getId() // null
+   producer.produce(message, (err) => {
+      if (err) console.log(err);
+      else {
+         const msgId = message.getId(); // string
+         console.log('Successfully produced. Message ID is ', msgId);
+      }
+   });
+})
 ```
 
+Starting with v7.0.6, before producing messages you need first to run your producer instance.
+
 See [Producer Reference](/docs/api/producer.md) for more details.
 
 #### Consumer Class

package/dist/misc/health-check/combined-run.js

@@ -1,40 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const __1 = require("../..");
 const redis_smq_common_1 = require("redis-smq-common");
-redis_smq_common_1.logger.setLogger(console);
-const config = {
-    logger: {
-        enabled: false,
-    },
-    messages: {
-        store: true,
-    },
-};
-const producer = new __1.Producer(config);
-const consumer = new __1.Consumer(config);
-consumer.run();
-const produce = (err) => {
+const __1 = require("../..");
+const events_1 = require("../../src/common/events/events");
+const queue = `queue_${Date.now()}`;
+const producer = new __1.Producer();
+const produceForever = (err) => {
     if (err)
         console.log(err);
     else {
-        setTimeout(() => {
-            const m = new __1.Message().setBody(Date.now()).setQueue(queue);
-            producer.produce(m, produce);
-        }, 1000);
+        if (producer.isGoingUp() || producer.isRunning()) {
+            const message = new __1.Message().setBody('some data').setQueue(queue);
+            producer.produce(message, produceForever);
+        }
     }
 };
-const queue = `queue_${Date.now()}`;
-__1.QueueManager.createInstance(config, (err, queueManager) => {
+const consumer = new __1.Consumer();
+consumer.consume(queue, (message, cb) => cb(), (err) => err && console.log(err));
+consumer.on(events_1.events.UP, () => {
+    console.log('UP');
+});
+consumer.on(events_1.events.DOWN, () => {
+    console.log('DOWN');
+});
+const serialOnOff = (cb) => redis_smq_common_1.async.waterfall([
+    (cb) => consumer.run((err) => cb(err)),
+    (cb) => consumer.shutdown((err) => cb(err)),
+    (cb) => consumer.run((err) => cb(err)),
+    (cb) => consumer.shutdown((err) => cb(err)),
+    (cb) => consumer.run((err) => cb(err)),
+    (cb) => consumer.shutdown((err) => cb(err)),
+    (cb) => consumer.run((err) => cb(err)),
+    (cb) => consumer.shutdown((err) => cb(err)),
+    (cb) => consumer.run((err) => cb(err)),
+    (cb) => consumer.shutdown((err) => cb(err)),
+], cb);
+let queueManager = null;
+redis_smq_common_1.async.waterfall([
+    (cb) => __1.QueueManager.createInstance({}, (err, instance) => {
+        if (err)
+            cb(err);
+        else {
+            queueManager = instance;
+            queueManager === null || queueManager === void 0 ? void 0 : queueManager.queue.create(queue, false, cb);
+        }
+    }),
+    (cb) => producer.run((err) => cb(err)),
+    (cb) => {
+        produceForever();
+        serialOnOff(cb);
+    },
+], (err) => {
     if (err)
         console.log(err);
     else {
-        queueManager === null || queueManager === void 0 ? void 0 : queueManager.queue.create(queue, false, (err) => {
-            if (err)
-                console.log(err);
-            else
-                consumer.consume(queue, (msg, cb) => cb(), produce);
-        });
+        producer.shutdown();
+        consumer.shutdown();
+        queueManager === null || queueManager === void 0 ? void 0 : queueManager.quit(() => void 0);
     }
 });
 //# sourceMappingURL=combined-run.js.map

package/dist/src/lib/base.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import { IConfig, IRequiredConfig } from '../../types';
+import { IConfig, IEventListener, IRequiredConfig } from '../../types';
 import { PowerManager, RedisClient } from 'redis-smq-common';
 import { ICallback, ICompatibleLogger, TFunction, TUnaryFunction } from 'redis-smq-common/dist/types';
 export declare abstract class Base extends EventEmitter {
@@ -9,15 +9,18 @@ export declare abstract class Base extends EventEmitter {
     protected sharedRedisClient: RedisClient | null;
     protected logger: ICompatibleLogger;
     protected config: IRequiredConfig;
-    constructor(config: IConfig);
+    protected eventListeners: IEventListener[];
+    constructor(config?: IConfig);
     protected setUpSharedRedisClient: (cb: ICallback<void>) => void;
     protected tearDownSharedRedisClient: (cb: ICallback<void>) => void;
-    protected registerEventsHandlers(): void;
+    protected registerSystemEventListeners(): void;
     protected goingUp(): TFunction[];
     protected up(cb?: ICallback<boolean>): void;
     protected goingDown(): TUnaryFunction<ICallback<void>>[];
     protected down(cb?: ICallback<boolean>): void;
     protected getSharedRedisClient(): RedisClient;
+    protected registerEventListeners(Ctors: (new () => IEventListener)[], cb: ICallback<void>): void;
+    protected tearDownEventListeners: (cb: ICallback<void>) => void;
     handleError(err: Error): void;
     run(cb?: ICallback<boolean>): void;
     shutdown(cb?: ICallback<boolean>): void;

package/dist/src/lib/base.js

@@ -7,9 +7,10 @@ const events_2 = require("../common/events/events");
 const configuration_1 = require("../config/configuration");
 const redis_smq_common_1 = require("redis-smq-common");
 class Base extends events_1.EventEmitter {
-    constructor(config) {
+    constructor(config = {}) {
         super();
         this.sharedRedisClient = null;
+        this.eventListeners = [];
         this.setUpSharedRedisClient = (cb) => {
             (0, redis_smq_common_1.createClientInstance)(this.config.redis, (err, client) => {
                 if (err)
@@ -32,13 +33,23 @@ class Base extends events_1.EventEmitter {
             else
                 cb();
         };
+        this.tearDownEventListeners = (cb) => {
+            redis_smq_common_1.async.each(this.eventListeners, (listener, index, done) => listener.quit(done), (err) => {
+                if (err)
+                    cb(err);
+                else {
+                    this.eventListeners = [];
+                    cb();
+                }
+            });
+        };
         this.id = (0, uuid_1.v4)();
         this.powerManager = new redis_smq_common_1.PowerManager(false);
         this.config = (0, configuration_1.getConfiguration)(config);
         this.logger = redis_smq_common_1.logger.getNamespacedLogger(this.config.logger, `${this.constructor.name.toLowerCase()}:${this.id}`);
-        this.registerEventsHandlers();
+        this.registerSystemEventListeners();
     }
-    registerEventsHandlers() {
+    registerSystemEventListeners() {
         this.on(events_2.events.GOING_UP, () => this.logger.info(`Going up...`));
         this.on(events_2.events.UP, () => this.logger.info(`Up and running...`));
         this.on(events_2.events.GOING_DOWN, () => this.logger.info(`Going down...`));
@@ -54,7 +65,7 @@ class Base extends events_1.EventEmitter {
         cb && cb(null, true);
     }
     goingDown() {
-        return [this.tearDownSharedRedisClient];
+        return [this.tearDownEventListeners, this.tearDownSharedRedisClient];
     }
     down(cb) {
         this.powerManager.commit();
@@ -66,52 +77,59 @@ class Base extends events_1.EventEmitter {
             throw new redis_smq_common_1.errors.PanicError('Expected an instance of RedisClient');
         return this.sharedRedisClient;
     }
+    registerEventListeners(Ctors, cb) {
+        redis_smq_common_1.async.eachOf(Ctors, (ctor, key, done) => {
+            const instance = new ctor();
+            instance.init({
+                instanceId: this.id,
+                eventProvider: this,
+                config: this.getConfig(),
+            }, (err) => {
+                if (err)
+                    done(err);
+                else {
+                    this.eventListeners.push(instance);
+                    done();
+                }
+            });
+        }, cb);
+    }
     handleError(err) {
         if (this.powerManager.isGoingUp() || this.powerManager.isRunning()) {
             throw err;
         }
     }
     run(cb) {
-        if (this.powerManager.isGoingDown()) {
-            this.once(events_2.events.DOWN, () => this.run(cb));
+        const r = this.powerManager.goingUp();
+        if (r) {
+            this.emit(events_2.events.GOING_UP);
+            const tasks = this.goingUp();
+            redis_smq_common_1.async.waterfall(tasks, (err) => {
+                if (err) {
+                    if (cb)
+                        cb(err);
+                    else
+                        this.emit(events_2.events.ERROR, err);
+                }
+                else
+                    this.up(cb);
+            });
         }
         else {
-            const r = this.powerManager.goingUp();
-            if (r) {
-                this.emit(events_2.events.GOING_UP);
-                const tasks = this.goingUp();
-                redis_smq_common_1.async.waterfall(tasks, (err) => {
-                    if (err) {
-                        if (cb)
-                            cb(err);
-                        else
-                            this.emit(events_2.events.ERROR, err);
-                    }
-                    else
-                        this.up(cb);
-                });
-            }
-            else {
-                cb && cb(null, r);
-            }
+            cb && cb(null, r);
         }
     }
     shutdown(cb) {
-        if (this.powerManager.isGoingUp()) {
-            this.once(events_2.events.UP, () => this.shutdown(cb));
-        }
-        else {
-            const r = this.powerManager.goingDown();
-            if (r) {
-                this.emit(events_2.events.GOING_DOWN);
-                const tasks = this.goingDown();
-                redis_smq_common_1.async.waterfall(tasks, () => {
-                    this.down(cb);
-                });
-            }
-            else
-                cb && cb(null, r);
+        const r = this.powerManager.goingDown();
+        if (r) {
+            this.emit(events_2.events.GOING_DOWN);
+            const tasks = this.goingDown();
+            redis_smq_common_1.async.waterfall(tasks, () => {
+                this.down(cb);
+            });
         }
+        else
+            cb && cb(null, r);
     }
     isRunning() {
         return this.powerManager.isRunning();

package/dist/src/lib/consumer/consumer-message-handler/message-handler.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { IEventListener, IRequiredConfig, TConsumerMessageHandler, TQueueParams } from '../../../../types';
+import { IRequiredConfig, TConsumerMessageHandler, TQueueParams } from '../../../../types';
 import { EventEmitter } from 'events';
 import { TCleanUpStatus } from './processing-queue';
 import { DequeueMessage } from './dequeue-message';
@@ -19,12 +19,9 @@ export declare class MessageHandler extends EventEmitter {
     protected dequeueMessage: DequeueMessage;
     protected consumeMessage: ConsumeMessage;
     protected handler: TConsumerMessageHandler;
-    protected eventListeners: IEventListener[];
     constructor(consumer: Consumer, queue: TQueueParams, handler: TConsumerMessageHandler, dequeueRedisClient: RedisClient, sharedRedisClient: RedisClient, logger: ICompatibleLogger);
     protected registerEventsHandlers(): void;
-    protected initEventListeners(): void;
     protected cleanUp(cb: ICallback<void>): void;
-    protected tearDownEventListeners(cb: ICallback<void>): void;
     handleError(err: Error): void;
     dequeue(): void;
     run(cb: ICallback<void>): void;

package/dist/src/lib/consumer/consumer-message-handler/message-handler.js

@@ -10,11 +10,9 @@ const dequeue_message_1 = require("./dequeue-message");
 const consume_message_1 = require("./consume-message");
 const redis_smq_common_1 = require("redis-smq-common");
 const retry_message_1 = require("./retry-message");
-const event_provider_1 = require("../../../common/event-listeners/event-provider");
 class MessageHandler extends events_2.EventEmitter {
     constructor(consumer, queue, handler, dequeueRedisClient, sharedRedisClient, logger) {
         super();
-        this.eventListeners = [];
         this.id = (0, uuid_1.v4)();
         this.consumer = consumer;
         this.consumerId = consumer.getId();
@@ -27,7 +25,6 @@ class MessageHandler extends events_2.EventEmitter {
         this.dequeueMessage = new dequeue_message_1.DequeueMessage(this, dequeueRedisClient);
         this.consumeMessage = new consume_message_1.ConsumeMessage(this, dequeueRedisClient, logger);
         this.registerEventsHandlers();
-        this.initEventListeners();
     }
     registerEventsHandlers() {
         this.on(events_1.events.UP, () => {
@@ -58,12 +55,6 @@ class MessageHandler extends events_2.EventEmitter {
         });
         this.on(events_1.events.DOWN, () => this.logger.info('Down.'));
     }
-    initEventListeners() {
-        this.getConfig().eventListeners.consumerEventListeners.forEach((ctor) => {
-            const plugin = new ctor(this.sharedRedisClient, this.consumerId, this.queue, new event_provider_1.EventProvider(this));
-            this.eventListeners.push(plugin);
-        });
-    }
     cleanUp(cb) {
         MessageHandler.cleanUp(this.getConfig(), this.sharedRedisClient, this.consumerId, this.queue, undefined, (err, reply) => {
             if (err)
@@ -78,16 +69,6 @@ class MessageHandler extends events_2.EventEmitter {
                 cb();
         });
     }
-    tearDownEventListeners(cb) {
-        redis_smq_common_1.async.each(this.eventListeners, (listener, index, done) => listener.quit(done), (err) => {
-            if (err)
-                cb(err);
-            else {
-                this.eventListeners = [];
-                cb();
-            }
-        });
-    }
     handleError(err) {
         if (this.powerManager.isRunning() || this.powerManager.isGoingUp()) {
             this.emit(events_1.events.ERROR, err);
@@ -113,7 +94,6 @@ class MessageHandler extends events_2.EventEmitter {
             this.powerManager.goingDown();
             redis_smq_common_1.async.waterfall([
                 (cb) => this.dequeueMessage.quit(cb),
-                (cb) => this.tearDownEventListeners(cb),
                 (cb) => this.cleanUp(cb),
                 (cb) => this.dequeueRedisClient.halt(cb),
             ], (err) => {

package/dist/src/lib/consumer/consumer-message-handler/multiplexed-message-handler/multiplexed-message-handler.js

@@ -23,7 +23,6 @@ class MultiplexedMessageHandler extends message_handler_1.MessageHandler {
             this.powerManager.goingDown();
             redis_smq_common_1.async.waterfall([
                 (cb) => this.dequeueMessage.quit(cb),
-                (cb) => this.tearDownEventListeners(cb),
                 (cb) => this.cleanUp(cb),
             ], (err) => {
                 if (err)

package/dist/src/lib/consumer/consumer.d.ts

@@ -13,6 +13,7 @@ export declare class Consumer extends Base {
     protected setUpHeartbeat: (cb: ICallback<void>) => void;
     protected tearDownHeartbeat: (cb: ICallback<void>) => void;
     protected setUpConsumerWorkers: (cb: ICallback<void>) => void;
+    protected initConsumerEventListeners: (cb: ICallback<void>) => void;
     protected tearDownConsumerWorkers: (cb: ICallback<void>) => void;
     protected runMessageHandlers: (cb: ICallback<void>) => void;
     protected shutdownMessageHandlers: (cb: ICallback<void>) => void;

package/dist/src/lib/consumer/consumer.js

@@ -55,6 +55,9 @@ class Consumer extends base_1.Base {
             this.workerRunner.addWorker(new schedule_worker_1.default(redisClient, true));
             this.workerRunner.run();
         };
+        this.initConsumerEventListeners = (cb) => {
+            this.registerEventListeners(this.config.eventListeners.consumerEventListeners, cb);
+        };
         this.tearDownConsumerWorkers = (cb) => {
             if (this.workerRunner) {
                 this.workerRunner.quit(() => {
@@ -87,6 +90,7 @@ class Consumer extends base_1.Base {
             .goingUp()
             .concat([
             this.setUpHeartbeat,
+            this.initConsumerEventListeners,
             this.runMessageHandlers,
             this.setUpConsumerWorkers,
         ]);

package/dist/src/lib/producer/errors/producer-not-running.error.d.ts

@@ -0,0 +1,4 @@
+import { errors } from 'redis-smq-common';
+export declare class ProducerNotRunningError extends errors.RedisSMQError {
+    constructor(msg?: string);
+}

package/dist/src/lib/producer/errors/producer-not-running.error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProducerNotRunningError = void 0;
+const redis_smq_common_1 = require("redis-smq-common");
+class ProducerNotRunningError extends redis_smq_common_1.errors.RedisSMQError {
+    constructor(msg = `Producer instance is not running. Before producing messages you need to run your producer instance.`) {
+        super(msg);
+    }
+}
+exports.ProducerNotRunningError = ProducerNotRunningError;
+//# sourceMappingURL=producer-not-running.error.js.map

package/dist/src/lib/producer/producer.d.ts

@@ -1,14 +1,10 @@
-import { IConfig, IEventListener } from '../../../types';
 import { Message } from '../message/message';
 import { Base } from '../base';
 import { RedisClient } from 'redis-smq-common';
 import { ICallback, TUnaryFunction } from 'redis-smq-common/dist/types';
 export declare class Producer extends Base {
-    protected eventListeners: IEventListener[];
-    constructor(config?: IConfig);
-    protected initEventListeners: (cb: ICallback<void>) => void;
+    protected initProducerEventListeners: (cb: ICallback<void>) => void;
     protected goingUp(): TUnaryFunction<ICallback<void>>[];
-    protected goingDown(): TUnaryFunction<ICallback<void>>[];
     protected enqueue(redisClient: RedisClient, message: Message, cb: ICallback<void>): void;
     produce(message: Message, cb: ICallback<void>): void;
 }

package/dist/src/lib/producer/producer.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Producer = void 0;
 const events_1 = require("../../common/events/events");
 const base_1 = require("../base");
-const redis_smq_common_1 = require("redis-smq-common");
 const redis_keys_1 = require("../../common/redis-keys/redis-keys");
 const message_not_published_error_1 = require("./errors/message-not-published.error");
 const message_queue_required_error_1 = require("./errors/message-queue-required.error");
@@ -11,32 +10,16 @@ const message_already_published_error_1 = require("./errors/message-already-publ
 const redis_client_1 = require("../../common/redis-client/redis-client");
 const schedule_message_1 = require("./schedule-message");
 const queue_1 = require("../queue-manager/queue");
-const event_provider_1 = require("../../common/event-listeners/event-provider");
+const producer_not_running_error_1 = require("./errors/producer-not-running.error");
 class Producer extends base_1.Base {
-    constructor(config = {}) {
-        super(config);
-        this.eventListeners = [];
-        this.initEventListeners = (cb) => {
-            const sharedRedisClient = this.getSharedRedisClient();
-            this.config.eventListeners.producerEventListeners.forEach((ctor) => this.eventListeners.push(new ctor(sharedRedisClient, this.id, new event_provider_1.EventProvider(this))));
-            cb();
+    constructor() {
+        super(...arguments);
+        this.initProducerEventListeners = (cb) => {
+            this.registerEventListeners(this.config.eventListeners.producerEventListeners, cb);
         };
-        this.run();
     }
     goingUp() {
-        return super.goingUp().concat([this.initEventListeners]);
-    }
-    goingDown() {
-        return [
-            (cb) => redis_smq_common_1.async.each(this.eventListeners, (listener, idx, done) => listener.quit(done), (err) => {
-                if (err)
-                    cb(err);
-                else {
-                    this.eventListeners = [];
-                    cb();
-                }
-            }),
-        ].concat(super.goingDown());
+        return super.goingUp().concat([this.initProducerEventListeners]);
     }
     enqueue(redisClient, message, cb) {
         var _a;
@@ -71,18 +54,20 @@ class Producer extends base_1.Base {
             cb(new message_already_published_error_1.MessageAlreadyPublishedError());
         }
         else {
-            const queueParams = queue_1.Queue.getParams(this.config, queue);
-            message.setQueue(queueParams);
-            const messageId = message.getSetMetadata().getId();
-            const callback = (err) => {
-                if (err)
-                    cb(err);
-                else {
-                    this.emit(events_1.events.MESSAGE_PUBLISHED, message);
-                    cb();
-                }
-            };
-            const proceed = () => {
+            if (!this.powerManager.isUp())
+                cb(new producer_not_running_error_1.ProducerNotRunningError());
+            else {
+                const queueParams = queue_1.Queue.getParams(this.config, queue);
+                message.setQueue(queueParams);
+                const messageId = message.getSetMetadata().getId();
+                const callback = (err) => {
+                    if (err)
+                        cb(err);
+                    else {
+                        this.emit(events_1.events.MESSAGE_PUBLISHED, message);
+                        cb();
+                    }
+                };
                 const redisClient = this.getSharedRedisClient();
                 if (message.isSchedulable()) {
                     (0, schedule_message_1.scheduleMessage)(redisClient, message, (err) => {
@@ -104,17 +89,7 @@ class Producer extends base_1.Base {
                         }
                     });
                 }
-            };
-            if (!this.powerManager.isUp()) {
-                if (this.powerManager.isGoingUp()) {
-                    this.once(events_1.events.UP, proceed);
-                }
-                else {
-                    cb(new redis_smq_common_1.errors.PanicError(`Producer ID ${this.getId()} is not running`));
-                }
             }
-            else
-                proceed();
         }
     }
 }

package/dist/types/index.d.ts

@@ -1,16 +1,18 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Message } from '../src/lib/message/message';
 import { redisKeys } from '../src/common/redis-keys/redis-keys';
 import { ICallback, TLoggerConfig, TRedisConfig } from 'redis-smq-common/dist/types';
-import { RedisClient } from 'redis-smq-common';
-export interface IEventProvider {
-    on(event: string, listener: (...args: any[]) => void): void;
-}
+import { EventEmitter } from 'events';
+export declare type TEventListenerInitArgs = {
+    eventProvider: EventEmitter;
+    config: IRequiredConfig;
+    instanceId: string;
+};
 export interface IEventListener {
+    init(args: TEventListenerInitArgs, cb: ICallback<void>): void;
     quit(cb: ICallback<void>): void;
 }
-export declare type TConsumerEventListenerConstructor = new (redisClient: RedisClient, consumerId: string, queue: TQueueParams, eventProvider: IEventProvider) => IEventListener;
-export declare type TProducerEventListenerConstructor = new (redisClient: RedisClient, producerId: string, eventProvider: IEventProvider) => IEventListener;
 export interface IMessagesConfig {
     store?: boolean | IMessagesConfigStore;
 }
@@ -23,8 +25,8 @@ export interface IMessagesConfigStore {
     deadLettered?: boolean | IMessagesConfigStoreOptions;
 }
 export interface IEventListenersConfig {
-    consumerEventListeners?: TConsumerEventListenerConstructor[];
-    producerEventListeners?: TProducerEventListenerConstructor[];
+    consumerEventListeners?: (new () => IEventListener)[];
+    producerEventListeners?: (new () => IEventListener)[];
 }
 export interface IConfig {
     redis?: TRedisConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redis-smq",
-  "version": "7.0.3",
+  "version": "7.0.6",
   "description": "A simple high-performance Redis message queue for Node.js.",
   "author": "Weyoss <weyoss@protonmail.com>",
   "license": "MIT",
@@ -36,9 +36,11 @@
     "bluebird": "3.7.2",
     "cron-parser": "3.5.0",
     "lodash": "4.17.21",
-    "redis-smq-common": "1.0.1",
     "uuid": "8.3.2"
   },
+  "peerDependencies": {
+    "redis-smq-common": "^1.0.1"
+  },
   "devDependencies": {
     "@types/bluebird": "3.5.36",
     "@types/debug": "4.1.7",
@@ -57,6 +59,7 @@
     "jest": "27.2.4",
     "lint-staged": "11.1.2",
     "prettier": "2.4.1",
+    "redis-smq-common": "^1.0.1",
     "supertest": "6.1.6",
     "ts-jest": "27.0.5",
     "ts-node": "10.2.1",

package/dist/misc/health-check/on-off.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/misc/health-check/on-off.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const redis_smq_common_1 = require("redis-smq-common");
-const __1 = require("../..");
-const events_1 = require("../../src/common/events/events");
-const queue = `queue_${Date.now()}`;
-const producer = new __1.Producer();
-const produceForever = (err) => {
-    if (err)
-        console.log(err);
-    else {
-        if (producer.isGoingUp() || producer.isRunning()) {
-            const message = new __1.Message().setBody('some data').setQueue(queue);
-            producer.produce(message, produceForever);
-        }
-    }
-};
-const consumer = new __1.Consumer();
-consumer.consume(queue, (message, cb) => cb(), (err) => err && console.log(err));
-consumer.on(events_1.events.UP, () => {
-    console.log('UP');
-});
-consumer.on(events_1.events.DOWN, () => {
-    console.log('DOWN');
-});
-const serialOnOff = (cb) => redis_smq_common_1.async.waterfall([
-    (cb) => consumer.run((err) => cb(err)),
-    (cb) => consumer.shutdown((err) => cb(err)),
-    (cb) => consumer.run((err) => cb(err)),
-    (cb) => consumer.shutdown((err) => cb(err)),
-    (cb) => consumer.run((err) => cb(err)),
-    (cb) => consumer.shutdown((err) => cb(err)),
-    (cb) => consumer.run((err) => cb(err)),
-    (cb) => consumer.shutdown((err) => cb(err)),
-    (cb) => consumer.run((err) => cb(err)),
-    (cb) => consumer.shutdown((err) => cb(err)),
-], cb);
-redis_smq_common_1.async.waterfall([
-    (cb) => __1.QueueManager.createInstance({}, (err, queueManager) => {
-        if (err)
-            cb(err);
-        else
-            queueManager === null || queueManager === void 0 ? void 0 : queueManager.queue.create(queue, false, cb);
-    }),
-    (cb) => {
-        produceForever();
-        serialOnOff(cb);
-    },
-], (err) => {
-    if (err)
-        console.log(err);
-    else {
-        producer.shutdown();
-        consumer.shutdown();
-        __1.QueueManager.createInstance({}, (err, queueManager) => queueManager === null || queueManager === void 0 ? void 0 : queueManager.quit(() => void 0));
-    }
-});
-//# sourceMappingURL=on-off.js.map

package/dist/src/common/event-listeners/event-provider.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="node" />
-import { IEventProvider } from '../../../types';
-import { EventEmitter } from 'events';
-export declare class EventProvider implements IEventProvider {
-    protected eventEmitter: EventEmitter;
-    constructor(eventEmitter: EventEmitter);
-    on(event: string, listener: (...args: any[]) => void): void;
-}

package/dist/src/common/event-listeners/event-provider.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventProvider = void 0;
-class EventProvider {
-    constructor(eventEmitter) {
-        this.eventEmitter = eventEmitter;
-    }
-    on(event, listener) {
-        this.eventEmitter.on(event, listener);
-    }
-}
-exports.EventProvider = EventProvider;
-//# sourceMappingURL=event-provider.js.map