Цепочки обещаний и анонимные возвраты обещаний

Похоже, вам просто интересно, как вручную разрешить / отклонить обещание. Если это так, вы можете просто вызвать Promise.resolve(optionalValue) или Promise.reject(optionalValue), если хотите перейти к обработчику catch:

function callDBDestroy() {
   var db;

   DB_Categories.destroy()
   .then(function () {
      if( DB_Equipment != null) {
          return DB_Equipment.destroy();
      } else {
          return Promise.resolve();
      }
   }).then(function () {
      return DB_Certificates.destroy();
   }).then(function () {
      return DB_Locations.destroy();
   }).catch(function (err) {
      showMsg("Error in callDBDestroy: " + err);
   });
}

Вы можете обернуть это:

function withDb(db, handler) {
    return function onFulfilled(value) {
       if(db === null) throw new Error("DB Null");
       return handler(value);
    });
}

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

function callDBDestroy() {
   var db;
   var w = withDb(db); // or whatever instance

   DB_Categories.destroy().then(w(function () {
       // do stuff

    }))); // .then(w( to chain calls here.
    ...
}

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

new Promise().resolve();

Вы ищете Promise.resolve(undefined). Хотя вы можете опустить undefined, это неявно.

….then(function () {
    if (DB_Equipment != null) {
        return DB_Equipment.destroy();
    } else {
        return Promise.resolve(undefined);
    }
}).…

И вам даже не нужно возвращать обещание из обратного вызова then, простой возврат undefined (или не returning) будет иметь тот же эффект.

….then(function () {
    if (DB_Equipment != null) {
        return DB_Equipment.destroy();
    }
}).…

В вашем случае я бы порекомендовал функцию-оболочку:

function destroyDatabase(db, name = "db") {
    if (db != null)
        return db.destroy().catch(err => {
            showMsg(`Error in destroying ${name}: ${err}`);
        });
    else
        return Promise.resolve();
}
function callDBDestroy() {
    return destroyDatabase(DB_Categories, "categories")
    .then(() => destroyDatabase(DB_Certificates, "certificates"))
    .then(() => destroyDatabase(DB_Locations, "locations"))
}
// or even in parallel:
function callDBDestroy() {
    return Promise.all([
        destroyDatabase(DB_Categories, "categories"),
        destroyDatabase(DB_Certificates, "certificates"),
        destroyDatabase(DB_Locations, "locations")
    ]);
}

Как насчет использования массива, поскольку вы выполняете ту же задачу, но изменяется только БД:

//serial
function callDBDestroy() {
    var databases = [
        DB_Categories,
        DB_Equipment,
        DB_Certificates,
        DB_Locations
    ];

    function errorMessage(err){ showMsg("Error in callDBDestroy: " + err) };

    databases.reduce(
        (prev, db) => db == null? 
            prev: 
            prev.then(() => db.destroy().catch(errorMessage)), 
        Promise.resolve()
    )
}

//parallel
function callDBDestroy() {
    var databases = [
        DB_Categories,
        DB_Equipment,
        DB_Certificates,
        DB_Locations
    ];

    function errorMessage(err){ showMsg("Error in callDBDestroy: " + err) };

    databases.forEach( db => db && db.destroy().catch(errorMessage) );
}

Я добавил серийную и параллельную версию.

Кажется, вы можете DRY это устранить и заменить много избыточного кода, используя массив баз данных, а затем просто прокрутите массив:

function callDbDestroy();
    var dbs = [DB_Categories, DB_Equipment, DB_Certificates, DB_Locations];

    // chain all the destroys together
    return dbs.reduce((p, db) => {
        return p.then(() => {
            if (db) {
                return db.destroy().catch(err => {
                    showMsg("Error in callDBDestroy: " + err);
                });
            }
        });

    }, Promise.resolve());
}

Вам не нужно возвращать обещание от обработчика .then(). Если у вас просто нет возвращаемого значения, это похоже на выполнение return undefined, что означает, что никакое значение не будет передано следующему обработчику .then(), но цепочка обещаний продолжится нормально. По идее, он работает так же, как return Promise.resolve(), но не нужно делать дополнительных обещаний.

Поскольку вы не передаете значение от одного .then() к следующему в цепочке, вам нечего передавать, поэтому вы можете просто не возвращать ничего, если нет значения db для вызова уничтожения.

К вашему сведению, использование .reduce() для цикла по массиву со структурой return p.then(...) является распространенным шаблоном проектирования для последовательности асинхронных операций с массивом.

К вашему сведению, используя библиотеку обещаний Bluebird (в которой есть несколько полезных помощников), это можно сделать следующим образом:

function callDbDestroy();
    var dbs = [DB_Categories, DB_Equipment, DB_Certificates, DB_Locations];

    return Promise.mapSeries(dbs, db => {
        if (db) {
            return db.destroy().catch(err => {
                showMsg("Error in callDBDestroy: " + err);
            });
        }
    });
}

Для получения дополнительной информации о том, почему Bluebird (или другие библиотеки обещаний) по-прежнему полезны даже с ES6, см. Есть ли еще причины использовать библиотеки обещаний, такие как Q или BlueBird, теперь, когда у нас есть обещания ES6?

Поскольку кажется, что все эти базы данных могут быть независимыми, мне интересно, почему вы заставляете их выполнять последовательно. Если их не нужно вводить в последовательность, вы можете сделать это:

function callDbDestroy();
    var dbs = [DB_Categories, DB_Equipment, DB_Certificates, DB_Locations];

    return Promise.all(dbs.map(db => {
        if (db) {
            return db.destroy().catch(err => {
                showMsg("Error in callDBDestroy: " + err);
            });
        }
    }));
}

Поскольку при этом выполняются операции параллельно, у него есть возможность сократить время сквозного выполнения по сравнению со строгой сериализацией.