Merge branch 'v5-search-broken' into cmd-parser-with-commands

Author: sjpotter

.github/workflows/tests.yml

@@ -33,7 +33,7 @@ jobs:
       - name: Install Packages
         run: npm ci
       - name: Build
-        run: npm run build -- ./packages/client ./packages/test-utils ./packages/bloom ./packages/graph ./packages/json ./packages/search ./packages/time-series ./packages/redis
+        run: npm run build
       - name: Run Tests
         run: npm run test -ws --if-present -- --forbid-only --redis-version=${{ matrix.redis-version }}
       - name: Upload to Codecov

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

@@ -389,11 +389,10 @@ describe('Client', () => {
   ): Promise<void> {
     const onceErrorPromise = once(errorClient, 'error');
     await client.sendCommand(['QUIT']);
-    await onceErrorPromise;
-//    await Promise.all([
-//      onceErrorPromise,
-//      assert.rejects(client.ping(), SocketClosedUnexpectedlyError)
-//    ]);
+    await Promise.all([
+      onceErrorPromise,
+      assert.rejects(client.ping())
+    ]);
   }
 
   testUtils.testWithClient('should reconnect when socket disconnects', async client => {

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

@@ -64,7 +64,7 @@ describe('HELLO', () => {
     assert.equal(typeof reply.id, 'number');
     assert.equal(reply.mode, 'standalone');
     assert.equal(reply.role, 'master');
-    assert.equal('modules' in reply, true);
+    assert.ok(reply.modules instanceof Array);
   }, {
     ...GLOBAL.SERVERS.OPEN,
     minimumDockerVersion: [6, 2]

packages/client/lib/commands/generic-transformers.ts

@@ -104,6 +104,10 @@ export const transformNullableDoubleReply = {
   3: undefined as unknown as () => DoubleReply | NullReply
 };
 
+export interface Stringable {
+  toString(): string;
+}
+
 export function transformTuplesToMap<T>(
   reply: UnwrapReply<ArrayReply<any>>,
   func: (elem: any) => T,
@@ -117,42 +121,42 @@ export function transformTuplesToMap<T>(
   return message;
 }
 
-export function createTransformTuplesReplyFunc(preserve?: any, typeMapping?: TypeMapping) {
-  return (reply: ArrayReply<BlobStringReply>) => {
-    return transformTuplesReply(reply, preserve, typeMapping);
+export function createTransformTuplesReplyFunc<T extends Stringable>(preserve?: any, typeMapping?: TypeMapping) {
+  return (reply: ArrayReply<T>) => {
+    return transformTuplesReply<T>(reply, preserve, typeMapping);
   };
 }
 
-export function transformTuplesReply(
-  reply: ArrayReply<BlobStringReply>,
+export function transformTuplesReply<T extends Stringable>(
+  reply: ArrayReply<T>,
   preserve?: any,
   typeMapping?: TypeMapping
-): MapReply<BlobStringReply, BlobStringReply> {
+): MapReply<T , T> {
   const mapType = typeMapping ? typeMapping[RESP_TYPES.MAP] : undefined;
 
   const inferred = reply as unknown as UnwrapReply<typeof reply>
 
   switch (mapType) {
     case Array: {
-      return reply as unknown as MapReply<BlobStringReply, BlobStringReply>;
+      return reply as unknown as MapReply<T, T>;
     }
     case Map: {
       const ret = new Map<string, BlobStringReply>;
 
       for (let i = 0; i < inferred.length; i += 2) {
-        ret.set(inferred[i].toString(), inferred[i + 1]);
+        ret.set(inferred[i].toString(), inferred[i + 1] as any);
       }
 
-      return ret as unknown as MapReply<BlobStringReply, BlobStringReply>;;
+      return ret as unknown as MapReply<T, T>;;
     }
     default: {
       const ret: Record<string, BlobStringReply> = Object.create(null);
 
       for (let i = 0; i < inferred.length; i += 2) {
-        ret[inferred[i].toString()] = inferred[i + 1];
+        ret[inferred[i].toString()] = inferred[i + 1] as any;
       }
 
-      return ret as unknown as MapReply<BlobStringReply, BlobStringReply>;;
+      return ret as unknown as MapReply<T, T>;;
     }
   }
 }

packages/client/lib/sentinel/commands/SENTINEL_MASTER.ts

@@ -7,7 +7,7 @@ export default {
     parser.push('SENTINEL', 'MASTER', dbname);
   },
   transformReply: {
-    2: transformTuplesReply,
+    2: transformTuplesReply<BlobStringReply>,
     3: undefined as unknown as () => MapReply<BlobStringReply, BlobStringReply>
   }
 } as const satisfies Command;

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

@@ -1,6 +1,6 @@
 import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
-import INFO from './INFO';
+import INFO, { InfoReply } from './INFO';
 import { SCHEMA_FIELD_TYPE } from './CREATE';
 import { parseArgs } from '@redis/client/lib/commands/generic-transformers';
 
@@ -16,7 +16,94 @@ describe('INFO', () => {
         await client.ft.create('index', {
             field: SCHEMA_FIELD_TYPE.TEXT
         });
-        // just test that it doesn't throw an error
-        await client.ft.info('index');
+        const ret = await client.ft.info('index');
+        assert.deepEqual(ret.stopWords, undefined);
+        assert.deepEqual(
+            ret,
+            {
+                indexName: 'index',
+                indexOptions: [],
+                indexDefinition: Object.create(null, {
+                    default_score: {
+                        value: '1',
+                        configurable: true,
+                        enumerable: true
+                    },
+                    key_type: {
+                        value: 'HASH',
+                        configurable: true,
+                        enumerable: true
+                    },
+                    prefixes: {
+                        value: [''],
+                        configurable: true,
+                        enumerable: true
+                    }
+                }),
+                attributes: [Object.create(null, {
+                    identifier: {
+                        value: 'field',
+                        configurable: true,
+                        enumerable: true
+                    },
+                    attribute: {
+                        value: 'field',
+                        configurable: true,
+                        enumerable: true
+                    },
+                    type: {
+                        value: 'TEXT',
+                        configurable: true,
+                        enumerable: true
+                    },
+                    WEIGHT: {
+                        value: '1',
+                        configurable: true,
+                        enumerable: true
+                    }
+                })],
+                numDocs: 0,
+                maxDocId: 0,
+                numTerms: 0,
+                numRecords: 0,
+                invertedSzMb: 0,
+                vectorIndexSzMb: 0,
+                totalInvertedIndexBlocks: 0,
+                offsetVectorsSzMb: 0,
+                docTableSizeMb: 0,
+                sortableValuesSizeMb: 0,
+                keyTableSizeMb: 0,
+                recordsPerDocAvg: NaN,
+                bytesPerRecordAvg: NaN,
+                cleaning: 0,
+                offsetsPerTermAvg: NaN,
+                offsetBitsPerRecordAvg: NaN,
+                geoshapeSizeMb: 0,
+                hashIndexingFailures: 0,
+                indexing: 0,
+                percentIndexed: 1,
+                numberOfUses: 1,
+                tagOverheadSizeMb: 0,
+                textOverheadSizeMb: 0,
+                totalIndexMemorySizeMb: 0,
+                totalIndexingTime: 0,
+                gcStats: {
+                    bytesCollected: 0,
+                    totalMsRun: 0,
+                    totalCycles: 0,
+                    averageCycleTimeMs: NaN,
+                    lastRunTimeMs: 0,
+                    gcNumericTreesMissed: 0,
+                    gcBlocksDenied: 0
+                },
+                cursorStats: {
+                    globalIdle: 0,
+                    globalTotal: 0,
+                    indexCapacity: 128,
+                    indexTotal: 0
+                },
+            }
+        );
+
     }, GLOBAL.SERVERS.OPEN);
 });