orcaq 1.1.1 → 1.1.2

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

@@ -0,0 +1,425 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_1 = require("../commands");
+const node_events_1 = require("node:events");
+const commander_1 = require("../commander");
+const cluster_slots_1 = __importStar(require("./cluster-slots"));
+const multi_command_1 = __importDefault(require("./multi-command"));
+const errors_1 = require("../errors");
+const parser_1 = require("../client/parser");
+const ASKING_1 = require("../commands/ASKING");
+const single_entry_cache_1 = __importDefault(require("../single-entry-cache"));
+const tracing_1 = require("../client/tracing");
+const identity_1 = require("../client/identity");
+class RedisCluster extends node_events_1.EventEmitter {
+    static #createCommand(command, resp) {
+        const transformReply = (0, commander_1.getTransformReply)(command, resp);
+        return async function (...args) {
+            const parser = new parser_1.BasicCommandParser();
+            command.parseCommand(parser, ...args);
+            return this._self._execute(parser.firstKey, command.IS_READ_ONLY, this._commandOptions, (client, opts) => client._executeCommand(command, parser, opts, transformReply));
+        };
+    }
+    static #createModuleCommand(command, resp) {
+        const transformReply = (0, commander_1.getTransformReply)(command, resp);
+        return async function (...args) {
+            const parser = new parser_1.BasicCommandParser();
+            command.parseCommand(parser, ...args);
+            return this._self._execute(parser.firstKey, command.IS_READ_ONLY, this._self._commandOptions, (client, opts) => client._executeCommand(command, parser, opts, transformReply));
+        };
+    }
+    static #createFunctionCommand(name, fn, resp) {
+        const prefix = (0, commander_1.functionArgumentsPrefix)(name, fn);
+        const transformReply = (0, commander_1.getTransformReply)(fn, resp);
+        return async function (...args) {
+            const parser = new parser_1.BasicCommandParser();
+            parser.push(...prefix);
+            fn.parseCommand(parser, ...args);
+            return this._self._execute(parser.firstKey, fn.IS_READ_ONLY, this._self._commandOptions, (client, opts) => client._executeCommand(fn, parser, opts, transformReply));
+        };
+    }
+    static #createScriptCommand(script, resp) {
+        const prefix = (0, commander_1.scriptArgumentsPrefix)(script);
+        const transformReply = (0, commander_1.getTransformReply)(script, resp);
+        return async function (...args) {
+            const parser = new parser_1.BasicCommandParser();
+            parser.push(...prefix);
+            script.parseCommand(parser, ...args);
+            return this._self._execute(parser.firstKey, script.IS_READ_ONLY, this._commandOptions, (client, opts) => client._executeScript(script, parser, opts, transformReply));
+        };
+    }
+    static #SingleEntryCache = new single_entry_cache_1.default();
+    static factory(config) {
+        let Cluster = RedisCluster.#SingleEntryCache.get(config);
+        if (!Cluster) {
+            Cluster = (0, commander_1.attachConfig)({
+                BaseClass: RedisCluster,
+                commands: commands_1.NON_STICKY_COMMANDS,
+                createCommand: RedisCluster.#createCommand,
+                createModuleCommand: RedisCluster.#createModuleCommand,
+                createFunctionCommand: RedisCluster.#createFunctionCommand,
+                createScriptCommand: RedisCluster.#createScriptCommand,
+                config
+            });
+            Cluster.prototype.Multi = multi_command_1.default.extend(config);
+            RedisCluster.#SingleEntryCache.set(config, Cluster);
+        }
+        return (options) => {
+            // returning a "proxy" to prevent the namespaces._self to leak between "proxies"
+            return Object.create(new Cluster(options));
+        };
+    }
+    static create(options) {
+        return RedisCluster.factory(options)(options);
+    }
+    _options;
+    _slots;
+    #identity;
+    _self = this;
+    _commandOptions;
+    /**
+     * An array of the cluster slots, each slot contain its `master` and `replicas`.
+     * Use with {@link RedisCluster.prototype.nodeClient} to get the client for a specific node (master or replica).
+     */
+    get slots() {
+        return this._self._slots.slots;
+    }
+    get clientSideCache() {
+        return this._self._slots.clientSideCache;
+    }
+    /**
+     * An array of the cluster masters.
+     * Use with {@link RedisCluster.prototype.nodeClient} to get the client for a specific master node.
+     */
+    get masters() {
+        return this._self._slots.masters;
+    }
+    /**
+     * An array of the cluster replicas.
+     * Use with {@link RedisCluster.prototype.nodeClient} to get the client for a specific replica node.
+     */
+    get replicas() {
+        return this._self._slots.replicas;
+    }
+    /**
+     * A map form a node address (`<host>:<port>`) to its shard, each shard contain its `master` and `replicas`.
+     * Use with {@link RedisCluster.prototype.nodeClient} to get the client for a specific node (master or replica).
+     */
+    get nodeByAddress() {
+        return this._self._slots.nodeByAddress;
+    }
+    /**
+     * The current pub/sub node.
+     */
+    get pubSubNode() {
+        return this._self._slots.pubSubNode;
+    }
+    get isOpen() {
+        return this._self._slots.isOpen;
+    }
+    /**
+     * @internal
+     * Returns the cluster identity for tracking in metrics.
+     */
+    get identity() {
+        return this._self.#identity;
+    }
+    constructor(options) {
+        super();
+        this.#identity = {
+            id: (0, identity_1.generateClusterClientId)(options.rootNodes),
+            role: identity_1.ClientRole.CLUSTER
+        };
+        this._options = options;
+        this._slots = new cluster_slots_1.default(options, this.emit.bind(this), this.#identity.id);
+        this.on(cluster_slots_1.RESUBSCRIBE_LISTENERS_EVENT, this.resubscribeAllPubSubListeners.bind(this));
+        if (options?.commandOptions) {
+            this._commandOptions = options.commandOptions;
+        }
+    }
+    duplicate(overrides) {
+        return new (Object.getPrototypeOf(this).constructor)({
+            ...this._self._options,
+            commandOptions: this._commandOptions,
+            ...overrides
+        });
+    }
+    async connect() {
+        await this._self._slots.connect();
+        return this;
+    }
+    withCommandOptions(options) {
+        const proxy = Object.create(this);
+        proxy._commandOptions = options;
+        return proxy;
+    }
+    _commandOptionsProxy(key, value) {
+        const proxy = Object.create(this);
+        proxy._commandOptions = Object.create(this._commandOptions ?? null);
+        proxy._commandOptions[key] = value;
+        return proxy;
+    }
+    /**
+     * Override the `typeMapping` command option
+     */
+    withTypeMapping(typeMapping) {
+        return this._commandOptionsProxy('typeMapping', typeMapping);
+    }
+    // /**
+    //  * Override the `policies` command option
+    //  * TODO
+    //  */
+    // withPolicies<POLICIES extends CommandPolicies> (policies: POLICIES) {
+    //   return this._commandOptionsProxy('policies', policies);
+    // }
+    _handleAsk(fn) {
+        return async (client, options) => {
+            const chainId = Symbol("asking chain");
+            const opts = options ? { ...options } : {};
+            opts.chainId = chainId;
+            const ret = await Promise.all([
+                client.sendCommand([ASKING_1.ASKING_CMD], { chainId: chainId }),
+                fn(client, opts)
+            ]);
+            return ret[1];
+        };
+    }
+    async _execute(firstKey, isReadonly, options, fn) {
+        const maxCommandRedirections = this._options.maxCommandRedirections ?? 16;
+        let { client, slotNumber } = await this._slots.getClientAndSlotNumber(firstKey, isReadonly);
+        let i = 0;
+        let myFn = fn;
+        while (true) {
+            try {
+                const opts = options ?? {};
+                opts.slotNumber = slotNumber;
+                return await myFn(client, opts);
+            }
+            catch (_err) {
+                const err = _err;
+                myFn = fn;
+                // TODO: error class
+                if (++i > maxCommandRedirections || !(err instanceof Error)) {
+                    if (err instanceof Error) {
+                        (0, tracing_1.publish)(tracing_1.CHANNELS.ERROR, () => ({
+                            error: err,
+                            origin: 'cluster',
+                            internal: false,
+                            clientId: client._clientId,
+                            retryCount: i,
+                        }));
+                    }
+                    throw err;
+                }
+                if (err.message.startsWith('ASK')) {
+                    (0, tracing_1.publish)(tracing_1.CHANNELS.ERROR, () => ({
+                        error: err,
+                        origin: 'cluster',
+                        internal: true,
+                        clientId: client._clientId,
+                        retryCount: i,
+                    }));
+                    const address = err.message.substring(err.message.lastIndexOf(' ') + 1);
+                    let redirectTo = await this._slots.getMasterByAddress(address);
+                    if (!redirectTo) {
+                        await this._slots.rediscover(client);
+                        redirectTo = await this._slots.getMasterByAddress(address);
+                    }
+                    if (!redirectTo) {
+                        throw new Error(`Cannot find node ${address}`);
+                    }
+                    client = redirectTo;
+                    myFn = this._handleAsk(fn);
+                    continue;
+                }
+                if (err.message.startsWith('MOVED')) {
+                    (0, tracing_1.publish)(tracing_1.CHANNELS.ERROR, () => ({
+                        error: err,
+                        origin: 'cluster',
+                        internal: true,
+                        clientId: client._clientId,
+                        retryCount: i,
+                    }));
+                    await this._slots.rediscover(client);
+                    const clientAndSlot = await this._slots.getClientAndSlotNumber(firstKey, isReadonly);
+                    client = clientAndSlot.client;
+                    slotNumber = clientAndSlot.slotNumber;
+                    continue;
+                }
+                throw err;
+            }
+        }
+    }
+    async sendCommand(firstKey, isReadonly, args, options) {
+        // Merge global options with local options
+        const opts = {
+            ...this._self._commandOptions,
+            ...options
+        };
+        return this._self._execute(firstKey, isReadonly, opts, (client, opts) => client.sendCommand(args, opts));
+    }
+    MULTI(routing) {
+        return new this.Multi(async (firstKey, isReadonly, commands) => {
+            const { client } = await this._self._slots.getClientAndSlotNumber(firstKey, isReadonly);
+            return client._executeMulti(commands);
+        }, async (firstKey, isReadonly, commands) => {
+            const { client } = await this._self._slots.getClientAndSlotNumber(firstKey, isReadonly);
+            return client._executePipeline(commands);
+        }, routing, this._commandOptions?.typeMapping);
+    }
+    multi = this.MULTI;
+    async SUBSCRIBE(channels, listener, bufferMode) {
+        return (await this._self._slots.getPubSubClient())
+            .SUBSCRIBE(channels, listener, bufferMode);
+    }
+    subscribe = this.SUBSCRIBE;
+    async UNSUBSCRIBE(channels, listener, bufferMode) {
+        return this._self._slots.executeUnsubscribeCommand(client => client.UNSUBSCRIBE(channels, listener, bufferMode));
+    }
+    unsubscribe = this.UNSUBSCRIBE;
+    async PSUBSCRIBE(patterns, listener, bufferMode) {
+        return (await this._self._slots.getPubSubClient())
+            .PSUBSCRIBE(patterns, listener, bufferMode);
+    }
+    pSubscribe = this.PSUBSCRIBE;
+    async PUNSUBSCRIBE(patterns, listener, bufferMode) {
+        return this._self._slots.executeUnsubscribeCommand(client => client.PUNSUBSCRIBE(patterns, listener, bufferMode));
+    }
+    pUnsubscribe = this.PUNSUBSCRIBE;
+    async SSUBSCRIBE(channels, listener, bufferMode) {
+        const maxCommandRedirections = this._self._options.maxCommandRedirections ?? 16, firstChannel = Array.isArray(channels) ? channels[0] : channels;
+        let client = await this._self._slots.getShardedPubSubClient(firstChannel);
+        for (let i = 0;; i++) {
+            try {
+                return await client.SSUBSCRIBE(channels, listener, bufferMode);
+            }
+            catch (err) {
+                if (++i > maxCommandRedirections || !(err instanceof errors_1.ErrorReply)) {
+                    throw err;
+                }
+                if (err.message.startsWith('MOVED')) {
+                    await this._self._slots.rediscover(client);
+                    client = await this._self._slots.getShardedPubSubClient(firstChannel);
+                    continue;
+                }
+                throw err;
+            }
+        }
+    }
+    sSubscribe = this.SSUBSCRIBE;
+    SUNSUBSCRIBE(channels, listener, bufferMode) {
+        return this._self._slots.executeShardedUnsubscribeCommand(Array.isArray(channels) ? channels[0] : channels, client => client.SUNSUBSCRIBE(channels, listener, bufferMode));
+    }
+    resubscribeAllPubSubListeners(allListeners) {
+        if (allListeners.CHANNELS) {
+            for (const [channel, listeners] of allListeners.CHANNELS) {
+                listeners.buffers.forEach(bufListener => {
+                    this.subscribe(channel, bufListener, true);
+                });
+                listeners.strings.forEach(strListener => {
+                    this.subscribe(channel, strListener);
+                });
+            }
+        }
+        if (allListeners.PATTERNS) {
+            for (const [channel, listeners] of allListeners.PATTERNS) {
+                listeners.buffers.forEach(bufListener => {
+                    this.pSubscribe(channel, bufListener, true);
+                });
+                listeners.strings.forEach(strListener => {
+                    this.pSubscribe(channel, strListener);
+                });
+            }
+        }
+        if (allListeners.SHARDED) {
+            for (const [channel, listeners] of allListeners.SHARDED) {
+                listeners.buffers.forEach(bufListener => {
+                    this.sSubscribe(channel, bufListener, true);
+                });
+                listeners.strings.forEach(strListener => {
+                    this.sSubscribe(channel, strListener);
+                });
+            }
+        }
+    }
+    sUnsubscribe = this.SUNSUBSCRIBE;
+    /**
+     * @deprecated Use `close` instead.
+     */
+    quit() {
+        return this._self._slots.quit();
+    }
+    /**
+     * @deprecated Use `destroy` instead.
+     */
+    disconnect() {
+        return this._self._slots.disconnect();
+    }
+    close() {
+        this._self._slots.clientSideCache?.onPoolClose();
+        return this._self._slots.close();
+    }
+    destroy() {
+        this._self._slots.clientSideCache?.onPoolClose();
+        return this._self._slots.destroy();
+    }
+    nodeClient(node) {
+        return this._self._slots.nodeClient(node);
+    }
+    /**
+     * Returns a random node from the cluster.
+     * Userful for running "forward" commands (like PUBLISH) on a random node.
+     */
+    getRandomNode() {
+        return this._self._slots.getRandomNode();
+    }
+    /**
+     * Get a random node from a slot.
+     * Useful for running readonly commands on a slot.
+     */
+    getSlotRandomNode(slot) {
+        return this._self._slots.getSlotRandomNode(slot);
+    }
+    /**
+     * @deprecated use `.masters` instead
+     * TODO
+     */
+    getMasters() {
+        return this.masters;
+    }
+    /**
+     * @deprecated use `.slots[<SLOT>]` instead
+     * TODO
+     */
+    getSlotMaster(slot) {
+        return this.slots[slot].master;
+    }
+}
+exports.default = RedisCluster;
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redis/client/dist/lib/cluster/multi-command.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_1 = require("../commands");
+const multi_command_1 = __importDefault(require("../multi-command"));
+const commander_1 = require("../commander");
+const parser_1 = require("../client/parser");
+class RedisClusterMultiCommand {
+    static #createCommand(command, resp) {
+        const transformReply = (0, commander_1.getTransformReply)(command, resp);
+        return function (...args) {
+            const parser = new parser_1.BasicCommandParser();
+            command.parseCommand(parser, ...args);
+            const redisArgs = parser.redisArgs;
+            redisArgs.preserve = parser.preserve;
+            const firstKey = parser.firstKey;
+            return this.addCommand(firstKey, command.IS_READ_ONLY, redisArgs, transformReply);
+        };
+    }
+    static #createModuleCommand(command, resp) {
+        const transformReply = (0, commander_1.getTransformReply)(command, resp);
+        return function (...args) {
+            const parser = new parser_1.BasicCommandParser();
+            command.parseCommand(parser, ...args);
+            const redisArgs = parser.redisArgs;
+            redisArgs.preserve = parser.preserve;
+            const firstKey = parser.firstKey;
+            return this._self.addCommand(firstKey, command.IS_READ_ONLY, redisArgs, transformReply);
+        };
+    }
+    static #createFunctionCommand(name, fn, resp) {
+        const prefix = (0, commander_1.functionArgumentsPrefix)(name, fn);
+        const transformReply = (0, commander_1.getTransformReply)(fn, resp);
+        return function (...args) {
+            const parser = new parser_1.BasicCommandParser();
+            parser.push(...prefix);
+            fn.parseCommand(parser, ...args);
+            const redisArgs = parser.redisArgs;
+            redisArgs.preserve = parser.preserve;
+            const firstKey = parser.firstKey;
+            return this._self.addCommand(firstKey, fn.IS_READ_ONLY, redisArgs, transformReply);
+        };
+    }
+    static #createScriptCommand(script, resp) {
+        const transformReply = (0, commander_1.getTransformReply)(script, resp);
+        return function (...args) {
+            const parser = new parser_1.BasicCommandParser();
+            script.parseCommand(parser, ...args);
+            const scriptArgs = parser.redisArgs;
+            scriptArgs.preserve = parser.preserve;
+            const firstKey = parser.firstKey;
+            return this.#addScript(firstKey, script.IS_READ_ONLY, script, scriptArgs, transformReply);
+        };
+    }
+    static extend(config) {
+        return (0, commander_1.attachConfig)({
+            BaseClass: RedisClusterMultiCommand,
+            commands: commands_1.NON_STICKY_COMMANDS,
+            createCommand: RedisClusterMultiCommand.#createCommand,
+            createModuleCommand: RedisClusterMultiCommand.#createModuleCommand,
+            createFunctionCommand: RedisClusterMultiCommand.#createFunctionCommand,
+            createScriptCommand: RedisClusterMultiCommand.#createScriptCommand,
+            config
+        });
+    }
+    #multi;
+    #executeMulti;
+    #executePipeline;
+    #firstKey;
+    #isReadonly = true;
+    constructor(executeMulti, executePipeline, routing, typeMapping) {
+        this.#multi = new multi_command_1.default(typeMapping);
+        this.#executeMulti = executeMulti;
+        this.#executePipeline = executePipeline;
+        this.#firstKey = routing;
+    }
+    #setState(firstKey, isReadonly) {
+        this.#firstKey ??= firstKey;
+        this.#isReadonly &&= isReadonly;
+    }
+    addCommand(firstKey, isReadonly, args, transformReply) {
+        this.#setState(firstKey, isReadonly);
+        this.#multi.addCommand(args, transformReply);
+        return this;
+    }
+    #addScript(firstKey, isReadonly, script, args, transformReply) {
+        this.#setState(firstKey, isReadonly);
+        this.#multi.addScript(script, args, transformReply);
+        return this;
+    }
+    async exec(execAsPipeline = false) {
+        if (execAsPipeline)
+            return this.execAsPipeline();
+        return this.#multi.transformReplies(await this.#executeMulti(this.#firstKey, this.#isReadonly, this.#multi.queue));
+    }
+    EXEC = this.exec;
+    execTyped(execAsPipeline = false) {
+        return this.exec(execAsPipeline);
+    }
+    async execAsPipeline() {
+        if (this.#multi.queue.length === 0)
+            return [];
+        return this.#multi.transformReplies(await this.#executePipeline(this.#firstKey, this.#isReadonly, this.#multi.queue));
+    }
+    execAsPipelineTyped() {
+        return this.execAsPipeline();
+    }
+    /**
+     * Adds a raw command to the multi/pipeline queue.
+     *
+     * Note: Using this method breaks the type inference for `execTyped` and
+     * `execAsPipelineTyped`. This is a known limitation and will be addressed
+     * in the future.
+     */
+    sendCommand(args, options) {
+        const redisArgs = args.slice();
+        this.addCommand(options?.firstKey, options?.isReadonly, redisArgs);
+        return this;
+    }
+}
+exports.default = RedisClusterMultiCommand;
+//# sourceMappingURL=multi-command.js.map

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scriptArgumentsPrefix = exports.functionArgumentsPrefix = exports.getTransformReply = exports.attachConfig = void 0;
+/* FIXME: better error message / link */
+function throwResp3SearchModuleUnstableError() {
+    throw new Error('Some RESP3 results for Redis Query Engine responses may change. Refer to the readme for guidance');
+}
+function attachConfig({ BaseClass, commands, createCommand, createModuleCommand, createFunctionCommand, createScriptCommand, config }) {
+    const RESP = config?.RESP ?? 2, Class = class extends BaseClass {
+    };
+    for (const [name, command] of Object.entries(commands)) {
+        if (config?.RESP == 3 && command.unstableResp3 && !config.unstableResp3) {
+            Class.prototype[name] = throwResp3SearchModuleUnstableError;
+        }
+        else {
+            Class.prototype[name] = createCommand(command, RESP);
+        }
+    }
+    if (config?.modules) {
+        for (const [moduleName, module] of Object.entries(config.modules)) {
+            const fns = Object.create(null);
+            for (const [name, command] of Object.entries(module)) {
+                if (config.RESP == 3 && command.unstableResp3 && !config.unstableResp3) {
+                    fns[name] = throwResp3SearchModuleUnstableError;
+                }
+                else {
+                    fns[name] = createModuleCommand(command, RESP);
+                }
+            }
+            attachNamespace(Class.prototype, moduleName, fns);
+        }
+    }
+    if (config?.functions) {
+        for (const [library, commands] of Object.entries(config.functions)) {
+            const fns = Object.create(null);
+            for (const [name, command] of Object.entries(commands)) {
+                fns[name] = createFunctionCommand(name, command, RESP);
+            }
+            attachNamespace(Class.prototype, library, fns);
+        }
+    }
+    if (config?.scripts) {
+        for (const [name, script] of Object.entries(config.scripts)) {
+            Class.prototype[name] = createScriptCommand(script, RESP);
+        }
+    }
+    return Class;
+}
+exports.attachConfig = attachConfig;
+function attachNamespace(prototype, name, fns) {
+    Object.defineProperty(prototype, name, {
+        get() {
+            const value = Object.create(fns);
+            value._self = this;
+            Object.defineProperty(this, name, { value });
+            return value;
+        }
+    });
+}
+function getTransformReply(command, resp) {
+    switch (typeof command.transformReply) {
+        case 'function':
+            return command.transformReply;
+        case 'object':
+            return command.transformReply[resp];
+    }
+}
+exports.getTransformReply = getTransformReply;
+function functionArgumentsPrefix(name, fn) {
+    const prefix = [
+        fn.IS_READ_ONLY ? 'FCALL_RO' : 'FCALL',
+        name
+    ];
+    if (fn.NUMBER_OF_KEYS !== undefined) {
+        prefix.push(fn.NUMBER_OF_KEYS.toString());
+    }
+    return prefix;
+}
+exports.functionArgumentsPrefix = functionArgumentsPrefix;
+function scriptArgumentsPrefix(script) {
+    const prefix = [
+        script.IS_READ_ONLY ? 'EVALSHA_RO' : 'EVALSHA',
+        script.SHA1
+    ];
+    if (script.NUMBER_OF_KEYS !== undefined) {
+        prefix.push(script.NUMBER_OF_KEYS.toString());
+    }
+    return prefix;
+}
+exports.scriptArgumentsPrefix = scriptArgumentsPrefix;
+//# sourceMappingURL=commander.js.map

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Lists ACL categories or commands in a category
+     * @param parser - The Redis command parser
+     * @param categoryName - Optional category name to filter commands
+     */
+    parseCommand(parser, categoryName) {
+        parser.push('ACL', 'CAT');
+        if (categoryName) {
+            parser.push(categoryName);
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=ACL_CAT.js.map

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Deletes one or more users from the ACL
+     * @param parser - The Redis command parser
+     * @param username - Username(s) to delete
+     */
+    parseCommand(parser, username) {
+        parser.push('ACL', 'DELUSER');
+        parser.pushVariadic(username);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=ACL_DELUSER.js.map