DOC-4942 added remaining commands plus fixes

Author: andy-stark-redis

content/develop/clients/nodejs/migration.md

@@ -9,7 +9,7 @@ categories:
 - oss
 - kubernetes
 - clients
-description: Learn the differences between `ioredis` and `node-redis`
+description: Discover the differences between `ioredis` and `node-redis`.
 linkTitle: Migrate from ioredis
 title: Migrate from ioredis
 weight: 6
@@ -21,11 +21,11 @@ but this library is now deprecated in favor of
 [`node-redis`]({{< relref "/develop/clients/nodejs" >}}). This guide
 outlines the main similarities and differences between the two libraries.
 You may find this information useful if you are an `ioredis` user and you want to
-start a new Node.js project or migrate an existing `ioredis` project to `node-redis`
+start a new Node.js project or migrate an existing `ioredis` project to `node-redis`.
 
 ## Comparison of `ioredis` and `node-redis`
 
-The table below summarizes how `ioredis` and `node-redis` implement some
+The tables below summarize how `ioredis` and `node-redis` implement some
 key features of Redis. See the following sections for more information about
 each feature.
 
@@ -35,7 +35,7 @@ each feature.
 | :-- | :-- | :-- |
 | [Initial connection](#initial-connection) | Happens when you create a client instance | Requires you to call a method on the client instance |
 | [Reconnection after a connection is lost](#reconnection) | Automatic by default | Manual by default |
-| [Connection events](#connection-events) | Emits `connect`, `ready`, `error`, and `close` events. | Emits `connect`, `ready`, `error`, `end`, and `reconnecting` events. |
+| [Connection events](#connection-events) | Emits `connect`, `ready`, `error`, and `close` events | Emits `connect`, `ready`, `error`, `end`, and `reconnecting` events |
 
 ### Command handling
 
@@ -44,20 +44,23 @@ each feature.
 | [Command case](#command-case) | Lowercase only (eg, `hset`) | Uppercase or camel case (eg, `HSET` or `hSet`) |
 | [Command argument handling](#command-argument-handling) | Argument objects flattened and items passed directly | Argument objects parsed to generate correct argument list |
 | [Asynchronous command result handling](#async-result) | Callbacks and Promises | Promises only |
+| [Arbitrary command execution](#arbitrary-command-execution) | Uses the `call()` method | Uses the `sendCommand()` method |
 
 ### Techniques
 
 | Feature | `ioredis` | `node-redis` |
 | :-- | :-- | :-- |
 | [Pipelining](#pipelining) | Automatic, or with `pipeline()` command | Automatic, or with `multi()` command |
-| [Scan iteration](#scan-iteration) | Uses `scanStream()`, etc. | Uses `scanIterator()`, etc |
+| [Scan iteration](#scan-iteration) | Uses `scanStream()`, etc | Uses `scanIterator()`, etc |
 | [Subscribing to channels](#subscribing-to-channels) | Uses `client.on('message', ...)` event | Uses `subscribe(...)` command |
 
 ### Specific commands
 
 | Command | `ioredis` | `node-redis` |
 | :-- | :-- | :-- |
 | [`SETNX`](#setnx-command) | Supported explicitly | Supported as an option for `SET` |
+| [`HMSET`](#hmset-command) | Supported explicitly | Supported with standard `HSET` functionality |
+| [`CONFIG`](#config-command) | Supported explicitly | Supported with separate `configGet()`, `configSet()`, etc |co
 
 ## Details
 
@@ -70,10 +73,10 @@ The sections below explain the points of comparison between `ioredis` and
 of the client object:
 
 ```js
-const Redis = require('ioredis');
+const client = require('ioredis');
 
 // Connects to localhost:6379 on instantiation.
-const redis = new Redis();
+const client = new Redis();
 ```
 
 `node-redis` requires you to call the `connect()` method on the client object
@@ -100,7 +103,7 @@ for more information.
 The `connect`, `ready`, `error`, and `close` events that `ioredis` emits
 are equivalent to the `connect`, `ready`, `error`, and `end` events
 in `node-redis`, but `node-redis` also emits a `reconnecting` event.
-See []({{< relref "/develop/clients/nodejs/connect#connection-events" >}})
+See [Connection events]({{< relref "/develop/clients/nodejs/connect#connection-events" >}})
 for more information.
 
 ### Command case
@@ -110,13 +113,13 @@ use uppercase or camel case versions of the method names.
 
 ```js
 // ioredis
-redis.hset("key", "field", "value");
+client.hset('key', 'field', 'value');
 
 // node-redis
-redis.HSET("key", "field", "value");
+client.HSET('key', 'field', 'value');
 
 // ...or
-redis.hSet("key", "field", "value");
+client.hSet('key', 'field', 'value');
 ```
 
 ### Command argument handling
@@ -126,23 +129,23 @@ the server, in a similar way to [`redis-cli`]({{< relref "/develop/tools/cli" >}
 
 ```js
 // Equivalent to the command line `SET key 100 EX 10`.
-redis.set("key", 100, "EX", 10);
+client.set('key', 100, 'EX', 10);
 ```
 
 Arrays passed as arguments are flattened into individual elements and
 objects are flattened into sequential key-value pairs:
 
 ```js
 // These commands are all equivalent.
-redis.hset("user" {
-    name: "Bob",
+client.hset('user' {
+    name: 'Bob',
     age: 20,
-    description: "I am a programmer",
+    description: 'I am a programmer',
 });
 
-redis.hset("user", ["name", "Bob", "age", 20, "description", "I am a programmer"]);
+client.hset('user', ['name', 'Bob', 'age', 20, 'description', 'I am a programmer']);
 
-redis.hset("user", "name", "Bob", "age", 20, "description", "I am a programmer");
+client.hset('user', 'name', 'Bob', 'age', 20, 'description', 'I am a programmer');
 ```
 
 `node-redis` uses predefined formats for command arguments. These include specific
@@ -151,8 +154,8 @@ of the CLI command. Internally, `node-redis` constructs the correct command usin
 the method arguments you pass:
 
 ```js
-// Equivalent to the command line `SET key 100 EX 10`.
-redis.set("bike:5", "bike", {EX: 10});
+// Equivalent to the command line `SET bike:5 bike EX 10`.
+client.set('bike:5', 'bike', {EX: 10});
 ```
 
 ### Asynchronous command result handling {#async-result}
@@ -164,7 +167,7 @@ return values to respond to command results:
 
 ```js
 // Callback
-redis.get("mykey", (err, result) => {
+client.get('mykey', (err, result) => {
   if (err) {
     console.error(err);
   } else {
@@ -173,7 +176,7 @@ redis.get("mykey", (err, result) => {
 });
 
 // Promise
-redis.get("mykey").then(
+client.get('mykey').then(
     (result) => {
         console.log(result);
     },
@@ -188,27 +191,54 @@ you must always use a `then()` handler or the
 [`await`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await)
 operator to receive them.
 
+### Arbitrary command execution
+
+`ioredis` lets you issue arbitrary commands in a similar format to
+[`redis-cli`]({{< relref "/develop/tools/cli" >}}) using the `call()`
+command:
+
+```js
+await client.call('JSON.SET', 'doc', "$", '{"f1": {"a":1}, "f2":{"a":2}}');
+```
+
+In `node-redis`, you can get the same effect outside a transaction using `sendCommand()`:
+
+```js
+await client.sendCommand(['hset', 'hash2', 'number', '3']);
+```
+
+Within a transaction, use `addCommand()` to include arbitrary commands. Note that
+you can freely mix `addCommand()` calls with standard commands in the same
+transaction:
+
+```js
+const responses = await client.multi()
+  .addCommand(['hset', 'hash3', 'number', '4'])
+  .hGet('hash3', 'number')
+  .exec();
+```
+
 ### Pipelining
 
 Both `ioredis` and `node-redis` will pipeline commands automatically if
 they are executed in the same "tick" of the
 [event loop](https://nodejs.org/en/learn/asynchronous-work/event-loop-timers-and-nexttick#what-is-the-event-loop)
 (see
-[Pipelines and transactions]({{< relref "/develop/clients/nodejs/transpipe" >}})
+[Execute a pipeline]({{< relref "/develop/clients/nodejs/transpipe#execute-a-pipeline" >}})
 for more information).
 
 You can also create a pipeline with explicit commands in both clients.
-For `ioredis`, you use the `pipeline()` command with a chain of
+With `ioredis`, you use the `pipeline()` command with a chain of
 commands, ending with `exec()` to run the pipeline:
 
 ```js
 // ioredis example
-redis.pipeline()
-    .set("foo", "1")
-    .get("foo")
-    .set("foo", "2")
-    .incr("foo")
-    .get("foo")
+client.pipeline()
+    .set('foo', '1')
+    .get('foo')
+    .set('foo', '2')
+    .incr('foo')
+    .get('foo')
     .exec(function (err, results) {
       // Handle results or errors.
     });
@@ -218,7 +248,7 @@ For `node-redis`, the approach is similar, except that you call the `multi()`
 command to start the pipeline and `execAsPipeline()` to run it:
 
 ```js
-redis.multi()
+client.multi()
     .set('seat:3', '#3')
     .set('seat:4', '#4')
     .set('seat:5', '#5')
@@ -238,19 +268,19 @@ from the set of keys returned by the [`SCAN`]({{< relref "/commands/scan" >}})
 command:
 
 ```js
-const redis = new Redis();
+const client = new Redis();
 // Create a readable stream (object mode)
-const stream = redis.scanStream();
-stream.on("data", (resultKeys) => {
+const stream = client.scanStream();
+stream.on('data', (resultKeys) => {
   // `resultKeys` is an array of strings representing key names.
   // Note that resultKeys may contain 0 keys, and that it will sometimes
   // contain duplicates due to SCAN's implementation in Redis.
   for (let i = 0; i < resultKeys.length; i++) {
     console.log(resultKeys[i]);
   }
 });
-stream.on("end", () => {
-  console.log("all keys have been visited");
+stream.on('end', () => {
+  console.log('all keys have been visited');
 });
 ```
 
@@ -268,6 +298,7 @@ other multi-key commands):
 ```js
 for await (const keys of client.scanIterator()) {
   const values = await client.mGet(keys);
+  // Process values...
 }
 ```
 
@@ -285,7 +316,7 @@ client.on('message', (channel, message) => {
 ```
 
 With `node-redis`, you use the `subscribe()` command to register the
-message callback. Also, when you use a connection to subscribe, the
+message callback. Also, when you use a connection to subscribe, that
 connection can't issue any other commands, so you must create a
 dedicated connection for the subscription. Use the `client.duplicate()`
 method to create a new connection with the same settings as the original:
@@ -305,13 +336,40 @@ await subscriber.subscribe('channel', (message) => {
 command with an explicit method:
 
 ```js
-client.setnx("bike:1", "bike");
+client.setnx('bike:1', 'bike');
 ```
 
 `node-redis` doesn't provide a `SETNX` method but implements the same
 functionality with the `NX` option to the [`SET`]({{< relref "/commands/set" >}})
 command:
 
 ```js
-await client.set("bike:1", "bike", {'NX': true});
+await client.set('bike:1', 'bike', {'NX': true});
+```
+
+### `HMSET` command
+
+The [`HMSET`]({{< relref "/commands/hmset" >}}) command has been deprecated
+since Redis v4.0.0, but it is still supported by `ioredis`. With `node-redis`
+you should use the [`HSET`]({{< relref "/commands/hset" >}}) command with
+multiple key-value pairs. See the [`HSET`]({{< relref "/commands/hset" >}})
+command page for more information.
+
+### `CONFIG` command
+
+`ioredis` supports a `config()` method to set or get server configuration
+options:
+
+```js
+client.config('SET', 'notify-keyspace-events', 'KEA');
+```
+
+`node-redis` doesn't have a `config()` method, but instead supports the
+standard commands [`configSet()`]({{< relref "/commands/config-set" >}}),
+[`configGet()`]({{< relref "/commands/config-get" >}}),
+[`configResetStat()`]({{< relref "/commands/config-resetstat" >}}), and
+[`configRewrite`]({{< relref "/commands/config-rewrite" >}}):
+
+```js
+await client.configSet('maxclients', '2000');
 ```