Node-Redis



node-redis is a modern, high performance Redis client for Node.js.

How do I Redis?

Learn for free at Redis University

Build faster with the Redis Launchpad

Try the Redis Cloud

Dive in developer tutorials

Join the Redis community

Work at Redis

Installation

Start a redis via docker:

``bash
docker run -p 6379:6379 -d redis:8.0-rc1
`

To install node-redis, simply:

`bash
npm install redis
`
> "redis" is the "whole in one" package that includes all the other packages. If you only need a subset of the commands,
> you can install the individual packages. See the list below.

Packages

| Name | Description |
| ---------------------------------------------- | ------------------------------------------------------------------------------------------- |
| redis | The client with all the "redis-stack" modules |
| @redis/client | The base clients (i.e RedisClient, RedisCluster, etc.) |
| @redis/bloom | Redis Bloom commands |
| @redis/json | Redis JSON commands |
| @redis/search | RediSearch commands |
| @redis/time-series | Redis Time-Series commands |
| @redis/entraid | Secure token-based authentication for Redis clients using Microsoft Entra ID |

> Looking for a high-level library to handle object mapping?
> See redis-om-node!

Usage

$3

`typescript
import { createClient } from "redis";

const client = await createClient()
.on("error", (err) => console.log("Redis Client Error", err))
.connect();

await client.set("key", "value");
const value = await client.get("key");
client.destroy();
`

The above code connects to localhost on port 6379. To connect to a different host or port, use a connection string in
the format redis[s]://[[username][:password]@][host][:port][/db-number]:

`typescript
createClient({
url: "redis://alice:foobared@awesome.redis.server:6380",
});
`

You can also use discrete parameters, UNIX sockets, and even TLS to connect. Details can be found in
the client configuration guide.

To check if the 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).

$3

There is built-in support for all of the out-of-the-box Redis commands. They are exposed
using the raw Redis command names (HSET, HGETALL, etc.) and a friendlier camel-cased version (hSet, hGetAll,
etc.):

`typescript
// raw Redis commands
await client.HSET("key", "field", "value");
await client.HGETALL("key");

// friendly JavaScript commands
await client.hSet("key", "field", "value");
await client.hGetAll("key");
`

Modifiers to commands are specified using a JavaScript object:

`typescript
await client.set("key", "value", {
EX: 10,
NX: true,
});
`

Replies will be transformed into useful data structures:

`typescript
await client.hGetAll("key"); // { field1: 'value1', field2: 'value2' }
await client.hVals("key"); // ['value1', 'value2']
`

Buffers are supported as well:

`typescript
const client = createClient().withTypeMapping({
[RESP_TYPES.BLOB_STRING]: Buffer
});

await client.hSet("key", "field", Buffer.from("value")); // 'OK'
await client.hGet("key", "field"); // { field: }

`

$3

If you want to run commands and/or use arguments that Node Redis doesn't know about (yet!) use .sendCommand():

`typescript
await client.sendCommand(["SET", "key", "value", "NX"]); // 'OK'

await client.sendCommand(["HGETALL", "key"]); // ['key1', 'field1', 'key2', 'field2']
`

$3

Start a transaction by calling .multi(), then chaining your commands. When
you're done, call .exec() and you'll get an array back with your results:

`typescript
await client.set("another-key", "another-value");

const [setKeyReply, otherKeyValue] = await client
.multi()
.set("key", "value")
.get("another-key")
.exec(); // ['OK', 'another-value']
`

You can also watch keys by calling
.watch(). Your transaction will abort if any of the watched keys change.

$3

In v4, RedisClient had the ability to create a pool of connections using an "Isolation Pool" on top of the "main"
connection. However, there was no way to use the pool without a "main" connection:

`javascript
const client = await createClient()
.on("error", (err) => console.error(err))
.connect();

