kanso-orm/lib/query-object.js

'use strict';
var Relationship = require('./relationship');

function QueryObject(table, attributes, relationships, options) {
  this.table = table;
  this.relationships = relationships;
  this.relationshipsSorted = {};
  this.relationshipsCreated = {};
  this.options = options;
  this.filter(attributes, relationships);
  return this;
}

QueryObject.prototype.filter = function(attributes, relationships) {
  var newAttributes = {};
  var relationshipsSorted = {};
  for(var attribute in attributes) {
    if(relationships.hasOwnProperty(attribute)) {
      switch(relationships[attribute].type) {
        case Relationship.Types.belongsToOne: {
          if(!relationshipsSorted.belongsToOne) relationshipsSorted.belongsToOne = {};
          relationshipsSorted.belongsToOne[attribute] = attributes[attribute];
          break;
        }
        case Relationship.Types.belongsToMany: {
          if(!relationshipsSorted.belongsToMany) relationshipsSorted.belongsToMany = {};
          relationshipsSorted.belongsToMany[attribute] = attributes[attribute];
          break;
        }
        case Relationship.Types.hasOne: {
          if(!relationshipsSorted.hasOne) relationshipsSorted.hasOne = {};
          relationshipsSorted.hasOne[attribute] = attributes[attribute];
          break;
        }
        case Relationship.Types.hasMany: {
          if(!relationshipsSorted.hasMany) relationshipsSorted.hasMany = {};
          relationshipsSorted.hasMany[attribute] = attributes[attribute];
          break;
        }
      }
    } else {
      newAttributes[attribute] = attributes[attribute];
    }
  }
  this.relationshipsSorted = Object.assign({}, this.relationshipsSorted, relationshipsSorted);
  this.attributes = Object.assign({}, this.attributes, newAttributes);
};

//
// Relationships Create
//

QueryObject.prototype.createBelongsToOne = function() {
  var attributes = [];
  var relationships = [];
  var promises = [];
  for(var attribute in this.relationshipsSorted.belongsToOne) {
    if(this.relationships.hasOwnProperty(attribute)) {
      var relationship = this.relationships[attribute];
      var relationshipData = this.relationshipsSorted.belongsToOne[attribute];
      //
      // REFACTOR:
      // Make sure we aren't trying to create injected models
      if(!relationshipData[relationship.identifer.parent]) {
        var promise = relationship.createBelongsToOne(relationshipData,  this.options);
        attributes.push(attribute);
        relationships.push(relationship);
        promises.push(promise);
      }
      // Attach
      else {
        // TODO: Rename to relationshipsAttached
        this.relationshipsCreated[attribute] = relationshipData;
      }
      //
      //
      //
    }
  }
  return Promise.all(promises).then((models) => {
    var newAttributes = {};
    models.map((model, index) => {
      this.relationshipsCreated[attributes[index]] = model;
      newAttributes[attributes[index]] = model;
    });
    this.filter(newAttributes, this.relationships);
  });
};

QueryObject.prototype.createBelongsToMany = function() {
  var attributes = [];
  var relationships = [];
  var promises = [];
  for(var attribute in this.relationshipsSorted.belongsToMany) {
    if(this.relationships.hasOwnProperty(attribute)) {
      var relationship = this.relationships[attribute];
      this.relationshipsSorted.belongsToMany[attribute].map((relationshipData) => {
        //
        // REFACTOR:
        // Make sure we aren't trying to create injected models
        let targetModelFactory = relationship.getTargetModel();
        if(!relationshipData[targetModelFactory.identifer.parent]) {
          var promise = relationship.createBelongsToOne(relationshipData, this.options);
          attributes.push(attribute);
          relationships.push(relationship);
          promises.push(promise);
        }
        // Attach
        else {
          // TODO: Rename to relationshipsAttached
          if(!this.relationshipsCreated[attribute]) {
            this.relationshipsCreated[attribute] = [];
          }
          this.relationshipsCreated[attribute].push(relationshipData);
        }
        //
        //
        //
      });
    }
  }
  return Promise.all(promises).then((modelsMany) => {
    var newAttributes = {};
    modelsMany.map((models, index) => {
      this.relationshipsCreated[attributes[index]] = models;
      newAttributes[attributes[index]] = models;
    });
    this.filter(newAttributes, this.relationships);
  });
};

