fix reply parshing

packages/client/lib/commands/COMMAND_DOCS.ts

@@ -3,36 +3,126 @@ import { pushVerdictArguments } from './generic-transformers';
 
 export const IS_READ_ONLY = true;
 
-export function transformArguments(keys: string | Array<string>): RedisCommandArguments {
-    return pushVerdictArguments(['COMMAND', 'DOCS'], keys);
-}
+export function transformArguments(...commandNames: Array<string>): RedisCommandArguments {
+    const args = ['COMMAND', 'DOCS'];
 
-type CommandDocumentation = {
-    summary: string;
-    since: string;
-    group: string;
-    complexity: string;
-    history?: Array<[version: string, feature: string]>;
-};
-
-type CommandDocsReply = Array<[CommandName: string, CommandDocumentation: CommandDocumentation]>;
-
-export function transformReply(rawReply: Array<any>): CommandDocsReply {
-    const replyArray:CommandDocsReply = [];
-
-    for (let i = 0; i < rawReply.length; i++) {
-        
-        replyArray.push([
-            rawReply[i++], // The name of the command
-            {
-                summary: rawReply[i][1],
-                since: rawReply[i][3],
-                group: rawReply[i][5],
-                complexity: rawReply[i][7],
-                history: rawReply[i][8] == 'history' ? rawReply[i][9] : null
-            }
-        ]);
+    if (commandNames) {
+        pushVerdictArguments(args, commandNames);
     }
 
-    return replyArray;
+    return args;
+}
+
+interface ArgumentsDoc {
+    keySpecIndex?: number;
+    type?: string;
+    token?: string;
+    summary?: string;
+    flags?: Array<string>;
+}
+
+interface ArgumentsDocsReply {
+    [name: string]: ArgumentsDoc;
+}
+
+interface Doc {
+    summary?: string;
+    since?: string;
+    group?: string;
+    complexity?: string;
+    history?: Array<{
+        version: string;
+        description: string;
+    }>;
+    arguments?: ArgumentsDocsReply;
+    subCommands?: CommandDocsReply;
+}
+
+interface CommandDocsReply {
+    [command: string]: Doc;
+}
+
+export function transformReply(rawReply: Array<any>): CommandDocsReply {
+    const reply:CommandDocsReply = {};
+
+    for (let i = 0; i < rawReply.length; i++) {
+        reply[rawReply[i++]] = createDocumentationInterface(rawReply[i]);
+    }
+
+    return reply;
+}
+
+function createDocumentationInterface(rawDocumentation: Array<any>): Doc {
+    const doc:Doc = {}
+
+    for (let j = 0; j < rawDocumentation.length; j++) {
+        switch (rawDocumentation[j++]) {
+            case 'summary':
+                doc['summary'] = rawDocumentation[j];
+                break;
+            case 'since':
+                doc['since'] = rawDocumentation[j];
+                break;
+            case 'group':
+                doc['group'] = rawDocumentation[j];
+                break;
+            case 'complexity':
+                doc['complexity'] = rawDocumentation[j];
+                break;
+            case 'history':
+                const historyArray = []
+                for (let k = 0; k < rawDocumentation[j].length; k++) {
+                    historyArray.push({
+                        version: rawDocumentation[j][k][0],
+                        description: rawDocumentation[j][k][1]
+                    });
+                }
+                doc['history'] = historyArray;
+                break;
+            case 'arguments':
+                doc['arguments'] = createArgumentsDocumentation(rawDocumentation[j]);
+                break;
+            case 'subcommands':
+                doc['subCommands'] = transformReply(rawDocumentation[j]);
+                break;
+        }
+    }
+
+    return doc;
+}
+
+function createArgumentsDocumentation(rawDocumentation: Array<any>): ArgumentsDocsReply {
+    const doc:ArgumentsDocsReply = {}
+
+    for (let k = 0; k < rawDocumentation.length; k++) {
+        let argumentName = "";
+        const argumentData:ArgumentsDoc = {};
+        
+        for (let l = 0; l < rawDocumentation[k].length; l++) {
+            switch (rawDocumentation[k][l++]) {
+                case 'name':
+                    argumentName = rawDocumentation[k][l];
+                    break;
+                case 'type':
+                    argumentData['type'] = rawDocumentation[k][l];
+                    break;
+                case 'token':
+                    argumentData['token'] = rawDocumentation[k][l];
+                    break;
+                case 'summary':
+                    argumentData['summary'] = rawDocumentation[k][l];
+                    break;
+                case 'flags':
+                    argumentData['flags'] = rawDocumentation[k][l];
+                    break;
+                case 'key_spec_index':
+                    argumentData['keySpecIndex'] = rawDocumentation[k][l];
+                    break;
+            }
+        }
+
+        doc[argumentName] = argumentData;
+    }
+
+    return doc;
 }