fix #1738 - add support for buffers in HSET

Author: leibale

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

@@ -2,13 +2,22 @@ import { strict as assert } from 'assert';
 import { transformArguments } from './HSET';
 import testUtils, { GLOBAL } from '../test-utils';
 
-describe('HSET', () => {
+describe.only('HSET', () => {
     describe('transformArguments', () => {
-        it('field, value', () => {
-            assert.deepEqual(
-                transformArguments('key', 'field', 'value'),
-                ['HSET', 'key', 'field', 'value']
-            );
+        describe('field, value', () => {
+            it('string', () => {
+                assert.deepEqual(
+                    transformArguments('key', 'field', 'value'),
+                    ['HSET', 'key', 'field', 'value']
+                );
+            });
+
+            it('Buffer', () => {
+                assert.deepEqual(
+                    transformArguments('key', Buffer.from('field'), Buffer.from('value')),
+                    ['HSET', 'key', Buffer.from('field'), Buffer.from('value')]
+                );
+            });
         });
 
         it('Map', () => {

packages/client/lib/commands/HSET.ts

@@ -1,24 +1,27 @@
 import { RedisCommandArguments } from '.';
 
-type HSETObject = Record<string | number, string | number>;
+type Types = string | number | Buffer;
 
-type HSETMap = Map<string | number, string | number>;
+type HSETObject = Record<string | number, Types>;
 
-type HSETTuples = Array<[string, string]> | Array<string>;
+type HSETMap = Map<Types, Types>;
+
+type HSETTuples = Array<[Types, Types]> | Array<Types>;
 
 export const FIRST_KEY_INDEX = 1;
 
-type GenericArguments = [key: string];
+type GenericArguments = [key: string | Buffer];
 
-type SingleFieldArguments = [...generic: GenericArguments, field: string, value: string];
+type SingleFieldArguments = [...generic: GenericArguments, field: Types, value: Types];
 
 type MultipleFieldsArguments = [...generic: GenericArguments, value: HSETObject | HSETMap | HSETTuples];
 
 export function transformArguments(...[ key, value, fieldValue ]: SingleFieldArguments | MultipleFieldsArguments): RedisCommandArguments {
-    const args = ['HSET', key];
+    const args: RedisCommandArguments = ['HSET', key];
 
-    if (typeof value === 'string') {
-        args.push(value, fieldValue!);
+    if (typeof value === 'string' || typeof value === 'number' || Buffer.isBuffer(value)) {
+        pushValue(args, value);
+        pushValue(args, fieldValue!);
     } else if (value instanceof Map) {
         pushMap(args, value);
     } else if (Array.isArray(value)) {
@@ -30,20 +33,36 @@ export function transformArguments(...[ key, value, fieldValue ]: SingleFieldArg
     return args;
 }
 
-function pushMap(args: Array<string>, map: HSETMap): void {
+function pushMap(args: RedisCommandArguments, map: HSETMap): void {
     for (const [key, value] of map.entries()) {
-        args.push(key.toString(), value.toString());
+        pushValue(args, key);
+        pushValue(args, value);
     }
 }
 
-function pushTuples(args: Array<string>, tuples: HSETTuples): void {
-    args.push(...tuples.flat());
+function pushTuples(args: RedisCommandArguments, tuples: HSETTuples): void {
+    for (const tuple of tuples) {
+        if (Array.isArray(tuple)) {
+            pushTuples(args, tuple);
+            continue;
+        }
+
+        pushValue(args, tuple);
+    }
 }
 
-function pushObject(args: Array<string>, object: HSETObject): void {
+function pushObject(args: RedisCommandArguments, object: HSETObject): void {
     for (const key of Object.keys(object)) {
         args.push(key.toString(), object[key].toString());
     }
 }
 
+function pushValue(args: RedisCommandArguments, value: Types): void {
+    args.push(
+        typeof value === 'number' ?
+            value.toString() :
+            value
+    );
+}
+
 export declare function transformReply(): number;