redis/node-redis
1
0
Fork 0
mirror of https://github.com/redis/node-redis.git synced 2025-08-17 19:41:06 +03:00
Code Activity

lots of todo commends

Browse Source
This commit is contained in:
leibale
2021-06-18 16:51:30 -04:00
parent 93938b4b91
commit 07f5e7f6b2
49 changed files with 604 additions and 242 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
lib/client.ts
View File

@@ -6,9 +6,8 @@ import RedisMultiCommand, { MultiQueuedCommand, RedisMultiCommandType } from './
import EventEmitter from 'events';
import { CommandOptions, commandOptions, isCommandOptions } from './command-options';
import { RedisLuaScript, RedisLuaScripts } from './lua-script';
import { ScanOptions } from './commands/generic-transformers';
import { ScanOptions, ZMember } from './commands/generic-transformers';
import { ScanCommandOptions } from './commands/SCAN';
import { ZMember } from './commands/ZADD';
export interface RedisClientOptions<M = RedisModules, S = RedisLuaScripts> {
socket?: RedisSocketOptions;

3
lib/commands/BZPOPMAX.ts
View File

@@ -1,5 +1,4 @@
import { transformReplyNumberInfinity } from './generic-transformers';
import { ZMember } from './ZADD';
import { transformReplyNumberInfinity, ZMember } from './generic-transformers';
export const FIRST_KEY_INDEX = 1;

3
lib/commands/BZPOPMIN.ts
View File

@@ -1,5 +1,4 @@
import { transformReplyNumberInfinity } from './generic-transformers';
import { ZMember } from './ZADD';
import { transformReplyNumberInfinity, ZMember } from './generic-transformers';
export const FIRST_KEY_INDEX = 1;

26
lib/commands/HRANDFIELD.spec.ts
View File

@@ -3,27 +3,11 @@ import { TestRedisServers, itWithClient } from '../test-utils';
import { transformArguments } from './HRANDFIELD';
describe('HRANDFIELD', () => {
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
transformArguments('key'),
['HRANDFIELD', 'key']
);
});
it('with count', () => {
assert.deepEqual(
transformArguments('key', 1),
['HRANDFIELD', 'key', '1']
);
});
it('with count & values', () => {
assert.deepEqual(
transformArguments('key', 1, true),
['HRANDFIELD', 'key', '1', 'WITHVALUES']
);
});
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key'),
['HRANDFIELD', 'key']
);
});
itWithClient(TestRedisServers.OPEN, 'client.hRandField', async client => {

20
lib/commands/HRANDFIELD.ts
View File

@@ -1,21 +1,9 @@
import { transformReplyStringArray } from './generic-transformers';
import { transformReplyString } from './generic-transformers';
export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string, count?: number, withValues?: boolean): Array<string> {
const args = ['HRANDFIELD', key];
if (count) {
args.push(count.toString());
if (withValues) {
args.push('WITHVALUES');
}
}
return args;
export function transformArguments(key: string): Array<string> {
return ['HRANDFIELD', key];
}
export function transformReply(reply: null | string | Array<string>): null | string | Array<string> {
// TODO: convert to object when `withValues`?
return reply;
};
export const transformReply = transformReplyString;

19
lib/commands/HRANDFIELD_COUNT.spec.ts Normal file
View File

@@ -0,0 +1,19 @@
import { strict as assert } from 'assert';
import { TestRedisServers, itWithClient } from '../test-utils';
import { transformArguments } from './HRANDFIELD_COUNT';
describe('HRANDFIELD COUNT', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key', 1),
['HRANDFIELD', 'key', '1']
);
});
itWithClient(TestRedisServers.OPEN, 'client.hRandFieldCount', async client => {
assert.equal(
await client.hRandFieldCount('key', 1),
null
);
});
});

14
lib/commands/HRANDFIELD_COUNT.ts Normal file
View File

@@ -0,0 +1,14 @@
import { transformArguments as transformHRandFieldArguments } from './HRANDFIELD';
export { FIRST_KEY_INDEX } from './HRANDFIELD';
export function transformArguments(key: string, count: number): Array<string> {
return [
...transformHRandFieldArguments(key),
count.toString()
];
}
export function transformReply(reply: Array<string> | null): Array<string> | null {
return reply;
}

19
lib/commands/HRANDFIELD_COUNT_WITHVALUES.spec.ts Normal file
View File

@@ -0,0 +1,19 @@
import { strict as assert } from 'assert';
import { TestRedisServers, itWithClient } from '../test-utils';
import { transformArguments } from './HRANDFIELD_COUNT_WITHVALUES';
describe('HRANDFIELD COUNT WITHVALUES', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key', 1),
['HRANDFIELD', 'key', '1', 'WITHVALUES']
);
});
itWithClient(TestRedisServers.OPEN, 'client.hRandFieldCountWithValues', async client => {
assert.equal(
await client.hRandFieldCountWithValues('key', 1),
null
);
});
});

17
lib/commands/HRANDFIELD_COUNT_WITHVALUES.ts Normal file
View File

