redis 3.1.0 → 3.1.1

package/heroku/node_modules/redis-commands/index.js

@@ -0,0 +1,168 @@
+'use strict'
+
+var commands = require('./commands.json')
+
+/**
+ * Redis command list
+ *
+ * All commands are lowercased.
+ *
+ * @var {string[]}
+ * @public
+ */
+exports.list = Object.keys(commands)
+
+var flags = {}
+exports.list.forEach(function (commandName) {
+  flags[commandName] = commands[commandName].flags.reduce(function (flags, flag) {
+    flags[flag] = true
+    return flags
+  }, {})
+})
+/**
+ * Check if the command exists
+ *
+ * @param {string} commandName - the command name
+ * @return {boolean} result
+ * @public
+ */
+exports.exists = function (commandName) {
+  return Boolean(commands[commandName])
+}
+
+/**
+ * Check if the command has the flag
+ *
+ * Some of possible flags: readonly, noscript, loading
+ * @param {string} commandName - the command name
+ * @param {string} flag - the flag to check
+ * @return {boolean} result
+ * @public
+ */
+exports.hasFlag = function (commandName, flag) {
+  if (!flags[commandName]) {
+    throw new Error('Unknown command ' + commandName)
+  }
+
+  return Boolean(flags[commandName][flag])
+}
+
+/**
+ * Get indexes of keys in the command arguments
+ *
+ * @param {string} commandName - the command name
+ * @param {string[]} args - the arguments of the command
+ * @param {object} [options] - options
+ * @param {boolean} [options.parseExternalKey] - parse external keys
+ * @return {number[]} - the list of the index
+ * @public
+ *
+ * @example
+ * ```javascript
+ * getKeyIndexes('set', ['key', 'value']) // [0]
+ * getKeyIndexes('mget', ['key1', 'key2']) // [0, 1]
+ * ```
+ */
+exports.getKeyIndexes = function (commandName, args, options) {
+  var command = commands[commandName]
+  if (!command) {
+    throw new Error('Unknown command ' + commandName)
+  }
+
+  if (!Array.isArray(args)) {
+    throw new Error('Expect args to be an array')
+  }
+
+  var keys = []
+  var i, keyStart, keyStop, parseExternalKey
+  switch (commandName) {
+    case 'zunionstore':
+    case 'zinterstore':
+      keys.push(0)
+    // fall through
+    case 'eval':
+    case 'evalsha':
+      keyStop = Number(args[1]) + 2
+      for (i = 2; i < keyStop; i++) {
+        keys.push(i)
+      }
+      break
+    case 'sort':
+      parseExternalKey = options && options.parseExternalKey
+      keys.push(0)
+      for (i = 1; i < args.length - 1; i++) {
+        if (typeof args[i] !== 'string') {
+          continue
+        }
+        var directive = args[i].toUpperCase()
+        if (directive === 'GET') {
+          i += 1
+          if (args[i] !== '#') {
+            if (parseExternalKey) {
+              keys.push([i, getExternalKeyNameLength(args[i])])
+            } else {
+              keys.push(i)
+            }
+          }
+        } else if (directive === 'BY') {
+          i += 1
+          if (parseExternalKey) {
+            keys.push([i, getExternalKeyNameLength(args[i])])
+          } else {
+            keys.push(i)
+          }
+        } else if (directive === 'STORE') {
+          i += 1
+          keys.push(i)
+        }
+      }
+      break
+    case 'migrate':
+      if (args[2] === '') {
+        for (i = 5; i < args.length - 1; i++) {
+          if (args[i].toUpperCase() === 'KEYS') {
+            for (var j = i + 1; j < args.length; j++) {
+              keys.push(j)
+            }
+            break
+          }
+        }
+      } else {
+        keys.push(2)
+      }
+      break
+    case 'xreadgroup':
+    case 'xread':
+      // Keys are 1st half of the args after STREAMS argument.
+      for (i = commandName === 'xread' ? 0 : 3; i < args.length - 1; i++) {
+        if (String(args[i]).toUpperCase() === 'STREAMS') {
+          for (j = i + 1; j <= i + ((args.length - 1 - i) / 2); j++) {
+            keys.push(j)
+          }
+          break
+        }
+      }
+      break
+    default:
+      // Step has to be at least one in this case, otherwise the command does
+      // not contain a key.
+      if (command.step > 0) {
+        keyStart = command.keyStart - 1
+        keyStop = command.keyStop > 0 ? command.keyStop : args.length + command.keyStop + 1
+        for (i = keyStart; i < keyStop; i += command.step) {
+          keys.push(i)
+        }
+      }
+      break
+  }
+
+  return keys
+}
+
+function getExternalKeyNameLength (key) {
+  if (typeof key !== 'string') {
+    key = String(key)
+  }
+  var hashPos = key.indexOf('->')
+  return hashPos === -1 ? key.length : hashPos
+}

