orcaq 1.0.26 → 1.0.28

package/.output/server/node_modules/ioredis/built/DataHandler.js

@@ -1,220 +0,0 @@
-"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,
-        };
-        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/.output/server/node_modules/ioredis/built/Pipeline.js

@@ -1,334 +0,0 @@
-"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) && (0, commands_1.hasFlag)(command.name, "readonly");
-                    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;
-                        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;
-    }
-};