redis-smq-common 1.0.0-rc.0 → 1.0.0-rc.11

package/.codecov.yml

@@ -0,0 +1,5 @@
+coverage:
+  status:
+    patch:
+      default:
+        target: 80%

package/CHANGELOG.md

@@ -1,6 +1,59 @@
 # CHANGELOG
 
-## 1.0.0-rc.0 (2022-05-24)
+## 1.0.0-rc.11 (2022-05-31)
+
+* Update RedisClient and IRedisClientMulti interfaces (8732c97)
+
+## 1.0.0-rc.10 (2022-05-31)
+
+* Fix broken promisify(All) because of ICallback typing (4250e32)
+
+## 1.0.0-rc.9 (2022-05-31)
+
+* Improve RedisClient typings (27219a6)
+* Set up codecov (98293bd)
+* Fix type coverage (2f4a722)
+
+## 1.0.0-rc.8 (2022-05-30)
+
+* Add WatchedKeysChangedError class (1e42e80)
+
+## 1.0.0-rc.7 (2022-05-30)
+
+* Fix various redis errors (9349261)
+
+## 1.0.0-rc.6 (2022-05-30)
+
+* Fix missing RedisClient from package exports (88f90f0)
+
+## 1.0.0-rc.5 (2022-05-30)
+
+* Update IRedisClientMulti interface (be1c534)
+
+## 1.0.0-rc.4 (2022-05-30)
+
+* Update docs (5b88f1d)
+* Clean up (dfccabf)
+* Fix type coverage (a5def8d)
+* Implement RedisClientMulti (fc5a832)
+* Fix redis-client/test00001 (ba817ef)
+* Drop support for node.js v12 (14773ab)
+* Add node-redis v4 support (WIP) (a316490)
+* Add NPM version badge (8fa0d52)
+* Update package keywords (98b6e5e)
+* Update logs.md (fe0e708)
+* Add shared docs (19b9f0b)
+
+## 1.0.0-rc.3 (2022-05-26)
+
+* Update README.md
+* Refactor and clean up Worker and WorkerRunner classes
+
+## 1.0.0-rc.2 (2022-05-25)
+
+* Allow children of Worker class to access worker params
+
+## 1.0.0-rc.1 (2022-05-24)
 
 * Update package keywords and description
 * Use codecov instead of coveralls

package/README.md

@@ -1,15 +1,17 @@
 <div align="center" style="text-align: center">
   <p><a href="https://github.com/weyoss/redis-smq-common"><img alt="RedisSMQ" src="./logo.png" /></a></p>
   <p>A simple high-performance Redis message queue for Node.js.</p>
-  <p>
-    <a href="https://github.com/weyoss/redis-smq-common/actions/workflows/tests.yml"><img src="https://github.com/weyoss/redis-smq-common/actions/workflows/tests.yml/badge.svg" alt="Tests" style="max-width:100%;" /></a>
-    <a href="https://codecov.io/github/weyoss/redis-smq-common?branch=master" rel="nofollow"><img src="https://img.shields.io/codecov/c/github/weyoss/redis-smq-common" alt="Coverage Status" /></a>
-    <a href="https://lgtm.com/projects/g/weyoss/redis-smq-common/context:javascript" rel="nofollow"><img src="https://img.shields.io/lgtm/grade/javascript/github/weyoss/redis-smq-common.svg?logo=lgtm&logoWidth=18" alt="Code quality" /></a>
-  </p>
 </div>
 
 ## RedisSMQ Common Library
 
