Merge pull request #41 from InputActions/scripting-unhandled-promise-rejection

scripting: handle unhandled promise rejection

Author: taj-ny

src/libinputactions/scripting/FunctionWrapper.h

@@ -59,14 +59,14 @@ class FunctionWrapper : public QObject
         if constexpr (std::is_void_v<TReturn>) {
             function(engine->fromScriptValue<TArgs>(args[I])...);
             return {};
-        }
+        } else {
+            const auto result = function(engine->fromScriptValue<TArgs>(args[I])...);
+            if constexpr (std::is_same_v<TReturn, QJSValue>) {
+                return result;
+            }
 
-        const auto result = function(engine->fromScriptValue<TArgs>(args[I])...);
-        if constexpr (std::is_same_v<TReturn, QJSValue>) {
-            return result;
+            return engine->toScriptValue(std::move(result));
         }
-
-        return engine->toScriptValue(std::move(result));
     }
 
     QJSEngine *m_engine;

src/libinputactions/scripting/ScriptingEngine.cpp

@@ -88,6 +88,48 @@ void ScriptingEngine::initialize()
 
                                  return m_engine->importModule(module);
                              }));
+
+    // Unhandled promise rejection handling
+    // TODO Maybe perform the check when the promise is garbage collected if possible
+    m_engine->evaluate(R"(
+        const { delay } = require("inputactions/core");
+
+        const patch = (promise) => {
+            promise.__then = promise.then;
+            promise.then = function(onFulfilled, onRejected) {
+                this.__handled = true;
+                return patch(this.__then(onFulfilled, onRejected));
+            };
+
+            promise.__then(undefined, x => {
+                delay(100).__then(() => {
+                    if (!promise.__handled) {
+                        __unhandledPromiseRejection(x);
+                    }
+                })
+            });
+
+            return promise;
+        }
+
+        const _Promise = Promise;
+        Promise = function(executor) {
+            return patch(new _Promise((resolve, reject) => {
+                executor(resolve, reject);
+            }));
+        }
+        Promise.all = _Promise.all;
+        Promise.race = _Promise.race;
+        Promise.reject = _Promise.reject;
+        Promise.resolve = _Promise.resolve;
+    )");
+    globalObject.setProperty("__unhandledPromiseRejection", newFunction<void, QJSValue>([this](QJSValue error) {
+                                 if (error.isError()) {
+                                     qCCritical(INPUTACTIONS_SCRIPTING).nospace().noquote() << "Uncaught (in promise) script error\n" << errorToString(error);
+                                 } else {
+                                     qCCritical(INPUTACTIONS_SCRIPTING).nospace().noquote() << "Uncaught (in promise) " << error.toString();
+                                 }
+                             }));
 }
 
 void ScriptingEngine::initializeWatchdog()