DOC-4942 added more items and separated tables

Author: andy-stark-redis

content/develop/clients/nodejs/connect.md

@@ -67,7 +67,7 @@ createClient({
 ```
 To check if the client is connected and ready to send commands, use `client.isReady`, which returns a Boolean. `client.isOpen` is also available. This returns `true` when the client's underlying socket is open, and `false` when it isn't (for example, when the client is still connecting or reconnecting after a network error).
 
-### Connect to a Redis cluster
+## Connect to a Redis cluster
 
 To connect to a Redis cluster, use `createCluster`.
 
@@ -97,7 +97,7 @@ console.log(value); // returns 'bar'
 await cluster.quit();
 ```
 
-### Connect to your production Redis with TLS
+## Connect to your production Redis with TLS
 
 When you deploy your application, use TLS and follow the [Redis security]({{< relref "/operate/oss_and_stack/management/security/" >}}) guidelines.
 
@@ -127,3 +127,77 @@ await client.disconnect();
 ```
 
 You can also use discrete parameters and UNIX sockets. Details can be found in the [client configuration guide](https://github.com/redis/node-redis/blob/master/docs/client-configuration.md).
+
+## Reconnect after disconnection
+
+By default, `node-redis` doesn't attempt to reconnect automatically when
+the connection to the server is lost. However, you can set the
+`socket.reconnectionStrategy` field in the configuration to decide
+whether to try to reconnect and how to approach it. Choose one of the following values for
+`socket.reconnectionStrategy`:
+
+-   `false`: (Default) Don't attempt to reconnect.
+-   `number`: Wait for this number of milliseconds and then attempt to reconnect.
+-   `<function>`: Use a custom
+    function to decide how to handle reconnection.
+
+The custom function has the following signature:
+
+```js
+(retries: number, cause: Error) => false | number | Error
+```
+
+It is called before each attempt to reconnect, with the `retries`
+indicating how many attempts have been made so far. The `cause` parameter is an
+[`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
+object with information about how the connection was lost. The return value
+from the function can be any of the following:
+
+-   `false`: Don't attempt to reconnect.
+-   `number`: Wait this number of milliseconds and then try again.
+-   `Error`: Same as `false`, but lets you supply extra information about why
+    no attempt was made to reconnect.
+
+The example below shows a `reconnectionStrategy` function that implements a
+custom [exponential backoff](https://en.wikipedia.org/wiki/Exponential_backoff)
+strategy:
+
+```js
+createClient({
+  socket: {
+    reconnectStrategy: retries => {
+        // Generate a random jitter between 0 – 200 ms:
+        const jitter = Math.floor(Math.random() * 200);
+
+        // Delay is an exponential back off, (times^2) * 50 ms, with a
+        // maximum value of 2000 ms:
+        const delay = Math.min(Math.pow(2, retries) * 50, 2000);
+
+        return delay + jitter;
+    }
+  }
+});
+```
+
+## Connection events
+
+The client object emits the following
+[events](https://developer.mozilla.org/en-US/docs/Web/API/Event) that are
+related to connection:
+
+-   `connect`: (No parameters) The client is about to start connecting to the server.
+-   `ready`: (No parameters) The client has connected and is ready to use.
+-   `end`: (No parameters) The client has been intentionally closed using `client.quit()`.
+-   `error`: An error has occurred, which is described by the
+    [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
+    parameter. This is usually a network issue such as "Socket closed unexpectedly".
+-   `reconnecting`: (No parameters) The client is about to try reconnecting after the
+    connection was lost due to an error.
+
+Use code like the following to respond to these events:
+
+```js
+client.on('error', error => {
+    console.error(`Redis client error:`, error);
+});
+```

content/develop/clients/nodejs/migration.md

@@ -23,18 +23,85 @@ 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`
 
+## Comparison of `ioredis` and `node-redis`
+
 The table below summarizes how `ioredis` and `node-redis` implement some
 key features of Redis. See the following sections for more information about
 each feature.
 
+### Connection
+
+| Feature | `ioredis` | `node-redis` |
+| :-- | :-- | :-- |
+| [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. |
+
+### Command handling
+
 | Feature | `ioredis` | `node-redis` |
 | :-- | :-- | :-- |
 | [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 |
+
+### Specific commands
+
+| Feature | `ioredis` | `node-redis` |
+| :-- | :-- | :-- |
+
+
+### Techniques
+
+| Feature | `ioredis` | `node-redis` |
+| :-- | :-- | :-- |
 | [Pipelining](#pipelining) | Automatic, or with `pipeline()` command | Automatic, or with `multi()` command |
 
-## Command case
+## Details
+
+The sections below explain the points of comparison between `ioredis` and
+`node-redis` in more detail.
+
+### Initial connection
+
+`ioredis` makes the connection to the Redis server when you create an instance
+of the client object:
+
+```js
+const Redis = require('ioredis');
+
+// Connects to localhost:6379 on instantiation.
+const redis = new Redis();
+```
+
+`node-redis` requires you to call the `connect()` method on the client object
+to make the connection:
+
+```js
+import { createClient } from 'redis';
+
+const client = await createClient();
+await client.connect(); // Requires explicit connection.
+```
+
+### Reconnection after a connection is lost {#reconnection}
+
+`ioredis` automatically attempts to reconnect if the connection
+was lost due to an error. By default, `node-redis` doesn't attempt
+to reconnect, but you can enable a custom reconnection strategy
+when you create the client object. See
+[Reconnect after disconnection]({{< relref "/develop/clients/nodejs/connect#reconnect-after-disconnection" >}})
+for more information.
+
+### Connection events
+
+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" >}})
+for more information.
+
+### Command case
 
 Command methods in `ioredis` are always lowercase. With `node-redis`, you can
 use uppercase or camel case versions of the method names.
@@ -50,7 +117,7 @@ redis.HSET("key", "field", "value");
 redis.hSet("key", "field", "value");
 ```
 
-## Command argument handling
+### Command argument handling
 
 `ioredis` parses command arguments to strings and then passes them to
 the server, in a similar way to [`redis-cli`]({{< relref "/develop/tools/cli" >}}).
@@ -86,7 +153,7 @@ the method arguments you pass:
 redis.set("bike:5", "bike", {EX: 10});
 ```
 
-## Asynchronous command result handling {#async-result}
+### Asynchronous command result handling {#async-result}
 
 All commands for both `ioredis` and `node-redis` are executed
 asynchronously. `ioredis` supports both callbacks and
@@ -119,7 +186,7 @@ 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.
 
-## Pipelining
+### Pipelining
 
 Both `ioredis` and `node-redis` will pipeline commands automatically if
 they are executed in the same "tick" of the