redo resp2 "map" types to return Objects to be resp3 default compatible

+ 'fix' for event 'end' test.

Author: sjpotter

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

@@ -117,15 +117,18 @@ describe('Client', () => {
   });
 
   testUtils.testWithClient('connect, ready and end events', async client => {
+    const p1 = once(client, 'connect');
+    const p2 = once(client, 'ready');
+    const p3 = once(client, 'end');
+
     await Promise.all([
-      once(client, 'connect'),
-      once(client, 'ready'),
+      p1,
+      p2,
       client.connect()
     ]);
 
-    // TODO: This is failing and I don't know why.  when I run manually it seems fine.
     await Promise.all([
-      once(client, 'end'),
+      p3,
       client.close()
     ]);
   }, {

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

@@ -100,20 +100,21 @@ describe('XREAD', () => {
         id: '0-0'
       }),
     ])
-    assert.deepEqual(reply, [{
-        name: 'key',
-        messages: [{
-          id,
-          message: Object.create(null, {
-            field: {
-              value: 'value',
-              configurable: true,
-              enumerable: true
-            }
-          })
-        }]
+
+    const obj = Object.assign(Object.create(null), {
+      'key': [{
+        id: id,
+        message: Object.create(null, {
+          field: {
+            value: 'value',
+            configurable: true,
+            enumerable: true
+          }
+        })
       }]
-    );
+    });
+
+    assert.deepStrictEqual(reply, obj);
   }, {
     client: GLOBAL.SERVERS.OPEN,
     cluster: GLOBAL.CLUSTERS.OPEN

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

@@ -123,10 +123,9 @@ describe('XREADGROUP', () => {
       })
     ]);
 
