= {
[P in keyof M as ExcludeMappedString]: {
[C in keyof M[P] as ExcludeMappedString]: RedisCommandSignature;
};
};
export type WithFunctions = {
[P in keyof F as ExcludeMappedString]: {
[FF in keyof F[P] as ExcludeMappedString]: RedisCommandSignature;
};
};
export type WithScripts = {
[P in keyof S as ExcludeMappedString]: RedisCommandSignature;
};
export type RedisClientType<
M extends RedisModules = Record,
F extends RedisFunctions = Record,
S extends RedisScripts = Record
> = RedisClient & WithCommands & WithModules & WithFunctions & WithScripts;
export type InstantiableRedisClient<
M extends RedisModules,
F extends RedisFunctions,
S extends RedisScripts
> = new (options?: RedisClientOptions) => RedisClientType;
export interface ClientCommandOptions extends QueueCommandOptions {
isolated?: boolean;
}
type ClientLegacyCallback = (err: Error | null, reply?: RedisCommandRawReply) => void;
export default class RedisClient<
M extends RedisModules,
F extends RedisFunctions,
S extends RedisScripts
> extends EventEmitter {
static commandOptions(options: T): CommandOptions {
return commandOptions(options);
}
commandOptions = RedisClient.commandOptions;
static extend<
M extends RedisModules,
F extends RedisFunctions,
S extends RedisScripts
>(extensions?: RedisExtensions): InstantiableRedisClient {
const Client = attachExtensions({
BaseClass: RedisClient,
modulesExecutor: RedisClient.prototype.commandsExecutor,
modules: extensions?.modules,
functionsExecutor: RedisClient.prototype.functionsExecuter,
functions: extensions?.functions,
scriptsExecutor: RedisClient.prototype.scriptsExecuter,
scripts: extensions?.scripts
});
if (Client !== RedisClient) {
Client.prototype.Multi = RedisClientMultiCommand.extend(extensions);
}
return Client;
}
static create<
M extends RedisModules,
F extends RedisFunctions,
S extends RedisScripts
>(options?: RedisClientOptions): RedisClientType {
return new (RedisClient.extend(options))(options);
}
static parseURL(url: string): RedisClientOptions {
// https://www.iana.org/assignments/uri-schemes/prov/redis
const { hostname, port, protocol, username, password, pathname } = new URL(url),
parsed: RedisClientOptions = {
socket: {
host: hostname
}
};
if (protocol === 'rediss:') {
(parsed.socket as RedisTlsSocketOptions).tls = true;
} else if (protocol !== 'redis:') {
throw new TypeError('Invalid protocol');
}
if (port) {
(parsed.socket as TcpSocketConnectOpts).port = Number(port);
}
if (username) {
parsed.username = decodeURIComponent(username);
}
if (password) {
parsed.password = decodeURIComponent(password);
}
if (pathname.length > 1) {
const database = Number(pathname.substring(1));
if (isNaN(database)) {
throw new TypeError('Invalid pathname');
}
parsed.database = database;
}
return parsed;
}
readonly #options?: RedisClientOptions;
readonly #socket: RedisSocket;
readonly #queue: RedisCommandsQueue;
readonly #isolationPool: Pool>;
readonly #v4: Record = {};
#selectedDB = 0;
get options(): RedisClientOptions | undefined {
return this.#options;
}
get isOpen(): boolean {
return this.#socket.isOpen;
}
get isReady(): boolean {
return this.#socket.isReady;
}
get v4(): Record {
if (!this.#options?.legacyMode) {
throw new Error('the client is not in "legacy mode"');
}
return this.#v4;
}
constructor(options?: RedisClientOptions) {
super();
this.#options = this.#initiateOptions(options);
this.#queue = this.#initiateQueue();
this.#socket = this.#initiateSocket();
this.#isolationPool = createPool({
create: async () => {
const duplicate = this.duplicate({
isolationPoolOptions: undefined
}).on('error', err => this.emit('error', err));
await duplicate.connect();
return duplicate;
},
destroy: client => client.disconnect()
}, options?.isolationPoolOptions);
this.#legacyMode();
}
#initiateOptions(options?: RedisClientOptions): RedisClientOptions | undefined {
if (options?.url) {
const parsed = RedisClient.parseURL(options.url);
if (options.socket) {
parsed.socket = Object.assign(options.socket, parsed.socket);
}
Object.assign(options, parsed);
}
if (options?.database) {
this.#selectedDB = options.database;
}
return options;
}
#initiateQueue(): RedisCommandsQueue {
return new RedisCommandsQueue(this.#options?.commandsQueueMaxLength);
}
#initiateSocket(): RedisSocket {
const socketInitiator = async (): Promise => {
const promises = [];
if (this.#selectedDB !== 0) {
promises.push(
this.#queue.addCommand(
['SELECT', this.#selectedDB.toString()],
{ asap: true }
)
);
}
if (this.#options?.readonly) {
promises.push(
this.#queue.addCommand(
COMMANDS.READONLY.transformArguments(),
{ asap: true }
)
);
}
if (this.#options?.name) {
promises.push(
this.#queue.addCommand(
COMMANDS.CLIENT_SETNAME.transformArguments(this.#options.name),
{ asap: true }
)
);
}
if (this.#options?.username || this.#options?.password) {
promises.push(
this.#queue.addCommand(
COMMANDS.AUTH.transformArguments({
username: this.#options.username,
password: this.#options.password ?? ''
}),
{ asap: true }
)
);
}
const resubscribePromise = this.#queue.resubscribe();
if (resubscribePromise) {
promises.push(resubscribePromise);
}
if (promises.length) {
this.#tick(true);
await Promise.all(promises);
}
};
return new RedisSocket(socketInitiator, this.#options?.socket)
.on('data', chunk => this.#queue.onReplyChunk(chunk))
.on('error', err => {
this.emit('error', err);
if (this.#socket.isOpen && !this.#options?.disableOfflineQueue) {
this.#queue.flushWaitingForReply(err);
} else {
this.#queue.flushAll(err);
}
})
.on('connect', () => {
this.emit('connect');
})
.on('ready', () => {
this.emit('ready');
this.#setPingTimer();
this.#tick();
})
.on('reconnecting', () => this.emit('reconnecting'))
.on('drain', () => this.#tick())
.on('end', () => this.emit('end'));
}
#legacyMode(): void {
if (!this.#options?.legacyMode) return;
(this as any).#v4.sendCommand = this.#sendCommand.bind(this);
(this as any).sendCommand = (...args: Array): void => {
let callback: ClientLegacyCallback;
if (typeof args[args.length - 1] === 'function') {
callback = args.pop() as ClientLegacyCallback;
}
this.#sendCommand(transformLegacyCommandArguments(args))
.then((reply: RedisCommandRawReply) => {
if (!callback) return;
// https://github.com/NodeRedis/node-redis#commands:~:text=minimal%20parsing
callback(null, reply);
})
.catch((err: Error) => {
if (!callback) {
this.emit('error', err);
return;
}
callback(err);
});
};
for (const name of Object.keys(COMMANDS)) {
this.#defineLegacyCommand(name);
}
for (const name of Object.keys(COMMANDS)) {
(this as any)[name.toLowerCase()] = (this as any)[name];
}
// hard coded commands
this.#defineLegacyCommand('SELECT');
this.#defineLegacyCommand('select');
this.#defineLegacyCommand('SUBSCRIBE');
this.#defineLegacyCommand('subscribe');
this.#defineLegacyCommand('PSUBSCRIBE');
this.#defineLegacyCommand('pSubscribe');
this.#defineLegacyCommand('UNSUBSCRIBE');
this.#defineLegacyCommand('unsubscribe');
this.#defineLegacyCommand('PUNSUBSCRIBE');
this.#defineLegacyCommand('pUnsubscribe');
this.#defineLegacyCommand('QUIT');
this.#defineLegacyCommand('quit');
}
#defineLegacyCommand(name: string): void {
this.#v4[name] = (this as any)[name].bind(this);
(this as any)[name] =
(...args: Array): void => (this as any).sendCommand(name, ...args);
}
#pingTimer?: NodeJS.Timer;
#setPingTimer(): void {
if (!this.#options?.pingInterval || !this.#socket.isReady) return;
clearTimeout(this.#pingTimer);
this.#pingTimer = setTimeout(() => {
if (!this.#socket.isReady) return;
(this as unknown as RedisClientType).ping()
.then(reply => this.emit('ping-interval', reply))
.catch(err => this.emit('error', err))
.finally(() => this.#setPingTimer());
}, this.#options.pingInterval);
}
duplicate(overrides?: Partial>): RedisClientType {
return new (Object.getPrototypeOf(this).constructor)({
...this.#options,
...overrides
});
}
async connect(): Promise {
await this.#socket.connect();
}
async commandsExecutor(
command: C,
args: Array
): Promise> {
const { args: redisArgs, options } = transformCommandArguments(command, args);
return transformCommandReply(
command,
await this.#sendCommand(redisArgs, options),
redisArgs.preserve
);
}
sendCommand(
args: RedisCommandArguments,
options?: ClientCommandOptions
): Promise {
return this.#sendCommand(args, options);
}
// using `#sendCommand` cause `sendCommand` is overwritten in legacy mode
#sendCommand(
args: RedisCommandArguments,
options?: ClientCommandOptions
): Promise {
if (!this.#socket.isOpen) {
return Promise.reject(new ClientClosedError());
} else if (options?.isolated) {
return this.executeIsolated(isolatedClient =>
isolatedClient.sendCommand(args, {
...options,
isolated: false
})
);
} else if (!this.#socket.isReady && this.#options?.disableOfflineQueue) {
return Promise.reject(new ClientOfflineError());
}
const promise = this.#queue.addCommand(args, options);
this.#tick();
return promise;
}
async functionsExecuter(
fn: F,
args: Array,
name: string
): Promise> {
const { args: redisArgs, options } = transformCommandArguments(fn, args);
return transformCommandReply(
fn,
await this.executeFunction(name, fn, redisArgs, options),
redisArgs.preserve
);
}
executeFunction(
name: string,
fn: RedisFunction,
args: RedisCommandArguments,
options?: ClientCommandOptions
): Promise {
return this.#sendCommand(
fCallArguments(name, fn, args),
options
);
}
async scriptsExecuter(
script: S,
args: Array
): Promise> {
const { args: redisArgs, options } = transformCommandArguments(script, args);
return transformCommandReply(
script,
await this.executeScript(script, redisArgs, options),
redisArgs.preserve
);
}
async executeScript(
script: RedisScript,
args: RedisCommandArguments,
options?: ClientCommandOptions
): Promise {
const redisArgs: RedisCommandArguments = ['EVALSHA', script.SHA1];
if (script.NUMBER_OF_KEYS !== undefined) {
redisArgs.push(script.NUMBER_OF_KEYS.toString());
}
redisArgs.push(...args);
try {
return await this.#sendCommand(redisArgs, options);
} catch (err: any) {
if (!err?.message?.startsWith?.('NOSCRIPT')) {
throw err;
}
redisArgs[0] = 'EVAL';
redisArgs[1] = script.SCRIPT;
return this.#sendCommand(redisArgs, options);
}
}
async SELECT(db: number): Promise;
async SELECT(options: CommandOptions, db: number): Promise;
async SELECT(options?: any, db?: any): Promise {
if (!isCommandOptions(options)) {
db = options;
options = null;
}
await this.#sendCommand(['SELECT', db.toString()], options);
this.#selectedDB = db;
}
select = this.SELECT;
#subscribe(
command: PubSubSubscribeCommands,
channels: string | Array,
listener: PubSubListener,
bufferMode?: T
): Promise {
const promise = this.#queue.subscribe(
command,
channels,
listener,
bufferMode
);
this.#tick();
return promise;
}
SUBSCRIBE(
channels: string | Array,
listener: PubSubListener,
bufferMode?: T
): Promise {
return this.#subscribe(
PubSubSubscribeCommands.SUBSCRIBE,
channels,
listener,
bufferMode
);
}
subscribe = this.SUBSCRIBE;
PSUBSCRIBE(
patterns: string | Array,
listener: PubSubListener,
bufferMode?: T
): Promise {
return this.#subscribe(
PubSubSubscribeCommands.PSUBSCRIBE,
patterns,
listener,
bufferMode
);
}
pSubscribe = this.PSUBSCRIBE;
#unsubscribe(
command: PubSubUnsubscribeCommands,
channels?: string | Array,
listener?: PubSubListener,
bufferMode?: T
): Promise {
const promise = this.#queue.unsubscribe(command, channels, listener, bufferMode);
this.#tick();
return promise;
}
UNSUBSCRIBE(
channels?: string | Array,
listener?: PubSubListener,
bufferMode?: T
): Promise {
return this.#unsubscribe(
PubSubUnsubscribeCommands.UNSUBSCRIBE,
channels,
listener,
bufferMode
);
}
unsubscribe = this.UNSUBSCRIBE;
PUNSUBSCRIBE(
patterns?: string | Array,
listener?: PubSubListener,
bufferMode?: T
): Promise {
return this.#unsubscribe(
PubSubUnsubscribeCommands.PUNSUBSCRIBE,
patterns,
listener,
bufferMode
);
}
pUnsubscribe = this.PUNSUBSCRIBE;
QUIT(): Promise {
return this.#socket.quit(() => {
const quitPromise = this.#queue.addCommand(['QUIT'], {
ignorePubSubMode: true
});
this.#tick();
return Promise.all([
quitPromise,
this.#destroyIsolationPool()
]);
});
}
quit = this.QUIT;
#tick(force = false): void {
if (this.#socket.writableNeedDrain || (!force && !this.#socket.isReady)) {
return;
}
this.#socket.cork();
while (!this.#socket.writableNeedDrain) {
const args = this.#queue.getCommandToSend();
if (args === undefined) break;
this.#socket.writeCommand(args);
}
}
executeIsolated(fn: (client: RedisClientType) => T | Promise): Promise {
return this.#isolationPool.use(fn);
}
MULTI(): RedisClientMultiCommandType {
return new (this as any).Multi(
this.multiExecutor.bind(this),
this.#options?.legacyMode
);
}
multi = this.MULTI;
async multiExecutor(
commands: Array,
selectedDB?: number,
chainId?: symbol
): Promise> {
if (!this.#socket.isOpen) {
return Promise.reject(new ClientClosedError());
}
const promise = Promise.all(
commands.map(({ args }) => {
return this.#queue.addCommand(args, { chainId });
})
);
this.#tick();
const results = await promise;
if (selectedDB !== undefined) {
this.#selectedDB = selectedDB;
}
return results;
}
async* scanIterator(options?: ScanCommandOptions): AsyncIterable {
let cursor = 0;
do {
const reply = await (this as any).scan(cursor, options);
cursor = reply.cursor;
for (const key of reply.keys) {
yield key;
}
} while (cursor !== 0);
}
async* hScanIterator(key: string, options?: ScanOptions): AsyncIterable> {
let cursor = 0;
do {
const reply = await (this as any).hScan(key, cursor, options);
cursor = reply.cursor;
for (const tuple of reply.tuples) {
yield tuple;
}
} while (cursor !== 0);
}
async* sScanIterator(key: string, options?: ScanOptions): AsyncIterable {
let cursor = 0;
do {
const reply = await (this as any).sScan(key, cursor, options);
cursor = reply.cursor;
for (const member of reply.members) {
yield member;
}
} while (cursor !== 0);
}
async* zScanIterator(key: string, options?: ScanOptions): AsyncIterable> {
let cursor = 0;
do {
const reply = await (this as any).zScan(key, cursor, options);
cursor = reply.cursor;
for (const member of reply.members) {
yield member;
}
} while (cursor !== 0);
}
async disconnect(): Promise {
this.#queue.flushAll(new DisconnectsClientError());
this.#socket.disconnect();
await this.#destroyIsolationPool();
}
async #destroyIsolationPool(): Promise {
await this.#isolationPool.drain();
await this.#isolationPool.clear();
}
ref(): void {
this.#socket.ref();
}
unref(): void {
this.#socket.unref();
}
}
attachCommands({
BaseClass: RedisClient,
commands: COMMANDS,
executor: RedisClient.prototype.commandsExecutor
});
(RedisClient.prototype as any).Multi = RedisClientMultiCommand;
node-redis-redis-4.5.1/packages/client/lib/client/multi-command.ts 0000664 0000000 0000000 00000014424 14337741144 0025071 0 ustar 00root root 0000000 0000000 import COMMANDS from './commands';
import { RedisCommand, RedisCommandArguments, RedisCommandRawReply, RedisFunctions, RedisModules, RedisExtensions, RedisScript, RedisScripts, ExcludeMappedString, RedisFunction } from '../commands';
import RedisMultiCommand, { RedisMultiQueuedCommand } from '../multi-command';
import { attachCommands, attachExtensions, transformLegacyCommandArguments } from '../commander';
type CommandSignature<
C extends RedisCommand,
M extends RedisModules,
F extends RedisFunctions,
S extends RedisScripts
> = (...args: Parameters) => RedisClientMultiCommandType;
type WithCommands<
M extends RedisModules,
F extends RedisFunctions,
S extends RedisScripts
> = {
[P in keyof typeof COMMANDS]: CommandSignature<(typeof COMMANDS)[P], M, F, S>;
};
type WithModules<
M extends RedisModules,
F extends RedisFunctions,
S extends RedisScripts
> = {
[P in keyof M as ExcludeMappedString]: {
[C in keyof M[P] as ExcludeMappedString]: CommandSignature;
};
};
type WithFunctions<
M extends RedisModules,
F extends RedisFunctions,
S extends RedisScripts
> = {
[P in keyof F as ExcludeMappedString]: {
[FF in keyof F[P] as ExcludeMappedString]: CommandSignature;
};
};
type WithScripts<
M extends RedisModules,
F extends RedisFunctions,
S extends RedisScripts
> = {
[P in keyof S as ExcludeMappedString]: CommandSignature;
};
export type RedisClientMultiCommandType<
M extends RedisModules,
F extends RedisFunctions,
S extends RedisScripts
> = RedisClientMultiCommand & WithCommands & WithModules & WithFunctions & WithScripts