await client.ping(client.commandOptions({ isolated: true }));
`

In v5 we've extracted this pool logic into its own class—RedisClientPool:

`javascript
const pool = await createClientPool()
.on("error", (err) => console.error(err))
.connect();

await pool.ping();
`

$3

See the Pub/Sub overview.

$3

SCAN results can be looped over
using async iterators:

`typescript
for await (const key of client.scanIterator()) {
// use the key!
await client.get(key);
}
`

This works with HSCAN, SSCAN, and ZSCAN too:

`typescript
for await (const { field, value } of client.hScanIterator("hash")) {
}
for await (const member of client.sScanIterator("set")) {
}
for await (const { score, value } of client.zScanIterator("sorted-set")) {
}
`

You can override the default options by providing a configuration object:

`typescript
client.scanIterator({
TYPE: "string", // SCAN only
MATCH: "patter*",
COUNT: 100,
});
`

$3

The QUIT command has been deprecated in Redis 7.2 and should now also be considered deprecated in Node-Redis. Instead
of sending a QUIT command to the server, the client can simply close the network connection.

client.QUIT/quit() is replaced by client.close(). and, to avoid confusion, client.disconnect() has been renamed to
client.destroy().

`typescript
client.destroy();
`


$3

Node Redis v5 adds support for Client Side Caching, which enables clients to cache query results locally. The Redis server will notify the client when cached results are no longer valid.

`typescript
// Enable client side caching with RESP3
const client = createClient({
RESP: 3,
clientSideCache: {
ttl: 0, // Time-to-live (0 = no expiration)
maxEntries: 0, // Maximum entries (0 = unlimited)
evictPolicy: "LRU" // Eviction policy: "LRU" or "FIFO"
}
});
`

See the V5 documentation for more details and advanced usage.

$3

Node Redis will automatically pipeline requests that are made during the same "tick".

`typescript
client.set("Tm9kZSBSZWRpcw==", "users:1");
client.sAdd("users:1:tokens", "Tm9kZSBSZWRpcw==");
`

Of course, if you don't do something with your Promises you're certain to
get unhandled Promise exceptions. To take
advantage of auto-pipelining and handle your Promises, use Promise.all().

`typescript
await Promise.all([
client.set("Tm9kZSBSZWRpcw==", "users:1"),
client.sAdd("users:1:tokens", "Tm9kZSBSZWRpcw=="),
]);
`

$3

See the Programmability overview.

$3

Check out the Clustering Guide when using Node Redis to connect to a Redis Cluster.

$3

The Node Redis client class is an Nodejs EventEmitter and it emits an event each time the network status changes:

| Name | When | Listener arguments |
| ----------------------- | ---------------------------------------------------------------------------------- | --------------------------------------------------------- |
| connect | Initiating a connection to the server | _No arguments_ |
| ready | Client is ready to use | _No arguments_ |
| end | Connection has been closed (via .disconnect()) | _No arguments_ |
| error | An error has occurred—usually a network issue such as "Socket closed unexpectedly" | (error: Error) |
| reconnecting | Client is trying to reconnect to the server | _No arguments_ |
| sharded-channel-moved | See here | See here |

> :warning: You MUST listen to error events. If a client doesn't have at least one error listener registered and
> an error occurs, that error will be thrown and the Node.js process will exit. See the > EventEmitter` docs for more details.

> The client will not emit any other events beyond those listed above.

Supported Redis versions

Node Redis is supported with the following versions of Redis:

| Version | Supported |
| ------- | ------------------ |
| 8.0.z | :heavy_check_mark: |
| 7.4.z | :heavy_check_mark: |
| 7.2.z | :heavy_check_mark: |
| < 7.2 | :x: |

> Node Redis should work with older versions of Redis, but it is not fully tested and we cannot offer support.

Migration

- From V3 to V4
- From V4 to V5
- V5

Contributing

If you'd like to contribute, check out the contributing guide.

Thank you to all the people who already contributed to Node Redis!


License

This repository is licensed under the "MIT" license. See LICENSE.