Cmd parser with commands

.github/workflows/tests.yml

@@ -17,7 +17,7 @@ jobs:
       fail-fast: false
       matrix:
         node-version: ['18', '20']
-        redis-version: ['5', '6.0', '6.2', '7.0', '7.2']
+        redis-version: ['5', '6.0', '6.2', '7.0', '7.2', '7.4']
     steps:
       - uses: actions/checkout@v4
         with:

packages/bloom/lib/commands/bloom/ADD.spec.ts

@@ -1,11 +1,12 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../../test-utils';
 import ADD from './ADD';
+import { parseArgs } from '@redis/client/dist/lib/commands/generic-transformers';
 
 describe('BF.ADD', () => {
   it('transformArguments', () => {
     assert.deepEqual(
-      ADD.transformArguments('key', 'item'),
+      parseArgs(ADD, 'key', 'item'),
       ['BF.ADD', 'key', 'item']
     );
   });

packages/bloom/lib/commands/bloom/ADD.ts

@@ -1,11 +1,13 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
 import { RedisArgument, Command } from '@redis/client/dist/lib/RESP/types';
 import { transformBooleanReply } from '@redis/client/dist/lib/commands/generic-transformers';
 
 export default {
-  FIRST_KEY_INDEX: 1,
   IS_READ_ONLY: false,
-  transformArguments(key: RedisArgument, item: RedisArgument) {
-    return ['BF.ADD', key, item];
+  parseCommand(parser: CommandParser, key: RedisArgument, item: RedisArgument) {
+    parser.push('BF.ADD');
+    parser.pushKey(key);
+    parser.push(item);
   },
   transformReply: transformBooleanReply
 } as const satisfies Command;

packages/bloom/lib/commands/bloom/CARD.spec.ts

@@ -1,11 +1,12 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../../test-utils';
 import CARD from './CARD';
+import { parseArgs } from '@redis/client/dist/lib/commands/generic-transformers';
 
 describe('BF.CARD', () => {
   it('transformArguments', () => {
     assert.deepEqual(
-      CARD.transformArguments('bloom'),
+      parseArgs(CARD, 'bloom'),
       ['BF.CARD', 'bloom']
     );
   });

packages/bloom/lib/commands/bloom/CARD.ts

@@ -1,10 +1,11 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
 import { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';
 
 export default {
-  FIRST_KEY_INDEX: 1,
   IS_READ_ONLY: true,
-  transformArguments(key: RedisArgument) {
-    return ['BF.CARD', key];
+  parseCommand(parser: CommandParser, key: RedisArgument) {
+    parser.push('BF.CARD');
+    parser.pushKey(key);
   },
   transformReply: undefined as unknown as () => NumberReply
 } as const satisfies Command;

packages/bloom/lib/commands/bloom/EXISTS.spec.ts

@@ -1,11 +1,12 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../../test-utils';
 import EXISTS from './EXISTS';
+import { parseArgs } from '@redis/client/dist/lib/commands/generic-transformers';
 
 describe('BF.EXISTS', () => {
   it('transformArguments', () => {
     assert.deepEqual(
-      EXISTS.transformArguments('key', 'item'),
+      parseArgs(EXISTS, 'key', 'item'),
       ['BF.EXISTS', 'key', 'item']
     );
   });

packages/bloom/lib/commands/bloom/EXISTS.ts

@@ -1,11 +1,13 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
 import { RedisArgument, Command } from '@redis/client/dist/lib/RESP/types';
 import { transformBooleanReply } from '@redis/client/dist/lib/commands/generic-transformers';
 
 export default {
-  FIRST_KEY_INDEX: 1,
   IS_READ_ONLY: true,
-  transformArguments(key: RedisArgument, item: RedisArgument) {
-    return ['BF.EXISTS', key, item];
+  parseCommand(parser: CommandParser, key: RedisArgument, item: RedisArgument) {
+    parser.push('BF.EXISTS');
+    parser.pushKey(key);
+    parser.push(item);
   },
   transformReply: transformBooleanReply
 } as const satisfies Command;

packages/bloom/lib/commands/bloom/INFO.spec.ts

@@ -1,11 +1,12 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../../test-utils';
 import INFO from './INFO';
+import { parseArgs } from '@redis/client/dist/lib/commands/generic-transformers';
 
 describe('BF.INFO', () => {
   it('transformArguments', () => {
     assert.deepEqual(
-      INFO.transformArguments('bloom'),
+      parseArgs(INFO, 'bloom'),
       ['BF.INFO', 'bloom']
     );
   });
@@ -17,10 +18,10 @@ describe('BF.INFO', () => {
     ]);
 
     assert.equal(typeof reply, 'object');
-    assert.equal(reply.capacity, 100);
-    assert.equal(typeof reply.size, 'number');
-    assert.equal(typeof reply.numberOfFilters, 'number');
-    assert.equal(typeof reply.numberOfInsertedItems, 'number');
-    assert.equal(typeof reply.expansionRate, 'number');
+    assert.equal(reply['Capacity'], 100);
+    assert.equal(typeof reply['Size'], 'number');
+    assert.equal(typeof reply['Number of filters'], 'number');
+    assert.equal(typeof reply['Number of items inserted'], 'number');
+    assert.equal(typeof reply['Expansion rate'], 'number');
   }, GLOBAL.SERVERS.OPEN);
 });

packages/bloom/lib/commands/bloom/INFO.ts

@@ -1,11 +1,25 @@
-import { RedisArgument, Command } from '@redis/client/dist/lib/RESP/types';
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, Command, UnwrapReply, NullReply, NumberReply, TuplesToMapReply, Resp2Reply, SimpleStringReply, TypeMapping } from '@redis/client/dist/lib/RESP/types';
+import { transformInfoV2Reply } from '.';
+
+export type BfInfoReplyMap = TuplesToMapReply<[
+  [SimpleStringReply<'Capacity'>, NumberReply],
+  [SimpleStringReply<'Size'>, NumberReply],
+  [SimpleStringReply<'Number of filters'>, NumberReply],
+  [SimpleStringReply<'Number of items inserted'>, NumberReply],
+  [SimpleStringReply<'Expansion rate'>, NullReply | NumberReply] 
+]>;
 
 export default {
-  FIRST_KEY_INDEX: 1,
   IS_READ_ONLY: true,
-  transformArguments(key: RedisArgument) {
-    return ['BF.INFO', key];
+  parseCommand(parser: CommandParser, key: RedisArgument) {
+    parser.push('BF.INFO');
+    parser.pushKey(key);
   },
-  // TODO
-  transformReply: undefined as unknown as () => any
+  transformReply: {
+    2: (reply: UnwrapReply<Resp2Reply<BfInfoReplyMap>>, _, typeMapping?: TypeMapping): BfInfoReplyMap => {
+      return transformInfoV2Reply<BfInfoReplyMap>(reply, typeMapping);
+    },
+    3: undefined as unknown as () => BfInfoReplyMap
+  }
 } as const satisfies Command;

packages/bloom/lib/commands/bloom/INSERT.spec.ts

@@ -1,54 +1,55 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../../test-utils';
 import INSERT from './INSERT';
+import { parseArgs } from '@redis/client/dist/lib/commands/generic-transformers';
 
 describe('BF.INSERT', () => {
   describe('transformArguments', () => {
     it('simple', () => {
       assert.deepEqual(
-        INSERT.transformArguments('key', 'item'),
+        parseArgs(INSERT, 'key', 'item'),
         ['BF.INSERT', 'key', 'ITEMS', 'item']
       );
     });
 
     it('with CAPACITY', () => {
       assert.deepEqual(
-        INSERT.transformArguments('key', 'item', { CAPACITY: 100 }),
+        parseArgs(INSERT, 'key', 'item', { CAPACITY: 100 }),
         ['BF.INSERT', 'key', 'CAPACITY', '100', 'ITEMS', 'item']
       );
     });
 
     it('with ERROR', () => {
       assert.deepEqual(
-        INSERT.transformArguments('key', 'item', { ERROR: 0.01 }),
+        parseArgs(INSERT, 'key', 'item', { ERROR: 0.01 }),
         ['BF.INSERT', 'key', 'ERROR', '0.01', 'ITEMS', 'item']
       );
     });
 
     it('with EXPANSION', () => {
       assert.deepEqual(
-        INSERT.transformArguments('key', 'item', { EXPANSION: 1 }),
+        parseArgs(INSERT, 'key', 'item', { EXPANSION: 1 }),
         ['BF.INSERT', 'key', 'EXPANSION', '1', 'ITEMS', 'item']
       );
     });
 
     it('with NOCREATE', () => {
       assert.deepEqual(
-        INSERT.transformArguments('key', 'item', { NOCREATE: true }),
+        parseArgs(INSERT, 'key', 'item', { NOCREATE: true }),
         ['BF.INSERT', 'key', 'NOCREATE', 'ITEMS', 'item']
       );
     });
 
     it('with NONSCALING', () => {
       assert.deepEqual(
-        INSERT.transformArguments('key', 'item', { NONSCALING: true }),
+        parseArgs(INSERT, 'key', 'item', { NONSCALING: true }),
         ['BF.INSERT', 'key', 'NONSCALING', 'ITEMS', 'item']
       );
     });
 
     it('with CAPACITY, ERROR, EXPANSION, NOCREATE and NONSCALING', () => {
       assert.deepEqual(
-        INSERT.transformArguments('key', 'item', {
+        parseArgs(INSERT, 'key', 'item', {
           CAPACITY: 100,
           ERROR: 0.01,
           EXPANSION: 1,