redis-parser

What is redis-parser?

The redis-parser npm package is designed for parsing responses from a Redis server. It supports both JavaScript and TypeScript and is capable of handling different types of Redis responses, including errors, simple strings, integers, bulk strings, arrays, and more. It's particularly useful for developers working with Redis in Node.js environments, providing a straightforward way to interpret the data returned by Redis commands.

What are redis-parser's main functionalities?

Error Handling

This feature allows handling of Redis errors. When a Redis server responds with an error, the parser can catch and process this error appropriately.

{"const { Parser } = require('redis-parser');
const parser = new Parser({
  returnError: function(err) { console.error('Error:', err); },
  returnReply: function(reply) { console.log('Reply:', reply); }
});
parser.execute(Buffer.from('-Error message\r\n'));
}

Parsing Simple Strings

This demonstrates how to parse simple string responses from Redis. It's useful for commands that return a simple status response.

{"const { Parser } = require('redis-parser');
const parser = new Parser({
  returnError: function(err) { console.error('Error:', err); },
  returnReply: function(reply) { console.log('Reply:', reply); }
});
parser.execute(Buffer.from('+OK\r\n'));
}

Parsing Arrays

This feature is for parsing array responses from Redis, which is common for commands that return multiple values.

{"const { Parser } = require('redis-parser');
const parser = new Parser({
  returnError: function(err) { console.error('Error:', err); },
  returnReply: function(reply) { console.log('Reply:', reply); }
});
parser.execute(Buffer.from('*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n'));
}

Other packages similar to redis-parser

ioredis

ioredis is a robust, performance-focused, and full-featured Redis client for Node.js. Unlike redis-parser, which focuses solely on parsing responses, ioredis provides a comprehensive solution for interacting with Redis, including connection, command execution, and response parsing.

README

redis-parser

A high performance redis parser solution built for node_redis and ioredis.

Generally all RESP data will be properly parsed by the parser.

Install

Install with NPM:

npm install redis-parser

Usage

new Parser(options);

Possible options

• returnReply: function; mandatory
• returnError: function; mandatory
• returnFatalError: function; optional, defaults to the returnError function
• returnBuffers: boolean; optional, defaults to false
• name: javascript|hiredis; optional, defaults to hiredis and falls back to the js parser if not available

Example

var Parser = require("redis-parser");

function Library () {}

Library.prototype.returnReply = function (reply) { ... }
Library.prototype.returnError = function (err) { ... }
Library.prototype.returnFatalError = function (err) { ... }

var lib = new Library();

var parser = new Parser({
    returnReply: function(reply) {
        lib.returnReply(reply);
    },
    returnError: function(err) {
        lib.returnError(err);
    },
    returnFatalError: function (err) {
        lib.returnFatalError(err);
    }
}); // This returns either a hiredis or the js parser instance depending on what's available

Library.prototype.streamHandler = function () {
    this.stream.on('data', function (buffer) {
        // Here the data (e.g. `new Buffer('$5\r\nHello\r\n'`)) is passed to the parser and the result is passed to either function depending on the provided data.
        parser.execute(buffer);
    });
};

You do not have to use the returnFatalError function. Fatal errors will be returned in the normal error function in that case.

And if you want to return buffers instead of strings, you can do this by adding the returnBuffers option.

// Same functions as in the first example

var parser = new Parser({
    returnReply: function(reply) {
        lib.returnReply(reply);
    },
    returnError: function(err) {
        lib.returnError(err);
    },
    returnBuffers: true // All strings are returned as buffer e.g. <Buffer 48 65 6c 6c 6f>
});

// The streamHandler as above

Further info

The hiredis parser is still the fasted parser for Node.js and therefor used as default in redis-parser if the hiredis parser is available.

Otherwise the pure js NodeRedis parser is choosen that is almost as fast as the hiredis parser besides some situations in which it'll be a bit slower.

Protocol errors

To handle protocol errors (this is very unlikely to happen) gracefuly you should add the returnFatalError option, reject any still running command (they might have been processed properly but the reply is just wrong), destroy the socket and reconnect. Otherwise a chunk might still contain partial data of a following command that was already processed properly but answered in the same chunk as the command that resulted in the protocol error.

Contribute

The js parser is already optimized but there are likely further optimizations possible. Besides running the tests you'll also have to run the change at least against the node_redis benchmark suite and post the improvement in the PR. If you want to write a own parser benchmark, that would also be great!

npm install
npm test

# Run node_redis benchmark (let's guess you cloned node_redis in another folder)
cd ../redis
npm install
npm run benchmark parser=javascript > old.log
# Replace the changed parser in the node_modules
npm run benchmark parser=javascript > new.log
node benchmarks/diff_multi_bench_output.js old.log new.log > improvement.log

License

MIT