ref #2489

docs/todo.md

@@ -1,19 +1,16 @@
-# Leibale
+# Client
 
 - Does `close`/`destory` actually close the connection from the Redis POV? Works with OSS, but what about Redis Enterprie?
 
-# Docs
-
+Docs:
 - [v4 to v5](./v4-to-v5.md) - Legacy mode
 - [Command Options](./command-options.md)
 - [RESP](./RESP.md)
 
-# Missing functionality
+# Server
 
 - `HEXISTS`: accepts one field only, should be the same as `EXISTS`
 
-# Replies
-
 `String` -> `Double`:
 - `INCRBYFLOAT`
 - `HINCRBYFLOAT`

packages/client/lib/RESP/decoder.spec.ts

@@ -1,66 +1,75 @@
 // import { strict as assert } from 'assert';
 // import { SinonSpy, spy } from 'sinon';
-// import RESP2Decoder from './decoder';
-// import { ErrorReply } from '../../errors';
+// import { Decoder, RESP_TYPES } from './decoder';
+// import { ErrorReply } from '../errors';
+// import { TypeMapping } from './types';
 
-// interface DecoderAndSpies {
-//     decoder: RESP2Decoder;
-//     returnStringsAsBuffersSpy: SinonSpy;
-//     onReplySpy: SinonSpy;
-// }
-
-// function createDecoderAndSpies(returnStringsAsBuffers: boolean): DecoderAndSpies {
-//     const returnStringsAsBuffersSpy = spy(() => returnStringsAsBuffers),
-//         onReplySpy = spy();
+// function createDecoderAndSpies(typeMapping: TypeMapping = {}) {
+//   const typeMappingSpy = spy(() => typeMapping),
+//     onReplySpy = spy(),
+//     onErrorReplySpy = spy(),
+//     onPushSpy = spy();
 
 //   return {
-//         decoder: new RESP2Decoder({
-//             returnStringsAsBuffers: returnStringsAsBuffersSpy,
-//             onReply: onReplySpy
+//     decoder: new Decoder({
+//       getTypeMapping: typeMappingSpy,
+//       onReply: onReplySpy,
+//       onErrorReply: onErrorReplySpy,
+//       onPush: onPushSpy
 //     }),
-//         returnStringsAsBuffersSpy,
-//         onReplySpy
+//     typeMappingSpy,
+//     onReplySpy,
+//     onErrorReplySpy,
+//     onPushSpy
 //   };
 // }
 
-// function writeChunks(stream: RESP2Decoder, buffer: Buffer) {
+// function writeChunks(stream: Decoder, buffer: Buffer) {
 //   let i = 0;
 //   while (i < buffer.length) {
-//         stream.write(buffer.slice(i, ++i));
+//     stream.write(buffer.subarray(i, ++i));
 //   }
 // }
 
 // type Replies = Array<Array<unknown>>;
 
-// interface TestsOptions {
-//     toWrite: Buffer;
-//     returnStringsAsBuffers: boolean;
-//     replies: Replies;
+// function generateTests(toWrite: Buffer, tests: Array<Test & { name: string }>): void {
+//   for (const test of tests) {
+//     describe(test.name, () => {
+//       generateTests(toWrite, test);
+//     });
+//   }
 // }
 
-// function generateTests({
-//     toWrite,
-//     returnStringsAsBuffers,
-//     replies
-// }: TestsOptions): void {
+// interface Test {
+//   typeMapping?: TypeMapping;
+//   replies?: Replies;
+//   errorReplies?: Replies;
+//   pushReplies?: Replies;
+// }
+
+// function genetareTypeTests(toWrite: Buffer, { typeMapping, replies, errorReplies, pushReplies }: Test) {
+//   const total = (replies?.length ?? 0) + (errorReplies?.length ?? 0) + (pushReplies?.length ?? 0);
 //   it('single chunk', () => {
-//         const { decoder, returnStringsAsBuffersSpy, onReplySpy } =
-//             createDecoderAndSpies(returnStringsAsBuffers);
+//     const { decoder, typeMappingSpy, onReplySpy, onErrorReplySpy, onPushSpy } = createDecoderAndSpies(typeMapping);
 //     decoder.write(toWrite);
-//         assert.equal(returnStringsAsBuffersSpy.callCount, replies.length);
+//     assert.equal(typeMappingSpy.callCount, total);
 //     testReplies(onReplySpy, replies);
+//     testReplies(onErrorReplySpy, errorReplies);
+//     testReplies(onPushSpy, pushReplies);
 //   });
 
 //   it('multiple chunks', () => {