package/heroku/node_modules/redis-commands/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "redis-commands",
+  "version": "1.7.0",
+  "description": "Redis commands",
+  "main": "index.js",
+  "scripts": {
+    "pretest": "npm run lint",
+    "test": "mocha",
+    "posttest": "npm run coverage && npm run coverage:check",
+    "coverage": "node ./node_modules/istanbul/lib/cli.js cover --preserve-comments ./node_modules/mocha/bin/_mocha -- -R spec",
+    "coverage:check": "node ./node_modules/istanbul/lib/cli.js check-coverage --branch 100 --statement 100",
+    "build": "node tools/build",
+    "lint": "standard --fix --verbose | snazzy"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NodeRedis/redis-commands.git"
+  },
+  "keywords": [
+    "redis",
+    "commands",
+    "prefix"
+  ],
+  "author": "luin <i@zihua.li> (http://zihua.li)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/NodeRedis/redis-commands/issues"
+  },
+  "homepage": "https://github.com/NodeRedis/redis-commands",
+  "devDependencies": {
+    "chai": "^4.0.1",
+    "codeclimate-test-reporter": "^0.5.1",
+    "ioredis": "^4.9.0",
+    "istanbul": "^0.4.3",
+    "safe-stable-stringify": "^1.0.0",
+    "mocha": "^6.0.0",
+    "snazzy": "^8.0.0",
+    "standard": "^12.0.0"
+  },
+  "dependencies": {}
+}

package/heroku/node_modules/redis-commands/tools/build.js

@@ -0,0 +1,62 @@
+var fs = require('fs')
+var path = require('path')
+var stringify = require('safe-stable-stringify')
+var commandPath = path.join(__dirname, '..', 'commands.json')
+var redisCommands = require('../')
+
+var Redis = require('ioredis')
+var redis = new Redis(process.env.REDIS_URI)
+
+redis.command().then(function (res) {
+  redis.disconnect()
+
+  // Find all special handled cases
+  var movableKeys = String(redisCommands.getKeyIndexes).match(/case '[a-z-]+':/g).map(function (entry) {
+    return entry.replace(/^case '|':$/g, '')
+  })
+
+  var commands = res.reduce(function (prev, current) {
+    var currentCommandPos = movableKeys.indexOf(current[0])
+    if (currentCommandPos !== -1 && current[2].indexOf('movablekeys') !== -1) {
+      movableKeys.splice(currentCommandPos, 1)
+    }
+    // https://github.com/antirez/redis/issues/2598
+    if (current[0] === 'brpop' && current[4] === 1) {
+      current[4] = -2
+    }
+    prev[current[0]] = {
+      arity: current[1] || 1, // https://github.com/antirez/redis/pull/2986
+      flags: current[2],
+      keyStart: current[3],
+      keyStop: current[4],
+      step: current[5]
+    }
+    return prev
+  }, {})
+
+  // Future proof. Redis might implement this at some point
+  // https://github.com/antirez/redis/pull/2982
+  if (!commands.quit) {
+    commands.quit = {
+      arity: 1,
+      flags: [
+        'loading',
+        'stale',
+        'readonly'
+      ],
+      keyStart: 0,
+      keyStop: 0,
+      step: 0
+    }
+  }
+
+  if (movableKeys.length !== 0) {
+    throw new Error('Not all commands (\'' + movableKeys.join('\', \'') + '\') with the "movablekeys" flag are handled in the code')
+  }
+
+  // Use safe-stable-stringify instead fo JSON.stringify
+  // for easier diffing
+  var content = stringify(commands, null, '  ')
+
+  fs.writeFileSync(commandPath, content)
+})

package/heroku/node_modules/redis-errors/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Ruben Bridgewater
+
+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-errors/README.md

