Как использовать модуль "q" для рефакторинга кода мангуста?

Ответ 1

Вы хотите использовать Q.nfcall, документированный в README и Wiki. Все методы Mongoose имеют стиль Node. Я также использую .spread вместо ручного деструктурирования .then.

var mongoose = require('mongoose');
mongoose.connect('mongo://localhost/test');
var conn = mongoose.connection;

var users = conn.collection('users');
var channels = conn.collection('channels');
var articles = conn.collection('articles');

function getInsertedArticles() {
    return Q.nfcall(users.insert.bind(users), [{/*user1*/},{/*user2*/}]).spread(function (user1, user2) {
        return Q.nfcall(channels.insert.bind(channels), [{userId:user1._id},{userId:user2._id}]).spread(function (channel1, channel2) {
            return Q.nfcall(articles.insert.bind(articles), [{userId:user1._id,channelId:channel1._id},{}]);
        });
    })
}

getInsertedArticles()
    .spread(function (article1, article2) {
        // you only get here if all three of the above steps succeeded
    })
    .fail(function (error) {
        // you get here if any of the above three steps failed
    }
);

На практике редко вы хотите использовать .spread, поскольку обычно вы вставляете массив, который не знает размер. В этом случае код может выглядеть более как это (здесь я также иллюстрирую Q.nbind).

Для сравнения с оригинальным не совсем справедливо, потому что у вашего оригинала нет обработки ошибок. Исправленная версия оригинальной версии Node будет выглядеть так:

var mongoose = require('mongoose');
mongoose.connect('mongo://localhost/test');
var conn = mongoose.connection;