@@ -0,0 +1,17 @@
import { transformReplyTupels, TupelsObject } from './generic-transformers';
import { transformArguments as transformHRandFieldCountArguments } from './HRANDFIELD_COUNT';
export { FIRST_KEY_INDEX } from './HRANDFIELD_COUNT';
export function transformArguments(key: string, count: number): Array<string> {
return [
...transformHRandFieldCountArguments(key, count),
'WITHVALUES'
];
}
export function transformReply(reply: Array<string> | null): TupelsObject | null {
if (reply === null) return null;
return transformReplyTupels(reply);
}

19
lib/commands/SRANDMEMBER.spec.ts
View File

@@ -3,20 +3,11 @@ import { TestRedisServers, itWithClient } from '../test-utils';
import { transformArguments } from './SRANDMEMBER';
describe('SRANDMEMBER', () => {
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
transformArguments('key'),
['SRANDMEMBER', 'key']
);
});
it('with count', () => {
assert.deepEqual(
transformArguments('key', 2),
['SRANDMEMBER', 'key', '2']
);
});
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key'),
['SRANDMEMBER', 'key']
);
});
itWithClient(TestRedisServers.OPEN, 'client.sRandMember', async client => {

15
lib/commands/SRANDMEMBER.ts
View File

@@ -1,16 +1,9 @@
import { transformReplyStringArray } from './generic-transformers';
import { transformReplyStringNull } from './generic-transformers';
export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string, count?: number): Array<string> {
const args = ['SRANDMEMBER', key];
if (typeof count === 'number') {
args.push(count.toString());
}
return args;
export function transformArguments(key: string): Array<string> {
return ['SRANDMEMBER', key];
}
// TODO: without `count` it'll return "bulk string" and not "array"
export const transformReply = transformReplyStringArray;
export const transformReply = transformReplyStringNull;

19
lib/commands/SRANDMEMBER_COUNT.spec.ts Normal file
View File

@@ -0,0 +1,19 @@
import { strict as assert } from 'assert';
import { TestRedisServers, itWithClient } from '../test-utils';
import { transformArguments } from './SRANDMEMBER_COUNT';
describe('SRANDMEMBER COUNT', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key', 1),
['SRANDMEMBER', 'key', '1']
);
});
itWithClient(TestRedisServers.OPEN, 'client.sRandMemberCount', async client => {
assert.deepEqual(
await client.sRandMemberCount('key', 1),
[]
);
});
});

13
lib/commands/SRANDMEMBER_COUNT.ts Normal file
View File

@@ -0,0 +1,13 @@
import { transformReplyStringArray } from './generic-transformers';
import { transformArguments as transformSRandMemberArguments } from './SRANDMEMBER';
export { FIRST_KEY_INDEX } from './SRANDMEMBER';
export function transformArguments(key: string, count: number): Array<string> {
return [
...transformSRandMemberArguments(key),
count.toString()
];
}
export const transformReply = transformReplyStringArray;

4
lib/commands/XADD.ts
View File

