Как отправить несколько запросов с одной конечной точки на Express?

Ответ 1

Там более одного способа сделать это:

Вложенные обратные вызовы

Без promises вы можете вложить обратные вызовы:

router.post('/search', (req, res) => {
    var collection = db.get().collection('styles')
    var data = [];

    collection.distinct('make.name', (err, docs) => {
      if (err) {
        // ALWAYS HANDLE ERRORS!
      }
      data.push({'make': docs });
        collection.distinct('model', (function (err, docs) {
          if (err) {
            // ALWAYS HANDLE ERRORS!
          }
          data.push({'model': docs });
          res.send(data);
        }))
    });
});

Это было бы самым простым способом, но обратите внимание, что это неэффективно, если эти два запроса могут выполняться параллельно.

Модуль async

Вы можете использовать модуль async:

router.post('/search', (req, res) => {
    var collection = db.get().collection('styles')
    var data = [];

    async.parallel({
      make: cb => collection.distinct('make.name', cb),
      model: cb => collection.distinct('model', cb),
    }, (err, responses) => {
      if (err) {
        // ALWAYS HANDLE ERRORS!
      }
      data.push({'make': responses.make });
      data.push({'model': responses.model });
      res.send(data);
    });
});

Смотрите: https://caolan.github.io/async/docs.html#parallel

Но это может быть не самым удобным способом.

ES2017 async/await

Самый гибкий способ сделать это, если у вас есть 30 вызовов сделать, будет:

• Используйте функции, которые возвращают promises вместо функций, которые принимают обратные вызовы
• Использовать async/await, если вы можете или, по крайней мере, создавать сопрограммы на основе генераторов
• Ожидание promises (или выход promises), когда логика должна выполняться последовательно
• Используйте Promise.all() для всего, что можно сделать параллельно

С асинхронным/ожиданием ваш код может выглядеть так:

    // in sequence:    
    var make = await collection.distinct('make.name');
    var model = await collection.distinct('model');
    // use 'make' and 'model'

Или:

    // in parallel:
    var array = await Promise.all([
      collection.distinct('make.name'),
      collection.distinct('model'),
    ]);
    // use array[0] and array[1]

Большим преимуществом async/await является обработка ошибок:

try {
  var x = await asyncFunc1();
  var array = await Promise.all([asyncFunc2(x), asyncFunc3(x)]);
  var y = asyncFunc4(array);
  console.log(await asyncFunc5(y));
} catch (err) {
  // handle any error here
}

Вы можете использовать его только внутри функции, созданной с помощью ключевого слова async. Для получения дополнительной информации см.:

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await

Для поддержки в браузерах см.

• http://caniuse.com/async-functions

Для поддержки в Node см.

• http://node.green/#ES2017-features-async-functions

В местах, где у вас нет встроенной поддержки async и await, вы можете использовать Babel:

• https://babeljs.io/docs/plugins/transform-async-to-generator/

или со слегка отличающимся синтаксисом, основанным на генераторе, как в co или сопрограмме Bluebird:

• https://www.npmjs.com/package/co
• http://bluebirdjs.com/docs/api/promise.coroutine.html

Смотрите эти ответы для получения дополнительной информации:

• try/catch блоки с асинхронным/ожиданием
• node.js ~ конструирование последовательности цепочек Promise разрешает
• Как выполнять функции генератора в параллельном режиме?
• node.js ~ конструирование последовательности цепочек Promise разрешает
• Использование async/wait + Bluebird для promisifyAll
• jQuery: вернуть данные после успеха ajax-звонка

Ответ 2

Вы можете сделать это с помощью Promises

router.post('/search', (req, res) => {
    var collection = db.get().collection('styles');
    // Create promise for "make.name" query
    let firstQuery = new Promise((resolve, reject) => {
        collection.distinct('make.name', (err, docs) => {
            if (!err) {
                resolve(docs);
            } else {
                reject(err);
            }
        });
    });
    // Create promise for "model" query
    let secondQuery = new Promise((resolve, reject) => {
        collection.distinct('model', (function (err, docs) {
            if (!err) {
                resolve(docs);
            } else {
                reject(err);
            }
        }))
    })
    // Run both queries at the same time and handle both resolve results or first reject
    Promise.all([firstQuery, secondQuery])
        .then((results) => {
            res.send({ "make.name": results[0], "model": results[1] });
        })
        .catch((err) => {
            // Catch error 
            res.send({});
        });
});

Также вы можете использовать деструктурирование в таких функциях обратного вызова:

Promise.all([firstQuery, secondQuery])
    .then(([makeName, model]) => res.send({ "make.name": makeName, model }))

UPD: если у вас есть куча коллекции для запроса, вы можете создать массив имен коллекций, сопоставить их с обещаниями и обработать с помощью Promise.all, например

let collections = ["firstCollection", "secondCollection", "nCollection"];
let promises = collections.map((collectionName) => {
    return new Promise((resolve, reject) => {
        collection.distinct(collectionName, (err, docs) => {
            if (!err) {
                resolve(docs)
            } else {
                reject(err);
            }
        });
    })
});
Promise.all(promises)
    .then(results => {
        // Do what you want to do
    })
    .catch(error => {
        // or catch 
    });