fix: refactor C++ JSI promise

Author: JakubGonera

common/rnexecutorch/host_objects/ModelHostObject.h

@@ -1,26 +1,30 @@
+#pragma once
+
 #include <cstdio>
 #include <string>
 #include <tuple>
 #include <vector>
 
+#include <ReactCommon/CallInvoker.h>
+
 #include <rnexecutorch/Log.h>
 #include <rnexecutorch/host_objects/JsiConversions.h>
 #include <rnexecutorch/jsi/JsiHostObject.h>
-#include <rnexecutorch/jsi/JsiPromise.h>
+#include <rnexecutorch/jsi/Promise.h>
 
 namespace rnexecutorch {
 
 template <typename Model> class ModelHostObject : public JsiHostObject {
 public:
-  explicit ModelHostObject(
-      const std::shared_ptr<Model> &model, jsi::Runtime *runtime,
-      const std::shared_ptr<react::CallInvoker> &callInvoker)
-      : model(model), promiseVendor(runtime, callInvoker) {
-    addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject, forward));
+  explicit ModelHostObject(const std::shared_ptr<Model> &model,
+                           std::shared_ptr<react::CallInvoker> callInvoker)
+      : model(model), callInvoker(callInvoker) {
+    addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>, forward));
   }
 
   JSI_HOST_FUNCTION(forward) {
-    auto promise = promiseVendor.createPromise(
+    auto promise = Promise::createPromise(
+        runtime, callInvoker,
         [this, count, args, &runtime](std::shared_ptr<Promise> promise) {
           constexpr std::size_t forwardArgCount =
               jsiconversion::getArgumentCount(&Model::forward);
@@ -35,27 +39,29 @@ template <typename Model> class ModelHostObject : public JsiHostObject {
             return;
           }
 
-          // Do the asynchronous work
-          std::thread([this, promise = std::move(promise), args, &runtime]() {
+          // We need to dispatch a thread if we want the forward to be
+          // asynchronous
+          std::thread([args, &runtime, this, promise = std::move(promise)]() {
             try {
               auto argsConverted = jsiconversion::createArgsTupleFromJsi(
                   &Model::forward, args, runtime);
               auto result = std::apply(std::bind_front(&Model::forward, model),
                                        argsConverted);
 
-              promise->resolve([result =
-                                    std::move(result)](jsi::Runtime &runtime) {
-                return jsiconversion::getJsiValue(std::move(result), runtime);
-              });
+              promise->resolve(
+                  jsiconversion::getJsiValue(std::move(result), runtime));
             } catch (const std::runtime_error &e) {
-              // This catch should be merged with the next one
-              // (std::runtime_error inherits from std::exception) HOWEVER react
-              // native has broken RTTI which breaks proper exception type
-              // checking. Remove when the following change is present in our
-              // version:
+              // This catch should be merged with the next two
+              // (std::runtime_error and jsi::JSError inherits from
+              // std::exception) HOWEVER react native has broken RTTI which
+              // breaks proper exception type checking. Remove when the
+              // following change is present in our version:
               // https://github.com/facebook/react-native/commit/3132cc88dd46f95898a756456bebeeb6c248f20e
               promise->reject(e.what());
               return;
+            } catch (const jsi::JSError &e) {
+              promise->reject(e.what());
+              return;
             } catch (const std::exception &e) {
               promise->reject(e.what());
               return;
@@ -71,7 +77,7 @@ template <typename Model> class ModelHostObject : public JsiHostObject {
 
 private:
   std::shared_ptr<Model> model;
-  PromiseVendor promiseVendor;
+  std::shared_ptr<react::CallInvoker> callInvoker;
 };
 
 } // namespace rnexecutorch

common/rnexecutorch/jsi/JsiPromise.cpp

@@ -0,0 +1,29 @@
+#include "Promise.h"
+
+namespace rnexecutorch {
+
+Promise::Promise(jsi::Runtime &runtime,
+                 std::shared_ptr<react::CallInvoker> callInvoker,
+                 jsi::Value resolver, jsi::Value rejecter)
+    : runtime(runtime), callInvoker(callInvoker),
+      _resolver(std::move(resolver)), _rejecter(std::move(rejecter)) {}
+
+void Promise::resolve(jsi::Value &&result) {
+  // invokeAsync takes a std::function which is copyable so we need to wrap
+  // the jsi::Value which is not.
+  auto resultPtr = std::make_shared<jsi::Value>(std::move(result));
+  callInvoker->invokeAsync([resultPtr, this]() -> void {
+    _resolver.asObject(runtime).asFunction(runtime).call(runtime,
+                                                         std::move(*resultPtr));
+  });
+}
+
+void Promise::reject(std::string message) {
+  callInvoker->invokeAsync([message = std::move(message), this]() -> void {
+    jsi::JSError error(runtime, message);
+    _rejecter.asObject(runtime).asFunction(runtime).call(runtime,
+                                                         error.value());
+  });
+}
+
+} // namespace rnexecutorch

common/rnexecutorch/jsi/JsiPromise.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+
+namespace rnexecutorch {
+
+using namespace facebook;
+
+class Promise;
+
+template <typename T>
+concept PromiseRunFn =
+    std::invocable<T, std::shared_ptr<Promise>> &&
+    std::same_as<std::invoke_result_t<T, std::shared_ptr<Promise>>, void>;
+
+class Promise {
+public:
+  Promise(jsi::Runtime &runtime,
+          std::shared_ptr<react::CallInvoker> callInvoker, jsi::Value resolver,
+          jsi::Value rejecter);
+
+  Promise(const Promise &) = delete;
+  Promise &operator=(const Promise &) = delete;
+
+  void resolve(jsi::Value &&result);
+  void reject(std::string error);
+
+  /**
+    Creates a new promise and runs the supplied "run" function that takes this
+    promise. We use a template for the function type to not use std::function
+    and be able to bind a lambda.
+  */
+  template <PromiseRunFn Fn>
+  static jsi::Value
+  createPromise(jsi::Runtime &runtime,
+                std::shared_ptr<react::CallInvoker> callInvoker, Fn &&run) {
+    // Get Promise ctor from global
+    auto promiseCtor =
+        runtime.global().getPropertyAsFunction(runtime, "Promise");
+
+    auto promiseCallback = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "PromiseCallback"), 2,
+        [run = std::move(run),
+         callInvoker](jsi::Runtime &runtime, const jsi::Value &thisValue,
+                      const jsi::Value *arguments, size_t count) -> jsi::Value {
+          // Call function
+          auto promise = std::make_shared<Promise>(
+              runtime, callInvoker, arguments[0].asObject(runtime),
+              arguments[1].asObject(runtime));
+          run(promise);
+
+          return jsi::Value::undefined();
+        });
+
+    return promiseCtor.callAsConstructor(runtime, promiseCallback);
+  }
+
+private:
+  jsi::Runtime &runtime;
+  std::shared_ptr<react::CallInvoker> callInvoker;
+  jsi::Value _resolver;
+  jsi::Value _rejecter;
+};
+
+} // namespace rnexecutorch