redis 3.1.0 → 3.1.1

package/heroku/node_modules/redis/lib/multi.js

@@ -0,0 +1,187 @@
+'use strict';
+
+var Queue = require('denque');
+var utils = require('./utils');
+var Command = require('./command');
+
+function Multi (client, args) {
+    this._client = client;
+    this.queue = new Queue();
+    var command, tmp_args;
+    if (args) { // Either undefined or an array. Fail hard if it's not an array
+        for (var i = 0; i < args.length; i++) {
+            command = args[i][0];
+            tmp_args = args[i].slice(1);
+            if (Array.isArray(command)) {
+                this[command[0]].apply(this, command.slice(1).concat(tmp_args));
+            } else {
+                this[command].apply(this, tmp_args);
+            }
+        }
+    }
+}
+
+function pipeline_transaction_command (self, command_obj, index) {
+    // Queueing is done first, then the commands are executed
+    var tmp = command_obj.callback;
+    command_obj.callback = function (err, reply) {
+        // Ignore the multi command. This is applied by node_redis and the user does not benefit by it
+        if (err && index !== -1) {
+            if (tmp) {
+                tmp(err);
+            }
+            err.position = index;
+            self.errors.push(err);
+        }
+        // Keep track of who wants buffer responses:
+        // By the time the callback is called the command_obj got the buffer_args attribute attached
+        self.wants_buffers[index] = command_obj.buffer_args;
+        command_obj.callback = tmp;
+    };
+    self._client.internal_send_command(command_obj);
+}
+
+Multi.prototype.exec_atomic = Multi.prototype.EXEC_ATOMIC = Multi.prototype.execAtomic = function exec_atomic (callback) {
+    if (this.queue.length < 2) {
+        return this.exec_batch(callback);
+    }
+    return this.exec(callback);
+};
+
+function multi_callback (self, err, replies) {
+    var i = 0, command_obj;
+
+    if (err) {
+        err.errors = self.errors;
+        if (self.callback) {
+            self.callback(err);
+            // Exclude connection errors so that those errors won't be emitted twice
+        } else if (err.code !== 'CONNECTION_BROKEN') {
+            self._client.emit('error', err);
+        }
+        return;
+    }
+
+    if (replies) {
+        while (command_obj = self.queue.shift()) {
+            if (replies[i] instanceof Error) {
+                var match = replies[i].message.match(utils.err_code);
+                // LUA script could return user errors that don't behave like all other errors!
+                if (match) {
+                    replies[i].code = match[1];
+                }
+                replies[i].command = command_obj.command.toUpperCase();
+                if (typeof command_obj.callback === 'function') {
+                    command_obj.callback(replies[i]);
+                }
+            } else {
+                // If we asked for strings, even in detect_buffers mode, then return strings:
+                replies[i] = self._client.handle_reply(replies[i], command_obj.command, self.wants_buffers[i]);
+                if (typeof command_obj.callback === 'function') {
+                    command_obj.callback(null, replies[i]);
+                }
+            }
+            i++;
+        }
+    }
+
+    if (self.callback) {
+        self.callback(null, replies);
+    }
+}
+
+Multi.prototype.exec_transaction = function exec_transaction (callback) {
+    if (this.monitoring || this._client.monitoring) {
+        var err = new RangeError(
+            'Using transaction with a client that is in monitor mode does not work due to faulty return values of Redis.'
+        );
+        err.command = 'EXEC';
+        err.code = 'EXECABORT';
+        return utils.reply_in_order(this._client, callback, err);
+    }
+    var self = this;
+    var len = self.queue.length;
+    self.errors = [];
+    self.callback = callback;
+    self._client.cork();
+    self.wants_buffers = new Array(len);
+    pipeline_transaction_command(self, new Command('multi', []), -1);
+    // Drain queue, callback will catch 'QUEUED' or error
+    for (var index = 0; index < len; index++) {
+        // The commands may not be shifted off, since they are needed in the result handler
+        pipeline_transaction_command(self, self.queue.get(index), index);
+    }
+
+    self._client.internal_send_command(new Command('exec', [], function (err, replies) {
+        multi_callback(self, err, replies);
+    }));
+    self._client.uncork();
+    return !self._client.should_buffer;
+};
+
+function batch_callback (self, cb, i) {
+    return function batch_callback (err, res) {
+        if (err) {
+            self.results[i] = err;
+            // Add the position to the error
+            self.results[i].position = i;
+        } else {
+            self.results[i] = res;
+        }
+        cb(err, res);
+    };
+}
+
+Multi.prototype.exec = Multi.prototype.EXEC = Multi.prototype.exec_batch = function exec_batch (callback) {
+    var self = this;
+    var len = self.queue.length;
+    var index = 0;
+    var command_obj;
+    if (len === 0) {
+        utils.reply_in_order(self._client, callback, null, []);
+        return !self._client.should_buffer;
+    }
+    self._client.cork();
+    if (!callback) {
+        while (command_obj = self.queue.shift()) {
+            self._client.internal_send_command(command_obj);
+        }
+        self._client.uncork();
+        return !self._client.should_buffer;
+    }
+    var callback_without_own_cb = function (err, res) {
+        if (err) {
+            self.results.push(err);
+            // Add the position to the error
+            var i = self.results.length - 1;
+            self.results[i].position = i;
+        } else {
+            self.results.push(res);
+        }
+        // Do not emit an error here. Otherwise each error would result in one emit.
+        // The errors will be returned in the result anyway
+    };
+    var last_callback = function (cb) {
+        return function (err, res) {
+            cb(err, res);
+            callback(null, self.results);
+        };
+    };
+    self.results = [];
+    while (command_obj = self.queue.shift()) {
+        if (typeof command_obj.callback === 'function') {
+            command_obj.callback = batch_callback(self, command_obj.callback, index);
+        } else {
+            command_obj.callback = callback_without_own_cb;
+        }
+        if (typeof callback === 'function' && index === len - 1) {
+            command_obj.callback = last_callback(command_obj.callback);
+        }
+        this._client.internal_send_command(command_obj);
+        index++;
+    }
+    self._client.uncork();
+    return !self._client.should_buffer;
+};
+
+module.exports = Multi;

