formatting + load the tableName from the passed DaoFactory if passed to references

lib/dao-factory.js

@@ -5,8 +5,6 @@ var Utils     = require("./utils")
 
 module.exports = (function() {
   var DAOFactory = function(name, attributes, options) {
-    var self = this
-
     this.options = Utils._.extend({
       timestamps: true,
       instanceMethods: {},
@@ -24,18 +22,25 @@ module.exports = (function() {
 
     // error check options
     Utils._.each(options.validate, function(validator, validatorType) {
-      if (Utils._.contains(Utils._.keys(attributes), validatorType))
+      if (Utils._.contains(Utils._.keys(attributes), validatorType)) {
         throw new Error("A model validator function must not have the same name as a field. Model: " + name + ", field/validation name: " + validatorType)
-      if (!Utils._.isFunction(validator))
+      }
+
+      if (!Utils._.isFunction(validator)) {
         throw new Error("Members of the validate option must be functions. Model: " + name + ", error with validate member " + validatorType)
+      }
     })
 
     this.name = name
+
     if (!this.options.tableName) {
       this.tableName = this.options.freezeTableName ? name : Utils.pluralize(name, this.options.language)
     } else {
       this.tableName = this.options.tableName
     }
+
+    attributes = replaceReferencesWithTableNames(attributes)
+
     this.rawAttributes     = attributes
     this.daoFactoryManager = null // defined in init function
     this.associations      = {}
@@ -59,8 +64,8 @@ module.exports = (function() {
     var self = this;
 
     this.daoFactoryManager = daoFactoryManager
-
     this.primaryKeys       = {};
+
     Utils._.each(this.attributes, function(dataTypeString, attributeName) {
       if ((attributeName !== 'id') && (dataTypeString.indexOf('PRIMARY KEY') !== -1)) {
         self.primaryKeys[attributeName] = dataTypeString
@@ -75,9 +80,11 @@ module.exports = (function() {
     findAutoIncrementField.call(this)
 
     // DAO prototype
+    // WTF ... ?
     this.DAO = function() {
       DAO.apply(this, arguments);
-    };
+    }
+
     Util.inherits(this.DAO, DAO);
 
     this.DAO.prototype.rawAttributes = this.rawAttributes;
@@ -89,47 +96,48 @@ module.exports = (function() {
     }
 
     Utils._.each(['Get', 'Set'], function(type) {
-      var prop  = type.toLowerCase(),
-          opt   = prop + 'terMethods',
-          meth  = '__define' + type + 'ter__',
-          funcs = Utils._.isObject(self.options[opt]) ? self.options[opt] : {}
-      ;
+      var prop  = type.toLowerCase()
+        , opt   = prop + 'terMethods'
+        , meth  = '__define' + type + 'ter__'
+        , funcs = Utils._.isObject(self.options[opt]) ? self.options[opt] : {}
 
       Utils._.each(self.rawAttributes, function(attr, name) {
-        if (attr.hasOwnProperty(prop))
+        if (attr.hasOwnProperty(prop)) {
           funcs[name] = attr[prop]
-      });
+        }
+      })
 
       Utils._.each(funcs, function(fct, name) {
-        if (!Utils._.isFunction(fct))
+        if (!Utils._.isFunction(fct)) {
           throw new Error(type + 'ter for "' + name + '" is not a function.')
+        }
 
-        self.DAO.prototype[meth](name, fct);
+        self.DAO.prototype[meth](name, fct)
       })
     })
 
     this.DAO.prototype.attributes    = Object.keys(this.DAO.prototype.rawAttributes);
+    this.DAO.prototype.booleanValues = []
+    this.DAO.prototype.defaultValues = {}
+    this.DAO.prototype.validators    = {}
 
-    this.DAO.prototype.booleanValues = [];
-    this.DAO.prototype.defaultValues = {};
-    this.DAO.prototype.validators = {};
     Utils._.each(this.rawAttributes, function (definition, name) {
       if (((definition === DataTypes.BOOLEAN) || (definition.type === DataTypes.BOOLEAN))) {
         self.DAO.prototype.booleanValues.push(name);
       }
       if (definition.hasOwnProperty('defaultValue')) {
         self.DAO.prototype.defaultValues[name] = function() {
-          return Utils.toDefaultValue(definition.defaultValue);
+          return Utils.toDefaultValue(definition.defaultValue)
         }
       }
 
       if (definition.hasOwnProperty('validate')) {
         self.DAO.prototype.validators[name] = definition.validate;
       }
-    });
+    })
 
-    this.DAO.prototype.__factory = this;
-    this.DAO.prototype.hasDefaultValues = !Utils._.isEmpty(this.DAO.prototype.defaultValues);
+    this.DAO.prototype.__factory        = this
+    this.DAO.prototype.hasDefaultValues = !Utils._.isEmpty(this.DAO.prototype.defaultValues)
 
     return this
   }
@@ -627,6 +635,16 @@ module.exports = (function() {
     }
   }
 
+  var replaceReferencesWithTableNames = function(attributes) {
+    Object.keys(attributes).forEach(function(attrName) {
+      if (attributes[attrName].references instanceof DAOFactory) {
+        attributes[attrName].references = attributes[attrName].references.tableName
+      }
+    })
+
+    return attributes
+  }
+
   Utils._.extend(DAOFactory.prototype, require("./associations/mixin"))
 
   return DAOFactory