-//         const { decoder, returnStringsAsBuffersSpy, onReplySpy } =
-//             createDecoderAndSpies(returnStringsAsBuffers);
+//     const { decoder, typeMappingSpy, onReplySpy, onErrorReplySpy, onPushSpy } = createDecoderAndSpies(typeMapping);
 //     writeChunks(decoder, toWrite);
-//         assert.equal(returnStringsAsBuffersSpy.callCount, replies.length);
+//     assert.equal(typeMappingSpy.callCount, total);
 //     testReplies(onReplySpy, replies);
+//     testReplies(onErrorReplySpy, errorReplies);
+//     testReplies(onPushSpy, pushReplies);
 //   });
 // }
 
-// function testReplies(spy: SinonSpy, replies: Replies): void {
+// function testReplies(spy: SinonSpy, replies?: Replies): void {
 //   if (!replies) {
 //     assert.equal(spy.callCount, 0);
 //     return;
@@ -76,11 +85,48 @@
 // }
 
 // describe('RESP2Parser', () => {
+//   describe('Null', () => {
+//     genetareTypeTests(Buffer.from('_\r\n'), {
+//       replies: [[null]]
+//     });
+//   });
+
+//   describe('Boolean', () => {
+//     genetareTypeTests(Buffer.from('#t\r\n'), {
+//       replies: [[null]]
+//     });
+//   });
+
+//   describe('Number', () => {
+//     generateTests(Buffer.from(':-1\r\n'))
+//     describe('as number', () => {
+//       describe('-1', () => {
+//         generateTests({
+//           toWrite: ,
+//           replies: [[-1]]
+//         });
+//       });
+  
+//       describe('0', () => {
+//         generateTests({
+//           toWrite: Buffer.from(':0\r\n'),
+//           replies: [[0]]
+//         });
+//       });
+  
+//       describe('+1', () => {
+//         generateTests({
+//           toWrite: Buffer.from(':+1\r\n'),
+//           replies: [[1]]
+//         });
+//       });
+//     });
+//   });
+  
 //   describe('Simple String', () => {
 //     describe('as strings', () => {
 //       generateTests({
 //         toWrite: Buffer.from('+OK\r\n'),
-//                 returnStringsAsBuffers: false,
 //         replies: [['OK']]
 //       });
 //     });
@@ -88,7 +134,9 @@
 //     describe('as buffers', () => {
 //       generateTests({
 //         toWrite: Buffer.from('+OK\r\n'),
-//                 returnStringsAsBuffers: true,
+//         typeMapping: {
+//           [RESP_TYPES.SIMPLE_STRING]: Buffer
+//         },
 //         replies: [[Buffer.from('OK')]]
 //       });
 //     });
@@ -97,28 +145,11 @@
 //   describe('Error', () => {
 //     generateTests({
 //       toWrite: Buffer.from('-ERR\r\n'),
-//             returnStringsAsBuffers: false,
-//             replies: [[new ErrorReply('ERR')]]
+//       errorReplies: [[new ErrorReply('ERR')]]
 //     });
 //   });
 
-//     describe('Integer', () => {
-//         describe('-1', () => {
-//             generateTests({
-//                 toWrite: Buffer.from(':-1\r\n'),
-//                 returnStringsAsBuffers: false,
-//                 replies: [[-1]]
-//             });
-//         });
   
-//         describe('0', () => {
-//             generateTests({
-//                 toWrite: Buffer.from(':0\r\n'),
-//                 returnStringsAsBuffers: false,
-//                 replies: [[0]]
-//             });
-//         });
-//     });
 
 //   describe('Bulk String', () => {
 //     describe('null', () => {

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

@@ -0,0 +1,46 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import ZRANK_WITHSCORE from './ZRANK_WITHSCORE';
+
+describe('ZRANK WITHSCORE', () => {
+  testUtils.isVersionGreaterThanHook([7, 2]);
+
+  it('transformArguments', () => {
+    assert.deepEqual(
+      ZRANK_WITHSCORE.transformArguments('key', 'member'),
+      ['ZRANK', 'key', 'member', 'WITHSCORE']
+    );
+  });
+
+  testUtils.testAll('zRankWithScore - null', async client => {
+    assert.equal(
+      await client.zRankWithScore('key', 'member'),
+      null
+    );
+  }, {
+    client: GLOBAL.SERVERS.OPEN,
+    cluster: GLOBAL.CLUSTERS.OPEN
+  });
+
+  testUtils.testAll('zRankWithScore - with member', async client => {
+    const member = {
+      value: '1',
+      score: 1
+    }
+
+    const [, reply] = await Promise.all([
+      client.zAdd('key', member),
+      client.zRankWithScore('key', member.value)
+    ])
+    assert.deepEqual(
+      reply,
+      {
+        rank: 0,
+        score: 1
+      }
+    );
+  }, {
+    client: GLOBAL.SERVERS.OPEN,
+    cluster: GLOBAL.CLUSTERS.OPEN
+  });
+});

