V5 bringing RESP3, Sentinel and TypeMapping to node-redis

RESP3 Support
   - Some commands responses in RESP3 aren't stable yet and therefore return an "untyped" ReplyUnion.
 
Sentinel

TypeMapping

Correctly types Multi commands

Note: some API changes to be further documented in v4-to-v5.md

packages/search/lib/commands/SPELLCHECK.ts

@@ -1,62 +1,71 @@
-interface SpellCheckTerms {
-    mode: 'INCLUDE' | 'EXCLUDE';
-    dictionary: string;
+import { RedisArgument, CommandArguments, Command, ReplyUnion } from '@redis/client/dist/lib/RESP/types';
+
+export interface Terms {
+  mode: 'INCLUDE' | 'EXCLUDE';
+  dictionary: RedisArgument;
 }
 
-interface SpellCheckOptions {
-    DISTANCE?: number;
-    TERMS?: SpellCheckTerms | Array<SpellCheckTerms>;
-    DIALECT?: number;
+export interface FtSpellCheckOptions {
+  DISTANCE?: number;
+  TERMS?: Terms | Array<Terms>;
+  DIALECT?: number;
 }
 
-export function transformArguments(index: string, query: string, options?: SpellCheckOptions): Array<string> {
+export default {
+  FIRST_KEY_INDEX: undefined,
+  IS_READ_ONLY: true,
+  transformArguments(index: RedisArgument, query: RedisArgument, options?: FtSpellCheckOptions) {
     const args = ['FT.SPELLCHECK', index, query];
 
     if (options?.DISTANCE) {
-        args.push('DISTANCE', options.DISTANCE.toString());
+      args.push('DISTANCE', options.DISTANCE.toString());
     }
 
     if (options?.TERMS) {
-        if (Array.isArray(options.TERMS)) {
-            for (const term of options.TERMS) {
-                pushTerms(args, term);
-            }
-        } else {
-            pushTerms(args, options.TERMS);
+      if (Array.isArray(options.TERMS)) {
+        for (const term of options.TERMS) {
+          pushTerms(args, term);
         }
+      } else {
+        pushTerms(args, options.TERMS);
+      }
     }
 
     if (options?.DIALECT) {
-        args.push('DIALECT', options.DIALECT.toString());
+      args.push('DIALECT', options.DIALECT.toString());
     }
 
     return args;
-}
-
-function pushTerms(args: Array<string>, { mode, dictionary }: SpellCheckTerms): void {
-    args.push('TERMS', mode, dictionary);
-}
+  },
+  transformReply: {
+    2: (rawReply: SpellCheckRawReply): SpellCheckReply => {
+      return rawReply.map(([, term, suggestions]) => ({
+        term,
+        suggestions: suggestions.map(([score, suggestion]) => ({
+          score: Number(score),
+          suggestion
+        }))
+      }));
+    },
+    3: undefined as unknown as () => ReplyUnion,
+  },
+  unstableResp3: true
+} as const satisfies Command;
 
 type SpellCheckRawReply = Array<[
-    _: string,
-    term: string,
-    suggestions: Array<[score: string, suggestion: string]>
+  _: string,
+  term: string,
+  suggestions: Array<[score: string, suggestion: string]>
 ]>;
 
 type SpellCheckReply = Array<{
-    term: string,
-    suggestions: Array<{
-        score: number,
-        suggestion: string
-    }>
+  term: string,
+  suggestions: Array<{
+    score: number,
+    suggestion: string
+  }>
 }>;
 
-export function transformReply(rawReply: SpellCheckRawReply): SpellCheckReply {
-    return rawReply.map(([, term, suggestions]) => ({
-        term,
-        suggestions: suggestions.map(([score, suggestion]) => ({
-            score: Number(score),
-            suggestion
-        }))
-    }));
+function pushTerms(args: CommandArguments, { mode, dictionary }: Terms) {
+  args.push('TERMS', mode, dictionary);
 }