Synchronous code in then handler of Promise

Question

I need to execute some synchronous code after an asynchrnous Promise is resolved. Currently my code looks like this:

console.log("Starting");

promiseFunc().
then(function() {
  console.log("PromiseFunc done. Doing Synchronous work...");
  synchronousFunc1();
  synchronousFunc2();
  console.log("Synchronous work done");
}).
catch(function(err) {
  console.log("Error:" + err);
}).
then(function() {
  console.log("Done")
});

Everything is working fine: The first then is executed after promiseFunc is resolved and the final then is executed last. I think the spec expects me to return a new Promise or a value from the then, but there is nothing useful I can return.

Here are my questions:

1. Does this 'pattern' for executing synchronous code after a promise is resolved make sense? Is it okay to return undefined from the then block?
2. What happens if someone decides to implement synchronousFunc1 with a promise? This will break the order of execution. I think such a breaking change shouldn't be made. Instead another asynchronousFunc1 should be implemented. Am I right?
3. What about my catch/then implementation? The final then should be executed always. I think this will not work, if an exception is thrown in the catch handler. Are there alternatives? I know there is a finally handler in bluebird, but I want to use standard Promise features only.

Answer 1

Does this 'pattern' for executing synchronous code after a promise is resolved make sense?

Yes. That's what we all do.

Is it okay to return undefined from the then block?

Not really, every work should have a result (otherwise it would be pointless) and you should return that. But if your function is only executing side effects, then returning undefined is the result, so it's okay.

What happens if someone decides to implement synchronousFunc1 with a promise? This will break the order of execution.

Yes, that's a breaking change.

I think such a breaking change shouldn't be made. Instead another asynchronousFunc1 should be implemented. Am I right?

How breaking changes are handled depends on the policy of the library and its contracts with callers. It might be a major version update, it might be a new function, it might be anything; it should be announced properly of course. You'll have to change your code anyway.

If the name of the function suggests that it's synchronous, it shouldn't return a promise; the name should be changed with the implementation in that case.

What about my catch/then implementation? The final then should be executed always. I think this will not work, if an exception is thrown in the catch handler.

Correct. You'll have to make sure that the catch handler doesn't throw :-)

Are there alternatives? I know there is a finally handler in bluebird, but I want to use standard Promise features only.

If you are using bluebird, you should use finally. It'll likely become standardised anyway, and many other libs support it as well. If not, you can always shim it yourself. Its implementation is superior to yours, especially about return values and handling things like cancellation appropriately.