chore: update tests & deps

Author: AVVS

.babelrc

@@ -1,6 +1,6 @@
 {
   "plugins": [
-    "transform-strict-mode",
-    "transform-object-rest-spread"
+    "@babel/plugin-transform-strict-mode",
+    "@babel/plugin-proposal-object-rest-spread"
   ]
 }

.commitlintrc.js

@@ -0,0 +1,34 @@
+module.exports = {
+  rules: {
+    'body-leading-blank': [1, 'always'],
+    'footer-leading-blank': [1, 'always'],
+    'header-max-length': [2, 'always', 72],
+    'scope-case': [2, 'always', 'lower-case'],
+    'subject-case': [
+      2,
+      'never',
+      ['sentence-case', 'start-case', 'pascal-case', 'upper-case']
+    ],
+    'subject-empty': [2, 'never'],
+    'subject-full-stop': [2, 'never', '.'],
+    'type-case': [2, 'always', 'lower-case'],
+    'type-empty': [2, 'never'],
+    'type-enum': [2, 'always', [
+        'build',
+        'ci',
+        'docs',
+        'feat',
+        'fix',
+        'perf',
+        'refactor',
+        'revert',
+        'style',
+        'test',
+        'major',
+        'minor',
+        'patch',
+        'chore'
+      ]
+    ]
+  }
+};

.gitignore

@@ -27,3 +27,5 @@ lib
 # https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git
 node_modules
 test/dump
+.nyc_output
+coverage

.releaserc.json

@@ -0,0 +1,15 @@
+{
+  "branch": "master",
+  "analyzeCommits": {
+    "preset": "angular",
+    "releaseRules": [
+      { "type": "docs", "release": "patch" },
+      { "type": "refactor", "release": "patch" },
+      { "type": "style", "release": "patch" },
+      { "type": "minor", "release": "minor" },
+      { "type": "patch", "release": "patch" },
+      { "type": "major", "release": "major" },
+      { "type": "breaking", "release": "major" }
+    ]
+  }
+}

package.json

@@ -7,10 +7,10 @@
     "node": ">= 7.6.0"
   },
   "scripts": {
-    "test": "./test/docker.sh",
+    "test": "mdep test run",
     "compile": "make all",
-    "prepublish": "npm run compile",
-    "postversion": "git push && npm publish && git push --tags"
+    "prepublishOnly": "yarn compile",
+    "semantic-release": "semantic-release"
   },
   "repository": {
     "type": "git",
@@ -33,17 +33,28 @@
     "ioredis": "2.x.x || 3.x.x"
   },
   "devDependencies": {
-    "babel-cli": "^6.24.1",
-    "babel-plugin-transform-object-rest-spread": "^6.23.0",
-    "babel-plugin-transform-strict-mode": "^6.24.1",
-    "babel-register": "^6.24.1",
-    "chai": "^3.4.1",
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/plugin-proposal-object-rest-spread": "^7.0.0",
+    "@babel/plugin-transform-strict-mode": "^7.0.0",
+    "@babel/register": "^7.0.0",
+    "@makeomatic/deploy": "^8.4.4",
+    "babel-plugin-istanbul": "^5.1.4",
+    "chai": "^4.2.0",
+    "cross-env": "^5.2.0",
     "faker": "^4.1.0",
-    "ioredis": "^2.4.0",
-    "lodash": "^4.16.3",
-    "mocha": "^3.3.0"
+    "ioredis": "^4.9.5",
+    "lodash": "^4.17.11",
+    "mocha": "^6.1.4",
+    "nyc": "^14.1.1"
   },
   "dependencies": {
-    "cluster-key-slot": "^1.0.6"
+    "cluster-key-slot": "^1.0.12"
+  },
+  "husky": {
+    "hooks": {
+      "commit-msg": "commitlint -e $HUSKY_GIT_PARAMS",
+      "prepare-commit-msg": "./node_modules/@makeomatic/deploy/git-hooks/prepare-commit-msg $HUSKY_GIT_PARAMS"
+    }
   }
 }

src/constants.js

@@ -0,0 +1 @@
+exports.FSORT_TEMP_KEYSET = 'fsort_temp_keys';

