[CAE-686] Changed hsetex function signature for better consistency with other commands

Author: htemelski-redis

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

@@ -6,63 +6,63 @@ import HSETEX from './HSETEX';
 describe('HSETEX parseCommand', () => {
   it('hSetEx parseCommand base', () => {
     const parser = new BasicCommandParser;
-    HSETEX.parseCommand(parser, 'key', {}, 'field', 'value');
+    HSETEX.parseCommand(parser, 'key', ['field', 'value']);
     assert.deepEqual(parser.redisArgs, ['HSETEX', 'key', 'FIELDS', '1', 'field', 'value']);
   });
 
   it('hSetEx parseCommand base empty obj', () => {
     const parser = new BasicCommandParser;
-    assert.throws(() => {HSETEX.parseCommand(parser, 'key', {}, {})});
+    assert.throws(() => {HSETEX.parseCommand(parser, 'key', {})});
   });
 
   it('hSetEx parseCommand base one key obj', () => {
     const parser = new BasicCommandParser;
-    HSETEX.parseCommand(parser, 'key', {}, {'k': 'v'});
+    HSETEX.parseCommand(parser, 'key', {'k': 'v'});
     assert.deepEqual(parser.redisArgs, ['HSETEX', 'key', 'FIELDS', '1', 'k', 'v']);
   });
 
   it('hSetEx parseCommand array', () => {
     const parser = new BasicCommandParser;
-    HSETEX.parseCommand(parser, 'key', {}, ['field1', 'value1', 'field2', 'value2']);
+    HSETEX.parseCommand(parser, 'key', ['field1', 'value1', 'field2', 'value2']);
     assert.deepEqual(parser.redisArgs, ['HSETEX', 'key', 'FIELDS', '2', 'field1', 'value1', 'field2', 'value2']);
   });
 
-  it('hSetEx parseCommand array invalid args, thows error', () => {
+  it('hSetEx parseCommand array invalid args, throws an error', () => {
     const parser = new BasicCommandParser;
-    assert.throws(() => {HSETEX.parseCommand(parser, 'key', {}, ['field1', 'value1', 'field2'])});
+    assert.throws(() => {HSETEX.parseCommand(parser, 'key', ['field1', 'value1', 'field2'])});
   });
 
   it('hSetEx parseCommand array in array', () => {
     const parser1 = new BasicCommandParser;
-    HSETEX.parseCommand(parser1, 'key', {}, [['field1', 'value1'], ['field2', 'value2']]);
+    HSETEX.parseCommand(parser1, 'key', [['field1', 'value1'], ['field2', 'value2']]);
     assert.deepEqual(parser1.redisArgs, ['HSETEX', 'key', 'FIELDS', '2', 'field1', 'value1', 'field2', 'value2']);
 
     const parser2 = new BasicCommandParser;
-    HSETEX.parseCommand(parser2, 'key', {}, [['field1', 'value1'], ['field2', 'value2'], ['field3', 'value3']]);
+    HSETEX.parseCommand(parser2, 'key', [['field1', 'value1'], ['field2', 'value2'], ['field3', 'value3']]);
     assert.deepEqual(parser2.redisArgs, ['HSETEX', 'key', 'FIELDS', '3', 'field1', 'value1', 'field2', 'value2', 'field3', 'value3']);
   });
 
   it('hSetEx parseCommand map', () => {
     const parser1 = new BasicCommandParser;
-    HSETEX.parseCommand(parser1, 'key', {}, new Map([['field1', 'value1'], ['field2', 'value2']]));
+    HSETEX.parseCommand(parser1, 'key', new Map([['field1', 'value1'], ['field2', 'value2']]));
     assert.deepEqual(parser1.redisArgs, ['HSETEX', 'key', 'FIELDS', '2', 'field1', 'value1', 'field2', 'value2']);
   });
 
   it('hSetEx parseCommand obj', () => {
     const parser1 = new BasicCommandParser;
-    HSETEX.parseCommand(parser1, 'key', {}, {field1: "value1", field2: "value2"});
+    HSETEX.parseCommand(parser1, 'key', {field1: "value1", field2: "value2"});
     assert.deepEqual(parser1.redisArgs, ['HSETEX', 'key', 'FIELDS', '2', 'field1', 'value1', 'field2', 'value2']);
   });
 
   it('hSetEx parseCommand options FNX KEEPTTL', () => {
     const parser = new BasicCommandParser;
-    HSETEX.parseCommand(parser, 'key', {mode: 'FNX', expiration: 'KEEPTTL'}, 'field', 'value');
+    HSETEX.parseCommand(parser, 'key', ['field', 'value'], {mode: 'FNX', expiration: 'KEEPTTL'});
     assert.deepEqual(parser.redisArgs, ['HSETEX', 'key', 'FNX', 'KEEPTTL', 'FIELDS', '1', 'field', 'value']);
   });
 
   it('hSetEx parseCommand options FXX EX 500', () => {
     const parser = new BasicCommandParser;
-    HSETEX.parseCommand(parser, 'key', {mode: 'FXX', expiration: {type: 'EX', value: 500}}, 'field', 'value');
+    HSETEX.parseCommand(parser, 'key', ['field', 'value'], {mode: 'FXX', expiration: {type: 'EX', value: 500}});
     assert.deepEqual(parser.redisArgs, ['HSETEX', 'key', 'FXX', 'EX', '500', 'FIELDS', '1', 'field', 'value']);
   });
 });
@@ -72,27 +72,27 @@ describe('HSETEX parseCommand', () => {
 describe.skip('HSETEX call', () => {
     testUtils.testWithClientIfVersionWithinRange([[8], 'LATEST'], 'hSetEx calls', async client => {
       assert.deepEqual(
-        await client.hSetEx('key', {expiration: {type: "EX", value: 500}, mode: "FNX"}, 'filed1', 'value1'),
+        await client.hSetEx('key',  ['f1', 'f2'], {expiration: {type: "EX", value: 500}, mode: "FNX"}),
         1
       );
 
       assert.deepEqual(
-        await client.hSetEx('key', {expiration: {type: "EX", value: 500}, mode: "FXX"}, ['filed1', 'value1', 'field2', 'value2']),
+        await client.hSetEx('key', ['field1', 'value1', 'field2', 'value2'], {expiration: {type: "EX", value: 500}, mode: "FXX"}),
         0
       );
 
       assert.deepEqual(
-        await client.hSetEx('key', {expiration: {type: "EX", value: 500}, mode: "FNX"}, ['filed1', 'value1', 'field2', 'value2']),
+        await client.hSetEx('key', ['field1', 'value1', 'field2', 'value2'], {expiration: {type: "EX", value: 500}, mode: "FNX"}),
         1
       );
 
       assert.deepEqual(
-        await client.hSetEx('key', {expiration: {type: "EX", value: 500}, mode: "FNX"}, 'filed2', 'value2'),
+        await client.hSetEx('key', ['field2', 'value2'], {expiration: {type: "EX", value: 500}, mode: "FNX"}),
         1
       );
 
       assert.deepEqual(
-        await client.hSetEx('key', {expiration: {type: "EX", value: 500}, mode: "FXX"}, ['filed1', 'value1', 'field2', 'value2']),
+        await client.hSetEx('key', ['field1', 'value1', 'field2', 'value2'], {expiration: {type: "EX", value: 500}, mode: "FXX"}),
         1
       );
     }, GLOBAL.SERVERS.OPEN);

packages/client/lib/commands/HSETEX.ts

@@ -19,16 +19,12 @@ type HSETEXMap = Map<HashTypes, HashTypes>;
 
 type HSETEXTuples = Array<[HashTypes, HashTypes]> | Array<HashTypes>;
 
-type SingleFieldArguments = [field: HashTypes, value: HashTypes];
-
-type MultipleFieldsArguments = [value: HSETEXObject | HSETEXMap | HSETEXTuples];
-
 export default {
   parseCommand(
     parser: CommandParser,
     key: RedisArgument,
-    options?: HSetExOptions,
-    ...[value, fieldValue]: SingleFieldArguments | MultipleFieldsArguments
+    fields: HSETEXObject | HSETEXMap | HSETEXTuples,
+    options?: HSetExOptions
   ) {
     parser.push('HSETEX');
     parser.pushKey(key);
@@ -50,21 +46,13 @@ export default {
     }
 
     parser.push('FIELDS')
-    if (typeof value === 'string' || typeof value === 'number' || value instanceof Buffer) {
-        parser.push(
-            '1',
-            convertValue(value),
-            convertValue(fieldValue!)
-        );
-      } else if (typeof value === 'undefined' || typeof value === null) {
-        throw Error('passed undefined or null object')
-      } else if (value instanceof Map) {
-        pushMap(parser, value);
-      } else if (Array.isArray(value)) {
-        pushTuples(parser, value);
-      } else {
-        pushObject(parser, value);
-      }
+    if (fields instanceof Map) {
+        pushMap(parser, fields);
+    } else if (Array.isArray(fields)) {
+        pushTuples(parser, fields);
+    } else {
+        pushObject(parser, fields);
+    }
   },
   transformReply: undefined as unknown as () => NumberReply<0 | 1>
 } as const satisfies Command;