redis-smq 8.0.0-rc.23 → 8.0.0-rc.24

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 
 
+## [8.0.0-rc.24](https://github.com/weyoss/redis-smq/compare/v8.0.0-rc.23...v8.0.0-rc.24) (2024-05-15)
+
+
+### Bug Fixes
+
+* **namespace:** replace generic error in getNamespaceQueues() ([aa9c8e5](https://github.com/weyoss/redis-smq/commit/aa9c8e5a125bdf1fc8e200263618693671219882))
+* **queue-rate-limit:** always validate queue existence ([538cf78](https://github.com/weyoss/redis-smq/commit/538cf786b3b3131f137d1488d6d130323acb571d))
+
+
+### Documentation
+
+* add new error classes reference ([6c39625](https://github.com/weyoss/redis-smq/commit/6c3962589537a83fe345e349743a798e73e751a6))
+
+
+### Codebase Refactoring
+
+* **queue-rate-limit:** move QueueRateLimit.set() logic to LUA ([d104a9c](https://github.com/weyoss/redis-smq/commit/d104a9c038ea321e5e18049bffefc54850d4294f))
+* **queue:** return the original error instance ([14228ec](https://github.com/weyoss/redis-smq/commit/14228ec255776cabf2a9202078cd016f80b5f5da))
+
 ## [8.0.0-rc.23](https://github.com/weyoss/redis-smq/compare/v8.0.0-rc.22...v8.0.0-rc.23) (2024-05-10)
 
 

package/dist/cjs/src/common/redis-client/scripts/lua/set-queue-rate-limit.lua

@@ -0,0 +1,14 @@
+local keyQueueProperties = KEYS[1]
+
+---
+
+local EQueuePropertyRateLimit = ARGV[1]
+local rateLimit = ARGV[2]
+
+local result = redis.call("EXISTS", keyQueueProperties)
+if result == 0 then
+    return 'QUEUE_NOT_FOUND';
+end
+
+redis.call("HSET", keyQueueProperties, EQueuePropertyRateLimit, rateLimit)
+return 'OK'

package/dist/cjs/src/common/redis-client/scripts/scripts.d.ts

@@ -11,6 +11,7 @@ export declare enum ELuaScriptName {
     DELETE_MESSAGE = "DELETE_MESSAGE",
     FETCH_MESSAGE_FOR_PROCESSING = "FETCH_MESSAGE_FOR_PROCESSING",
     DELETE_CONSUMER_GROUP = "DELETE_CONSUMER_GROUP",
-    CLEANUP_OFFLINE_CONSUMER = "CLEANUP_OFFLINE_CONSUMER"
+    CLEANUP_OFFLINE_CONSUMER = "CLEANUP_OFFLINE_CONSUMER",
+    SET_QUEUE_RATE_LIMIT = "SET_QUEUE_RATE_LIMIT"
 }
 //# sourceMappingURL=scripts.d.ts.map

package/dist/cjs/src/common/redis-client/scripts/scripts.js

@@ -42,6 +42,7 @@ var ELuaScriptName;
     ELuaScriptName["FETCH_MESSAGE_FOR_PROCESSING"] = "FETCH_MESSAGE_FOR_PROCESSING";
     ELuaScriptName["DELETE_CONSUMER_GROUP"] = "DELETE_CONSUMER_GROUP";
     ELuaScriptName["CLEANUP_OFFLINE_CONSUMER"] = "CLEANUP_OFFLINE_CONSUMER";
+    ELuaScriptName["SET_QUEUE_RATE_LIMIT"] = "SET_QUEUE_RATE_LIMIT";
 })(ELuaScriptName = exports.ELuaScriptName || (exports.ELuaScriptName = {}));
 redis_smq_common_1.RedisClientAbstract.addScript(ELuaScriptName.PUBLISH_SCHEDULED_MESSAGE, fs
     .readFileSync((0, path_1.resolve)((0, redis_smq_common_1.getDirname)(), './lua/publish-scheduled-message.lua'))
@@ -78,4 +79,7 @@ redis_smq_common_1.RedisClientAbstract.addScript(ELuaScriptName.DELETE_CONSUMER_
 redis_smq_common_1.RedisClientAbstract.addScript(ELuaScriptName.CLEANUP_OFFLINE_CONSUMER, fs
     .readFileSync((0, path_1.resolve)((0, redis_smq_common_1.getDirname)(), './lua/cleanup-offline-consumer.lua'))
     .toString());
+redis_smq_common_1.RedisClientAbstract.addScript(ELuaScriptName.SET_QUEUE_RATE_LIMIT, fs
+    .readFileSync((0, path_1.resolve)((0, redis_smq_common_1.getDirname)(), './lua/set-queue-rate-limit.lua'))
+    .toString());
 //# sourceMappingURL=scripts.js.map

package/dist/cjs/src/lib/namespace/errors/index.d.ts

@@ -1,3 +1,4 @@
 export { NamespaceNotFoundError } from './namespace-not-found.error.js';
 export { NamespaceError } from './namespace.error.js';
+export { NamespaceInvalidNamespaceError } from './namespace-invalid-namespace.error.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/src/lib/namespace/errors/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NamespaceError = exports.NamespaceNotFoundError = void 0;
+exports.NamespaceInvalidNamespaceError = exports.NamespaceError = exports.NamespaceNotFoundError = void 0;
 var namespace_not_found_error_js_1 = require("./namespace-not-found.error.js");
 Object.defineProperty(exports, "NamespaceNotFoundError", { enumerable: true, get: function () { return namespace_not_found_error_js_1.NamespaceNotFoundError; } });
 var namespace_error_js_1 = require("./namespace.error.js");
 Object.defineProperty(exports, "NamespaceError", { enumerable: true, get: function () { return namespace_error_js_1.NamespaceError; } });
+var namespace_invalid_namespace_error_js_1 = require("./namespace-invalid-namespace.error.js");
+Object.defineProperty(exports, "NamespaceInvalidNamespaceError", { enumerable: true, get: function () { return namespace_invalid_namespace_error_js_1.NamespaceInvalidNamespaceError; } });
 //# sourceMappingURL=index.js.map

package/dist/cjs/src/lib/namespace/errors/namespace-invalid-namespace.error.d.ts

@@ -0,0 +1,4 @@
+import { NamespaceError } from './namespace.error.js';
+export declare class NamespaceInvalidNamespaceError extends NamespaceError {
+}
+//# sourceMappingURL=namespace-invalid-namespace.error.d.ts.map

package/dist/cjs/src/lib/namespace/errors/namespace-invalid-namespace.error.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NamespaceInvalidNamespaceError = void 0;
+const namespace_error_js_1 = require("./namespace.error.js");
+class NamespaceInvalidNamespaceError extends namespace_error_js_1.NamespaceError {
+}
+exports.NamespaceInvalidNamespaceError = NamespaceInvalidNamespaceError;
+//# sourceMappingURL=namespace-invalid-namespace.error.js.map

package/dist/cjs/src/lib/namespace/namespace.js

@@ -39,7 +39,7 @@ class Namespace {
     getNamespaceQueues(namespace, cb) {
         const ns = redis_keys_js_1.redisKeys.validateRedisKey(namespace);
         if (ns instanceof Error)
-            cb(ns);
+            cb(new index_js_2.NamespaceInvalidNamespaceError());
         else {
             this.redisClient.getSetInstance((err, client) => {
                 if (err)
@@ -80,7 +80,7 @@ class Namespace {
     delete(namespace, cb) {
         const ns = redis_keys_js_1.redisKeys.validateRedisKey(namespace);
         if (ns instanceof Error)
-            cb(ns);
+            cb(new index_js_2.NamespaceInvalidNamespaceError());
         else {
             this.redisClient.getSetInstance((err, client) => {
                 if (err)

package/dist/cjs/src/lib/queue/_/_parse-queue-extended-params.js

@@ -14,7 +14,7 @@ function _parseQueueExtendedParams(args) {
     if (typeof args === 'string') {
         const queueParams = (0, _parse_queue_params_js_1._parseQueueParams)(args);
         if (queueParams instanceof Error)
-            return new queue_invalid_queue_parameter_error_js_1.QueueInvalidQueueParameterError();
+            return queueParams;
         return {
             queueParams,
             groupId: null,
@@ -23,7 +23,7 @@ function _parseQueueExtendedParams(args) {
     if (isQueueParams(args)) {
         const queueParams = (0, _parse_queue_params_js_1._parseQueueParams)(args);
         if (queueParams instanceof Error)
-            return new queue_invalid_queue_parameter_error_js_1.QueueInvalidQueueParameterError();
+            return queueParams;
         return {
             queueParams,
             groupId: null,

package/dist/cjs/src/lib/queue/_/_parse-queue-params-and-validate.d.ts

@@ -0,0 +1,4 @@
+import { ICallback, IRedisClient } from 'redis-smq-common';
+import { IQueueParams } from '../types/queue.js';
+export declare function _parseQueueParamsAndValidate(redisClient: IRedisClient, queue: string | IQueueParams, cb: ICallback<IQueueParams>): void;
+//# sourceMappingURL=_parse-queue-params-and-validate.d.ts.map

package/dist/cjs/src/lib/queue/_/_parse-queue-params-and-validate.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._parseQueueParamsAndValidate = void 0;
+const queue_queue_not_found_error_js_1 = require("../errors/queue-queue-not-found.error.js");
+const _parse_queue_params_js_1 = require("./_parse-queue-params.js");
+const _queue_exists_js_1 = require("./_queue-exists.js");
+function _parseQueueParamsAndValidate(redisClient, queue, cb) {
+    const queueParams = (0, _parse_queue_params_js_1._parseQueueParams)(queue);
+    if (queueParams instanceof Error)
+        cb(queueParams);
+    else
+        (0, _queue_exists_js_1._queueExists)(redisClient, queueParams, (err, reply) => {
+            if (err)
+                cb(err);
+            else if (!reply)
+                cb(new queue_queue_not_found_error_js_1.QueueQueueNotFoundError());
+            else
+                cb(null, queueParams);
+        });
+}
+exports._parseQueueParamsAndValidate = _parseQueueParamsAndValidate;
+//# sourceMappingURL=_parse-queue-params-and-validate.js.map

package/dist/cjs/src/lib/queue/_/_queue-exists.d.ts

@@ -0,0 +1,4 @@
+import { ICallback, IRedisClient } from 'redis-smq-common';
+import { IQueueParams } from '../types/queue.js';
+export declare function _queueExists(redisClient: IRedisClient, queue: IQueueParams, cb: ICallback<boolean>): void;
+//# sourceMappingURL=_queue-exists.d.ts.map

package/dist/cjs/src/lib/queue/_/_queue-exists.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._queueExists = void 0;
+const redis_keys_js_1 = require("../../../common/redis-keys/redis-keys.js");
+function _queueExists(redisClient, queue, cb) {
+    const { keyQueues } = redis_keys_js_1.redisKeys.getMainKeys();
+    redisClient.sismember(keyQueues, JSON.stringify(queue), (err, reply) => {
+        if (err)
+            cb(err);
+        else
+            cb(null, !!reply);
+    });
+}
+exports._queueExists = _queueExists;
+//# sourceMappingURL=_queue-exists.js.map

package/dist/cjs/src/lib/queue/queue.js

@@ -11,6 +11,7 @@ const _delete_queue_js_1 = require("./_/_delete-queue.js");
 const _get_queue_properties_js_1 = require("./_/_get-queue-properties.js");
 const _get_queues_js_1 = require("./_/_get-queues.js");
 const _parse_queue_params_js_1 = require("./_/_parse-queue-params.js");
+const _queue_exists_js_1 = require("./_/_queue-exists.js");
 const index_js_3 = require("./errors/index.js");
 const index_js_4 = require("./types/index.js");
 class Queue {
@@ -85,15 +86,8 @@ class Queue {
                     cb(err);
                 else if (!client)
                     cb(new redis_smq_common_1.CallbackEmptyReplyError());
-                else {
-                    const { keyQueues } = redis_keys_js_1.redisKeys.getMainKeys();
-                    client.sismember(keyQueues, JSON.stringify(queueParams), (err, reply) => {
-                        if (err)
-                            cb(err);
-                        else
-                            cb(null, !!reply);
-                    });
-                }
+                else
+                    (0, _queue_exists_js_1._queueExists)(client, queueParams, cb);
             });
         }
     }

package/dist/cjs/src/lib/queue-rate-limit/errors/index.d.ts

@@ -1,4 +1,5 @@
 export { QueueRateLimitError } from './queue-rate-limit.error.js';
 export { QueueRateLimitInvalidIntervalError } from './queue-rate-limit-invalid-interval.error.js';
 export { QueueRateLimitInvalidLimitError } from './queue-rate-limit-invalid-limit.error.js';
+export { QueueRateLimitQueueNotFoundError } from './queue-rate-limit-queue-not-found.error.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/src/lib/queue-rate-limit/errors/index.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueueRateLimitInvalidLimitError = exports.QueueRateLimitInvalidIntervalError = exports.QueueRateLimitError = void 0;
+exports.QueueRateLimitQueueNotFoundError = exports.QueueRateLimitInvalidLimitError = exports.QueueRateLimitInvalidIntervalError = exports.QueueRateLimitError = void 0;
 var queue_rate_limit_error_js_1 = require("./queue-rate-limit.error.js");
 Object.defineProperty(exports, "QueueRateLimitError", { enumerable: true, get: function () { return queue_rate_limit_error_js_1.QueueRateLimitError; } });
 var queue_rate_limit_invalid_interval_error_js_1 = require("./queue-rate-limit-invalid-interval.error.js");
 Object.defineProperty(exports, "QueueRateLimitInvalidIntervalError", { enumerable: true, get: function () { return queue_rate_limit_invalid_interval_error_js_1.QueueRateLimitInvalidIntervalError; } });
 var queue_rate_limit_invalid_limit_error_js_1 = require("./queue-rate-limit-invalid-limit.error.js");
 Object.defineProperty(exports, "QueueRateLimitInvalidLimitError", { enumerable: true, get: function () { return queue_rate_limit_invalid_limit_error_js_1.QueueRateLimitInvalidLimitError; } });
+var queue_rate_limit_queue_not_found_error_js_1 = require("./queue-rate-limit-queue-not-found.error.js");
+Object.defineProperty(exports, "QueueRateLimitQueueNotFoundError", { enumerable: true, get: function () { return queue_rate_limit_queue_not_found_error_js_1.QueueRateLimitQueueNotFoundError; } });
 //# sourceMappingURL=index.js.map

package/dist/cjs/src/lib/queue-rate-limit/errors/queue-rate-limit-queue-not-found.error.d.ts

@@ -0,0 +1,4 @@
+import { QueueRateLimitError } from './queue-rate-limit.error.js';
+export declare class QueueRateLimitQueueNotFoundError extends QueueRateLimitError {
+}
+//# sourceMappingURL=queue-rate-limit-queue-not-found.error.d.ts.map

package/dist/cjs/src/lib/queue-rate-limit/errors/queue-rate-limit-queue-not-found.error.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueRateLimitQueueNotFoundError = void 0;
+const queue_rate_limit_error_js_1 = require("./queue-rate-limit.error.js");
+class QueueRateLimitQueueNotFoundError extends queue_rate_limit_error_js_1.QueueRateLimitError {
+}
+exports.QueueRateLimitQueueNotFoundError = QueueRateLimitQueueNotFoundError;
+//# sourceMappingURL=queue-rate-limit-queue-not-found.error.js.map

package/dist/cjs/src/lib/queue-rate-limit/queue-rate-limit.js

@@ -3,10 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueueRateLimit = void 0;
 const redis_smq_common_1 = require("redis-smq-common");
 const redis_client_instance_js_1 = require("../../common/redis-client/redis-client-instance.js");
+const scripts_js_1 = require("../../common/redis-client/scripts/scripts.js");
 const redis_keys_js_1 = require("../../common/redis-keys/redis-keys.js");
 const index_js_1 = require("../../config/index.js");
+const _parse_queue_params_and_validate_js_1 = require("../queue/_/_parse-queue-params-and-validate.js");
 const index_js_2 = require("../queue/index.js");
-const _parse_queue_params_js_1 = require("../queue/_/_parse-queue-params.js");
 const _has_rate_limit_exceeded_js_1 = require("./_/_has-rate-limit-exceeded.js");
 const index_js_3 = require("./errors/index.js");
 class QueueRateLimit {
@@ -20,91 +21,106 @@ class QueueRateLimit {
         this.queue = new index_js_2.Queue();
     }
     clear(queue, cb) {
-        const queueParams = (0, _parse_queue_params_js_1._parseQueueParams)(queue);
-        if (queueParams instanceof Error)
-            cb(queueParams);
-        else {
-            this.redisClient.getSetInstance((err, client) => {
-                if (err)
-                    cb(err);
-                else if (!client)
-                    cb(new redis_smq_common_1.CallbackEmptyReplyError());
-                else {
-                    const { keyQueueProperties, keyQueueRateLimitCounter } = redis_keys_js_1.redisKeys.getQueueKeys(queueParams, null);
-                    const multi = client.multi();
-                    multi.hdel(keyQueueProperties, String(index_js_2.EQueueProperty.RATE_LIMIT));
-                    multi.del(keyQueueRateLimitCounter);
-                    multi.exec((err) => cb(err));
-                }
-            });
-        }
+        this.redisClient.getSetInstance((err, client) => {
+            if (err)
+                cb(err);
+            else if (!client)
+                cb(new redis_smq_common_1.CallbackEmptyReplyError());
+            else
+                (0, _parse_queue_params_and_validate_js_1._parseQueueParamsAndValidate)(client, queue, (err, queueParams) => {
+                    if (err)
+                        cb(err);
+                    else if (!queueParams)
+                        cb(new redis_smq_common_1.CallbackEmptyReplyError());
+                    else {
+                        const { keyQueueProperties, keyQueueRateLimitCounter } = redis_keys_js_1.redisKeys.getQueueKeys(queueParams, null);
+                        const multi = client.multi();
+                        multi.hdel(keyQueueProperties, String(index_js_2.EQueueProperty.RATE_LIMIT));
+                        multi.del(keyQueueRateLimitCounter);
+                        multi.exec((err) => cb(err));
+                    }
+                });
+        });
     }
     set(queue, rateLimit, cb) {
-        const queueParams = (0, _parse_queue_params_js_1._parseQueueParams)(queue);
-        if (queueParams instanceof Error)
-            cb(queueParams);
-        else {
-            this.redisClient.getSetInstance((err, client) => {
-                if (err)
-                    cb(err);
-                else if (!client)
-                    cb(new redis_smq_common_1.CallbackEmptyReplyError());
-                else {
-                    const limit = Number(rateLimit.limit);
-                    if (isNaN(limit) || limit <= 0) {
-                        cb(new index_js_3.QueueRateLimitInvalidLimitError());
-                    }
-                    const interval = Number(rateLimit.interval);
-                    if (isNaN(interval) || interval < 1000) {
-                        cb(new index_js_3.QueueRateLimitInvalidIntervalError());
+        this.redisClient.getSetInstance((err, client) => {
+            if (err)
+                cb(err);
+            else if (!client)
+                cb(new redis_smq_common_1.CallbackEmptyReplyError());
+            else
+                (0, _parse_queue_params_and_validate_js_1._parseQueueParamsAndValidate)(client, queue, (err, queueParams) => {
+                    if (err)
+                        cb(err);
+                    else if (!queueParams)
+                        cb(new redis_smq_common_1.CallbackEmptyReplyError());
+                    else {
+                        const limit = Number(rateLimit.limit);
+                        if (isNaN(limit) || limit <= 0) {
+                            cb(new index_js_3.QueueRateLimitInvalidLimitError());
+                        }
+                        const interval = Number(rateLimit.interval);
+                        if (isNaN(interval) || interval < 1000) {
+                            cb(new index_js_3.QueueRateLimitInvalidIntervalError());
+                        }
+                        const validatedRateLimit = { interval, limit };
+                        const { keyQueueProperties } = redis_keys_js_1.redisKeys.getQueueKeys(queueParams, null);
+                        client.runScript(scripts_js_1.ELuaScriptName.SET_QUEUE_RATE_LIMIT, [keyQueueProperties], [index_js_2.EQueueProperty.RATE_LIMIT, JSON.stringify(validatedRateLimit)], (err, reply) => {
+                            if (err)
+                                cb(err);
+                            else if (reply !== 'OK')
+                                cb(new index_js_3.QueueRateLimitQueueNotFoundError());
+                            else
+                                cb();
+                        });
                     }
-                    const validatedRateLimit = { interval, limit };
-                    const { keyQueueProperties } = redis_keys_js_1.redisKeys.getQueueKeys(queueParams, null);
-                    client.hset(keyQueueProperties, String(index_js_2.EQueueProperty.RATE_LIMIT), JSON.stringify(validatedRateLimit), (err) => cb(err));
-                }
-            });
-        }
+                });
+        });
     }
     hasExceeded(queue, rateLimit, cb) {
-        const queueParams = (0, _parse_queue_params_js_1._parseQueueParams)(queue);
-        if (queueParams instanceof Error)
-            cb(queueParams);
-        else {
-            this.redisClient.getSetInstance((err, client) => {
-                if (err)
-                    cb(err);
-                else if (!client)
-                    cb(new redis_smq_common_1.CallbackEmptyReplyError());
-                else
-                    (0, _has_rate_limit_exceeded_js_1._hasRateLimitExceeded)(client, queueParams, rateLimit, cb);
-            });
-        }
+        this.redisClient.getSetInstance((err, client) => {
+            if (err)
+                cb(err);
+            else if (!client)
+                cb(new redis_smq_common_1.CallbackEmptyReplyError());
+            else
+                (0, _parse_queue_params_and_validate_js_1._parseQueueParamsAndValidate)(client, queue, (err, queueParams) => {
+                    if (err)
+                        cb(err);
+                    else if (!queueParams)
+                        cb(new redis_smq_common_1.CallbackEmptyReplyError());
+                    else
+                        (0, _has_rate_limit_exceeded_js_1._hasRateLimitExceeded)(client, queueParams, rateLimit, cb);
+                });
+        });
     }
     get(queue, cb) {
-        const queueParams = (0, _parse_queue_params_js_1._parseQueueParams)(queue);
-        if (queueParams instanceof Error)
-            cb(queueParams);
-        else {
-            this.redisClient.getSetInstance((err, client) => {
-                if (err)
-                    cb(err);
-                else if (!client)
-                    cb(new redis_smq_common_1.CallbackEmptyReplyError());
-                else {
-                    const { keyQueueProperties } = redis_keys_js_1.redisKeys.getQueueKeys(queueParams, null);
-                    client.hget(keyQueueProperties, String(index_js_2.EQueueProperty.RATE_LIMIT), (err, reply) => {
-                        if (err)
-                            cb(err);
-                        else if (!reply)
-                            cb(null, null);
-                        else {
-                            const rateLimit = JSON.parse(reply);
-                            cb(null, rateLimit);
-                        }
-                    });
-                }
-            });
-        }
+        this.redisClient.getSetInstance((err, client) => {
+            if (err)
+                cb(err);
+            else if (!client)
+                cb(new redis_smq_common_1.CallbackEmptyReplyError());
+            else
+                (0, _parse_queue_params_and_validate_js_1._parseQueueParamsAndValidate)(client, queue, (err, queueParams) => {
+                    if (err)
+                        cb(err);
+                    else if (!queueParams)
+                        cb(new redis_smq_common_1.CallbackEmptyReplyError());
+                    else {
+                        const { keyQueueProperties } = redis_keys_js_1.redisKeys.getQueueKeys(queueParams, null);
+                        client.hget(keyQueueProperties, String(index_js_2.EQueueProperty.RATE_LIMIT), (err, reply) => {
+                            if (err)
+                                cb(err);
+                            else if (!reply)
+                                cb(null, null);
+                            else {
+                                const rateLimit = JSON.parse(reply);
+                                cb(null, rateLimit);
+                            }
+                        });
+                    }
+                });
+        });
     }
 }
 exports.QueueRateLimit = QueueRateLimit;

package/dist/esm/src/common/redis-client/scripts/lua/set-queue-rate-limit.lua

@@ -0,0 +1,14 @@
+local keyQueueProperties = KEYS[1]
+
+---
+
+local EQueuePropertyRateLimit = ARGV[1]
+local rateLimit = ARGV[2]
+
+local result = redis.call("EXISTS", keyQueueProperties)
+if result == 0 then
+    return 'QUEUE_NOT_FOUND';
+end
+
+redis.call("HSET", keyQueueProperties, EQueuePropertyRateLimit, rateLimit)
+return 'OK'

package/dist/esm/src/common/redis-client/scripts/scripts.d.ts

@@ -11,6 +11,7 @@ export declare enum ELuaScriptName {
     DELETE_MESSAGE = "DELETE_MESSAGE",
     FETCH_MESSAGE_FOR_PROCESSING = "FETCH_MESSAGE_FOR_PROCESSING",
     DELETE_CONSUMER_GROUP = "DELETE_CONSUMER_GROUP",
-    CLEANUP_OFFLINE_CONSUMER = "CLEANUP_OFFLINE_CONSUMER"
+    CLEANUP_OFFLINE_CONSUMER = "CLEANUP_OFFLINE_CONSUMER",
+    SET_QUEUE_RATE_LIMIT = "SET_QUEUE_RATE_LIMIT"
 }
 //# sourceMappingURL=scripts.d.ts.map

package/dist/esm/src/common/redis-client/scripts/scripts.js

@@ -16,6 +16,7 @@ export var ELuaScriptName;
     ELuaScriptName["FETCH_MESSAGE_FOR_PROCESSING"] = "FETCH_MESSAGE_FOR_PROCESSING";
     ELuaScriptName["DELETE_CONSUMER_GROUP"] = "DELETE_CONSUMER_GROUP";
     ELuaScriptName["CLEANUP_OFFLINE_CONSUMER"] = "CLEANUP_OFFLINE_CONSUMER";
+    ELuaScriptName["SET_QUEUE_RATE_LIMIT"] = "SET_QUEUE_RATE_LIMIT";
 })(ELuaScriptName = ELuaScriptName || (ELuaScriptName = {}));
 RedisClientAbstract.addScript(ELuaScriptName.PUBLISH_SCHEDULED_MESSAGE, fs
     .readFileSync(resolve(getDirname(), './lua/publish-scheduled-message.lua'))
@@ -52,4 +53,7 @@ RedisClientAbstract.addScript(ELuaScriptName.DELETE_CONSUMER_GROUP, fs
 RedisClientAbstract.addScript(ELuaScriptName.CLEANUP_OFFLINE_CONSUMER, fs
     .readFileSync(resolve(getDirname(), './lua/cleanup-offline-consumer.lua'))
     .toString());
+RedisClientAbstract.addScript(ELuaScriptName.SET_QUEUE_RATE_LIMIT, fs
+    .readFileSync(resolve(getDirname(), './lua/set-queue-rate-limit.lua'))
+    .toString());
 //# sourceMappingURL=scripts.js.map

package/dist/esm/src/lib/namespace/errors/index.d.ts

@@ -1,3 +1,4 @@
 export { NamespaceNotFoundError } from './namespace-not-found.error.js';
 export { NamespaceError } from './namespace.error.js';
+export { NamespaceInvalidNamespaceError } from './namespace-invalid-namespace.error.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/src/lib/namespace/errors/index.js

@@ -1,3 +1,4 @@
 export { NamespaceNotFoundError } from './namespace-not-found.error.js';
 export { NamespaceError } from './namespace.error.js';
+export { NamespaceInvalidNamespaceError } from './namespace-invalid-namespace.error.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/src/lib/namespace/errors/namespace-invalid-namespace.error.d.ts

@@ -0,0 +1,4 @@
+import { NamespaceError } from './namespace.error.js';
+export declare class NamespaceInvalidNamespaceError extends NamespaceError {
+}
+//# sourceMappingURL=namespace-invalid-namespace.error.d.ts.map

package/dist/esm/src/lib/namespace/errors/namespace-invalid-namespace.error.js

@@ -0,0 +1,4 @@
+import { NamespaceError } from './namespace.error.js';
+export class NamespaceInvalidNamespaceError extends NamespaceError {
+}
+//# sourceMappingURL=namespace-invalid-namespace.error.js.map

package/dist/esm/src/lib/namespace/namespace.js

@@ -4,7 +4,7 @@ import { redisKeys } from '../../common/redis-keys/redis-keys.js';
 import { Configuration } from '../../config/index.js';
 import { _deleteQueue } from '../queue/_/_delete-queue.js';
 import { _getQueues } from '../queue/_/_get-queues.js';
-import { NamespaceNotFoundError } from './errors/index.js';
+import { NamespaceInvalidNamespaceError, NamespaceNotFoundError, } from './errors/index.js';
 export class Namespace {
     logger;
     redisClient;
@@ -35,7 +35,7 @@ export class Namespace {
     getNamespaceQueues(namespace, cb) {
         const ns = redisKeys.validateRedisKey(namespace);
         if (ns instanceof Error)
-            cb(ns);
+            cb(new NamespaceInvalidNamespaceError());
         else {
             this.redisClient.getSetInstance((err, client) => {
                 if (err)
@@ -76,7 +76,7 @@ export class Namespace {
     delete(namespace, cb) {
         const ns = redisKeys.validateRedisKey(namespace);
         if (ns instanceof Error)
-            cb(ns);
+            cb(new NamespaceInvalidNamespaceError());
         else {
             this.redisClient.getSetInstance((err, client) => {
                 if (err)

package/dist/esm/src/lib/queue/_/_parse-queue-extended-params.js

@@ -11,7 +11,7 @@ export function _parseQueueExtendedParams(args) {
     if (typeof args === 'string') {
         const queueParams = _parseQueueParams(args);
         if (queueParams instanceof Error)
-            return new QueueInvalidQueueParameterError();
+            return queueParams;
         return {
             queueParams,
             groupId: null,
@@ -20,7 +20,7 @@ export function _parseQueueExtendedParams(args) {
     if (isQueueParams(args)) {
         const queueParams = _parseQueueParams(args);
         if (queueParams instanceof Error)
-            return new QueueInvalidQueueParameterError();
+            return queueParams;
         return {
             queueParams,
             groupId: null,

package/dist/esm/src/lib/queue/_/_parse-queue-params-and-validate.d.ts

@@ -0,0 +1,4 @@
+import { ICallback, IRedisClient } from 'redis-smq-common';
+import { IQueueParams } from '../types/queue.js';
+export declare function _parseQueueParamsAndValidate(redisClient: IRedisClient, queue: string | IQueueParams, cb: ICallback<IQueueParams>): void;
+//# sourceMappingURL=_parse-queue-params-and-validate.d.ts.map

package/dist/esm/src/lib/queue/_/_parse-queue-params-and-validate.js

@@ -0,0 +1,18 @@
+import { QueueQueueNotFoundError } from '../errors/queue-queue-not-found.error.js';
+import { _parseQueueParams } from './_parse-queue-params.js';
+import { _queueExists } from './_queue-exists.js';
+export function _parseQueueParamsAndValidate(redisClient, queue, cb) {
+    const queueParams = _parseQueueParams(queue);
+    if (queueParams instanceof Error)
+        cb(queueParams);
+    else
+        _queueExists(redisClient, queueParams, (err, reply) => {
+            if (err)
+                cb(err);
+            else if (!reply)
+                cb(new QueueQueueNotFoundError());
+            else
+                cb(null, queueParams);
+        });
+}
+//# sourceMappingURL=_parse-queue-params-and-validate.js.map

package/dist/esm/src/lib/queue/_/_queue-exists.d.ts

@@ -0,0 +1,4 @@
+import { ICallback, IRedisClient } from 'redis-smq-common';
+import { IQueueParams } from '../types/queue.js';
+export declare function _queueExists(redisClient: IRedisClient, queue: IQueueParams, cb: ICallback<boolean>): void;
+//# sourceMappingURL=_queue-exists.d.ts.map

package/dist/esm/src/lib/queue/_/_queue-exists.js

@@ -0,0 +1,11 @@
+import { redisKeys } from '../../../common/redis-keys/redis-keys.js';
+export function _queueExists(redisClient, queue, cb) {
+    const { keyQueues } = redisKeys.getMainKeys();
+    redisClient.sismember(keyQueues, JSON.stringify(queue), (err, reply) => {
+        if (err)
+            cb(err);
+        else
+            cb(null, !!reply);
+    });
+}
+//# sourceMappingURL=_queue-exists.js.map

package/dist/esm/src/lib/queue/queue.js

@@ -8,6 +8,7 @@ import { _deleteQueue } from './_/_delete-queue.js';
 import { _getQueueProperties } from './_/_get-queue-properties.js';
 import { _getQueues } from './_/_get-queues.js';
 import { _parseQueueParams } from './_/_parse-queue-params.js';
+import { _queueExists } from './_/_queue-exists.js';
 import { QueueQueueExistsError } from './errors/index.js';
 import { EQueueProperty, } from './types/index.js';
 export class Queue {
@@ -82,15 +83,8 @@ export class Queue {
                     cb(err);
                 else if (!client)
                     cb(new CallbackEmptyReplyError());
-                else {
-                    const { keyQueues } = redisKeys.getMainKeys();
-                    client.sismember(keyQueues, JSON.stringify(queueParams), (err, reply) => {
-                        if (err)
-                            cb(err);
-                        else
-                            cb(null, !!reply);
-                    });
-                }
+                else
+                    _queueExists(client, queueParams, cb);
             });
         }
     }

package/dist/esm/src/lib/queue-rate-limit/errors/index.d.ts

@@ -1,4 +1,5 @@
 export { QueueRateLimitError } from './queue-rate-limit.error.js';
 export { QueueRateLimitInvalidIntervalError } from './queue-rate-limit-invalid-interval.error.js';
 export { QueueRateLimitInvalidLimitError } from './queue-rate-limit-invalid-limit.error.js';
+export { QueueRateLimitQueueNotFoundError } from './queue-rate-limit-queue-not-found.error.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/src/lib/queue-rate-limit/errors/index.js

@@ -1,4 +1,5 @@
 export { QueueRateLimitError } from './queue-rate-limit.error.js';
 export { QueueRateLimitInvalidIntervalError } from './queue-rate-limit-invalid-interval.error.js';
 export { QueueRateLimitInvalidLimitError } from './queue-rate-limit-invalid-limit.error.js';
+export { QueueRateLimitQueueNotFoundError } from './queue-rate-limit-queue-not-found.error.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/src/lib/queue-rate-limit/errors/queue-rate-limit-queue-not-found.error.d.ts

@@ -0,0 +1,4 @@
+import { QueueRateLimitError } from './queue-rate-limit.error.js';
+export declare class QueueRateLimitQueueNotFoundError extends QueueRateLimitError {
+}
+//# sourceMappingURL=queue-rate-limit-queue-not-found.error.d.ts.map

package/dist/esm/src/lib/queue-rate-limit/errors/queue-rate-limit-queue-not-found.error.js

@@ -0,0 +1,4 @@
+import { QueueRateLimitError } from './queue-rate-limit.error.js';
+export class QueueRateLimitQueueNotFoundError extends QueueRateLimitError {
+}
+//# sourceMappingURL=queue-rate-limit-queue-not-found.error.js.map

package/dist/esm/src/lib/queue-rate-limit/queue-rate-limit.js

@@ -1,11 +1,12 @@
 import { async, CallbackEmptyReplyError, logger, } from 'redis-smq-common';
 import { RedisClientInstance } from '../../common/redis-client/redis-client-instance.js';
+import { ELuaScriptName } from '../../common/redis-client/scripts/scripts.js';
 import { redisKeys } from '../../common/redis-keys/redis-keys.js';
 import { Configuration } from '../../config/index.js';
+import { _parseQueueParamsAndValidate } from '../queue/_/_parse-queue-params-and-validate.js';
 import { EQueueProperty, Queue, } from '../queue/index.js';
-import { _parseQueueParams } from '../queue/_/_parse-queue-params.js';
 import { _hasRateLimitExceeded } from './_/_has-rate-limit-exceeded.js';
-import { QueueRateLimitInvalidLimitError, QueueRateLimitInvalidIntervalError, } from './errors/index.js';
+import { QueueRateLimitInvalidLimitError, QueueRateLimitInvalidIntervalError, QueueRateLimitQueueNotFoundError, } from './errors/index.js';
 export class QueueRateLimit {
     redisClient;
     logger;
@@ -17,91 +18,106 @@ export class QueueRateLimit {
         this.queue = new Queue();
     }
     clear(queue, cb) {
-        const queueParams = _parseQueueParams(queue);
-        if (queueParams instanceof Error)
-            cb(queueParams);
-        else {
-            this.redisClient.getSetInstance((err, client) => {
-                if (err)
-                    cb(err);
-                else if (!client)
-                    cb(new CallbackEmptyReplyError());
-                else {
-                    const { keyQueueProperties, keyQueueRateLimitCounter } = redisKeys.getQueueKeys(queueParams, null);
-                    const multi = client.multi();
-                    multi.hdel(keyQueueProperties, String(EQueueProperty.RATE_LIMIT));
-                    multi.del(keyQueueRateLimitCounter);
-                    multi.exec((err) => cb(err));
-                }
-            });
-        }
+        this.redisClient.getSetInstance((err, client) => {
+            if (err)
+                cb(err);
+            else if (!client)
+                cb(new CallbackEmptyReplyError());
+            else
+                _parseQueueParamsAndValidate(client, queue, (err, queueParams) => {
+                    if (err)
+                        cb(err);
+                    else if (!queueParams)
+                        cb(new CallbackEmptyReplyError());
+                    else {
+                        const { keyQueueProperties, keyQueueRateLimitCounter } = redisKeys.getQueueKeys(queueParams, null);
+                        const multi = client.multi();
+                        multi.hdel(keyQueueProperties, String(EQueueProperty.RATE_LIMIT));
+                        multi.del(keyQueueRateLimitCounter);
+                        multi.exec((err) => cb(err));
+                    }
+                });
+        });
     }
     set(queue, rateLimit, cb) {
-        const queueParams = _parseQueueParams(queue);
-        if (queueParams instanceof Error)
-            cb(queueParams);
-        else {
-            this.redisClient.getSetInstance((err, client) => {
-                if (err)
-                    cb(err);
-                else if (!client)
-                    cb(new CallbackEmptyReplyError());
-                else {
-                    const limit = Number(rateLimit.limit);
-                    if (isNaN(limit) || limit <= 0) {
-                        cb(new QueueRateLimitInvalidLimitError());
-                    }
-                    const interval = Number(rateLimit.interval);
-                    if (isNaN(interval) || interval < 1000) {
-                        cb(new QueueRateLimitInvalidIntervalError());
+        this.redisClient.getSetInstance((err, client) => {
+            if (err)
+                cb(err);
+            else if (!client)
+                cb(new CallbackEmptyReplyError());
+            else
+                _parseQueueParamsAndValidate(client, queue, (err, queueParams) => {
+                    if (err)
+                        cb(err);
+                    else if (!queueParams)
+                        cb(new CallbackEmptyReplyError());
+                    else {
+                        const limit = Number(rateLimit.limit);
+                        if (isNaN(limit) || limit <= 0) {
+                            cb(new QueueRateLimitInvalidLimitError());
+                        }
+                        const interval = Number(rateLimit.interval);
+                        if (isNaN(interval) || interval < 1000) {
+                            cb(new QueueRateLimitInvalidIntervalError());
+                        }
+                        const validatedRateLimit = { interval, limit };
+                        const { keyQueueProperties } = redisKeys.getQueueKeys(queueParams, null);
+                        client.runScript(ELuaScriptName.SET_QUEUE_RATE_LIMIT, [keyQueueProperties], [EQueueProperty.RATE_LIMIT, JSON.stringify(validatedRateLimit)], (err, reply) => {
+                            if (err)
+                                cb(err);
+                            else if (reply !== 'OK')
+                                cb(new QueueRateLimitQueueNotFoundError());
+                            else
+                                cb();
+                        });
                     }
-                    const validatedRateLimit = { interval, limit };
-                    const { keyQueueProperties } = redisKeys.getQueueKeys(queueParams, null);
-                    client.hset(keyQueueProperties, String(EQueueProperty.RATE_LIMIT), JSON.stringify(validatedRateLimit), (err) => cb(err));
-                }
-            });
-        }
+                });
+        });
     }
     hasExceeded(queue, rateLimit, cb) {
-        const queueParams = _parseQueueParams(queue);
-        if (queueParams instanceof Error)
-            cb(queueParams);
-        else {
-            this.redisClient.getSetInstance((err, client) => {
-                if (err)
-                    cb(err);
-                else if (!client)
-                    cb(new CallbackEmptyReplyError());
-                else
-                    _hasRateLimitExceeded(client, queueParams, rateLimit, cb);
-            });
-        }
+        this.redisClient.getSetInstance((err, client) => {
+            if (err)
+                cb(err);
+            else if (!client)
+                cb(new CallbackEmptyReplyError());
+            else
+                _parseQueueParamsAndValidate(client, queue, (err, queueParams) => {
+                    if (err)
+                        cb(err);
+                    else if (!queueParams)
+                        cb(new CallbackEmptyReplyError());
+                    else
+                        _hasRateLimitExceeded(client, queueParams, rateLimit, cb);
+                });
+        });
     }
     get(queue, cb) {
-        const queueParams = _parseQueueParams(queue);
-        if (queueParams instanceof Error)
-            cb(queueParams);
-        else {
-            this.redisClient.getSetInstance((err, client) => {
-                if (err)
-                    cb(err);
-                else if (!client)
-                    cb(new CallbackEmptyReplyError());
-                else {
-                    const { keyQueueProperties } = redisKeys.getQueueKeys(queueParams, null);
-                    client.hget(keyQueueProperties, String(EQueueProperty.RATE_LIMIT), (err, reply) => {
-                        if (err)
-                            cb(err);
-                        else if (!reply)
-                            cb(null, null);
-                        else {
-                            const rateLimit = JSON.parse(reply);
-                            cb(null, rateLimit);
-                        }
-                    });
-                }
-            });
-        }
+        this.redisClient.getSetInstance((err, client) => {
+            if (err)
+                cb(err);
+            else if (!client)
+                cb(new CallbackEmptyReplyError());
+            else
+                _parseQueueParamsAndValidate(client, queue, (err, queueParams) => {
+                    if (err)
+                        cb(err);
+                    else if (!queueParams)
+                        cb(new CallbackEmptyReplyError());
+                    else {
+                        const { keyQueueProperties } = redisKeys.getQueueKeys(queueParams, null);
+                        client.hget(keyQueueProperties, String(EQueueProperty.RATE_LIMIT), (err, reply) => {
+                            if (err)
+                                cb(err);
+                            else if (!reply)
+                                cb(null, null);
+                            else {
+                                const rateLimit = JSON.parse(reply);
+                                cb(null, rateLimit);
+                            }
+                        });
+                    }
+                });
+        });
     }
     shutdown = (cb) => {
         async.waterfall([this.queue.shutdown, this.redisClient.shutdown], cb);

package/package.json

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