+<p>
+    <a href="https://github.com/weyoss/redis-smq-common/actions/workflows/tests.yml"><img src="https://github.com/weyoss/redis-smq-common/actions/workflows/tests.yml/badge.svg" alt="Tests" style="max-width:100%;" /></a>
+    <a href="https://npmjs.org/package/redis-smq-common" rel="nofollow"><img src="https://img.shields.io/npm/v/redis-smq-common.svg" alt="NPM version" /></a>
+    <a href="https://codecov.io/github/weyoss/redis-smq-common?branch=master" rel="nofollow"><img src="https://img.shields.io/codecov/c/github/weyoss/redis-smq-common" alt="Coverage Status" /></a>
+    <a href="https://lgtm.com/projects/g/weyoss/redis-smq-common/context:javascript" rel="nofollow"><img src="https://img.shields.io/lgtm/grade/javascript/github/weyoss/redis-smq-common.svg?logo=lgtm&logoWidth=18" alt="Code quality" /></a>
+</p>
+
 [RedisSMQ](https://github.com/weyoss/redis-smq) shared components that may be used by integrated applications and extensions.
 
 ## License

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export { errors } from './src/errors';
 export { LockManager } from './src/lock-manager/lock-manager';
 export { logger } from './src/logger/logger';
 export { PowerManager } from './src/power-manager/power-manager';
+export { createClientInstance } from './src/redis-client/create-client-instance';
 export { RedisClient } from './src/redis-client/redis-client';
 export { Ticker } from './src/ticker/ticker';
 export { Worker } from './src/worker/worker';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.events = exports.WorkerPool = exports.WorkerRunner = exports.Worker = exports.Ticker = exports.RedisClient = exports.PowerManager = exports.logger = exports.LockManager = exports.errors = exports.async = void 0;
+exports.events = exports.WorkerPool = exports.WorkerRunner = exports.Worker = exports.Ticker = exports.RedisClient = exports.createClientInstance = exports.PowerManager = exports.logger = exports.LockManager = exports.errors = exports.async = void 0;
 var async_1 = require("./src/async/async");
 Object.defineProperty(exports, "async", { enumerable: true, get: function () { return async_1.async; } });
 var errors_1 = require("./src/errors");
@@ -11,6 +11,8 @@ var logger_1 = require("./src/logger/logger");
 Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });
 var power_manager_1 = require("./src/power-manager/power-manager");
 Object.defineProperty(exports, "PowerManager", { enumerable: true, get: function () { return power_manager_1.PowerManager; } });
+var create_client_instance_1 = require("./src/redis-client/create-client-instance");
+Object.defineProperty(exports, "createClientInstance", { enumerable: true, get: function () { return create_client_instance_1.createClientInstance; } });
 var redis_client_1 = require("./src/redis-client/redis-client");
 Object.defineProperty(exports, "RedisClient", { enumerable: true, get: function () { return redis_client_1.RedisClient; } });
 var ticker_1 = require("./src/ticker/ticker");

package/dist/src/lock-manager/lock-manager.js

