feat: add Then method with onRejected handler to Promise class

Author: miguelmarcondesf

napi-inl.h

@@ -2835,6 +2835,28 @@ inline MaybeOrValue<Promise> Promise::Then(napi_value onFulfilled) const {
 #endif
 }
 
+inline MaybeOrValue<Promise> Promise::Then(napi_value onFulfilled, napi_value onRejected) const {
+  EscapableHandleScope scope(_env);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  MaybeOrValue<Value> thenMethodMaybe = Get("then");
+  Function thenMethod = thenMethodMaybe.Unwrap().As<Function>();
+#else
+  Function thenMethod = Get("then").As<Function>();
+#endif
+  MaybeOrValue<Value> result = thenMethod.Call(*this, {onFulfilled, onRejected});
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()).As<Promise>());
+  }
+  return Nothing<Promise>();
+#else
+  if (scope.Env().IsExceptionPending()) {
+    return Promise();
+  }
+  return scope.Escape(result).As<Promise>();
+#endif
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Buffer<T> class
 ////////////////////////////////////////////////////////////////////////////////

napi.h

@@ -1578,6 +1578,7 @@ class Promise : public Object {
   Promise(napi_env env, napi_value value);
 
   MaybeOrValue<Promise> Then(napi_value onFulfilled) const;
+  MaybeOrValue<Promise> Then(napi_value onFulfilled, napi_value onRejected) const;
 };
 
 template <typename T>

test/promise.cc

@@ -40,6 +40,40 @@ Value ThenMethodOnFulfilled(const CallbackInfo& info) {
   return result;
 }
 
+Value ThenMethodOnFulfilledOnRejectedResolve(const CallbackInfo& info) {
+  auto deferred = Promise::Deferred::New(info.Env());
+  Function onFulfilled = info[0].As<Function>();
+  Function onRejected = info[1].As<Function>();
+
+  Promise resultPromise = MaybeUnwrap(deferred.Promise().Then(onFulfilled, onRejected));
+
+  bool isPromise = resultPromise.IsPromise();
+  deferred.Resolve(Number::New(info.Env(), 42));
+
+  Object result = Object::New(info.Env());
+  result["isPromise"] = Boolean::New(info.Env(), isPromise);
+  result["promise"] = resultPromise;
+
+  return result;
+}
+
+Value ThenMethodOnFulfilledOnRejectedReject(const CallbackInfo& info) {
+  auto deferred = Promise::Deferred::New(info.Env());
+  Function onFulfilled = info[0].As<Function>();
+  Function onRejected = info[1].As<Function>();
+
+  Promise resultPromise = MaybeUnwrap(deferred.Promise().Then(onFulfilled, onRejected));
+
+  bool isPromise = resultPromise.IsPromise();
+  deferred.Reject(String::New(info.Env(), "Rejected"));
+
+  Object result = Object::New(info.Env());
+  result["isPromise"] = Boolean::New(info.Env(), isPromise);
+  result["promise"] = resultPromise;
+
+  return result;
+}
+
 Object InitPromise(Env env) {
   Object exports = Object::New(env);
 
@@ -48,7 +82,11 @@ Object InitPromise(Env env) {
   exports["rejectPromise"] = Function::New(env, RejectPromise);
   exports["promiseReturnsCorrectEnv"] =
       Function::New(env, PromiseReturnsCorrectEnv);
-  exports["ThenMethodOnFulfilled"] = Function::New(env, ThenMethodOnFulfilled);
+  exports["thenMethodOnFulfilled"] = Function::New(env, ThenMethodOnFulfilled);
+  exports["thenMethodOnFulfilledOnRejectedResolve"] =
+      Function::New(env, ThenMethodOnFulfilledOnRejectedResolve);
+  exports["thenMethodOnFulfilledOnRejectedReject"] =
+      Function::New(env, ThenMethodOnFulfilledOnRejectedReject);
 
   return exports;
 }

test/promise.js

@@ -19,8 +19,20 @@ async function test (binding) {
   assert(binding.promise.promiseReturnsCorrectEnv());
 
   const onFulfilled = (value) => value * 2;
-  const result = binding.promise.thenMethodOnFulfilled(onFulfilled);
-  assert.strictEqual(result.isPromise, true);
-  const finalValue = await result.promise;
-  assert.strictEqual(finalValue, 84);
+  const onRejected = (reason) => reason + '!';
+
+  const thenOnFulfilled = binding.promise.thenMethodOnFulfilled(onFulfilled);
+  assert.strictEqual(thenOnFulfilled.isPromise, true);
+  const onFulfilledValue = await thenOnFulfilled.promise;
+  assert.strictEqual(onFulfilledValue, 84);
+
+  const thenResolve = binding.promise.thenMethodOnFulfilledOnRejectedResolve(onFulfilled, onRejected);
+  assert.strictEqual(thenResolve.isPromise, true);
+  const thenResolveValue = await thenResolve.promise;
+  assert.strictEqual(thenResolveValue, 84);
+
+  const thenRejected = binding.promise.thenMethodOnFulfilledOnRejectedReject(onFulfilled, onRejected);
+  assert.strictEqual(thenRejected.isPromise, true);
+  const rejectedValue = await thenRejected.promise;
+  assert.strictEqual(rejectedValue, 'Rejected!');
 }