-    assert.deepEqual(readGroupReply, [{
-      name: 'key',
-      messages: [{
-        id,
+    const obj = Object.assign(Object.create(null), {
+      'key': [{
+        id: id,
         message: Object.create(null, {
           field: {
             value: 'value',
@@ -135,7 +134,9 @@ describe('XREADGROUP', () => {
           }
         })
       }]
-    }]);
+    });
+
+    assert.deepStrictEqual(readGroupReply, obj);
   }, {
     client: GLOBAL.SERVERS.OPEN,
     cluster: GLOBAL.CLUSTERS.OPEN

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

@@ -468,52 +468,58 @@ export function transformStreamMessagesReply(r: ArrayReply<StreamMessageRawReply
 type StreamMessagesRawReply = TuplesReply<[name: BlobStringReply, ArrayReply<StreamMessageRawReply>]>;
 type StreamsMessagesRawReply2 = ArrayReply<StreamMessagesRawReply>;
 
-export function transformStreamsMessagesReplyResp2(reply: UnwrapReply<StreamsMessagesRawReply2> | UnwrapReply<NullReply>): StreamsMessagesReply | null {
-  if (reply === null) return null;
+export function transformStreamsMessagesReplyResp2(
+  reply: UnwrapReply<StreamsMessagesRawReply2 | NullReply>
+): Record<string, StreamMessagesReply> | NullReply {
+  if (reply === null) return null as unknown as NullReply;
 
-  return reply.map((s) => {
-    const stream = s as unknown as UnwrapReply<typeof s>;
+  const ret: Record<string, StreamMessagesReply> = Object.create(null);
 
-    return {
-      name: stream[0],
-      messages: transformStreamMessagesReply(stream[1])
-    }
-  })
+  for (let i=0; i < reply.length; i ++) {
+    const stream = reply[i] as unknown as UnwrapReply<StreamMessagesRawReply>;
+
+    const name = stream[0] as unknown as UnwrapReply<BlobStringReply>;
+    const rawMessages = stream[1];
+
+    ret[name.toString()] = transformStreamMessagesReply(rawMessages);
+  }
+
+  return ret;
 }
 
 type StreamsMessagesRawReply3 = MapReply<BlobStringReply, ArrayReply<StreamMessageRawReply>>;
 
-export function transformStreamsMessagesReplyResp3(reply: UnwrapReply<StreamsMessagesRawReply3> | UnwrapReply<NullReply>): StreamsMessagesReply | null {
-  if (reply === null) return null;
+export function transformStreamsMessagesReplyResp3(reply: UnwrapReply<StreamsMessagesRawReply3 | NullReply>): MapReply<BlobStringReply, StreamMessagesReply> | NullReply {
+  if (reply === null) return null as unknown as NullReply;
 
-  const ret: StreamsMessagesReply = [];
   if (reply instanceof Map) {
-    for (const [name, rawMessages] of reply) {
-      ret.push({
-        name,
-        messages: transformStreamMessagesReply(rawMessages),
-      })
+    const ret = new Map<string, StreamMessagesReply>();
+
+    for (const [n, rawMessages] of reply) {
+      const name = n as unknown as UnwrapReply<BlobStringReply>;
+
+      ret.set(name.toString(), transformStreamMessagesReply(rawMessages));
     }
 
-    return ret;
+    return ret as unknown as MapReply<BlobStringReply, StreamMessagesReply>
   } else if (reply instanceof Array) {
+    const ret = [];
+
     for (let i=0; i < reply.length; i += 2) {
-      const name = reply[i] as BlobStringReply
+      const name = reply[i] as BlobStringReply;
       const rawMessages = reply[i+1] as ArrayReply<StreamMessageRawReply>;
 
-      ret.push({
-        name,
-        messages: transformStreamMessagesReply(rawMessages)
-      });
+      ret.push(name);
+      ret.push(transformStreamMessagesReply(rawMessages));
     }
+
+    return ret as unknown as MapReply<BlobStringReply, StreamMessagesReply>
   } else {
+    const ret = Object.create(null);
     for (const [name, rawMessages] of Object.entries(reply)) {
-      ret.push({
-        name,
-        messages: transformStreamMessagesReply(rawMessages),
-      })
+      ret[name] = transformStreamMessagesReply(rawMessages);
     }
-  }
 
-  return ret;
-}
+    return ret as unknown as MapReply<BlobStringReply, StreamMessagesReply>
+  }
+}

packages/time-series/lib/commands/MGET.spec.ts

@@ -29,12 +29,15 @@ describe('TS.MGET', () => {
       client.ts.mGet('label=value')
     ]);
 
-    assert.deepEqual(reply, [{
-      key: 'key',
-      sample: {
-        timestamp: 0,
-        value: 0
+    const obj = Object.assign(Object.create(null), {
+      'key': {
+        sample: {
+          timestamp: 0,
+          value: 0
+        }
       }
-    }]);
+    });
+
+    assert.deepStrictEqual(reply, obj);
   }, GLOBAL.SERVERS.OPEN);
 });

packages/time-series/lib/commands/MGET.ts

@@ -1,6 +1,6 @@
 import { CommandArguments, Command, BlobStringReply, ArrayReply, UnwrapReply, Resp2Reply, MapReply, TuplesReply } from '@redis/client/dist/lib/RESP/types';
 import { RedisVariadicArgument, pushVariadicArguments } from '@redis/client/dist/lib/commands/generic-transformers';
-import { RawLabels2, RawLabels3, resp3MapToValue, SampleRawReply, transformSampleReply } from '.';
+import { RawLabels2, RawLabels3, resp2MapToValue, resp3MapToValue, SampleRawReply, transformSampleReply } from '.';
 
 export interface TsMGetOptions {
   LATEST?: boolean;
@@ -19,11 +19,13 @@ export function pushFilterArgument(args: CommandArguments, filter: RedisVariadic
   return pushVariadicArguments(args, filter);
 }
 
-export type MGetRawReply2 = ArrayReply<[
+export type MGetRawReplyValue2 = TuplesReply<[
   key: BlobStringReply,
   labels: RawLabels2,
   sample: Resp2Reply<SampleRawReply>
-]>;
+]>
+
+export type MGetRawReply2 = ArrayReply<MGetRawReplyValue2>;
 
 export type MGetRawReplyValue3 = TuplesReply<[
   labels: RawLabels3,
@@ -45,15 +47,16 @@ export interface MGetReply3 {
   sample: ReturnType<typeof transformSampleReply[3]>;
 }
 
-export function parseResp3Mget(
-  key: BlobStringReply | string,
-  value: UnwrapReply<MGetRawReplyValue3>
-): MGetReply3 {
-
+export function parseResp3Mget(value: UnwrapReply<MGetRawReplyValue3>) {
   return {
-    key: key,
     sample: transformSampleReply[3](value[1])
-  }
+  };
+}
+
+export function parseResp2Mget(value: UnwrapReply<MGetRawReplyValue2>) {
+  return {
+    sample: transformSampleReply[2](value[2])
+  };
 }
 
 export default {
@@ -64,13 +67,10 @@ export default {
     return pushFilterArgument(args, filter);
   },
   transformReply: {
-    2(reply: UnwrapReply<MGetRawReply2>): Array<MGetReply2> {
-      return reply.map(([key, _, sample]) => ({
-        key: key,
-        sample: transformSampleReply[2](sample)
-      }));
+    2(reply: UnwrapReply<MGetRawReply2>) {
+      return resp2MapToValue(reply, parseResp2Mget);
     },
-    3(reply: UnwrapReply<MGetRawReply3>): Array<MGetReply3> {
+    3(reply: UnwrapReply<MGetRawReply3>) {
       return resp3MapToValue(reply, parseResp3Mget)
     }
   }

packages/time-series/lib/commands/MGET_WITHLABELS.spec.ts

@@ -29,13 +29,16 @@ describe('TS.MGET_WITHLABELS', () => {
       client.ts.mGetWithLabels('label=value')
     ]);
 
-    assert.deepEqual(reply, [{
-      key: 'key',
-      labels: { label: 'value' },
-      sample: {
-        timestamp: 0,
-        value: 0
+    const obj = Object.assign(Object.create(null), {
+      'key': {
+        labels: { label: 'value' },
+        sample: {
+          timestamp: 0,
+          value: 0
+        }
       }
-    }]);
+    });
+    
+    assert.deepStrictEqual(reply, obj);
   }, GLOBAL.SERVERS.OPEN);
 });

packages/time-series/lib/commands/MGET_WITHLABELS.ts

@@ -1,7 +1,7 @@
-import { BlobStringReply, Command, UnwrapReply } from '@redis/client/dist/lib/RESP/types';
+import { Command, UnwrapReply } from '@redis/client/dist/lib/RESP/types';
 import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
-import { TsMGetOptions, pushLatestArgument, pushFilterArgument, MGetReply2, MGetRawReply2, MGetReply3, MGetRawReplyValue3, MGetRawReply3, parseResp3Mget } from './MGET';
-import { Labels, pushWithLabelsArgument, resp3MapToValue, transformLablesReply2, transformLablesReply3, transformSampleReply } from '.';
+import { TsMGetOptions, pushLatestArgument, pushFilterArgument, MGetReply2, MGetRawReply2, MGetReply3, MGetRawReplyValue3, MGetRawReply3, parseResp3Mget, parseResp2Mget, MGetRawReplyValue2 } from './MGET';
+import { Labels, pushWithLabelsArgument, resp2MapToValue, resp3MapToValue, transformLablesReply2, transformLablesReply3 } from '.';
 
 export interface TsMGetWithLabelsOptions extends TsMGetOptions {
   SELECTED_LABELS?: RedisVariadicArgument;
@@ -15,11 +15,17 @@ export interface MGetWithLabelsReply3 extends MGetReply3 {
   labels: Labels;
 };
 
-function parseResp3MgetWithLabels(
-  key: BlobStringReply | string,
-  value: UnwrapReply<MGetRawReplyValue3>
+function parseResp2MgetWithLabels(
+  value: UnwrapReply<MGetRawReplyValue2>,
 ): MGetWithLabelsReply3 {
-  const ret = parseResp3Mget(key, value) as MGetWithLabelsReply3;
+  const ret = parseResp2Mget(value) as unknown as MGetWithLabelsReply3;
+  ret.labels = transformLablesReply2(value[1]);
+
+  return ret;
+}
+
+function parseResp3MgetWithLabels(value: UnwrapReply<MGetRawReplyValue3>): MGetWithLabelsReply3 {
+  const ret = parseResp3Mget(value) as MGetWithLabelsReply3;
   ret.labels = transformLablesReply3(value[0]);
 
   return ret;
@@ -34,15 +40,11 @@ export default {
     return pushFilterArgument(args, filter);
   },
   transformReply: {
-    2(reply: UnwrapReply<MGetRawReply2>): Array<MGetWithLabelsReply2> {
-      return reply.map(([key, labels, sample]) => ({
-          key: key,
-          labels: transformLablesReply2(labels),
-          sample: transformSampleReply[2](sample)
-      }));
+    2(reply: UnwrapReply<MGetRawReply2>) {
+      return resp2MapToValue(reply, parseResp2MgetWithLabels);
     },
-    3(reply: UnwrapReply<MGetRawReply3>): Array<MGetReply3> {
-      return resp3MapToValue(reply, parseResp3MgetWithLabels)
+    3(reply: UnwrapReply<MGetRawReply3>) {
+      return resp3MapToValue(reply, parseResp3MgetWithLabels);
     }
   },
 } as const satisfies Command;

packages/time-series/lib/commands/MRANGE.spec.ts

@@ -2,9 +2,17 @@ import { strict as assert } from 'node:assert';
 import testUtils, { GLOBAL } from '../test-utils';
 import MRANGE, { TIME_SERIES_REDUCERS } from './MRANGE';
 import { TIME_SERIES_AGGREGATION_TYPE } from './CREATERULE';
+import { CommandArguments } from '@redis/client/lib/RESP/types';
 
 describe('TS.MRANGE', () => {
   it('transformArguments', () => {
+    const expectedReply: CommandArguments = [
+      'TS.MRANGE', '-', '+', 'FILTER_BY_TS', '0', 'FILTER_BY_VALUE', '0', '1',
+      'COUNT', '1', 'ALIGN', '-', 'AGGREGATION', 'AVG', '1', 'FILTER', 'label=value',
+      'GROUPBY', 'label', 'REDUCE', 'SUM'
+    ];
+    expectedReply.preserve = true;
+    
     assert.deepEqual(
       MRANGE.transformArguments('-', '+', 'label=value', {
         FILTER_BY_TS: [0],
@@ -23,11 +31,7 @@ describe('TS.MRANGE', () => {
           reducer: TIME_SERIES_REDUCERS.SUM
         },
       }),
-      [
-        'TS.MRANGE', '-', '+', 'FILTER_BY_TS', '0', 'FILTER_BY_VALUE', '0', '1',
-        'COUNT', '1', 'ALIGN', '-', 'AGGREGATION', 'AVG', '1', 'FILTER', 'label=value',
-        'GROUPBY', 'label', 'REDUCE', 'SUM'
-      ]
+      expectedReply
     );
   });
 
@@ -43,12 +47,15 @@ describe('TS.MRANGE', () => {
       })
     ]);
 
-    assert.deepEqual(reply, [{
-      key: 'key',
-      samples: [{
-        timestamp: 0,
-        value: 0
-      }]
-    }]);
+    const obj = Object.assign(Object.create(null), {
+      'key': {
+        samples: [{
+          timestamp: 0,
+          value: 0
+        }]
+      }
+    });
+
+    assert.deepStrictEqual(reply, obj);
   }, GLOBAL.SERVERS.OPEN);
 });