Установите минимальную задержку для разрешения обещания bluebird.js

Я считаю, что все, что вам нужно сделать, это Promise.delay(value).return(promise):

Вы можете обернуть его в служебную функцию:

function stallPromise(promise, delay) {
    return Promise.delay(delay).return(promise);
}

function doSomethingAsync(minDelay) {
    var p = new Promise(makeCallWith3SecondLatency); 

    return stallPromise(p, minDelay);
}

var minDelay = 5000;
doSomethingAsync(minDelay).then(printResult);

http://jsfiddle.net/s572rg7y/1/

Обратите внимание: если обещание отклонено, отложенное обещание не будет отклонено до тех пор, пока не истечет пять секунд. Это может быть желаемым поведением (как указывает @Benjamin Gruenbaum в комментариях), но если вы предпочитаете, чтобы оно было немедленно отклонено, есть два других варианта:

С Promise.join:

function stallPromise(promise, delay) {
    // if you're using underscore/lodash, you can use _.identity for this
    function identity(val) { return val; }

    return Promise.join(promise, Promise.delay(delay), identity);
}

Или подход @Benjamin Gruenbaum с Promise.all:

function minDelay(promise, delay) {
    Promise.all([promise, Promise.delay(delay)]).get(0);
}

Твоя проблема

Прежде всего, обещание другого 3-х секундного звонка здесь не имеет значения, оно не должно быть частью обещания. Хотя я польщен, что вам понравился мой ответ с .join, это также не тот инструмент, который я бы использовал здесь.

Во-первых, вызов API — это просто произвольная функция, возвращающая обещание.

function yourApiCall(){
    // your function that returns a promise AFTER promisificatin
}

На самом деле, нас это мало волнует. Это может быть и просто:

var p = ... ; //p is a promise

Теперь мы хотим убедиться, что прошло не менее 3 секунд, прежде чем мы разрешим p.

function minDelay(p, ms){ // stealing name from JLRishe's answer
    return Promise.all([p, Promise.delay(ms)]).get(0);
}

Который принимает произвольное обещание и возвращает обещание, для разрешения которого требуется не менее ms миллисекунд.

minDelay(p, 300).then(function(el){
   // el is minDelay's return value and at least 300 ms have passed
});

Вы также можете поместить его в прототип Bluebird (если вы пишете библиотеку, обязательно сначала получите свою собственную изолированную копию):

Promise.prototype.minDelay = function minDelay(ms){
    // note that unlike the example above this will delay 
    // on rejections too 
    return Promise.delay(ms).return(this);
}

Что позволит вам декларативно сделать:

p.minDelay(300).then(function(res){
   // access result
}); 

Более общая проблема

Часто, когда люди спрашивают об этой проблеме, на самом деле их волнует то, чтобы функция возвращала результат не чаще, чем каждые миллисекунды, или чтобы функция действовала как монитор того, как часто выполняются вызовы. Это необходимо для ограничения количества вызовов, которые выполняются в веб-службе, которая ограничивает скорость. Это должно быть ограничено на уровне функции, возвращающей обещание. Например:

var queue = Promise.resolve();
function throttle(fn, ms){
    var res = queue.then(function(){ // wait for queue
        return fn(); // call the function
    });
    queue = Promise.delay(ms).return(queue); // make the queue wait
    return res; // return the result
}

Это позволит вам сделать:

function myApiCall(){
    // returns a promise
}
var api = throttle(myApiCall, 300); // make call at most every 300 ms;

api(); // calls will be sequenced and queued
api(); // calls will be made at most every 300 ms
api(); // just be sure to call this directly, return this to consumers

Библиотека spex была написана специально для решения таких проблем, как регулирование данных и балансировка нагрузки при использовании промисов.

В вашем случае мы можем использовать следующий пример:

var spex = require('spex')(Promise);

function source(index, data, delay) {
    var start = Date.now();
    return new Promise(function (resolve) {
        // request your data here;

        var end = Date.now();
        if (end - start < 5000) {
            setTimeout(function () {
                resolve();
            }, 5000 - end + start);
        } else {
            resolve();
        }
    });
}

function dest(index, data, delay) {
    // you can do additional load balancing here,
    // while processing the data;
}

spex.sequence(source, dest)
    .then(function (data) {
        console.log("DATA:", data);
    });

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

В вашем случае может быть интересен параметр delay, который передается как в исходную, так и в целевую функции, поэтому при необходимости балансировка нагрузки может выполняться в двух направлениях.

Кроме того, вы можете использовать метод page с та же стратегия балансировки нагрузки, но обработка запросов на страницах.