Cleaned up the BusterJS file even more, foreign keys should be working properly too.

lib/associations/has-many-single-linked.js

@@ -43,7 +43,7 @@ module.exports = (function() {
     if (obsoleteAssociations.length > 0) {
       // clear the old associations
       var obsoleteIds = obsoleteAssociations.map(function(associatedObject) {
-        associatedObject[self.__factory.identifier] = null
+        associatedObject[self.__factory.identifier] = (newAssociations.length < 1 ? null : self.instance.id)
         return associatedObject.id
       })
 
@@ -55,12 +55,12 @@ module.exports = (function() {
     if (unassociatedObjects.length > 0) {
       // set the new associations
       var unassociatedIds = unassociatedObjects.map(function(associatedObject) {
-        associatedObject[self.__factory.identifier] = self.instance.id
+        associatedObject[self.__factory.identifier] = (newAssociations.length < 1 ? null : self.instance.id)
         return associatedObject.id
       })
 
       update = {}
-      update[self.__factory.identifier] = self.instance.id
+      update[self.__factory.identifier] = (newAssociations.length < 1 ? null : self.instance.id)
       chainer.add(this.__factory.target.update(update, { id: unassociatedIds }))
     }
 

lib/associations/has-one.js

@@ -70,17 +70,25 @@ module.exports = (function() {
 
   HasOne.prototype.injectSetter = function(obj) {
     var self    = this
-      , options = self.options || {}
 
     obj[this.accessors.set] = function(associatedObject) {
-      var instance = this;
+      var instance = this
       return new Utils.CustomEventEmitter(function(emitter) {
         instance[self.accessors.get]().success(function(oldObj) {
           if (oldObj) {
             oldObj[self.identifier] = null
-            oldObj.save()
+            oldObj.save().success(function() {
+              if (associatedObject) {
+                associatedObject[self.identifier] = instance.id
+                associatedObject
+                  .save()
+                  .success(function() { emitter.emit('success', associatedObject) })
+                  .error(function(err) { emitter.emit('error', err) })
+              } else {
+                emitter.emit('success', null)
               }
-
+            })
+          } else {
             if (associatedObject) {
               associatedObject[self.identifier] = instance.id
               associatedObject
@@ -90,7 +98,7 @@ module.exports = (function() {
             } else {
               emitter.emit('success', null)
             }
-
+          }
         })
       }).run()
     }

lib/query-interface.js

@@ -266,23 +266,129 @@ module.exports = (function() {
   }
 
   QueryInterface.prototype.update = function(dao, tableName, values, identifier) {
-    var sql = this.QueryGenerator.updateQuery(tableName, values, identifier)
-    return queryAndEmit.call(this, [sql, dao], 'update')
+    var self = this
+      , restrict = false
+      , sql = self.QueryGenerator.updateQuery(tableName, values, identifier)
+
+    // Check for a restrict field
+    if (!!dao.daoFactory && !!dao.daoFactory.associations) {
+      var keys = Object.keys(dao.daoFactory.associations)
+        , length = keys.length
+
+      for (var i = 0; i < length; i++) {
+        if (dao.daoFactory.associations[keys[i]].options && dao.daoFactory.associations[keys[i]].options.onUpdate && dao.daoFactory.associations[keys[i]].options.onUpdate === "restrict") {
+          restrict = true
+        }
+      }
+    }
+
+    return new Utils.CustomEventEmitter(function(emitter) {
+      var chainer = new Utils.QueryChainer()
+
+        chainer.add(self, 'enableForeignKeyConstraints', [])
+        chainer.add(self, 'queryAndEmit', [[sql, dao], 'delete'])
+
+      chainer.runSerially()
+      .success(function(results){
+        emitter.query = { sql: sql }
+        emitter.emit('success', results[1])
+        emitter.emit('sql', sql)
+      })
+      .error(function(err) {
+        emitter.query = { sql: sql }
+        emitter.emit('error', err)
+        emitter.emit('sql', sql)
+      })
+      .on('sql', function(sql) {
+        console.log('SQL!');
+        emitter.emit('sql', sql)
+      })
+    }).run()
   }
 
   QueryInterface.prototype.bulkUpdate = function(tableName, values, identifier) {
-    var sql = this.QueryGenerator.updateQuery(tableName, values, identifier)
-    return queryAndEmit.call(this, sql, 'bulkUpdate')
+    var self = this
+      , sql = self.QueryGenerator.updateQuery(tableName, values, identifier)
+
+    return new Utils.CustomEventEmitter(function(emitter) {
+      var chainer = new Utils.QueryChainer()
+
+      chainer.add(self, 'enableForeignKeyConstraints', [])
+      chainer.add(self, 'queryAndEmit', [sql, 'bulkUpdate'])
+
+      return chainer.runSerially()
+      .success(function(results){
+        emitter.query = { sql: sql }
+        emitter.emit('sql', sql)
+        emitter.emit('success', results[1])
+      })
+      .error(function(err) {
+        emitter.query = { sql: sql }
+        emitter.emit('sql', sql)
+        emitter.emit('error', err)
+      })
+    }).run()
   }
 
   QueryInterface.prototype.delete = function(dao, tableName, identifier) {
-    var sql = this.QueryGenerator.deleteQuery(tableName, identifier)
-    return queryAndEmit.call(this, [sql, dao], 'delete')
+    var self = this
+      , restrict = false
+      , sql = self.QueryGenerator.deleteQuery(tableName, identifier)
+
+    // Check for a restrict field
+    if (!!dao.daoFactory && !!dao.daoFactory.associations) {
+      var keys = Object.keys(dao.daoFactory.associations)
+        , length = keys.length
+
+      for (var i = 0; i < length; i++) {
+        if (dao.daoFactory.associations[keys[i]].options && dao.daoFactory.associations[keys[i]].options.onDelete && dao.daoFactory.associations[keys[i]].options.onDelete === "restrict") {
+          restrict = true
+        }
+      }
+    }
+
+    return new Utils.CustomEventEmitter(function(emitter) {
+      var chainer = new Utils.QueryChainer()
+
+        chainer.add(self, 'enableForeignKeyConstraints', [])
+        chainer.add(self, 'queryAndEmit', [[sql, dao], 'delete'])
+
+      chainer.runSerially()
+      .success(function(results){
+        emitter.query = { sql: sql }
+        emitter.emit('sql', sql)
+        emitter.emit('success', results[1])
+      })
+      .error(function(err) {
+        emitter.query = { sql: sql }
+        emitter.emit('sql', sql)
+        emitter.emit('error', err)
+      })
+    }).run()
   }
 
   QueryInterface.prototype.bulkDelete = function(tableName, identifier, options) {
-    var sql = this.QueryGenerator.deleteQuery(tableName, identifier, Utils._.defaults(options || {}, {limit: null}))
-    return queryAndEmit.call(this, sql, 'bulkDelete')
+    var self = this
+    var sql = self.QueryGenerator.deleteQuery(tableName, identifier, Utils._.defaults(options || {}, {limit: null}))
+
+    return new Utils.CustomEventEmitter(function(emitter) {
+      var chainer = new Utils.QueryChainer()
+
+      chainer.add(self, 'enableForeignKeyConstraints', [])
+      chainer.add(self, 'queryAndEmit', [sql, 'bulkDelete', options])
+
+      chainer.runSerially()
+      .success(function(results){
+        emitter.query = { sql: sql }
+        emitter.emit('sql', sql)
+        emitter.emit('success', results[1])
+      })
+      .error(function(err) {
+        emitter.query = { sql: sql }
+        emitter.emit('sql', sql)
+        emitter.emit('error', err)
+      })
+    }).run()
   }
 
   QueryInterface.prototype.select = function(factory, tableName, options, queryOptions) {
@@ -385,9 +491,7 @@ module.exports = (function() {
     return this.QueryGenerator.escape(value)
   }
 
-  // private
-
-  var queryAndEmit = function(sqlOrQueryParams, methodName, options, emitter) {
+  var queryAndEmit = QueryInterface.prototype.queryAndEmit = function(sqlOrQueryParams, methodName, options, emitter) {
     options = Utils._.extend({
       success: function(){},
       error: function(){}

spec/associations/foreign-keys.spec.js

+/* jshint camelcase: false */
+var buster    = require("buster")
+  , Helpers   = require('../buster-helpers')
+  , Sequelize = require('../../index')
+  , DataTypes = require(__dirname + "/../../lib/data-types")
+  , dialect   = Helpers.getTestDialect()
+
+buster.spec.expose()
+buster.testRunner.timeout = 1000
+
+describe(Helpers.getTestDialectTeaser("ForeignKeys"), function() {
+  var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
+
+  before(function(done) {
+    var self = this
+    self.sequelize = Object.create(sequelize)
+    Helpers.clearDatabase(this.sequelize, done)
+  })
+
+  afterAll(function(done) {
+    Helpers.clearDatabase(sequelize, done)
+  })
+
+  describe("Foreign key constraints", function() {
+    it("are not enabled by default", function(done) {
+      var self = Object.create(this.sequelize)
+        , Task = self.define('Task1', { title: Sequelize.STRING })
+        , User = self.define('User1', { username: Sequelize.STRING })
+
+      User.hasMany(Task)
+
+      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.setTask1s([task]).success(function() {
+                user.destroy().success(function() {
+                  Task.findAll().success(function(tasks) {
+                    expect(tasks.length).toEqual(1)
+                    done()
+                  })
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+
+    it("can cascade deletes", function(done) {
+      var self = Object.create(this.sequelize)
+        , Task = self.define('Task2', { title: DataTypes.STRING })
+        , User = self.define('User2', { username: DataTypes.STRING })
+
+      User.hasMany(Task, {onDelete: 'cascade'})
+
+      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.setTask2s([task]).success(function() {
+                user.destroy()
+                .error(function(err) {
+                  expect(false).toEqual('This shouldn\'t error.')
+                  done()
+                })
+                .success(function() {
+                  Task.all({where: {User2Id: user.id}}).success(function(tasks) {
+                    expect(tasks.length).toEqual(0)
+                    done()
+                  })
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+
+    it("can restrict deletes", function(done) {
+      var self = Object.create(this.sequelize)
+        , Task = self.define('Task3', { title: DataTypes.STRING })
+        , User = self.define('User3', { username: DataTypes.STRING })
+
+      User.hasMany(Task, {onDelete: 'restrict'})
+
+      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.setTask3s([task]).success(function() {
+                user.destroy()
+                .success(function(success) {
+                  expect(false).toEqual('This shouldn\'t succeed.')
+                  done()
+                })
+                .error(function(err) {
+                  // Should fail due to FK restriction
+                  Task.all().success(function(tasks) {
+                    expect(tasks.length).toEqual(1)
+                    done()
+                  })
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+
+    it("can cascade updates", function(done) {
+      var self = Object.create(this.sequelize)
+        , Task = self.define('Task4', { title: DataTypes.STRING })
+        , User = self.define('User4', { username: DataTypes.STRING })
+
+      User.hasMany(Task, {onUpdate: 'cascade'})
+
+      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.setTask4s([task]).success(function() {
+
+                // Changing the id of a DAO requires a little dance since
+                // the `UPDATE` query generated by `save()` uses `id` in the
+                // `WHERE` clause
+
+                var tableName = user.QueryInterface.QueryGenerator.addSchema(user.__factory)
+                user.QueryInterface.update(user, tableName, {id: 999}, user.id)
+                .error(function() {
+                  expect(false).toEqual('This shouldn\'t error.')
+                  done()
+                })
+                .success(function() {
+                  Task.all().success(function(tasks) {
+                    expect(tasks.length).toEqual(1)
+                    expect(tasks[0].User4Id).toEqual(999)
+                    done()
+                  })
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+
+    it("can restrict updates", function(done) {
+      var self = Object.create(this.sequelize)
+        , Task = self.define('Task5', { title: DataTypes.STRING })
+        , User = self.define('User5', { username: DataTypes.STRING })
+
+      User.hasMany(Task, {onUpdate: 'restrict'})
+
+      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.setTask5s([task]).success(function() {
+
+                // Changing the id of a DAO requires a little dance since
+                // the `UPDATE` query generated by `save()` uses `id` in the
+                // `WHERE` clause
+
+                var tableName = user.QueryInterface.QueryGenerator.addSchema(user.__factory)
+                user.QueryInterface.update(user, tableName, {id: 999}, user.id)
+                .success(function() {
+                  expect(false).toEqual('You shouldn\'t reach this.')
+                  done()
+                })
+                .error(function() {
+                  // Should fail due to FK restriction
+                  Task.all().success(function(tasks) {
+                    expect(tasks.length).toEqual(1)
+                    done()
+                  })
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+  })
+})

spec/configuration.spec.js

@@ -50,6 +50,7 @@ describe(Helpers.getTestDialectTeaser("Configuration"), function() {
         return done()
       }
 
+      (function() {
         var sequelizeSpecific1 = new Sequelize(config[dialect].database, config[dialect].username, 'fakepass123', {logging: false, host: config[dialect].host, port: 1, dialect: dialect})
         , domain = require('domain')
         , d = domain.create()
@@ -65,6 +66,7 @@ describe(Helpers.getTestDialectTeaser("Configuration"), function() {
           sequelizeSpecific1.query('select 1 as hello')
           .success(function(){})
         })
+      })()
     })
 
     it('when we don\'t have a valid dialect.', function(done) {

spec/dao.spec.js

@@ -36,10 +36,9 @@ describe(Helpers.getTestDialectTeaser("DAO"), function() {
 
   before(function(done) {
     var self = this
-
-    self.sequelize = sequelize
+    self.sequelize = Object.create(sequelize)
     self.User      = User
-    Helpers.clearDatabase(this.sequelize, function(){
+    Helpers.clearDatabase(self.sequelize, function(){
       self.User.sync({ force: true }).success(done)
     })
   })
@@ -999,8 +998,8 @@ describe(Helpers.getTestDialectTeaser("DAO"), function() {
           identifier: 'identifier'
         }).success(function(user) {
           var emitter = user.updateAttributes({name: 'foobar'})
-          emitter.success(function() {
-            expect(emitter.query.sql).toMatch(/WHERE [`"]identifier[`"]..identifier./)
+          emitter.on('sql', function(sql) {
+            expect(sql).toMatch(/WHERE [`"]identifier[`"]..identifier./)
             done()
           })
         })

spec/dao.validations.spec.js

@@ -7,16 +7,13 @@ buster.spec.expose()
 buster.testRunner.timeout = 1000
 
 describe(Helpers.getTestDialectTeaser("DaoValidator"), function() {
+  var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
+
   describe('validations', function() {
     beforeAll(function(done) {
       var self = this
-      Helpers.initTests({
-        dialect: dialect,
-        onComplete: function(sequelize) {
-          self.sequelize = sequelize
-          done()
-        }
-      })
+      self.sequelize = Object.create(sequelize)
+      Helpers.clearDatabase(self.sequelize, done)
     })
 
     var checks = {

spec/language.spec.js

@@ -7,31 +7,30 @@ buster.spec.expose()
 buster.testRunner.timeout = 1000
 
 describe(Helpers.getTestDialectTeaser("Language Util"), function() {
+  var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
   describe("Plural", function(){
-    beforeAll(function(done) {
+    before(function(done) {
       var self = this
-      Helpers.initTests({
-        dialect: dialect,
-        onComplete: function(sequelize) {
-          self.sequelize = sequelize
+      self.sequelize = Object.create(sequelize)
       self.sequelize.options.language = 'es'
-          done()
-        }
-      })
+      Helpers.clearDatabase(self.sequelize, done)
     })
 
     it("should rename tables to their plural form...", function(done){
-      var table = this.sequelize.define('arbol', {name: Sequelize.STRING})
-      var table2 = this.sequelize.define('androide', {name: Sequelize.STRING})
+      var self = this
+        , table = self.sequelize.define('arbol', {name: Sequelize.STRING})
+        , table2 = self.sequelize.define('androide', {name: Sequelize.STRING})
+
       expect(table.tableName).toEqual('arboles')
       expect(table2.tableName).toEqual('androides')
       done()
     })
 
     it("should be able to pluralize/singularize associations...", function(done){
-      var table = this.sequelize.define('arbol', {name: Sequelize.STRING})
-      var table2 = this.sequelize.define('androide', {name: Sequelize.STRING})
-      var table3 = this.sequelize.define('hombre', {name: Sequelize.STRING})
+      var self = this
+        , table = self.sequelize.define('arbol', {name: Sequelize.STRING})
+        , table2 = self.sequelize.define('androide', {name: Sequelize.STRING})
+        , table3 = self.sequelize.define('hombre', {name: Sequelize.STRING})
 
       table.hasOne(table2)
       table2.belongsTo(table)

spec/promise.spec.js

@@ -34,9 +34,9 @@ describe(Helpers.getTestDialectTeaser("Promise"), function () {
 
   before(function(done) {
     var self = this
-    self.sequelize = sequelize
+    self.sequelize = Object.create(sequelize)
     self.User      = User
-    Helpers.clearDatabase(this.sequelize, function(){
+    Helpers.clearDatabase(self.sequelize, function(){
       self.User.sync({ force: true }).then(function() {done()}, done)
     })
   })

spec/query-generator.spec.js

@@ -11,8 +11,9 @@ describe(Helpers.getTestDialectTeaser("QueryGenerators"), function() {
   var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
 
   before(function(done) {
-    this.sequelize = sequelize
-    this.interface = this.sequelize.getQueryInterface()
+    var self = this
+    self.sequelize = Object.create(sequelize)
+    self.interface = self.sequelize.getQueryInterface()
     done()
   })
 

spec/query-interface.spec.js

@@ -9,9 +9,10 @@ describe(Helpers.getTestDialectTeaser("QueryInterface"), function() {
   var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
 
   before(function(done) {
-    this.sequelize = sequelize
-    this.interface = this.sequelize.getQueryInterface()
-    Helpers.clearDatabase(this.sequelize, done)
+    var self = this
+    self.sequelize = Object.create(sequelize)
+    self.interface = self.sequelize.getQueryInterface()
+    Helpers.clearDatabase(self.sequelize, done)
   })
 
   describe('dropAllTables', function() {

spec/sequelize.spec.js

@@ -22,7 +22,7 @@ describe(Helpers.getTestDialectTeaser("Sequelize"), function() {
 
   before(function(done) {
     var self = this
-    self.sequelize = sequelize
+    self.sequelize = Object.create(sequelize)
     Helpers.clearDatabase(self.sequelize, done)
   })