@hypernetlabs/common-redis-provider/lib/RedisClient.js

Redis provider, ready for injection, using Neverthrow

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.RedisClient = void 0;
const neverthrow_1 = require("neverthrow");
const redlock_1 = __importDefault(require("redlock"));
const RedisError_1 = require("./RedisError");
const RedlockWrapper_1 = require("./RedlockWrapper");
class RedisClient {
    constructor(redisClient, config) {
        this.redisClient = redisClient;
        this.config = config;
        this.redlock = new redlock_1.default([redisClient], {
            // the expected clock drift; for more details
            // see http://redis.io/topics/distlock
            driftFactor: config.redlockDriftFactor || 0.01,
            // the max number of times Redlock will attempt
            // to lock a resource before erroring
            retryCount: config.redlockRetryCount || 10,
            // the time in ms between attempts
            retryDelay: config.redlockRetryDelay || 200,
            // the max time in ms randomly added to retries
            // to improve performance under high contention
            // see https://www.awsarchitectureblog.com/2015/03/backoff.html
            retryJitter: config.redlockRetryJitter || 200, // time in ms
        });
        // Report any errors from the redis locking mechanism
        this.redlock.on("clientError", (err) => {
            console.error(err);
        });
    }
    get(key) {
        return neverthrow_1.ResultAsync.fromPromise(new Promise((resolve, reject) => {
            this.redisClient.get(key, (error, val) => {
                if (error != null) {
                    reject(error);
                }
                else {
                    resolve(val);
                }
            });
        }), (e) => {
            return new RedisError_1.RedisError(`Cannot get key ${key} from Redis`, e);
        });
    }
    del(key) {
        return neverthrow_1.ResultAsync.fromPromise(new Promise((resolve, reject) => {
            this.redisClient.del(key, (error) => {
                if (error != null) {
                    reject(error);
                }
                else {
                    resolve();
                }
            });
        }), (e) => {
            return new RedisError_1.RedisError(`Cannot del key ${key} from Redis`, e);
        });
    }
    set(key, value, duration) {
        return neverthrow_1.ResultAsync.fromPromise(new Promise((resolve, reject) => {
            this.redisClient.set(key, value, "EX", duration, (error, val) => {
                if (error != null) {
                    reject(error);
                }
                else {
                    resolve(undefined);
                }
            });
        }), (e) => {
            return new RedisError_1.RedisError(`Cannot set key ${key} in Redis`, e);
        });
    }
    sendCommand(command, args) {
        return neverthrow_1.ResultAsync.fromPromise(new Promise((resolve, reject) => {
            this.redisClient.sendCommand(command, args, (err, val) => {
                if (err == null) {
                    resolve(val);
                }
                else {
                    reject(err);
                }
            });
        }), (e) => {
            return new RedisError_1.RedisError(`Cannot add event to stream ${command}`, e);
        });
    }
    lock(lockNames, ttl) {
        return neverthrow_1.ResultAsync.fromPromise(this.redlock.lock(lockNames, ttl), (e) => {
            return new RedisError_1.RedisError(`Unable to aquire locks ${lockNames}`, e);
        }).map((lock) => {
            return new RedlockWrapper_1.RedlockWrapper(lock);
        });
    }
    duplicate() {
        return new RedisClient(this.redisClient.duplicate(), this.config);
    }
    getClient() {
        return this.redisClient;
    }
}
exports.RedisClient = RedisClient;
//# sourceMappingURL=RedisClient.js.map