src/filtered-list-bust.lua

@@ -0,0 +1,15 @@
+-- must be a set of ids
+local idSet = KEYS[1];
+-- current time
+local curTime = ARGV[1];
+-- caching time
+local expiration = tonumber(ARGV[2] or 30000);
+
+--
+local tempKeysSet = getIndexTempKeys(idSet);
+local keys = redis.call("ZRANGEBYSCORE", tempKeysSet, curTime - expiration, '+inf');
+
+if #keys > 0 then
+  redis.call("DEL", unpack(keys));
+  redis.call("DEL", tempKeysSet);
+end

src/fsort.js

@@ -0,0 +1,72 @@
+const { FSORT_TEMP_KEYSET } = require('./constants');
+
+function getIndexTempKeys(index) {
+  return `${index}::${exports.FSORT_TEMP_KEYSET}`;
+}
+
+async function fsort(...args) {
+  const {
+    redis,
+    dlock,
+  } = this;
+
+  const [
+    idSet,
+    metadataKey,
+    hashKey,
+    order,
+    filter,
+    curTime,
+    offset = 0,
+    limit = 10,
+    expiration = 30000,
+    returnKeyOnly = false,
+  ] = args;
+
+  const tempKeysSet = getIndexTempKeys(idSet);
+  const jsonFilter = JSON.parse(filter);
+
+  const [FFLKey, PSSKey] = prepareKeys({
+    metadataKey,
+    hashKey,
+    jsonFilter,
+  });
+}
+
+function prepareKeys(opts) {
+  const {
+    metadataKey,
+    hashKey,
+    jsonFilter,
+  }
+
+  const finalFilteredListKeys = [idSet, order];
+  const preSortedSetKeys = [idSet, order];
+  const totalFilters = Object.keys(jsonFilter).length;
+
+  if (metadataKey) {
+    if (hashKey) {
+      finalFilteredListKeys.push(metadataKey, hashKey);
+      preSortedSetKeys.push(metadataKey, hashKey);
+    }
+
+    if (totalFilters > 0) {
+      finalFilteredListKeys.push(filter);
+    }
+  } else if (totalFilters >= 1 && typeof jsonFilter['#'] === 'string') {
+    finalFilteredListKeys.push(`{"#":"${jsonFilter['#']}"}`);
+  }
+
+  return [
+    finalFilteredListKeys.join(':'),
+    preSortedSetKeys.join(':'),
+  ];
+}
+
+function FilteredSort(redis, dlock) {
+  this.dlock = dlock;
+  this.redis = redis;
+  this.fsort = fsort.bind(this);
+}
+
+module.exports = dlock => new FilteredSort(dlock);

src/groupped-list.lua

@@ -0,0 +1,79 @@
+-- cached id list key
+local idListKey = KEYS[1];
+-- meta key
+local metadataKey = KEYS[2];
+-- stringified [key]: [aggregateMethod] pairs
+local aggregates = ARGV[1];
+
+-- local cache
+local rcall = redis.call;
+local tinsert = table.insert;
+
+local jsonAggregates = cjson.decode(aggregates);
+local aggregateKeys = {};
+local result = {};
+
+local function try(what)
+  local status, result = pcall(what[1]);
+  if not status then
+    return what[2](result);
+  end
+
+  return result;
+end
+
+local function catch(what)
+  return what[1]
+end
+
+local function anynumber(a)
+  return try {
+    function()
+      local num = tonumber(a);
+      return num ~= nil and num or tonumber(cjson.decode(a));
+    end,
+
+    catch {
+      function()
+        return nil;
+      end
+    }
+  }
+end
+
+local function aggregateSum(value1, value2)
+  return value1 + value2;
+end
+
+local aggregateType = {
+  sum = aggregateSum
+};
+
+for key, method in pairs(jsonAggregates) do
+  tinsert(aggregateKeys, key);
+  result[key] = 0;
+
+  if type(aggregateType[method]) ~= "function" then
+    return error("not supported op: " .. method);
+  end
+end
+
+local valuesToGroup = rcall("LRANGE", idListKey, 0, -1);
+
+-- group
+for _, id in ipairs(valuesToGroup) do
+  -- metadata is stored here
+  local metaKey = metadataKey:gsub("*", id, 1);
+  -- pull information about required aggregate keys
+  -- only 1 operation is supported now - sum
+  -- but we can calculate multiple values
+  local values = rcall("HMGET", metaKey, unpack(aggregateKeys));
+
+  for i, aggregateKey in ipairs(aggregateKeys) do
+    local aggregateMethod = aggregateType[jsonAggregates[aggregateKey]];
+    local value = anynumber(values[i]) or 0;
+    result[aggregateKey] = aggregateMethod(result[aggregateKey], value);
+  end
+end
+
+return cjson.encode(result);

