refactor validateIncludedElement to utilise altered getAssociation

lib/dao-factory.js

@@ -1349,100 +1349,85 @@ module.exports = (function() {
 
 
   var validateIncludedElement = function(include, parent) {
   var validateIncludedElement = function(include, parent) {
     if (include instanceof DAOFactory) {
     if (include instanceof DAOFactory) {
-      include = { daoFactory: include, as: include.tableName }
+      include = { daoFactory: include }
     }
     }
 
 
     if (typeof parent === "undefined") {
     if (typeof parent === "undefined") {
       parent = this
       parent = this
     }
     }
 
 
-    if (typeof include === 'object') {
-      if (include.hasOwnProperty('model')) {
-        include.daoFactory = include.model
-        delete include.model
-      }
+    if (typeof include !== 'object') {
+      throw new Error('Include unexpected. Element has to be either an instance of DAOFactory or an object.')
+    }
 
 
-      if (!include.hasOwnProperty('as')) {
-        include.as = include.daoFactory.tableName
-      }
+    if (include.hasOwnProperty('model')) {
+      include.daoFactory = include.model
+      delete include.model
+    } else if (!include.hasOwnProperty('daoFactory')) {
+      throw new Error('Include malformed. Expected attributes: daoFactory, as!')
+    }
 
 
-      if (include.hasOwnProperty('attributes')) {
-        var primaryKeys;
-        if (include.daoFactory.hasPrimaryKeys) {
-          primaryKeys = []
-          for (var field_name in include.daoFactory.primaryKeys) {
-            primaryKeys.push(field_name)
-          }
-        } else {
-          primaryKeys = ['id']
+    if (include.hasOwnProperty('attributes')) {
+      var primaryKeys;
+      if (include.daoFactory.hasPrimaryKeys) {
+        primaryKeys = []
+        for (var field_name in include.daoFactory.primaryKeys) {
+          primaryKeys.push(field_name)
         }
         }
-        include.attributes = include.attributes.concat(primaryKeys)
       } else {
       } else {
-        include.attributes = Object.keys(include.daoFactory.attributes)
+        primaryKeys = ['id']
       }
       }
+      include.attributes = include.attributes.concat(primaryKeys)
+    } else {
+      include.attributes = Object.keys(include.daoFactory.attributes)
+    }
 
 
-      // pseudo include just needed the attribute logic, return
-      if (include._pseudo) return include
-
-      if (include.hasOwnProperty('daoFactory') && (include.hasOwnProperty('as'))) {
-        var usesAlias   = (include.as !== include.daoFactory.tableName)
-          , association = (usesAlias ? parent.getAssociationByAlias(include.as) : parent.getAssociation(include.daoFactory))
-
-        // If single (1:1) association, we singularize the alias, so it will match the automatically generated alias of belongsTo/HasOne
-        if (association && !usesAlias && association.isSingleAssociation) {
-          include.as = Utils.singularize(include.daoFactory.tableName, include.daoFactory.options.language)
+    // pseudo include just needed the attribute logic, return
+    if (include._pseudo) return include
+
+    // check if the current daoFactory is actually associated with the passed daoFactory - or it's a pseudo include
+	var association = parent.getAssociation(include.daoFactory, include.as)
+    if (association) {
+      include.association = association
+      include.as = association.as
+
+      // If through, we create a pseudo child include, to ease our parsing later on
+      if (Object(include.association.through) === include.association.through) {
+        if (!include.include) include.include = []
+        var through = include.association.through
+
+        include.through = {
+          daoFactory: through,
+          as: Utils.singularize(through.tableName, through.options.language),
+          association: {
+            isSingleAssociation: true
+          },
+          _pseudo: true
         }
         }
 
 
-        // check if the current daoFactory is actually associated with the passed daoFactory - or it's a pseudo include
-        if (association && (!association.options.as || (association.options.as === include.as))) {
-          include.association = association
-
-          // If through, we create a pseudo child include, to ease our parsing later on
-          if (Object(include.association.through) === include.association.through) {
-            if (!include.include) include.include = []
-            var through = include.association.through
-
-            include.through = {
-              daoFactory: through,
-              as: Utils.singularize(through.tableName, through.options.language),
-              association: {
-                isSingleAssociation: true
-              },
-              _pseudo: true
-            }
-
-            include.include.push(include.through)
-          }
+        include.include.push(include.through)
+      }
 
 
-          if (include.required === undefined) {
-            include.required = false
-            if (include.where) {
-              include.required = true
-            }
-          }
+      if (include.required === undefined) {
+        include.required = !!include.where
+      }
 
 
-          // Validate child includes
-          if (include.hasOwnProperty('include')) {
-            validateIncludedElements(include)
-          }
+      // Validate child includes
+      if (include.hasOwnProperty('include')) {
+        validateIncludedElements(include)
+      }
 
 
-          return include
-        } else {
-          var msg = include.daoFactory.name
+      return include
+    } else {
+      var msg = include.daoFactory.name
 
 
-          if (usesAlias) {
-            msg += " (" + include.as + ")"
-          }
+      if (include.as) {
+        msg += " (" + include.as + ")"
+      }
 
 
-          msg += " is not associated to " + this.name + "!"
+      msg += " is not associated to " + this.name + "!"
 
 
-          throw new Error(msg)
-        }
-      } else {
-        throw new Error('Include malformed. Expected attributes: daoFactory, as!')
-      }
-    } else {
-      throw new Error('Include unexpected. Element has to be either an instance of DAOFactory or an object.')
+      throw new Error(msg)
     }
     }
   }
   }