ioredis-om 5.10.2

package/built/DataHandler.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Command_1 = require("./Command");
+const utils_1 = require("./utils");
+const RedisParser = require("redis-parser");
+const SubscriptionSet_1 = require("./SubscriptionSet");
+const debug = (0, utils_1.Debug)("dataHandler");
+class DataHandler {
+    constructor(redis, parserOptions) {
+        this.redis = redis;
+        const parser = new RedisParser({
+            stringNumbers: parserOptions.stringNumbers,
+            returnBuffers: true,
+            returnError: (err) => {
+                this.returnError(err);
+            },
+            returnFatalError: (err) => {
+                this.returnFatalError(err);
+            },
+            returnReply: (reply) => {
+                this.returnReply(reply);
+            },
+        });
+        // prependListener ensures the parser receives and processes data before socket timeout checks are performed
+        redis.stream.prependListener("data", (data) => {
+            parser.execute(data);
+        });
+        // prependListener() doesn't enable flowing mode automatically - we need to resume the stream manually
+        redis.stream.resume();
+    }
+    returnFatalError(err) {
+        err.message += ". Please report this.";
+        this.redis.recoverFromFatalError(err, err, { offlineQueue: false });
+    }
+    returnError(err) {
+        const item = this.shiftCommand(err);
+        if (!item) {
+            return;
+        }
+        err.command = {
+            name: item.command.name,
+            args: item.command.args,
+        };
+        if (item.command.name == "ssubscribe" && err.message.includes("MOVED")) {
+            this.redis.emit("moved");
+            return;
+        }
+        this.redis.handleReconnection(err, item);
+    }
+    returnReply(reply) {
+        if (this.handleMonitorReply(reply)) {
+            return;
+        }
+        if (this.handleSubscriberReply(reply)) {
+            return;
+        }
+        const item = this.shiftCommand(reply);
+        if (!item) {
+            return;
+        }
+        if (Command_1.default.checkFlag("ENTER_SUBSCRIBER_MODE", item.command.name)) {
+            this.redis.condition.subscriber = new SubscriptionSet_1.default();
+            this.redis.condition.subscriber.add(item.command.name, reply[1].toString());
+            if (!fillSubCommand(item.command, reply[2])) {
+                this.redis.commandQueue.unshift(item);
+            }
+        }
+        else if (Command_1.default.checkFlag("EXIT_SUBSCRIBER_MODE", item.command.name)) {
+            if (!fillUnsubCommand(item.command, reply[2])) {
+                this.redis.commandQueue.unshift(item);
+            }
+        }
+        else {
+            item.command.resolve(reply);
+        }
+    }
+    handleSubscriberReply(reply) {
+        if (!this.redis.condition.subscriber) {
+            return false;
+        }
+        const replyType = Array.isArray(reply) ? reply[0].toString() : null;
+        debug('receive reply "%s" in subscriber mode', replyType);
+        switch (replyType) {
+            case "message":
+                if (this.redis.listeners("message").length > 0) {
+                    // Check if there're listeners to avoid unnecessary `toString()`.
+                    this.redis.emit("message", reply[1].toString(), reply[2] ? reply[2].toString() : "");
+                }
+                this.redis.emit("messageBuffer", reply[1], reply[2]);
+                break;
+            case "pmessage": {
+                const pattern = reply[1].toString();
+                if (this.redis.listeners("pmessage").length > 0) {
+                    this.redis.emit("pmessage", pattern, reply[2].toString(), reply[3].toString());
+                }
+                this.redis.emit("pmessageBuffer", pattern, reply[2], reply[3]);
+                break;
+            }
+            case "smessage": {
+                if (this.redis.listeners("smessage").length > 0) {
+                    this.redis.emit("smessage", reply[1].toString(), reply[2] ? reply[2].toString() : "");
+                }
+                this.redis.emit("smessageBuffer", reply[1], reply[2]);
+                break;
+            }
+            case "ssubscribe":
+            case "subscribe":
+            case "psubscribe": {
+                const channel = reply[1].toString();
+                this.redis.condition.subscriber.add(replyType, channel);
+                const item = this.shiftCommand(reply);
+                if (!item) {
+                    return;
+                }
+                if (!fillSubCommand(item.command, reply[2])) {
+                    this.redis.commandQueue.unshift(item);
+                }
+                break;
+            }
+            case "sunsubscribe":
+            case "unsubscribe":
+            case "punsubscribe": {
+                const channel = reply[1] ? reply[1].toString() : null;
+                if (channel) {
+                    this.redis.condition.subscriber.del(replyType, channel);
+                }
+                const count = reply[2];
+                if (Number(count) === 0) {
+                    this.redis.condition.subscriber = false;
+                }
+                const item = this.shiftCommand(reply);
+                if (!item) {
+                    return;
+                }
+                if (!fillUnsubCommand(item.command, count)) {
+                    this.redis.commandQueue.unshift(item);
+                }
+                break;
+            }
+            default: {
+                const item = this.shiftCommand(reply);
+                if (!item) {
+                    return;
+                }
+                item.command.resolve(reply);
+            }
+        }
+        return true;
+    }
+    handleMonitorReply(reply) {
+        if (this.redis.status !== "monitoring") {
+            return false;
+        }
+        const replyStr = reply.toString();
+        if (replyStr === "OK") {
+            // Valid commands in the monitoring mode are AUTH and MONITOR,
+            // both of which always reply with 'OK'.
+            // So if we got an 'OK', we can make certain that
+            // the reply is made to AUTH & MONITOR.
+            return false;
+        }
+        // Since commands sent in the monitoring mode will trigger an exception,
+        // any replies we received in the monitoring mode should consider to be
+        // realtime monitor data instead of result of commands.
+        const len = replyStr.indexOf(" ");
+        const timestamp = replyStr.slice(0, len);
+        const argIndex = replyStr.indexOf('"');
+        const args = replyStr
+            .slice(argIndex + 1, -1)
+            .split('" "')
+            .map((elem) => elem.replace(/\\"/g, '"'));
+        const dbAndSource = replyStr.slice(len + 2, argIndex - 2).split(" ");
+        this.redis.emit("monitor", timestamp, args, dbAndSource[1], dbAndSource[0]);
+        return true;
+    }
+    shiftCommand(reply) {
+        const item = this.redis.commandQueue.shift();
+        if (!item) {
+            const message = "Command queue state error. If you can reproduce this, please report it.";
+            const error = new Error(message +
+                (reply instanceof Error
+                    ? ` Last error: ${reply.message}`
+                    : ` Last reply: ${reply.toString()}`));
+            this.redis.emit("error", error);
+            return null;
+        }
+        return item;
+    }
+}
+exports.default = DataHandler;
+const remainingRepliesMap = new WeakMap();
+function fillSubCommand(command, count) {
+    let remainingReplies = remainingRepliesMap.has(command)
+        ? remainingRepliesMap.get(command)
+        : command.args.length;
+    remainingReplies -= 1;
+    if (remainingReplies <= 0) {
+        command.resolve(count);
+        remainingRepliesMap.delete(command);
+        return true;
+    }
+    remainingRepliesMap.set(command, remainingReplies);
+    return false;
+}
+function fillUnsubCommand(command, count) {
+    let remainingReplies = remainingRepliesMap.has(command)
+        ? remainingRepliesMap.get(command)
+        : command.args.length;
+    if (remainingReplies === 0) {
+        if (Number(count) === 0) {
+            remainingRepliesMap.delete(command);
+            command.resolve(count);
+            return true;
+        }
+        return false;
+    }
+    remainingReplies -= 1;
+    if (remainingReplies <= 0) {
+        command.resolve(count);
+        return true;
+    }
+    remainingRepliesMap.set(command, remainingReplies);
+    return false;
+}

package/built/Pipeline.d.ts

@@ -0,0 +1,31 @@
+import Redis from "./Redis";
+import Cluster from "./cluster";
+import Command from "./Command";
+import Commander from "./utils/Commander";
+declare class Pipeline extends Commander<{
+    type: "pipeline";
+}> {
+    redis: Redis | Cluster;
+    isCluster: boolean;
+    isPipeline: boolean;
+    leftRedirections: {
+        value?: number;
+    };
+    promise: Promise<unknown>;
+    resolve: (result: unknown) => void;
+    reject: (error: Error) => void;
+    private replyPending;
+    private _queue;
+    private _result;
+    private _transactions;
+    private _shaToScript;
+    private preferKey;
+    constructor(redis: Redis | Cluster);
+    fillResult(value: unknown[], position: number): void;
+    sendCommand(command: Command): unknown;
+    addBatch(commands: any): this;
+}
+export default Pipeline;
+interface Pipeline {
+    length: number;
+}

package/built/Pipeline.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const calculateSlot = require("cluster-key-slot");
+const commands_1 = require("@ioredis/commands");
+const standard_as_callback_1 = require("standard-as-callback");
+const util_1 = require("util");
+const Command_1 = require("./Command");
+const utils_1 = require("./utils");
+const Commander_1 = require("./utils/Commander");
+/*
+  This function derives from the cluster-key-slot implementation.
+  Instead of checking that all keys have the same slot, it checks that all slots are served by the same set of nodes.
+  If this is satisfied, it returns the first key's slot.
+*/
+function generateMultiWithNodes(redis, keys) {
+    const slot = calculateSlot(keys[0]);
+    const target = redis._groupsBySlot[slot];
+    for (let i = 1; i < keys.length; i++) {
+        if (redis._groupsBySlot[calculateSlot(keys[i])] !== target) {
+            return -1;
+        }
+    }
+    return slot;
+}
+class Pipeline extends Commander_1.default {
+    constructor(redis) {
+        super();
+        this.redis = redis;
+        this.isPipeline = true;
+        this.replyPending = 0;
+        this._queue = [];
+        this._result = [];
+        this._transactions = 0;
+        this._shaToScript = {};
+        this.isCluster =
+            this.redis.constructor.name === "Cluster" || this.redis.isCluster;
+        this.options = redis.options;
+        Object.keys(redis.scriptsSet).forEach((name) => {
+            const script = redis.scriptsSet[name];
+            this._shaToScript[script.sha] = script;
+            this[name] = redis[name];
+            this[name + "Buffer"] = redis[name + "Buffer"];
+        });
+        redis.addedBuiltinSet.forEach((name) => {
+            this[name] = redis[name];
+            this[name + "Buffer"] = redis[name + "Buffer"];
+        });
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+        const _this = this;
+        Object.defineProperty(this, "length", {
+            get: function () {
+                return _this._queue.length;
+            },
+        });
+    }
+    fillResult(value, position) {
+        if (this._queue[position].name === "exec" && Array.isArray(value[1])) {
+            const execLength = value[1].length;
+            for (let i = 0; i < execLength; i++) {
+                if (value[1][i] instanceof Error) {
+                    continue;
+                }
+                const cmd = this._queue[position - (execLength - i)];
+                try {
+                    value[1][i] = cmd.transformReply(value[1][i]);
+                }
+                catch (err) {
+                    value[1][i] = err;
+                }
+            }
+        }
+        this._result[position] = value;
+        if (--this.replyPending) {
+            return;
+        }
+        if (this.isCluster) {
+            let retriable = true;
+            let commonError;
+            for (let i = 0; i < this._result.length; ++i) {
+                const error = this._result[i][0];
+                const command = this._queue[i];
+                if (error) {
+                    if (command.name === "exec" &&
+                        error.message ===
+                            "EXECABORT Transaction discarded because of previous errors.") {
+                        continue;
+                    }
+                    if (!commonError) {
+                        commonError = {
+                            name: error.name,
+                            message: error.message,
+                        };
+                    }
+                    else if (commonError.name !== error.name ||
+                        commonError.message !== error.message) {
+                        retriable = false;
+                        break;
+                    }
+                }
+                else if (!command.inTransaction) {
+                    const isReadOnly = (0, commands_1.exists)(command.name, { caseInsensitive: true }) &&
+                        (0, commands_1.hasFlag)(command.name, "readonly", { nameCaseInsensitive: true });
+                    if (!isReadOnly) {
+                        retriable = false;
+                        break;
+                    }
+                }
+            }
+            if (commonError && retriable) {
+                const _this = this;
+                const errv = commonError.message.split(" ");
+                const queue = this._queue;
+                let inTransaction = false;
+                this._queue = [];
+                for (let i = 0; i < queue.length; ++i) {
+                    if (errv[0] === "ASK" &&
+                        !inTransaction &&
+                        queue[i].name !== "asking" &&
+                        (!queue[i - 1] || queue[i - 1].name !== "asking")) {
+                        const asking = new Command_1.default("asking");
+                        asking.ignore = true;
+                        this.sendCommand(asking);
+                    }
+                    queue[i].initPromise();
+                    this.sendCommand(queue[i]);
+                    inTransaction = queue[i].inTransaction;
+                }
+                let matched = true;
+                if (typeof this.leftRedirections === "undefined") {
+                    this.leftRedirections = {};
+                }
+                const exec = function () {
+                    _this.exec();
+                };
+                const cluster = this.redis;
+                cluster.handleError(commonError, this.leftRedirections, {
+                    moved: function (_slot, key) {
+                        _this.preferKey = key;
+                        if (cluster.slots[errv[1]]) {
+                            if (cluster.slots[errv[1]][0] !== key) {
+                                cluster.slots[errv[1]] = [key];
+                            }
+                        }
+                        else {
+                            cluster.slots[errv[1]] = [key];
+                        }
+                        cluster._groupsBySlot[errv[1]] =
+                            cluster._groupsIds[cluster.slots[errv[1]].join(";")];
+                        cluster.refreshSlotsCache();
+                        _this.exec();
+                    },
+                    ask: function (_slot, key) {
+                        _this.preferKey = key;
+                        _this.exec();
+                    },
+                    tryagain: exec,
+                    clusterDown: exec,
+                    connectionClosed: exec,
+                    maxRedirections: () => {
+                        matched = false;
+                    },
+                    defaults: () => {
+                        matched = false;
+                    },
+                });
+                if (matched) {
+                    return;
+                }
+            }
+        }
+        let ignoredCount = 0;
+        for (let i = 0; i < this._queue.length - ignoredCount; ++i) {
+            if (this._queue[i + ignoredCount].ignore) {
+                ignoredCount += 1;
+            }
+            this._result[i] = this._result[i + ignoredCount];
+        }
+        this.resolve(this._result.slice(0, this._result.length - ignoredCount));
+    }
+    sendCommand(command) {
+        if (this._transactions > 0) {
+            command.inTransaction = true;
+        }
+        const position = this._queue.length;
+        command.pipelineIndex = position;
+        command.promise
+            .then((result) => {
+            this.fillResult([null, result], position);
+        })
+            .catch((error) => {
+            this.fillResult([error], position);
+        });
+        this._queue.push(command);
+        return this;
+    }
+    addBatch(commands) {
+        let command, commandName, args;
+        for (let i = 0; i < commands.length; ++i) {
+            command = commands[i];
+            commandName = command[0];
+            args = command.slice(1);
+            this[commandName].apply(this, args);
+        }
+        return this;
+    }
+}
+exports.default = Pipeline;
+// @ts-expect-error
+const multi = Pipeline.prototype.multi;
+// @ts-expect-error
+Pipeline.prototype.multi = function () {
+    this._transactions += 1;
+    return multi.apply(this, arguments);
+};
+// @ts-expect-error
+const execBuffer = Pipeline.prototype.execBuffer;
+// @ts-expect-error
+Pipeline.prototype.execBuffer = (0, util_1.deprecate)(function () {
+    if (this._transactions > 0) {
+        this._transactions -= 1;
+    }
+    return execBuffer.apply(this, arguments);
+}, "Pipeline#execBuffer: Use Pipeline#exec instead");
+// NOTE: To avoid an unhandled promise rejection, this will unconditionally always return this.promise,
+// which always has the rejection handled by standard-as-callback
+// adding the provided rejection callback.
+//
+// If a different promise instance were returned, that promise would cause its own unhandled promise rejection
+// errors, even if that promise unconditionally resolved to **the resolved value of** this.promise.
+Pipeline.prototype.exec = function (callback) {
+    // Wait for the cluster to be connected, since we need nodes information before continuing
+    if (this.isCluster && !this.redis.slots.length) {
+        if (this.redis.status === "wait")
+            this.redis.connect().catch(utils_1.noop);
+        if (callback && !this.nodeifiedPromise) {
+            this.nodeifiedPromise = true;
+            (0, standard_as_callback_1.default)(this.promise, callback);
+        }
+        this.redis.delayUntilReady((err) => {
+            if (err) {
+                this.reject(err);
+                return;
+            }
+            this.exec(callback);
+        });
+        return this.promise;
+    }
+    if (this._transactions > 0) {
+        this._transactions -= 1;
+        return execBuffer.apply(this, arguments);
+    }
+    if (!this.nodeifiedPromise) {
+        this.nodeifiedPromise = true;
+        (0, standard_as_callback_1.default)(this.promise, callback);
+    }
+    if (!this._queue.length) {
+        this.resolve([]);
+    }
+    let pipelineSlot;
+    if (this.isCluster) {
+        // List of the first key for each command
+        const sampleKeys = [];
+        for (let i = 0; i < this._queue.length; i++) {
+            const keys = this._queue[i].getKeys();
+            if (keys.length) {
+                sampleKeys.push(keys[0]);
+            }
+            // For each command, check that the keys belong to the same slot
+            if (keys.length && calculateSlot.generateMulti(keys) < 0) {
+                this.reject(new Error("All the keys in a pipeline command should belong to the same slot"));
+                return this.promise;
+            }
+        }
+        if (sampleKeys.length) {
+            pipelineSlot = generateMultiWithNodes(this.redis, sampleKeys);
+            if (pipelineSlot < 0) {
+                this.reject(new Error("All keys in the pipeline should belong to the same slots allocation group"));
+                return this.promise;
+            }
+        }
+        else {
+            // Send the pipeline to a random node
+            pipelineSlot = (Math.random() * 16384) | 0;
+        }
+    }
+    const _this = this;
+    execPipeline();
+    return this.promise;
+    function execPipeline() {
+        let writePending = (_this.replyPending = _this._queue.length);
+        let node;
+        if (_this.isCluster) {
+            node = {
+                slot: pipelineSlot,
+                redis: _this.redis.connectionPool.nodes.all[_this.preferKey],
+            };
+        }
+        let data = "";
+        let buffers;
+        const stream = {
+            isPipeline: true,
+            destination: _this.isCluster ? node : { redis: _this.redis },
+            write(writable) {
+                if (typeof writable !== "string") {
+                    if (!buffers) {
+                        buffers = [];
+                    }
+                    if (data) {
+                        buffers.push(Buffer.from(data, "utf8"));
+                        data = "";
+                    }
+                    buffers.push(writable);
+                }
+                else {
+                    data += writable;
+                }
+                if (!--writePending) {
+                    if (buffers) {
+                        if (data) {
+                            buffers.push(Buffer.from(data, "utf8"));
+                        }
+                        stream.destination.redis.stream.write(Buffer.concat(buffers));
+                    }
+                    else {
+                        stream.destination.redis.stream.write(data);
+                    }
+                    // Reset writePending for resending
+                    writePending = _this._queue.length;
+                    data = "";
+                    buffers = undefined;
+                }
+            },
+        };
+        for (let i = 0; i < _this._queue.length; ++i) {
+            _this.redis.sendCommand(_this._queue[i], stream, node);
+        }
+        return _this.promise;
+    }
+};