orcaq 1.1.1 → 1.1.2

package/.output/server/node_modules/@redis/client/dist/lib/client/pub-sub.js

@@ -0,0 +1,351 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PubSub = exports.PUBSUB_TYPE = void 0;
+const cluster_key_slot_1 = __importDefault(require("cluster-key-slot"));
+const tracing_1 = require("./tracing");
+exports.PUBSUB_TYPE = {
+    CHANNELS: 'CHANNELS',
+    PATTERNS: 'PATTERNS',
+    SHARDED: 'SHARDED'
+};
+const COMMANDS = {
+    [exports.PUBSUB_TYPE.CHANNELS]: {
+        subscribe: Buffer.from('subscribe'),
+        unsubscribe: Buffer.from('unsubscribe'),
+        message: Buffer.from('message')
+    },
+    [exports.PUBSUB_TYPE.PATTERNS]: {
+        subscribe: Buffer.from('psubscribe'),
+        unsubscribe: Buffer.from('punsubscribe'),
+        message: Buffer.from('pmessage')
+    },
+    [exports.PUBSUB_TYPE.SHARDED]: {
+        subscribe: Buffer.from('ssubscribe'),
+        unsubscribe: Buffer.from('sunsubscribe'),
+        message: Buffer.from('smessage')
+    }
+};
+class PubSub {
+    #clientId;
+    constructor(clientId) {
+        this.#clientId = clientId;
+    }
+    static isStatusReply(reply) {
+        const firstElement = typeof reply[0] === 'string' ? Buffer.from(reply[0]) : reply[0];
+        return (COMMANDS[exports.PUBSUB_TYPE.CHANNELS].subscribe.equals(firstElement) ||
+            COMMANDS[exports.PUBSUB_TYPE.CHANNELS].unsubscribe.equals(firstElement) ||
+            COMMANDS[exports.PUBSUB_TYPE.PATTERNS].subscribe.equals(firstElement) ||
+            COMMANDS[exports.PUBSUB_TYPE.PATTERNS].unsubscribe.equals(firstElement) ||
+            COMMANDS[exports.PUBSUB_TYPE.SHARDED].subscribe.equals(firstElement));
+    }
+    static isShardedUnsubscribe(reply) {
+        const firstElement = typeof reply[0] === 'string' ? Buffer.from(reply[0]) : reply[0];
+        return COMMANDS[exports.PUBSUB_TYPE.SHARDED].unsubscribe.equals(firstElement);
+    }
+    static #channelsArray(channels) {
+        return (Array.isArray(channels) ? channels : [channels]);
+    }
+    static #listenersSet(listeners, returnBuffers) {
+        return (returnBuffers ? listeners.buffers : listeners.strings);
+    }
+    #subscribing = 0;
+    #isActive = false;
+    get isActive() {
+        return this.#isActive;
+    }
+    listeners = {
+        [exports.PUBSUB_TYPE.CHANNELS]: new Map(),
+        [exports.PUBSUB_TYPE.PATTERNS]: new Map(),
+        [exports.PUBSUB_TYPE.SHARDED]: new Map()
+    };
+    subscribe(type, channels, listener, returnBuffers) {
+        const args = [COMMANDS[type].subscribe], channelsArray = PubSub.#channelsArray(channels);
+        for (const channel of channelsArray) {
+            let channelListeners = this.listeners[type].get(channel);
+            if (!channelListeners || channelListeners.unsubscribing) {
+                args.push(channel);
+            }
+        }
+        if (args.length === 1) {
+            // all channels are already subscribed, add listeners without issuing a command
+            for (const channel of channelsArray) {
+                PubSub.#listenersSet(this.listeners[type].get(channel), returnBuffers).add(listener);
+            }
+            return;
+        }
+        this.#isActive = true;
+        this.#subscribing++;
+        return {
+            args,
+            channelsCounter: args.length - 1,
+            resolve: () => {
+                this.#subscribing--;
+                for (const channel of channelsArray) {
+                    let listeners = this.listeners[type].get(channel);
+                    if (!listeners) {
+                        listeners = {
+                            unsubscribing: false,
+                            buffers: new Set(),
+                            strings: new Set()
+                        };
+                        this.listeners[type].set(channel, listeners);
+                    }
+                    PubSub.#listenersSet(listeners, returnBuffers).add(listener);
+                }
+            },
+            reject: () => {
+                this.#subscribing--;
+                this.#updateIsActive();
+            }
+        };
+    }
+    extendChannelListeners(type, channel, listeners) {
+        if (!this.#extendChannelListeners(type, channel, listeners))
+            return;
+        this.#isActive = true;
+        this.#subscribing++;
+        return {
+            args: [
+                COMMANDS[type].subscribe,
+                channel
+            ],
+            channelsCounter: 1,
+            resolve: () => this.#subscribing--,
+            reject: () => {
+                this.#subscribing--;
+                this.#updateIsActive();
+            }
+        };
+    }
+    #extendChannelListeners(type, channel, listeners) {
+        const existingListeners = this.listeners[type].get(channel);
+        if (!existingListeners) {
+            this.listeners[type].set(channel, listeners);
+            return true;
+        }
+        for (const listener of listeners.buffers) {
+            existingListeners.buffers.add(listener);
+        }
+        for (const listener of listeners.strings) {
+            existingListeners.strings.add(listener);
+        }
+        return false;
+    }
+    extendTypeListeners(type, listeners) {
+        const args = [COMMANDS[type].subscribe];
+        for (const [channel, channelListeners] of listeners) {
+            if (this.#extendChannelListeners(type, channel, channelListeners)) {
+                args.push(channel);
+            }
+        }
+        if (args.length === 1)
+            return;
+        this.#isActive = true;
+        this.#subscribing++;
+        return {
+            args,
+            channelsCounter: args.length - 1,
+            resolve: () => this.#subscribing--,
+            reject: () => {
+                this.#subscribing--;
+                this.#updateIsActive();
+            }
+        };
+    }
+    unsubscribe(type, channels, listener, returnBuffers) {
+        const listeners = this.listeners[type];
+        if (!channels) {
+            return this.#unsubscribeCommand([COMMANDS[type].unsubscribe], 
+            // cannot use `this.#subscribed` because there might be some `SUBSCRIBE` commands in the queue
+            // cannot use `this.#subscribed + this.#subscribing` because some `SUBSCRIBE` commands might fail
+            NaN, () => listeners.clear());
+        }
+        const channelsArray = PubSub.#channelsArray(channels);
+        if (!listener) {
+            return this.#unsubscribeCommand([COMMANDS[type].unsubscribe, ...channelsArray], channelsArray.length, () => {
+                for (const channel of channelsArray) {
+                    listeners.delete(channel);
+                }
+            });
+        }
+        const args = [COMMANDS[type].unsubscribe];
+        for (const channel of channelsArray) {
+            const sets = listeners.get(channel);
+            if (sets) {
+                let current, other;
+                if (returnBuffers) {
+                    current = sets.buffers;
+                    other = sets.strings;
+                }
+                else {
+                    current = sets.strings;
+                    other = sets.buffers;
+                }
+                const currentSize = current.has(listener) ? current.size - 1 : current.size;
+                if (currentSize !== 0 || other.size !== 0)
+                    continue;
+                sets.unsubscribing = true;
+            }
+            args.push(channel);
+        }
+        if (args.length === 1) {
+            // all channels has other listeners,
+            // delete the listeners without issuing a command
+            for (const channel of channelsArray) {
+                PubSub.#listenersSet(listeners.get(channel), returnBuffers).delete(listener);
+            }
+            return;
+        }
+        return this.#unsubscribeCommand(args, args.length - 1, () => {
+            for (const channel of channelsArray) {
+                const sets = listeners.get(channel);
+                if (!sets)
+                    continue;
+                (returnBuffers ? sets.buffers : sets.strings).delete(listener);
+                if (sets.buffers.size === 0 && sets.strings.size === 0) {
+                    listeners.delete(channel);
+                }
+            }
+        });
+    }
+    #unsubscribeCommand(args, channelsCounter, removeListeners) {
+        return {
+            args,
+            channelsCounter,
+            resolve: () => {
+                removeListeners();
+                this.#updateIsActive();
+            },
+            reject: undefined
+        };
+    }
+    #updateIsActive() {
+        this.#isActive = (this.listeners[exports.PUBSUB_TYPE.CHANNELS].size !== 0 ||
+            this.listeners[exports.PUBSUB_TYPE.PATTERNS].size !== 0 ||
+            this.listeners[exports.PUBSUB_TYPE.SHARDED].size !== 0 ||
+            this.#subscribing !== 0);
+    }
+    reset() {
+        this.#isActive = false;
+        this.#subscribing = 0;
+    }
+    resubscribe() {
+        const commands = [];
+        for (const [type, listeners] of Object.entries(this.listeners)) {
+            if (!listeners.size)
+                continue;
+            this.#isActive = true;
+            if (type === exports.PUBSUB_TYPE.SHARDED) {
+                this.#shardedResubscribe(commands, listeners);
+            }
+            else {
+                this.#normalResubscribe(commands, type, listeners);
+            }
+        }
+        return commands;
+    }
+    #normalResubscribe(commands, type, listeners) {
+        this.#subscribing++;
+        const callback = () => this.#subscribing--;
+        commands.push({
+            args: [
+                COMMANDS[type].subscribe,
+                ...listeners.keys()
+            ],
+            channelsCounter: listeners.size,
+            resolve: callback,
+            reject: callback
+        });
+    }
+    #shardedResubscribe(commands, listeners) {
+        const callback = () => this.#subscribing--;
+        for (const channel of listeners.keys()) {
+            this.#subscribing++;
+            commands.push({
+                args: [
+                    COMMANDS[exports.PUBSUB_TYPE.SHARDED].subscribe,
+                    channel
+                ],
+                channelsCounter: 1,
+                resolve: callback,
+                reject: callback
+            });
+        }
+    }
+    handleMessageReply(reply) {
+        const firstElement = typeof reply[0] === 'string' ? Buffer.from(reply[0]) : reply[0];
+        if (COMMANDS[exports.PUBSUB_TYPE.CHANNELS].message.equals(firstElement)) {
+            this.#emitPubSubMessage(exports.PUBSUB_TYPE.CHANNELS, reply[2], reply[1]);
+            return true;
+        }
+        else if (COMMANDS[exports.PUBSUB_TYPE.PATTERNS].message.equals(firstElement)) {
+            this.#emitPubSubMessage(exports.PUBSUB_TYPE.PATTERNS, reply[3], reply[2], reply[1]);
+            return true;
+        }
+        else if (COMMANDS[exports.PUBSUB_TYPE.SHARDED].message.equals(firstElement)) {
+            this.#emitPubSubMessage(exports.PUBSUB_TYPE.SHARDED, reply[2], reply[1]);
+            return true;
+        }
+        return false;
+    }
+    removeShardedListeners(channel) {
+        const listeners = this.listeners[exports.PUBSUB_TYPE.SHARDED].get(channel);
+        this.listeners[exports.PUBSUB_TYPE.SHARDED].delete(channel);
+        this.#updateIsActive();
+        return listeners;
+    }
+    removeAllListeners() {
+        const result = {
+            [exports.PUBSUB_TYPE.CHANNELS]: this.listeners[exports.PUBSUB_TYPE.CHANNELS],
+            [exports.PUBSUB_TYPE.PATTERNS]: this.listeners[exports.PUBSUB_TYPE.PATTERNS],
+            [exports.PUBSUB_TYPE.SHARDED]: this.listeners[exports.PUBSUB_TYPE.SHARDED]
+        };
+        this.#updateIsActive();
+        this.listeners[exports.PUBSUB_TYPE.CHANNELS] = new Map();
+        this.listeners[exports.PUBSUB_TYPE.PATTERNS] = new Map();
+        this.listeners[exports.PUBSUB_TYPE.SHARDED] = new Map();
+        return result;
+    }
+    removeShardedPubSubListenersForSlots(slots) {
+        const sharded = new Map();
+        for (const [chanel, value] of this.listeners[exports.PUBSUB_TYPE.SHARDED]) {
+            if (slots.has((0, cluster_key_slot_1.default)(chanel))) {
+                sharded.set(chanel, value);
+                this.listeners[exports.PUBSUB_TYPE.SHARDED].delete(chanel);
+            }
+        }
+        this.#updateIsActive();
+        return {
+            [exports.PUBSUB_TYPE.SHARDED]: sharded
+        };
+    }
+    #emitPubSubMessage(type, message, channel, pattern) {
+        const keyString = (pattern ?? channel).toString(), listeners = this.listeners[type].get(keyString);
+        if (!listeners)
+            return;
+        (0, tracing_1.publish)(tracing_1.CHANNELS.PUBSUB, () => ({
+            direction: 'in',
+            clientId: this.#clientId,
+            channel,
+            sharded: type === exports.PUBSUB_TYPE.SHARDED,
+        }));
+        for (const listener of listeners.buffers) {
+            listener(message, channel);
+        }
+        if (!listeners.strings.size)
+            return;
+        const channelString = pattern ? channel.toString() : keyString, messageString = channelString === '__redis__:invalidate' ?
+            // https://github.com/redis/redis/pull/7469
+            // https://github.com/redis/redis/issues/7463
+            (message === null ? null : message.map(x => x.toString())) :
+            message.toString();
+        for (const listener of listeners.strings) {
+            listener(messageString, channelString);
+        }
+    }
+}
+exports.PubSub = PubSub;
+//# sourceMappingURL=pub-sub.js.map

