orcaq 1.0.20

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+/**
+ * Convenient class to convert the process of scanning keys to a readable stream.
+ */
+class ScanStream extends stream_1.Readable {
+    constructor(opt) {
+        super(opt);
+        this.opt = opt;
+        this._redisCursor = "0";
+        this._redisDrained = false;
+    }
+    _read() {
+        if (this._redisDrained) {
+            this.push(null);
+            return;
+        }
+        const args = [this._redisCursor];
+        if (this.opt.key) {
+            args.unshift(this.opt.key);
+        }
+        if (this.opt.match) {
+            args.push("MATCH", this.opt.match);
+        }
+        if (this.opt.type) {
+            args.push("TYPE", this.opt.type);
+        }
+        if (this.opt.count) {
+            args.push("COUNT", String(this.opt.count));
+        }
+        if (this.opt.noValues) {
+            args.push("NOVALUES");
+        }
+        this.opt.redis[this.opt.command](args, (err, res) => {
+            if (err) {
+                this.emit("error", err);
+                return;
+            }
+            this._redisCursor = res[0] instanceof Buffer ? res[0].toString() : res[0];
+            if (this._redisCursor === "0") {
+                this._redisDrained = true;
+            }
+            this.push(res[1]);
+        });
+    }
+    close() {
+        this._redisDrained = true;
+    }
+}
+exports.default = ScanStream;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const Command_1 = require("./Command");
+const standard_as_callback_1 = require("standard-as-callback");
+class Script {
+    constructor(lua, numberOfKeys = null, keyPrefix = "", readOnly = false) {
+        this.lua = lua;
+        this.numberOfKeys = numberOfKeys;
+        this.keyPrefix = keyPrefix;
+        this.readOnly = readOnly;
+        this.sha = (0, crypto_1.createHash)("sha1").update(lua).digest("hex");
+        const sha = this.sha;
+        const socketHasScriptLoaded = new WeakSet();
+        this.Command = class CustomScriptCommand extends Command_1.default {
+            toWritable(socket) {
+                const origReject = this.reject;
+                this.reject = (err) => {
+                    if (err.message.indexOf("NOSCRIPT") !== -1) {
+                        socketHasScriptLoaded.delete(socket);
+                    }
+                    origReject.call(this, err);
+                };
+                if (!socketHasScriptLoaded.has(socket)) {
+                    socketHasScriptLoaded.add(socket);
+                    this.name = "eval";
+                    this.args[0] = lua;
+                }
+                else if (this.name === "eval") {
+                    this.name = "evalsha";
+                    this.args[0] = sha;
+                }
+                return super.toWritable(socket);
+            }
+        };
+    }
+    execute(container, args, options, callback) {
+        if (typeof this.numberOfKeys === "number") {
+            args.unshift(this.numberOfKeys);
+        }
+        if (this.keyPrefix) {
+            options.keyPrefix = this.keyPrefix;
+        }
+        if (this.readOnly) {
+            options.readOnly = true;
+        }
+        const evalsha = new this.Command("evalsha", [this.sha, ...args], options);
+        evalsha.promise = evalsha.promise.catch((err) => {
+            if (err.message.indexOf("NOSCRIPT") === -1) {
+                throw err;
+            }
+            // Resend the same custom evalsha command that gets transformed
+            // to an eval in case it's not loaded yet on the connection.
+            const resend = new this.Command("evalsha", [this.sha, ...args], options);
+            const client = container.isPipeline ? container.redis : container;
+            return client.sendCommand(resend);
+        });
+        (0, standard_as_callback_1.default)(evalsha.promise, callback);
+        return container.sendCommand(evalsha);
+    }
+}
+exports.default = Script;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Tiny class to simplify dealing with subscription set
+ */
+class SubscriptionSet {
+    constructor() {
+        this.set = {
+            subscribe: {},
+            psubscribe: {},
+            ssubscribe: {},
+        };
+    }
+    add(set, channel) {
+        this.set[mapSet(set)][channel] = true;
+    }
+    del(set, channel) {
+        delete this.set[mapSet(set)][channel];
+    }
+    channels(set) {
+        return Object.keys(this.set[mapSet(set)]);
+    }
+    isEmpty() {
+        return (this.channels("subscribe").length === 0 &&
+            this.channels("psubscribe").length === 0 &&
+            this.channels("ssubscribe").length === 0);
+    }
+}
+exports.default = SubscriptionSet;
+function mapSet(set) {
+    if (set === "unsubscribe") {
+        return "subscribe";
+    }
+    if (set === "punsubscribe") {
+        return "psubscribe";
+    }
+    if (set === "sunsubscribe") {
+        return "ssubscribe";
+    }
+    return set;
+}

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

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWithAutoPipelining = exports.getFirstValueInFlattenedArray = exports.shouldUseAutoPipelining = exports.notAllowedAutoPipelineCommands = exports.kCallbacks = exports.kExec = void 0;
+const lodash_1 = require("./utils/lodash");
+const calculateSlot = require("cluster-key-slot");
+const standard_as_callback_1 = require("standard-as-callback");
+exports.kExec = Symbol("exec");
+exports.kCallbacks = Symbol("callbacks");
+exports.notAllowedAutoPipelineCommands = [
+    "auth",
+    "info",
+    "script",
+    "quit",
+    "cluster",
+    "pipeline",
+    "multi",
+    "subscribe",
+    "psubscribe",
+    "unsubscribe",
+    "unpsubscribe",
+    "select",
+];
+function executeAutoPipeline(client, slotKey) {
+    /*
+      If a pipeline is already executing, keep queueing up commands
+      since ioredis won't serve two pipelines at the same time
+    */
+    if (client._runningAutoPipelines.has(slotKey)) {
+        return;
+    }
+    if (!client._autoPipelines.has(slotKey)) {
+        /*
+          Rare edge case. Somehow, something has deleted this running autopipeline in an immediate
+          call to executeAutoPipeline.
+         
+          Maybe the callback in the pipeline.exec is sometimes called in the same tick,
+          e.g. if redis is disconnected?
+        */
+        return;
+    }
+    client._runningAutoPipelines.add(slotKey);
+    // Get the pipeline and immediately delete it so that new commands are queued on a new pipeline
+    const pipeline = client._autoPipelines.get(slotKey);
+    client._autoPipelines.delete(slotKey);
+    const callbacks = pipeline[exports.kCallbacks];
+    // Stop keeping a reference to callbacks immediately after the callbacks stop being used.
+    // This allows the GC to reclaim objects referenced by callbacks, especially with 16384 slots
+    // in Redis.Cluster
+    pipeline[exports.kCallbacks] = null;
+    // Perform the call
+    pipeline.exec(function (err, results) {
+        client._runningAutoPipelines.delete(slotKey);
+        /*
+          Invoke all callback in nextTick so the stack is cleared
+          and callbacks can throw errors without affecting other callbacks.
+        */
+        if (err) {
+            for (let i = 0; i < callbacks.length; i++) {
+                process.nextTick(callbacks[i], err);
+            }
+        }
+        else {
+            for (let i = 0; i < callbacks.length; i++) {
+                process.nextTick(callbacks[i], ...results[i]);
+            }
+        }
+        // If there is another pipeline on the same node, immediately execute it without waiting for nextTick
+        if (client._autoPipelines.has(slotKey)) {
+            executeAutoPipeline(client, slotKey);
+        }
+    });
+}
+function shouldUseAutoPipelining(client, functionName, commandName) {
+    return (functionName &&
+        client.options.enableAutoPipelining &&
+        !client.isPipeline &&
+        !exports.notAllowedAutoPipelineCommands.includes(commandName) &&
+        !client.options.autoPipeliningIgnoredCommands.includes(commandName));
+}
+exports.shouldUseAutoPipelining = shouldUseAutoPipelining;
+function getFirstValueInFlattenedArray(args) {
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (typeof arg === "string") {
+            return arg;
+        }
+        else if (Array.isArray(arg) || (0, lodash_1.isArguments)(arg)) {
+            if (arg.length === 0) {
+                continue;
+            }
+            return arg[0];
+        }
+        const flattened = [arg].flat();
+        if (flattened.length > 0) {
+            return flattened[0];
+        }
+    }
+    return undefined;
+}
+exports.getFirstValueInFlattenedArray = getFirstValueInFlattenedArray;
+function executeWithAutoPipelining(client, functionName, commandName, args, callback) {
+    // On cluster mode let's wait for slots to be available
+    if (client.isCluster && !client.slots.length) {
+        if (client.status === "wait")
+            client.connect().catch(lodash_1.noop);
+        return (0, standard_as_callback_1.default)(new Promise(function (resolve, reject) {
+            client.delayUntilReady((err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                executeWithAutoPipelining(client, functionName, commandName, args, null).then(resolve, reject);
+            });
+        }), callback);
+    }
+    // If we have slot information, we can improve routing by grouping slots served by the same subset of nodes
+    // Note that the first value in args may be a (possibly empty) array.
+    // ioredis will only flatten one level of the array, in the Command constructor.
+    const prefix = client.options.keyPrefix || "";
+    const slotKey = client.isCluster
+        ? client.slots[calculateSlot(`${prefix}${getFirstValueInFlattenedArray(args)}`)].join(",")
+        : "main";
+    if (!client._autoPipelines.has(slotKey)) {
+        const pipeline = client.pipeline();
+        pipeline[exports.kExec] = false;
+        pipeline[exports.kCallbacks] = [];
+        client._autoPipelines.set(slotKey, pipeline);
+    }
+    const pipeline = client._autoPipelines.get(slotKey);
+    /*
+      Mark the pipeline as scheduled.
+      The symbol will make sure that the pipeline is only scheduled once per tick.
+      New commands are appended to an already scheduled pipeline.
+    */
+    if (!pipeline[exports.kExec]) {
+        pipeline[exports.kExec] = true;
+        /*
+          Deferring with setImmediate so we have a chance to capture multiple
+          commands that can be scheduled by I/O events already in the event loop queue.
+        */
+        setImmediate(executeAutoPipeline, client, slotKey);
+    }
+    // Create the promise which will execute the command in the pipeline.
+    const autoPipelinePromise = new Promise(function (resolve, reject) {
+        pipeline[exports.kCallbacks].push(function (err, value) {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve(value);
+        });
+        if (functionName === "call") {
+            args.unshift(commandName);
+        }
+        pipeline[functionName](...args);
+    });
+    return (0, standard_as_callback_1.default)(autoPipelinePromise, callback);
+}
+exports.executeWithAutoPipelining = executeWithAutoPipelining;