function getInsertedArticles(cb) {
    // insert users
    conn.collection('users').insert([{/*user1*/},{/*user2*/}], function(err, docs) {
        if (err) {
            cb(err);
            return;
        }

        var user1 = docs[0], user2 = docs[1];

        // insert channels
        conn.collection('channels').insert([{userId:user1._id},{userId:user2._id}], function(err, docs) {
            if (err) {
                cb(err);
                return;
            }

            var channel1 = docs[0], channel2 = docs[1];

            // insert articles
            conn.collection('articles').insert([{userId:user1._id,channelId:channel1._id},{}], function(err, docs) {
                if (err) {
                    cb(err);
                    return;
                }

                var article1 = docs[0], article2 = docs[1];

                cb(null, [article1, article2]);
            }
        });
    };
}

getInsertedArticles(function (err, articles) {
    if (err) {
        // you get here if any of the three steps failed.
        // `articles` is `undefined`.
    } else {
        // you get here if all three succeeded.
        // `err` is null.
    }
});

Ответ 2

С альтернативным вариантом deferred вы можете сделать это следующим образом:

var mongoose = require('mongoose');
mongoose.connect('mongo://localhost/test');
var conn = mongoose.connection;

// Setup 'pinsert', promise version of 'insert' method
var promisify = require('deferred').promisify
mongoose.Collection.prototype.pinsert = promisify(mongoose.Collection.prototype.insert);

var user1, user2;
// insert users
conn.collection('users').pinsert([{/*user1*/},{/*user2*/}])
// insert channels
.then(function (users) {
  user1 = users[0]; user2 = users[1];
  return conn.collection('channels').pinsert([{userId:user1._id},{userId:user2._id}]);
})
// insert articles
.match(function (channel1, channel2) {
  return conn.collection('articles').pinsert([{userId:user1._id,channelId:channel1._id},{}]);
})
.done(function (articles) {
  // Do something with articles
}, function (err) {
   // Handle any error that might have occurred on the way
});    

Ответ 3

Учитывая Model.save вместо Collection.insert (совершенно одинаково в нашем случае).

Вам не нужно использовать Q, вы можете обернуть save и возвратите Mongoose Promise.

Сначала создайте метод утилиты, чтобы обернуть функцию сохранения, которая не очень чистая, но что-то вроде:

  //Utility function (put it in a better place)
  var saveInPromise = function (model) {

    var promise = new mongoose.Promise();

    model.save(function (err, result) {
      promise.resolve(err, result);
    });

    return promise;
  }

Затем вы можете использовать его вместо сохранения, чтобы связать свой promises

  var User = mongoose.model('User');
  var Channel = mongoose.model('Channel');
  var Article = mongoose.model('Article');

  //Step 1
  var user = new User({data: 'value'});
  saveInPromise(user).then(function () {

    //Step 2
    var channel = new Channel({user: user.id})
    return saveInPromise(channel);

  }).then(function (channel) {

    //Step 3
    var article = new Article({channel: channel.id})
    return saveInPromise(article);

  }, function (err) {
    //A single place to handle your errors

  });

Я предполагаю, что такую ​​простоту мы ищем. правильно? Конечно, функция полезности может быть реализована с лучшей интеграцией с Mongoose.

Позвольте мне знать, что вы об этом думаете.

Кстати, есть проблема с этой точной проблемой в Mongoose Github:

• Добавить возвращаемое значение "обещание" для операции сохранения модели

Я надеюсь, что он скоро будет решен. Я думаю, что это занимает несколько раз, потому что они думают перейти от mpromise к Q: см. здесь, а затем здесь.

Ответ 4

Два года спустя этот вопрос просто появился в моем клиенте RSS...

С мая 2012 года ситуация немного изменилась, и теперь мы можем решить эту проблему по-другому. Более конкретно, сообщество Javascript стало "уменьшающим сознание", поскольку решение включить Array.prototype.reduce (и другие методы Array) в ECMAScript5. Array.prototype.reduce всегда (и до сих пор) доступен как polyfill, но в то время он был немного оценен многими из нас. Разумеется, те, кто бежал впереди кривой, могут смириться с этим.

Задача, поставленная в вопросе, представляется формульной, с правилами следующим образом:

• Объекты в массиве, переданные как первый параметр в conn.collection(table).insert(), строятся следующим образом (где N соответствует индексу объекта в массиве):
  • [{},...]
  • [{userId: userN._id},...]
  • [{userId: userN._id, channelId: channelN._id},...]
• имена таблиц (по порядку): users, channels, articles.
• свойствами соответствующих объектов являются: user, channel, article (т.е. имена таблиц без плюрализации 's).

Общий шаблон из эта статья Taoofcode) для последовательного асинхронного вызова:

function workMyCollection(arr) {  
    return arr.reduce(function(promise, item) {
        return promise.then(function(result) {
            return doSomethingAsyncWithResult(item, result);
        });        
    }, q());
}

При довольно легкой адаптации этот шаблон может быть выполнен для упорядочения требуемого секвенирования:

function cascadeInsert(tables, n) {
    /* 
    /* tables: array of unpluralisd table names
    /* n: number of users to insert.
    /* returns promise of completion|error
     */
    var ids = []; // this outer array is available to the inner functions (to be read and written to).
    for(var i=0; i<n; i++) { ids.push({}); } //initialize the ids array with n plain objects.
    return tables.reduce(function (promise, t) {
        return promise.then(function (docs) {
            for(var i=0; i<ids.length; i++) {
                if(!docs[i]) throw (new Error(t + ": returned documents list does not match the request"));//or simply `continue;` to be error tolerant (if acceptable server-side).
                ids[i][t+'Id'] = docs[i]._id; //progressively add properties to the `ids` objects
            }
            return insert(ids, t + 's');
        });
    }, Q());
}

Наконец, здесь рабочая функция, возвращающая обещание, insert():

function insert(ids, t) {
    /* 
    /* ids: array of plain objects with properties as defined by the rules
    /* t: table name.
    /* returns promise of docs
     */
    var dfrd = Q.defer();
    conn.collection(t).insert(ids, function(err, docs) {
        (err) ? dfrd.reject(err) : dfrd.resolve(docs);
    });
    return dfrd.promise;
}

Таким образом, вы можете указать в качестве параметров, переданных в cascadeInsert, фактические имена таблиц/свойств и количество вставляемых пользователей.

cascadeInsert( ['user', 'channel', 'article'], 2 ).then(function () {
   // you get here if everything was successful
}).catch(function (err) {
   // you get here if anything failed
});

Это хорошо работает, потому что таблицы в вопросе имеют регулярные множественные числа (user = > users, channel = > channels). Если какой-либо из них был нерегулярным (например, stimulus = > stimuli, child = > children), тогда нам нужно было бы переосмыслить - (и, вероятно, реализовать хеш-поиск). В любом случае адаптация была бы довольно тривиальной.

Ответ 5

Сегодня мы mongoose-q. Плагин для mongoose, который дает вам такие вещи, как execQ и saveQ, которые возвращают Q promises.