Merge remote-tracking branch 'upstream/master' into test

Author: sjpotter

packages/client/lib/client/index.spec.ts

@@ -450,6 +450,33 @@ describe('Client', () => {
     assert.deepEqual(hash, results);
   }, GLOBAL.SERVERS.OPEN);
 
+  testUtils.testWithClient('hScanNoValuesIterator', async client => {
+    const hash: Record<string, string> = {};
+    const expectedFields: Array<string> = [];
+    for (let i = 0; i < 100; i++) {
+       hash[i.toString()] = i.toString();
+       expectedFields.push(i.toString());
+    }
+
+    await client.hSet('key', hash);
+
+    const actualFields: Array<string> = [];
+    for await (const fields of client.hScanNoValuesIterator('key')) {
+      for (const field of fields) {
+        actualFields.push(field);
+      }
+    }
+
+    function sort(a: string, b: string) {
+      return Number(a) - Number(b);
+    }
+
+    assert.deepEqual(actualFields.sort(sort), expectedFields);
+  }, {
+    ...GLOBAL.SERVERS.OPEN,
+    minimumDockerVersion: [7, 4]
+  });
+
   testUtils.testWithClient('sScanIterator', async client => {
     const members = new Set<string>();
     for (let i = 0; i < 100; i++) {

packages/client/lib/client/index.ts

@@ -927,6 +927,19 @@ export default class RedisClient<
     } while (cursor !== '0');
   }
 
+  async* hScanNoValuesIterator(
+    this: RedisClientType<M, F, S, RESP, TYPE_MAPPING>,
+    key: RedisArgument,
+    options?: ScanCommonOptions & ScanIteratorOptions
+  ) {
+    let cursor = options?.cursor ?? '0';
+    do {
+      const reply = await this.hScanNoValues(key, cursor, options);
+      cursor = reply.cursor;
+      yield reply.fields;
+    } while (cursor !== '0');
+  }
+
   async* sScanIterator(
     this: RedisClientType<M, F, S, RESP, TYPE_MAPPING>,
     key: RedisArgument,

packages/client/lib/commands/HPERSIST.ts

@@ -8,4 +8,4 @@ export default {
     return pushVariadicArgument(['HPERSIST', key, 'FIELDS'], fields);
   },
   transformReply: undefined as unknown as () => ArrayReply<NumberReply> | NullReply
-} as const satisfies Command;
+} as const satisfies Command;

packages/client/lib/commands/HPEXPIRE.ts

@@ -21,4 +21,4 @@ export default {
     return pushVariadicArgument(args, fields);
   },
   transformReply: undefined as unknown as () => ArrayReply<HashExpiration> | NullReply
-} as const satisfies Command;
+} as const satisfies Command;

packages/client/lib/commands/HPEXPIREAT.ts

@@ -21,4 +21,4 @@ export default {
     return pushVariadicArgument(args, fields);
   },
   transformReply: undefined as unknown as () => ArrayReply<HashExpiration> | NullReply
-} as const satisfies Command;
+} as const satisfies Command;

packages/client/lib/commands/HPEXPIRETIME.ts

@@ -8,4 +8,4 @@ export default {
     return pushVariadicArgument(['HPEXPIRETIME', key, 'FIELDS'], fields);
   },
   transformReply: undefined as unknown as () => ArrayReply<NumberReply> | NullReply
-} as const satisfies Command;
+} as const satisfies Command;

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

@@ -40,6 +40,31 @@ describe('HSCAN', () => {
     });
   });
 
+  describe('transformReply', () => {
+    it('without tuples', () => {
+      assert.deepEqual(
+        HSCAN.transformReply(['0' as any, []]),
+        {
+          cursor: '0',
+          entries: []
+        }
+      );
+    });
+    
+    it('with tuples', () => {
+      assert.deepEqual(
+        HSCAN.transformReply(['0' as any, ['field', 'value'] as any]),
+        {
+          cursor: '0',
+          entries: [{
+            field: 'field',
+            value: 'value'
+          }]
+        }
+      );
+    });
+  });
+
   testUtils.testWithClient('client.hScan', async client => {
     const [, reply] = await Promise.all([
       client.hSet('key', 'field', 'value'),

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

@@ -1,9 +1,10 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
 import HSCAN_NOVALUES from './HSCAN_NOVALUES';
+import { BlobStringReply } from '../RESP/types';
 
 describe('HSCAN_NOVALUES', () => {
-  testUtils.isVersionGreaterThanHook([7.4]);
+  testUtils.isVersionGreaterThanHook([7,4]);
 
   describe('transformArguments', () => {
     it('cusror only', () => {
@@ -42,6 +43,29 @@ describe('HSCAN_NOVALUES', () => {
     });
   });
 
+  describe('transformReply', () => {
+    it('without keys', () => {
+      assert.deepEqual(
+        HSCAN_NOVALUES.transformReply(['0' as any, []]),
+        {
+          cursor: '0',
+          fields: []
+        }
+      );
+    });
+
+    it('with keys', () => {
+      assert.deepEqual(
+        HSCAN_NOVALUES.transformReply(['0' as any, ['key1', 'key2'] as any]),
+        {
+           cursor: '0',
+           fields: ['key1', 'key2']
+        }
+      );
+    });
+  });
+
+
   testUtils.testWithClient('client.hScanNoValues', async client => {
     const [, reply] = await Promise.all([
       client.hSet('key', 'field', 'value'),

packages/search/lib/commands/CREATE.spec.ts

@@ -147,6 +147,18 @@ describe('FT.CREATE', () => {
             ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG', 'WITHSUFFIXTRIE']
           );
         });
+
+	it('with INDEXEMPTY', () => {
+          assert.deepEqual(
+            CREATE.transformArguments('index', {
+              field: {
+                type: SCHEMA_FIELD_TYPE.TAG,
+                INDEXEMPTY: true
+              }
+            }),
+            ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG', 'INDEXEMPTY']
+          );
+        });
       });
 
       describe('VECTOR', () => {
@@ -280,6 +292,18 @@ describe('FT.CREATE', () => {
           ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'NOINDEX']
         );
       });
+
+      it('with INDEXMISSING', () => {
+        assert.deepEqual(
+          CREATE.transformArguments('index', {
+            field: {
+              type: SCHEMA_FIELD_TYPE.TEXT,
+              INDEXMISSING: true
+            }
+          }),
+          ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'INDEXMISSING']
+        );
+      });
     });
 
     it('with ON', () => {