This fork uses babel to transpile the code to ES5.
It's zero dependency and lightweight function that allows execute array of functions and promises in sequence and returns Promise
Behavior very similar to Promise.all
.
It's executes promises with functions one by one and returns promise with array of results
this code
promise1.then(() => promise2.then(() => promise3.then(callback))).then(done);
equivalent to
const sequence = require('sequence-as-promise');
sequence([promise1, promise2, promise3, callback]).then(done);
with npm
npm i --save sequence-as-promise
with yarn
yarn add sequence-as-promise
We have array of functions with promises, and we need to execute all that functions in sequence
All functions in sequence accepts two arguments, (prevResult, results) => {}
-
prevResult
the result of previous function or promise call -
results
an array of results from previous functions or promises calls
const sequence = require('sequence-as-promise');
sequence([
Promise.resolve({status: true}),
(prevResult/*{status: true}*/, results) => {
return {moveCircleToMiddle: true};
},
(prevResult/*{moveCircleToMiddle: true}*/, results) => {
return {showGrayCircle: true};
},
(prevResult/*{showGrayCircle: true}*/, results) => {
return {showMicrophone: true};
}
]).then((results) => console.log('all done', results))
Most standard use case is a fetch dependant data one by one
const sequence = require('sequence-as-promise');
sequence([
fetchUser(32),
(user) => {
if (user && user.id === 1) {
return fetchAdminUrls(user.id);
}
return fetchUserUrls(user.id);
},
(urls) => {//previous fetch resolved and passed as argument
return urls.map(makeLink)
}
]).then((results) => {
const [user, _, links] = results;
renderHTML(user, links);
});
Any function or promise in sequence can throw an error, so we need to handle it
const sequence = require('sequence-as-promise');
sequence([
fetchUser(32),
(user) => {
if (user && user.id === 1) {
return fetchAdminUrls(user.id); //for instance this fetch throws server error
}
return fetchUserUrls(user.id);
},
(urls) => { //this will not be executed, because previous promise thorws error
return urls.map(makeLink);
}
]).then(
(results) => {
const [user, _, links] = results;
renderHTML(user, links);
},
(results) => {
const error = results.pop(); //last item in results always be an error
renderError(error);
}
);
But, if we need to call all that functions with primitive values between them (why not?).
const sequence = require('sequence-as-promise');
sequence([
() => {
return {moveCircleToMiddle: true};
},
100,
(prevResult/*100*/, results) => {
return {showGrayCircle: prevResult};
},
(prevResult/*{showGrayCircle: 100}*/, results) => {
return {showMicrophone: true};
},
500,
(prev, values) => { // prev == 500
return {moveCircleToTop: true};
}
]).then((results) => console.log('all done', results))
Or we have Promises in that array of functions.
const sequence = require('sequence-as-promise');
sequence([
() => new Promise((resolve, reject) => {
resolve({moveCircleToMiddle: true});
}),
() => {
return {showGrayCircle: true};
}
]).then(() => console.log('all done'))