kanso-orm/lib/relationship.js

'use strict';
function Relationship(config) {
  this.ORM = config.ORM;
  this.tableName = config.tableName;
  this.type = config.type;
  this.modelFactoryName = config.modelFactoryName;
  this.identifer = {
    parent: config.parentIdentifer,
    child: config.childIdentifer
  };
  if(this.type === Relationship.Types.belongsToMany) {
    this.throughTableName = config.throughTableName;
    this.throughModel = Relationship.createThroughModelFactory(
      this.ORM,
      this.tableName,
      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, table, throughTable, identifer) {
  // Base model
  var model = {
    attributes: {}
  };
  // Create table attribute
  model.attributes[identifer.child] = {};
  // Create relation
  model.attributes[table] = function(context) {
    return context.belongsToOne(table, identifer.parent, identifer.child);
  };
  // Create new factory if it doesn't exist
  // If it does, update the factory's attributes to include identifer
  if(!ORM.models.hasOwnProperty(throughTable)) {
    ORM.Model.extend(throughTable, model);
  } else {
    ORM.models[throughTable].addTableAttributes(model.attributes);
  }
  // Return
  return ORM.models[throughTable];
};

//
// Create
//

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

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

//
// 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) {
    let targetIdentifer = this.getTargetModel().identifer;
    var attributes = {
      [targetIdentifer.child]: parentModel[targetIdentifer.parent],
      [this.identifer.child]: childModel[this.identifer.parent]
    };
    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: {
      if(childModel[self.identifer.child]) {
        query[self.identifer.parent] = childModel[self.identifer.child];
        promise = self.ORM.models[self.modelFactoryName].findOne(query);
      } else {
        promise = Promise.resolve(null);
      }
      break;
    }
    case Relationship.Types.belongsToMany : {
      query = {};
      // selfThroughIdentifer, selfIdentifer
      promise = new Promise(function(resolve, reject) {
        var models = [];
        query[self.identifer.child] = childModel[self.identifer.parent];
        // Get all through models
        self.ORM.models[self.throughTableName].find(query, {
          include: [{ relation: self.modelFactoryName }]
        })
        // 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) => {
    if(model) {
      childModel[table] = model;
    }
    return childModel;
  });
};

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

Relationship.prototype.getThroughModel = function() {
  return this.throughModel;
};

Relationship.prototype.getTargetModel = function() {
  return this.throughModel.relationships[this.modelFactoryName];
};

module.exports = Relationship;