feat(tm-android): Reject Promise if Turbo Module method throws an Error

packages/react-native/Libraries/AppDelegate/RCTAppSetupUtils.mm

@@ -56,6 +56,16 @@ void RCTAppSetupPrepareApp(UIApplication *application, BOOL turboModuleEnabled)
   RCTEnableTurboModule(turboModuleEnabled);
 #endif
 
+#ifndef RCT_TRACE_PROMISE_REJECTION_ENABLED
+#if DEBUG
+#define RCT_TRACE_PROMISE_REJECTION_ENABLED 1
+#endif
+#endif
+
+#if RCT_TRACE_PROMISE_REJECTION_ENABLED
+  RCTEnableTraceTurboModulePromiseRejections(YES);
+#endif
+
 #if DEBUG
   // Disable idle timer in dev builds to avoid putting application in background and complicating
   // Metro reconnection logic. Users only need this when running the application using our CLI tooling.

packages/react-native/Libraries/AppDelegate/React-RCTAppDelegate.podspec

@@ -16,18 +16,22 @@ else
   source[:tag] = "v#{version}"
 end
 
+trace_promise_rejections_enabled = ENV["RCT_TRACE_PROMISE_REJECTION_ENABLED"] == "1"
+trace_promise_rejections_flag = (trace_promise_rejections_enabled ? " -DRCT_TRACE_PROMISE_REJECTION_ENABLED" : "")
+
 folly_flags = ' -DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1'
 folly_compiler_flags = folly_flags + ' ' + '-Wno-comma -Wno-shorten-64-to-32'
 
 is_new_arch_enabled = ENV["RCT_NEW_ARCH_ENABLED"] == "1"
+
 use_hermes =  ENV['USE_HERMES'] == nil || ENV['USE_HERMES'] == '1'
 use_frameworks = ENV['USE_FRAMEWORKS'] != nil
 
 new_arch_enabled_flag = (is_new_arch_enabled ? " -DRCT_NEW_ARCH_ENABLED" : "")
 is_fabric_enabled = is_new_arch_enabled || ENV["RCT_FABRIC_ENABLED"]
 fabric_flag = (is_fabric_enabled ? " -DRN_FABRIC_ENABLED" : "")
 hermes_flag = (use_hermes ? " -DUSE_HERMES" : "")
