redis-smq-common 1.0.0-rc.3 → 1.0.0-rc.4

package/CHANGELOG.md

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

package/README.md

@@ -7,6 +7,7 @@
 
 <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>

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,22 @@
+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): this;
+    sadd(key: string, element: string): this;
+    srem(key: string, element: string): this;
+    hset(key: string, field: string, value: string): this;
+    hdel(key: string, field: string): this;
+    pexpire(key: string, millis: number): this;
+    rpoplpush(source: string, destination: string): this;
+    del(key: string): this;
+    exec(cb: ICallback<unknown[]>): void;
+}

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IoredisClientMulti = void 0;
+const redis_client_error_1 = require("../errors/redis-client.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, 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;
+    }
+    pexpire(key, millis) {
+        this.multi.pexpire(key, millis);
+        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 redis_client_error_1.RedisClientError(`Redis transaction has been abandoned. Try again.`));
+            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,54 @@
+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>): 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;
+    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>): 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>): void;
+    rpoplpush(source: string, destination: string, cb: ICallback<string>): void;
+    zrangebyscorewithscores(source: string, min: number, max: number, cb: ICallback<Record<string, string>>): void;
+    rpop(key: string, cb: ICallback<string>): 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>): 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>): 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,186 @@
+"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);
+    }
+    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,22 @@
+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): this;
+    sadd(key: string, element: string): this;
+    srem(key: string, element: string): this;
+    hset(key: string, field: string, value: string): this;
+    hdel(key: string, field: string): this;
+    pexpire(key: string, millis: number): this;
+    rpoplpush(source: string, destination: string): this;
+    del(key: string): this;
+    exec(cb: ICallback<unknown[]>): void;
+}

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeRedisV3ClientMulti = void 0;
+const redis_client_error_1 = require("../errors/redis-client.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;
+    }
+    pexpire(key, millis) {
+        this.multi.pexpire(key, millis);
+        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 redis_client_error_1.RedisClientError(`Redis transaction has been abandoned. Try again.`));
+            else
+                cb(null, reply);
+        });
+    }
+}
+exports.NodeRedisV3ClientMulti = NodeRedisV3ClientMulti;
+//# sourceMappingURL=node-redis-v3-client-multi.js.map

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

@@ -0,0 +1,54 @@
+import { RedisClient } from '../redis-client';
+import { ICallback } from '../../../types';
+import { ClientOpts, RedisClient as NodeRedis } from 'redis';
+import { NodeRedisV3ClientMulti } from './node-redis-v3-client-multi';
+export declare class NodeRedisV3Client extends RedisClient {
+    protected client: NodeRedis;
+    constructor(config?: ClientOpts);
+    set(key: string, value: string, options: {
+        expire?: {
+            mode: 'EX' | 'PX';
+            value: number;
+        };
+        exists?: 'NX' | 'XX';
+    }, cb: ICallback<string>): void;
+    zadd(key: string, score: number, member: string, cb: ICallback<number | string>): void;
+    multi(): NodeRedisV3ClientMulti;
+    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;
+    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>): 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>): void;
+    rpoplpush(source: string, destination: string, cb: ICallback<string>): void;
+    zrangebyscorewithscores(source: string, min: number, max: number, cb: ICallback<Record<string, string>>): void;
+    rpop(key: string, cb: ICallback<string>): 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>): 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>): 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;
+}