redis-smq 7.0.0-rc.7 → 7.0.0-rc.8

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## 7.0.0-rc.8 (2022-06-09)
+
+* Update docs (96a45e7)
+* Test consumers/producers event listeners (856e12d)
+* Implement consumers/producers event listeners (6f5d603)
+
 ## 7.0.0-rc.7 (2022-06-07)
 
 * Update redis keys prefix (a6ca852)

package/dist/index.d.ts

@@ -4,4 +4,3 @@ export { Producer } from './src/lib/producer/producer';
 export { Message } from './src/lib/message/message';
 export { MessageManager } from './src/lib/message-manager/message-manager';
 export { QueueManager } from './src/lib/queue-manager/queue-manager';
-export { registerProducerPlugin, registerConsumerPlugin, } from './src/plugins/plugins';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerConsumerPlugin = exports.registerProducerPlugin = exports.QueueManager = exports.MessageManager = exports.Message = exports.Producer = exports.Consumer = exports.events = void 0;
+exports.QueueManager = exports.MessageManager = exports.Message = exports.Producer = exports.Consumer = exports.events = void 0;
 var events_1 = require("./src/common/events/events");
 Object.defineProperty(exports, "events", { enumerable: true, get: function () { return events_1.events; } });
 var consumer_1 = require("./src/lib/consumer/consumer");
@@ -13,7 +13,4 @@ var message_manager_1 = require("./src/lib/message-manager/message-manager");
 Object.defineProperty(exports, "MessageManager", { enumerable: true, get: function () { return message_manager_1.MessageManager; } });
 var queue_manager_1 = require("./src/lib/queue-manager/queue-manager");
 Object.defineProperty(exports, "QueueManager", { enumerable: true, get: function () { return queue_manager_1.QueueManager; } });
-var plugins_1 = require("./src/plugins/plugins");
-Object.defineProperty(exports, "registerProducerPlugin", { enumerable: true, get: function () { return plugins_1.registerProducerPlugin; } });
-Object.defineProperty(exports, "registerConsumerPlugin", { enumerable: true, get: function () { return plugins_1.registerConsumerPlugin; } });
 //# sourceMappingURL=index.js.map

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

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

@@ -0,0 +1,13 @@
+"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

package/dist/src/config/configuration.js

@@ -5,12 +5,14 @@ const namespace_1 = require("./namespace");
 const redis_1 = require("./redis");
 const logger_1 = require("./logger");
 const messages_1 = require("./messages/messages");
+const event_listeners_1 = require("./event-listeners/event-listeners");
 function getConfiguration(config = {}) {
     return {
         namespace: (0, namespace_1.default)(config),
         redis: (0, redis_1.default)(config),
         logger: (0, logger_1.default)(config),
         messages: (0, messages_1.default)(config),
+        eventListeners: (0, event_listeners_1.EventListeners)(config),
     };
 }
 exports.getConfiguration = getConfiguration;

package/dist/src/config/event-listeners/event-listeners.d.ts

@@ -0,0 +1,2 @@
+import { IConfig, TRequiredEventListenersConfig } from '../../../types';
+export declare function EventListeners(userConfig: IConfig): TRequiredEventListenersConfig;

package/dist/src/config/event-listeners/event-listeners.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventListeners = void 0;
+const lodash_1 = require("lodash");
+const defaultConfig = {
+    consumerEventListeners: [],
+    producerEventListeners: [],
+};
+function EventListeners(userConfig) {
+    const { eventListeners = {} } = userConfig;
+    return (0, lodash_1.merge)({}, defaultConfig, eventListeners);
+}
+exports.EventListeners = EventListeners;
+//# sourceMappingURL=event-listeners.js.map

package/dist/src/lib/base.js

@@ -6,7 +6,6 @@ const events_1 = require("events");
 const events_2 = require("../common/events/events");
 const configuration_1 = require("../config/configuration");
 const redis_smq_common_1 = require("redis-smq-common");