package/.output/server/node_modules/ioredis/built/cluster/ClusterOptions.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CLUSTER_OPTIONS = void 0;
+const dns_1 = require("dns");
+exports.DEFAULT_CLUSTER_OPTIONS = {
+    clusterRetryStrategy: (times) => Math.min(100 + times * 2, 2000),
+    enableOfflineQueue: true,
+    enableReadyCheck: true,
+    scaleReads: "master",
+    maxRedirections: 16,
+    retryDelayOnMoved: 0,
+    retryDelayOnFailover: 100,
+    retryDelayOnClusterDown: 100,
+    retryDelayOnTryAgain: 100,
+    slotsRefreshTimeout: 1000,
+    useSRVRecords: false,
+    resolveSrv: dns_1.resolveSrv,
+    dnsLookup: dns_1.lookup,
+    enableAutoPipelining: false,
+    autoPipeliningIgnoredCommands: [],
+    shardedSubscribers: false,
+};

package/.output/server/node_modules/ioredis/built/cluster/ClusterSubscriber.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("./util");
+const utils_1 = require("../utils");
+const Redis_1 = require("../Redis");
+const debug = (0, utils_1.Debug)("cluster:subscriber");
+class ClusterSubscriber {
+    constructor(connectionPool, emitter, isSharded = false) {
+        this.connectionPool = connectionPool;
+        this.emitter = emitter;
+        this.isSharded = isSharded;
+        this.started = false;
+        //There is only one connection for the entire pool
+        this.subscriber = null;
+        //The slot range for which this subscriber is responsible
+        this.slotRange = [];
+        this.onSubscriberEnd = () => {
+            if (!this.started) {
+                debug("subscriber has disconnected, but ClusterSubscriber is not started, so not reconnecting.");
+                return;
+            }
+            // If the subscriber closes whilst it's still the active connection,
+            // we might as well try to connecting to a new node if possible to
+            // minimise the number of missed publishes.
+            debug("subscriber has disconnected, selecting a new one...");
+            this.selectSubscriber();
+        };
+        // If the current node we're using as the subscriber disappears
+        // from the node pool for some reason, we will select a new one
+        // to connect to.
+        // Note that this event is only triggered if the connection to
+        // the node has been used; cluster subscriptions are setup with
+        // lazyConnect = true. It's possible for the subscriber node to
+        // disappear without this method being called!
+        // See https://github.com/luin/ioredis/pull/1589
+        this.connectionPool.on("-node", (_, key) => {
+            if (!this.started || !this.subscriber) {
+                return;
+            }
+            if ((0, util_1.getNodeKey)(this.subscriber.options) === key) {
+                debug("subscriber has left, selecting a new one...");
+                this.selectSubscriber();
+            }
+        });
+        this.connectionPool.on("+node", () => {
+            if (!this.started || this.subscriber) {
+                return;
+            }
+            debug("a new node is discovered and there is no subscriber, selecting a new one...");
+            this.selectSubscriber();
+        });
+    }
+    getInstance() {
+        return this.subscriber;
+    }
+    /**
+     * Associate this subscriber to a specific slot range.
+     *
+     * Returns the range or an empty array if the slot range couldn't be associated.
+     *
+     * BTW: This is more for debugging and testing purposes.
+     *
+     * @param range
+     */
+    associateSlotRange(range) {
+        if (this.isSharded) {
+            this.slotRange = range;
+        }
+        return this.slotRange;
+    }
+    start() {
+        this.started = true;
+        this.selectSubscriber();
+        debug("started");
+    }
+    stop() {
+        this.started = false;
+        if (this.subscriber) {
+            this.subscriber.disconnect();
+            this.subscriber = null;
+        }
+    }
+    isStarted() {
+        return this.started;
+    }
+    selectSubscriber() {
+        const lastActiveSubscriber = this.lastActiveSubscriber;
+        // Disconnect the previous subscriber even if there
+        // will not be a new one.
+        if (lastActiveSubscriber) {
+            lastActiveSubscriber.off("end", this.onSubscriberEnd);
+            lastActiveSubscriber.disconnect();
+        }
+        if (this.subscriber) {
+            this.subscriber.off("end", this.onSubscriberEnd);
+            this.subscriber.disconnect();
+        }
+        const sampleNode = (0, utils_1.sample)(this.connectionPool.getNodes());
+        if (!sampleNode) {
+            debug("selecting subscriber failed since there is no node discovered in the cluster yet");
+            this.subscriber = null;
+            return;
+        }
+        const { options } = sampleNode;
+        debug("selected a subscriber %s:%s", options.host, options.port);
+        /*
+         * Create a specialized Redis connection for the subscription.
+         * Note that auto reconnection is enabled here.
+         *
+         * `enableReadyCheck` is also enabled because although subscription is allowed
+         * while redis is loading data from the disk, we can check if the password
+         * provided for the subscriber is correct, and if not, the current subscriber
+         * will be disconnected and a new subscriber will be selected.
+         */
+        let connectionPrefix = "subscriber";
+        if (this.isSharded)
+            connectionPrefix = "ssubscriber";
+        this.subscriber = new Redis_1.default({
+            port: options.port,
+            host: options.host,
+            username: options.username,
+            password: options.password,
+            enableReadyCheck: true,
+            connectionName: (0, util_1.getConnectionName)(connectionPrefix, options.connectionName),
+            lazyConnect: true,
+            tls: options.tls,
+            // Don't try to reconnect the subscriber connection. If the connection fails
+            // we will get an end event (handled below), at which point we'll pick a new
+            // node from the pool and try to connect to that as the subscriber connection.
+            retryStrategy: null,
+        });
+        // Ignore the errors since they're handled in the connection pool.
+        this.subscriber.on("error", utils_1.noop);
+        // The node we lost connection to may not come back up in a
+        // reasonable amount of time (e.g. a slave that's taken down
+        // for maintainence), we could potentially miss many published
+        // messages so we should reconnect as quickly as possible, to
+        // a different node if needed.
+        this.subscriber.once("end", this.onSubscriberEnd);
+        // Re-subscribe previous channels
+        const previousChannels = { subscribe: [], psubscribe: [], ssubscribe: [] };
+        if (lastActiveSubscriber) {
+            const condition = lastActiveSubscriber.condition || lastActiveSubscriber.prevCondition;
+            if (condition && condition.subscriber) {
+                previousChannels.subscribe = condition.subscriber.channels("subscribe");
+                previousChannels.psubscribe =
+                    condition.subscriber.channels("psubscribe");
+                previousChannels.ssubscribe =
+                    condition.subscriber.channels("ssubscribe");
+            }
+        }
+        if (previousChannels.subscribe.length ||
+            previousChannels.psubscribe.length ||
+            previousChannels.ssubscribe.length) {
+            let pending = 0;
+            for (const type of ["subscribe", "psubscribe", "ssubscribe"]) {
+                const channels = previousChannels[type];
+                if (channels.length) {
+                    pending += 1;
+                    debug("%s %d channels", type, channels.length);
+                    this.subscriber[type](channels)
+                        .then(() => {
+                        if (!--pending) {
+                            this.lastActiveSubscriber = this.subscriber;
+                        }
+                    })
+                        .catch(() => {
+                        // TODO: should probably disconnect the subscriber and try again.
+                        debug("failed to %s %d channels", type, channels.length);
+                    });
+                }
+            }
+        }
+        else {
+            this.lastActiveSubscriber = this.subscriber;
+        }
+        for (const event of [
+            "message",
+            "messageBuffer",
+        ]) {
+            this.subscriber.on(event, (arg1, arg2) => {
+                this.emitter.emit(event, arg1, arg2);
+            });
+        }
+        for (const event of ["pmessage", "pmessageBuffer"]) {
+            this.subscriber.on(event, (arg1, arg2, arg3) => {
+                this.emitter.emit(event, arg1, arg2, arg3);
+            });
+        }
+        if (this.isSharded == true) {
+            for (const event of [
+                "smessage",
+                "smessageBuffer",
+            ]) {
+                this.subscriber.on(event, (arg1, arg2) => {
+                    this.emitter.emit(event, arg1, arg2);
+                });
+            }
+        }
+    }
+}
+exports.default = ClusterSubscriber;