ioredis-om 5.10.2

package/built/ScanStream.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { Readable, ReadableOptions } from "stream";
+interface Options extends ReadableOptions {
+    key?: string;
+    match?: string;
+    type?: string;
+    command: string;
+    redis: any;
+    count?: string | number;
+    noValues?: boolean;
+}
+/**
+ * Convenient class to convert the process of scanning keys to a readable stream.
+ */
+export default class ScanStream extends Readable {
+    private opt;
+    private _redisCursor;
+    private _redisDrained;
+    constructor(opt: Options);
+    _read(): void;
+    close(): void;
+}
+export {};

package/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/built/Script.d.ts

@@ -0,0 +1,11 @@
+import { Callback } from "./types";
+export default class Script {
+    private lua;
+    private numberOfKeys;
+    private keyPrefix;
+    private readOnly;
+    private sha;
+    private Command;
+    constructor(lua: string, numberOfKeys?: number | null, keyPrefix?: string, readOnly?: boolean);
+    execute(container: any, args: any[], options: any, callback?: Callback): any;
+}

package/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/built/SubscriptionSet.d.ts

@@ -0,0 +1,14 @@
+import { CommandNameFlags } from "./Command";
+declare type AddSet = CommandNameFlags["ENTER_SUBSCRIBER_MODE"][number];
+declare type DelSet = CommandNameFlags["EXIT_SUBSCRIBER_MODE"][number];
+/**
+ * Tiny class to simplify dealing with subscription set
+ */
+export default class SubscriptionSet {
+    private set;
+    add(set: AddSet, channel: string): void;
+    del(set: DelSet, channel: string): void;
+    channels(set: AddSet | DelSet): string[];
+    isEmpty(): boolean;
+}
+export {};

package/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/built/autoPipelining.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { ArgumentType } from "./Command";
+export declare const kExec: unique symbol;
+export declare const kCallbacks: unique symbol;
+export declare const notAllowedAutoPipelineCommands: string[];
+export declare function shouldUseAutoPipelining(client: any, functionName: string, commandName: string): boolean;
+export declare function getFirstValueInFlattenedArray(args: ArgumentType[]): string | Buffer | number | null | undefined;
+export declare function executeWithAutoPipelining(client: any, functionName: string, commandName: string, args: ArgumentType[], callback: any): Promise<unknown>;

package/built/autoPipelining.js

