possibility to listen for all finished commands

lib/query-interface.js

@@ -5,9 +5,17 @@ module.exports = (function() {
     this.sequelize = sequelize
     this.sequelize = sequelize
     this.QueryGenerator = require('./connectors/' + this.sequelize.options.connector + '/query-generator')
     this.QueryGenerator = require('./connectors/' + this.sequelize.options.connector + '/query-generator')
   }
   }
+  Utils.addEventEmitter(QueryInterface)
 
 
   QueryInterface.prototype.createTable = function(tableName, attributes, options) {
   QueryInterface.prototype.createTable = function(tableName, attributes, options) {
-    return query.call(this, this.QueryGenerator.createTableQuery(tableName, attributes, options))
+    var _query = query.call(this, this.QueryGenerator.createTableQuery(tableName, attributes, options))
+      , self   = this
+
+    _query
+      .success(function(){ self.emit('createTable', null) })
+      .error(function(err){ self.emit('createTable', err)})
+
+    return _query
   }
   }
 
 
   QueryInterface.prototype.showAllTables = function() {
   QueryInterface.prototype.showAllTables = function() {
@@ -18,15 +26,25 @@ module.exports = (function() {
         var tableNames = Sequelize.Utils._.map(data, function(hash) {
         var tableNames = Sequelize.Utils._.map(data, function(hash) {
           return Sequelize.Utils._.values(hash)
           return Sequelize.Utils._.values(hash)
         })
         })
+
+        self.emit('showAllTables', null)
         emitter.emit('success', Sequelize.Utils._.flatten(tableNames))
         emitter.emit('success', Sequelize.Utils._.flatten(tableNames))
       }).error(function(err) {
       }).error(function(err) {
+        self.emit('showAllTables', err)
         emitter.emit('failure', err)
         emitter.emit('failure', err)
       })
       })
     }).run()
     }).run()
   }
   }
 
 
   QueryInterface.prototype.dropTable = function(tableName) {
   QueryInterface.prototype.dropTable = function(tableName) {
-    return query.call(this, this.QueryGenerator.dropTableQuery(tableName))
+    var _query = query.call(this, this.QueryGenerator.dropTableQuery(tableName))
+      , self   = this
+
+    _query
+      .success(function(){ self.emit('dropTable', null) })
+      .error(function(err){ self.emit('dropTable', err)})
+
+    return _query
   }
   }
 
 
   QueryInterface.prototype.dropAllTables = function() {
   QueryInterface.prototype.dropAllTables = function() {
@@ -41,9 +59,16 @@ module.exports = (function() {
         })
         })
         chainer
         chainer
           .run()
           .run()
-          .success(function() { emitter.emit('success', null) })
-          .error(function(err) { emitter.emit('failure', err) })
+          .success(function() {
+            self.emit('dropAllTables', null)
+            emitter.emit('success', null)
+          })
+          .error(function(err) {
+            self.emit('dropAllTables', err)
+            emitter.emit('failure', err)
+          })
       }).error(function(err) {
       }).error(function(err) {
+        self.emit('dropAllTables', err)
         emitter.emit('failure', err)
         emitter.emit('failure', err)
       })
       })
     }).run()
     }).run()
@@ -84,26 +109,54 @@ module.exports = (function() {
       query
       query
         .call(self, self.QueryGenerator.insertQuery(tableName, values), model)
         .call(self, self.QueryGenerator.insertQuery(tableName, values), model)
         .success(function(obj) {
         .success(function(obj) {
+          self.emit('insert', null)
+
           obj.isNewRecord = false
           obj.isNewRecord = false
           emitter.emit('success', obj)
           emitter.emit('success', obj)
         })
         })
-        .error(function(err) { emitter.emit('failure', err) })
+        .error(function(err) {
+          self.emit('insert', err)
+          emitter.emit('failure', err)
+        })
     }).run()
     }).run()
   }
   }
 
 
   QueryInterface.prototype.update = function(model, tableName, values, identifier) {
   QueryInterface.prototype.update = function(model, tableName, values, identifier) {
-    var sql = this.QueryGenerator.updateQuery(tableName, values, identifier)
-    return query.call(this, sql, model)
+    var sql    = this.QueryGenerator.updateQuery(tableName, values, identifier)
+      , _query = query.call(this, sql, model)
+      , self   = this
+
+    _query
+      .success(function(){ self.emit('update', null) })
+      .error(function(err){ self.emit('update', err)})
+
+    return _query
   }
   }
 
 
   QueryInterface.prototype.delete = function(model, tableName, identifier) {
   QueryInterface.prototype.delete = function(model, tableName, identifier) {
-    var sql = this.QueryGenerator.deleteQuery(tableName, identifier)
-    return query.call(this, sql, model)
+    var sql    = this.QueryGenerator.deleteQuery(tableName, identifier)
+      , _query = query.call(this, sql, model)
+      , self   = this
+
+    _query
+      .success(function(){ self.emit('delete', null) })
+      .error(function(err){ self.emit('delete', err)})
+
+    return _query
   }
   }
 
 
   QueryInterface.prototype.select = function(factory, tableName, options, queryOptions) {
   QueryInterface.prototype.select = function(factory, tableName, options, queryOptions) {
     queryOptions = queryOptions || {}
     queryOptions = queryOptions || {}
-    return query.call(this, this.QueryGenerator.selectQuery(tableName, options), factory, queryOptions)
+
+    var sql    = this.QueryGenerator.selectQuery(tableName, options)
+      , _query = query.call(this, sql, factory, queryOptions)
+      , self   = this
+
+    _query
+      .success(function(){ self.emit('select', null) })
+      .error(function(err){ self.emit('select', err)})
+
+    return _query
   }
   }
 
 
   QueryInterface.prototype.rawSelect = function(tableName, options, attributeSelector) {
   QueryInterface.prototype.rawSelect = function(tableName, options, attributeSelector) {
@@ -113,11 +166,14 @@ module.exports = (function() {
       throw new Error('Please pass an attribute selector!')
       throw new Error('Please pass an attribute selector!')
 
 
     return new Utils.CustomEventEmitter(function(emitter) {
     return new Utils.CustomEventEmitter(function(emitter) {
-      var sql = self.QueryGenerator.selectQuery(tableName, options)
+      var sql    = self.QueryGenerator.selectQuery(tableName, options)
+        , _query = query.call(self, sql, null, { plain: true, raw: true })
 
 
-      query.call(self, sql, null, { plain: true, raw: true }).success(function(data) {
+      _query.success(function(data) {
+        self.emit('rawSelect', null)
         emitter.emit('success', data[attributeSelector])
         emitter.emit('success', data[attributeSelector])
       }).error(function(err) {
       }).error(function(err) {
+        self.emit('rawSelect', err)
         emitter.emit('failure', err)
         emitter.emit('failure', err)
       })
       })
     }).run()
     }).run()