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

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

@@ -46,6 +46,8 @@ typedef void (^RCTPromiseResolveBlock)(id result);
  */
 typedef void (^RCTPromiseRejectBlock)(NSString *code, NSString *message, NSError *error);
 
+typedef void (^RCTInternalPromiseRejectBlock)(NSException *exception);
+
 RCT_EXTERN_C_BEGIN
 
 typedef struct RCTMethodInfo {

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/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.cpp

@@ -64,7 +64,8 @@ struct JNIArgs {
 jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
     jsi::Function &&function,
     jsi::Runtime &rt,
-    const std::shared_ptr<CallInvoker> &jsInvoker) {
+    const std::shared_ptr<CallInvoker> &jsInvoker,
+    std::function<void(const std::shared_ptr<CallbackWrapper>&, const std::vector<jsi::Value>&)>&& executor) {
   auto weakWrapper =
       CallbackWrapper::createWeak(std::move(function), rt, jsInvoker);
 
@@ -80,7 +81,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,
+       executor = std::move(executor)](folly::dynamic responses) mutable {
         if (wrapperWasCalled) {
           throw std::runtime_error(
               "Callback arg cannot be called more than once");
@@ -94,7 +96,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),
+             executor = std::move(executor)]() {
               auto strongWrapper2 = weakWrapper.lock();
               if (!strongWrapper2) {
                 return;
@@ -107,16 +110,55 @@ jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
                     jsi::valueFromDynamic(strongWrapper2->runtime(), val));
               }
 
-              strongWrapper2->callback().call(
-                  strongWrapper2->runtime(),
-                  (const jsi::Value *)args.data(),
-                  args.size());
+              executor(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(
+    jsi::Function &&function,
+    jsi::Runtime &rt,
+    const std::shared_ptr<CallInvoker> &jsInvoker,
+    std::shared_ptr<std::string> jsStack) {
+  auto executor = [jsStack = std::move(jsStack)](
+          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", *jsStack);
+      reject->callback().call(rt2, error);
+  };
+  return createJavaCallbackFromJSIFunction(std::move(function), rt, jsInvoker, std::move(executor));
+}
+
 // This is used for generating short exception strings.
 std::string stringifyJSIValue(const jsi::Value &v, jsi::Runtime *rt = nullptr) {
   if (v.isUndefined()) {
@@ -447,6 +489,19 @@ jsi::JSError convertThrowableToJSError(
   return {runtime, std::move(error)};
 }
 
+void rejectWithException(
+    std::shared_ptr<CallbackWrapper> &reject,
+    std::exception_ptr &exception,
+    std::string &jsStack) {
+  jsi::Runtime &runtime = reject->runtime();
+  auto throwable = jni::getJavaExceptionForCppException(exception);
+  auto jsError = convertThrowableToJSError(runtime, throwable);
+  jsError.value().asObject(runtime).setProperty(runtime, "stack", jsStack);
+  reject->callback().call(
+          runtime,
+          jsError.value());
+}
+
 } // namespace
 
 jsi::Value JavaTurboModule::invokeJavaMethod(
@@ -805,18 +860,26 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
               throw std::invalid_argument("Promise fn arg count must be 2");
             }
 
+            std::shared_ptr<std::string> jsStack = std::make_shared<std::string>(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);
+            jsi::Function rejectInternalJSIFn =
+                promiseConstructorArgs[1].getObject(runtime).getFunction(
+                    runtime);
+            auto rejectInternalWeakWrapper =
+                CallbackWrapper::createWeak(std::move(rejectInternalJSIFn), 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(
+                              std::move(rejectJSIFn), runtime, jsInvoker_, jsStack)
                               .release();
 
             jclass jPromiseImpl =
@@ -843,12 +906,15 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
 
             nativeInvoker_->invokeAsync(
                 [jargs,
+                 rejectInternalWeakWrapper = std::move(rejectInternalWeakWrapper),
+                 jsStack = std::move(jsStack),
                  globalRefs,
                  methodID,
                  instance_ = jni::make_weak(instance_),
                  moduleNameStr,
                  methodNameStr,
                  id = getUniqueId()]() mutable -> void {
+                  auto rejectInternalStrongWrapper = rejectInternalWeakWrapper.lock();
                   auto instance = instance_.lockLocal();
 
                   if (!instance) {
@@ -871,7 +937,12 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
                   } catch (...) {
                     TMPL::asyncMethodCallExecutionFail(
                         moduleName, methodName, id);
-                    throw;
+                    if (rejectInternalStrongWrapper) {
+                      auto exception = std::current_exception();
+                      rejectWithException(rejectInternalStrongWrapper, exception, *jsStack);
+                    } else {
+                      throw;
+                    }
                   }
 
                   for (auto globalRef : globalRefs) {

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

@@ -103,9 +103,10 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
       bool isSync,
       const char *methodName,
       NSInvocation *inv,
-      NSMutableArray *retainedObjectsForInvocation);
+      NSMutableArray *retainedObjectsForInvocation,
+      RCTInternalPromiseRejectBlock optionalInternalRejectBlock);
 
-  using PromiseInvocationBlock = void (^)(RCTPromiseResolveBlock resolveWrapper, RCTPromiseRejectBlock rejectWrapper);
+  using PromiseInvocationBlock = void (^)(RCTPromiseResolveBlock resolveWrapper, RCTPromiseRejectBlock rejectWrapper, RCTInternalPromiseRejectBlock internalRejectWrapper);
   jsi::Value createPromise(jsi::Runtime &runtime, std::string methodName, PromiseInvocationBlock invoke);
 };
 

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

@@ -239,6 +239,24 @@ static int32_t getUniqueId()
   return {runtime, std::move(error)};
 }
 
+/**
+ * Creates JSErrorValue with given stack trace.
+ */
+static jsi::Value createRejectJSErrorValue(jsi::Runtime &runtime, NSDictionary *reason, std::string jsStack)
+{
+  jsi::Object cause = convertNSDictionaryToJSIObject(runtime, reason);
+  jsi::Value error;
+  NSString *message = reason[@"message"];
+  if (message) {
+    error = createJSRuntimeError(runtime, "Exception in HostFunction: " + std::string([message UTF8String]));
+  } else {
+    error = createJSRuntimeError(runtime, "Exception in HostFunction: <unknown>");
+  }
+  error.asObject(runtime).setProperty(runtime, "stack", jsStack);
+  error.asObject(runtime).setProperty(runtime, "cause", std::move(cause));
+  return error;
+}
+
 }
 
 jsi::Value ObjCTurboModule::createPromise(jsi::Runtime &runtime, std::string methodName, PromiseInvocationBlock invoke)
@@ -248,6 +266,9 @@ static int32_t getUniqueId()
   }
 
   jsi::Function Promise = runtime.global().getPropertyAsFunction(runtime, "Promise");
+  std::string jsStack = createJSRuntimeError(runtime, "")
+      .asObject(runtime).getProperty(runtime, "stack").asString(runtime).utf8(runtime);
+
   std::string moduleName = name_;
 
   // Note: the passed invoke() block is not retained by default, so let's retain it here to help keep it longer.
@@ -257,7 +278,7 @@ static int32_t getUniqueId()
       runtime,
       jsi::PropNameID::forAscii(runtime, "fn"),
       2,
-      [invokeCopy, jsInvoker = jsInvoker_, moduleName, methodName](
+      [invokeCopy, jsInvoker = jsInvoker_, moduleName, methodName, jsStack = std::move(jsStack)](
           jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) {
         std::string moduleMethod = moduleName + "." + methodName + "()";
 
@@ -324,7 +345,7 @@ static int32_t getUniqueId()
           resolveWasCalled = YES;
         };
 
-        RCTPromiseRejectBlock rejectBlock = ^(NSString *code, NSString *message, NSError *error) {
+        auto handlePromiseRejection = ^(NSDictionary *reason) {
           if (resolveWasCalled) {
             RCTLogError(@"%s: Tried to reject a promise after it's already been resolved.", moduleMethod.c_str());
             return;
@@ -341,17 +362,15 @@ static int32_t getUniqueId()
             return;
           }
 
-          NSDictionary *jsError = RCTJSErrorFromCodeMessageAndNSError(code, message, error);
-          strongRejectWrapper->jsInvoker().invokeAsync([weakResolveWrapper, weakRejectWrapper, jsError, blockGuard]() {
+          strongRejectWrapper->jsInvoker().invokeAsync([weakResolveWrapper, weakRejectWrapper, blockGuard, reason, jsStack = std::move(jsStack)]() {
             auto strongResolveWrapper2 = weakResolveWrapper.lock();
             auto strongRejectWrapper2 = weakRejectWrapper.lock();
             if (!strongResolveWrapper2 || !strongRejectWrapper2) {
               return;
             }
 
             jsi::Runtime &rt = strongRejectWrapper2->runtime();
-            jsi::Value arg = convertNSDictionaryToJSIObject(rt, jsError);
-            strongRejectWrapper2->callback().call(rt, arg);
+            strongRejectWrapper2->callback().call(rt, createRejectJSErrorValue(rt, reason, jsStack));
 
             strongResolveWrapper2->destroy();
             strongRejectWrapper2->destroy();
@@ -361,7 +380,21 @@ static int32_t getUniqueId()
           rejectWasCalled = YES;
         };
 
-        invokeCopy(resolveBlock, rejectBlock);
+        RCTPromiseRejectBlock rejectBlock = ^(NSString *code, NSString *message, NSError *error) {
+          NSDictionary *reason = RCTJSErrorFromCodeMessageAndNSError(code, message, error);
+          handlePromiseRejection(reason);
+        };
+
+        RCTInternalPromiseRejectBlock internalRejectBlock = ^(NSException *exception) {
+          handlePromiseRejection(@{
+            @"name": exception.name,
+            @"message": exception.reason,
+            @"stackSymbols": exception.callStackSymbols,
+            @"stackReturnAddresses": exception.callStackReturnAddresses,
+          });
+        };
+
+        invokeCopy(resolveBlock, rejectBlock, internalRejectBlock);
         return jsi::Value::undefined();
       });
 
@@ -382,7 +415,8 @@ static int32_t getUniqueId()
     bool isSync,
     const char *methodName,
     NSInvocation *inv,
-    NSMutableArray *retainedObjectsForInvocation)
+    NSMutableArray *retainedObjectsForInvocation,
+    RCTInternalPromiseRejectBlock optionalInternalRejectBlock)
 {
   __block id result;
   __weak id<RCTBridgeModule> weakModule = instance_;
@@ -405,7 +439,16 @@ static int32_t getUniqueId()
     @try {
       [inv invokeWithTarget:strongModule];
     } @catch (NSException *exception) {
-      throw convertNSExceptionToJSError(runtime, exception);
+      if (isSync) {
+        throw convertNSExceptionToJSError(runtime, exception);
+      } else {
+        if (optionalInternalRejectBlock != nil) {
+          optionalInternalRejectBlock(exception);
+        } else {
+          // JSFunction returning void
+          throw;
+        }
+      }
     } @finally {
       [retainedObjectsForInvocation removeAllObjects];
     }
@@ -718,20 +761,21 @@ static int32_t getUniqueId()
 
   if (returnType == PromiseKind) {
     returnValue = createPromise(
-        runtime, methodNameStr, ^(RCTPromiseResolveBlock resolveBlock, RCTPromiseRejectBlock rejectBlock) {
+        runtime, methodNameStr, ^(RCTPromiseResolveBlock resolveBlock, RCTPromiseRejectBlock rejectBlock, RCTInternalPromiseRejectBlock internalRejectBlock) {
           RCTPromiseResolveBlock resolveCopy = [resolveBlock copy];
           RCTPromiseRejectBlock rejectCopy = [rejectBlock copy];
+          RCTInternalPromiseRejectBlock internalRejectCopy = [internalRejectBlock copy];
 
           [inv setArgument:(void *)&resolveCopy atIndex:count + 2];
           [inv setArgument:(void *)&rejectCopy atIndex:count + 3];
           [retainedObjectsForInvocation addObject:resolveCopy];
           [retainedObjectsForInvocation addObject:rejectCopy];
           // The return type becomes void in the ObjC side.
-          performMethodInvocation(runtime, isMethodSync(VoidKind), methodName, inv, retainedObjectsForInvocation);
+          performMethodInvocation(runtime, isMethodSync(VoidKind), methodName, inv, retainedObjectsForInvocation, internalRejectCopy);
         });
   } else {
     id result =
-        performMethodInvocation(runtime, isMethodSync(returnType), methodName, inv, retainedObjectsForInvocation);
+        performMethodInvocation(runtime, isMethodSync(returnType), methodName, inv, retainedObjectsForInvocation, nil);
 
     if (isMethodSync(returnType)) {
       TurboModulePerfLogger::syncMethodCallReturnConversionStart(moduleName, methodName);

packages/rn-tester/js/examples/TurboModule/SampleTurboModuleExample.js

@@ -92,12 +92,9 @@ class SampleTurboModuleExample extends React.Component<{||}, State> {
       }
     },
     promiseThrows: () => {
-      try {
-        // $FlowFixMe[unused-promise]
-        NativeSampleTurboModule.promiseThrows?.();
-      } catch (e) {
-        return e.message;
-      }
+      NativeSampleTurboModule.promiseThrows?.()
+        .then(() => {})
+        .catch(e => this._setResult('promiseThrows', e.message));
     },
     voidFuncAssert: () => {
       try {
@@ -115,8 +112,9 @@ class SampleTurboModuleExample extends React.Component<{||}, State> {
     },
     promiseAssert: () => {
       try {
-        // $FlowFixMe[unused-promise]
-        NativeSampleTurboModule.promiseAssert?.();
+        NativeSampleTurboModule.promiseAssert?.()
+          .then(() => {})
+          .catch(e => this._setResult('promiseAssert', e.message));
       } catch (e) {
         return e.message;
       }