wip

packages/client/lib/commands/ZADD.spec.ts

@@ -115,19 +115,7 @@ describe('ZADD', () => {
       );
     });
 
-    it('with INCR', () => {
+    it('with condition, comparison, CH', () => {
-      assert.deepEqual(
-        ZADD.transformArguments('key', {
-          value: '1',
-          score: 1
-        }, {
-          INCR: true
-        }),
-        ['ZADD', 'key', 'INCR', '1', '1']
-      );
-    });
-
-    it('with condition, comparison, CH, INCR', () => {
       assert.deepEqual(
         ZADD.transformArguments('key', {
           value: '1',
@@ -135,10 +123,9 @@ describe('ZADD', () => {
         }, {
           condition: 'XX',
           comparison: 'LT',
-          CH: true,
+          CH: true
-          INCR: true
         }),
-        ['ZADD', 'key', 'XX', 'LT', 'CH', 'INCR', '1', '1']
+        ['ZADD', 'key', 'XX', 'LT', 'CH', '1', '1']
       );
     });
   });

packages/client/lib/commands/ZADD.ts

@@ -1,4 +1,4 @@
-import { RedisArgument, NumberReply, DoubleReply, Command } from '../RESP/types';
+import { RedisArgument, NumberReply, DoubleReply, Command, CommandArguments } from '../RESP/types';
 import { ZMember, transformDoubleArgument, transformDoubleReply } from './generic-transformers';
 
 export interface ZAddOptions {
@@ -21,7 +21,6 @@ export interface ZAddOptions {
    */
   GT?: boolean;
   CH?: boolean;
-  INCR?: boolean;
 }
 
 export default {
@@ -53,10 +52,20 @@ export default {
       args.push('CH');
     }
 
-    if (options?.INCR) {
+    pushMembers(args, members);
-      args.push('INCR');
-    }
 
+    return args;
+  },
+  transformReply: {
+    2: transformDoubleReply,
+    3: undefined as unknown as () => NumberReply
+  }
+} as const satisfies Command;
+
+export function pushMembers(
+  args: CommandArguments, 
+  members: ZMember | Array<ZMember>
+) {
   if (Array.isArray(members)) {
     for (const member of members) {
       pushMember(args, member);
@@ -64,14 +73,7 @@ export default {
   } else {
     pushMember(args, members);
   }
-
+}
-    return args;
-  },
-  transformReply: {
-    2: transformDoubleReply,
-    3: undefined as unknown as () => NumberReply | DoubleReply
-  }
-} as const satisfies Command;
 
 function pushMember(args: Array<RedisArgument>, member: ZMember) {
   args.push(

packages/client/lib/commands/ZADD_INCR.spec.ts

@@ -0,0 +1,93 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import ZADD_INCR from './ZADD_INCR';
+
+describe('ZADD INCR', () => {
+  describe('transformArguments', () => {
+    it('single member', () => {
+      assert.deepEqual(
+        ZADD_INCR.transformArguments('key', {
+          value: '1',
+          score: 1
+        }),
+        ['ZADD', 'key', 'INCR', '1', '1']
+      );
+    });
+
+    it('multiple members', () => {
+      assert.deepEqual(
+        ZADD_INCR.transformArguments('key', [{
+          value: '1',
+          score: 1
+        }, {
+          value: '2',
+          score: 2
+        }]),
+        ['ZADD', 'key', 'INCR', '1', '1', '2', '2']
+      );
+    });
+
+    it('with condition', () => {
+      assert.deepEqual(
+        ZADD_INCR.transformArguments('key', {
+          value: '1',
+          score: 1
+        }, {
+          condition: 'NX'
+        }),
+        ['ZADD', 'key', 'NX', 'INCR', '1', '1']
+      );
+    });
+
+    it('with comparison', () => {
+      assert.deepEqual(
+        ZADD_INCR.transformArguments('key', {
+          value: '1',
+          score: 1
+        }, {
+          comparison: 'LT'
+        }),
+        ['ZADD', 'key', 'LT', 'INCR', '1', '1']
+      );
+    });    
+
+    it('with CH', () => {
+      assert.deepEqual(
+        ZADD_INCR.transformArguments('key', {
+          value: '1',
+          score: 1
+        }, {
+          CH: true
+        }),
+        ['ZADD', 'key', 'CH', 'INCR', '1', '1']
+      );
+    });
+
+    it('with condition, comparison, CH', () => {
+      assert.deepEqual(
+        ZADD_INCR.transformArguments('key', {
+          value: '1',
+          score: 1
+        }, {
+          condition: 'XX',
+          comparison: 'LT',
+          CH: true
+        }),
+        ['ZADD', 'key', 'XX', 'LT', 'CH', 'INCR', '1', '1']
+      );
+    });
+  });
+
+  testUtils.testAll('zAddIncr', async client => {
+    assert.equal(
+      await client.zAddIncr('key', {
+        value: '1',
+        score: 1
+      }),
+      1
+    );
+  }, {
+    client: GLOBAL.SERVERS.OPEN,
+    cluster: GLOBAL.CLUSTERS.OPEN
+  });
+});

packages/client/lib/commands/ZADD_INCR.ts

@@ -0,0 +1,42 @@
+import { RedisArgument, DoubleReply, NullReply, Command } from '../RESP/types';
+import { pushMembers } from './ZADD';
+import { ZMember, transformDoubleArgument, transformNullableDoubleReply } from './generic-transformers';
+
+export interface ZAddOptions {
+  condition?: 'NX' | 'XX';
+  comparison?: 'LT' | 'GT';
+  CH?: boolean;
+}
+
+export default {
+  FIRST_KEY_INDEX: 1,
+  transformArguments(
+    key: RedisArgument,
+    members: ZMember | Array<ZMember>,
+    options?: ZAddOptions
+  ) {
+    const args = ['ZADD', key];
+
+    if (options?.condition) {
+      args.push(options.condition);
+    }
+
+    if (options?.comparison) {
+      args.push(options.comparison);
+    }
+
+    if (options?.CH) {
+      args.push('CH');
+    }
+
+    args.push('INCR');
+
+    pushMembers(args, members);
+
+    return args;
+  },
+  transformReply: {
+    2: transformNullableDoubleReply,
+    3: undefined as unknown as () => DoubleReply | NullReply
+  }
+} as const satisfies Command;

packages/client/lib/commands/ZDIFF_WITHSCORES.ts

@@ -1,19 +1,14 @@
-import { ArrayReply, BlobStringReply, Command, NumberReply } from '../RESP/types';
+import { Command } from '../RESP/types';
 import ZDIFF from './ZDIFF';
-import { transformSortedSetWithScoresReply } from './generic-transformers';
+import { transformSortedSetReply } from './generic-transformers';
 
 export default {
-  FIRST_KEY_INDEX: 2,
+  FIRST_KEY_INDEX: ZDIFF.FIRST_KEY_INDEX,
-  IS_READ_ONLY: true,
+  IS_READ_ONLY: ZDIFF.IS_READ_ONLY,
-  transformArguments(keys: Parameters<typeof ZDIFF.transformArguments>[0]) {
+  transformArguments(...args: Parameters<typeof ZDIFF.transformArguments>) {
-    const args = ZDIFF.transformArguments(keys);
+    const redisArgs = ZDIFF.transformArguments(...args);
-    args.push('WITHSCORES');
+    redisArgs.push('WITHSCORES');
-    return args;
+    return redisArgs;
   },
-  transformReply: {
+  transformReply: transformSortedSetReply
-    2: transformSortedSetWithScoresReply,
-    3: (reply: ArrayReply<[BlobStringReply, NumberReply]>) => {
-      return reply.map(([value, score]) => ({ value, score }));
-    }
-  }
 } as const satisfies Command;

packages/client/lib/commands/ZINTERSTORE.ts

@@ -1,12 +1,13 @@
 
 import { RedisArgument, NumberReply, Command } from '../RESP/types';
-import { pushZInterArguments, ZInterKeyAndWeight, ZInterKeys, ZInterOptions } from './ZINTER';
+import { pushZInterArguments, ZInterOptions } from './ZINTER';
+import { ZKeys } from './generic-transformers';
 
 export default {
   FIRST_KEY_INDEX: 1,
   transformArguments(
     destination: RedisArgument,
-    keys: ZInterKeys<RedisArgument> | ZInterKeys<ZInterKeyAndWeight>,
+    keys: ZKeys,
     options?: ZInterOptions
   ) {
     return pushZInterArguments(['ZINTERSTORE', destination], keys, options);

packages/client/lib/commands/ZINTER_WITHSCORES.ts

@@ -1,22 +1,6 @@
-// import { RedisCommandArguments } from '.';
+import { Command } from '../RESP/types';
-// import { transformArguments as transformZInterArguments } from './ZINTER';
-
-// export { FIRST_KEY_INDEX, IS_READ_ONLY } from './ZINTER';
-
-// export function transformArguments(...args: Parameters<typeof transformZInterArguments>): RedisCommandArguments {
-//     return [
-//         ...transformZInterArguments(...args),
-//         'WITHSCORES'
-//     ];
-// }
-
-
-
-// // transformSortedSetWithScoresReply
-
-import { ArrayReply, BlobStringReply, Command, DoubleReply } from '../RESP/types';
 import ZINTER from './ZINTER';
-import { transformSortedSetWithScoresReply } from './generic-transformers';
+import { transformSortedSetReply } from './generic-transformers';
 
 export default {
   FIRST_KEY_INDEX: ZINTER.FIRST_KEY_INDEX,
@@ -26,13 +10,5 @@ export default {
     redisArgs.push('WITHSCORES');
     return redisArgs;
   },
-  transformReply: {
+  transformReply: transformSortedSetReply
-    2: transformSortedSetWithScoresReply,
-    3: (reply: ArrayReply<[BlobStringReply, DoubleReply]>) => {
-      return reply.map(([member, score]) => ({
-        member,
-        score
-      }));
-    }
-  }
 } as const satisfies Command;

packages/client/lib/commands/ZRANGEBYSCORE_WITHSCORES.spec.ts

@@ -1,33 +1,36 @@
-// import { strict as assert } from 'assert';
+import { strict as assert } from 'assert';
-// import testUtils, { GLOBAL } from '../test-utils';
+import testUtils, { GLOBAL } from '../test-utils';
-// import { transformArguments } from './ZRANGEBYSCORE_WITHSCORES';
+import ZRANGEBYSCORE_WITHSCORES from './ZRANGEBYSCORE_WITHSCORES';
 
-// describe('ZRANGEBYSCORE WITHSCORES', () => {
+describe('ZRANGEBYSCORE WITHSCORES', () => {
-//     describe('transformArguments', () => {
+  describe('transformArguments', () => {
-//         it('simple', () => {
+    it('simple', () => {
-//             assert.deepEqual(
+      assert.deepEqual(
-//                 transformArguments('src', 0, 1),
+        ZRANGEBYSCORE_WITHSCORES.transformArguments('src', 0, 1),
-//                 ['ZRANGEBYSCORE', 'src', '0', '1', 'WITHSCORES']
+        ['ZRANGEBYSCORE', 'src', '0', '1', 'WITHSCORES']
-//             );
+      );
-//         });
+    });
 
-//         it('with LIMIT', () => {
+    it('with LIMIT', () => {
-//             assert.deepEqual(
+      assert.deepEqual(
-//                 transformArguments('src', 0, 1, {
+        ZRANGEBYSCORE_WITHSCORES.transformArguments('src', 0, 1, {
-//                     LIMIT: {
+          LIMIT: {
-//                         offset: 0,
+            offset: 0,
-//                         count: 1
+            count: 1
-//                     }
+          }
-//                 }),
+        }),
-//                 ['ZRANGEBYSCORE', 'src', '0', '1', 'LIMIT', '0', '1', 'WITHSCORES']
+        ['ZRANGEBYSCORE', 'src', '0', '1', 'LIMIT', '0', '1', 'WITHSCORES']
-//             );
+      );
-//         });
+    });
-//     });
+  });
 
-//     testUtils.testWithClient('client.zRangeByScoreWithScores', async client => {
+  testUtils.testAll('zRangeByScoreWithScores', async client => {
-//         assert.deepEqual(
+    assert.deepEqual(
-//             await client.zRangeByScoreWithScores('src', 0, 1),
+      await client.zRangeByScoreWithScores('src', 0, 1),
-//             []
+      []
-//         );
+    );
-//     }, GLOBAL.SERVERS.OPEN);
+  }, {
-// });
+    client: GLOBAL.SERVERS.OPEN,
+    cluster: GLOBAL.CLUSTERS.OPEN
+  });
+});

packages/client/lib/commands/ZRANGEBYSCORE_WITHSCORES.ts

@@ -1,18 +1,14 @@
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
+import { Command } from '../RESP/types';
-// import { ZRangeByScoreOptions, transformArguments as transformZRangeByScoreArguments } from './ZRANGEBYSCORE';
+import ZRANGEBYSCORE from './ZRANGEBYSCORE';
+import { transformSortedSetReply } from './generic-transformers';
 
-// export { FIRST_KEY_INDEX, IS_READ_ONLY } from './ZRANGEBYSCORE';
+export default {
-
+  FIRST_KEY_INDEX: ZRANGEBYSCORE.FIRST_KEY_INDEX,
-// export function transformArguments(
+  IS_READ_ONLY: ZRANGEBYSCORE.IS_READ_ONLY,
-//     key: RedisCommandArgument,
+  transformArguments(...args: Parameters<typeof ZRANGEBYSCORE.transformArguments>) {
-//     min: string | number,
+    const redisArgs = ZRANGEBYSCORE.transformArguments(...args);
-//     max: string | number,
+    redisArgs.push('WITHSCORES');
-//     options?: ZRangeByScoreOptions
+    return redisArgs;
-// ): RedisCommandArguments {
+  },
-//     return [
+  transformReply: transformSortedSetReply
-//         ...transformZRangeByScoreArguments(key, min, max, options),
+} as const satisfies Command;
-//         'WITHSCORES'
-//     ];
-// }
-
-// export { transformSortedSetWithScoresReply as transformReply } from './generic-transformers';

packages/client/lib/commands/ZUNIONSTORE.spec.ts

@@ -6,27 +6,41 @@ describe('ZUNIONSTORE', () => {
   describe('transformArguments', () => {
     it('key (string)', () => {
       assert.deepEqual(
-        ZUNIONSTORE.transformArguments('destination', 'key'),
+        ZUNIONSTORE.transformArguments('destination', 'source'),
         ['ZUNIONSTORE', 'destination', '1', 'key']
       );
     });
 
-    it('keys (array)', () => {
+    it('keys (Array<string>)', () => {
       assert.deepEqual(
         ZUNIONSTORE.transformArguments('destination', ['1', '2']),
         ['ZUNIONSTORE', 'destination', '2', '1', '2']
       );
     });
 
-    it('with WEIGHTS', () => {
+    it('key & weight', () => {
       assert.deepEqual(
-        ZUNIONSTORE.transformArguments('destination', 'key', {
+        ZUNIONSTORE.transformArguments('destination', {
-          WEIGHTS: [1]
+          key: 'key',
+          weight: 1
         }),
         ['ZUNIONSTORE', 'destination', '1', 'key', 'WEIGHTS', '1']
       );
     });
 
+    it('keys & weights', () => {
+      assert.deepEqual(
+        ZUNIONSTORE.transformArguments('destination', [{
+          key: 'a',
+          weight: 1
+        }, {
+          key: 'b',
+          weight: 2
+        }]),
+        ['ZUNIONSTORE', 'destination', '2', 'a', 'b', 'WEIGHTS', '1', '2']
+      );
+    });
+
     it('with AGGREGATE', () => {
       assert.deepEqual(
         ZUNIONSTORE.transformArguments('destination', 'key', {
@@ -35,16 +49,6 @@ describe('ZUNIONSTORE', () => {
         ['ZUNIONSTORE', 'destination', '1', 'key', 'AGGREGATE', 'SUM']
       );
     });
-
-    it('with WEIGHTS, AGGREGATE', () => {
-      assert.deepEqual(
-        ZUNIONSTORE.transformArguments('destination', 'key', {
-          WEIGHTS: [1],
-          AGGREGATE: 'SUM'
-        }),
-        ['ZUNIONSTORE', 'destination', '1', 'key', 'WEIGHTS', '1', 'AGGREGATE', 'SUM']
-      );
-    });
   });
 
   testUtils.testAll('zUnionStore', async client => {

packages/client/lib/commands/ZUNION_WITHSCORES.spec.ts

@@ -9,14 +9,14 @@ describe('ZUNION WITHSCORES', () => {
     it('key (string)', () => {
       assert.deepEqual(
         ZUNION_WITHSCORES.transformArguments('key'),
-        ['ZUNION', '1', 'key']
+        ['ZUNION', '1', 'key', 'WITHSCORES']
       );
     });
 
     it('keys (Array<string>)', () => {
       assert.deepEqual(
         ZUNION_WITHSCORES.transformArguments(['1', '2']),
-        ['ZUNION', '2', '1', '2']
+        ['ZUNION', '2', '1', '2', 'WITHSCORES']
       );
     });
 
@@ -26,7 +26,7 @@ describe('ZUNION WITHSCORES', () => {
           key: 'key',
           weight: 1
         }),
-        ['ZUNION', '1', 'key', 'WEIGHTS', '1']
+        ['ZUNION', '1', 'key', 'WEIGHTS', '1', 'WITHSCORES']
       );
     });
 
@@ -39,7 +39,7 @@ describe('ZUNION WITHSCORES', () => {
           key: 'b',
           weight: 2
         }]),
-        ['ZUNION', '2', 'a', 'b', 'WEIGHTS', '1', '2']
+        ['ZUNION', '2', 'a', 'b', 'WEIGHTS', '1', '2', 'WITHSCORES']
       );
     });
 

packages/client/lib/commands/index.ts

@@ -186,6 +186,7 @@ import XDEL from './XDEL';
 import XSETID from './XSETID';
 import XTRIM from './XTRIM';
 import XLEN from './XLEN';
+import ZADD_INCR from './ZADD_INCR';
 import ZADD from './ZADD';
 import ZCARD from './ZCARD';
 import ZCOUNT from './ZCOUNT';
@@ -204,6 +205,7 @@ import ZRANDMEMBER_COUNT from './ZRANDMEMBER_COUNT';
 import ZRANDMEMBER from './ZRANDMEMBER';
 import ZRANGE from './ZRANGE';
 import ZRANGEBYLEX from './ZRANGEBYLEX';
+import ZRANGEBYSCORE_WITHSCORES from './ZRANGEBYSCORE_WITHSCORES';
 import ZRANGEBYSCORE from './ZRANGEBYSCORE';
 import ZREMRANGEBYSCORE from './ZREMRANGEBYSCORE';
 import ZRANK from './ZRANK';
@@ -596,6 +598,8 @@ export default {
   xTrim: XTRIM,
   XLEN,
   xLen: XLEN,
+  ZADD_INCR,
+  zAddIncr: ZADD_INCR,
   ZADD,
   zAdd: ZADD,
   ZCARD,
@@ -632,6 +636,8 @@ export default {
   zRange: ZRANGE,
   ZRANGEBYLEX,
   zRangeByLex: ZRANGEBYLEX,
+  ZRANGEBYSCORE_WITHSCORES,
+  zRangeByScoreWithScores: ZRANGEBYSCORE_WITHSCORES,
   ZRANGEBYSCORE,
   zRangeByScore: ZRANGEBYSCORE,
   ZRANK,