QueryObject.prototype.createHasOne = function(parentModel) {
  var attributes = [];
  var relationships = [];
  var promises = [];
  for(var attribute in this.relationshipsSorted.hasOne) {
    if(this.relationships.hasOwnProperty(attribute)) {
      var relationship = this.relationships[attribute];
      var relationshipData = this.relationshipsSorted.hasOne[attribute];
      //
      // REFACTOR:
      // Make sure we aren't trying to create injected models
      if(!relationshipData[relationship.identifer.parent]) {
        var promise = relationship.createHasOne(relationshipData, parentModel, this.options);
        attributes.push(attribute);
        relationships.push(relationship);
        promises.push(promise);
      }
      // Attach
      else {
        this.relationshipsCreated[attribute] = relationshipData;
      }
      //
      //
      //
    }
  }
  return Promise.all(promises).then((models) => {
    models.map((model, index) => {
      this.relationshipsCreated[attributes[index]] = model;
    });
  });
};

QueryObject.prototype.createHasMany = function(parentModel) {
  var attributes = [];
  var relationships = [];
  var promises = [];
  for(var attribute in this.relationshipsSorted.hasMany) {
    if(this.relationships.hasOwnProperty(attribute)) {
      var relationship = this.relationships[attribute];
      this.relationshipsSorted.hasMany[attribute].map((relationshipData) => {
        //
        // REFACTOR:
        // Make sure we aren't trying to create injected models
        if(!relationshipData[relationship.identifer.child]) {
          var promise = relationship.createHasOne(relationshipData, parentModel,  this.options);
          attributes.push(attribute);
          relationships.push(relationship);
          promises.push(promise);
        }
        // Attach
        else {
          // TODO: Rename to relationshipsAttached
          if(!this.relationshipsCreated[attribute]) {
            this.relationshipsCreated[attribute] = [];
          }
          this.relationshipsCreated[attribute].push(relationshipData);
        }
        //
        //
        //
      });
    }
  }
  return Promise.all(promises).then((modelsMany) => {
    modelsMany.map((models, index) => {
      // TODO: Rename to relationshipsAttached
      if(!this.relationshipsCreated[attributes[index]]) {
        this.relationshipsCreated[attributes[index]] = [];
      }
      this.relationshipsCreated[attributes[index]].push(models);
    });
  });
};

//
// Relationships Attach
//

QueryObject.prototype.attachBelongsToOne = function() {
  for(var attribute in this.relationshipsSorted.belongsToOne) {
    if(this.relationships.hasOwnProperty(attribute)) {
      this.attributes = this.relationships[attribute].attachAsAttribute(
        this.attributes,
        this.relationshipsSorted.belongsToOne[attribute]
      );
    }
  }
};

QueryObject.prototype.attachBelongsToMany = function(childModel, options) {
    var promises = [];
    for(var attribute in this.relationshipsSorted.belongsToMany) {
      if(this.relationships.hasOwnProperty(attribute)) {
        var promise = this.relationships[attribute].attach(
          childModel,
          this.relationshipsSorted.belongsToMany[attribute],
          options
        );
        promises.push(promise);
      }
    }
    return Promise.all(promises);
};

//
// Concat
//
QueryObject.prototype.concatCreatedRelationships = function(model) {
  return Object.assign({}, model, this.relationshipsCreated);
};

//
// Getters
//

QueryObject.prototype.getTable = function() {
  return this.table;
};

QueryObject.prototype.getRelationships = function() {
  return this.relationships;
};

QueryObject.prototype.getAttributes = function() {
  return this.attributes;
};

QueryObject.prototype.getJoin = function() {
  return Object.assign({},
    this.relationshipsSorted.belongsToOne,
    this.relationshipsSorted.belongsToMany,
    this.relationshipsSorted.hasOne,
    this.relationshipsSorted.hasMany);
};

QueryObject.prototype.getOptions = function() {
  return this.options;
};

module.exports = QueryObject;