package/heroku/node_modules/redis/lib/utils.js

@@ -0,0 +1,134 @@
+'use strict';
+
+// hgetall converts its replies to an Object. If the reply is empty, null is returned.
+// These function are only called with internal data and have therefore always the same instanceof X
+function replyToObject (reply) {
+    // The reply might be a string or a buffer if this is called in a transaction (multi)
+    if (reply.length === 0 || !(reply instanceof Array)) {
+        return null;
+    }
+    var obj = {};
+    for (var i = 0; i < reply.length; i += 2) {
+        obj[reply[i].toString('binary')] = reply[i + 1];
+    }
+    return obj;
+}
+
+function replyToStrings (reply) {
+    if (reply instanceof Buffer) {
+        return reply.toString();
+    }
+    if (reply instanceof Array) {
+        var res = new Array(reply.length);
+        for (var i = 0; i < reply.length; i++) {
+            // Recusivly call the function as slowlog returns deep nested replies
+            res[i] = replyToStrings(reply[i]);
+        }
+        return res;
+    }
+
+    return reply;
+}
+
+function print (err, reply) {
+    if (err) {
+        // A error always begins with Error:
+        console.log(err.toString());
+    } else {
+        console.log('Reply: ' + reply);
+    }
+}
+
+var camelCase;
+// Deep clone arbitrary objects with arrays. Can't handle cyclic structures (results in a range error)
+// Any attribute with a non primitive value besides object and array will be passed by reference (e.g. Buffers, Maps, Functions)
+// All capital letters are going to be replaced with a lower case letter and a underscore infront of it
+function clone (obj) {
+    var copy;
+    if (Array.isArray(obj)) {
+        copy = new Array(obj.length);
+        for (var i = 0; i < obj.length; i++) {
+            copy[i] = clone(obj[i]);
+        }
+        return copy;
+    }
+    if (Object.prototype.toString.call(obj) === '[object Object]') {
+        copy = {};
+        var elems = Object.keys(obj);
+        var elem;
+        while (elem = elems.pop()) {
+            if (elem === 'tls') { // special handle tls
+                copy[elem] = obj[elem];
+                continue;
+            }
+            // Accept camelCase options and convert them to snake_case
+            var snake_case = elem.replace(/[A-Z][^A-Z]/g, '_$&').toLowerCase();
+            // If camelCase is detected, pass it to the client, so all variables are going to be camelCased
+            // There are no deep nested options objects yet, but let's handle this future proof
+            if (snake_case !== elem.toLowerCase()) {
+                camelCase = true;
+            }
+            copy[snake_case] = clone(obj[elem]);
+        }
+        return copy;
+    }
+    return obj;
+}
+
+function convenienceClone (obj) {
+    camelCase = false;
+    obj = clone(obj) || {};
+    if (camelCase) {
+        obj.camel_case = true;
+    }
+    return obj;
+}
+
+function callbackOrEmit (self, callback, err, res) {
+    if (callback) {
+        callback(err, res);
+    } else if (err) {
+        self.emit('error', err);
+    }
+}
+
+function replyInOrder (self, callback, err, res, queue) {
+    // If the queue is explicitly passed, use that, otherwise fall back to the offline queue first,
+    // as there might be commands in both queues at the same time
+    var command_obj;
+    /* istanbul ignore if: TODO: Remove this as soon as we test Redis 3.2 on travis */
+    if (queue) {
+        command_obj = queue.peekBack();
+    } else {
+        command_obj = self.offline_queue.peekBack() || self.command_queue.peekBack();
+    }
+    if (!command_obj) {
+        process.nextTick(function () {
+            callbackOrEmit(self, callback, err, res);
+        });
+    } else {
+        var tmp = command_obj.callback;
+        command_obj.callback = tmp ?
+            function (e, r) {
+                tmp(e, r);
+                callbackOrEmit(self, callback, err, res);
+            } :
+            function (e, r) {
+                if (e) {
+                    self.emit('error', e);
+                }
+                callbackOrEmit(self, callback, err, res);
+            };
+    }
+}
+
+module.exports = {
+    reply_to_strings: replyToStrings,
+    reply_to_object: replyToObject,
+    print: print,
+    err_code: /^([A-Z]+)\s+(.+)$/,
+    monitor_regex: /^[0-9]{10,11}\.[0-9]+ \[[0-9]+ .+\]( ".+?")+$/,
+    clone: convenienceClone,
+    callback_or_emit: callbackOrEmit,
+    reply_in_order: replyInOrder
+};

