@linaframework/arango-orm/dist/models/model.js

> Please check out https://github.com/awesome-graphql-space/lina and https://github.com/oknoah/final/packages/arangolize for similar projects that MAY be more up to date

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _create = require('babel-runtime/core-js/object/create');

var _create2 = _interopRequireDefault(_create);

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _arangojs = require('arangojs');

var _arangojs2 = _interopRequireDefault(_arangojs);

var _schema = require('../schemas/schema');

var _schema2 = _interopRequireDefault(_schema);

var _lodash = require('lodash');

var _arangolize = require('arangolize');

var _arangolize2 = _interopRequireDefault(_arangolize);

function _interopRequireDefault(obj) {
  return obj && obj.__esModule ? obj : { default: obj };
}

var Model = function () {
  function Model() {
    (0, _classCallCheck3.default)(this, Model);
  }

  (0, _createClass3.default)(Model, [{
    key: 'save',

    /******************* public methods *******************/
    value: async function save() {
      return this.constructor.save(this);
    }
  }, {
    key: 'update',
    value: async function update() {
      return this.constructor.update(this);
    }
  }, {
    key: 'remove',
    value: async function remove() {
      return this.constructor.remove(this);
    }
  }, {
    key: 'restore',
    value: async function restore() {
      return this.constructor.restore(this);
    }
  }], [{
    key: '_getSchema',
    // user schema

    value: function _getSchema() {
      if (!this._normalSchema) {
        this._normalSchema = new _schema2.default(this.schema);
      }
      return this._normalSchema;
    } // connection options

  }, {
    key: '_getDatabase',
    value: async function _getDatabase() {
      if (Model._database) {
        return Model._database;
      }

      var dbName = this.options.database;
      var host = this.options.host || 'localhost';
      var port = this.options.port || 8529;
      var username = this.options.username || 'root';
      var password = this.options.password || '';
      var protocol = this.options.protocol || '' + (host === 'localhost' ? 'http' : 'https');
      var url = this.options.url || protocol + '://' + username + ':' + password + '@' + host + ':' + port;

      var db = (0, _arangojs2.default)({
        url: url
      });

      try {
        await db.createDatabase(dbName);
      } catch (e) {
        // throw new Error(get(e, 'response.body.errorMessage', e))
      }

      db.useDatabase(dbName);

      Model._database = db;
      return db;
    }
  }, {
    key: '_getCollection',
    value: async function _getCollection() {
      if (this._collection) {
        await this._setIndexes(this._collection);
        return this._collection;
      }

      var db = await this._getDatabase();
      var collection = db.collection(this.name);
      try {
        await collection.create();
        await this._setIndexes(collection);
      } catch (e) {}
      return this._collection = collection;
    }
  }, {
    key: '_setIndexes',
    value: async function _setIndexes(collection) {
      var schema = this._getSchema();
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

      try {
        for (var _iterator = (0, _getIterator3.default)(schema.fields), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          var field = _step.value;

          if (!field.options.index) continue;

          var path = field.path.join('.');
          var unique = field.options.unique;
          await collection.createHashIndex(path, { unique: unique });
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }
    }
  }, {
    key: '_call',
    value: async function _call(method) {
      try {
        var collection = await this._getCollection();
        if (!collection[method]) {
          throw Error('Collection has no method \'' + method + '\'');
        }

        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          args[_key - 1] = arguments[_key];
        }

        return await collection[method].apply(collection, args);
      } catch (e) {
        throw new Error((0, _lodash.get)(e, 'response.body.errorMessage', e));
      }
    }
  }, {
    key: '_validate',
    value: function _validate(data) {
      var schema = this._getSchema();
      schema.validate(data);
    }
  }, {
    key: '_getDocument',
    value: function _getDocument(documentHandle) {
      return this._call('document', documentHandle);
    }
  }, {
    key: '_getDocuments',
    value: function _getDocuments(documentHandles) {
      return this._call('lookupByKeys', documentHandles);
    }
  }, {
    key: '_createModelByDocument',
    value: function _createModelByDocument(document) {
      var model = (0, _create2.default)(this.prototype);
      this._documentToModel(model, document);
      model.constructor();
      return model;
    }
  }, {
    key: '_documentToModel',
    value: function _documentToModel(model, document) {
      var schema = this._getSchema();
      schema.documentToModel(model, document);
      return model;
    }
  }, {
    key: '_modelToDocument',
    value: function _modelToDocument(model) {
      var schema = this._getSchema();
      var document = {};
      schema.modelToDocument(model, document);
      return document;
    }

    /******************* public static methods *******************/

  }, {
    key: 'add',
    value: async function add(data) {
      this._validate(data);
      data = this._modelToDocument(data);
      data._removed = false;
      data.createdAt = new Date().toISOString();
      var documentHandle = await this._call('save', data);
      var document = await this._call('document', documentHandle);
      return this._createModelByDocument(document);
    }
  }, {
    key: 'get',
    value: async function get(documentHandle) {
      var document = await this._getDocument(documentHandle);
      return this._createModelByDocument(document);
    }
  }, {
    key: 'getArr',
    value: async function getArr(documentHandles) {
      var _this = this;

      var documents = await this._getDocuments(documentHandles);
      return documents.map(function (document) {
        return _this._createModelByDocument(document);
      });
    }
  }, {
    key: 'save',
    value: async function save(model) {
      this._validate(model);
      var document = this._modelToDocument(model);
      document.updatedAt = new Date().toISOString();
      var newHandle = await this._call('update', model._id, document);
      model._rev = newHandle._rev;
      return model;
    }
  }, {
    key: 'update',
    value: async function update(model) {
      var document = await this._getDocument(model);
      this._documentToModel(model, document);
      return model;
    }
  }, {
    key: 'remove',
    value: async function remove(model) {
      model._removed = true;
      return this.save(model);
    }
  }, {
    key: 'restore',
    value: async function restore(model) {
      model._removed = false;
      return this.save(model);
    }
  }, {
    key: 'find',
    value: async function find(args) {
      var _this2 = this;

      var andCount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

      var db = await this._getDatabase();

      var _ref = await (0, _arangolize2.default)((0, _extends3.default)({
        collection: this.name
      }, args)),
          bindVars = _ref.bindVars,
          query = _ref.query;

      var cursor = await db.query({
        query: query,
        bindVars: bindVars
      });
      var docs = await cursor.all();
      var documents = docs[0];

      if (documents) {
        var limit = args.limit,
            include = args.include;

        var modeled = await _promise2.default.all(documents.data.map(async function (data) {
          var modelFromDoc = include ? data : _this2._createModelByDocument(data);

          return modelFromDoc;
        }));

        if (andCount) {
          return {
            data: modeled,
            meta: documents.meta
          };
        }

        return limit === 1 ? modeled[0] : modeled;
      }
    }
  }, {
    key: 'findOne',
    value: async function findOne() {
      var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      args.skip = 0;
      args.limit = 1;
      var model = await this.find(args);
      return model;
    }
  }, {
    key: 'findAndCount',
    value: async function findAndCount() {
      var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var results = await this.find(args, true);
      return results;
    }
  }, {
    key: 'count',
    value: async function count(selector) {
      var cursor = await this._call('byExample', selector);
      return cursor.count;
    }
  }, {
    key: 'have',
    value: async function have(selector) {
      var model = await this.findOne(selector);
      return !!model;
    }
  }]);
  return Model;
}();

Model.options = null;
Model.schema = null;
Model._normalSchema = null;
Model._collection = null;
Model._database = null;
Model.aql = _arangojs.aql;
exports.default = Model;