@lskjs/scylla/BaseScyllaModel.js

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _mapKeys = _interopRequireDefault(require("@lskjs/utils/mapKeys"));

var _mapValuesKeys = _interopRequireDefault(require("@lskjs/utils/mapValuesKeys"));

var _tryJSONparse = _interopRequireDefault(require("@lskjs/utils/tryJSONparse"));

var _tryJSONstringify = _interopRequireDefault(require("@lskjs/utils/tryJSONstringify"));

var _isFinite = _interopRequireDefault(require("lodash/isFinite"));

var _map = _interopRequireDefault(require("lodash/map"));

var _mapValues = _interopRequireDefault(require("lodash/mapValues"));

var _snakeCase = _interopRequireDefault(require("lodash/snakeCase"));

var notNan = function notNan(a) {
  return (0, _isFinite["default"])(a) ? a : null;
};

var BaseScyllaModel = /*#__PURE__*/function () {
  function BaseScyllaModel(_ref) {
    var app = _ref.app;
    (0, _classCallCheck2["default"])(this, BaseScyllaModel);
    this.app = app;
    this.log = app.log;
    if (!this.schema) this.schema = this.getSchema();
  }

  (0, _createClass2["default"])(BaseScyllaModel, [{
    key: "getSchema",
    value: function getSchema() {
      return {};
    }
  }, {
    key: "stringifyData",
    value: function stringifyData(data) {
      var _this = this;

      return (0, _mapValues["default"])(data, function (value, key) {
        var type = _this.schema[key];

        if (!type) {
          _this.log.warn('missing field in schema: ', key);

          return undefined;
        }

        if (['int', 'bigint', 'smallint'].includes(type)) return notNan(Number(value));
        if (type === 'text<json>') return (0, _tryJSONstringify["default"])(value);
        if (type === 'timestamp') return new Date(value).getTime();

        if (type.startsWith('list')) {
          var value2 = Array.isArray(value) ? value.filter(function (a) {
            return a !== null && a !== undefined;
          }) : null; // console.log({ value, value2 });

          return value2;
        }

        return value;
      });
    }
  }, {
    key: "parseData",
    value: function parseData(data) {
      var _this2 = this;

      return (0, _mapValuesKeys["default"])(data, function (value, key) {
        var type = _this2.schema[key];
        if (typeof value === 'undefined') return null;
        if (type === 'text<json>') return {
          key: key,
          value: (0, _tryJSONparse["default"])(value)
        };
        if (type === 'timestamp') return {
          key: key,
          value: new Date(value)
        };
        return {
          key: key,
          value: value
        };
      });
    }
  }, {
    key: "getSchemaString",
    value: function getSchemaString() {
      var schema = (0, _mapKeys["default"])(this.schema, function (value, key) {
        var newKey = key[0] === '_' ? "_".concat((0, _snakeCase["default"])(key)) : (0, _snakeCase["default"])(key);
        if (newKey[0] === '_') return "\"".concat(newKey, "\"");
        return newKey;
      });
      return (0, _map["default"])(schema, function (value, key) {
        return "".concat(key, " ").concat(value === 'text<json>' ? 'text' : value);
      }).join(',\n');
    }
  }, {
    key: "createInsertQuery",
    value: function createInsertQuery(table, data) {
      var keys = Object.keys(data);
      var defaultKeyspace = this.scylla.config.defaultKeyspace;
      return "INSERT INTO ".concat(defaultKeyspace, ".").concat(this.table, " (").concat(keys.map(function (key) {
        return "\"".concat(key, "\"");
      }).join(', '), ") VALUES (").concat(keys.map(function () {
        return '?';
      }).join(', '), ")");
    }
  }, {
    key: "execute",
    value: function () {
      var _execute = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(query, values, options, json) {
        var res;
        return _regenerator["default"].wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                if (this.scylla.debug) this.scylla.log.trace("[scylla] table=".concat(this.table, "\n"), query, values);
                _context.prev = 1;
                _context.next = 4;
                return this.scylla.execute(query, values, options);

              case 4:
                res = _context.sent;
                return _context.abrupt("return", res);

              case 8:
                _context.prev = 8;
                _context.t0 = _context["catch"](1);
                this.scylla.log.warn("[scylla] table=".concat(this.table, "\n"), query);
                this.scylla.log.trace(json || values);
                this.scylla.log.error('[scylla] err ', _context.t0);
                throw _context.t0;

              case 14:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this, [[1, 8]]);
      }));

      function execute(_x, _x2, _x3, _x4) {
        return _execute.apply(this, arguments);
      }

      return execute;
    }()
  }, {
    key: "run",
    value: function () {
      var _run = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
        return _regenerator["default"].wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _context2.next = 2;
                return this.app.module('scylla');

              case 2:
                this.scylla = _context2.sent;

              case 3:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function run() {
        return _run.apply(this, arguments);
      }

      return run;
    }()
  }], [{
    key: "run",
    value: function () {
      var _run2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(props) {
        var obj;
        return _regenerator["default"].wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                obj = new this(props);
                _context3.next = 3;
                return obj.run();

              case 3:
                return _context3.abrupt("return", obj);

              case 4:
              case "end":
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      function run(_x5) {
        return _run2.apply(this, arguments);
      }

      return run;
    }()
  }]);
  return BaseScyllaModel;
}();

var _default = BaseScyllaModel;
exports["default"] = _default;
//# sourceMappingURL=BaseScyllaModel.js.map