@@ -0,0 +1,167 @@
+"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");
+const commands_1 = require("@ioredis/commands");
+exports.kExec = Symbol("exec");
+exports.kCallbacks = Symbol("callbacks");
+exports.notAllowedAutoPipelineCommands = [
+    "auth",
+    "info",
+    "script",
+    "quit",
+    "cluster",
+    "pipeline",
+    "multi",
+    "subscribe",
+    "psubscribe",
+    "unsubscribe",
+    "unpsubscribe",
+    "select",
+    "client",
+];
+function executeAutoPipeline(client, slotKey) {
+    /*
+      If a pipeline is already executing, keep queueing up commands
+      since ioredis-om 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-om will only flatten one level of the array, in the Command constructor.
+    const prefix = client.options.keyPrefix || "";
+    let slotKey = client.isCluster
+        ? client.slots[calculateSlot(`${prefix}${getFirstValueInFlattenedArray(args)}`)].join(",")
+        : "main";
+    // When scaleReads is enabled, separate read and write commands into different pipelines
+    // so they can be routed to replicas and masters respectively
+    if (client.isCluster && client.options.scaleReads !== "master") {
+        const isReadOnly = (0, commands_1.exists)(commandName) && (0, commands_1.hasFlag)(commandName, "readonly");
+        slotKey += isReadOnly ? ":read" : ":write";
+    }
+    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/built/cluster/ClusterOptions.d.ts

@@ -0,0 +1,172 @@
+/// <reference types="node" />
+import { SrvRecord } from "dns";
+import { RedisOptions } from "../redis/RedisOptions";
+import { CommanderOptions } from "../utils/Commander";
+import { NodeRole } from "./util";
+export declare type DNSResolveSrvFunction = (hostname: string, callback: (err: NodeJS.ErrnoException | null | undefined, records?: SrvRecord[]) => void) => void;
+export declare type DNSLookupFunction = (hostname: string, callback: (err: NodeJS.ErrnoException | null | undefined, address: string, family?: number) => void) => void;
+export declare type NatMapFunction = (key: string) => {
+    host: string;
+    port: number;
+} | null;
+export declare type NatMap = {
+    [key: string]: {
+        host: string;
+        port: number;
+    };
+} | NatMapFunction;
+/**
+ * Options for Cluster constructor
+ */
+export interface ClusterOptions extends CommanderOptions {
+    /**
+     * See "Quick Start" section.
+     *
+     * @default (times) => Math.min(100 + times * 2, 2000)
+     */
+    clusterRetryStrategy?: ((times: number, reason?: Error) => number | void | null) | undefined;
+    /**
+     * See Redis class.
+     *
+     * @default true
+     */
+    enableOfflineQueue?: boolean | undefined;
+    /**
+     * When enabled, ioredis-om only emits "ready" event when `CLUSTER INFO`
+     * command reporting the cluster is ready for handling commands.
+     *
+     * @default true
+     */
+    enableReadyCheck?: boolean | undefined;
+    /**
+     * Scale reads to the node with the specified role.
+     *
+     * @default "master"
+     */
+    scaleReads?: NodeRole | Function | undefined;
+    /**
+     * When a MOVED or ASK error is received, client will redirect the
+     * command to another node.
+     * This option limits the max redirections allowed to send a command.
+     *
+     * @default 16
+     */
+    maxRedirections?: number | undefined;
+    /**
+     * When an error is received when sending a command (e.g.
+     * "Connection is closed." when the target Redis node is down), client will retry
+     * if `retryDelayOnFailover` is valid delay time (in ms).
+     *
+     * @default 100
+     */
+    retryDelayOnFailover?: number | undefined;
+    /**
+     * When a CLUSTERDOWN error is received, client will retry
+     * if `retryDelayOnClusterDown` is valid delay time (in ms).
+     *
+     * @default 100
+     */
+    retryDelayOnClusterDown?: number | undefined;
+    /**
+     * When a TRYAGAIN error is received, client will retry
+     * if `retryDelayOnTryAgain` is valid delay time (in ms).
+     *
+     * @default 100
+     */
+    retryDelayOnTryAgain?: number | undefined;
+    /**
+     * By default, this value is 0, which means when a `MOVED` error is received,
+     * the client will resend the command instantly to the node returned together with
+     * the `MOVED` error. However, sometimes it takes time for a cluster to become
+     * state stabilized after a failover, so adding a delay before resending can
+     * prevent a ping pong effect.
+     *
+     * @default 0
+     */
+    retryDelayOnMoved?: number | undefined;
+    /**
+     * The milliseconds before a timeout occurs while refreshing
+     * slots from the cluster.
+     *
+     * @default 1000
+     */
+    slotsRefreshTimeout?: number | undefined;
+    /**
+     * The milliseconds between every automatic slots refresh.
+     *
+     * @default 5000
+     */
+    slotsRefreshInterval?: number | undefined;
+    /**
+     * Use sharded subscribers instead of a single subscriber.
+     *
+     * If sharded subscribers are used, then one additional subscriber connection per master node
+     * is established. If you don't plan to use SPUBLISH/SSUBSCRIBE, then this should be disabled.
+     *
+     * @default false
+     */
+    shardedSubscribers?: boolean | undefined;
+    /**
+     * Passed to the constructor of `Redis`
+     *
+     * @default null
+     */
+    redisOptions?: Omit<RedisOptions, "port" | "host" | "path" | "sentinels" | "retryStrategy" | "enableOfflineQueue" | "readOnly"> | undefined;
+    /**
+     * By default, When a new Cluster instance is created,
+     * it will connect to the Redis cluster automatically.
+     * If you want to keep the instance disconnected until the first command is called,
+     * set this option to `true`.
+     *
+     * @default false
+     */
+    lazyConnect?: boolean | undefined;
+    /**
+     * Discover nodes using SRV records
+     *
+     * @default false
+     */
+    useSRVRecords?: boolean | undefined;
+    /**
+     * SRV records will be resolved via this function.
+     *
+     * You may provide a custom `resolveSrv` function when you want to customize
+     * the cache behavior of the default function.
+     *
+     * @default require('dns').resolveSrv
+     */
+    resolveSrv?: DNSResolveSrvFunction | undefined;
+    /**
+     * Hostnames will be resolved to IP addresses via this function.
+     * This is needed when the addresses of startup nodes are hostnames instead
+     * of IPs.
+     *
+     * You may provide a custom `lookup` function when you want to customize
+     * the cache behavior of the default function.
+     *
+     * @default require('dns').lookup
+     */
+    dnsLookup?: DNSLookupFunction | undefined;
+    natMap?: NatMap | undefined;
+    /**
+     * See Redis class.
+     *
+     * @default false
+     */
+    enableAutoPipelining?: boolean | undefined;
+    /**
+     * See Redis class.
+     *
+     * @default []
+     */
+    autoPipeliningIgnoredCommands?: string[] | undefined;
+    /**
+     * Custom LUA commands
+     */
+    scripts?: Record<string, {
+        lua: string;
+        numberOfKeys?: number;
+        readOnly?: boolean;
+    }> | undefined;
+}
+export declare const DEFAULT_CLUSTER_OPTIONS: ClusterOptions;

package/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/built/cluster/ClusterSubscriber.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import ConnectionPool from "./ConnectionPool";
+export default class ClusterSubscriber {
+    private connectionPool;
+    private emitter;
+    private isSharded;
+    private started;
+    private subscriber;
+    private lastActiveSubscriber;
+    private slotRange;
+    constructor(connectionPool: ConnectionPool, emitter: EventEmitter, isSharded?: boolean);
+    getInstance(): any;
+    /**
+     * 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: number[]): number[];
+    start(): void;
+    stop(): void;
+    isStarted(): boolean;
+    private onSubscriberEnd;
+    private selectSubscriber;
+}