Merge branch 'v5_to_master' into cmd-parser-with-commands

Author: sjpotter

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

@@ -451,6 +451,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

@@ -942,6 +942,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/HEXPIRE.ts

@@ -1,7 +1,20 @@
 import { CommandParser } from '../client/parser';
-import { ArrayReply, Command, NumberReply, RedisArgument } from '../RESP/types';
+import { ArrayReply, Command, RedisArgument } from '../RESP/types';
 import { RedisVariadicArgument } from './generic-transformers';
 
+export const HASH_EXPIRATION = {
+  /** The field does not exist */
+  FIELD_NOT_EXISTS: -2,
+  /** Specified NX | XX | GT | LT condition not met */
+  CONDITION_NOT_MET: 0,
+  /** Expiration time was set or updated */
+  UPDATED: 1,
+  /** Field deleted because the specified expiration time is in the past */
+  DELETED: 2
+} as const;
+
+export type HashExpiration = typeof HASH_EXPIRATION[keyof typeof HASH_EXPIRATION];
+
 export default {
   parseCommand(
     parser: CommandParser,
@@ -22,5 +35,5 @@ export default {
 
     parser.pushVariadicWithLength(fields);
   },
-  transformReply: undefined as unknown as () => ArrayReply<NumberReply>
+  transformReply: undefined as unknown as () => ArrayReply<HashExpiration>
 } as const satisfies Command;

packages/client/lib/commands/HPERSIST.ts

@@ -14,4 +14,4 @@ export default {
     parser.pushVariadicWithLength(fields);
   },
   transformReply: undefined as unknown as () => ArrayReply<NumberReply> | NullReply
-} as const satisfies Command;
+} as const satisfies Command;

packages/client/lib/commands/HPEXPIRE.ts

@@ -1,6 +1,7 @@
 import { CommandParser } from '../client/parser';
-import { ArrayReply, Command, NullReply, NumberReply, RedisArgument } from '../RESP/types';
+import { ArrayReply, Command, NullReply, RedisArgument } from '../RESP/types';
 import { RedisVariadicArgument } from './generic-transformers';
+import { HashExpiration } from "./HEXPIRE";
 
 export default {
   parseCommand(
@@ -22,5 +23,5 @@ export default {
 
     parser.pushVariadicWithLength(fields);
   },
-  transformReply: undefined as unknown as () => ArrayReply<NumberReply> | NullReply
-} as const satisfies Command;
+  transformReply: undefined as unknown as () => ArrayReply<HashExpiration> | NullReply
+} as const satisfies Command;

packages/client/lib/commands/HPEXPIREAT.ts

@@ -1,6 +1,7 @@
 import { CommandParser } from '../client/parser';
-import { ArrayReply, Command, NullReply, NumberReply, RedisArgument } from '../RESP/types';
+import { ArrayReply, Command, NullReply, RedisArgument } from '../RESP/types';
 import { RedisVariadicArgument, transformPXAT } from './generic-transformers';
+import { HashExpiration } from "./HEXPIRE";
 
 export default {
   IS_READ_ONLY: true,
@@ -23,5 +24,5 @@ export default {
 
     parser.pushVariadicWithLength(fields);
   },
-  transformReply: undefined as unknown as () => ArrayReply<NumberReply> | NullReply
-} as const satisfies Command;
+  transformReply: undefined as unknown as () => ArrayReply<HashExpiration> | NullReply
+} as const satisfies Command;

packages/client/lib/commands/HPEXPIRETIME.ts

@@ -15,4 +15,4 @@ export default {
     parser.pushVariadicWithLength(fields);
   },
   transformReply: undefined as unknown as () => ArrayReply<NumberReply> | NullReply
-} as const satisfies Command;
+} as const satisfies Command;

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

@@ -41,6 +41,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

@@ -4,7 +4,7 @@ import HSCAN_NOVALUES from './HSCAN_NOVALUES';
 import { parseArgs } from './generic-transformers';
 
 describe('HSCAN_NOVALUES', () => {
-  testUtils.isVersionGreaterThanHook([7.4]);
+  testUtils.isVersionGreaterThanHook([7,4]);
 
   describe('transformArguments', () => {
     it('cusror only', () => {
@@ -43,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/AGGREGATE.spec.ts

@@ -21,6 +21,13 @@ describe('AGGREGATE', () => {
       );
     });
 
+    it('with ADDSCORES', () => {
+      assert.deepEqual(
+        parseArgs(AGGREGATE, 'index', '*', { ADDSCORES: true }),
+        ['FT.AGGREGATE', 'index', '*', 'ADDSCORES']
+      );
+    });  
+
     describe('with LOAD', () => {
       describe('single', () => {
         describe('without alias', () => {

packages/search/lib/commands/AGGREGATE.ts

@@ -119,6 +119,7 @@ interface FilterStep extends AggregateStep<FT_AGGREGATE_STEPS['FILTER']> {
 
 export interface FtAggregateOptions {
   VERBATIM?: boolean;
+  ADDSCORES?: boolean;
   LOAD?: LoadField | Array<LoadField>;
   TIMEOUT?: number;
   STEPS?: Array<GroupByStep | SortStep | ApplyStep | LimitStep | FilterStep>;
@@ -168,6 +169,10 @@ export function parseAggregateOptions(parser: CommandParser , options?: FtAggreg
     parser.push('VERBATIM');
   }
 
+  if (options?.ADDSCORES) {
+    parser.push('ADDSCORES');
+  }  
+
   if (options?.LOAD) {
     const args: Array<RedisArgument> = [];
 

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

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