@@ -1,4 +1,4 @@
import { StreamMessage, transformReplyString } from './generic-transformers';
import { TupelsObject, transformReplyString } from './generic-transformers';
export const FIRST_KEY_INDEX = 1;
@@ -13,7 +13,7 @@ interface XAddOptions {
}
}
export function transformArguments(key: string, id: string, message: StreamMessage, options?: XAddOptions): Array<string> {
export function transformArguments(key: string, id: string, message: TupelsObject, options?: XAddOptions): Array<string> {
const args = ['XADD', key];
if (options?.NOMKSTREAM) {

6
lib/commands/XINFO_STREAM.ts
View File

@@ -1,4 +1,4 @@
import { StreamMessageReply, transformReplyStreamMessage } from './generic-transformers';
import { StreamMessageReply, transformReplyTupels } from './generic-transformers';
export const FIRST_KEY_INDEX = 2;
@@ -27,11 +27,11 @@ export function transformReply(reply: Array<any>): XInfoStreamReply {
groups: reply[9],
firstEntry: reply[11] ? {
id: reply[11][0] ?? null,
message: transformReplyStreamMessage(reply[11][1])
message: transformReplyTupels(reply[11][1])
} : null,
lastEntry: reply[13] ? {
id: reply[13][0],
message: transformReplyStreamMessage(reply[13][1])
message: transformReplyTupels(reply[13][1])
} : null
};
}

7
lib/commands/ZADD.ts
View File

@@ -1,4 +1,4 @@
import { transformArgumentNumberInfinity, transformReplyNumberInfinity } from './generic-transformers';
import { transformArgumentNumberInfinity, transformReplyNumberInfinity, ZMember } from './generic-transformers';
export const FIRST_KEY_INDEX = 1;
@@ -28,11 +28,6 @@ interface INCR {
type ZAddOptions = (NX | (XX & LT & GT)) & CH & INCR;
export interface ZMember {
score: number;
value: string;
}
export function transformArguments(key: string, members: ZMember | Array<ZMember>, options?: ZAddOptions): Array<string> {
const args = ['ZADD', key];

9
lib/commands/ZDIFF.spec.ts
View File

@@ -17,15 +17,6 @@ describe('ZDIFF', () => {
['ZDIFF', '2', '1', '2']
);
});
it('WITHSCORES', () => {
assert.deepEqual(
transformArguments('key', {
WITHSCORES: true
}),
['ZDIFF', '1', 'key', 'WITHSCORES']
);
});
});
itWithClient(TestRedisServers.OPEN, 'client.zDiff', async client => {

11
lib/commands/ZDIFF.ts
View File

@@ -4,11 +4,7 @@ export const FIRST_KEY_INDEX = 2;
export const IS_READ_ONLY = true;
interface ZDiffOptions {
WITHSCORES?: true;
}
export function transformArguments(keys: Array<string> | string, options?: ZDiffOptions): Array<string> {
export function transformArguments(keys: Array<string> | string): Array<string> {
const args = ['ZDIFF'];
if (typeof keys === 'string') {
@@ -17,12 +13,7 @@ export function transformArguments(keys: Array<string> | string, options?: ZDiff
args.push(keys.length.toString(), ...keys);
}
if (options?.WITHSCORES) {
args.push('WITHSCORES');
}
return args;
}
// TODO: convert to `Array<ZMember>` when "WITHSCORES"
export const transformReply = transformReplyStringArray;

28
lib/commands/ZDIFF_WITHSCORES.spec.ts Normal file
View File

@@ -0,0 +1,28 @@
import { strict as assert } from 'assert';
import { TestRedisServers, itWithClient } from '../test-utils';
import { transformArguments } from './ZDIFF_WITHSCORES';
describe('ZDIFF WITHSCORES', () => {
describe('transformArguments', () => {
it('string', () => {
assert.deepEqual(
transformArguments('key'),
['ZDIFF', '1', 'key', 'WITHSCORES']
);
});
it('array', () => {
assert.deepEqual(
transformArguments(['1', '2']),
['ZDIFF', '2', '1', '2', 'WITHSCORES']
);
});
});
itWithClient(TestRedisServers.OPEN, 'client.zDiffWithScores', async client => {
assert.deepEqual(
await client.zDiffWithScores('key'),
[]
);
});
});

13
lib/commands/ZDIFF_WITHSCORES.ts Normal file
View File

@@ -0,0 +1,13 @@
import { transformReplySortedSetWithScores } from './generic-transformers';
import { transformArguments as transformZDiffArguments } from './ZDIFF';
export { FIRST_KEY_INDEX, IS_READ_ONLY } from './ZDIFF';
export function transformArguments(...args: Parameters<typeof transformZDiffArguments>): Array<string> {
return [
...transformZDiffArguments(...args),
'WITHSCORES'
];
}
export const transformReply = transformReplySortedSetWithScores;

16
lib/commands/ZINTER.spec.ts
View File

@@ -36,23 +36,13 @@ describe('ZINTER', () => {
);
});
it('with WITHSCORES', () => {
assert.deepEqual(
transformArguments('key', {
WITHSCORES: true
}),
['ZINTER', '1', 'key', 'WITHSCORES']
);
});
it('with WEIGHTS, AGGREGATE, WITHSCORES', () => {
it('with WEIGHTS, AGGREGATE', () => {
assert.deepEqual(
transformArguments('key', {
WEIGHTS: [1],
AGGREGATE: 'SUM',
WITHSCORES: true
AGGREGATE: 'SUM'
}),
['ZINTER', '1', 'key', 'WEIGHTS', '1', 'AGGREGATE', 'SUM', 'WITHSCORES']
['ZINTER', '1', 'key', 'WEIGHTS', '1', 'AGGREGATE', 'SUM']
);
});
});

6
lib/commands/ZINTER.ts
View File

@@ -7,7 +7,6 @@ export const IS_READ_ONLY = true;
interface ZInterOptions {
WEIGHTS?: Array<number>;
AGGREGATE?: 'SUM' | 'MIN' | 'MAX';
WITHSCORES?: true;
}
export function transformArguments(keys: Array<string> | string, options?: ZInterOptions): Array<string> {
@@ -30,12 +29,7 @@ export function transformArguments(keys: Array<string> | string, options?: ZInte
args.push('AGGREGATE', options?.AGGREGATE);
}
if (options?.WITHSCORES) {
args.push('WITHSCORES');
}
return args;
}
// TODO: convert to `Array<ZMember>` when "WITHSCORES"
export const transformReply = transformReplyStringArray;

56
lib/commands/ZINTER_WITHSCORES.spec.ts Normal file
View File

@@ -0,0 +1,56 @@
import { strict as assert } from 'assert';
import { TestRedisServers, itWithClient } from '../test-utils';
import { transformArguments } from './ZINTER_WITHSCORES';
describe('ZINTER WITHSCORES', () => {
describe('transformArguments', () => {
it('key (string)', () => {
assert.deepEqual(
transformArguments('key'),
['ZINTER', '1', 'key', 'WITHSCORES']
);
});
it('keys (array)', () => {
assert.deepEqual(
transformArguments(['1', '2']),
['ZINTER', '2', '1', '2', 'WITHSCORES']
);
});
it('with WEIGHTS', () => {
assert.deepEqual(
transformArguments('key', {
WEIGHTS: [1]
}),
['ZINTER', '1', 'key', 'WEIGHTS', '1', 'WITHSCORES']
);
});
it('with AGGREGATE', () => {
assert.deepEqual(
transformArguments('key', {
AGGREGATE: 'SUM'
}),
['ZINTER', '1', 'key', 'AGGREGATE', 'SUM', 'WITHSCORES']
);
});
it('with WEIGHTS, AGGREGATE', () => {
assert.deepEqual(
transformArguments('key', {
WEIGHTS: [1],
AGGREGATE: 'SUM'
}),
['ZINTER', '1', 'key', 'WEIGHTS', '1', 'AGGREGATE', 'SUM', 'WITHSCORES']
);
});
});
itWithClient(TestRedisServers.OPEN, 'client.zInterWithScores', async client => {
assert.deepEqual(
await client.zInterWithScores('key'),
[]
);
});
});

13
lib/commands/ZINTER_WITHSCORES.ts Normal file
View File

@@ -0,0 +1,13 @@
import { transformReplySortedSetWithScores } from './generic-transformers';
import { transformArguments as transformZInterArguments } from './ZINTER';
export { FIRST_KEY_INDEX, IS_READ_ONLY } from './ZINTER';
export function transformArguments(...args: Parameters<typeof transformZInterArguments>): Array<string> {
return [
...transformZInterArguments(...args),
'WITHSCORES'
];
}
export const transformReply = transformReplySortedSetWithScores;

19
lib/commands/ZPOPMAX.spec.ts
View File

@@ -3,20 +3,11 @@ import { TestRedisServers, itWithClient } from '../test-utils';
import { transformArguments } from './ZPOPMAX';
describe('ZPOPMAX', () => {
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
transformArguments('key'),
['ZPOPMAX', 'key']
);
});
it('with count', () => {
assert.deepEqual(
transformArguments('key', 1),
['ZPOPMAX', 'key', '1']
);
});
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key'),
['ZPOPMAX', 'key']
);
});
itWithClient(TestRedisServers.OPEN, 'client.zPopMax', async client => {

4
lib/commands/ZPOPMAX.ts
View File

@@ -1,5 +1,4 @@
import { transformReplyNumberInfinity } from './generic-transformers';
import { ZMember } from './ZADD';
import { transformReplyNumberInfinity, ZMember } from './generic-transformers';
export const FIRST_KEY_INDEX = 1;
@@ -16,7 +15,6 @@ export function transformArguments(key: string, count?: number): Array<string> {
return args;
}
// TODO return type should be `ZMember` when count is 1 or undefined
export function transformReply(reply: [string, string] | []): ZMember | null {
if (!reply.length) return null;

19
lib/commands/ZPOPMAX_COUNT.spec.ts Normal file
View File

@@ -0,0 +1,19 @@
import { strict as assert } from 'assert';
import { TestRedisServers, itWithClient } from '../test-utils';
import { transformArguments } from './ZPOPMAX_COUNT';
describe('ZPOPMAX COUNT', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key', 1),
['ZPOPMAX', 'key', '1']
);
});
itWithClient(TestRedisServers.OPEN, 'client.zPopMaxCount', async client => {
assert.deepEqual(
await client.zPopMaxCount('key', 1),
[]
);
});
});

14
lib/commands/ZPOPMAX_COUNT.ts Normal file
View File

@@ -0,0 +1,14 @@
import { deepEqual } from 'assert/strict';
import { transformReplySortedSetWithScores } from './generic-transformers';
import { transformArguments as transformZPopMaxArguments } from './ZPOPMAX';
export { FIRST_KEY_INDEX } from './ZPOPMAX';
export function transformArguments(key: string, count: number): Array<string> {
return [
...transformZPopMaxArguments(key),
count.toString()
];
}
export const transformReply = transformReplySortedSetWithScores;

19
lib/commands/ZPOPMIN.spec.ts
View File

@@ -3,20 +3,11 @@ import { TestRedisServers, itWithClient } from '../test-utils';
import { transformArguments } from './ZPOPMIN';
describe('ZPOPMIN', () => {
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
transformArguments('key'),
['ZPOPMIN', 'key']
);
});
it('with count', () => {
assert.deepEqual(
transformArguments('key', 1),
['ZPOPMIN', 'key', '1']
);
});
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key'),
['ZPOPMIN', 'key']
);
});
itWithClient(TestRedisServers.OPEN, 'client.zPopMin', async client => {

14
lib/commands/ZPOPMIN.ts
View File

@@ -1,22 +1,14 @@
import { transformReplyNumberInfinity } from './generic-transformers';
import { ZMember } from './ZADD';
import { transformReplyNumberInfinity, ZMember } from './generic-transformers';
export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string, count?: number): Array<string> {
const args = [
export function transformArguments(key: string): Array<string> {
return [
'ZPOPMIN',
key
];
if (typeof count === 'number') {
args.push(count.toString());
}
return args;
}
// TODO return type should be `ZMember` when count is 1 or undefined
export function transformReply(reply: [string, string] | []): ZMember | null {
if (!reply.length) return null;

19
lib/commands/ZPOPMIN_COUNT.spec.ts Normal file
View File

@@ -0,0 +1,19 @@
import { strict as assert } from 'assert';
import { TestRedisServers, itWithClient } from '../test-utils';
import { transformArguments } from './ZPOPMIN_COUNT';
describe('ZPOPMIN COUNT', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key', 1),
['ZPOPMIN', 'key', '1']
);
});
itWithClient(TestRedisServers.OPEN, 'client.zPopMinCount', async client => {
assert.deepEqual(
await client.zPopMinCount('key', 1),
[]
);
});
});

13
lib/commands/ZPOPMIN_COUNT.ts Normal file
View File

@@ -0,0 +1,13 @@
import { transformReplySortedSetWithScores } from './generic-transformers';
import { transformArguments as transformZPopMinArguments } from './ZPOPMIN';
export { FIRST_KEY_INDEX } from './ZPOPMIN';
export function transformArguments(key: string, count: number): Array<string> {
return [
...transformZPopMinArguments(key),
count.toString()
];
}
export const transformReply = transformReplySortedSetWithScores;

26
lib/commands/ZRANDMEMBER.spec.ts
View File

@@ -3,27 +3,11 @@ import { TestRedisServers, itWithClient } from '../test-utils';
import { transformArguments } from './ZRANDMEMBER';
describe('ZRANDMEMBER', () => {
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
transformArguments('key'),
['ZRANDMEMBER', 'key']
);
});
it('with count', () => {
assert.deepEqual(
transformArguments('key', 1),
['ZRANDMEMBER', 'key', '1']
);
});
it('with count, WITHSCORES', () => {
assert.deepEqual(
transformArguments('key', 1, true),
['ZRANDMEMBER', 'key', '1', 'WITHSCORES']
);
});
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key'),
['ZRANDMEMBER', 'key']
);
});
itWithClient(TestRedisServers.OPEN, 'client.zRandMember', async client => {

25
lib/commands/ZRANDMEMBER.ts
View File

@@ -1,22 +1,11 @@
import { transformReplyStringNull } from './generic-transformers';
export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true;
export function transformArguments(key: string, count?: number, WITHSCORES?: true): Array<string> {
const args = ['ZRANDMEMBER', key];
if (typeof count === 'number') {
args.push(count.toString());
if (WITHSCORES) {
args.push('WITHSCORES');
}
}
return args;
export function transformArguments(key: string): Array<string> {
return ['ZRANDMEMBER', key];
}
// TODO: string when count is 1 or undefined, array when count is > 1, object when WITHSCORES
type ZRandMemberReply = string | Array<string> | null
export function transformReply(reply: ZRandMemberReply): ZRandMemberReply {
return reply;
}
export const transformReply = transformReplyStringNull;

19
lib/commands/ZRANDMEMBER_COUNT.spec.ts Normal file
View File

@@ -0,0 +1,19 @@
import { strict as assert } from 'assert';
import { TestRedisServers, itWithClient } from '../test-utils';
import { transformArguments } from './ZRANDMEMBER_COUNT';
describe('ZRANDMEMBER COUNT', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key', 1),
['ZRANDMEMBER', 'key', '1']
);
});
itWithClient(TestRedisServers.OPEN, 'client.zRandMemberCount', async client => {
assert.equal(
await client.zRandMemberCount('key', 1),
null
);
});
});

14
lib/commands/ZRANDMEMBER_COUNT.ts Normal file
View File

@@ -0,0 +1,14 @@
import { transformArguments as transformZRandMemberArguments } from './ZRANDMEMBER';
export { FIRST_KEY_INDEX, IS_READ_ONLY } from './ZRANDMEMBER';
export function transformArguments(key: string, count: number): Array<string> {
return [
...transformZRandMemberArguments(key),
count.toString()
];
}
export function transformReply(reply: Array<string> | null): Array<string> | null {
return reply;
}

19
lib/commands/ZRANDMEMBER_COUNT_WITHSCORES.spec.ts Normal file
View File

@@ -0,0 +1,19 @@
import { strict as assert } from 'assert';
import { TestRedisServers, itWithClient } from '../test-utils';
import { transformArguments } from './ZRANDMEMBER_COUNT_WITHSCORES';
describe('ZRANDMEMBER COUNT WITHSCORES', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key', 1),
['ZRANDMEMBER', 'key', '1', 'WITHSCORES']
);
});
itWithClient(TestRedisServers.OPEN, 'client.zRandMemberCountWithScores', async client => {
assert.equal(
await client.zRandMemberCountWithScores('key', 1),
null
);
});
});

17
lib/commands/ZRANDMEMBER_COUNT_WITHSCORES.ts Normal file
View File

@@ -0,0 +1,17 @@
import { transformReplySortedSetWithScores, ZMember } from './generic-transformers';
import { transformArguments as transformZRandMemberCountArguments } from './ZRANDMEMBER_COUNT';
export { FIRST_KEY_INDEX, IS_READ_ONLY } from './ZRANDMEMBER_COUNT';
export function transformArguments(...args: Parameters<typeof transformZRandMemberCountArguments>): Array<string> {
return [
...transformZRandMemberCountArguments(...args),
'WITHSCORES'
];
}
export function transformReply(reply: Array<string> | null): Array<ZMember> | null {
if (reply === null) return null;
return transformReplySortedSetWithScores(reply);
}

12
lib/commands/ZRANGE.spec.ts
View File

@@ -41,18 +41,6 @@ describe('ZRANGE', () => {
);
});
it('with WITHSCORES', () => {
assert.deepEqual(
transformArguments('src', 0, 1, {
LIMIT: {
offset: 0,
count: 1
},
}),
['ZRANGE', 'src', '0', '1', 'LIMIT', '0', '1']
);
});
it('with BY & REV & LIMIT', () => {
assert.deepEqual(
transformArguments('src', 0, 1, {

14
lib/commands/ZRANGE.ts
View File

@@ -1,4 +1,4 @@
import { transformArgumentNumberInfinity, transformReplyNumber, transformReplyStringArray } from './generic-transformers';
import { transformReplyStringArray } from './generic-transformers';
export const FIRST_KEY_INDEX = 1;
@@ -11,15 +11,14 @@ interface ZRangeOptions {
offset: number;
count: number;
};
WITHSCORES?: true;
}
export function transformArguments(src: string, min: number, max: number, options?: ZRangeOptions): Array<string> {
export function transformArguments(src: string, min: string | number, max: string | number, options?: ZRangeOptions): Array<string> {
const args = [
'ZRANGE',
src,
transformArgumentNumberInfinity(min),
transformArgumentNumberInfinity(max)
typeof min === 'string' ? min : min.toString(),
typeof max === 'string' ? max : max.toString()
];
switch (options?.BY) {
@@ -40,12 +39,7 @@ export function transformArguments(src: string, min: number, max: number, option
args.push('LIMIT', options.LIMIT.offset.toString(), options.LIMIT.count.toString());
}
if (options?.WITHSCORES) {
args.push('WITHSCORES');
}
return args;
}
// TODO: convert to `ZMember` when "WITHSCORES"
export const transformReply = transformReplyStringArray;

65
lib/commands/ZRANGE_WITHSCORES.spec.ts Normal file
View File

@@ -0,0 +1,65 @@
import { strict as assert } from 'assert';
import { TestRedisServers, itWithClient } from '../test-utils';
import { transformArguments } from './ZRANGE_WITHSCORES';
describe('ZRANGE WITHSCORES', () => {
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
transformArguments('src', 0, 1),
['ZRANGE', 'src', '0', '1', 'WITHSCORES']
);
});
it('with BY', () => {
assert.deepEqual(
transformArguments('src', 0, 1, {
BY: 'SCORE'
}),
['ZRANGE', 'src', '0', '1', 'BYSCORE', 'WITHSCORES']
);
});
it('with REV', () => {
assert.deepEqual(
transformArguments('src', 0, 1, {
REV: true
}),
['ZRANGE', 'src', '0', '1', 'REV', 'WITHSCORES']
);
});
it('with LIMIT', () => {
assert.deepEqual(
transformArguments('src', 0, 1, {
LIMIT: {
offset: 0,
count: 1
}
}),
['ZRANGE', 'src', '0', '1', 'LIMIT', '0', '1', 'WITHSCORES']
);
});
it('with BY & REV & LIMIT', () => {
assert.deepEqual(
transformArguments('src', 0, 1, {
BY: 'SCORE',
REV: true,
LIMIT: {
offset: 0,
count: 1
}
}),
['ZRANGE', 'src', '0', '1', 'BYSCORE', 'REV', 'LIMIT', '0', '1', 'WITHSCORES']
);
});
});
itWithClient(TestRedisServers.OPEN, 'client.zRangeWithScores', async client => {
assert.deepEqual(
await client.zRangeWithScores('src', 0, 1),
[]
);
});
});

13
lib/commands/ZRANGE_WITHSCORES.ts Normal file
View File

@@ -0,0 +1,13 @@
import { transformReplySortedSetWithScores } from './generic-transformers';
import { transformArguments as transformZRangeArguments } from './ZRANGE';
export { FIRST_KEY_INDEX, IS_READ_ONLY } from './ZRANGE';
export function transformArguments(...args: Parameters<typeof transformZRangeArguments>): Array<string> {
return [
...transformZRangeArguments(...args),
'WITHSCORES'
];
}
export const transformReply = transformReplySortedSetWithScores;

3
lib/commands/ZSCAN.ts
View File

@@ -1,5 +1,4 @@
import { ScanOptions, transformReplyNumberInfinity, transformScanArguments } from './generic-transformers';
import { ZMember } from './ZADD';
import { ScanOptions, transformReplyNumberInfinity, transformScanArguments, ZMember } from './generic-transformers';
export const FIRST_KEY_INDEX = 1;

9
lib/commands/ZUNION.spec.ts
View File

@@ -35,15 +35,6 @@ describe('ZUNION', () => {
['ZUNION', '1', 'key', 'AGGREGATE', 'SUM']
);
});
it('with WITHSCORES', () => {
assert.deepEqual(
transformArguments('key', {
WITHSCORES: true
}),
['ZUNION', '1', 'key', 'WITHSCORES']
);
});
});
itWithClient(TestRedisServers.OPEN, 'client.zUnion', async client => {

6
lib/commands/ZUNION.ts
View File

@@ -7,7 +7,6 @@ export const IS_READ_ONLY = true;
interface ZUnionOptions {
WEIGHTS?: Array<number>;
AGGREGATE?: 'SUM' | 'MIN' | 'MAX';
WITHSCORES?: true;
}
export function transformArguments(keys: Array<string> | string, options?: ZUnionOptions): Array<string> {
@@ -27,12 +26,7 @@ export function transformArguments(keys: Array<string> | string, options?: ZUnio
args.push('AGGREGATE', options.AGGREGATE);
}
if (options?.WITHSCORES) {
args.push('WITHSCORES');
}
return args;
}
// TODO: convert to `Array<ZMember>` when "WITHSCORES"
export const transformReply = transformReplyStringArray;

46
lib/commands/ZUNION_WITHSCORES.spec.ts Normal file
View File

@@ -0,0 +1,46 @@
import { strict as assert } from 'assert';
import { TestRedisServers, itWithClient } from '../test-utils';
import { transformArguments } from './ZUNION_WITHSCORES';
describe('ZUNION WITHSCORES', () => {
describe('transformArguments', () => {
it('key (string)', () => {
assert.deepEqual(
transformArguments('key'),
['ZUNION', '1', 'key', 'WITHSCORES']
);
});
it('keys (array)', () => {
assert.deepEqual(
transformArguments(['1', '2']),
['ZUNION', '2', '1', '2', 'WITHSCORES']
);
});
it('with WEIGHTS', () => {
assert.deepEqual(
transformArguments('key', {
WEIGHTS: [1]
}),
['ZUNION', '1', 'key', 'WEIGHTS', '1', 'WITHSCORES']
);
});
it('with AGGREGATE', () => {
assert.deepEqual(
transformArguments('key', {
AGGREGATE: 'SUM'
}),
['ZUNION', '1', 'key', 'AGGREGATE', 'SUM', 'WITHSCORES']
);
});
});
itWithClient(TestRedisServers.OPEN, 'client.zUnionWithScores', async client => {
assert.deepEqual(
await client.zUnionWithScores('key'),
[]
);
});
});

13
lib/commands/ZUNION_WITHSCORES.ts Normal file
View File

@@ -0,0 +1,13 @@
import { transformReplySortedSetWithScores } from './generic-transformers';
import { transformArguments as transformZUnionArguments } from './ZUNION';
export { FIRST_KEY_INDEX, IS_READ_ONLY } from './ZUNION';
export function transformArguments(...args: Parameters<typeof transformZUnionArguments>): Array<string> {
return [
...transformZUnionArguments(...args),
'WITHSCORES'
];
}
export const transformReply = transformReplySortedSetWithScores;

32
lib/commands/generic-transformers.ts
View File

@@ -6,6 +6,10 @@ export function transformReplyString(reply: string): string {
return reply;
}
export function transformReplyStringNull(reply: string | null): string | null {
return reply;
}
export function transformReplyStringArray(reply: Array<string>): Array<string> {
return reply;
}
@@ -89,11 +93,11 @@ export function transformArgumentNumberInfinity(num: number): string {
}
}
export interface StreamMessage {
export interface TupelsObject {
[field: string]: string;
}
export function transformReplyStreamMessage(reply: Array<string>): StreamMessage {
export function transformReplyTupels(reply: Array<string>): TupelsObject {
const message = Object.create(null);
for (let i = 0; i < reply.length; i += 2) {
@@ -105,7 +109,7 @@ export function transformReplyStreamMessage(reply: Array<string>): StreamMessage
export interface StreamMessageReply {
id: string;
message: StreamMessage;
message: TupelsObject;
}
export type StreamMessagesReply = Array<StreamMessageReply>;
@@ -116,7 +120,7 @@ export function transformReplyStreamMessages(reply: Array<any>): StreamMessagesR
for (let i = 0; i < reply.length; i += 2) {
messages.push({
id: reply[i],
message: transformReplyStreamMessage(reply[i + 1])
message: transformReplyTupels(reply[i + 1])
});
}
@@ -138,7 +142,7 @@ export function transformReplyStreamsMessages(reply: Array<any>): StreamsMessage
});
}
return streams
return streams;
}
export function transformReplyStreamsMessagesNull(reply: Array<any> | null): StreamsMessagesReply | null {
@@ -146,3 +150,21 @@ export function transformReplyStreamsMessagesNull(reply: Array<any> | null): Str
return transformReplyStreamsMessages(reply);
}
export interface ZMember {
score: number;
value: string;
}
export function transformReplySortedSetWithScores(reply: Array<string>): Array<ZMember> {
const members = [];
for (let i = 0; i < reply.length; i += 2) {
members.push({
value: reply[i],
score: transformReplyNumberInfinity(reply[i + 1])
});
}
return members;
}

33
lib/commands/index.ts
View File

@@ -26,6 +26,8 @@ import * as HINCRBYFLOAT from './HINCRBYFLOAT';
import * as HKEYS from './HKEYS';
import * as HLEN from './HLEN';
import * as HMGET from './HMGET';
import * as HRANDFIELD_COUNT_WITHVALUES from './HRANDFIELD_COUNT_WITHVALUES';
import * as HRANDFIELD_COUNT from './HRANDFIELD_COUNT';
import * as HRANDFIELD from './HRANDFIELD';
import * as HSET from './HSET';
import * as HSETNX from './HSETNX';
@@ -63,6 +65,7 @@ import * as SMISMEMBER from './SMISMEMBER';
import * as SMOVE from './SMOVE';
import * as SORT from './SORT';
import * as SPOP from './SPOP';
import * as SRANDMEMBER_COUNT from './SRANDMEMBER_COUNT';
import * as SRANDMEMBER from './SRANDMEMBER';
import * as SREM from './SREM';
import * as SSCAN from './SSCAN';
@@ -97,16 +100,23 @@ import * as XTRIM from './XTRIM';
import * as ZADD from './ZADD';
import * as ZCARD from './ZCARD';
import * as ZCOUNT from './ZCOUNT';
import * as ZDIFF_WITHSCORES from './ZDIFF_WITHSCORES';
import * as ZDIFF from './ZDIFF';
import * as ZDIFFSTORE from './ZDIFFSTORE';
import * as ZINCRBY from './ZINCRBY';
import * as ZINTER_WITHSCORES from './ZINTER_WITHSCORES';
import * as ZINTER from './ZINTER';
import * as ZINTERSTORE from './ZINTERSTORE';
import * as ZLEXCOUNT from './ZLEXCOUNT';
import * as ZMSCORE from './ZMSCORE';
import * as ZPOPMAX_COUNT from './ZPOPMAX_COUNT';
import * as ZPOPMAX from './ZPOPMAX';
import * as ZPOPMIN_COUNT from './ZPOPMIN_COUNT';
import * as ZPOPMIN from './ZPOPMIN';
import * as ZRANDMEMBER_COUNT_WITHSCORES from './ZRANDMEMBER_COUNT_WITHSCORES';
import * as ZRANDMEMBER_COUNT from './ZRANDMEMBER_COUNT';
import * as ZRANDMEMBER from './ZRANDMEMBER';
import * as ZRANGE_WITHSCORES from './ZRANGE_WITHSCORES';
import * as ZRANGE from './ZRANGE';
import * as ZRANGESTORE from './ZRANGESTORE';
import * as ZRANK from './ZRANK';
@@ -117,6 +127,7 @@ import * as ZREMRANGEBYSCORE from './ZREMRANGEBYSCORE';
import * as ZREVRANK from './ZREVRANK';
import * as ZSCAN from './ZSCAN';
import * as ZSCORE from './ZSCORE';
import * as ZUNION_WITHSCORES from './ZUNION_WITHSCORES';
import * as ZUNION from './ZUNION';
import * as ZUNIONSTORE from './ZUNIONSTORE';
@@ -177,6 +188,10 @@ export default {
hLen: HLEN,
HMGET,
hmGet: HMGET,
HRANDFIELD_COUNT_WITHVALUES,
hRandFieldCountWithValues: HRANDFIELD_COUNT_WITHVALUES,
HRANDFIELD_COUNT,
hRandFieldCount: HRANDFIELD_COUNT,
HRANDFIELD,
hRandField: HRANDFIELD,
HSET,
@@ -251,6 +266,8 @@ export default {
sort: SORT,
SPOP,
sPop: SPOP,
SRANDMEMBER_COUNT,
sRandMemberCount: SRANDMEMBER_COUNT,
SRANDMEMBER,
sRandMember: SRANDMEMBER,
SREM,
@@ -319,12 +336,16 @@ export default {
zCard: ZCARD,
ZCOUNT,
zCount: ZCOUNT,
ZDIFF_WITHSCORES,
zDiffWithScores: ZDIFF_WITHSCORES,
ZDIFF,
zDiff: ZDIFF,
ZDIFFSTORE,
zDiffStore: ZDIFFSTORE,
ZINCRBY,
zIncrBy: ZINCRBY,
ZINTER_WITHSCORES,
zInterWithScores: ZINTER_WITHSCORES,
ZINTER,
zInter: ZINTER,
ZINTERSTORE,
@@ -333,12 +354,22 @@ export default {
zLexCount: ZLEXCOUNT,
ZMSCORE,
zmScore: ZMSCORE,
ZPOPMAX_COUNT,
zPopMaxCount: ZPOPMAX_COUNT,
ZPOPMAX,
zPopMax: ZPOPMAX,
ZPOPMIN_COUNT,
zPopMinCount: ZPOPMIN_COUNT,
ZPOPMIN,
zPopMin: ZPOPMIN,
ZRANDMEMBER_COUNT_WITHSCORES,
zRandMemberCountWithScores: ZRANDMEMBER_COUNT_WITHSCORES,
ZRANDMEMBER_COUNT,
zRandMemberCount: ZRANDMEMBER_COUNT,
ZRANDMEMBER,
zRandMember: ZRANDMEMBER,
ZRANGE_WITHSCORES,
zRangeWithScores: ZRANGE_WITHSCORES,
ZRANGE,
zRange: ZRANGE,
ZRANGESTORE,
@@ -359,6 +390,8 @@ export default {
zScan: ZSCAN,
ZSCORE,
zScore: ZSCORE,
ZUNION_WITHSCORES,
zUnionWithScores: ZUNION_WITHSCORES,
ZUNION,
zUnion: ZUNION,
ZUNIONSTORE,