javascript - CosmosDB gemte procedurer - promise i stedet for callback

Er det muligt at bruge JavaScript-promises i stedet for almindelige callbacks i CosmosDB (DocumentDB) stored procedure API-kald? En anvendelse ville være at implementere pagination.

For eksempel

token = getToken();
doSomething(token);    

//....
function getToken(....) {   

  //...
  collection.queryDocuments(link, query, queryOptions, function(error, documents, responseOptions) {
    return responseOptions.continuation;
  });
}

ville ikke fungere, fordi tokenet returneres inden for en callback, og udførslen fortsætter. Kan du venligst give et eksempel på, hvordan du ville implementere dette?

Svar #1

Den version af ECMAScript, der refereres til i Cosmos DB-dokumentationen, understøtter async/await og Promises. Jeg er i stand til at bruge begge dele i mine lagrede procedurer.

Her er en funktion, der returnerer et løfte, som udfører en parameterstyret dokumentforespørgsel:

function queryDocumentsAsync(sql, parameters, options) {
    const querySpec = {
        query: sql,
        parameters: parameters
    };

    return new Promise((resolve, reject)=>{
        let isAccepted = __.queryDocuments(__.getSelfLink(), querySpec, options || {}, (err, feed, options) => {
            if(err) reject(err);
            resolve({
                feed: feed,
                options: options
            });
        });
        if(!isAccepted) throw "Query was not accepted.";
    });
}

Jeg ser dog nogle begrænsninger ved at tvinge en rollback med denne tilgang. Hvis du kaster en fejl, bliver den opslugt af promise-kæden og kommer aldrig ud.

Svar #2

Her er et eksempel på, hvordan man bruger async await til forespørgsels- og erstattelsesscenarier.

function async_sample() {
    const ERROR_CODE = {
        NotAccepted: 429
    };

    const asyncHelper = {
        queryDocuments(sqlQuery, options) {
            return new Promise((resolve, reject) => {
                const isAccepted = __.queryDocuments(__.getSelfLink(), sqlQuery, options, (err, feed, options) => {
                    if (err) reject(err);
                    resolve({ feed, options });
                });
                if (!isAccepted) reject(new Error(ERROR_CODE.NotAccepted, "replaceDocument was not accepted."));
            });
        },

        replaceDocument(doc) {
            return new Promise((resolve, reject) => {
                const isAccepted = __.replaceDocument(doc._self, doc, (err, result, options) => {
                    if (err) reject(err);
                    resolve({ result, options });
                });
                if (!isAccepted) reject(new Error(ERROR_CODE.NotAccepted, "replaceDocument was not accepted."));
            });
        }
    };

    async function main() {
        let continuation;
        do {
            let { feed, options } = await asyncHelper.queryDocuments("SELECT * from c", { continuation });

            for (let doc of feed) {
                doc.newProp = 1;
                await asyncHelper.replaceDocument(doc);
            }

            continuation = options.continuation;
        } while (continuation);
    }

    main().catch(err => getContext().abort(err));
}