var open = function(name, ver) {
  return new Promise(function(yes, no) {
     var req = indexedDB.open(name, var);
     req.onupgradedneeded = function(res) {
       no(req);
       req.onsuccess = null; // for clarity
     };
     req.onsuccess = function() {
       yes(res.result);
     };
     req.onblocked = no;
  }
});

open('db name', 3).then(function(db) {
  // use db here

 }, function(req) {
   // version upgrade logic here

   if (req instanceof IDBResult) {
    return new Promise(function(yes, no) {
      req.transaction.createObjectStore('store_3');
      req.onsuccess = function() {
        yes(req.result);
      });
    });
  }
});

我终于找到了一种方法来避免这个API的所有缺点，并且找到了一种解决方案，它公开了一个干净的基于承诺的接口，并推广到任意数量的数据库迁移。

• 架构更改 * 只能 * 在versionchange事务期间执行;但是数据改变 * 不能 * 在versionchange事务期间执行，因此我们必须区分数据和模式迁移，并且以不同的方式利用不同的事务来执行它们。更新数据改变 * 可以 * 在versionchange事务期间执行，但不是通过通常的db.transaction('readwrite', ...).objectstore(...)方法-这会抛出异常。
• 为了允许模式创建和填充的任意交错，我们必须将它们视为单独的迁移步骤，并且仅在前一步骤的事务成功后才尝试一个步骤。
• 规范（https：//www.example.com）明确禁止显式事务管理dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#transaction-concept，该规范限制了事务可重用的程度，因为一旦事件循环完成，事务将被标记为非活动状态
• 因此，方法.open(dbName, version)只允许一个versionchange事务，一旦成功，它就消失了。
• 因此，多个迁移步骤需要多次连续调用.open(dbName, version)
• versionchange事务在其他数据库连接打开时阻塞，因此在尝试链中的下一个迁移之前必须关闭每个连接。

下面是我为解决所有这些问题而编写的代码。

var newPromise = function(withDeferred) {
    var deferred = $q.defer();
    try {
        withDeferred(deferred);
    } catch (err) {
        deferred.reject(err); 
    }
    return deferred.promise;
};

var newTransactionPromise = function(getTransaction) {
    return newPromise(function(deferred) {
        var transaction = getTransaction();

        transaction.oncomplete = function(ev) { deferred.resolve(); };
        transaction.onabort = function(ev) { deferred.reject(transaction.error); };
    });
};

var newMigrationPromise = function(dbName, version, migration) {
    return newPromise(function(deferred) {
        var request = indexedDB.open(dbName, version);

        // NB: caller must ensure upgrade callback always called
        request.onupgradeneeded = function(event) {
            var db = request.result;
            newTransactionPromise(
                function() {
                    migration(db, request.transaction);
                    return request.transaction;
                })
                .then(function() { db.close(); })
                .then(deferred.resolve, deferred.reject);
        };

        request.onerror = function(ev) { deferred.reject(request.error); };
    });
};

var migrations = [
    function(db, transaction) {
        db.createObjectStore("entries", { keyPath: 'id', autoIncrement: true });
    },
    function(db, transactionn) {
        db.createObjectStore("entries2", { keyPath: 'id', autoIncrement: true });
    },
    function(db, transaction) {
        var entryStore = transaction.objectStore("entries");

        entryStore.add({description: "First task"});
    }
];

var upgradeAndOpen = function() {
    return open()
        .then(function(db) {
            var version = db.version;
            db.close(); // this connection will block the upgrade (AFAICT)
            return version;
        })
        .then(function(version) {
            return newPromise(function(deferred) {
                // version when created but empty is v1
                // so after the first migration (index: 0) the version must be 2
                var migrationsPerformed = version - 1;
                var migrationCount = migrations.length;

                var previousMigration = newPromise(function(deferred) { deferred.resolve(); });

                for (var index = migrationsPerformed; index < migrationCount; index++)
                {
                    var performNextMigration = newMigrationPromise.bind(this, "caesium", index+2, migrations[index]);
                    previousMigration = previousMigration.then(performNextMigration);
                }

                previousMigration.then(deferred.resolve, deferred.reject);
            });
        })
        .then(open);
};

var open = function() {
    return newPromise(function(deferred) {
        var request = indexedDB.open("caesium");

        request.onsuccess = function(ev) { deferred.resolve(request.result); };
        request.onerror = function(ev) { deferred.reject(request.error); };
    });
};

upgradeAndOpen()
    .then(function() { $scope.status = "completed"; }, function(err) { $scope.status = err; });

闭包库有promise wrapper for IndexedDB。它的开放数据库方法返回一个promise，IDB中的所有内容都用promise Package 在那里。
所以这和你的想法差不多。
下面是从那里摘录的例子：

goog.db.openDatabase('mydb', 1, function(ev, db, tx) {
    db.createObjectStore('mystore');
  }).addCallback(function(db) {
    var putTx = db.createTransaction(
        [],
        goog.db.Transaction.TransactionMode.READ_WRITE);
    var store = putTx.objectStore('mystore');
    store.put('value', 'key');
    goog.listen(putTx, goog.db.Transaction.EventTypes.COMPLETE, function() {
      var getTx = db.createTransaction([]);
      var request = getTx.objectStore('mystore').get('key');
      request.addCallback(function(result) {
        ...
      });
  });

我已经从那里开始，但产生的API没有工作得很好，所以发生我写了IndexedDB Package 器，再次使用闭包库。
用promise Package 所有东西的问题是不容易使用的，你需要跟踪活动的事务。正如你所看到的，你将有三个级别的数据库查询的承诺，1）数据库打开承诺2）事务承诺3）请求承诺。
您可以通过在global上始终将db作为应用程序的引用来消除第一个承诺，但最后两个承诺仍然存在。
所以主要是，我把这三个承诺合并成一个关于我的图书馆的承诺。