redis-smq 7.0.4 → 7.0.5

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## 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)

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;
+    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

@@ -10,6 +10,7 @@ class Base extends events_1.EventEmitter {
     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,6 +77,23 @@ 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;

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/producer.d.ts

@@ -1,14 +1,12 @@
-import { IConfig, IEventListener } from '../../../types';
+import { IConfig } 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

@@ -11,32 +11,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");
 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();
+        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;

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.4",
+  "version": "7.0.5",
   "description": "A simple high-performance Redis message queue for Node.js.",
   "author": "Weyoss <weyoss@protonmail.com>",
   "license": "MIT",

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