package/.output/server/node_modules/@redis/client/dist/lib/client/socket.js

@@ -0,0 +1,336 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_events_1 = require("node:events");
+const node_net_1 = __importDefault(require("node:net"));
+const node_tls_1 = __importDefault(require("node:tls"));
+const errors_1 = require("../errors");
+const promises_1 = require("node:timers/promises");
+const enterprise_maintenance_manager_1 = require("./enterprise-maintenance-manager");
+const tracing_1 = require("./tracing");
+class RedisSocket extends node_events_1.EventEmitter {
+    #initiator;
+    #connectTimeout;
+    #reconnectStrategy;
+    #socketFactory;
+    #socketTimeout;
+    #clientId;
+    #maintenanceTimeout;
+    #socket;
+    #isOpen = false;
+    get isOpen() {
+        return this.#isOpen;
+    }
+    #isReady = false;
+    get isReady() {
+        return this.#isReady;
+    }
+    #isSocketUnrefed = false;
+    #socketEpoch = 0;
+    get socketEpoch() {
+        return this.#socketEpoch;
+    }
+    get host() {
+        return this.#socket?.remoteAddress;
+    }
+    get port() {
+        return this.#socket?.remotePort;
+    }
+    constructor(initiator, clientId, options) {
+        super();
+        this.#initiator = initiator;
+        this.#connectTimeout = options?.connectTimeout ?? 5000;
+        this.#reconnectStrategy = this.#createReconnectStrategy(options);
+        this.#socketFactory = this.#createSocketFactory(options);
+        this.#socketTimeout = options?.socketTimeout;
+        this.#clientId = clientId;
+    }
+    #createReconnectStrategy(options) {
+        const strategy = options?.reconnectStrategy;
+        if (strategy === false || typeof strategy === 'number') {
+            return () => strategy;
+        }
+        if (strategy) {
+            return (retries, cause) => {
+                try {
+                    const retryIn = strategy(retries, cause);
+                    if (retryIn !== false && !(retryIn instanceof Error) && typeof retryIn !== 'number') {
+                        throw new TypeError(`Reconnect strategy should return \`false | Error | number\`, got ${retryIn} instead`);
+                    }
+                    return retryIn;
+                }
+                catch (err) {
+                    this.emit('error', err);
+                    return this.defaultReconnectStrategy(retries, err);
+                }
+            };
+        }
+        return this.defaultReconnectStrategy;
+    }
+    #createSocketFactory(options) {
+        // TLS
+        if (options?.tls === true) {
+            const withDefaults = {
+                ...options,
+                port: options?.port ?? 6379,
+                // https://nodejs.org/api/tls.html#tlsconnectoptions-callback "Any socket.connect() option not already listed"
+                // @types/node is... incorrect...
+                // @ts-expect-error
+                noDelay: options?.noDelay ?? true,
+                // https://nodejs.org/api/tls.html#tlsconnectoptions-callback "Any socket.connect() option not already listed"
+                // @types/node is... incorrect...
+                // @ts-expect-error
+                keepAlive: options?.keepAlive ?? true,
+                // https://nodejs.org/api/tls.html#tlsconnectoptions-callback "Any socket.connect() option not already listed"
+                // @types/node is... incorrect...
+                // @ts-expect-error
+                keepAliveInitialDelay: options?.keepAliveInitialDelay ?? 5000,
+                timeout: undefined,
+                onread: undefined,
+                readable: true,
+                writable: true
+            };
+            return {
+                create() {
+                    return node_tls_1.default.connect(withDefaults);
+                },
+                event: 'secureConnect'
+            };
+        }
+        // IPC
+        if (options && 'path' in options) {
+            const withDefaults = {
+                ...options,
+                timeout: undefined,
+                onread: undefined,
+                readable: true,
+                writable: true
+            };
+            return {
+                create() {
+                    return node_net_1.default.createConnection(withDefaults);
+                },
+                event: 'connect'
+            };
+        }
+        // TCP
+        const withDefaults = {
+            ...options,
+            port: options?.port ?? 6379,
+            noDelay: options?.noDelay ?? true,
+            keepAlive: options?.keepAlive ?? true,
+            keepAliveInitialDelay: options?.keepAliveInitialDelay ?? 5000,
+            timeout: undefined,
+            onread: undefined,
+            readable: true,
+            writable: true
+        };
+        return {
+            create() {
+                return node_net_1.default.createConnection(withDefaults);
+            },
+            event: 'connect'
+        };
+    }
+    #shouldReconnect(retries, cause) {
+        const retryIn = this.#reconnectStrategy(retries, cause);
+        if (retryIn === false) {
+            this.#isOpen = false;
+            this.emit('error', cause);
+            return cause;
+        }
+        else if (retryIn instanceof Error) {
+            this.#isOpen = false;
+            this.emit('error', cause);
+            return new errors_1.ReconnectStrategyError(retryIn, cause);
+        }
+        return retryIn;
+    }
+    async connect() {
+        if (this.#isOpen) {
+            throw new Error('Socket already opened');
+        }
+        this.#isOpen = true;
+        return this.#connect();
+    }
+    async #connect() {
+        let retries = 0;
+        do {
+            try {
+                const connectStartTime = performance.now();
+                this.#socket = await this.#createSocket();
+                this.emit('connect');
+                try {
+                    await this.#initiator();
+                    // Check if socket was closed/destroyed during initiator execution
+                    if (!this.#socket || this.#socket.destroyed || !this.#socket.readable || !this.#socket.writable) {
+                        const retryIn = this.#shouldReconnect(retries++, new errors_1.SocketClosedUnexpectedlyError());
+                        if (typeof retryIn !== 'number') {
+                            throw retryIn;
+                        }
+                        await (0, promises_1.setTimeout)(retryIn);
+                        this.emit('reconnecting');
+                        continue;
+                    }
+                }
+                catch (err) {
+                    this.#socket.destroy();
+                    this.#socket = undefined;
+                    throw err;
+                }
+                this.#isReady = true;
+                this.#socketEpoch++;
+                (0, tracing_1.publish)(tracing_1.CHANNELS.CONNECTION_READY, () => ({
+                    clientId: this.#clientId,
+                    serverAddress: this.host,
+                    serverPort: this.port,
+                    createTimeMs: performance.now() - connectStartTime,
+                }));
+                this.emit('ready');
+            }
+            catch (err) {
+                const retryIn = this.#shouldReconnect(retries++, err);
+                if (typeof retryIn !== 'number') {
+                    throw retryIn;
+                }
+                this.emit('error', err);
+                await (0, promises_1.setTimeout)(retryIn);
+                this.emit('reconnecting');
+            }
+        } while (this.#isOpen && !this.#isReady);
+    }
+    setMaintenanceTimeout(ms) {
+        (0, enterprise_maintenance_manager_1.dbgMaintenance)(`Set socket timeout to ${ms}`);
+        if (this.#maintenanceTimeout === ms) {
+            (0, enterprise_maintenance_manager_1.dbgMaintenance)(`Socket already set maintenanceCommandTimeout to ${ms}, skipping`);
+            return;
+        }
+        ;
+        this.#maintenanceTimeout = ms;
+        if (ms !== undefined) {
+            this.#socket?.setTimeout(ms);
+            (0, tracing_1.publish)(tracing_1.CHANNELS.CONNECTION_RELAXED_TIMEOUT, () => ({ clientId: this.#clientId, value: 1 }));
+        }
+        else {
+            this.#socket?.setTimeout(this.#socketTimeout ?? 0);
+            (0, tracing_1.publish)(tracing_1.CHANNELS.CONNECTION_RELAXED_TIMEOUT, () => ({ clientId: this.#clientId, value: -1 }));
+        }
+    }
+    async #createSocket() {
+        const socket = this.#socketFactory.create();
+        let onTimeout;
+        if (this.#connectTimeout !== undefined) {
+            onTimeout = () => socket.destroy(new errors_1.ConnectionTimeoutError());
+            socket.once('timeout', onTimeout);
+            socket.setTimeout(this.#connectTimeout);
+        }
+        if (this.#isSocketUnrefed) {
+            socket.unref();
+        }
+        await (0, node_events_1.once)(socket, this.#socketFactory.event);
+        if (onTimeout) {
+            socket.removeListener('timeout', onTimeout);
+        }
+        if (this.#socketTimeout) {
+            socket.once('timeout', () => {
+                const error = this.#maintenanceTimeout
+                    ? new errors_1.SocketTimeoutDuringMaintenanceError(this.#maintenanceTimeout)
+                    : new errors_1.SocketTimeoutError(this.#socketTimeout);
+                socket.destroy(error);
+            });
+            socket.setTimeout(this.#socketTimeout);
+        }
+        socket
+            .once('error', err => this.#onSocketError(err))
+            .once('close', hadError => {
+            if (hadError || !this.#isOpen || this.#socket !== socket)
+                return;
+            this.#onSocketError(new errors_1.SocketClosedUnexpectedlyError());
+        })
+            .on('drain', () => this.emit('drain'))
+            .on('data', data => this.emit('data', data));
+        return socket;
+    }
+    #onSocketError(err) {
+        const wasReady = this.#isReady;
+        this.#isReady = false;
+        this.emit('error', err);
+        if (wasReady) {
+            (0, tracing_1.publish)(tracing_1.CHANNELS.CONNECTION_CLOSED, () => ({ clientId: this.#clientId, reason: 'error', wasConnected: true }));
+        }
+        if (!wasReady || !this.#isOpen || typeof this.#shouldReconnect(0, err) !== 'number')
+            return;
+        this.emit('reconnecting');
+        this.#connect().catch(() => {
+            // the error was already emitted, silently ignore it
+        });
+    }
+    write(iterable) {
+        if (!this.#socket)
+            return;
+        this.#socket.cork();
+        for (const args of iterable) {
+            for (const toWrite of args) {
+                this.#socket.write(toWrite);
+            }
+            if (this.#socket.writableNeedDrain)
+                break;
+        }
+        this.#socket.uncork();
+    }
+    async quit(fn) {
+        if (!this.#isOpen) {
+            throw new errors_1.ClientClosedError();
+        }
+        this.#isOpen = false;
+        const reply = await fn();
+        this.destroySocket();
+        return reply;
+    }
+    close() {
+        if (!this.#isOpen) {
+            throw new errors_1.ClientClosedError();
+        }
+        this.#isOpen = false;
+    }
+    destroy() {
+        if (!this.#isOpen) {
+            throw new errors_1.ClientClosedError();
+        }
+        this.#isOpen = false;
+        this.destroySocket();
+    }
+    destroySocket() {
+        const wasReady = this.#isReady;
+        this.#isReady = false;
+        if (this.#socket) {
+            this.#socket.destroy();
+            this.#socket = undefined;
+        }
+        (0, tracing_1.publish)(tracing_1.CHANNELS.CONNECTION_CLOSED, () => ({ clientId: this.#clientId, reason: 'application_close', wasConnected: wasReady }));
+        this.emit('end');
+    }
+    ref() {
+        this.#isSocketUnrefed = false;
+        this.#socket?.ref();
+    }
+    unref() {
+        this.#isSocketUnrefed = true;
+        this.#socket?.unref();
+    }
+    defaultReconnectStrategy(retries, cause) {
+        // By default, do not reconnect on socket timeout.
+        if (cause instanceof errors_1.SocketTimeoutError) {
+            return false;
+        }
+        // Generate a random jitter between 0 – 200 ms:
+        const jitter = Math.floor(Math.random() * 200);
+        // Delay is an exponential back off, (times^2) * 50 ms, with a maximum value of 2000 ms:
+        const delay = Math.min(Math.pow(2, retries) * 50, 2000);
+        return delay + jitter;
+    }
+}
+exports.default = RedisSocket;
+//# sourceMappingURL=socket.js.map