Code coverage report for upstream/lib/associations/belongs-to.js

Statements: 95.65% (44 / 46)      Branches: 84.85% (28 / 33)      Functions: 100% (7 / 7)      Lines: 95.65% (44 / 46)     

All files » upstream/lib/associations/ » belongs-to.js
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 1041       1 1 41 41 41 41 41 41 41   41       41 33     41       41   41             1 41       41   41 41 41     41   41     1 41       41 7       7   7 1     1     6     7     41     1 41   41 22     22 22             22     41     1    
var Utils     = require("./../utils")
  , DataTypes = require('./../data-types')
  , Helpers   = require('./helpers')
 
module.exports = (function() {
  var BelongsTo = function(source, target, options) {
    this.associationType      = 'BelongsTo'
    this.source               = source
    this.target               = target
    this.options              = options
    this.isSingleAssociation  = true
    this.isSelfAssociation    = (this.source.tableName == this.target.tableName)
    this.as                   = this.options.as
 
    Iif (this.isSelfAssociation && !this.options.foreignKey && !!this.as) {
      this.options.foreignKey = Utils._.underscoredIf(Utils.singularize(this.source.tableName, this.source.options.language) + "Id", this.source.options.underscored)
    }
 
    if (!this.as) {
      this.as = this.options.as = Utils.singularize(this.target.tableName, this.target.options.language)
    }
 
    this.associationAccessor = this.isSelfAssociation
      ? Utils.combineTableNames(this.target.tableName, this.as)
      : this.as
 
    this.options.useHooks = options.useHooks
 
    this.accessors = {
      get: Utils._.camelize('get_' + this.as),
      set: Utils._.camelize('set_' + this.as)
    }
  }
 
  // the id is in the source table
  BelongsTo.prototype.injectAttributes = function() {
    var newAttributes  = {}
      , targetKeys     = Object.keys(this.target.primaryKeys)
      , keyType        = ((this.target.hasPrimaryKeys && targetKeys.length === 1) ? this.target.rawAttributes[targetKeys[0]].type : DataTypes.INTEGER)
 
    this.identifier = this.options.foreignKey || Utils._.underscoredIf(Utils.singularize(this.target.tableName, this.target.options.language) + "Id", this.source.options.underscored)
 
    newAttributes[this.identifier] = { type: this.options.keyType || keyType }
    Helpers.addForeignKeyConstraints(newAttributes[this.identifier], this.target, this.source, this.options)
    Utils._.defaults(this.source.rawAttributes, newAttributes)
 
    // Sync attributes and setters/getters to DAO prototype
    this.source.refreshAttributes()
 
    return this
  }
 
  BelongsTo.prototype.injectGetter = function(obj) {
    var self     = this
      , primaryKeys = Object.keys(self.target.primaryKeys)
      , primaryKey = primaryKeys.length === 1 ? primaryKeys[0] : 'id'
 
    obj[this.accessors.get] = function(params) {
      var id      = this[self.identifier]
        , where   = {}
        , options = Utils._.pick(params || {}, 'transaction')
 
      where[primaryKey] = id
 
      if (!Utils._.isUndefined(params)) {
        Iif (!Utils._.isUndefined(params.where)) {
          params.where = Utils._.extend(where, params.where)
        } else {
          params.where = where
        }
      } else {
        params = id
      }
 
      return self.target.find(params, options)
    }
 
    return this
  }
 
  BelongsTo.prototype.injectSetter = function(obj) {
    var self     = this
 
    obj[this.accessors.set] = function(associatedObject, options) {
      var primaryKeys = !!associatedObject && !!associatedObject.daoFactory ? Object.keys(associatedObject.daoFactory.primaryKeys) : []
        , primaryKey = primaryKeys.length === 1 ? primaryKeys[0] : 'id'
 
      this[self.identifier] = associatedObject ? associatedObject[primaryKey] : null
      options = Utils._.extend({
        fields: [ self.identifier ],
        allowNull: [self.identifier],
        association: true
      }, options)
 
      // passes the changed field to save, so only that field get updated.
      return this.save(options)
    }
 
    return this
  }
 
  return BelongsTo
})()