Manipulation de prises multiples dans la chaîne promise

.catch fonctionne comme l'instruction try-catch, ce qui signifie que vous n'avez besoin que d'une prise à la fin:

repository.Query(getAccountByIdQuery)
        .then(convertDocumentToModel)
        .then(verifyOldPassword)
        .then(changePassword)
        .then(function(){
            res.status(200).send();
        })
        .catch(function(error) {
            if (/*see if error is not found error*/) {
                res.status(404).send({ error: "No account found with this Id" });
            } else if (/*see if error is verification error*/) {
                res.status(406).send({ OldPassword: error });
            } else {
                console.log(error);
                res.status(500).send({ error: "Unable to change password" });
            }
        });

Je me demande s'il y a un moyen pour moi de forcer la chaîne à s'arrêter à un certain point en fonction des erreurs

Non. Vous ne pouvez pas vraiment "mettre fin" à une chaîne, sauf si vous lancez une exception qui fait des bulles jusqu'à sa fin. Voir la réponse de Benjamin Gruenbaum pour savoir comment faire cela.

Une dérivation de son modèle ne serait pas de distinguer les types d'erreur, mais d'utiliser des erreurs qui ont des champs statusCode et body qui peuvent être envoyés à partir d'un seul gestionnaire .catch Générique. Selon la structure de votre application, sa solution pourrait être plus propre.

Ou s'il existe un meilleur moyen de structurer cela pour obtenir une forme de comportement de branchement

Oui, vous pouvez faire branchement avec des promesses . Cependant, cela signifie quitter la chaîne et "revenir" à l'imbrication - comme vous le feriez dans une instruction imbriquée if-else ou try-catch:

repository.Query(getAccountByIdQuery)
.then(function(account) {
    return convertDocumentToModel(account)
    .then(verifyOldPassword)
    .then(function(verification) {
        return changePassword(verification)
        .then(function() {
            res.status(200).send();
        })
    }, function(verificationError) {
        res.status(406).send({ OldPassword: error });
    })
}, function(accountError){
    res.status(404).send({ error: "No account found with this Id" });
})
.catch(function(error){
    console.log(error);
    res.status(500).send({ error: "Unable to change password" });
});

J'ai fait de cette façon:

Vous laissez votre prise à la fin. Et il suffit de lancer une erreur quand cela arrive à mi-chemin de votre chaîne.

    repository.Query(getAccountByIdQuery)
    .then((resultOfQuery) => convertDocumentToModel(resultOfQuery)) //inside convertDocumentToModel() you check for empty and then throw new Error('no_account')
    .then((model) => verifyOldPassword(model)) //inside convertDocumentToModel() you check for empty and then throw new Error('no_account')        
    .then(changePassword)
    .then(function(){
        res.status(200).send();
    })
    .catch((error) => {
    if (error.name === 'no_account'){
        res.status(404).send({ error: "No account found with this Id" });

    } else  if (error.name === 'wrong_old_password'){
        res.status(406).send({ OldPassword: error });

    } else {
         res.status(500).send({ error: "Unable to change password" });

    }
});

Vos autres fonctions ressembleraient probablement à ceci:

function convertDocumentToModel(resultOfQuery) {
    if (!resultOfQuery){
        throw new Error('no_account');
    } else {
    return new Promise(function(resolve) {
        //do stuff then resolve
        resolve(model);
    }                       
}

Au Lieu de .then().catch()... vous pouvez faire .then(resolveFunc, rejectFunc). Cette chaîne de promesses serait mieux si vous manipuliez les choses en cours de route. Voici comment je le réécrirais:

repository.Query(getAccountByIdQuery)
    .then(
        convertDocumentToModel,
        () => {
            res.status(404).send({ error: "No account found with this Id" });
            return Promise.reject(null)
        }
    )
    .then(
        verifyOldPassword,
        () => Promise.reject(null)
    )
    .then(
        changePassword,
        (error) => {
            if (error != null) {
                res.status(406).send({ OldPassword: error });
            }
            return Promise.Promise.reject(null);
        }
    )
    .then(
        _ => res.status(200).send(),
        error => {
            if (error != null) {
                console.error(error);
                res.status(500).send({ error: "Unable to change password" });
            }
        }
    );

Remarque: Le if (error != null), c'est un peu un hack pour interagir avec l'erreur la plus récente.