tabel/lib/kredis/Client.js

A simple orm for PostgreSQL which works with simple javascript objects and arrays

'use strict';

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var redisdsl = require('redisdsl');

var _require = require('lodash'),
    isString = _require.isString,
    isNumber = _require.isNumber,
    isArray = _require.isArray;

var Queue = require('./Queue');
var Hash = require('./Hash');

var Connection = function Connection(config) {
  var _this = this;

  _classCallCheck(this, Connection);

  this.config = _extends({}, config, 'keyPrefix' in config ? { prefix: config.keyPrefix } : {});

  var _redisdsl = redisdsl(this.config),
      quit = _redisdsl.quit,
      psetex = _redisdsl.psetex,
      set = _redisdsl.set,
      get = _redisdsl.get,
      exists = _redisdsl.exists,
      del = _redisdsl.del,
      lrange = _redisdsl.lrange,
      rpush = _redisdsl.rpush,
      lpop = _redisdsl.lpop,
      rEval = _redisdsl.eval;

  Object.assign(this, {
    cmd: {
      quit: quit,
      psetex: psetex,
      set: set,
      get: get,
      exists: exists,
      del: del,
      lrange: lrange,
      rpush: rpush,
      lpop: lpop,
      rEval: rEval,
      clear: function clear(prefix) {
        var pattern = isString(prefix) ? prefix + '*' : '*';

        var luaScript = ['local keys = redis.call("keys", "' + _this.config.prefix + pattern + '")', 'for i=1,#keys,5000 do', '    redis.call("del", unpack(keys, i, math.min(i+4999, #keys)))', 'end', 'return keys'].join('\r\n');

        return _this.cmd.rEval(luaScript, 0);
      }
    }
  });

  // console.log(this.cmd.clear);
};

var Client = function () {
  function Client(config) {
    _classCallCheck(this, Client);

    this.connection = new Connection(config);
  }

  _createClass(Client, [{
    key: 'disconnect',
    value: function disconnect() {
      return this.connection.cmd.quit();
    }
  }, {
    key: 'set',
    value: function set(key, val, lifetime) {
      if (isNumber(lifetime)) {
        return this.connection.cmd.psetex(key, lifetime, JSON.stringify(val));
      } else {
        return this.connection.cmd.set(key, JSON.stringify(val));
      }
    }
  }, {
    key: 'put',
    value: function put(values, lifetime) {
      var _this2 = this;

      return Promise.all(Object.keys(values).map(function (key) {
        return _this2.connection.cmd.set(key, values[key], lifetime);
      }));
    }
  }, {
    key: 'get',
    value: function get(key) {
      var _this3 = this;

      var defaultVal = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

      if (isArray(key)) {
        return Promise.all(key.map(function (k) {
          return _this3.connection.cmd.get(k, defaultVal);
        }));
      }

      return this.connection.cmd.get(key).then(function (val) {
        if (val === null) {
          return defaultVal;
        } else {
          return JSON.parse(val);
        }
      });
    }
  }, {
    key: 'exists',
    value: function exists(key) {
      var _this4 = this;

      if (isArray(key)) {
        return Promise.all(key.map(function (k) {
          return _this4.exists(k);
        }));
      }

      return this.connection.cmd.exists(key).then(function (result) {
        return result !== 0;
      });
    }
  }, {
    key: 'del',
    value: function del(key) {
      var _this5 = this;

      if (isArray(key)) {
        return Promise.all(key.map(function (k) {
          return _this5.del(k);
        }));
      }

      return this.connection.cmd.del(key);
    }
  }, {
    key: 'delete',
    value: function _delete(key) {
      return this.del(key);
    }
  }, {
    key: 'clear',
    value: function clear(prefix) {
      return this.connection.cmd.clear(prefix);
    }
  }, {
    key: 'range',
    value: function range(queue) {
      var startI = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
      var endI = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;

      return this.connection.cmd.lrange(queue, startI, endI).then(function (items) {
        return items.map(function (item) {
          return JSON.parse(item);
        });
      });
    }
  }, {
    key: 'nq',
    value: function nq(queue, vals) {
      if (isArray(vals)) {
        vals = vals.map(function (v) {
          return JSON.stringify(v);
        });
      } else {
        vals = JSON.stringify(vals);
      }

      return this.connection.cmd.rpush(queue, vals);
    }
  }, {
    key: 'dq',
    value: function dq(queue) {
      return this.connection.cmd.lpop(queue).then(function (val) {
        return JSON.parse(val);
      });
    }
  }, {
    key: 'queue',
    value: function queue(name) {
      return new Queue(this, name);
    }
  }, {
    key: 'hash',
    value: function hash(name) {
      return new Hash(this, name);
    }
  }]);

  return Client;
}();

module.exports = Client;