序列化js节点事务

Question

我现在是新的续集，我有点困惑如何使用续集的事务。

我的项目启动了可以同时调用的事件，这是一个最小化的示例，其中包含两个事件eventA或eventB，以及一个最小化的模型User。

var Sequelize = require（'sequelize'）;

module.exports = function(sequelize, DataTypes) {
    return sequelize.define('Uer', {
        stuff: {
            type: Sequelize.STRING,
            defaultValue: ""
        }
    }, {
        classMethods: {
            getAllUsers : function (resultsCallback) {                  
                this.findAll().complete(function(err, users) {
                    resultsCallback(err, users);                   
                })
            }
        },
        instanceMethods: {           

            update1: function (transaction) {
                    var stuff = this.stuff + "1";

                    this.updateUserAttributes(document, transaction, function(err, results){

                });
            },

            update2: function (transaction) {
                    var stuff = this.stuff + "2";

                    var document = {};
                    document.stuff = stuff;

                this.updateUserAttributes(document, transaction, function(err, results){

                });
            },

            updateUserAttributes : function(document, transaction, resultsCallback) {

                var docArray = [];                

                var call = _.after(Object.keys(document).length, function(){


                    this
                    .updateAttributes(document, docArray,  {
                        transaction: transaction
                    })
                    .complete(function(err, results) {
                        if (!!err) {
                            console.log('An error occurred while updating', err)   
                        } else if (!results) {
                            console.log('Failed to update User.')
                        }       

                        resultsCallback(err, results);  
                    });

                }.bind(this));   

                for(var key in document){
                    docArray.push(String(key));
                    call();
                }
            }
        }
    });
}

eventA

...
    sequelize.transaction(function(transaction) {
        User.sync().success(function(err, restuls){
            User.getAllUsers(function(err, results){
                for (var i = 0; i < results.length; i++){
                    results[i].update1(transaction)
                }
                transaction.commit();
            });     
        });
    });
...

eventB

    ....
sequelize.transaction(function(transaction) {
    User.sync().success(function(err, restuls){
        User.getAllUsers(function(err, results){
                for (var i = 0; i < results.length; i++){
                    results[i].update2(transaction)
                }
                transaction.commit();
            });     
        });
});
...

我的问题是，例如，事件A和事件B的首次出现被调用，但是其中只有一个保留在数据库中sutff =“ 2”而不是stuff =“ 12”。

Answer 1

这是我的实现，并且在任何地方都使用此方法。

function trans(callback, done) {
    sequelize.transaction(function (t) {
        function commit(callback) {
            t.commit().done(function (err) {
                console.log('commited')
                if (callback)
                    callback(err)
            })
        }

        function rollback(rollbackErr, callback) {
            t.rollback().done(function (err) {
                if (callback)
                    callback(err || rollbackErr)
            })
        }

        t.done(function () {
            if (done) done()
        })

        callback(commit, rollback, t)
    })
}



function someExecution(data, callback){

    trans(function(commit, rollback, t){
        Model.create(data, {transaction: t}).done(function(err, obj){
            if (err) return rollback(err, callback)
            Model.findAll({where: {some: 1}}, {transaction: t}).done(function(err, list){
                if (err) return rollback(err, callback)
                commit(callback)
            })
        })
    })

}

Answer 2

只是对于其他有相同问题的人。 我最终通过行锁定解决了这个问题。

另外，我没有将事务传递给所有.save()和.updateAttributtes() ，也没有正确使用更新属性，也就是说（至少对于我所看到的）：

updateAttributes（{fieldName：newFieldValue}，{fields：[fieldName]，transaction：transaction}）