ioredis-om 5.10.2

package/built/tracing.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceConnect = exports.traceBatch = exports.traceCommand = exports.sanitizeArgs = void 0;
+// Argument sanitization rules adapted from @opentelemetry/redis-common (Apache 2.0).
+// https://github.com/open-telemetry/opentelemetry-js-contrib/blob/main/packages/redis-common/src/index.ts
+//
+// Each entry specifies how many positional args (after the command name) are safe
+// to emit. -1 means all args are safe (read-only/structural commands).
+// Unlisted commands default to 0 (all args redacted) for safe-by-default behavior,
+// which covers AUTH, HELLO, and unknown/custom commands.
+const SERIALIZATION_SUBSETS = [
+    { regex: /^ECHO/i, args: 0 },
+    {
+        regex: /^(LPUSH|MSET|PFA|PUBLISH|RPUSH|SADD|SET|SPUBLISH|XADD|ZADD)/i,
+        args: 1,
+    },
+    { regex: /^(HSET|HMSET|LSET|LINSERT)/i, args: 2 },
+    {
+        regex: /^(ACL|BIT|B[LRZ]|CLIENT|CLUSTER|CONFIG|COMMAND|DECR|DEL|EVAL|EX|FUNCTION|GEO|GET|HINCR|HMGET|HSCAN|INCR|L[TRLM]|MEMORY|P[EFISTU]|RPOP|S[CDIMORSU]|XACK|X[CDGILPRT]|Z[CDILMPRS])/i,
+        args: -1,
+    },
+];
+function sanitizeArgs(commandName, args) {
+    let allowedArgCount = 0;
+    for (const subset of SERIALIZATION_SUBSETS) {
+        if (subset.regex.test(commandName)) {
+            allowedArgCount = subset.args;
+            break;
+        }
+    }
+    if (allowedArgCount === -1) {
+        return args.map((a) => String(a));
+    }
+    const result = [];
+    for (let i = 0; i < args.length; i++) {
+        if (i < allowedArgCount) {
+            result.push(String(args[i]));
+        }
+        else {
+            result.push("?");
+        }
+    }
+    return result;
+}
+exports.sanitizeArgs = sanitizeArgs;
+// Load diagnostics_channel with Node 18 compatibility
+const dc = (() => {
+    try {
+        return "getBuiltinModule" in process
+            ? process.getBuiltinModule("node:diagnostics_channel")
+            : require("node:diagnostics_channel");
+    }
+    catch {
+        return undefined;
+    }
+})();
+const hasTracingChannel = dc && typeof dc.tracingChannel === "function";
+const commandChannel = hasTracingChannel
+    ? dc.tracingChannel("ioredis-om:command")
+    : undefined;
+const batchChannel = hasTracingChannel
+    ? dc.tracingChannel("ioredis-om:batch")
+    : undefined;
+const connectChannel = hasTracingChannel
+    ? dc.tracingChannel("ioredis-om:connect")
+    : undefined;
+function shouldTrace(channel) {
+    return !!channel && channel.hasSubscribers !== false;
+}
+const noop = () => { };
+function traceCommand(fn, contextFactory) {
+    if (!shouldTrace(commandChannel))
+        return fn();
+    // tracePromise returns a wrapper promise that re-rejects on error.
+    // Silence the wrapper to prevent unhandled rejections when callers
+    // (e.g. Pipeline) discard the return value. Callers that await this
+    // promise still see the rejection through their own .then() chain.
+    const traced = commandChannel.tracePromise(fn, contextFactory());
+    traced.catch(noop);
+    return traced;
+}
+exports.traceCommand = traceCommand;
+function traceBatch(fn, contextFactory) {
+    if (!shouldTrace(batchChannel))
+        return fn();
+    const traced = batchChannel.tracePromise(fn, contextFactory());
+    traced.catch(noop);
+    return traced;
+}
+exports.traceBatch = traceBatch;
+function traceConnect(fn, contextFactory) {
+    if (!shouldTrace(connectChannel))
+        return fn();
+    return connectChannel.tracePromise(fn, contextFactory());
+}
+exports.traceConnect = traceConnect;

package/built/transaction.d.ts

@@ -0,0 +1,13 @@
+import { ChainableCommander } from "./utils/RedisCommander";
+export interface Transaction {
+    pipeline(commands?: unknown[][]): ChainableCommander;
+    multi(options: {
+        pipeline: false;
+    }): Promise<"OK">;
+    multi(): ChainableCommander;
+    multi(options: {
+        pipeline: true;
+    }): ChainableCommander;
+    multi(commands?: unknown[][]): ChainableCommander;
+}
+export declare function addTransactionSupport(redis: any): void;

