Merge pull request #1477 from janmeier/contraintWork

Enabled onDelete and onUpdate constraints for n:m

changelog.md

@@ -3,6 +3,8 @@ Notice: All 1.7.x changes are present in 2.0.x aswell
 # v2.0.0-dev11
 - [PERFORMANCE] increased build performance when using include, which speeds up findAll etc.
 - [BUG] Made it possible to use HSTORE both in attribute: HSTORE and attribute: { type: HSTORE } form. Thanks to @tomchentw [#1458](https://github.com/sequelize/sequelize/pull/1458)
+- [FEATURE] n:m now marks the columns of the through table as foreign keys and cascades them on delete and update by default.
+- [FEATURE] 1:1 and 1:m marks columns as foreign keys, and sets them to cascade on update and set null on delete. If you are working with an existing DB which does not allow null values, be sure to override those options, or disable them completely by passing useConstrations: false to your assocation call (`M1.belongsTo(M2, { useConstraints: false})`).
 
 #### Backwards compatability changes
 - selectedValues has been removed for performance reasons, if you depend on this, please open an issue and we will help you work around it.
@@ -10,6 +12,8 @@ Notice: All 1.7.x changes are present in 2.0.x aswell
   - if you have any 1:1 relations where both sides use an alias, you'll need to set the foreign key, or they'll each use a different foreign key based on their alias.
 - foreign keys for non-id primary keys will now be named for the foreign key, i.e. pub_name rather than pub_id
   - if you have non-id primary keys you should go through your associations and set the foreignKey option if relying on a incorrect _id foreign key
+- syncOnAssocation has been removed. It only worked for n:m, and having a synchronous function (hasMany) that invokes an asynchronous function (sync) without returning an emitter does not make a lot of sense. If you (implicitly) depended on this feature, sequelize.sync is your friend. If you do not want to do a full sync, use custom through models for n:m (`M1.hasMany(M2, { through: M3})`) and sync the through model explicitly.
+- Join tables will be no longer be paranoid (have a deletedAt timestamp added), even though other models are.
 
 # v1.7.0
 - [FEATURE] covers more advanced include cases with limiting and filtering (specifically cases where a include would be in the subquery but its child include wouldnt be, for cases where a 1:1 association had a 1:M association as a nested include)

lib/associations/belongs-to.js

@@ -47,6 +47,10 @@ module.exports = (function() {
     var newAttributes  = {}
 
     newAttributes[this.identifier] = { type: this.options.keyType || this.target.rawAttributes[this.targetIdentifier].type }
+    if (this.options.constraints !== false) {
+      this.options.onDelete = this.options.onDelete || 'SET NULL'
+      this.options.onUpdate = this.options.onUpdate || 'CASCADE'
+    }
     Helpers.addForeignKeyConstraints(newAttributes[this.identifier], this.target, this.source, this.options)
     Utils._.defaults(this.source.rawAttributes, newAttributes)
 

lib/associations/has-many.js

@@ -103,7 +103,8 @@ module.exports = (function() {
 
     if (typeof this.through === "string") {
       this.through = this.sequelize.define(this.through, {}, _.extend(this.options, {
-        tableName: this.through
+        tableName: this.through,
+        paranoid: false  // A paranoid join table does not make sense
       }))
 
       if (this.targetAssociation) {
@@ -174,24 +175,46 @@ module.exports = (function() {
 
       // define a new model, which connects the models
       var combinedTableAttributes = {}
-      var sourceKeyType = this.source.rawAttributes[this.source.primaryKeyAttribute].type
-      var targetKeyType = this.target.rawAttributes[this.target.primaryKeyAttribute].type
+        , sourceKeyType = this.source.rawAttributes[this.source.primaryKeyAttribute].type
+        , targetKeyType = this.target.rawAttributes[this.target.primaryKeyAttribute].type
+        , sourceAttribute = { type: sourceKeyType }
+        , targetAttribute = { type: targetKeyType }
+
+      if (this.options.constraints !== false) {
+        sourceAttribute.references = this.source.getTableName()
+        sourceAttribute.referencesKey = this.source.primaryKeyAttribute
+        sourceAttribute.onDelete = this.options.onDelete || 'CASCADE'
+        sourceAttribute.onUpdate = this.options.onUpdate || 'CASCADE'
+      }
+      if (this.targetAssociation.options.constraints !== false) {
+        targetAttribute.references = this.target.getTableName()
+        targetAttribute.referencesKey = this.target.primaryKeyAttribute
+        targetAttribute.onDelete = this.targetAssociation.options.onDelete || 'CASCADE'
+        targetAttribute.onUpdate = this.targetAssociation.options.onUpdate || 'CASCADE'
+      }
 
       if (primaryKeyDeleted) {
-        combinedTableAttributes[this.identifier] = {type: sourceKeyType, primaryKey: true}
-        combinedTableAttributes[this.foreignIdentifier] = {type: targetKeyType, primaryKey: true}
+        targetAttribute.primaryKey = sourceAttribute.primaryKey = true
       } else { 
         var uniqueKey = [this.through.tableName, this.identifier, this.foreignIdentifier, 'unique'].join('_')
-        combinedTableAttributes[this.identifier] = {type: sourceKeyType, unique: uniqueKey}
-        combinedTableAttributes[this.foreignIdentifier] = {type: targetKeyType, unique: uniqueKey}
+        targetAttribute.unique = sourceAttribute.unique = uniqueKey
       }
 
+      combinedTableAttributes[this.identifier] = sourceAttribute
+      combinedTableAttributes[this.foreignIdentifier] = targetAttribute
+
       this.through.rawAttributes = Utils._.merge(this.through.rawAttributes, combinedTableAttributes)
       this.through.init(this.through.daoFactoryManager)
     } else {
       var newAttributes = {}
+      var constraintOptions = _.clone(this.options) // Create a new options object for use with addForeignKeyConstraints, to avoid polluting this.options in case it is later used for a n:m
       newAttributes[this.identifier] = { type: this.options.keyType || this.target.rawAttributes[this.target.primaryKeyAttribute].type }
-      Helpers.addForeignKeyConstraints(newAttributes[this.identifier], this.source, this.target, this.options)
+
+      if (this.options.constraints !== false) {
+        constraintOptions.onDelete = constraintOptions.onDelete || 'SET NULL'
+        constraintOptions.onUpdate = constraintOptions.onUpdate || 'CASCADE'
+      }
+      Helpers.addForeignKeyConstraints(newAttributes[this.identifier], this.source, this.target, constraintOptions)
       Utils._.defaults(this.target.rawAttributes, newAttributes)
     }
 

lib/associations/has-one.js

@@ -48,6 +48,11 @@ module.exports = (function() {
 
     newAttributes[this.identifier] = { type: this.options.keyType || keyType }
     Utils._.defaults(this.target.rawAttributes, newAttributes)
+
+    if (this.options.constraints !== false) {
+      this.options.onDelete = this.options.onDelete || 'SET NULL'
+      this.options.onUpdate = this.options.onUpdate || 'CASCADE'
+    }    
     Helpers.addForeignKeyConstraints(this.target.rawAttributes[this.identifier], this.source, this.target, this.options)
 
     // Sync attributes and setters/getters to DAO prototype

lib/dao-factory-manager.js

 var Toposort   = require('toposort-class')
   , DaoFactory = require('./dao-factory')
+  , _          = require('lodash')
 
 module.exports = (function() {
   var DAOFactoryManager = function(sequelize) {
@@ -39,9 +40,14 @@ module.exports = (function() {
    * take foreign key constraints into account so that dependencies are visited
    * before dependents.
    */
-  DAOFactoryManager.prototype.forEachDAO = function(iterator) {
+  DAOFactoryManager.prototype.forEachDAO = function(iterator, options) {
     var daos   = {}
       , sorter = new Toposort()
+      , sorted
+    
+    options = _.defaults(options || {}, {
+      reverse: true
+    })
 
     this.daos.forEach(function(dao) {
       var deps = []
@@ -62,7 +68,11 @@ module.exports = (function() {
       sorter.add(dao.tableName, deps)
     })
 
-    sorter.sort().reverse().forEach(function(name) {
+    sorted = sorter.sort()
+    if (options.reverse) {
+      sorted = sorted.reverse()
+    }
+    sorted.forEach(function(name) {
       iterator(daos[name], name)
     })
   }

lib/dao-factory.js

@@ -19,7 +19,6 @@ module.exports = (function() {
       validate: {},
       freezeTableName: false,
       underscored: false,
-      syncOnAssociation: true,
       paranoid: false,
       whereCollection: null,
       schema: null,
@@ -1613,7 +1612,15 @@ module.exports = (function() {
   var optClone = function (options) {
     return Utils._.cloneDeep(options, function (elem) {
       // The DAOFactories used for include are pass by ref, so don't clone them.
-      if (elem instanceof DAOFactory || elem instanceof Utils.col || elem instanceof Utils.literal || elem instanceof Utils.cast || elem instanceof Utils.fn || elem instanceof Utils.and || elem instanceof Utils.or) {
+      if (elem instanceof DAOFactory || 
+        elem instanceof Utils.col || 
+        elem instanceof Utils.literal ||  
+        elem instanceof Utils.cast || 
+        elem instanceof Utils.fn || 
+        elem instanceof Utils.and || 
+        elem instanceof Utils.or || 
+        elem instanceof Transaction
+      ) {
         return elem
       }
       // Unfortunately, lodash.cloneDeep doesn't preserve Buffer.isBuffer, which we have to rely on for binary data

lib/dialects/mysql/query-generator.js

@@ -54,7 +54,15 @@ module.exports = (function() {
 
           if (Utils._.includes(dataType, 'PRIMARY KEY')) {
             primaryKeys.push(attr)
+
+            if (Utils._.includes(dataType, 'REFERENCES')) { 
+               // MySQL doesn't support inline REFERENCES declarations: move to the end
+              var m = dataType.match(/^(.+) (REFERENCES.*)$/)
+              attrStr.push(this.quoteIdentifier(attr) + " " + m[1].replace(/PRIMARY KEY/, ''))
+              foreignKeys[attr] = m[2]
+            } else {
               attrStr.push(this.quoteIdentifier(attr) + " " + dataType.replace(/PRIMARY KEY/, ''))
+            }            
           } else if (Utils._.includes(dataType, 'REFERENCES')) {
             // MySQL doesn't support inline REFERENCES declarations: move to the end
             var m = dataType.match(/^(.+) (REFERENCES.*)$/)

lib/dialects/sqlite/query-generator.js

@@ -93,17 +93,18 @@ module.exports = (function() {
             modifierLastIndex = -1
           }
 
+          var dataTypeString = dataType
           if (Utils._.includes(dataType, 'PRIMARY KEY')) {
             if (Utils._.includes(dataType, 'INTEGER')) {
-              dataType = 'INTEGER PRIMARY KEY' // Only INTEGER is allowed for primary key, see https://github.com/sequelize/sequelize/issues/969 (no lenght, unsigned etc)
+              dataTypeString = 'INTEGER PRIMARY KEY' // Only INTEGER is allowed for primary key, see https://github.com/sequelize/sequelize/issues/969 (no lenght, unsigned etc)
             }
 
             if (needsMultiplePrimaryKeys) {
               primaryKeys.push(attr)
-              dataType = dataType.replace(/PRIMARY KEY/, 'NOT NULL')
+              dataTypeString = dataType.replace(/PRIMARY KEY/, 'NOT NULL')
             }
           }
-          attrStr.push(this.quoteIdentifier(attr) + " " + dataType)
+          attrStr.push(this.quoteIdentifier(attr) + " " + dataTypeString)
         }
       }
 

lib/query-interface.js

@@ -532,26 +532,7 @@ module.exports = (function() {
       }
     }
 
-    return new Utils.CustomEventEmitter(function(emitter) {
-      var chainer = new Utils.QueryChainer()
-
-      chainer.add(self, 'queryAndEmit', [[sql, dao, options], 'delete'])
-
-      chainer.runSerially()
-      .success(function(results){
-        emitter.query = { sql: sql }
-        emitter.emit('success', results[0])
-        emitter.emit('sql', sql)
-      })
-      .error(function(err) {
-        emitter.query = { sql: sql }
-        emitter.emit('error', err)
-        emitter.emit('sql', sql)
-      })
-      .on('sql', function(sql) {
-        emitter.emit('sql', sql)
-      })
-    }).run()
+    return this.queryAndEmit([sql, dao, options], 'update')
   }
 
   QueryInterface.prototype.bulkUpdate = function(tableName, values, identifier, options) {

lib/sequelize.js

@@ -387,7 +387,11 @@ module.exports = (function() {
     // Topologically sort by foreign key constraints to give us an appropriate
     // creation order
 
-    this.daoFactoryManager.forEachDAO(function(dao, daoName) {
+    if (options.force) {
+      chainer.add(this, 'drop')
+    }
+
+    this.daoFactoryManager.forEachDAO(function(dao) {
       if (dao) {
         chainer.add(dao, 'sync', [options])
       } else {
@@ -402,12 +406,16 @@ module.exports = (function() {
     var self = this
 
     return new Utils.CustomEventEmitter(function(emitter) {
-      var chainer = new Utils.QueryChainer
+      var chainer = new Utils.QueryChainer()
 
-      self.daoFactoryManager.daos.forEach(function(dao) { chainer.add(dao.drop()) })
+      self.daoFactoryManager.forEachDAO(function(dao) { 
+        if (dao) {
+          chainer.add(dao, 'drop', []) 
+        }
+      }, { reverse: false})
 
       chainer
-        .run()
+        .runSerially()
         .success(function() { emitter.emit('success', null) })
         .error(function(err) { emitter.emit('error', err) })
     }).run()

test/associations/belongs-to.test.js

@@ -85,7 +85,7 @@ describe(Support.getTestDialectTeaser("BelongsTo"), function() {
 
       self.sequelize.dropAllSchemas().done(function() {
         self.sequelize.createSchema('archive').done(function () {
-          self.sequelize.sync({force: true}).done(function () {
+          self.sequelize.sync({force: true }).done(function () {
             User.create({ username: 'foo', gender: 'male' }).success(function(user) {
               Task.create({ title: 'task', status: 'inactive' }).success(function(task) {
                 task.setUserXYZ(user).success(function() {
@@ -283,19 +283,41 @@ describe(Support.getTestDialectTeaser("BelongsTo"), function() {
   });
 
   describe("foreign key constraints", function() {
-    it("are not enabled by default", function(done) {
+    it("are enabled by default", function(done) {
       var Task = this.sequelize.define('Task', { title: DataTypes.STRING })
         , User = this.sequelize.define('User', { username: DataTypes.STRING })
 
-      Task.belongsTo(User)
+      Task.belongsTo(User) // defaults to SET NULL
 
       this.sequelize.sync({ force: true }).success(function() {
         User.create({ username: 'foo' }).success(function(user) {
           Task.create({ title: 'task' }).success(function(task) {
             task.setUser(user).success(function() {
               user.destroy().success(function() {
-                Task.findAll().success(function(tasks) {
-                  expect(tasks).to.have.length(1)
+                task.reload().success(function() {
+                  expect(task.UserId).to.equal(null)
+                  done()
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+
+    it("should be possible to disable them", function(done) {
+      var Task = this.sequelize.define('Task', { title: Sequelize.STRING })
+        , User = this.sequelize.define('User', { username: Sequelize.STRING })
+
+      Task.belongsTo(User, { constraints: false })
+
+      this.sequelize.sync({ force: true }).success(function() {
+        User.create({ username: 'foo' }).success(function(user) {
+          Task.create({ title: 'task' }).success(function(task) {
+            task.setUser(user).success(function() {
+              user.destroy().success(function() {
+                task.reload().success(function() {
+                  expect(task.UserId).to.equal(user.id)
                   done()
                 })
               })
@@ -447,7 +469,7 @@ describe(Support.getTestDialectTeaser("BelongsTo"), function() {
         var tableName = 'TaskXYZ_' + dataType.toString()
         Tasks[dataType] = self.sequelize.define(tableName, { title: DataTypes.STRING })
 
-        Tasks[dataType].belongsTo(User, { foreignKey: 'userId', keyType: dataType })
+        Tasks[dataType].belongsTo(User, { foreignKey: 'userId', keyType: dataType, constraints: false })
       })
 
       self.sequelize.sync({ force: true })

test/associations/has-one.test.js

@@ -211,7 +211,7 @@ describe(Support.getTestDialectTeaser("HasOne"), function() {
     })
   })
 
-  describe("foreign key", function () {
+  describe('foreign key', function () {
     it('should lowercase foreign keys when using underscored', function () {
       var User  = this.sequelize.define('User', { username: Sequelize.STRING }, { underscored: true })
         , Account = this.sequelize.define('Account', { name: Sequelize.STRING }, { underscored: true })
@@ -231,11 +231,11 @@ describe(Support.getTestDialectTeaser("HasOne"), function() {
   })
 
   describe("foreign key constraints", function() {
-    it("are not enabled by default", function(done) {
+    it("are enabled by default", function(done) {
       var Task = this.sequelize.define('Task', { title: Sequelize.STRING })
         , User = this.sequelize.define('User', { username: Sequelize.STRING })
 
-      User.hasOne(Task)
+      User.hasOne(Task) // defaults to set NULL
 
       User.sync({ force: true }).success(function() {
         Task.sync({ force: true }).success(function() {
@@ -243,8 +243,32 @@ describe(Support.getTestDialectTeaser("HasOne"), function() {
             Task.create({ title: 'task' }).success(function(task) {
               user.setTask(task).success(function() {
                 user.destroy().success(function() {
-                  Task.findAll().success(function(tasks) {
-                    expect(tasks).to.have.length(1)
+                  task.reload().success(function() {
+                    expect(task.UserId).to.equal(null)
+                    done()
+                  })
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+
+    it("should be possible to disable them", function(done) {
+      var Task = this.sequelize.define('Task', { title: Sequelize.STRING })
+        , User = this.sequelize.define('User', { username: Sequelize.STRING })
+
+      User.hasOne(Task, { constraints: false })
+
+      User.sync({ force: true }).success(function() {
+        Task.sync({ force: true }).success(function() {
+          User.create({ username: 'foo' }).success(function(user) {
+            Task.create({ title: 'task' }).success(function(task) {
+              user.setTask(task).success(function() {
+                user.destroy().success(function() {
+                  task.reload().success(function() {
+                    expect(task.UserId).to.equal(user.id)
                     done()
                   })
                 })
@@ -406,7 +430,7 @@ describe(Support.getTestDialectTeaser("HasOne"), function() {
         var tableName = 'TaskXYZ_' + dataType.toString()
         Tasks[dataType] = self.sequelize.define(tableName, { title: Sequelize.STRING })
 
-        User.hasOne(Tasks[dataType], { foreignKey: 'userId', keyType: dataType })
+        User.hasOne(Tasks[dataType], { foreignKey: 'userId', keyType: dataType, constraints: false })
 
         Tasks[dataType].sync({ force: true }).success(function() {
           expect(Tasks[dataType].rawAttributes.userId.type.toString())

test/dao-factory.test.js

@@ -279,11 +279,11 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
         bCol: { type: Sequelize.STRING, unique: 'a_and_b' }
       })
 
-      User.sync({ force: true }).on('sql', function(sql) {
+      User.sync({ force: true }).on('sql', _.after(2, function(sql) {
         expect(sql).to.match(/UNIQUE\s*(uniq_UserWithUniqueUsernames_username_email)?\s*\([`"]?username[`"]?, [`"]?email[`"]?\)/)
         expect(sql).to.match(/UNIQUE\s*(uniq_UserWithUniqueUsernames_aCol_bCol)?\s*\([`"]?aCol[`"]?, [`"]?bCol[`"]?\)/)
         done()
-      })
+      }))
     })
 
     it('allows us to customize the error message for unique constraint', function(done) {
@@ -1447,7 +1447,6 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
 
     it('should be able to reference a table with a schema set', function(done) {
       var self = this
-      var sequelize = this.sequelize
 
       var UserPub = this.sequelize.define('UserPub', {
         username: Sequelize.STRING
@@ -1463,14 +1462,14 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
 
       var run = function() {
         UserPub.sync({ force: true }).success(function() {
-          ItemPub.sync({ force: true }).on('sql', function(sql) {
+          ItemPub.sync({ force: true }).on('sql', _.after(2, function(sql) {
             if (dialect === "postgres") {
               expect(sql).to.match(/REFERENCES\s+"prefix"\."UserPubs" \("id"\)/)
             } else {
               expect(sql).to.match(/REFERENCES\s+`prefix\.UserPubs` \(`id`\)/)
             }
             done()
-          })
+          }))
         })
       }
 
@@ -1969,10 +1968,10 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
         str: { type: Sequelize.STRING, unique: true }
       })
 
-      uniqueTrue.sync({force: true}).on('sql', function(s) {
+      uniqueTrue.sync({force: true}).on('sql', _.after(2, function(s) {
         expect(s).to.match(/UNIQUE/)
         done()
-      })
+      }))
     })
 
     it("should not set unique when unique is false", function(done) {
@@ -1981,10 +1980,10 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
         str: { type: Sequelize.STRING, unique: false }
       })
 
-      uniqueFalse.sync({force: true}).on('sql', function(s) {
+      uniqueFalse.sync({force: true}).on('sql', _.after(2, function(s) {
         expect(s).not.to.match(/UNIQUE/)
         done()
-      })
+      }))
     })
 
     it("should not set unique when unique is unset", function(done) {
@@ -1993,10 +1992,10 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
         str: { type: Sequelize.STRING }
       })
 
-      uniqueUnset.sync({force: true}).on('sql', function(s) {
+      uniqueUnset.sync({force: true}).on('sql', _.after(2, function(s) {
         expect(s).not.to.match(/UNIQUE/)
         done()
-      })
+      }))
     })
   })
 

test/dao-factory/find.test.js

@@ -277,8 +277,7 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
         self.Worker      = self.sequelize.define('Worker', { name: Sequelize.STRING })
 
         this.init = function(callback) {
-          self.Task.sync({ force: true }).success(function() {
-            self.Worker.sync({ force: true }).success(function() {
+          self.sequelize.sync({ force: true }).success(function() {
             self.Worker.create({ name: 'worker' }).success(function(worker) {
               self.Task.create({ title: 'homework' }).success(function(task) {
                 self.worker    = worker
@@ -287,7 +286,6 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
               })
             })
           })
-          })
         }
         done()
       })
@@ -386,8 +384,8 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
           self.User.belongsTo(self.Group)
 
           self.sequelize.sync({ force: true }).success(function() {
-            self.User.create({ username: 'someone', GroupPKeagerbelongName: 'people' }).success(function() {
             self.Group.create({ name: 'people' }).success(function() {
+              self.User.create({ username: 'someone', GroupPKeagerbelongName: 'people' }).success(function() {  
                 self.User.find({
                   where: {
                     username: 'someone'
@@ -406,15 +404,12 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
         })
 
         it('getting parent data in many to one relationship', function(done) {
-
-          var self = this;
-
-          var User = self.sequelize.define('User', {
+          var User = this.sequelize.define('User', {
             id:  {type: Sequelize.INTEGER, autoIncrement: true, primaryKey: true},
             username:  {type: Sequelize.STRING}
           })
 
-          var Message = self.sequelize.define('Message', {
+          var Message = this.sequelize.define('Message', {
             id:  {type: Sequelize.INTEGER, autoIncrement: true, primaryKey: true},
             user_id:  {type: Sequelize.INTEGER},
             message:  {type: Sequelize.STRING}
@@ -423,8 +418,7 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
           User.hasMany(Message)
           Message.belongsTo(User, { foreignKey: 'user_id' })
 
-          Message.sync({ force: true }).success(function() {
-            User.sync({ force: true }).success(function() {
+          this.sequelize.sync({ force: true }).success(function() {
             User.create({username: 'test_testerson'}).success(function(user) {
               Message.create({user_id: user.id, message: 'hi there!'}).success(function(message) {
                 Message.create({user_id: user.id, message: 'a second message'}).success(function(message) {
@@ -438,7 +432,6 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
                     include: [{ model: User, attributes: ['username'] }]
 
                   }).success(function(messages) {
-
                     expect(messages.length).to.equal(2);
 
                     expect(messages[0].message).to.equal('hi there!');
@@ -450,16 +443,12 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
                     done()
 
                   })
-
                 })
               })
             })
-
           })
         })
 
-        })
-
         it('allows mulitple assocations of the same model with different alias', function (done) {
           var self = this
 
@@ -528,8 +517,8 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
           self.Group.hasOne(self.User)
 
           self.sequelize.sync({ force: true }).success(function() {
-            self.User.create({ username: 'someone', GroupPKeageroneName: 'people' }).success(function() {
             self.Group.create({ name: 'people' }).success(function() {
+              self.User.create({ username: 'someone', GroupPKeageroneName: 'people' }).success(function() {
                 self.Group.find({
                   where: {
                     name: 'people'

test/dao-factory/findAll.test.js

@@ -313,8 +313,7 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
         User.hasMany(Session, { as: 'Sessions' })
         Session.belongsTo(User)
 
-        Session.sync({ force: true }).success(function() {
-          User.sync({ force: true }).success(function() {
+        this.sequelize.sync({ force: true }).success(function() {
           User.create({name: 'Name1', password: '123', isAdmin: false}).success(function(user) {
             var sess = Session.build({
               lastUpdate: new Date(),
@@ -328,7 +327,6 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
           })
         })
       })
-      })
 
       it('should be able to find a row between a certain date', function(done) {
         this.User.findAll({
@@ -849,9 +847,7 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
           self.Country.hasMany(self.Person, { as: 'Residents', foreignKey: 'CountryResidentId' })
           self.Person.belongsTo(self.Country, { as: 'CountryResident', foreignKey: 'CountryResidentId' })
 
-          async.forEach([ self.Continent, self.Country, self.Industry, self.Person ], function(model, callback) {
-            model.sync({ force: true }).done(callback)
-          }, function () {
+          this.sequelize.sync({ force: true }).success(function () {
             async.parallel({
               europe: function(callback) {self.Continent.create({ name: 'Europe' }).done(callback)},
               england: function(callback) {self.Country.create({ name: 'England' }).done(callback)},
@@ -965,9 +961,7 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
           self.Country.hasMany(self.Person, { as: 'Residents', foreignKey: 'CountryResidentId' })
           self.Person.belongsTo(self.Country, { as: 'CountryResident', foreignKey: 'CountryResidentId' })
 
-          async.forEach([ self.Continent, self.Country, self.Person ], function(model, callback) {
-            model.sync({ force: true }).done(callback)
-          }, function () {
+          this.sequelize.sync({ force: true }).success(function () {
             async.parallel({
               europe: function(callback) {self.Continent.create({ name: 'Europe' }).done(callback)},
               asia: function(callback) {self.Continent.create({ name: 'Asia' }).done(callback)},
@@ -1120,9 +1114,7 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
           self.Country.hasMany(self.Industry, {through: self.IndustryCountry})
           self.Industry.hasMany(self.Country, {through: self.IndustryCountry})
 
-          async.forEach([ self.Country, self.Industry ], function(model, callback) {
-            model.sync({ force: true }).done(callback)
-          }, function () {
+          this.sequelize.sync({ force: true }).success(function () {
             async.parallel({
               england: function(callback) {self.Country.create({ name: 'England' }).done(callback)},
               france: function(callback) {self.Country.create({ name: 'France' }).done(callback)},

test/dao.validations.test.js

@@ -353,16 +353,14 @@ describe(Support.getTestDialectTeaser("DaoValidator"), function() {
           })
 
           Project.hasOne(Task)
-          Task.hasOne(Project)
+          Task.belongsTo(Project)
 
-          Project.sync({ force: true }).success(function() {
-            Task.sync({ force: true }).success(function() {
+          this.sequelize.sync({ force: true }).success(function() {
             self.Project = Project
             self.Task = Task
             done()
           })
         })
-        })
 
         it('correctly throws an error using create method ', function(done) {
           this.Project.create({name: 'nope'}).error(function(err) {

test/hooks.test.js

@@ -6334,12 +6334,10 @@ describe(Support.getTestDialectTeaser("Hooks"), function () {
           this.Projects.hasOne(this.Tasks, {onDelete: 'cascade', hooks: true})
           this.Tasks.belongsTo(this.Projects)
 
-          this.Projects.sync({ force: true }).success(function() {
-            self.Tasks.sync({ force: true }).success(function() {
+          this.sequelize.sync({ force: true }).success(function() {
             done()
           })
         })
-        })
 
         describe('#remove', function() {
           it('with no errors', function(done) {
@@ -6733,12 +6731,10 @@ describe(Support.getTestDialectTeaser("Hooks"), function () {
           this.Projects.hasMany(this.Tasks)
           this.Tasks.belongsTo(this.Projects)
 
-          this.Projects.sync({ force: true }).success(function() {
-            self.Tasks.sync({ force: true }).success(function() {
+          this.sequelize.sync({ force: true }).success(function() {
             done()
           })
         })
-        })
 
         describe('#remove', function() {
           it('with no errors', function(done) {
@@ -6842,12 +6838,10 @@ describe(Support.getTestDialectTeaser("Hooks"), function () {
           this.Projects.hasMany(this.Tasks, {cascade: 'onDelete', joinTableName: 'projects_and_tasks', hooks: true})
           this.Tasks.hasMany(this.Projects, {cascade: 'onDelete', joinTableName: 'projects_and_tasks', hooks: true})
 
-          this.Projects.sync({ force: true }).success(function() {
-            self.Tasks.sync({ force: true }).success(function() {
+          this.sequelize.sync({ force: true }).success(function() {
             done()
           })
         })
-        })
 
         describe('#remove', function() {
           it('with no errors', function(done) {
@@ -6952,12 +6946,10 @@ describe(Support.getTestDialectTeaser("Hooks"), function () {
           this.Projects.hasMany(this.Tasks, {hooks: true})
           this.Tasks.hasMany(this.Projects, {hooks: true})
 
-          this.Projects.sync({ force: true }).success(function() {
-            self.Tasks.sync({ force: true }).success(function() {
+          this.sequelize.sync({ force: true }).success(function() {
             done()
           })
         })
-        })
 
         describe('#remove', function() {
           it('with no errors', function(done) {

test/mysql/associations.test.js

@@ -57,8 +57,8 @@ if (Support.dialectIsMySQL()) {
         this.users = null
         this.tasks = null
 
-        this.User.hasMany(this.Task, {as:'Tasks'})
-        this.Task.hasMany(this.User, {as:'Users'})
+        this.User.hasMany(this.Task, {as:'Tasks', through: 'UserTasks'})
+        this.Task.hasMany(this.User, {as:'Users', through: 'UserTasks'})
 
         var self = this
           , users = []
@@ -72,8 +72,7 @@ if (Support.dialectIsMySQL()) {
           tasks[tasks.length] = {name: 'Task' + Math.random()}
         }
 
-        this.User.sync({ force: true }).success(function() {
-          self.Task.sync({ force: true }).success(function() {
+        this.sequelize.sync({ force: true }).success(function() {
           self.User.bulkCreate(users).success(function() {
             self.Task.bulkCreate(tasks).success(function() {
               done()
@@ -81,7 +80,6 @@ if (Support.dialectIsMySQL()) {
           })
         })
       })
-      })
 
       describe('addDAO / getDAO', function() {
         beforeEach(function(done) {

test/postgres/associations.test.js

@@ -63,8 +63,8 @@ if (dialect.match(/^postgres/)) {
           this.users = null
           this.tasks = null
 
-          this.User.hasMany(this.Task, {as:'Tasks'})
-          this.Task.hasMany(this.User, {as:'Users'})
+          this.User.hasMany(this.Task, {as:'Tasks', through: 'usertasks'})
+          this.Task.hasMany(this.User, {as:'Users', through: 'usertasks'})
 
           var self = this
             , users = []
@@ -78,8 +78,7 @@ if (dialect.match(/^postgres/)) {
             tasks[tasks.length] = {name: 'Task' + Math.random()}
           }
 
-          self.User.sync({ force: true }).success(function() {
-            self.Task.sync({ force: true }).success(function() {
+          this.sequelize.sync({ force: true }).success(function() {
             self.User.bulkCreate(users).success(function() {
               self.Task.bulkCreate(tasks).success(function() {
                 self.User.all().success(function(_users) {
@@ -93,7 +92,6 @@ if (dialect.match(/^postgres/)) {
             })
           })
         })
-        })
 
         it('should correctly add an association to the dao', function(done) {
           var self = this
@@ -122,8 +120,8 @@ if (dialect.match(/^postgres/)) {
           this.users = null
           this.tasks = null
 
-          this.User.hasMany(this.Task, {as:'Tasks'})
-          this.Task.hasMany(this.User, {as:'Users'})
+          this.User.hasMany(this.Task, {as:'Tasks', through: 'usertasks'})
+          this.Task.hasMany(this.User, {as:'Users', through: 'usertasks'})
 
           for (var i = 0; i < 5; ++i) {
             users[users.length] = {id: i+1, name: 'User' + Math.random()}
@@ -133,8 +131,7 @@ if (dialect.match(/^postgres/)) {
             tasks[tasks.length] = {id: x+1, name: 'Task' + Math.random()}
           }
 
-          self.User.sync({ force: true }).success(function() {
-            self.Task.sync({ force: true }).success(function() {
+          this.sequelize.sync({ force: true }).success(function() {
             self.User.bulkCreate(users).done(function(err) {
               expect(err).not.to.be.ok
               self.Task.bulkCreate(tasks).done(function(err) {
@@ -169,5 +166,4 @@ if (dialect.match(/^postgres/)) {
       })
     })
   })
-  })
 }

test/sequelize.executable.test.js

@@ -7,10 +7,12 @@ var chai      = require('chai')
   , exec      = require('child_process').exec
   , version   = (require(__dirname + '/../package.json')).version
   , path      = require('path')
+  , os        = require('os')
 
 chai.Assertion.includeStack = true
 
-describe(Support.getTestDialectTeaser("Executable"), function() {
+if (os.type().toLowerCase().indexOf('windows') === -1) {
+  describe(Support.getTestDialectTeaser("Executable"), function() {
     describe('call without arguments', function() {
       it("prints usage instructions", function(done) {
         exec('bin/sequelize', function(err, stdout, stderr) {
@@ -433,4 +435,6 @@ describe(Support.getTestDialectTeaser("Executable"), function() {
         })
       })
     })(['--url', '-U'])
-})
+  })
+
+}

test/support.js

 var fs        = require('fs')
   , path      = require('path')
+  , _         = require('lodash')
   , Sequelize = require(__dirname + "/../index")
   , DataTypes = require(__dirname + "/../lib/data-types")
   , Config    = require(__dirname + "/config/config")
@@ -44,30 +45,23 @@ var Support = {
 
     var config = Config[options.dialect]
 
-    options.logging = (options.hasOwnProperty('logging') ? options.logging : false)
-    options.pool    = options.pool !== undefined ? options.pool : config.pool
-
-    var sequelizeOptions = {
+    var sequelizeOptions = _.defaults(options, {
       host:           options.host || config.host,
-      logging:        options.logging,
+      logging:        false,
       dialect:        options.dialect,
       port:           options.port || process.env.SEQ_PORT || config.port,
-      pool:           options.pool,
+      pool:           config.pool,
       dialectOptions: options.dialectOptions || {}
-    }
+    })
 
-    if (!!options.define) {
-      sequelizeOptions.define = options.define
+    if (process.env.DIALECT === 'postgres-native') {
+      sequelizeOptions.native = true
     }
 
     if (!!config.storage) {
       sequelizeOptions.storage = config.storage
     }
 
-    if (process.env.DIALECT === 'postgres-native') {
-      sequelizeOptions.native = true
-    }
-
     return this.getSequelizeInstance(config.database, config.username, config.password, sequelizeOptions)
   },