use the new parseCommand api

nkaradzhov · nkaradzhov · commit d6c7860b0c51 · 2025-06-24T13:28:13.000+03:00
diff --git a/packages/client/lib/commands/VADD.spec.ts b/packages/client/lib/commands/VADD.spec.ts
@@ -1,51 +1,63 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
 import VADD from './VADD';
-import { parseArgs } from './generic-transformers';
+import { BasicCommandParser } from '../client/parser';
 
 describe('VADD', () => {
-  describe('transformArguments', () => {
+  describe('parseCommand', () => {
     it('basic usage', () => {
+      const parser = new BasicCommandParser();
+      VADD.parseCommand(parser, 'key', [1.0, 2.0, 3.0], 'element');
       assert.deepEqual(
-        parseArgs(VADD, 'key', [1.0, 2.0, 3.0], 'element'),
+        parser.redisArgs,
         ['VADD', 'key', 'VALUES', '3', '1', '2', '3', 'element']
       );
     });
 
     it('with REDUCE option', () => {
+      const parser = new BasicCommandParser();
+      VADD.parseCommand(parser, 'key', [1.0, 2], 'element', { REDUCE: 50 });
       assert.deepEqual(
-        parseArgs(VADD, 'key', [1.0, 2], 'element', { REDUCE: 50 }),
+        parser.redisArgs,
         ['VADD', 'key', 'REDUCE', '50', 'VALUES', '2', '1', '2', 'element']
       );
     });
 
     it('with quantization options', () => {
+      let parser = new BasicCommandParser();
+      VADD.parseCommand(parser, 'key', [1.0, 2.0], 'element', { QUANT: 'Q8' });
       assert.deepEqual(
-        parseArgs(VADD, 'key', [1.0, 2.0], 'element', { QUANT: 'Q8' }),
+        parser.redisArgs,
         ['VADD', 'key', 'VALUES', '2', '1', '2', 'element', 'Q8']
       );
 
+      parser = new BasicCommandParser();
+      VADD.parseCommand(parser, 'key', [1.0, 2.0], 'element', { QUANT: 'BIN' });
       assert.deepEqual(
-        parseArgs(VADD, 'key', [1.0, 2.0], 'element', { QUANT: 'BIN' }),
+        parser.redisArgs,
         ['VADD', 'key', 'VALUES', '2', '1', '2', 'element', 'BIN']
       );
 
+      parser = new BasicCommandParser();
+      VADD.parseCommand(parser, 'key', [1.0, 2.0], 'element', { QUANT: 'NOQUANT' });
       assert.deepEqual(
-        parseArgs(VADD, 'key', [1.0, 2.0], 'element', { QUANT: 'NOQUANT' }),
+        parser.redisArgs,
         ['VADD', 'key', 'VALUES', '2', '1', '2', 'element', 'NOQUANT']
       );
     });
 
     it('with all options', () => {
+      const parser = new BasicCommandParser();
+      VADD.parseCommand(parser, 'key', [1.0, 2.0], 'element', {
+        REDUCE: 50,
+        CAS: true,
+        QUANT: 'Q8',
+        EF: 200,
+        SETATTR: { name: 'test', value: 42 },
+        M: 16
+      });
       assert.deepEqual(
-        parseArgs(VADD, 'key', [1.0, 2.0], 'element', {
-          REDUCE: 50,
-          CAS: true,
-          QUANT: 'Q8',
-          EF: 200,
-          SETATTR: { name: 'test', value: 42 },
-          M: 16
-        }),
+        parser.redisArgs,
         [
           'VADD', 'key', 'REDUCE', '50', 'VALUES', '2', '1', '2', 'element',
           'CAS', 'Q8', 'EF', '200', 'SETATTR', '{"name":"test","value":42}', 'M', '16'
diff --git a/packages/client/lib/commands/VCARD.spec.ts b/packages/client/lib/commands/VCARD.spec.ts
@@ -1,12 +1,14 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
 import VCARD from './VCARD';
-import { parseArgs } from './generic-transformers';
+import { BasicCommandParser } from '../client/parser';
 
 describe('VCARD', () => {
-  it('transformArguments', () => {
+  it('parseCommand', () => {
+    const parser = new BasicCommandParser();
+    VCARD.parseCommand(parser, 'key')
     assert.deepEqual(
-      parseArgs(VCARD, 'key'),
+      parser.redisArgs,
       ['VCARD', 'key']
     );
   });
diff --git a/packages/client/lib/commands/VDIM.spec.ts b/packages/client/lib/commands/VDIM.spec.ts
@@ -1,12 +1,14 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
 import VDIM from './VDIM';
-import { parseArgs } from './generic-transformers';
+import { BasicCommandParser } from '../client/parser';
 
 describe('VDIM', () => {
-  it('transformArguments', () => {
+  it('parseCommand', () => {
+    const parser = new BasicCommandParser();
+    VDIM.parseCommand(parser, 'key');
     assert.deepEqual(
-      parseArgs(VDIM, 'key'),
+      parser.redisArgs,
       ['VDIM', 'key']
     );
   });
diff --git a/packages/client/lib/commands/VEMB.spec.ts b/packages/client/lib/commands/VEMB.spec.ts
@@ -1,12 +1,14 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
 import VEMB from './VEMB';
-import { parseArgs } from './generic-transformers';
+import { BasicCommandParser } from '../client/parser';
 
 describe('VEMB', () => {
-  it('transformArguments', () => {
+  it('parseCommand', () => {
+    const parser = new BasicCommandParser();
+    VEMB.parseCommand(parser, 'key', 'element');
     assert.deepEqual(
-      parseArgs(VEMB, 'key', 'element'),
+      parser.redisArgs,
       ['VEMB', 'key', 'element']
     );
   });
diff --git a/packages/client/lib/commands/VEMB_RAW.spec.ts b/packages/client/lib/commands/VEMB_RAW.spec.ts
@@ -1,12 +1,14 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
 import VEMB_RAW from './VEMB_RAW';
-import { parseArgs } from './generic-transformers';
+import { BasicCommandParser } from '../client/parser';
 
 describe('VEMB_RAW', () => {
-  it('transformArguments', () => {
+  it('parseCommand', () => {
+    const parser = new BasicCommandParser();
+    VEMB_RAW.parseCommand(parser, 'key', 'element');
     assert.deepEqual(
-      parseArgs(VEMB_RAW, 'key', 'element'),
+      parser.redisArgs,
       ['VEMB', 'key', 'element', 'RAW']
     );
   });
diff --git a/packages/client/lib/commands/VGETATTR.spec.ts b/packages/client/lib/commands/VGETATTR.spec.ts
@@ -1,12 +1,14 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
 import VGETATTR from './VGETATTR';
-import { parseArgs } from './generic-transformers';
+import { BasicCommandParser } from '../client/parser';
 
 describe('VGETATTR', () => {
-  it('transformArguments', () => {
+  it('parseCommand', () => {
+    const parser = new BasicCommandParser();
+    VGETATTR.parseCommand(parser, 'key', 'element');
     assert.deepEqual(
-      parseArgs(VGETATTR, 'key', 'element'),
+      parser.redisArgs,
       ['VGETATTR', 'key', 'element']
     );
   });
@@ -23,7 +25,7 @@ describe('VGETATTR', () => {
 
     assert.ok(result !== null);
     assert.equal(typeof result, 'object')
-    
+
     assert.deepEqual(result, {
       name: 'test'
     })
@@ -56,7 +58,7 @@ describe('VGETATTR', () => {
 
     assert.ok(result !== null);
     assert.equal(typeof result, 'object')
-    
+
     assert.deepEqual(result, {
       name: 'test-item',
       category: 'electronics',
diff --git a/packages/client/lib/commands/VINFO.spec.ts b/packages/client/lib/commands/VINFO.spec.ts
@@ -1,12 +1,14 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
 import VINFO from './VINFO';
-import { parseArgs } from './generic-transformers';
+import { BasicCommandParser } from '../client/parser';
 
 describe('VINFO', () => {
-  it('transformArguments', () => {
+  it('parseCommand', () => {
+    const parser = new BasicCommandParser();
+    VINFO.parseCommand(parser, 'key');
     assert.deepEqual(
-      parseArgs(VINFO, 'key'),
+      parser.redisArgs,
       ['VINFO', 'key']
     );
   });
diff --git a/packages/client/lib/commands/VLINKS.spec.ts b/packages/client/lib/commands/VLINKS.spec.ts
@@ -1,12 +1,14 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
 import VLINKS from './VLINKS';
-import { parseArgs } from './generic-transformers';
+import { BasicCommandParser } from '../client/parser';
 
 describe('VLINKS', () => {
-  it('transformArguments', () => {
+  it('parseCommand', () => {
+    const parser = new BasicCommandParser();
+    VLINKS.parseCommand(parser, 'key', 'element');
     assert.deepEqual(
-      parseArgs(VLINKS, 'key', 'element'),
+      parser.redisArgs,
       ['VLINKS', 'key', 'element']
     );
   });
diff --git a/packages/client/lib/commands/VLINKS_WITHSCORES.spec.ts b/packages/client/lib/commands/VLINKS_WITHSCORES.spec.ts
@@ -1,11 +1,13 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
-import { parseArgs } from './generic-transformers';
 import VLINKS_WITHSCORES from './VLINKS_WITHSCORES';
+import { BasicCommandParser } from '../client/parser';
 
 describe('VLINKS WITHSCORES', () => {
-  it('transformArguments', () => {
-    assert.deepEqual(parseArgs(VLINKS_WITHSCORES, 'key', 'element'), [
+  it('parseCommand', () => {
+    const parser = new BasicCommandParser();
+    VLINKS_WITHSCORES.parseCommand(parser, 'key', 'element');
+    assert.deepEqual(parser.redisArgs, [
       'VLINKS',
       'key',
       'element',
diff --git a/packages/client/lib/commands/VRANDMEMBER.spec.ts b/packages/client/lib/commands/VRANDMEMBER.spec.ts
@@ -1,20 +1,24 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
 import VRANDMEMBER from './VRANDMEMBER';
-import { parseArgs } from './generic-transformers';
+import { BasicCommandParser } from '../client/parser';
 
 describe('VRANDMEMBER', () => {
-  describe('transformArguments', () => {
+  describe('parseCommand', () => {
     it('without count', () => {
+      const parser = new BasicCommandParser();
+      VRANDMEMBER.parseCommand(parser, 'key');
       assert.deepEqual(
-        parseArgs(VRANDMEMBER, 'key'),
+        parser.redisArgs,
         ['VRANDMEMBER', 'key']
       );
     });
 
     it('with count', () => {
+      const parser = new BasicCommandParser();
+      VRANDMEMBER.parseCommand(parser, 'key', 2);
       assert.deepEqual(
-        parseArgs(VRANDMEMBER, 'key', 2),
+        parser.redisArgs,
         ['VRANDMEMBER', 'key', '2']
       );
     });
diff --git a/packages/client/lib/commands/VREM.spec.ts b/packages/client/lib/commands/VREM.spec.ts
@@ -1,12 +1,14 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
 import VREM from './VREM';
-import { parseArgs } from './generic-transformers';
+import { BasicCommandParser } from '../client/parser';
 
 describe('VREM', () => {
-  it('transformArguments', () => {
+  const parser = new BasicCommandParser();
+  VREM.parseCommand(parser, 'key', 'element');
+  it('parseCommand', () => {
     assert.deepEqual(
-      parseArgs(VREM, 'key', 'element'),
+      parser.redisArgs,
       ['VREM', 'key', 'element']
     );
   });
diff --git a/packages/client/lib/commands/VSETATTR.spec.ts b/packages/client/lib/commands/VSETATTR.spec.ts
@@ -1,20 +1,24 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
 import VSETATTR from './VSETATTR';
-import { parseArgs } from './generic-transformers';
+import { BasicCommandParser } from '../client/parser';
 
 describe('VSETATTR', () => {
-  describe('transformArguments', () => {
+  describe('parseCommand', () => {
     it('with object', () => {
+      const parser = new BasicCommandParser();
+      VSETATTR.parseCommand(parser, 'key', 'element', { name: 'test', value: 42 }),
       assert.deepEqual(
-        parseArgs(VSETATTR, 'key', 'element', { name: 'test', value: 42 }),
+        parser.redisArgs,
         ['VSETATTR', 'key', 'element', '{"name":"test","value":42}']
       );
     });
 
     it('with string', () => {
+      const parser = new BasicCommandParser();
+      VSETATTR.parseCommand(parser, 'key', 'element', '{"name":"test"}'),
       assert.deepEqual(
-        parseArgs(VSETATTR, 'key', 'element', '{"name":"test"}'),
+        parser.redisArgs,
         ['VSETATTR', 'key', 'element', '{"name":"test"}']
       );
     });
diff --git a/packages/client/lib/commands/VSIM.spec.ts b/packages/client/lib/commands/VSIM.spec.ts
@@ -1,34 +1,40 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
 import VSIM from './VSIM';
-import { parseArgs } from './generic-transformers';
+import { BasicCommandParser } from '../client/parser';
 
 describe('VSIM', () => {
-  describe('transformArguments', () => {
+  describe('parseCommand', () => {
     it('with vector', () => {
+      const parser = new BasicCommandParser();
+      VSIM.parseCommand(parser, 'key', [1.0, 2.0, 3.0]),
       assert.deepEqual(
-        parseArgs(VSIM, 'key', [1.0, 2.0, 3.0]),
+        parser.redisArgs,
         ['VSIM', 'key', 'VALUES', '3', '1', '2', '3']
       );
     });
 
     it('with element', () => {
+      const parser = new BasicCommandParser();
+      VSIM.parseCommand(parser, 'key', 'element');
       assert.deepEqual(
-        parseArgs(VSIM, 'key', 'element'),
+        parser.redisArgs,
         ['VSIM', 'key', 'ELE', 'element']
       );
     });
 
     it('with options', () => {
+      const parser = new BasicCommandParser();
+      VSIM.parseCommand(parser, 'key', 'element', {
+        COUNT: 5,
+        EF: 100,
+        FILTER: '.price > 20',
+        'FILTER-EF': 50,
+        TRUTH: true,
+        NOTHREAD: true
+      });
       assert.deepEqual(
-        parseArgs(VSIM, 'key', 'element', {
-          COUNT: 5,
-          EF: 100,
-          FILTER: '.price > 20',
-          'FILTER-EF': 50,
-          TRUTH: true,
-          NOTHREAD: true
-        }),
+        parser.redisArgs,
         [
           'VSIM', 'key', 'ELE', 'element',
           'COUNT', '5', 'EF', '100', 'FILTER', '.price > 20',
diff --git a/packages/client/lib/commands/VSIM_WITHSCORES.spec.ts b/packages/client/lib/commands/VSIM_WITHSCORES.spec.ts
@@ -1,11 +1,13 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
 import VSIM_WITHSCORES from './VSIM_WITHSCORES';
-import { parseArgs } from './generic-transformers';
+import { BasicCommandParser } from '../client/parser';
 
 describe('VSIM WITHSCORES', () => {
-  it('transformArguments', () => {
-    assert.deepEqual(parseArgs(VSIM_WITHSCORES, 'key', 'element'), [
+  it('parseCommand', () => {
+    const parser = new BasicCommandParser();
+    VSIM_WITHSCORES.parseCommand(parser, 'key', 'element')
+    assert.deepEqual(parser.redisArgs, [
       'VSIM',
       'key',
       'ELE',
