1267420195

Build # 1267420195

Build Type

push

github

Committed by GitHub

Commit Message

v4.0.0-rc.2 (#1664)

Run Details

1003 of 1114 branches covered (90.04%)

Branch coverage included in aggregate %.

193 of 200 new or added lines in 62 files covered. (96.5%)

2 existing lines in 1 file now uncovered.

2725 of 2800 relevant lines covered (97.32%)

3839.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.48

/lib/multi-command.ts

import COMMANDS, { TransformArgumentsReply } from './commands';
import { RedisCommand, RedisModules, RedisReply } from './commands';
import { RedisLuaScript, RedisLuaScripts } from './lua-script';
import { RedisClientOptions } from './client';
import { extendWithModulesAndScripts, extendWithDefaultCommands } from './commander';
import { WatchError } from './errors';

type RedisMultiCommandSignature<C extends RedisCommand, M extends RedisModules, S extends RedisLuaScripts> = (...args: Parameters<C['transformArguments']>) => RedisMultiCommandType<M, S>;

type WithCommands<M extends RedisModules, S extends RedisLuaScripts> = {
    [P in keyof typeof COMMANDS]: RedisMultiCommandSignature<(typeof COMMANDS)[P], M, S>
};

type WithModules<M extends RedisModules, S extends RedisLuaScripts> = {
    [P in keyof M]: {
        [C in keyof M[P]]: RedisMultiCommandSignature<M[P][C], M, S>;
    };
};

type WithScripts<M extends RedisModules, S extends RedisLuaScripts> = {
    [P in keyof S]: RedisMultiCommandSignature<S[P], M, S>
};

export type RedisMultiCommandType<M extends RedisModules = {}, S extends RedisLuaScripts = {}> =
    RedisMultiCommand<M, S> & WithCommands<M, S> & WithModules<M, S> & WithScripts<M, S>;

export interface MultiQueuedCommand {
    args: TransformArgumentsReply;
    preservedArguments?: unknown;
    transformReply?: RedisCommand['transformReply'];
}

export type RedisMultiExecutor = (queue: Array<MultiQueuedCommand>, chainId?: symbol) => Promise<Array<RedisReply>>;

export default class RedisMultiCommand<M extends RedisModules, S extends RedisLuaScripts> {
    static extend<M extends RedisModules, S extends RedisLuaScripts>(
        clientOptions?: RedisClientOptions<M, S>
    ): new (...args: ConstructorParameters<typeof RedisMultiCommand>) => RedisMultiCommandType<M, S> {
        return <any>extendWithModulesAndScripts({
            BaseClass: RedisMultiCommand,
            modules: clientOptions?.modules,
            modulesCommandsExecutor: RedisMultiCommand.prototype.commandsExecutor,
            scripts: clientOptions?.scripts,
            scriptsExecutor: RedisMultiCommand.prototype.scriptsExecutor
        });
    }

    static create<M extends RedisModules = {}, S extends RedisLuaScripts = {}>(
        executor: RedisMultiExecutor,
        clientOptions?: RedisClientOptions<M, S>
    ): RedisMultiCommandType<M, S> {
        return <any>new this(executor, clientOptions);
    }

    readonly #executor: RedisMultiExecutor;

    readonly #clientOptions: RedisClientOptions<M, S> | undefined;

    readonly #queue: Array<MultiQueuedCommand> = [];

    readonly #scriptsInUse = new Set<string>();

    readonly #v4: Record<string, any> = {};

    get v4(): Record<string, any> {
        if (!this.#clientOptions?.legacyMode) {
            throw new Error('client is not in "legacy mode"');
        }

        return this.#v4;
    }

    constructor(executor: RedisMultiExecutor, clientOptions?: RedisClientOptions<M, S>) {
        this.#executor = executor;
        this.#clientOptions = clientOptions;
        this.#legacyMode();
    }

    #legacyMode(): void {
        if (!this.#clientOptions?.legacyMode) return;

        this.#v4.addCommand = this.addCommand.bind(this);
        (this as any).addCommand = (...args: Array<unknown>): this => {
            this.#queue.push({
                args: args.flat() as Array<string>
            });
            return this;
        }
        this.#v4.exec = this.exec.bind(this);
        (this as any).exec = (callback?: (err: Error | null, replies?: Array<unknown>) => unknown): void => {
            this.#v4.exec()
                .then((reply: Array<unknown>) => {
                    if (!callback) return;

                    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);
        }
    }

    #defineLegacyCommand(name: string): void {
        (this as any).#v4[name] = (this as any)[name].bind(this.#v4);
        (this as any)[name] = (...args: Array<unknown>): void => (this as any).addCommand(name, args);
    }

    commandsExecutor(command: RedisCommand, args: Array<unknown>): this {
        return this.addCommand(
            command.transformArguments(...args),
            command.transformReply
        );
    }

    scriptsExecutor(script: RedisLuaScript, args: Array<unknown>): this {
        const transformedArguments: TransformArgumentsReply = [];
        if (this.#scriptsInUse.has(script.SHA1)) {
            transformedArguments.push(
                'EVALSHA',
                script.SHA1
            );
        } else {
            this.#scriptsInUse.add(script.SHA1);
            transformedArguments.push(
                'EVAL',
                script.SCRIPT
            );
        }

        transformedArguments.push(script.NUMBER_OF_KEYS.toString());

        const scriptArguments = script.transformArguments(...args);
        transformedArguments.push(...scriptArguments);
        if (scriptArguments.preserve) {
            transformedArguments.preserve = scriptArguments.preserve;
        }

        return this.addCommand(
            transformedArguments,
            script.transformReply
        );
    }

    addCommand(args: TransformArgumentsReply, transformReply?: RedisCommand['transformReply']): this {
        this.#queue.push({
            args,
            preservedArguments: args.preserve,
            transformReply
        });

        return this;
    }

    async exec(execAsPipeline = false): Promise<Array<RedisReply>> {
        if (execAsPipeline) {
            return this.execAsPipeline();
        } else if (!this.#queue.length) {
            return [];
        }

        const queue = this.#queue.splice(0),
            rawReplies = await this.#executor([
                { args: ['MULTI'] },
                ...queue,
                { args: ['EXEC'] }
            ], Symbol('[RedisMultiCommand] Chain ID')),
            execReply = rawReplies[rawReplies.length - 1] as (null | Array<RedisReply>);

        if (execReply === null) {
            throw new WatchError();
        }

        return this.#transformReplies(execReply, queue);
    }

    async execAsPipeline(): Promise<Array<RedisReply>> {
        if (!this.#queue.length) {
            return [];
        }

        const queue = this.#queue.splice(0);
        return this.#transformReplies(
            await this.#executor(queue),
            queue
        );
    }

    #transformReplies(rawReplies: Array<RedisReply>, queue: Array<MultiQueuedCommand>): Array<RedisReply> {
        return rawReplies.map((reply, i) => {
            const { transformReply, preservedArguments } = queue[i];
            return transformReply ? transformReply(reply, preservedArguments) : reply;
        });
    }
}