package/heroku/node_modules/redis/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "redis",
+  "version": "3.1.0",
+  "description": "A high performance Redis client.",
+  "keywords": [
+    "database",
+    "redis",
+    "transaction",
+    "pipelining",
+    "performance",
+    "queue",
+    "nodejs",
+    "pubsub",
+    "backpressure"
+  ],
+  "author": "Matt Ranney <mjr@ranney.com>",
+  "contributors": [
+    {
+      "name": "Mike Diarmid (Salakar)",
+      "url": "https://github.com/salakar"
+    },
+    {
+      "name": "Ruben Bridgewater (BridgeAR)",
+      "url": "https://github.com/BridgeAR"
+    }
+  ],
+  "license": "MIT",
+  "main": "./index.js",
+  "scripts": {
+    "coveralls": "nyc report --reporter=text-lcov | coveralls",
+    "coverage": "nyc report --reporter=html",
+    "benchmark": "node benchmarks/multi_bench.js",
+    "test": "nyc --cache mocha ./test/*.spec.js ./test/commands/*.spec.js --timeout=8000 && npm run coverage",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "lint:report": "eslint --output-file=eslint-report.json --format=json  .",
+    "compare": "node benchmarks/diff_multi_bench_output.js beforeBench.txt afterBench.txt"
+  },
+  "dependencies": {
+    "denque": "^1.5.0",
+    "redis-commands": "^1.7.0",
+    "redis-errors": "^1.2.0",
+    "redis-parser": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "devDependencies": {
+    "bluebird": "^3.7.2",
+    "coveralls": "^3.1.0",
+    "cross-spawn": "^7.0.3",
+    "eslint": "^7.21.0",
+    "intercept-stdout": "~0.1.2",
+    "metrics": "^0.1.21",
+    "mocha": "^8.3.0",
+    "nyc": "^15.1.0",
+    "prettier": "^2.2.1",
+    "tcp-port-used": "^1.0.1",
+    "uuid": "^8.3.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/NodeRedis/node-redis.git"
+  },
+  "bugs": {
+    "url": "https://github.com/NodeRedis/node-redis/issues"
+  },
+  "homepage": "https://github.com/NodeRedis/node-redis",
+  "directories": {
+    "example": "examples",
+    "test": "test"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/node-redis"
+  }
+}

