Node.js Callbacks in Synchronous Functions: Passing Functions as Arguments in Sequence (Nested One Inside The Other)... And Avoid Callback Hells - callback

Question

I didn't find many references to this specific question, so that's why I'm posting it even when it is pretty basic.
When we have to handle packages that require us to use callbacks in synchronous functions, I understand that it might be due to processes that will take long internal execution times; that is, there is no delay in the process depending on another machine, but ours. (is it right?)
So if we have a Node.js script which has, say three functions two of them with an internal latency:
File: index.js
function one() {
setTimeout(()=>{
console.log('menssage one');
},1000)
}
function two() {
setTimeout(()=>{
console.log('menssage two');
},700)
}
function three() {
console.log('menssage three');
}
one();
two();
three();
The expected output of $ node index is:
menssage three
menssage two
menssage one
But, what can we do if we want an ordered execution?
In order to solve it I tried indicating a callback as parameter of at least the functions one and two:
File: index2.js
function one(anotherFuncion) {
setTimeout(()=>{
console.log('message one');
anotherFuncion();
},1000)
}
function two(anotherFuncion) {
setTimeout(()=>{
console.log('message two');
anotherFuncion();
},700)
}
function three() {
console.log('message three');
}
// execution line here
However, index2 will only work if we indicate in the execution line something like:
two(three) or one(three) but never if we put something like: one(two(three))
What is the syntax to call in sequence these three function with callbacks nested one inside the other?

Answer 1

Now, I want to share one possible solution to the former question. It all depends on the arguments passed along with the callback. (Hope the community will share here more options).
The syntax that is key to this solution is the three dots: ... indicating an array of parameters of any length.
A first approach is this:
function one(aCallBack, ...args) {
setTimeout(()=>{
console.log('first message');
aCallBack(...args);
},1000)
}
function two(aCallBack, ...args) {
setTimeout(()=>{
console.log('second message');
aCallBack(...args);
},700)
}
function three() {
console.log('third message');
}
one(two, three);
The former script will return:
first message
second message
third message
Which is the desired output; however, a more general solution will allow us to set a "message" parameter. This way we can repeat the use of our own functions, called one inside another multiple times, cleanly (avoiding any callback hell):
function one(msg, aCallBack, ...args) {
setTimeout(()=>{
console.log(msg);
aCallBack(...args);
},1000)
}
function two(msg, aCallBack, ...args) {
setTimeout(()=>{
console.log(msg);
aCallBack(...args);
},700)
}
function three(msg) {
console.log(msg);
}
one('first message', two, 'second message', one, 'third message', one, 'fourth message', two, 'fifth message', three, 'sixth message');