feat: implement Then onFulfilled for Promise

Author: miguelmarcondesf

napi-inl.h

@@ -2813,6 +2813,28 @@ inline void Promise::CheckCast(napi_env env, napi_value value) {
 
 inline Promise::Promise(napi_env env, napi_value value) : Object(env, value) {}
 
+inline MaybeOrValue<Promise> Promise::Then(napi_value onFulfilled) 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});
+#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

@@ -1574,7 +1574,10 @@ class Promise : public Object {
 
   static void CheckCast(napi_env env, napi_value value);
 
+  Promise();
   Promise(napi_env env, napi_value value);
+
+  MaybeOrValue<Promise> Then(napi_value onFulfilled) const;
 };
 
 template <typename T>

test/promise.cc

@@ -1,4 +1,5 @@
 #include "napi.h"
+#include "test_helper.h"
 
 using namespace Napi;
 
@@ -23,6 +24,22 @@ Value PromiseReturnsCorrectEnv(const CallbackInfo& info) {
   return Boolean::New(info.Env(), deferred.Env() == info.Env());
 }
 
+Value ThenMethodOnFulfilled(const CallbackInfo& info) {
+  auto deferred = Promise::Deferred::New(info.Env());
+  Function onFulfilled = info[0].As<Function>();
+
+  Promise resultPromise = MaybeUnwrap(deferred.Promise().Then(onFulfilled));
+
+  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;
+}
+
 Object InitPromise(Env env) {
   Object exports = Object::New(env);
 
@@ -31,6 +48,7 @@ Object InitPromise(Env env) {
   exports["rejectPromise"] = Function::New(env, RejectPromise);
   exports["promiseReturnsCorrectEnv"] =
       Function::New(env, PromiseReturnsCorrectEnv);
+  exports["ThenMethodOnFulfilled"] = Function::New(env, ThenMethodOnFulfilled);
 
   return exports;
 }

test/promise.js

@@ -17,4 +17,10 @@ async function test (binding) {
   rejecting.then(common.mustNotCall()).catch(common.mustCall());
 
   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);
 }