package/heroku/node_modules/redis-commands/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 NodeRedis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/heroku/node_modules/redis-commands/README.md

@@ -0,0 +1,51 @@
+# Redis Commands
+
+[![Build Status](https://travis-ci.org/NodeRedis/redis-commands.png?branch=master)](https://travis-ci.org/NodeRedis/redis-commands)
+[![Code Climate](https://codeclimate.com/github/NodeRedis/redis-commands/badges/gpa.svg)](https://codeclimate.com/github/NodeRedis/redis-commands)
+[![Test Coverage](https://codeclimate.com/github/NodeRedis/redis-commands/badges/coverage.svg)](https://codeclimate.com/github/NodeRedis/redis-commands/coverage)
+
+This module exports all the commands that Redis supports.
+
+## Install
+
+```shell
+$ npm install redis-commands
+```
+
+## Usage
+
+```javascript
+var commands = require('redis-commands');
+```
+
+`.list` is an array contains all the lowercased commands:
+
+```javascript
+commands.list.forEach(function (command) {
+  console.log(command);
+});
+```
+
+`.exists()` is used to check if the command exists:
+
+```javascript
+commands.exists('set') // true
+commands.exists('other-command') // false
+```
+
+`.hasFlag()` is used to check if the command has the flag:
+
+```javascript
+commands.hasFlag('set', 'readonly') // false
+```
+
+`.getKeyIndexes()` is used to get the indexes of keys in the command arguments:
+
+```javascript
+commands.getKeyIndexes('set', ['key', 'value']) // [0]
+commands.getKeyIndexes('mget', ['key1', 'key2']) // [0, 1]
+```
+
+## Acknowledgment
+
+Thank [@Yuan Chuan](https://github.com/yuanchuan) for the package name. The original redis-commands is renamed to [@yuanchuan/redis-commands](https://www.npmjs.com/package/@yuanchuan/redis-commands).

package/heroku/node_modules/redis-commands/changelog.md

@@ -0,0 +1,83 @@
+## v.1.7.0 - 6 Feb, 2021
+
+Features
+
+-  Updated commands list to Redis 6.2
+
+## v.1.6.0 - 25 Jul, 2020
+
+Features
+
+-  Updated commands list to Redis 6.06
+
+## v.1.5.0 - 10 May, 2019
+
+Features
+
+-  Updated the commands list
+-  Added support for `XREAD` and `XREADGROUP` in `.getKeyIndexes()`
+
+## v.1.4.0 - 8 Oct, 2018
+
+Features
+
+-  Updated the commands list
+
+## v.1.3.5 - 28 Feb, 2018
+
+Bugfix
+
+-  Rebuild the commands with the latest stable release.
+   In v.1.3.3 the wrong Redis version was used.
+
+## v.1.3.4 - 26 Feb, 2018
+
+Chore
+
+-  Removed coverage folder from npm
+
+## v.1.3.3 - 24 Feb, 2018
+
+Features
+
+-  Rebuild the commands
+
+## v.1.3.2 - 24 Feb, 2018
+
+Chore
+
+-  Updated dependencies
+-  Fixed typos
+
+## v.1.3.1 - 25 Jan, 2017
+
+Bugfix
+
+-  Fix require for for webpack
+
+## v.1.3.0 - 20 Oct, 2016
+
+Features
+
+-  Rebuild the commands with the newest Redis unstable release
+
+## v.1.2.0 - 21 Apr, 2016
+
+Features
+
+-  Added support for `MIGRATE [...] KEYS key1, key2` (Redis >= v.3.0.6)
+-  Added build sanity check for unhandled commands with moveable keys
+-  Rebuild the commands with the newest unstable release
+-  Improved performance of .getKeyIndexes()
+
+Bugfix
+
+-  Fixed command command returning the wrong arity due to a Redis bug
+-  Fixed brpop command returning the wrong keystop due to a Redis bug
+
+## v.1.1.0 - 09 Feb, 2016
+
+Features
+
+-  Added .exists() to check for command existence
+-  Improved performance of .hasFlag()