@@ -0,0 +1,116 @@
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)
+
+# redis-errors
+
+All error classes used in [node_redis](https://github.com/NodeRedis/node_redis)
+from v.3.0.0 are in here. They can be required as needed.
+
+## Install
+
+Install with [NPM](https://npmjs.org/):
+
+  npm install redis-errors
+
+## Usage
+
+```js
+const { ReplyError, InterruptError } = require('redis-errors');
+
+// Using async await
+try {
+  await client.set('foo') // Missing value
+} catch (err) {
+  if (err instanceof InterruptError) {
+    console.error('Command might have been processed')
+  }
+  if (err instanceof ReplyError) {
+    // ...
+  }
+  throw err
+}
+
+// Using callbacks
+client.set('foo', (err, res) => {
+  if (err) {
+    if (err instanceof InterruptError) {
+      // ...
+    }
+  }
+})
+```
+
+### Error classes
+
+All errors returned by NodeRedis use own Error classes. You can distinguish
+different errors easily by checking for these classes.
+
+To know what caused the error they might contain properties to know in more
+detail what happened.
+
+Each error contains a `message`, a `name` and a `stack` property. Please be aware
+that the stack might not be useful due to the async nature and is in those cases
+therefore limited to two frames.
+
+There might be more not yet documented properties as well. Please feel free to
+open a pull request to document those as well.
+
+#### RedisError
+
+`Properties`:
+
+Properties depend on the individual error.
+
+All errors returned by NodeRedis (client) are `RedisError`s.  
+Subclass of `Error`
+
+#### ReplyError
+
+`Properties`:
+
+* `args`: The arguments passed to the command.
+* `command`: The command name.
+* `code`: The `Redis` error code. Redis itself uses some internal error codes.
+
+All errors returned by Redis itself (server) will be a `ReplyError`.  
+Subclass of `RedisError`
+
+#### ParserError
+
+`Properties`:
+
+* `buffer`: The raw buffer input stringified.
+* `offset`: The character count where the parsing error occurred.
+
+Parsing errors are returned as `ParserError`.  
+Subclass of `RedisError`
+**Note:** If you encounter one of these please report that error including the
+attached `offset` and `buffer` properties!  
+
+#### AbortError
+
+`Properties`:
+
+* `args`: The arguments passed to the command.
+* `command`: The command name.
+
+If a command was not yet executed but rejected, it'll return a `AbortError`.  
+Subclass of `RedisError`
+
+#### InterruptError
+
+`Properties`:
+
+* `args`: The arguments passed to the command.
+* `command`: The command name.
+* `origin`: The original error that caused the interrupt
+
+All executed commands that could not fulfill (e.g. network drop while
+executing) return a `InterruptError`.  
+Subclass of `AbortError`  
+**Note:** Interrupt errors can happen for multiple reasons that are out of the
+scope of NodeRedis itself. There is nothing that can be done on library side
+to prevent those.
+
+## License
+
+[MIT](./LICENSE)

package/heroku/node_modules/redis-errors/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const Errors = process.version.charCodeAt(1) < 55 && process.version.charCodeAt(2) === 46
+  ? require('./lib/old') // Node.js < 7
+  : require('./lib/modern')
+
+module.exports = Errors

package/heroku/node_modules/redis-errors/lib/modern.js

@@ -0,0 +1,59 @@
+'use strict'
+
+const assert = require('assert')
+
+class RedisError extends Error {
+  get name () {
+    return this.constructor.name
+  }
+}
+
+class ParserError extends RedisError {
+  constructor (message, buffer, offset) {
+    assert(buffer)
+    assert.strictEqual(typeof offset, 'number')
+
+    const tmp = Error.stackTraceLimit
+    Error.stackTraceLimit = 2
+    super(message)
+    Error.stackTraceLimit = tmp
+    this.offset = offset
+    this.buffer = buffer
+  }
+
+  get name () {
+    return this.constructor.name
+  }
+}
+
+class ReplyError extends RedisError {
+  constructor (message) {
+    const tmp = Error.stackTraceLimit
+    Error.stackTraceLimit = 2
+    super(message)
+    Error.stackTraceLimit = tmp
+  }
+  get name () {
+    return this.constructor.name
+  }
+}
+
+class AbortError extends RedisError {
+  get name () {
+    return this.constructor.name
+  }
+}
+
+class InterruptError extends AbortError {
+  get name () {
+    return this.constructor.name
+  }
+}
+
+module.exports = {
+  RedisError,
+  ParserError,
+  ReplyError,
+  AbortError,
+  InterruptError
+}

package/heroku/node_modules/redis-errors/lib/old.js

@@ -0,0 +1,119 @@
+'use strict'
+
+const assert = require('assert')
+const util = require('util')
+
+// RedisError
+
+function RedisError (message) {
+  Object.defineProperty(this, 'message', {
+    value: message || '',
+    configurable: true,
+    writable: true
+  })
+  Error.captureStackTrace(this, this.constructor)
+}
+
+util.inherits(RedisError, Error)
+
+Object.defineProperty(RedisError.prototype, 'name', {
+  value: 'RedisError',
+  configurable: true,
+  writable: true
+})
+
+// ParserError
+
+function ParserError (message, buffer, offset) {
+  assert(buffer)
+  assert.strictEqual(typeof offset, 'number')
+
+  Object.defineProperty(this, 'message', {
+    value: message || '',
+    configurable: true,
+    writable: true
+  })
+
+  const tmp = Error.stackTraceLimit
+  Error.stackTraceLimit = 2
+  Error.captureStackTrace(this, this.constructor)
+  Error.stackTraceLimit = tmp
+  this.offset = offset
+  this.buffer = buffer
+}
+
+util.inherits(ParserError, RedisError)
+
+Object.defineProperty(ParserError.prototype, 'name', {
+  value: 'ParserError',
+  configurable: true,
+  writable: true
+})
+
+// ReplyError
+
+function ReplyError (message) {
+  Object.defineProperty(this, 'message', {
+    value: message || '',
+    configurable: true,
+    writable: true
+  })
+  const tmp = Error.stackTraceLimit
+  Error.stackTraceLimit = 2
+  Error.captureStackTrace(this, this.constructor)
+  Error.stackTraceLimit = tmp
+}
+
+util.inherits(ReplyError, RedisError)
+
+Object.defineProperty(ReplyError.prototype, 'name', {
+  value: 'ReplyError',
+  configurable: true,
+  writable: true
+})
+
+// AbortError
+
+function AbortError (message) {
+  Object.defineProperty(this, 'message', {
+    value: message || '',
+    configurable: true,
+    writable: true
+  })
+  Error.captureStackTrace(this, this.constructor)
+}
+
+util.inherits(AbortError, RedisError)
+
+Object.defineProperty(AbortError.prototype, 'name', {
+  value: 'AbortError',
+  configurable: true,
+  writable: true
+})
+
+// InterruptError
+
+function InterruptError (message) {
+  Object.defineProperty(this, 'message', {
+    value: message || '',
+    configurable: true,
+    writable: true
+  })
+  Error.captureStackTrace(this, this.constructor)
+}
+
+util.inherits(InterruptError, AbortError)
+
+Object.defineProperty(InterruptError.prototype, 'name', {
+  value: 'InterruptError',
+  configurable: true,
+  writable: true
+})
+
+module.exports = {
+  RedisError,
+  ParserError,
+  ReplyError,
+  AbortError,
+  InterruptError
+}

package/heroku/node_modules/redis-errors/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "redis-errors",
+  "version": "1.2.0",
+  "description": "Error classes used in node_redis",
+  "main": "index.js",
+  "scripts": {
+    "test": "npm run coverage",
+    "lint": "standard --fix",
+    "posttest": "npm run lint && npm run coverage:check",
+    "coverage": "node ./node_modules/istanbul/lib/cli.js cover --preserve-comments ./node_modules/mocha/bin/_mocha -- -R spec",
+    "coverage:check": "node ./node_modules/istanbul/lib/cli.js check-coverage --statement 100"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NodeRedis/redis-errors.git"
+  },
+  "keywords": [
+    "redis",
+    "javascript",
+    "node",
+    "error"
+  ],
+  "engines": {
+    "node": ">=4"
+  },
+  "devDependencies": {
+    "istanbul": "^0.4.0",
+    "mocha": "^3.1.2",
+    "standard": "^10.0.0"
+  },
+  "author": "Ruben Bridgewater",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/NodeRedis/redis-errors/issues"
+  },
+  "homepage": "https://github.com/NodeRedis/redis-errors#readme",
+  "directories": {
+    "test": "test",
+    "lib": "lib"
+  }
+}

package/heroku/node_modules/redis-parser/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.
+