feat(transactions): promisify transactions

changelog.md

@@ -21,6 +21,7 @@ Notice: All 1.7.x changes are present in 2.0.x aswell
 - Model association calls (belongsTo/hasOne/hasMany) are no longer chainable. (this is to support being able to pass association references to include rather than model/as combinations)
 - `QueryInterface` no longer emits global events. This means you can no longer do things like `QueryInterface.on('showAllSchemas', function ... `
 - `sequelize.showAllSchemas` now returns an array of schemas, instead of an array containinig an array of schemas
+- `sequelize.transaction()` now returns a promise rather than a instance of Sequelize.Transaction
 
 # v2.0.0-dev11
 ### Caution: This release contains many changes and is highly experimental

lib/dialects/postgres/connector-manager.js

@@ -172,7 +172,11 @@ module.exports = (function() {
   };
 
   ConnectorManager.prototype.setTimezone = function(client, timezone, callback) {
-    client.query("SET TIME ZONE '" + (timezone ||  'UTC') + "'").on('end', callback);
+    client.query("SET TIME ZONE '" + (timezone ||  'UTC') + "'").on('error', function (err) {
+      callback(err);
+    }).on('end', function () {
+      callback();
+    });
   };
 
   ConnectorManager.prototype.disconnect = function() {

lib/sequelize.js

@@ -747,22 +747,14 @@ module.exports = (function() {
   Sequelize.prototype.transaction = function(_options, _callback) {
     var options = (typeof _options === 'function') ? {} : _options
       , callback = (typeof _options === 'function') ? _options : _callback
-      , wantsError = (callback.length === 2)
+      , wantsError = callback && callback.length === 2
       , transaction = new Transaction(this, options);
    
-    Utils.tick(function() {
-      if (wantsError) {
-        transaction.error(function(err) {
-          callback(err, transaction);
+    return transaction.prepareEnvironment().then(function () {
+      wantsError ? callback(null, transaction) : callback && callback(transaction);
+    }).catch(function (err) {
+      if (wantsError) callback(err);
     });
-      }
-
-      transaction.prepareEnvironment(function() {
-        wantsError ? callback(null, transaction) : callback(transaction);
-      });
-    });
-
-    return transaction;
   };
 
   Sequelize.prototype.log = function() {

lib/transaction.js

@@ -18,8 +18,6 @@ var Transaction = module.exports = function(sequelize, options) {
   }, options || {});
 };
 
-util.inherits(Transaction, Utils.CustomEventEmitter);
-
 /**
  * The possible isolations levels to use when starting a transaction
  *
@@ -71,7 +69,6 @@ Transaction.prototype.commit = function() {
     .sequelize
     .getQueryInterface()
     .commitTransaction(this, {})
-    .proxy(this)
     .done(this.cleanup.bind(this));
 };
 
@@ -86,53 +83,45 @@ Transaction.prototype.rollback = function() {
     .sequelize
     .getQueryInterface()
     .rollbackTransaction(this, {})
-    .proxy(this)
     .done(this.cleanup.bind(this));
 };
 
-Transaction.prototype.prepareEnvironment = function(callback) {
+Transaction.prototype.prepareEnvironment = function() {
   var self = this
     , connectorManager = self.sequelize.transactionManager.getConnectorManager(this.id);
 
-  this.begin(function() {
-    self.setIsolationLevel(function() {
-      self.setAutocommit(function() {
-        connectorManager.afterTransactionSetup(callback);
+  return this.begin().then(function () {
+    return self.setIsolationLevel();
+  }).then(function () {
+    return self.setAutocommit();
+  }).then(function () {
+    return new Utils.Promise(function (resolve, reject) {
+      connectorManager.afterTransactionSetup(function (err, result) {
+        if (err) return reject(err);
+        return resolve(result);
       });
     });
   });
 };
-
-// private
-var onError = function(err) {
-  this.emit('error', err);
-};
-
 Transaction.prototype.begin = function(callback) {
-  this
+  return this
     .sequelize
     .getQueryInterface()
-    .startTransaction(this, {})
-    .success(callback)
-    .error(onError.bind(this));
+    .startTransaction(this, {});
 };
 
 Transaction.prototype.setAutocommit = function(callback) {
-  this
+  return this
     .sequelize
     .getQueryInterface()
-    .setAutocommit(this, this.options.autocommit)
-    .success(callback)
-    .error(onError.bind(this));
+    .setAutocommit(this, this.options.autocommit);
 };
 
 Transaction.prototype.setIsolationLevel = function(callback) {
-  this
+  return this
     .sequelize
     .getQueryInterface()
-    .setIsolationLevel(this, this.options.isolationLevel)
-    .success(callback)
-    .error(onError.bind(this));
+    .setIsolationLevel(this, this.options.isolationLevel);
 };
 
 Transaction.prototype.cleanup = function() {

test/associations/belongs-to.test.js

@@ -42,7 +42,9 @@ describe(Support.getTestDialectTeaser("BelongsTo"), function() {
                       Group.all({ transaction: t }).success(function(groups) {
                         groups[0].getUser({ transaction: t }).success(function(associatedUser) {
                           expect(associatedUser).to.be.not.null
-                          t.rollback().success(function() { done() })
+                          t.rollback().success(function() {
+                            done()
+                          })
                         })
                       })
                     })