-other_cflags = "$(inherited)" + folly_flags + new_arch_enabled_flag + fabric_flag + hermes_flag
+other_cflags = "$(inherited)" + folly_flags + new_arch_enabled_flag + fabric_flag + hermes_flag + trace_promise_rejections_flag
 
 header_search_paths = [
   "$(PODS_TARGET_SRCROOT)/../../ReactCommon",

packages/react-native/React/Base/RCTBridge.h

@@ -64,6 +64,10 @@ RCT_EXTERN void RCTSetTurboModuleInteropBridgeProxyLogLevel(RCTBridgeProxyLoggin
 RCT_EXTERN BOOL RCTTurboModuleInteropForAllTurboModulesEnabled(void);
 RCT_EXTERN void RCTEnableTurboModuleInteropForAllTurboModules(BOOL enabled);
 
+// Trace Rejected Promises of Turbo Modules (store callers' js stack)
+RCT_EXTERN BOOL RCTTraceTurboModulePromiseRejections(void);
+RCT_EXTERN void RCTEnableTraceTurboModulePromiseRejections(BOOL enabled);
+
 typedef enum {
   kRCTGlobalScope,
   kRCTGlobalScopeUsingRetainJSCallback,

packages/react-native/React/Base/RCTBridge.mm

@@ -97,6 +97,40 @@ void RCTEnableTurboModule(BOOL enabled)
   turboModuleEnabled = enabled;
 }
 
+static BOOL turboModuleEagerInitEnabled = NO;
+BOOL RCTTurboModuleEagerInitEnabled(void)
+{
+  return turboModuleEagerInitEnabled;
+}
+
+static BOOL traceTurboModulePromiseRejections = NO;
+BOOL RCTTraceTurboModulePromiseRejections(void)
+{
+  return traceTurboModulePromiseRejections;
+}
+
+void RCTEnableTraceTurboModulePromiseRejections(BOOL enabled)
+{
+  traceTurboModulePromiseRejections = enabled;
+}
+
+void RCTEnableTurboModuleEagerInit(BOOL enabled)
+{
+  turboModuleEagerInitEnabled = enabled;
+}
+
+// Turn off TurboModule delegate locking
+static BOOL turboModuleManagerDelegateLockingDisabled = YES;
+BOOL RCTTurboModuleManagerDelegateLockingDisabled(void)
+{
+  return turboModuleManagerDelegateLockingDisabled;
+}
+
+void RCTDisableTurboModuleManagerDelegateLocking(BOOL disabled)
+{
+  turboModuleManagerDelegateLockingDisabled = disabled;
+}
+
 static BOOL turboModuleInteropEnabled = NO;
 BOOL RCTTurboModuleInteropEnabled(void)
 {

packages/react-native/React/Base/RCTUtils.m

@@ -489,7 +489,7 @@ BOOL RCTClassOverridesInstanceMethod(Class cls, SEL selector)
   NSArray<NSString *> *stackTrace = [NSThread callStackSymbols];
   NSMutableDictionary *userInfo;
   NSMutableDictionary<NSString *, id> *errorInfo = [NSMutableDictionary dictionaryWithObject:stackTrace
-                                                                                      forKey:@"nativeStackIOS"];
+                                                                                      forKey:@"stackSymbols"];
 
   if (error) {
     errorMessage = error.localizedDescription ?: @"Unknown error from a native module";

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/config/ReactFeatureFlags.java

@@ -160,4 +160,10 @@ public class ReactFeatureFlags {
 
   /** Clean yoga node when <Text /> does not change. */
   public static boolean enableCleanParagraphYogaNode = false;
+
+  /**
+   * Enables storing js caller stack when creating promise in native module.
+   * This is useful in case of Promise rejection and tracing the cause.
+   */
+  public static boolean traceTurboModulePromiseRejections = false;
 }

packages/react-native/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.cpp

@@ -57,16 +57,32 @@ JavaTurboModule::~JavaTurboModule() {
 
 namespace {
 
+constexpr static auto kReactFeatureFlagsJavaDescriptor = "com/facebook/react/config/ReactFeatureFlags";
+
+static bool getFeatureFlagBoolValue(const char *name) {
+    static const auto reactFeatureFlagsClass = facebook::jni::findClassStatic(kReactFeatureFlagsJavaDescriptor);
+    const auto field = reactFeatureFlagsClass->getStaticField<jboolean>(name);
+    return reactFeatureFlagsClass->getStaticFieldValue(field);
+}
+
+static bool isSavePromiseJSInvocationStackEnabled() {
+  static bool savePromiseJSInvocationStack = getFeatureFlagBoolValue("traceTurboModulePromiseRejections");
+  return savePromiseJSInvocationStack;
+}
+
 struct JNIArgs {
   JNIArgs(size_t count) : args_(count) {}
   std::vector<jvalue> args_;
   std::vector<jobject> globalRefs_;
 };
 
+using CallbackWrapperExecutor = std::function<void(const std::shared_ptr<CallbackWrapper>&, const std::vector<jsi::Value>&)>;
+
 jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
     jsi::Function &&function,
     jsi::Runtime &rt,
-    const std::shared_ptr<CallInvoker> &jsInvoker) {
+    const std::shared_ptr<CallInvoker> &jsInvoker,
+    CallbackWrapperExecutor&& callbackWrapperExecutor) {
   auto weakWrapper =
       CallbackWrapper::createWeak(std::move(function), rt, jsInvoker);
 
@@ -82,7 +98,8 @@ jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
   return JCxxCallbackImpl::newObjectCxxArgs(
       [weakWrapper = std::move(weakWrapper),
        callbackWrapperOwner = std::move(callbackWrapperOwner),
-       wrapperWasCalled = false](folly::dynamic responses) mutable {
+       wrapperWasCalled = false,
+       callbackWrapperExecutor = std::move(callbackWrapperExecutor)](folly::dynamic responses) mutable {
         if (wrapperWasCalled) {
           LOG(FATAL) << "callback arg cannot be called more than once";
         }
@@ -95,7 +112,8 @@ jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
         strongWrapper->jsInvoker().invokeAsync(
             [weakWrapper = std::move(weakWrapper),
              callbackWrapperOwner = std::move(callbackWrapperOwner),
-             responses = std::move(responses)]() {
+             responses = std::move(responses),
+             callbackWrapperExecutor = std::move(callbackWrapperExecutor)]() {
               auto strongWrapper2 = weakWrapper.lock();
               if (!strongWrapper2) {
                 return;
@@ -108,16 +126,88 @@ jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
                     jsi::valueFromDynamic(strongWrapper2->runtime(), val));
               }
 
-              strongWrapper2->callback().call(
-                  strongWrapper2->runtime(),
-                  (const jsi::Value *)args.data(),
-                  args.size());
+              callbackWrapperExecutor(strongWrapper2, args);
             });
 
         wrapperWasCalled = true;
       });
 }
 
+jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
+    jsi::Function &&function,
+    jsi::Runtime &rt,
+    const std::shared_ptr<CallInvoker> &jsInvoker) {
+  auto executor = [](
+          const std::shared_ptr<CallbackWrapper>& wrapper,
+          const std::vector<jsi::Value>& args) {
+      wrapper->callback().call(
+              wrapper->runtime(),
+              (const jsi::Value *)args.data(),
+              args.size());
+  };
+  return createJavaCallbackFromJSIFunction(std::move(function), rt, jsInvoker, std::move(executor));
+}
+
+jsi::Value createJSRuntimeError(jsi::Runtime &runtime, const std::string &message);
+
+jni::local_ref<JCxxCallbackImpl::JavaPart> createPromiseRejectJavaCallbackFromJSIFunction(
+    const std::weak_ptr<CallbackWrapper> &function,
+    jsi::Runtime &rt,
+    const std::shared_ptr<CallInvoker> &jsInvoker,
+    std::optional<std::string> jsInvocationStack) {
+  auto executor = [jsInvocationStack = std::move(jsInvocationStack)](
+          const std::shared_ptr<CallbackWrapper>& reject,
+          const std::vector<jsi::Value>& args) {
+      std::string message;
+      jsi::Runtime &rt2 = reject->runtime();
+      const jsi::Value* cause = args.data();
+      if (cause->isObject() && cause->asObject(rt2).getProperty(rt2, "message").isString()) {
+          message = cause->asObject(rt2).getProperty(rt2, "message").asString(rt2).utf8(rt2);
+      } else {
+          message = "<unknown>";
+      }
+
+      jsi::Value error = createJSRuntimeError(rt2, "Exception in HostFunction: " + message);
+      error.asObject(rt2).setProperty(rt2, "cause", *cause);
+      error.asObject(rt2).setProperty(rt2, "stack", *jsInvocationStack);
+      reject->callback().call(rt2, error);
+  };
+  return JCxxCallbackImpl::newObjectCxxArgs(
+          [function,
+                  wrapperWasCalled = false,
+                  executor = std::move(executor)](folly::dynamic responses) mutable {
+              if (wrapperWasCalled) {
+                  LOG(FATAL) << "callback arg cannot be called more than once";
+              }
+
+              auto strongWrapper = function.lock();
+              if (!strongWrapper) {
+                  return;
+              }
+
+              strongWrapper->jsInvoker().invokeAsync(
+                      [function,
+                              responses = std::move(responses),
+                              executor = std::move(executor)]() {
+                          auto strongWrapper2 = function.lock();
+                          if (!strongWrapper2) {
+                              return;
+                          }
+
+                          std::vector<jsi::Value> args;
+                          args.reserve(responses.size());
+                          for (const auto &val : responses) {
+                              args.emplace_back(
+                                      jsi::valueFromDynamic(strongWrapper2->runtime(), val));
+                          }
+
+                          executor(strongWrapper2, args);
+                      });
+
+              wrapperWasCalled = true;
+          });
+}
+
 // This is used for generating short exception strings.
 std::string stringifyJSIValue(const jsi::Value &v, jsi::Runtime *rt = nullptr) {
   if (v.isUndefined()) {
@@ -442,6 +532,35 @@ jsi::JSError convertThrowableToJSError(
   return {runtime, std::move(error)};
 }
 
+void rejectWithException(
+    std::weak_ptr<CallbackWrapper> &rejectWeak,
+    std::exception_ptr &exception,
+    std::optional<std::string> jsInvocationStack) {
+  auto reject = rejectWeak.lock();
+  if (reject) {
+    reject->jsInvoker().invokeAsync([
+      rejectWeak = std::move(rejectWeak),
+      jsInvocationStack = std::move(jsInvocationStack),
+      exception
+    ]() {
+      auto reject2 = rejectWeak.lock();
+      if (reject2) {
+        jsi::Runtime &runtime = reject2->runtime();
+        auto throwable = jni::getJavaExceptionForCppException(exception);
+        auto jsError = convertThrowableToJSError(runtime, throwable);
+        if (jsInvocationStack.has_value()) {
+          jsError.value().asObject(runtime).setProperty(runtime, "stack", *jsInvocationStack);
+        }
+        reject2->callback().call(
+          runtime,
+          jsError.value());
+      }
+    });
+  } else {
+    throw;
+  }
+}
+
 } // namespace
 
 jsi::Value JavaTurboModule::invokeJavaMethod(
@@ -801,18 +920,30 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
               throw std::invalid_argument("Promise fn arg count must be 2");
             }
 
+            // JS Stack at the time when the promise is created.
+            std::optional<std::string> jsInvocationStack;
+            if (isSavePromiseJSInvocationStackEnabled()) {
+                jsInvocationStack = createJSRuntimeError(runtime, "")
+                  .asObject(runtime)
+                  .getProperty(runtime, "stack")
+                  .asString(runtime)
+                  .utf8(runtime);
+            }
+
             jsi::Function resolveJSIFn =
                 promiseConstructorArgs[0].getObject(runtime).getFunction(
                     runtime);
             jsi::Function rejectJSIFn =
                 promiseConstructorArgs[1].getObject(runtime).getFunction(
                     runtime);
+            auto rejectJSIFunctionWeakWrapper =
+                CallbackWrapper::createWeak(std::move(rejectJSIFn), runtime, jsInvoker_);
 
             auto resolve = createJavaCallbackFromJSIFunction(
-                               std::move(resolveJSIFn), runtime, jsInvoker_)
-                               .release();
-            auto reject = createJavaCallbackFromJSIFunction(
-                              std::move(rejectJSIFn), runtime, jsInvoker_)
+                                std::move(resolveJSIFn), runtime, jsInvoker_)
+                                .release();
+            auto reject = createPromiseRejectJavaCallbackFromJSIFunction(
+                              rejectJSIFunctionWeakWrapper, runtime, jsInvoker_, jsInvocationStack)
                               .release();
 
             jclass jPromiseImpl =
@@ -840,6 +971,8 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
             nativeMethodCallInvoker_->invokeAsync(
                 methodName,
                 [jargs,
+                 rejectJSIFunctionWeakWrapper,
+                 jsInvocationStack = std::move(jsInvocationStack),
                  globalRefs,
                  methodID,
                  instance_ = jni::make_weak(instance_),
@@ -868,7 +1001,8 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
                   } catch (...) {
                     TMPL::asyncMethodCallExecutionFail(
                         moduleName, methodName, id);
-                    throw;
+                      auto exception = std::current_exception();
+                    rejectWithException(rejectJSIFunctionWeakWrapper, exception, jsInvocationStack);
                   }
 
                   for (auto globalRef : globalRefs) {

packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.h

@@ -23,6 +23,12 @@
   ((RCTTurboModuleEnabled() && [(klass) conformsToProtocol:@protocol(RCTTurboModule)]))
 #define RCT_IS_TURBO_MODULE_INSTANCE(module) RCT_IS_TURBO_MODULE_CLASS([(module) class])
 
+/**
+ * Block used to reject the JS promise waiting for a result
+ * in cases when the native method throws an exception.
+ */
+typedef void (^RCTNSDictionaryPromiseRejectBlock)(NSDictionary *exception);
+
 namespace facebook::react {
 
 class CallbackWrapper;
@@ -137,9 +143,10 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
       bool isSync,
       const char *methodName,
       NSInvocation *inv,
-      NSMutableArray *retainedObjectsForInvocation);
+      NSMutableArray *retainedObjectsForInvocation,
+      RCTNSDictionaryPromiseRejectBlock optionalInternalRejectBlock);
 
-  using PromiseInvocationBlock = void (^)(RCTPromiseResolveBlock resolveWrapper, RCTPromiseRejectBlock rejectWrapper);
+  using PromiseInvocationBlock = void (^)(RCTPromiseResolveBlock resolveWrapper, RCTPromiseRejectBlock rejectWrapper, RCTNSDictionaryPromiseRejectBlock internalRejectWrapper);
   jsi::Value createPromise(jsi::Runtime &runtime, std::string methodName, PromiseInvocationBlock invoke);
 };