package/built/transaction.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTransactionSupport = void 0;
+const utils_1 = require("./utils");
+const standard_as_callback_1 = require("standard-as-callback");
+const Pipeline_1 = require("./Pipeline");
+const tracing_1 = require("./tracing");
+function addTransactionSupport(redis) {
+    redis.pipeline = function (commands) {
+        const pipeline = new Pipeline_1.default(this);
+        if (Array.isArray(commands)) {
+            pipeline.addBatch(commands);
+        }
+        return pipeline;
+    };
+    const { multi } = redis;
+    redis.multi = function (commands, options) {
+        if (typeof options === "undefined" && !Array.isArray(commands)) {
+            options = commands;
+            commands = null;
+        }
+        if (options && options.pipeline === false) {
+            return multi.call(this);
+        }
+        const pipeline = new Pipeline_1.default(this);
+        // @ts-expect-error
+        pipeline.multi();
+        if (Array.isArray(commands)) {
+            pipeline.addBatch(commands);
+        }
+        const exec = pipeline.exec;
+        pipeline.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);
+                return (0, standard_as_callback_1.default)(new Promise((resolve, reject) => {
+                    this.redis.delayUntilReady((err) => {
+                        if (err) {
+                            reject(err);
+                            return;
+                        }
+                        this.exec(pipeline).then(resolve, reject);
+                    });
+                }), callback);
+            }
+            if (this._transactions > 0) {
+                exec.call(pipeline);
+            }
+            // Returns directly when the pipeline
+            // has been called multiple times (retries).
+            if (this.nodeifiedPromise) {
+                return exec.call(pipeline);
+            }
+            // Count only user commands (exclude MULTI/EXEC wrappers).
+            const batchSize = Math.max(pipeline.length - 2, 0);
+            const execAndUnwrap = () => exec.call(pipeline).then(function (result) {
+                const execResult = result[result.length - 1];
+                if (typeof execResult === "undefined") {
+                    throw new Error("Pipeline cannot be used to send any commands when the `exec()` has been called on it.");
+                }
+                if (execResult[0]) {
+                    execResult[0].previousErrors = [];
+                    for (let i = 0; i < result.length - 1; ++i) {
+                        if (result[i][0]) {
+                            execResult[0].previousErrors.push(result[i][0]);
+                        }
+                    }
+                    throw execResult[0];
+                }
+                return (0, utils_1.wrapMultiResult)(execResult[1]);
+            });
+            // Trace MULTI as a single batch operation on ioredis-om:batch.
+            const promise = "_buildBatchContext" in this.redis
+                ? (0, tracing_1.traceBatch)(execAndUnwrap, () => this.redis._buildBatchContext(batchSize))
+                : execAndUnwrap();
+            return (0, standard_as_callback_1.default)(promise, callback);
+        };
+        // @ts-expect-error
+        const { execBuffer } = pipeline;
+        // @ts-expect-error
+        pipeline.execBuffer = function (callback) {
+            if (this._transactions > 0) {
+                execBuffer.call(pipeline);
+            }
+            return pipeline.exec(callback);
+        };
+        return pipeline;
+    };
+    const { exec } = redis;
+    redis.exec = function (callback) {
+        return (0, standard_as_callback_1.default)(exec.call(this).then(function (results) {
+            if (Array.isArray(results)) {
+                results = (0, utils_1.wrapMultiResult)(results);
+            }
+            return results;
+        }), callback);
+    };
+}
+exports.addTransactionSupport = addTransactionSupport;

package/built/types.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { Socket } from "net";
+import { TLSSocket } from "tls";
+export declare type Callback<T = any> = (err?: Error | null, result?: T) => void;
+export declare type NetStream = Socket | TLSSocket;
+export declare type CommandParameter = string | Buffer | number | any[];
+export interface Respondable {
+    name: string;
+    args: CommandParameter[];
+    resolve(result: any): void;
+    reject(error: Error): void;
+}
+export interface PipelineWriteableStream {
+    isPipeline: true;
+    write(data: string | Buffer): unknown;
+    destination: {
+        redis: {
+            stream: NetStream;
+        };
+    };
+}
+export declare type WriteableStream = NetStream | PipelineWriteableStream;
+export interface CommandItem {
+    command: Respondable;
+    stream: WriteableStream;
+    select: number;
+}
+export interface ScanStreamOptions {
+    match?: string;
+    type?: string;
+    count?: number;
+    noValues?: boolean;
+}

package/built/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/built/utils/Commander.d.ts