src/index.js

@@ -0,0 +1,102 @@
+const fs = require('fs');
+const path = require('path');
+
+const camelCase = require('lodash/camelCase');
+const snakeCase = require('lodash/snakeCase');
+const { FSORT_TEMP_KEYSET } = require('./constants');
+
+const lua = fs.readFileSync(path.join(__dirname, 'sorted-filtered-list.lua'));
+const fsortBust = fs.readFileSync(path.join(__dirname, 'filtered-list-bust.lua'));
+const aggregateScript = fs.readFileSync(path.join(__dirname, 'groupped-list.lua'));
+
+// cached vars
+const regexp = /[\^\$\(\)\%\.\[\]\*\+\-\?]/g;
+const keys = Object.keys;
+const stringify = JSON.stringify;
+const BLACK_LIST_PROPS = ['eq', 'ne'];
+
+const luaWrapper = (script) => `
+---
+
+local function getIndexTempKeys(index)
+  return index .. "::${FSORT_TEMP_KEYSET}";
+end
+
+---
+
+${script.toString('utf-8')}
+`;
+
+/**
+ * Attached .sortedFilteredList function to ioredis instance
+ * @param  {ioredis} redis
+ */
+const fsortScript = luaWrapper(lua);
+const fsortBustScript = luaWrapper(fsortBust);
+
+exports.attach = function attachToRedis(redis, _name, useSnakeCase = false) {
+  const name = _name || 'sortedFilteredList';
+  const bustName = (useSnakeCase ? snakeCase : camelCase)(`${name}Bust`);
+  const aggregateName = (useSnakeCase ? snakeCase : camelCase)(`${name}Aggregate`);
+
+  redis.defineCommand(name, { numberOfKeys: 2, lua: fsortScript });
+  redis.defineCommand(bustName, { numberOfKeys: 1, lua: fsortBustScript });
+  redis.defineCommand(aggregateName, { numberOfKeys: 2, lua: aggregateScript });
+};
+
+exports.nonAtomic = (dlock) => require('./fsort')(dlock);
+
+/**
+ * Performs escape on a filter clause
+ * ^ $ ( ) % . [ ] * + - ? are prefixed with %
+ *
+ * @param  {String} filter
+ * @return {String}
+ */
+function escape(filter) {
+  return filter.replace(regexp, '%$&');
+};
+exports.escape = escape;
+
+/**
+ * Walks over object and escapes string, does not touch #multi.fields
+ * @param  {Object} obj
+ * @return {Object}
+ */
+function iterateOverObject(obj) {
+  const props = keys(obj);
+  const output = {};
+  props.forEach(function iterateOverProps(prop) {
+    const val = obj[prop];
+    const type = typeof val;
+    if (type === 'string' && BLACK_LIST_PROPS.indexOf(prop) === -1) {
+      output[prop] = escape(val);
+    } else if (type === 'object') {
+      if (prop !== '#multi') {
+        output[prop] = iterateOverObject(val);
+      } else {
+        output[prop] = val;
+        val.match = escape(val.match);
+      }
+    } else {
+      output[prop] = val;
+    }
+  });
+
+  return output;
+}
+
+/**
+ * Goes over filter and escapes each string
+ * @param  {Object} obj
+ * @return {String}
+ */
+exports.filter = function filter(obj) {
+  return stringify(iterateOverObject(obj));
+};
+
+/**
+ * Exports raw script
+ * @type {Buffer}
+ */
+exports.script = lua;