@@ -95,7 +95,13 @@ class LockManager {
             this.status = ELockStatus.locking;
             const lock = () => {
                 if (this.status === ELockStatus.locking) {
-                    this.redisClient.set(this.lockKey, this.lockId, 'PX', this.ttl, 'NX', (err, reply) => {
+                    this.redisClient.set(this.lockKey, this.lockId, {
+                        expire: {
+                            mode: 'PX',
+                            value: this.ttl,
+                        },
+                        exists: 'NX',
+                    }, (err, reply) => {
                         if (err)
                             cb(err);
                         else if (this.status === ELockStatus.locking) {

package/dist/src/redis-client/clients/ioredis-client-multi.d.ts

@@ -0,0 +1,24 @@
+import { ICallback, IRedisClientMulti } from '../../../types';
+import { Pipeline, Redis } from 'ioredis';
+export declare class IoredisClientMulti implements IRedisClientMulti {
+    protected multi: Pipeline;
+    constructor(client: Redis);
+    lrem(key: string, count: number, element: string): this;
+    lpop(key: string): this;
+    lpush(key: string, element: string): this;
+    ltrim(key: string, start: number, stop: number): this;
+    rpop(key: string): this;
+    rpush(key: string, element: string): this;
+    zadd(key: string, score: number, element: string): this;
+    zrem(key: string, element: string | string[]): this;
+    sadd(key: string, element: string): this;
+    srem(key: string, element: string | string[]): this;
+    hset(key: string, field: string, value: string): this;
+    hdel(key: string, field: string | string[]): this;
+    hincrby(key: string, field: string, by: number): this;
+    pexpire(key: string, millis: number): this;
+    expire(key: string, secs: number): this;
+    rpoplpush(source: string, destination: string): this;
+    del(key: string | string[]): this;
+    exec(cb: ICallback<unknown[]>): void;
+}

package/dist/src/redis-client/clients/ioredis-client-multi.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IoredisClientMulti = void 0;
+const redis_client_error_1 = require("../errors/redis-client.error");
+const watched_keys_changed_error_1 = require("../errors/watched-keys-changed.error");
+class IoredisClientMulti {
+    constructor(client) {
+        this.multi = client.multi();
+    }
+    lrem(key, count, element) {
+        this.multi.lrem(key, count, element);
+        return this;
+    }
+    lpop(key) {
+        this.multi.lpop(key);
+        return this;
+    }
+    lpush(key, element) {
+        this.multi.lpush(key, element);
+        return this;
+    }
+    ltrim(key, start, stop) {
+        this.multi.ltrim(key, start, stop);
+        return this;
+    }
+    rpop(key) {
+        this.multi.rpop(key);
+        return this;
+    }
+    rpush(key, element) {
+        this.multi.rpush(key, element);
+        return this;
+    }
+    zadd(key, score, element) {
+        this.multi.zadd(key, score, element);
+        return this;
+    }
+    zrem(key, element) {
+        this.multi.zrem(key, ...(typeof element === 'string' ? [element] : element));
+        return this;
+    }
+    sadd(key, element) {
+        this.multi.sadd(key, element);
+        return this;
+    }
+    srem(key, element) {
+        this.multi.srem(key, ...(typeof element === 'string' ? [element] : element));
+        return this;
+    }
+    hset(key, field, value) {
+        this.multi.hset(key, field, value);
+        return this;
+    }
+    hdel(key, field) {
+        this.multi.hdel(key, ...(typeof field === 'string' ? [field] : field));
+        return this;
+    }
+    hincrby(key, field, by) {
+        this.multi.hincrby(key, field, by);
+        return this;
+    }
+    pexpire(key, millis) {
+        this.multi.pexpire(key, millis);
+        return this;
+    }
+    expire(key, secs) {
+        this.multi.expire(key, secs);
+        return this;
+    }
+    rpoplpush(source, destination) {
+        this.multi.rpoplpush(source, destination);
+        return this;
+    }
+    del(key) {
+        this.multi.del(...(typeof key === 'string' ? [key] : key));
+        return this;
+    }
+    exec(cb) {
+        this.multi.exec((err, reply) => {
+            if (err)
+                cb(err);
+            else if (!reply)
+                cb(new watched_keys_changed_error_1.WatchedKeysChangedError());
+            else {
+                const lengths = [];
+                let err = null;
+                for (const i of reply) {
+                    if (!Array.isArray(i)) {
+                        err = new redis_client_error_1.RedisClientError('Expected an array reply from multi.exec()');
+                        break;
+                    }
+                    const [error, result] = i;
+                    if (error instanceof Error) {
+                        err = error;
+                        break;
+                    }
+                    lengths.push(result);
+                }
+                if (err)
+                    cb(err);
+                else
+                    cb(null, lengths);
+            }
+        });
+    }
+}
+exports.IoredisClientMulti = IoredisClientMulti;
+//# sourceMappingURL=ioredis-client-multi.js.map

package/dist/src/redis-client/clients/ioredis-client.d.ts

@@ -0,0 +1,56 @@
+import { RedisClient } from '../redis-client';
+import { Redis, RedisOptions } from 'ioredis';
+import { ICallback } from '../../../types';
+import { IoredisClientMulti } from './ioredis-client-multi';
+export declare class IoredisClient extends RedisClient {
+    protected client: Redis;
+    constructor(config?: RedisOptions);
+    set(key: string, value: string, options: {
+        expire?: {
+            mode: 'EX' | 'PX';
+            value: number;
+        };
+        exists?: 'NX' | 'XX';
+    }, cb: ICallback<string | null>): void;
+    zadd(key: string, score: number, member: string, cb: ICallback<number | string>): void;
+    multi(): IoredisClientMulti;
+    watch(args: string[], cb: ICallback<string>): void;
+    unwatch(cb: ICallback<string>): void;
+    sismember(key: string, member: string, cb: ICallback<number>): void;
+    zcard(key: string, cb: ICallback<number>): void;
+    zrange(key: string, min: number, max: number, cb: ICallback<string[]>): void;
+    psubscribe(pattern: string): void;
+    punsubscribe(channel: string): void;
+    subscribe(channel: string): void;
+    unsubscribe(channel: string): void;
+    zrangebyscore(key: string, min: number | string, max: number | string, cb: ICallback<string[]>): void;
+    smembers(key: string, cb: ICallback<string[]>): void;
+    sadd(key: string, member: string, cb: ICallback<number>): void;
+    hgetall(key: string, cb: ICallback<Record<string, string>>): void;
+    hget(key: string, field: string, cb: ICallback<string | null>): void;
+    hset(key: string, field: string, value: string, cb: ICallback<number>): void;
+    hdel(key: string, fields: string | string[], cb: ICallback<number>): void;
+    lrange(key: string, start: number, stop: number, cb: ICallback<string[]>): void;
+    hkeys(key: string, cb: ICallback<string[]>): void;
+    hlen(key: string, cb: ICallback<number>): void;
+    brpoplpush(source: string, destination: string, timeout: number, cb: ICallback<string | null>): void;
+    rpoplpush(source: string, destination: string, cb: ICallback<string | null>): void;
+    zrangebyscorewithscores(source: string, min: number, max: number, cb: ICallback<Record<string, string>>): void;
+    rpop(key: string, cb: ICallback<string | null>): void;
+    lrem(key: string, count: number, element: string, cb: ICallback<number>): void;
+    publish(channel: string, message: string, cb: ICallback<number>): void;
+    flushall(cb: ICallback<string>): void;
+    loadScript(script: string, cb: ICallback<string>): void;
+    evalsha(hash: string, args: (string | number)[] | string | number, cb: (err?: Error | null, res?: unknown) => void): void;
+    get(key: string, cb: ICallback<string | null>): void;
+    del(key: string | string[], cb: ICallback<number>): void;
+    llen(key: string, cb: ICallback<number>): void;
+    lmove(source: string, destination: string, from: 'LEFT' | 'RIGHT', to: 'LEFT' | 'RIGHT', cb: ICallback<string | null>): void;
+    zremrangebyscore(source: string, min: number | string, max: number | string, cb: ICallback<number>): void;
+    hmget(source: string, keys: string[], cb: ICallback<(string | null)[]>): void;
+    halt(cb: ICallback<void>): void;
+    end(flush: boolean): void;
+    quit(cb?: ICallback<void>): void;
+    getInfo(cb: ICallback<string>): void;
+    on(event: string, listener: (...args: unknown[]) => any): this;
+}

package/dist/src/redis-client/clients/ioredis-client.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IoredisClient = void 0;
+const redis_client_1 = require("../redis-client");
+const redis_client_error_1 = require("../errors/redis-client.error");
+const IORedis = require("ioredis");
+const ioredis_client_multi_1 = require("./ioredis-client-multi");
+class IoredisClient extends redis_client_1.RedisClient {
+    constructor(config = {}) {
+        super();
+        this.client = new IORedis(config);
+        this.client.once('ready', () => {
+            this.connectionClosed = false;
+            this.emit('ready');
+        });
+        this.client.once('end', () => {
+            this.connectionClosed = true;
+            this.emit('end');
+        });
+    }
+    set(key, value, options, cb) {
+        if (options.exists && options.expire) {
+            this.client.set(key, value, options.expire.mode, options.expire.value, options.exists, cb);
+        }
+        else if (options.expire) {
+            this.client.set(key, value, options.expire.mode, options.expire.value, cb);
+        }
+        else if (options.exists) {
+            this.client.set(key, value, options.exists, cb);
+        }
+        else {
+            this.client.set(key, value, cb);
+        }
+    }
+    zadd(key, score, member, cb) {
+        this.client.zadd(key, score, member, cb);
+    }
+    multi() {
+        return new ioredis_client_multi_1.IoredisClientMulti(this.client);
+    }
+    watch(args, cb) {
+        this.client.watch(args, cb);
+    }
+    unwatch(cb) {
+        this.client.unwatch(cb);
+    }
+    sismember(key, member, cb) {
+        this.client.sismember(key, member, cb);
+    }
+    zcard(key, cb) {
+        this.client.zcard(key, cb);
+    }
+    zrange(key, min, max, cb) {
+        this.client.zrange(key, min, max, cb);
+    }
+    psubscribe(pattern) {
+        this.client.psubscribe(pattern);
+    }
+    punsubscribe(channel) {
+        this.client.punsubscribe(channel);
+    }
+    subscribe(channel) {
+        this.client.subscribe(channel);
+    }
+    unsubscribe(channel) {
+        this.client.unsubscribe(channel);
+    }
+    zrangebyscore(key, min, max, cb) {
+        this.client.zrangebyscore(key, min, max, cb);
+    }
+    smembers(key, cb) {
+        this.client.smembers(key, cb);
+    }
+    sadd(key, member, cb) {
+        this.client.sadd(key, member, cb);
+    }
+    hgetall(key, cb) {
+        this.client.hgetall(key, cb);
+    }
+    hget(key, field, cb) {
+        this.client.hget(key, field, cb);
+    }
+    hset(key, field, value, cb) {
+        this.client.hset(key, field, value, cb);
+    }
+    hdel(key, fields, cb) {
+        this.client.hdel(key, fields, cb);
+    }
+    lrange(key, start, stop, cb) {
+        this.client.lrange(key, start, stop, cb);
+    }
+    hkeys(key, cb) {
+        this.client.hkeys(key, cb);
+    }
+    hlen(key, cb) {
+        this.client.hlen(key, cb);
+    }
+    brpoplpush(source, destination, timeout, cb) {
+        this.client.brpoplpush(source, destination, timeout, cb);
+    }
+    rpoplpush(source, destination, cb) {
+        this.client.rpoplpush(source, destination, cb);
+    }
+    zrangebyscorewithscores(source, min, max, cb) {
+        this.client.zrangebyscore(source, min, max, 'WITHSCORES', (err, reply) => {
+            if (err)
+                cb(err);
+            else {
+                const replyRange = reply !== null && reply !== void 0 ? reply : [];
+                const range = {};
+                for (let slice = replyRange.splice(0, 2); slice.length > 0; slice = replyRange.splice(0, 2)) {
+                    const [member, score] = slice;
+                    range[score] = member;
+                }
+                cb(null, range);
+            }
+        });
+    }
+    rpop(key, cb) {
+        this.client.rpop(key, cb);
+    }
+    lrem(key, count, element, cb) {
+        this.client.lrem(key, count, element, cb);
+    }
+    publish(channel, message, cb) {
+        this.client.publish(channel, message, cb);
+    }
+    flushall(cb) {
+        this.client.flushall(cb);
+    }
+    loadScript(script, cb) {
+        this.client.script('load', script, cb);
+    }
+    evalsha(hash, args, cb) {
+        const arrHash = [hash];
+        const arrArgs = Array.isArray(args) ? args : [args];
+        this.client.evalsha(arrHash.concat(arrArgs), cb);
+    }
+    get(key, cb) {
+        this.client.get(key, cb);
+    }
+    del(key, cb) {
+        this.client.del(key, cb);
+    }
+    llen(key, cb) {
+        this.client.llen(key, cb);
+    }
+    lmove(source, destination, from, to, cb) {
+        if (!this.validateRedisVersion(6, 2)) {
+            cb(new redis_client_error_1.RedisClientError('Command not supported by your Redis server. Minimal required Redis server version is 6.2.0.'));
+        }
+        else {
+            this.client.lmove(source, destination, from, to, cb);
+        }
+    }
+    zremrangebyscore(source, min, max, cb) {
+        this.client.zremrangebyscore(source, min, max, cb);
+    }
+    hmget(source, keys, cb) {
+        this.client.hmget(source, keys, cb);
+    }
+    halt(cb) {
+        if (!this.connectionClosed) {
+            this.client.once('end', cb);
+            this.end(true);
+        }
+        else
+            cb();
+    }
+    end(flush) {
+        if (!this.connectionClosed) {
+            this.client.disconnect(false);
+        }
+    }
+    quit(cb = () => void 0) {
+        if (!this.connectionClosed) {
+            this.client.once('end', cb);
+            this.client.quit();
+        }
+        else
+            cb();
+    }
+    getInfo(cb) {
+        this.client.info(cb);
+    }
+    on(event, listener) {
+        this.client.on(event, listener);
+        return this;
+    }
+}
+exports.IoredisClient = IoredisClient;
+//# sourceMappingURL=ioredis-client.js.map

package/dist/src/redis-client/clients/node-redis-v3-client-multi.d.ts

@@ -0,0 +1,24 @@
+import { ICallback, IRedisClientMulti } from '../../../types';
+import { Multi, RedisClient } from 'redis';
+export declare class NodeRedisV3ClientMulti implements IRedisClientMulti {
+    protected multi: Multi;
+    constructor(client: RedisClient);
+    lrem(key: string, count: number, element: string): this;
+    lpop(key: string): this;
+    lpush(key: string, element: string): this;
+    ltrim(key: string, start: number, stop: number): this;
+    rpop(key: string): this;
+    rpush(key: string, element: string): this;
+    zadd(key: string, score: number, element: string): this;
+    zrem(key: string, element: string | string[]): this;
+    sadd(key: string, element: string): this;
+    srem(key: string, element: string | string[]): this;
+    hset(key: string, field: string, value: string): this;
+    hdel(key: string, field: string | string[]): this;
+    hincrby(key: string, field: string, by: number): this;
+    pexpire(key: string, millis: number): this;
+    expire(key: string, secs: number): this;
+    rpoplpush(source: string, destination: string): this;
+    del(key: string | string[]): this;
+    exec(cb: ICallback<unknown[]>): void;
+}

package/dist/src/redis-client/clients/node-redis-v3-client-multi.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeRedisV3ClientMulti = void 0;
+const watched_keys_changed_error_1 = require("../errors/watched-keys-changed.error");
+class NodeRedisV3ClientMulti {
+    constructor(client) {
+        this.multi = client.multi();
+    }
+    lrem(key, count, element) {
+        this.multi.lrem(key, count, element);
+        return this;
+    }
+    lpop(key) {
+        this.multi.lpop(key);
+        return this;
+    }
+    lpush(key, element) {
+        this.multi.lpush(key, element);
+        return this;
+    }
+    ltrim(key, start, stop) {
+        this.multi.ltrim(key, start, stop);
+        return this;
+    }
+    rpop(key) {
+        this.multi.rpop(key);
+        return this;
+    }
+    rpush(key, element) {
+        this.multi.rpush(key, element);
+        return this;
+    }
+    zadd(key, score, element) {
+        this.multi.zadd(key, score, element);
+        return this;
+    }
+    zrem(key, element) {
+        this.multi.zrem(key, element);
+        return this;
+    }
+    sadd(key, element) {
+        this.multi.sadd(key, element);
+        return this;
+    }
+    srem(key, element) {
+        this.multi.srem(key, element);
+        return this;
+    }
+    hset(key, field, value) {
+        this.multi.hset(key, field, value);
+        return this;
+    }
+    hdel(key, field) {
+        this.multi.hdel(key, field);
+        return this;
+    }
+    hincrby(key, field, by) {
+        this.multi.hincrby(key, field, by);
+        return this;
+    }
+    pexpire(key, millis) {
+        this.multi.pexpire(key, millis);
+        return this;
+    }
+    expire(key, secs) {
+        this.multi.expire(key, secs);
+        return this;
+    }
+    rpoplpush(source, destination) {
+        this.multi.rpoplpush(source, destination);
+        return this;
+    }
+    del(key) {
+        this.multi.del(key);
+        return this;
+    }
+    exec(cb) {
+        this.multi.exec((err, reply) => {
+            if (err)
+                cb(err);
+            else if (!reply)
+                cb(new watched_keys_changed_error_1.WatchedKeysChangedError());
+            else
+                cb(null, reply);
+        });
+    }
+}
+exports.NodeRedisV3ClientMulti = NodeRedisV3ClientMulti;
+//# sourceMappingURL=node-redis-v3-client-multi.js.map