kanso-orm/lib/relationship.js

'use strict';
function Relationship(config) {
  this.ORM = config.ORM;
  this.type = config.type;
  this.modelFactoryName = config.modelFactoryName;
  // TEMP
  if(!config.throughTableName) {
    this.identifer = {
      parent: config.parentIdentifer,
      child: config.childIdentifer,
    };
  } else {
    this.identifer = {
      parent_0: config.parentIdentifer_0,
      child_0: config.childIdentifer_0,
      parent_1: config.parentIdentifer_1,
      child_1: config.childIdentifer_1
    };
    this.throughTableName = config.throughTableName;
    Relationship.createThroughModelFactory(this.ORM, this.modelFactoryName, this.throughTableName, this.identifer);
  }
}

Relationship.Types = {
  belongsToOne: 'BELONGS_TO_ONE',
  belongsToMany: 'BELONGS_TO_MANY',
  hasOne: 'HAS_ONE',
  hasMany: 'HAS_MANY'
};

//
// Private
//
Relationship.createThroughModelFactory = function(ORM, modelFactoryName, tableName, identifer) {
  // Base model
  var model = {
    attributes: {}
  };
  // Create table attribute
  model.attributes[identifer.parent_0] = {};
  model.attributes[identifer.parent_1] = {};

  // Create relation
  model.attributes[modelFactoryName] = function(context) {
    return context.belongsToOne(modelFactoryName, identifer.child_1, identifer.parent_1);
  };

  // Create new factory if it doesn't exist
  // If it does, update the factory's attributes to include identifer
  if(!ORM.models.hasOwnProperty(tableName)) {
    ORM.Model.extend(tableName, model);
  } else {
    ORM.models[tableName].addTableAttributes(model.attributes);
  }
};

//
// Create
//

Relationship.prototype.createBelongsToOne = function(attributes, options) {
  return ORM.models[this.modelFactoryName].create(attributes, options);
};

Relationship.prototype.createBelongsToMany = function(attributesMany, options) {
  var promises = [];
  attributesMany.map((attributes) => {
    var promise = this.createBelongsToOne(attributes, options);
    promises.push(promise);
  });
  return Promise.all(promises);
};

Relationship.prototype.createHasOne = function(attributes, parentModel, options) {
  var newAttributes = Object.assign({}, attributes, {
    [this.identifer.child]: parentModel[this.identifer.parent]
  });
  return ORM.models[this.modelFactoryName].create(newAttributes, options);
};

Relationship.prototype.createHasMany = function(attributesMany, parentModel, options) {
  var promises = [];
  attributesMany.map((attributes) => {
    var promise = this.createHasOne(attributes, parentModel, options);
    promises.push(promise);
  });
  return Promise.all(promises);
};

//
// Attach
//

Relationship.prototype.attachAsAttribute = function(attributes, parentModel) {
  var newAttributes = {};
  newAttributes[this.identifer.child] = parentModel[this.identifer.parent];
  return Object.assign(attributes, newAttributes);
};

// Note: parameter parentModel needs to be renamed,
// in many-to-many the related models are siblings.
// Parent should be refering to the Through table only.
Relationship.prototype.attach = function(childModel, parentModels, options) {
  var promises = [];
  parentModels.forEach(function(parentModel) {
    var attributes = {
      [this.identifer.parent_0]: childModel[this.identifer.child_0],
      [this.identifer.parent_1]: parentModel[this.identifer.child_1]
    };
    var promise = this.ORM.models[this.throughTableName].create(attributes, options);
    promises.push(promise);
  }, this);
  return Promise.all(promises);
};

//
// Include
//

Relationship.prototype.include = function(table, childModel) {
  var self = this;
  var promises = [];
  var query = {};
  var promise;
  switch(self.type) {
    case Relationship.Types.hasOne:
    case Relationship.Types.belongsToOne: {
      query[self.identifer.parent] = childModel[self.identifer.child];
      promise = self.ORM.models[self.modelFactoryName].findOne(query);
      break;
    }
    case Relationship.Types.belongsToMany : {
      query = {};
      var include = [self.modelFactoryName];
      // selfThroughIdentifer, selfIdentifer
      promise = new Promise(function(resolve, reject) {
        var models = [];
        query[self.identifer.parent_0] = childModel[self.identifer.child_0];
        // Get all through models
        self.ORM.models[self.throughTableName].find(query, {
          include: include
        })
        // Extract desired model in through model
        .then(function(throughModels) {
          throughModels.forEach(function(throughModel) {
            models.push(throughModel[self.modelFactoryName]);
          });
          resolve(models);
        })
        .catch(function(error) {
          reject(error);
        });
      });
      promises.push(promise);
      break;
    }
    case Relationship.Types.hasMany: {
      query = {};
      query[self.identifer.child] = childModel[self.identifer.parent];
      promise = self.ORM.models[self.modelFactoryName].find(query);
      promises.push(promise);
      break;
    }
  }
  return promise.then((model) => {
    childModel[table] = model;
    return childModel;
  });
};

//
// Helper
//
Relationship.prototype.getThroughTable = function() {
  return (this.type === Relationship.Types.belongsToMany)
  ? this.throughTableName
  : this.modelFactoryName;
};



module.exports = Relationship;