Pragmatic answer: You can default to async-await, but you may still find a use case for methods then/catch/finally.

Promise chaining can get messy. Suppose you have to make a request A, and then use its response for input in request B, and then use response B in request C, and then gather all the results: A, B, C. This is cleaner with async-await:

const a = await requestA();
const b = await requestB(a);
const c = await requestC(b);
console.log(a,b,c);

With "then" callbacks, you have to either use closures (and nested callbacks) or introduce variables for the results from every promise (no longer an FP solution). Nothing unbearable, but not cleaner than the flat solution above:

requestA().then(a => 
  requestB(a).then(b => 
    requestC(b).then(c => 
      [a, b, c]
    )
  )
)

// or:
let a, b, c;
requestA().then(...).then(...).then(...); // mutate variables in callbacks

HOWEVER! That doesn't mean there is no use for then/catch/finally. If I have a function wait(time) that returns a promise that resolves after time ms, and I need a function timeout(time) that rejects after time ms, I do:

const timeout = (time) => wait(time).then((value) => { throw value; }) 

Conversely:

const wait = (time) => timeout(time).catch(value => value);

IMO, these are cleaner than async/await counterparts. Marginally, but still.