fix BITFIELD command

lib/commands/BITFIELD.spec.ts

@@ -3,88 +3,39 @@ import { TestRedisServers, itWithClient } from '../test-utils';
 import { transformArguments } from './BITFIELD';
 
 describe('BITFIELD', () => {
-    describe('transformArguments', () => {
+    it('transformArguments', () => {
-        it('simple', () => {
         assert.deepEqual(
-                transformArguments('key'),
+            transformArguments('key', [{
-                ['BITFIELD', 'key']
+                operation: 'OVERFLOW',
-            );
+                behavior: 'WRAP'
-        });
+            }, {
-
+                operation: 'GET',
-        it('with GET', () => {
-            assert.deepEqual(
-                transformArguments('key', {
-                    GET: {
                 type: 'i8',
                 offset: 0
-                    }
+            }, {
-                }),
+                operation: 'OVERFLOW',
-                ['BITFIELD', 'key', 'GET', 'i8', '0']
+                behavior: 'SAT'
-            );
+            }, {
-        });
+                operation: 'SET',
-
+                type: 'i16',
-        it('with SET', () => {
+                offset: 1,
-            assert.deepEqual(
-                transformArguments('key', {
-                    SET: {
-                        type: 'i8',
-                        offset: 0,
                 value: 0
-                    }
+            }, {
-                }),
+                operation: 'OVERFLOW',
-                ['BITFIELD', 'key', 'SET', 'i8', '0', '0']
+                behavior: 'FAIL'
+            }, {
+                operation: 'INCRBY',
+                type: 'i32',
+                offset: 2,
+                increment: 1
+            }]),
+            ['BITFIELD', 'key', 'OVERFLOW', 'WRAP', 'GET', 'i8', '0', 'OVERFLOW', 'SAT', 'SET', 'i16', '1', '0', 'OVERFLOW', 'FAIL', 'INCRBY', 'i32', '2', '1']
         );
     });
 
-        it('with INCRBY', () => {
-            assert.deepEqual(
-                transformArguments('key', {
-                    INCRBY: {
-                        type: 'i8',
-                        offset: 0,
-                        increment: 0
-                    }
-                }),
-                ['BITFIELD', 'key', 'INCRBY', 'i8', '0', '0']
-            );
-        });
-
-        it('with OVERFLOW', () => {
-            assert.deepEqual(
-                transformArguments('key', {
-                    OVERFLOW: 'WRAP'
-                }),
-                ['BITFIELD', 'key', 'OVERFLOW', 'WRAP']
-            );
-        });
-
-        it('with GET, SET, INCRBY, OVERFLOW', () => {
-            assert.deepEqual(
-                transformArguments('key', {
-                    GET: {
-                        type: 'i8',
-                        offset: 0
-                    },
-                    SET: {
-                        type: 'i8',
-                        offset: 0,
-                        value: 0
-                    },
-                    INCRBY: {
-                        type: 'i8',
-                        offset: 0,
-                        increment: 0
-                    },
-                    OVERFLOW: 'WRAP'
-                }),
-                ['BITFIELD', 'key', 'GET', 'i8', '0', 'SET', 'i8', '0', '0', 'INCRBY', 'i8', '0', '0', 'OVERFLOW', 'WRAP']
-            );
-        })
-    });
-
     itWithClient(TestRedisServers.OPEN, 'client.bitField', async client => {
         assert.deepEqual(
-            await client.bitField('key'),
+            await client.bitField('key', []),
             []
         );
     });

lib/commands/BITFIELD.ts

@@ -1,4 +1,4 @@
-import { transformReplyNumber } from './generic-transformers';
+import { transformReplyNumberNullArray } from './generic-transformers';
 
 export const FIRST_KEY_INDEX = 1;
 
@@ -6,61 +6,79 @@ export const IS_READ_ONLY = true;
 
 type BitFieldType = string; // TODO 'i[1-64]' | 'u[1-63]'
 
-interface BitFieldOptions {
+interface BitFieldOperation<S extends string> {
-    GET?: {
+    operation: S;
+}
+
+interface BitFieldGetOperation extends BitFieldOperation<'GET'> {
     type: BitFieldType;
     offset: number | string;
-    };
+}
-    SET?: {
+
+interface BitFieldSetOperation extends BitFieldOperation<'SET'> {
     type: BitFieldType;
     offset: number | string;
     value: number;
-    };
+}
-    INCRBY?: {
+
+interface BitFieldIncrByOperation extends BitFieldOperation<'INCRBY'> {
     type: BitFieldType;
     offset: number | string;
     increment: number;
-    };
-    OVERFLOW?: 'WRAP' | 'SAT' | 'FAIL';
 }
 
-export function transformArguments(key: string, options?: BitFieldOptions): Array<string> {
+interface BitFieldOverflowOperation extends BitFieldOperation<'OVERFLOW'> {
+    behavior: string;
+}
+
+type BitFieldOperations = Array<
+    BitFieldGetOperation |
+    BitFieldSetOperation |
+    BitFieldIncrByOperation |
+    BitFieldOverflowOperation
+>;
+
+export function transformArguments(key: string, operations: BitFieldOperations): Array<string> {
     const args = ['BITFIELD', key];
 
-    if (options?.GET) {
+    for (const options of operations) {
+        switch (options.operation) {
+            case 'GET':
                 args.push(
                     'GET',
-            options.GET.type,
+                    options.type,
-            options.GET.offset.toString()
+                    options.offset.toString()
                 );
-    }
+                break;
 
-    if (options?.SET) {
+            case 'SET':
                 args.push(
                     'SET',
-            options.SET.type,
+                    options.type,
-            options.SET.offset.toString(),
+                    options.offset.toString(),
-            options.SET.value.toString()
+                    options.value.toString()
                 );
-    }
+                break;
 
-    if (options?.INCRBY) {
+            case 'INCRBY':
                 args.push(
                     'INCRBY',
-            options.INCRBY.type,
+                    options.type,
-            options.INCRBY.offset.toString(),
+                    options.offset.toString(),
-            options.INCRBY.increment.toString()
+                    options.increment.toString()
-        );
+                )
-    }
+                break;
 
-    if (options?.OVERFLOW) {
+            case 'OVERFLOW':
                 args.push(
                     'OVERFLOW',
-            options.OVERFLOW
+                    options.behavior
                 );
+                break;
+        }
     }
 
     return args;
 }
 
-export const transformReply = transformReplyNumber;
+export const transformReply = transformReplyNumberNullArray;

lib/commands/generic-transformers.ts

@@ -10,6 +10,10 @@ export function transformReplyNumberArray(reply: Array<number>): Array<number> {
     return reply;
 }
 
+export function transformReplyNumberNullArray(reply: Array<number | null>): Array<number | null> {
+    return reply;
+}
+
 export function transformReplyString(reply: string): string {
     return reply;
 }