packages/client/lib/commands/ZRANK_WITHSCORE.ts

@@ -0,0 +1,30 @@
+import { NullReply, TuplesReply, NumberReply, BlobStringReply, DoubleReply, Command } from '../RESP/types';
+import ZRANK from './ZRANK';
+
+export default {
+  FIRST_KEY_INDEX: ZRANK.FIRST_KEY_INDEX,
+  IS_READ_ONLY: ZRANK.IS_READ_ONLY,
+  transformArguments(...args: Parameters<typeof ZRANK.transformArguments>) {
+    const redisArgs = ZRANK.transformArguments(...args);
+    redisArgs.push('WITHSCORE');
+    return redisArgs;
+  },
+  transformReply: {
+    2: (reply: NullReply | TuplesReply<[NumberReply, BlobStringReply]>) => {
+      if (reply === null) return null;
+
+      return {
+        rank: reply[0],
+        score: Number(reply[1])
+      };
+    },
+    3: (reply: NullReply | TuplesReply<[BlobStringReply, DoubleReply]>) => {
+      if (reply === null) return null;
+
+      return {
+        rank: reply[0],
+        score: reply[1]
+      };
+    }
+  }
+} as const satisfies Command;

packages/client/lib/commands/index.ts

@@ -286,6 +286,7 @@ import ZRANGEBYSCORE_WITHSCORES from './ZRANGEBYSCORE_WITHSCORES';
 import ZRANGEBYSCORE from './ZRANGEBYSCORE';
 import ZRANGESTORE from './ZRANGESTORE';
 import ZREMRANGEBYSCORE from './ZREMRANGEBYSCORE';
+import ZRANK_WITHSCORE from './ZRANK_WITHSCORE';
 import ZRANK from './ZRANK';
 import ZREM from './ZREM';
 import ZREMRANGEBYLEX from './ZREMRANGEBYLEX';
@@ -586,6 +587,7 @@ type ZRANGEBYSCORE_WITHSCORES = typeof import('./ZRANGEBYSCORE_WITHSCORES').defa
 type ZRANGEBYSCORE = typeof import('./ZRANGEBYSCORE').default;
 type ZRANGESTORE = typeof import('./ZRANGESTORE').default;
 type ZREMRANGEBYSCORE = typeof import('./ZREMRANGEBYSCORE').default;
+type ZRANK_WITHSCORE = typeof import('./ZRANK_WITHSCORE').default;
 type ZRANK = typeof import('./ZRANK').default;
 type ZREM = typeof import('./ZREM').default;
 type ZREMRANGEBYLEX = typeof import('./ZREMRANGEBYLEX').default;
@@ -1174,6 +1176,8 @@ type Commands = {
   zRangeByScore: ZRANGEBYSCORE;
   ZRANGESTORE: ZRANGESTORE;
   zRangeStore: ZRANGESTORE;
+  ZRANK_WITHSCORE: ZRANK_WITHSCORE;
+  zRankWithScore: ZRANK_WITHSCORE;
   ZRANK: ZRANK;
   zRank: ZRANK;
   ZREM: ZREM;
@@ -1775,6 +1779,8 @@ export default {
   zRangeByScore: ZRANGEBYSCORE,
   ZRANGESTORE,
   zRangeStore: ZRANGESTORE,
+  ZRANK_WITHSCORE,
+  zRankWithScore: ZRANK_WITHSCORE,
   ZRANK,
   zRank: ZRANK,
   ZREM,

todo.md

@@ -1,31 +0,0 @@
-# return type \ missing documentation
-- `XAUTOCLAIM`
-- `XSETID`
-- `ZUNION`
-
-
-# create commands
-- `ZREVRANGE`
-- `ZREVRANGEBYLEX`
-- `ZREVRANGEBYSCORE`
-
-
-# waiting List categoreis
-- Set
-- Bitmap
-
-# fot leiba
-- `BZMPOP.ts`
-- `BZPOPMAX.ts`
-- `BZPOPMIN.ts`
-- `ZMPOP.ts`
-- `ZPOPMAX.ts`
-- `ZPOPMIN.ts`
-- `ZREVRANGE WITHSCORE`
-- `ZRANK WITHSCORE`
-- `MIGRATE`
-- `RESTORE`
-- `WAITAOF`
-
-# other
-