feat(redis): update redis commands (#120)

this updates both the https://github.com/antirez/redis-doc and https://github.com/NodeRedis/redis-commands dependencies.

fixes #46

Mostly the changes are new commands, but some function can now be called like client.hset('myhash', ['field1', 'Hello']) rather than client.hset('myhash', 'field1', 'Hello'). This allows setting multiple fields, e.g. client.hset('myhash', ['field1', 'Hello'], ['field2', 'Goodbye']).

The last arg of setbit can also now be number, rather than a string. Likely the string form will be dropped in the next major version.

See the diff from the PR merging this change for examples in the snapshot tests.

Author: mmkal

README.md

@@ -14,7 +14,7 @@ This package is a wrapper around node_redis and exclusively uses Promises. It pu
 ## Usage
 
 ```cli
-npm install --save handy-redis
+npm install --save redis handy-redis
 ```
 
 ES6/TypeScript:
@@ -47,6 +47,8 @@ client
 The package is published with TypeScript types, with the redis documentation and response type attached to each command:
 ![](./docs/intellisense.png)
 
+Note: the [redis](https://npmjs.com/package/redis) package is listed as a peer dependency, so should be installed separately. If you need to use recent redis commands (e.g. `xadd` (recent at time of writing, at least)), you can run `npm install redis-commands` to tell the `redis` package to use more up-to-date commands than [redis](https://npmjs.com/package/redis) pulls in by default.
+
 ### Examples
 
 See the [snapshot tests](https://github.com/mmkal/handy-redis/blob/master/test/generated/commands/__snapshots__) for tons of usage examples.

package-lock.json

@@ -79,6 +79,7 @@
     "lodash": "^4.17.14",
     "npm-run-all": "^4.1.5",
     "prettier": "^1.14.2",
+    "redis-commands": "^1.5.0",
     "semantic-release": "^15.13.16",
     "shelljs": "^0.8.3",
     "shx": "^0.3.2",

package.json

@@ -7,7 +7,7 @@ import { log, warn, error } from "./log";
 export const getExampleRuns = async () => {
     const examples = getCliExamples();
     const redisCli = spawn("docker", ["exec", "-i", "handy_redis", "redis-cli", "--no-raw"], { env: process.env });
-    redisCli.stdin.setDefaultEncoding("utf-8");
+    redisCli.stdin!.setDefaultEncoding("utf-8");
     const redisInteractor = {
         onstdout: (data: string) => log(data),
         onstderr: (data: string) => warn(data),
@@ -21,12 +21,12 @@ export const getExampleRuns = async () => {
                 resolve(parseCommandOutput(command, null, data));
             };
             log(">", command);
-            redisCli.stdin.write(`${command}\n`);
+            redisCli.stdin!.write(`${command}\n`);
         }),
     };
 
-    redisCli.stdout.on("data", data => redisInteractor.onstdout(data.toString()));
-    redisCli.stderr.on("data", data => redisInteractor.onstderr(data.toString()));
+    redisCli.stdout!.on("data", data => redisInteractor.onstdout(data.toString()));
+    redisCli.stderr!.on("data", data => redisInteractor.onstderr(data.toString()));
 
     const runs = new Array<CliExampleRun>();
     for (const example of examples) {

scripts/cli-examples.ts

@@ -42,14 +42,13 @@ const typeFor = (arg: Argument): string => {
 const buildTypeScriptCommandInfo = (name: string, command: Command): BasicCommandInfo[] => {
     const baseArgs = (command.arguments || []).map((a, index, all) => {
         const nameParts = new Array<string | number>();
-        if (a.name) {
-            nameParts.push(a.name);
+        if (a.command) {
+            nameParts.push(a.command);
         }
-        const previousArgsWithSameName = all
-            .slice(0, index)
-            .filter(other => other !== a && other.name === a.name);
-        if (a.command && (nameParts.length === 0 || previousArgsWithSameName.length > 0)) {
-            nameParts.unshift(a.command);
+        if (Array.isArray(a.name)) {
+            nameParts.push(...a.name);
+        } else if (a.name && a.name.toUpperCase() !== a.command) {
+            nameParts.push(a.name);
         }
         const argJson = JSON.stringify(a);
         if (all.map(other => JSON.stringify(other)).indexOf(argJson) !== index) {
@@ -59,7 +58,10 @@ const buildTypeScriptCommandInfo = (name: string, command: Command): BasicComman
             nameParts.push("arg");
             nameParts.push(index);
         }
-        const argName = nameParts.join("_").replace(/\W/g, "_");
+        const argName = nameParts
+            .map(p => _.camelCase(p.toString()))
+            .join("_")
+            .replace(/idOr$/, "idOr$");
         return {
             ...a,
             name: argName,
@@ -99,11 +101,34 @@ const buildTypeScriptCommandInfo = (name: string, command: Command): BasicComman
     .map(x => x!);
 };
 
-export const getBasicCommands = _.once(() => {
-    const referenceClient: { [methodName: string]: any } = createClient();
+const getCommandCollection = () => {
     const commandsJson = readFileSync(`${redisDoc}/commands.json`, "utf8");
     const commandCollection: CommandCollection = JSON.parse(commandsJson);
 
+    // hack: workaround while waiting for https://github.com/antirez/redis-doc/pulls/1231
+    const expectedSetArgs = '[{"name":"key","type":"key"},{"name":"value","type":"string"},{"name":"expiration","type":"enum","enum":["EX seconds","PX milliseconds"],"optional":true},{"name":"condition","type":"enum","enum":["NX","XX"],"optional":true}]';
+    if (JSON.stringify(commandCollection.SET.arguments) !== expectedSetArgs) {
+        throw Error([
+            "unexpected arguments value for command SET",
+            "hack working around the issue mentioned in https://github.com/antirez/redis-doc/pulls/1231 might not be needed anymore",
+            "expected: " + expectedSetArgs,
+            "actual:   " + JSON.stringify(commandCollection.SET.arguments),
+        ].join("\n"));
+    }
+    commandCollection.SET.arguments = [
+        { name: "key", type: "key" },
+        { name: "value", type: "string" },
+        { command: "EX", name: "seconds", type: "integer", optional: true },
+        { command: "PX", name: "milliseconds", type: "integer", optional: true },
+        { name: "condition", type: "enum", enum: ["NX", "XX"], optional: true }
+    ];
+    return commandCollection;
+};
+
+export const getBasicCommands = _.once(() => {
+    const referenceClient: { [methodName: string]: any } = createClient();
+    const commandCollection = getCommandCollection();
+
     const basicCommands = _.flatten(Object.keys(commandCollection).map(name => {
         const methodName = simplifyName(name);
         if (typeof referenceClient[methodName] !== "function") {

scripts/command/generate.ts

@@ -6,6 +6,15 @@ import { useUnderlyingImpl } from "../src/overrides";
 const generateClientInterface = async (getCommands: typeof getFullCommands) => {
     const typescriptCommands = await getCommands();
 
+    // hack: hset now can set multiple hash keys at once, so the generated type is (string, ...[string, string])
+    // it used to be (string, string, string) - explicitly allow that here.
+    // todo: remove this hack in next major version. Or earlier, if there's a better way to handle this class of command
+    const hsetIndex = typescriptCommands.findIndex(c => c.name === "hset");
+    typescriptCommands.splice(hsetIndex, 0, {
+        ...typescriptCommands[hsetIndex],
+        args: ["key", "field", "value"].map(name => ({ name, type: "string" }))
+    });
+
     const interfaceDeclarations = typescriptCommands.map(commandInfo => {
         const docs = [
             `/**`,
@@ -20,6 +29,10 @@ const generateClientInterface = async (getCommands: typeof getFullCommands) => {
         }
 
         const argList = commandInfo.args
+            // hack: setbit allowed a string as the last argument at one point.
+            // for backwards compatibility, continue allowing it even though redis-doc has updated
+            // todo: remove this hack in v2
+            .map(a => commandInfo.name === "setbit" && a.name === "value" ? { ...a, type: "number | string" } : a)
             .map(a => `${a.name}: ${a.type}`)
             .join(`,${EOL}${twotabs}`);
 

scripts/generate-types.ts

@@ -4,24 +4,14 @@ import { get } from "lodash";
 
 export const getOverloads = (args: Argument[]): Argument[][] => {
     if (args.length <= 1) {
-        const overloads = [args];
-        if (get(args, "[0].optional")) {
-            overloads.push([]);
-        }
-        return overloads;
+        return get(args, "[0].optional") ? [args, []] : [args];
     }
-    const first = args[0];
-    const theRest = args.slice(1);
-    let variations = new Array<Argument[]>();
-    const overloadsOfTheRest = getOverloads(theRest);
-    const argListsWithFirst = overloadsOfTheRest.map(argsSubList => [
-        first,
-        ...argsSubList
-    ]);
-    variations = variations.concat(argListsWithFirst);
-    if (first.optional) {
-        variations = variations.concat(overloadsOfTheRest);
+    const head = args[0];
+    const tailOverloads = getOverloads(args.slice(1));
+    const overloads = tailOverloads.map(argsSubList => [head, ...argsSubList]);
+    if (head.optional) {
+        overloads.push(...tailOverloads);
     }
 
-    return variations;
+    return overloads;
 };