I’ve noticed in a promise chain that if I don’t make a final call to catch() or then() that returns a promise resolved with undefined (implicit or otherwise), it will leave a promise unresolved. This seems like a memory leak risk, so I’d like to ask if it’s always necessary to use one of the aforementioned ways of finishing up a promise chain? Of course, it seems sensible to allows catch anything that goes wrong in the promise chain anyway.

See this example where p2 is left pending indefinitely:

let idCounter = 0;

function generateId() {
  return ++idCounter;
}

let p1;
let p2;
let p3;

function firstpromise() {
  p1 = new Promise((resolve, reject) => {
    setTimeout
      (
        () => {
          console.log("first promise completed");
          resolve("first promise resolved");
        }, 1000
      );
  });
  p1.id = generateId(); 
  return p1;
}

p2 = firstpromise().then((data) => {
  p3 = new Promise((resolve, reject) => {
    setTimeout
      (
        () => {
          console.log("second promise completed");
          resolve("second promise resolved");
          console.log(p1);
          console.log(p2);
          console.log(p3);
        }, 2000
      );
  });
  p3.id = generateId();
  console.log(p1);
  console.log(p2);
  console.log(p3);
  return p3;
});

p2.id = generateId();

console.log(p1);
console.log(p2);
console.log(p3);

Promise { <pending>, id: 1 }
Promise { <pending>, id: 2 }
undefined

first promise completed
Promise { 'first promise resolved', id: 1 }
Promise { <pending>, id: 2 }
Promise { <pending>, id: 3 }

second promise completed
Promise { 'first promise resolved', id: 1 }
Promise { <pending>, id: 2 }
Promise { 'second promise resolved', id: 3 }