-const plugins_1 = require("../plugins/plugins");
 class Base extends events_1.EventEmitter {
     constructor(config) {
         super();
@@ -38,7 +37,6 @@ class Base extends events_1.EventEmitter {
         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();
-        (0, plugins_1.disablePluginRegistration)();
     }
     registerEventsHandlers() {
         this.on(events_2.events.GOING_UP, () => this.logger.info(`Going up...`));

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

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

@@ -8,13 +8,13 @@ const consumer_queues_1 = require("../consumer-queues");
 const processing_queue_1 = require("./processing-queue");
 const dequeue_message_1 = require("./dequeue-message");
 const consume_message_1 = require("./consume-message");
-const plugins_1 = require("../../../plugins/plugins");
 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.plugins = [];
+        this.eventListeners = [];
         this.id = (0, uuid_1.v4)();
         this.consumer = consumer;
         this.consumerId = consumer.getId();
@@ -27,7 +27,7 @@ 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.initPlugins();
+        this.initEventListeners();
     }
     registerEventsHandlers() {
         this.on(events_1.events.UP, () => {
@@ -58,10 +58,10 @@ class MessageHandler extends events_2.EventEmitter {
         });
         this.on(events_1.events.DOWN, () => this.logger.info('Down.'));
     }
-    initPlugins() {
-        (0, plugins_1.getConsumerPlugins)().forEach((ctor) => {
-            const plugin = new ctor(this.sharedRedisClient, this.queue, this.consumer);
-            this.plugins.push(plugin);
+    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) {
@@ -78,12 +78,12 @@ class MessageHandler extends events_2.EventEmitter {
                 cb();
         });
     }
-    tearDownPlugins(cb) {
-        redis_smq_common_1.async.each(this.plugins, (plugin, index, done) => plugin.quit(done), (err) => {
+    tearDownEventListeners(cb) {
+        redis_smq_common_1.async.each(this.eventListeners, (listener, index, done) => listener.quit(done), (err) => {
             if (err)
                 cb(err);
             else {
-                this.plugins = [];
+                this.eventListeners = [];
                 cb();
             }
         });
@@ -113,7 +113,7 @@ class MessageHandler extends events_2.EventEmitter {
             this.powerManager.goingDown();
             redis_smq_common_1.async.waterfall([
                 (cb) => this.dequeueMessage.quit(cb),
-                (cb) => this.tearDownPlugins(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,7 @@ class MultiplexedMessageHandler extends message_handler_1.MessageHandler {
             this.powerManager.goingDown();
             redis_smq_common_1.async.waterfall([
                 (cb) => this.dequeueMessage.quit(cb),
-                (cb) => this.tearDownPlugins(cb),
+                (cb) => this.tearDownEventListeners(cb),
                 (cb) => this.cleanUp(cb),
             ], (err) => {
                 if (err)

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

@@ -1,12 +1,12 @@
-import { IConfig, IPlugin } from '../../../types';
+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 plugins: IPlugin[];
+    protected eventListeners: IEventListener[];
     constructor(config?: IConfig);
-    protected initPlugins: (cb: ICallback<void>) => void;
+    protected initEventListeners: (cb: ICallback<void>) => void;
     protected goingUp(): TUnaryFunction<ICallback<void>>[];
     protected goingDown(): TUnaryFunction<ICallback<void>>[];
     protected enqueue(redisClient: RedisClient, message: Message, cb: ICallback<void>): void;

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

@@ -6,33 +6,33 @@ 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 plugins_1 = require("../../plugins/plugins");
 const message_queue_required_error_1 = require("./errors/message-queue-required.error");
 const message_already_published_error_1 = require("./errors/message-already-published.error");
 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.plugins = [];
-        this.initPlugins = (cb) => {
+        this.eventListeners = [];
+        this.initEventListeners = (cb) => {
             const sharedRedisClient = this.getSharedRedisClient();
-            (0, plugins_1.getProducerPlugins)().forEach((ctor) => this.plugins.push(new ctor(sharedRedisClient, this)));
+            this.config.eventListeners.producerEventListeners.forEach((ctor) => this.eventListeners.push(new ctor(sharedRedisClient, this.id, new event_provider_1.EventProvider(this))));
             cb();
         };
         this.run();
     }
     goingUp() {
-        return super.goingUp().concat([this.initPlugins]);
+        return super.goingUp().concat([this.initEventListeners]);
     }
     goingDown() {
         return [
-            (cb) => redis_smq_common_1.async.each(this.plugins, (plugin, idx, done) => plugin.quit(done), (err) => {
+            (cb) => redis_smq_common_1.async.each(this.eventListeners, (listener, idx, done) => listener.quit(done), (err) => {
                 if (err)
                     cb(err);
                 else {
-                    this.plugins = [];
+                    this.eventListeners = [];
                     cb();
                 }
             }),

package/dist/types/index.d.ts

@@ -1,10 +1,16 @@
 /// <reference types="node" />
 import { Message } from '../src/lib/message/message';
 import { redisKeys } from '../src/common/redis-keys/redis-keys';
-import { Consumer } from '../src/lib/consumer/consumer';
-import { Producer } from '../src/lib/producer/producer';
 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;
+}
+export interface IEventListener {
+    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;
 }
@@ -16,11 +22,16 @@ export interface IMessagesConfigStore {
     acknowledged?: boolean | IMessagesConfigStoreOptions;
     deadLettered?: boolean | IMessagesConfigStoreOptions;
 }
+export interface IEventListenersConfig {
+    consumerEventListeners?: TConsumerEventListenerConstructor[];
+    producerEventListeners?: TProducerEventListenerConstructor[];
+}
 export interface IConfig {
     redis?: TRedisConfig;
     namespace?: string;
     logger?: TLoggerConfig;
     messages?: IMessagesConfig;
+    eventListeners?: IEventListenersConfig;
 }
 export interface IRequiredStoreMessagesParams extends Required<IMessagesConfigStoreOptions> {
     store: boolean;
@@ -29,10 +40,12 @@ export interface IRequiredMessagesConfigStore {
     acknowledged: IRequiredStoreMessagesParams;
     deadLettered: IRequiredStoreMessagesParams;
 }
+export declare type TRequiredEventListenersConfig = Required<IEventListenersConfig>;
 export interface IRequiredConfig extends Required<IConfig> {
     messages: {
         store: IRequiredMessagesConfigStore;
     };
+    eventListeners: TRequiredEventListenersConfig;
 }
 export declare type TPaginatedResponse<T> = {
     total: number;
@@ -126,11 +139,6 @@ export declare type TMessageMetadataJSON = {
     nextScheduledDelay: number;
     nextRetryDelay: number;
 };
-export interface IPlugin {
-    quit(cb: ICallback<void>): void;
-}
-export declare type TConsumerPluginConstructor = new (redisClient: RedisClient, queue: TQueueParams, consumer: Consumer) => IPlugin;
-export declare type TProducerPluginConstructor = new (redisClient: RedisClient, producer: Producer) => IPlugin;
 export declare type TMessageConsumeOptions = {
     ttl: number;
     retryThreshold: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redis-smq",
-  "version": "7.0.0-rc.7",
+  "version": "7.0.0-rc.8",
   "description": "A simple high-performance Redis message queue for Node.js.",
   "author": "Weyoss <weyoss@protonmail.com>",
   "license": "MIT",

package/dist/src/plugins/errors/plugin-registration-not-allowed-error.d.ts

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

package/dist/src/plugins/errors/plugin-registration-not-allowed-error.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginRegistrationNotAllowedError = void 0;
-const redis_smq_common_1 = require("redis-smq-common");
-class PluginRegistrationNotAllowedError extends redis_smq_common_1.errors.RedisSMQError {
-    constructor(msg = 'Plugin registration is only allowed before starting a consumer or a producer') {
-        super(msg);
-    }
-}
-exports.PluginRegistrationNotAllowedError = PluginRegistrationNotAllowedError;
-//# sourceMappingURL=plugin-registration-not-allowed-error.js.map

package/dist/src/plugins/plugins.d.ts

@@ -1,6 +0,0 @@
-import { TConsumerPluginConstructor, TProducerPluginConstructor } from '../../types';
-export declare function registerConsumerPlugin(PluginConstructor: TConsumerPluginConstructor): void;
-export declare function registerProducerPlugin(PluginConstructor: TProducerPluginConstructor): void;
-export declare function getConsumerPlugins(): TConsumerPluginConstructor[];
-export declare function getProducerPlugins(): TProducerPluginConstructor[];
-export declare function disablePluginRegistration(): void;

package/dist/src/plugins/plugins.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.disablePluginRegistration = exports.getProducerPlugins = exports.getConsumerPlugins = exports.registerProducerPlugin = exports.registerConsumerPlugin = void 0;
-const plugin_registration_not_allowed_error_1 = require("./errors/plugin-registration-not-allowed-error");
-let disabledPluginRegistration = false;
-const consumerPlugins = new Set();
-const producerPlugins = new Set();
-function registerConsumerPlugin(PluginConstructor) {
-    if (disabledPluginRegistration) {
-        throw new plugin_registration_not_allowed_error_1.PluginRegistrationNotAllowedError();
-    }
-    consumerPlugins.add(PluginConstructor);
-}
-exports.registerConsumerPlugin = registerConsumerPlugin;
-function registerProducerPlugin(PluginConstructor) {
-    if (disabledPluginRegistration) {
-        throw new plugin_registration_not_allowed_error_1.PluginRegistrationNotAllowedError();
-    }
-    producerPlugins.add(PluginConstructor);
-}
-exports.registerProducerPlugin = registerProducerPlugin;
-function getConsumerPlugins() {
-    return [...consumerPlugins];
-}
-exports.getConsumerPlugins = getConsumerPlugins;
-function getProducerPlugins() {
-    return [...producerPlugins];
-}
-exports.getProducerPlugins = getProducerPlugins;
-function disablePluginRegistration() {
-    if (!disabledPluginRegistration)
-        disabledPluginRegistration = true;
-}
-exports.disablePluginRegistration = disablePluginRegistration;
-//# sourceMappingURL=plugins.js.map