orcaq 1.0.20

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

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_1 = require("@ioredis/commands");
+const calculateSlot = require("cluster-key-slot");
+const standard_as_callback_1 = require("standard-as-callback");
+const utils_1 = require("./utils");
+/**
+ * Command instance
+ *
+ * It's rare that you need to create a Command instance yourself.
+ *
+ * ```js
+ * var infoCommand = new Command('info', null, function (err, result) {
+ *   console.log('result', result);
+ * });
+ *
+ * redis.sendCommand(infoCommand);
+ *
+ * // When no callback provided, Command instance will have a `promise` property,
+ * // which will resolve/reject with the result of the command.
+ * var getCommand = new Command('get', ['foo']);
+ * getCommand.promise.then(function (result) {
+ *   console.log('result', result);
+ * });
+ * ```
+ */
+class Command {
+    /**
+     * Creates an instance of Command.
+     * @param name Command name
+     * @param args An array of command arguments
+     * @param options
+     * @param callback The callback that handles the response.
+     * If omit, the response will be handled via Promise
+     */
+    constructor(name, args = [], options = {}, callback) {
+        this.name = name;
+        this.inTransaction = false;
+        this.isResolved = false;
+        this.transformed = false;
+        this.replyEncoding = options.replyEncoding;
+        this.errorStack = options.errorStack;
+        this.args = args.flat();
+        this.callback = callback;
+        this.initPromise();
+        if (options.keyPrefix) {
+            // @ts-expect-error
+            const isBufferKeyPrefix = options.keyPrefix instanceof Buffer;
+            // @ts-expect-error
+            let keyPrefixBuffer = isBufferKeyPrefix
+                ? options.keyPrefix
+                : null;
+            this._iterateKeys((key) => {
+                if (key instanceof Buffer) {
+                    if (keyPrefixBuffer === null) {
+                        keyPrefixBuffer = Buffer.from(options.keyPrefix);
+                    }
+                    return Buffer.concat([keyPrefixBuffer, key]);
+                }
+                else if (isBufferKeyPrefix) {
+                    // @ts-expect-error
+                    return Buffer.concat([options.keyPrefix, Buffer.from(String(key))]);
+                }
+                return options.keyPrefix + key;
+            });
+        }
+        if (options.readOnly) {
+            this.isReadOnly = true;
+        }
+    }
+    /**
+     * Check whether the command has the flag
+     */
+    static checkFlag(flagName, commandName) {
+        return !!this.getFlagMap()[flagName][commandName];
+    }
+    static setArgumentTransformer(name, func) {
+        this._transformer.argument[name] = func;
+    }
+    static setReplyTransformer(name, func) {
+        this._transformer.reply[name] = func;
+    }
+    static getFlagMap() {
+        if (!this.flagMap) {
+            this.flagMap = Object.keys(Command.FLAGS).reduce((map, flagName) => {
+                map[flagName] = {};
+                Command.FLAGS[flagName].forEach((commandName) => {
+                    map[flagName][commandName] = true;
+                });
+                return map;
+            }, {});
+        }
+        return this.flagMap;
+    }
+    getSlot() {
+        if (typeof this.slot === "undefined") {
+            const key = this.getKeys()[0];
+            this.slot = key == null ? null : calculateSlot(key);
+        }
+        return this.slot;
+    }
+    getKeys() {
+        return this._iterateKeys();
+    }
+    /**
+     * Convert command to writable buffer or string
+     */
+    toWritable(_socket) {
+        let result;
+        const commandStr = "*" +
+            (this.args.length + 1) +
+            "\r\n$" +
+            Buffer.byteLength(this.name) +
+            "\r\n" +
+            this.name +
+            "\r\n";
+        if (this.bufferMode) {
+            const buffers = new MixedBuffers();
+            buffers.push(commandStr);
+            for (let i = 0; i < this.args.length; ++i) {
+                const arg = this.args[i];
+                if (arg instanceof Buffer) {
+                    if (arg.length === 0) {
+                        buffers.push("$0\r\n\r\n");
+                    }
+                    else {
+                        buffers.push("$" + arg.length + "\r\n");
+                        buffers.push(arg);
+                        buffers.push("\r\n");
+                    }
+                }
+                else {
+                    buffers.push("$" +
+                        Buffer.byteLength(arg) +
+                        "\r\n" +
+                        arg +
+                        "\r\n");
+                }
+            }
+            result = buffers.toBuffer();
+        }
+        else {
+            result = commandStr;
+            for (let i = 0; i < this.args.length; ++i) {
+                const arg = this.args[i];
+                result +=
+                    "$" +
+                        Buffer.byteLength(arg) +
+                        "\r\n" +
+                        arg +
+                        "\r\n";
+            }
+        }
+        return result;
+    }
+    stringifyArguments() {
+        for (let i = 0; i < this.args.length; ++i) {
+            const arg = this.args[i];
+            if (typeof arg === "string") {
+                // buffers and strings don't need any transformation
+            }
+            else if (arg instanceof Buffer) {
+                this.bufferMode = true;
+            }
+            else {
+                this.args[i] = (0, utils_1.toArg)(arg);
+            }
+        }
+    }
+    /**
+     * Convert buffer/buffer[] to string/string[],
+     * and apply reply transformer.
+     */
+    transformReply(result) {
+        if (this.replyEncoding) {
+            result = (0, utils_1.convertBufferToString)(result, this.replyEncoding);
+        }
+        const transformer = Command._transformer.reply[this.name];
+        if (transformer) {
+            result = transformer(result);
+        }
+        return result;
+    }
+    /**
+     * Set the wait time before terminating the attempt to execute a command
+     * and generating an error.
+     */
+    setTimeout(ms) {
+        if (!this._commandTimeoutTimer) {
+            this._commandTimeoutTimer = setTimeout(() => {
+                if (!this.isResolved) {
+                    this.reject(new Error("Command timed out"));
+                }
+            }, ms);
+        }
+    }
+    initPromise() {
+        const promise = new Promise((resolve, reject) => {
+            if (!this.transformed) {
+                this.transformed = true;
+                const transformer = Command._transformer.argument[this.name];
+                if (transformer) {
+                    this.args = transformer(this.args);
+                }
+                this.stringifyArguments();
+            }
+            this.resolve = this._convertValue(resolve);
+            if (this.errorStack) {
+                this.reject = (err) => {
+                    reject((0, utils_1.optimizeErrorStack)(err, this.errorStack.stack, __dirname));
+                };
+            }
+            else {
+                this.reject = reject;
+            }
+        });
+        this.promise = (0, standard_as_callback_1.default)(promise, this.callback);
+    }
+    /**
+     * Iterate through the command arguments that are considered keys.
+     */
+    _iterateKeys(transform = (key) => key) {
+        if (typeof this.keys === "undefined") {
+            this.keys = [];
+            if ((0, commands_1.exists)(this.name)) {
+                // @ts-expect-error
+                const keyIndexes = (0, commands_1.getKeyIndexes)(this.name, this.args);
+                for (const index of keyIndexes) {
+                    this.args[index] = transform(this.args[index]);
+                    this.keys.push(this.args[index]);
+                }
+            }
+        }
+        return this.keys;
+    }
+    /**
+     * Convert the value from buffer to the target encoding.
+     */
+    _convertValue(resolve) {
+        return (value) => {
+            try {
+                const existingTimer = this._commandTimeoutTimer;
+                if (existingTimer) {
+                    clearTimeout(existingTimer);
+                    delete this._commandTimeoutTimer;
+                }
+                resolve(this.transformReply(value));
+                this.isResolved = true;
+            }
+            catch (err) {
+                this.reject(err);
+            }
+            return this.promise;
+        };
+    }
+}
+exports.default = Command;
+Command.FLAGS = {
+    VALID_IN_SUBSCRIBER_MODE: [
+        "subscribe",
+        "psubscribe",
+        "unsubscribe",
+        "punsubscribe",
+        "ssubscribe",
+        "sunsubscribe",
+        "ping",
+        "quit",
+    ],
+    VALID_IN_MONITOR_MODE: ["monitor", "auth"],
+    ENTER_SUBSCRIBER_MODE: ["subscribe", "psubscribe", "ssubscribe"],
+    EXIT_SUBSCRIBER_MODE: ["unsubscribe", "punsubscribe", "sunsubscribe"],
+    WILL_DISCONNECT: ["quit"],
+};
+Command._transformer = {
+    argument: {},
+    reply: {},
+};
+const msetArgumentTransformer = function (args) {
+    if (args.length === 1) {
+        if (args[0] instanceof Map) {
+            return (0, utils_1.convertMapToArray)(args[0]);
+        }
+        if (typeof args[0] === "object" && args[0] !== null) {
+            return (0, utils_1.convertObjectToArray)(args[0]);
+        }
+    }
+    return args;
+};
+const hsetArgumentTransformer = function (args) {
+    if (args.length === 2) {
+        if (args[1] instanceof Map) {
+            return [args[0]].concat((0, utils_1.convertMapToArray)(args[1]));
+        }
+        if (typeof args[1] === "object" && args[1] !== null) {
+            return [args[0]].concat((0, utils_1.convertObjectToArray)(args[1]));
+        }
+    }
+    return args;
+};
+Command.setArgumentTransformer("mset", msetArgumentTransformer);
+Command.setArgumentTransformer("msetnx", msetArgumentTransformer);
+Command.setArgumentTransformer("hset", hsetArgumentTransformer);
+Command.setArgumentTransformer("hmset", hsetArgumentTransformer);
+Command.setReplyTransformer("hgetall", function (result) {
+    if (Array.isArray(result)) {
+        const obj = {};
+        for (let i = 0; i < result.length; i += 2) {
+            const key = result[i];
+            const value = result[i + 1];
+            if (key in obj) {
+                // can only be truthy if the property is special somehow, like '__proto__' or 'constructor'
+                // https://github.com/luin/ioredis/issues/1267
+                Object.defineProperty(obj, key, {
+                    value,
+                    configurable: true,
+                    enumerable: true,
+                    writable: true,
+                });
+            }
+            else {
+                obj[key] = value;
+            }
+        }
+        return obj;
+    }
+    return result;
+});
+class MixedBuffers {
+    constructor() {
+        this.length = 0;
+        this.items = [];
+    }
+    push(x) {
+        this.length += Buffer.byteLength(x);
+        this.items.push(x);
+    }
+    toBuffer() {
+        const result = Buffer.allocUnsafe(this.length);
+        let offset = 0;
+        for (const item of this.items) {
+            const length = Buffer.byteLength(item);
+            Buffer.isBuffer(item)
+                ? item.copy(result, offset)
+                : result.write(item, offset, length);
+            offset += length;
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,220 @@
+"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;
+}