@@ -0,0 +1,50 @@
+import Command from "../Command";
+import { WriteableStream } from "../types";
+import RedisCommander, { ClientContext } from "./RedisCommander";
+export interface CommanderOptions {
+    keyPrefix?: string | undefined;
+    showFriendlyErrorStack?: boolean | undefined;
+}
+declare class Commander<Context extends ClientContext = {
+    type: "default";
+}> {
+    options: CommanderOptions;
+    /**
+     * @ignore
+     */
+    scriptsSet: {};
+    /**
+     * @ignore
+     */
+    addedBuiltinSet: Set<string>;
+    /**
+     * Return supported builtin commands
+     */
+    getBuiltinCommands(): string[];
+    /**
+     * Create a builtin command
+     */
+    createBuiltinCommand(commandName: string): {
+        string: any;
+        buffer: any;
+    };
+    /**
+     * Create add builtin command
+     */
+    addBuiltinCommand(commandName: string): void;
+    /**
+     * Define a custom command using lua script
+     */
+    defineCommand(name: string, definition: {
+        lua: string;
+        numberOfKeys?: number;
+        readOnly?: boolean;
+    }): void;
+    /**
+     * @ignore
+     */
+    sendCommand(command: Command, stream?: WriteableStream, node?: unknown): unknown;
+}
+interface Commander<Context> extends RedisCommander<Context> {
+}
+export default Commander;

package/built/utils/Commander.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_1 = require("@ioredis/commands");
+const autoPipelining_1 = require("../autoPipelining");
+const Command_1 = require("../Command");
+const Script_1 = require("../Script");
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+class Commander {
+    constructor() {
+        this.options = {};
+        /**
+         * @ignore
+         */
+        this.scriptsSet = {};
+        /**
+         * @ignore
+         */
+        this.addedBuiltinSet = new Set();
+    }
+    /**
+     * Return supported builtin commands
+     */
+    getBuiltinCommands() {
+        return commands.slice(0);
+    }
+    /**
+     * Create a builtin command
+     */
+    createBuiltinCommand(commandName) {
+        return {
+            string: generateFunction(null, commandName, "utf8"),
+            buffer: generateFunction(null, commandName, null),
+        };
+    }
+    /**
+     * Create add builtin command
+     */
+    addBuiltinCommand(commandName) {
+        this.addedBuiltinSet.add(commandName);
+        this[commandName] = generateFunction(commandName, commandName, "utf8");
+        this[commandName + "Buffer"] = generateFunction(commandName + "Buffer", commandName, null);
+    }
+    /**
+     * Define a custom command using lua script
+     */
+    defineCommand(name, definition) {
+        const script = new Script_1.default(definition.lua, definition.numberOfKeys, this.options.keyPrefix, definition.readOnly);
+        this.scriptsSet[name] = script;
+        this[name] = generateScriptingFunction(name, name, script, "utf8");
+        this[name + "Buffer"] = generateScriptingFunction(name + "Buffer", name, script, null);
+    }
+    /**
+     * @ignore
+     */
+    sendCommand(command, stream, node) {
+        throw new Error('"sendCommand" is not implemented');
+    }
+}
+const commands = commands_1.list.filter((command) => command !== "monitor");
+commands.push("sentinel");
+commands.forEach(function (commandName) {
+    Commander.prototype[commandName] = generateFunction(commandName, commandName, "utf8");
+    Commander.prototype[commandName + "Buffer"] = generateFunction(commandName + "Buffer", commandName, null);
+});
+Commander.prototype.call = generateFunction("call", "utf8");
+Commander.prototype.callBuffer = generateFunction("callBuffer", null);
+// @ts-expect-error
+Commander.prototype.send_command = Commander.prototype.call;
+function generateFunction(functionName, _commandName, _encoding) {
+    if (typeof _encoding === "undefined") {
+        _encoding = _commandName;
+        _commandName = null;
+    }
+    return function (...args) {
+        const commandName = (_commandName || args.shift());
+        let callback = args[args.length - 1];
+        if (typeof callback === "function") {
+            args.pop();
+        }
+        else {
+            callback = undefined;
+        }
+        const options = {
+            errorStack: this.options.showFriendlyErrorStack ? new Error() : undefined,
+            keyPrefix: this.options.keyPrefix,
+            replyEncoding: _encoding,
+        };
+        // No auto pipeline, use regular command sending
+        if (!(0, autoPipelining_1.shouldUseAutoPipelining)(this, functionName, commandName)) {
+            return this.sendCommand(
+            // @ts-expect-error
+            new Command_1.default(commandName, args, options, callback));
+        }
+        // Create a new pipeline and make sure it's scheduled
+        return (0, autoPipelining_1.executeWithAutoPipelining)(this, functionName, commandName, 
+        // @ts-expect-error
+        args, callback);
+    };
+}
+function generateScriptingFunction(functionName, commandName, script, encoding) {
+    return function (...args) {
+        const callback = typeof args[args.length - 1] === "function" ? args.pop() : undefined;
+        const options = {
+            replyEncoding: encoding,
+        };
+        if (this.options.showFriendlyErrorStack) {
+            options.errorStack = new Error();
+        }
+        // No auto pipeline, use regular command sending
+        if (!(0, autoPipelining_1.shouldUseAutoPipelining)(this, functionName, commandName)) {
+            return script.execute(this, args, options, callback);
+        }
+        // Create a new pipeline and make sure it's scheduled
+        return (0, autoPipelining_1.executeWithAutoPipelining)(this, functionName, commandName, args, callback);
+    };
+}
+exports.default = Commander;