Can you return a Promise with a predefined finally?

Question

I have a function that returns a Promise. When I am done using that Promise in the .then() or .catch() blocks, I always want to execute the same cleanup code. My current setup is this:

const promiseWithFinally = () => {
  return new Promise((resolve, reject) => {
    // resolve or reject at some point
  }).finally(() => console.log('finally done'))
}

promiseWithFinally()
  .then(() => console.log('then done'))
  .catch(() => console.log('catch done'))

What I want to happen is that either then done or catch done get logged first and then finally done. However it seems to get executed in the exact opposite order - when I resolve the Promise after a timeout of 5 seconds finally done gets logged first after 5 seconds and then then done immediately afterwards.

What am I doing wrong or is it possible to do this in general? I know I could just append the .finally() to each individual function call, but since it's always the same I'd like to put it in the function definition.

Generally speaking you shouldn't rely on handlers of the same promise to be called in any particular order. Even if you attach `finally` and `then` to the same promise, they would be called in the order you define them, I think. — Niet the Dark Absol, May 18 '21 at 11:34
Why are you expecting promise finally to be have this way? Would you expect synchronous finally to do this? — Benjamin Gruenbaum, May 18 '21 at 13:17
You're probably looking for the [promise disposer pattern](https://stackoverflow.com/q/28915677/1048572). — Bergi, May 23 '21 at 20:26

score 1 · Answer 1 · answered May 18 '21 at 11:54

1

No it's not possible. Finally is for cleaning up after a given promise, not for its then or catch methods.

What you can do is pass then and catch methods to the function which will be appended before finally:

const promiseWithFinally = (chain) => {
  return new Promise((resolve, reject) => {
    // resolve or reject at some point
    setTimeout(resolve, 1000);
  }).then(chain.then, chain.catch).finally(() => console.log('finally done'))
}

promiseWithFinally({
  then: () => console.log('then done'),
  catch: () => console.log('catch done')
})

answered May 18 '21 at 11:54

marzelin

10,790
2
30
49

basically it is the same as my answer. – Hannes Schneidermayer May 18 '21 at 11:55
I think this answer is as flawed as the previous one because it leaves me wondering whether you want a promise at all. This depends on some details the OP doesn't provide. – Wilco Bakker May 18 '21 at 12:01
I think a good consensus is that you can't really rely on finally though. – Wilco Bakker May 18 '21 at 12:02
it's probably xy problem. I don't see any practical reason to chain promises like this. – marzelin May 18 '21 at 12:11

score 1 · Answer 2 · edited May 23 '21 at 20:15

Short answer

No it is not possible as you cannot rely on when finally is being ran.

Longer answer and possible solution

Code

const cleanupFunc = () => {
  console.log('Cleaning up.');
  };

const someAsyncMethod = (thenFunc, catchFunc) => {
  new Promise(
    (resolve, reject) => {
      setTimeout(() => resolve(), 5000);
    },
  )
    .then((...args) => {
      try {
        thenFunc(...args);
      } catch (err) {
      }
      cleanupFunc();
    })
    .catch((...args) => {
      try {
        catchFunc(...args);
      } catch (err) {
      }
      cleanupFunc();
    });
};

someAsyncMethod((result) => console.log('Then done'), (err) => console.log('Catch done'));

Explanation

Al though it is not possible to rely on finally, what you can do is write a function that needs to do some asynchronous operation returning a promise. In my example this operation is waiting on a 5 second timeout but his can also, for example, be an asynchronous api call that returns a promise.

The next step would be to add a then and a catch call to the promise the asynchronous operation returns that both begin with a try clause in which you call the callback parameter that belongs to the type of resolve (thenFunc for then, catchFunc for catch) followed by a catch which doesn't do anything and ends by calling the cleanup function. in this way you are certain that whatever happens during running the then or catch callback, the cleanup function is being called.

score 0 · Answer 3 · answered May 27 '21 at 20:59

Assuming you know the rest of the handlers to that promise are going to be attached synchronously, and all actions in the handler are synchronous, it is possible, albeit a little bit hacky.

Simply have the finally handler re-attach itself at the end:

const promiseWithFinally = () => {
  const thisPromise = new Promise((resolve, reject) => {
    // Rejection example
    setTimeout(reject, 200);
  }).finally(() => {
    setTimeout(() => {
      thisPromise.finally(() => console.log('finally done')).catch(() => {});
    }, 0);
  });
  return thisPromise;
};

promiseWithFinally()
  .then(() => console.log('then done'))
  .catch(() => console.log('catch done'));

Can you return a Promise with a predefined finally?

3 Answers3

Short answer

Longer answer and possible solution

Code

Explanation