extendWithDefaultCommands(RedisMultiCommand, RedisMultiCommand.prototype.commandsExecutor);

1	import COMMANDS, { TransformArgumentsReply } from './commands';	6✔
2	import { RedisCommand, RedisModules, RedisReply } from './commands';
3	import { RedisLuaScript, RedisLuaScripts } from './lua-script';
4	import { RedisClientOptions } from './client';
5	import { extendWithModulesAndScripts, extendWithDefaultCommands } from './commander';	6✔
6	import { WatchError } from './errors';	6✔
7
8	type RedisMultiCommandSignature<C extends RedisCommand, M extends RedisModules, S extends RedisLuaScripts> = (...args: Parameters<C['transformArguments']>) => RedisMultiCommandType<M, S>;
9
10	type WithCommands<M extends RedisModules, S extends RedisLuaScripts> = {
11	[P in keyof typeof COMMANDS]: RedisMultiCommandSignature<(typeof COMMANDS)[P], M, S>
12	};
13
14	type WithModules<M extends RedisModules, S extends RedisLuaScripts> = {
15	[P in keyof M]: {
16	[C in keyof M[P]]: RedisMultiCommandSignature<M[P][C], M, S>;
17	};
18	};
19
20	type WithScripts<M extends RedisModules, S extends RedisLuaScripts> = {
21	[P in keyof S]: RedisMultiCommandSignature<S[P], M, S>
22	};
23
24	export type RedisMultiCommandType<M extends RedisModules = {}, S extends RedisLuaScripts = {}> =
25	RedisMultiCommand<M, S> & WithCommands<M, S> & WithModules<M, S> & WithScripts<M, S>;
26
27	export interface MultiQueuedCommand {
28	args: TransformArgumentsReply;
29	preservedArguments?: unknown;
30	transformReply?: RedisCommand['transformReply'];
31	}
32
33	export type RedisMultiExecutor = (queue: Array<MultiQueuedCommand>, chainId?: symbol) => Promise<Array<RedisReply>>;
34
35	export default class RedisMultiCommand<M extends RedisModules, S extends RedisLuaScripts> {	6✔
36	static extend<M extends RedisModules, S extends RedisLuaScripts>(
37	clientOptions?: RedisClientOptions<M, S>
38	): new (...args: ConstructorParameters<typeof RedisMultiCommand>) => RedisMultiCommandType<M, S> {
39	return <any>extendWithModulesAndScripts({	453✔
40	BaseClass: RedisMultiCommand,
41	modules: clientOptions?.modules,	1,359✔
42	modulesCommandsExecutor: RedisMultiCommand.prototype.commandsExecutor,
43	scripts: clientOptions?.scripts,	1,359✔
44	scriptsExecutor: RedisMultiCommand.prototype.scriptsExecutor
45	});
46	}
47
48	static create<M extends RedisModules = {}, S extends RedisLuaScripts = {}>(
49	executor: RedisMultiExecutor,
50	clientOptions?: RedisClientOptions<M, S>
51	): RedisMultiCommandType<M, S> {
52	return <any>new this(executor, clientOptions);	36✔
53	}
54
55	readonly #executor: RedisMultiExecutor;	90✔
56
57	readonly #clientOptions: RedisClientOptions<M, S> \| undefined;	90✔
58
59	readonly #queue: Array<MultiQueuedCommand> = [];	90✔
60
61	readonly #scriptsInUse = new Set<string>();	90✔
62
63	readonly #v4: Record<string, any> = {};	90✔
64
65	get v4(): Record<string, any> {
66	if (!this.#clientOptions?.legacyMode) {	12!
67	throw new Error('client is not in "legacy mode"');	×
68	}
69
70	return this.#v4;	12✔
71	}
72
73	constructor(executor: RedisMultiExecutor, clientOptions?: RedisClientOptions<M, S>) {
74	this.#executor = executor;	90✔
75	this.#clientOptions = clientOptions;	90✔
76	this.#legacyMode();	90✔
77	}
78
79	#legacyMode(): void {
80	if (!this.#clientOptions?.legacyMode) return;	90✔
81
82	this.#v4.addCommand = this.addCommand.bind(this);	18✔
83	(this as any).addCommand = (...args: Array<unknown>): this => {	18✔
84	this.#queue.push({	18✔
85	args: args.flat() as Array<string>
86	});
87	return this;	18✔
88	}
89	this.#v4.exec = this.exec.bind(this);	18✔
90	(this as any).exec = (callback?: (err: Error \| null, replies?: Array<unknown>) => unknown): void => {	18✔
91	this.#v4.exec()	12✔
92	.then((reply: Array<unknown>) => {
93	if (!callback) return;	12✔
94
95	callback(null, reply);	6✔
96	})
97	.catch((err: Error) => {
98	if (!callback) {	×
99	// this.emit('error', err);
100	return;	×
101	}
102
103	callback(err);	×
104	});
105	};
106
107	for (const name of Object.keys(COMMANDS)) {	18✔
108	this.#defineLegacyCommand(name);	8,838✔
109	}
110	}
111
112	#defineLegacyCommand(name: string): void {
113	(this as any).#v4[name] = (this as any)[name].bind(this.#v4);	8,838✔
114	(this as any)[name] = (...args: Array<unknown>): void => (this as any).addCommand(name, args);	8,838✔
115	}
116
117	commandsExecutor(command: RedisCommand, args: Array<unknown>): this {
118	return this.addCommand(	84✔
119	command.transformArguments(...args),
120	command.transformReply
121	);
122	}
123
124	scriptsExecutor(script: RedisLuaScript, args: Array<unknown>): this {
125	const transformedArguments: TransformArgumentsReply = [];	18✔
126	if (this.#scriptsInUse.has(script.SHA1)) {	18✔
127	transformedArguments.push(	6✔
128	'EVALSHA',
129	script.SHA1
130	);
131	} else {
132	this.#scriptsInUse.add(script.SHA1);	12✔
133	transformedArguments.push(	12✔
134	'EVAL',
135	script.SCRIPT
136	);
137	}
138
139	transformedArguments.push(script.NUMBER_OF_KEYS.toString());	18✔
140
141	const scriptArguments = script.transformArguments(...args);	18✔
142	transformedArguments.push(...scriptArguments);	18✔
143	if (scriptArguments.preserve) {	18!
NEW 144	transformedArguments.preserve = scriptArguments.preserve;	×
145	}
146
147	return this.addCommand(	18✔
148	transformedArguments,
149	script.transformReply
150	);
151	}
152
153	addCommand(args: TransformArgumentsReply, transformReply?: RedisCommand['transformReply']): this {
154	this.#queue.push({	108✔
155	args,
156	preservedArguments: args.preserve,
157	transformReply
158	});
159
160	return this;	108✔
161	}
162
163	async exec(execAsPipeline = false): Promise<Array<RedisReply>> {	66✔
164	if (execAsPipeline) {	72✔
165	return this.execAsPipeline();	6✔
166	} else if (!this.#queue.length) {	66✔
167	return [];	6✔
168	}
169
170	const queue = this.#queue.splice(0),	60✔
171	rawReplies = await this.#executor([	60✔
172	{ args: ['MULTI'] },
173	...queue,
174	{ args: ['EXEC'] }
175	], Symbol('[RedisMultiCommand] Chain ID')),
176	execReply = rawReplies[rawReplies.length - 1] as (null \| Array<RedisReply>);	54✔
177
178	if (execReply === null) {	54✔
179	throw new WatchError();	12✔
180	}
181
182	return this.#transformReplies(execReply, queue);	42✔
183	}
184
185	async execAsPipeline(): Promise<Array<RedisReply>> {
186	if (!this.#queue.length) {	24✔
187	return [];	6✔
188	}
189
190	const queue = this.#queue.splice(0);	18✔
191	return this.#transformReplies(	18✔
192	await this.#executor(queue),
193	queue
194	);
195	}
196
197	#transformReplies(rawReplies: Array<RedisReply>, queue: Array<MultiQueuedCommand>): Array<RedisReply> {
198	return rawReplies.map((reply, i) => {	60✔
199	const { transformReply, preservedArguments } = queue[i];	96✔
200	return transformReply ? transformReply(reply, preservedArguments) : reply;	96✔
201	});
202	}
203	}
204
205	extendWithDefaultCommands(RedisMultiCommand, RedisMultiCommand.prototype.commandsExecutor);	6✔

NodeRedis / node-redis / 1267420195

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous