lots of todo commends

lib/client.ts

@@ -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;

lib/commands/BZPOPMAX.ts

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

lib/commands/BZPOPMIN.ts

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

lib/commands/HRANDFIELD.spec.ts

@@ -3,29 +3,13 @@ import { TestRedisServers, itWithClient } from '../test-utils';
 import { transformArguments } from './HRANDFIELD';
 
 describe('HRANDFIELD', () => {
-    describe('transformArguments', () => {
+    it('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']
-            );
-        });
-    });
-
     itWithClient(TestRedisServers.OPEN, 'client.hRandField', async client => {
         assert.equal(
             await client.hRandField('key'),

lib/commands/HRANDFIELD.ts

@@ -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> {
+export function transformArguments(key: string): Array<string> {
-    const args = ['HRANDFIELD', key];
+    return ['HRANDFIELD', key];
-    if (count) {
-        args.push(count.toString());
-
-        if (withValues) {
-            args.push('WITHVALUES');
-        }
-    }
-
-    return args;
 }
 
-export function transformReply(reply: null | string | Array<string>): null | string | Array<string> {
+export const transformReply = transformReplyString;
-    // TODO: convert to object when `withValues`?
-    return reply;
-};

lib/commands/HRANDFIELD_COUNT.spec.ts

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

lib/commands/HRANDFIELD_COUNT.ts

@@ -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;
+}

lib/commands/HRANDFIELD_COUNT_WITHVALUES.spec.ts

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

lib/commands/HRANDFIELD_COUNT_WITHVALUES.ts

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

lib/commands/SRANDMEMBER.spec.ts

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

lib/commands/SRANDMEMBER.ts

@@ -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> {
+export function transformArguments(key: string): Array<string> {
-    const args = ['SRANDMEMBER', key];
+    return ['SRANDMEMBER', key];
-
-    if (typeof count === 'number') {
-        args.push(count.toString());
-    }
-
-    return args;
 }
 
-// TODO: without `count` it'll return "bulk string" and not "array"
+export const transformReply = transformReplyStringNull;
-export const transformReply = transformReplyStringArray;

lib/commands/SRANDMEMBER_COUNT.spec.ts

@@ -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),
+            []
+        );
+    });
+});

lib/commands/SRANDMEMBER_COUNT.ts

@@ -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;

lib/commands/XADD.ts

@@ -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) {

lib/commands/XINFO_STREAM.ts

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

lib/commands/ZADD.ts

@@ -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];
 

lib/commands/ZDIFF.spec.ts

@@ -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 => {

lib/commands/ZDIFF.ts

@@ -4,11 +4,7 @@ export const FIRST_KEY_INDEX = 2;
 
 export const IS_READ_ONLY = true;
 
-interface ZDiffOptions {
+export function transformArguments(keys: Array<string> | string): Array<string> {
-    WITHSCORES?: true;
-}
-
-export function transformArguments(keys: Array<string> | string, options?: ZDiffOptions): 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;

lib/commands/ZDIFF_WITHSCORES.spec.ts

@@ -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'),
+            []
+        );
+    });
+});

lib/commands/ZDIFF_WITHSCORES.ts

@@ -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;

lib/commands/ZINTER.spec.ts

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

lib/commands/ZINTER.ts

@@ -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;

lib/commands/ZINTER_WITHSCORES.spec.ts

@@ -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'),
+            []
+        );
+    });
+});

lib/commands/ZINTER_WITHSCORES.ts

@@ -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;

lib/commands/ZPOPMAX.spec.ts

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

lib/commands/ZPOPMAX.ts

@@ -1,5 +1,4 @@
-import { transformReplyNumberInfinity } from './generic-transformers';
+import { transformReplyNumberInfinity, ZMember } from './generic-transformers';
-import { ZMember } from './ZADD';
 
 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;
     

lib/commands/ZPOPMAX_COUNT.spec.ts

@@ -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),
+            []
+        );
+    });
+});

lib/commands/ZPOPMAX_COUNT.ts

@@ -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;

lib/commands/ZPOPMIN.spec.ts

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

lib/commands/ZPOPMIN.ts

@@ -1,22 +1,14 @@
-import { transformReplyNumberInfinity } from './generic-transformers';
+import { transformReplyNumberInfinity, ZMember } from './generic-transformers';
-import { ZMember } from './ZADD';
 
 export const FIRST_KEY_INDEX = 1;
 
-export function transformArguments(key: string, count?: number): Array<string> {
+export function transformArguments(key: string): Array<string> {
-    const args = [
+    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;
     

lib/commands/ZPOPMIN_COUNT.spec.ts

@@ -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),
+            []
+        );
+    });
+});

lib/commands/ZPOPMIN_COUNT.ts

@@ -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;

lib/commands/ZRANDMEMBER.spec.ts

@@ -3,29 +3,13 @@ import { TestRedisServers, itWithClient } from '../test-utils';
 import { transformArguments } from './ZRANDMEMBER';
 
 describe('ZRANDMEMBER', () => {
-    describe('transformArguments', () => {
+    it('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']
-            );
-        });
-    });
-
     itWithClient(TestRedisServers.OPEN, 'client.zRandMember', async client => {
         assert.equal(
             await client.zRandMember('key'),

lib/commands/ZRANDMEMBER.ts

@@ -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> {
+export function transformArguments(key: string): Array<string> {
-    const args = ['ZRANDMEMBER', key];
+    return ['ZRANDMEMBER', key];
-
-    if (typeof count === 'number') {
-        args.push(count.toString());
-
-        if (WITHSCORES) {
-            args.push('WITHSCORES');
-        }
-    }
-
-    return args;
 }
 
-// TODO: string when count is 1 or undefined, array when count is > 1, object when WITHSCORES
+export const transformReply = transformReplyStringNull;
-type ZRandMemberReply = string | Array<string> | null
-
-export function transformReply(reply: ZRandMemberReply): ZRandMemberReply {
-    return reply;
-}

lib/commands/ZRANDMEMBER_COUNT.spec.ts

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

lib/commands/ZRANDMEMBER_COUNT.ts

@@ -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;
+}

lib/commands/ZRANDMEMBER_COUNT_WITHSCORES.spec.ts

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

lib/commands/ZRANDMEMBER_COUNT_WITHSCORES.ts

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

lib/commands/ZRANGE.spec.ts

@@ -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, {

lib/commands/ZRANGE.ts

@@ -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),
+        typeof min === 'string' ? min : min.toString(),
-        transformArgumentNumberInfinity(max)
+        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;

lib/commands/ZRANGE_WITHSCORES.spec.ts

@@ -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),
+            []
+        );
+    });
+});

lib/commands/ZRANGE_WITHSCORES.ts

@@ -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;

lib/commands/ZSCAN.ts

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

lib/commands/ZUNION.spec.ts

@@ -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 => {

lib/commands/ZUNION.ts

@@ -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;

lib/commands/ZUNION_WITHSCORES.spec.ts

@@ -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'),
+            []
+        );
+    });
+});

lib/commands/ZUNION_WITHSCORES.ts

@@ -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;

lib/commands/generic-transformers.ts

@@ -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;
+}

lib/commands/index.ts

@@ -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,