@nocobase/plugin-workflow-javascript 2.1.0-beta.10 → 2.1.0-beta.12

package/dist/node_modules/isolated-vm/src/isolate/executor.h

@@ -0,0 +1,183 @@
+#pragma once
+#include <v8.h>
+#include <chrono>
+#include <mutex>
+#include <thread>
+#include "holder.h"
+#include "v8-profiler.h"
+
+namespace ivm {
+class InspectorAgent;
+class IsolateEnvironment;
+class Scheduler;
+
+/**
+ * Executor class handles v8 locking while C++ code is running. Thread syncronization is handled
+ * by v8::Locker. This also enters the isolate and sets up a handle scope.
+ */
+class Executor { // "En taro adun"
+	friend InspectorAgent;
+	friend IsolateEnvironment;
+	public:
+		explicit Executor(IsolateEnvironment& env);
+		Executor(const Executor&) = delete;
+		~Executor();
+		auto operator= (const Executor&) = delete;
+
+		static auto GetCurrentEnvironment() -> IsolateEnvironment*;
+		static auto GetDefaultEnvironment() -> IsolateEnvironment&;
+		static auto IsDefaultThread() -> bool;
+		static auto MayRunInlineTasks(IsolateEnvironment& env) -> bool;
+
+	private:
+		class CpuTimer {
+			public:
+				explicit CpuTimer(Executor& executor);
+				CpuTimer(const CpuTimer&) = delete;
+				~CpuTimer();
+				auto operator= (const CpuTimer&) = delete;
+
+				using TimePoint = std::chrono::time_point<std::chrono::steady_clock, std::chrono::nanoseconds>;
+				auto Delta(const std::lock_guard<std::mutex>& /*lock*/) const -> std::chrono::nanoseconds;
+				void Pause();
+				void Resume();
+				static auto Now() -> TimePoint;
+
+			private:
+				Executor& executor;
+				CpuTimer* last;
+				TimePoint time;
+#if USE_CLOCK_THREAD_CPUTIME_ID
+				std::chrono::time_point<std::chrono::steady_clock> steady_time;
+#endif
+		};
+
+		// WallTimer is also responsible for pausing the current CpuTimer before we attempt to
+		// acquire the v8::Locker, because that could block in which case CPU shouldn't be counted.
+		class WallTimer {
+			public:
+				explicit WallTimer(Executor& executor);
+				WallTimer(const WallTimer&) = delete;
+				~WallTimer();
+				auto operator= (const WallTimer&) = delete;
+
+				auto Delta(const std::lock_guard<std::mutex>& /*lock*/) const -> std::chrono::nanoseconds;
+
+			private:
+				Executor& executor;
+				CpuTimer* cpu_timer;
+				std::chrono::time_point<std::chrono::steady_clock> time;
+		};
+
+	public:
+		// Pauses CpuTimer
+		class UnpauseScope;
+		class PauseScope {
+			friend UnpauseScope;
+			public:
+				explicit PauseScope(CpuTimer* timer) : timer{timer} { timer->Pause(); }
+				PauseScope(const PauseScope&) = delete;
+				~PauseScope() { timer->Resume(); }
+				auto operator=(const PauseScope&) = delete;
+
+			private:
+				CpuTimer* timer;
+		};
+
+		// Unpauses CpuTimer
+		class UnpauseScope {
+			public:
+				explicit UnpauseScope(PauseScope& pause) : timer{pause.timer} { timer->Resume(); }
+				UnpauseScope(const UnpauseScope&) = delete;
+				~UnpauseScope() { timer->Pause(); }
+				auto operator=(const UnpauseScope&) = delete;
+
+				CpuTimer* timer;
+		};
+
+		// A scope sets the current environment without locking v8
+		class Scope {
+			public:
+				explicit Scope(IsolateEnvironment& env);
+				Scope(const Scope&) = delete;
+				~Scope();
+				auto operator= (const Scope&) = delete;
+
+			private:
+				Executor* last;
+		};
+
+		class Profiler {
+			public:
+				explicit Profiler(IsolateEnvironment& env);
+				Profiler(const Profiler&) = delete;
+				~Profiler();
+				auto operator= (const Profiler&) = delete;
+			private:
+				IsolateEnvironment* environment;
+				Executor* executor;
+				v8::CpuProfiler* profiler;
+				v8::Isolate* isolate;
+		};
+
+		// Locks this environment for execution. Implies `Scope` as well.
+		class Lock {
+			public:
+				explicit Lock(IsolateEnvironment& env);
+				Lock(const Lock&) = delete;
+				~Lock() = default;
+				auto operator= (const Lock&) = delete;
+
+			private:
+				// These need to be separate from `Executor::current_executor` because the default isolate
+				// doesn't actually get a lock.
+				Scope scope;
+				WallTimer wall_timer;
+				v8::Locker locker;
+				CpuTimer cpu_timer;
+				v8::Isolate::Scope isolate_scope;
+				v8::HandleScope handle_scope;
+				Profiler profiler;
+		};
+
+		class Unlock {
+			public:
+				explicit Unlock(IsolateEnvironment& env);
+				Unlock(const Unlock&) = delete;
+				~Unlock() = default;
+				auto operator= (const Unlock&) = delete;
+
+			private:
+				PauseScope pause_scope;
+				v8::Unlocker unlocker;
+		};
+
+	private:
+		IsolateEnvironment& env;
+		Executor& default_executor;
+		std::thread::id default_thread;
+		Lock* current_lock = nullptr;
+		CpuTimer* cpu_timer = nullptr;
+		WallTimer* wall_timer = nullptr;
+		int depth = 0;
+		std::mutex timer_mutex;
+		std::chrono::nanoseconds cpu_time{};
+		std::chrono::nanoseconds wall_time{};
+
+		static thread_local CpuTimer* cpu_timer_thread;
+		static thread_local Executor* current_executor;
+};
+
+inline auto Executor::GetCurrentEnvironment() -> IsolateEnvironment* {
+	return current_executor == nullptr ? nullptr : &current_executor->env;
+}
+
+inline auto Executor::GetDefaultEnvironment() -> IsolateEnvironment& {
+	return current_executor->default_executor.env;
+}
+
+inline auto Executor::IsDefaultThread() -> bool {
+	return std::this_thread::get_id() == current_executor->default_thread;
+};
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/isolate/external.h

@@ -0,0 +1,64 @@
+#pragma once
+#include "environment.h"
+#include "util.h"
+#include <v8.h>
+#include <memory>
+#include <utility>
+
+namespace ivm {
+namespace detail {
+
+template <class Type>
+class ExternalHolder {
+	public:
+		ExternalHolder(const ExternalHolder&) = delete;
+		~ExternalHolder() = default;
+		auto operator=(const ExternalHolder&) = delete;
+
+		template <class ...Args>
+		static auto New(Args&&... args) {
+			// Allocate heap memory for ExternalHolder (don't construct)
+			ExternalHolder* that = std::allocator<ExternalHolder>{}.allocate(1);
+			// Create a new v8::External referencing the unconstructed holder
+			auto external = v8::External::New(v8::Isolate::GetCurrent(), &that->data);
+			// Construct the holder in-place
+			new(that) ExternalHolder(external, std::forward<Args>(args)...);
+			// Setup weak callbacks (technically could throw)
+			that->handle.SetWeak(reinterpret_cast<void*>(that), WeakCallbackV8, v8::WeakCallbackType::kParameter);
+			IsolateEnvironment::GetCurrent().AddWeakCallback(&that->handle, WeakCallback, that);
+			// Return local external handle
+			return external;
+		}
+
+	private:
+		template <class ...Args>
+		explicit ExternalHolder(v8::Local<v8::External> handle, Args&&... args) :
+			handle{v8::Isolate::GetCurrent(), handle}, data{std::forward<Args>(args)...} {}
+
+		static void WeakCallback(void* param) {
+			auto* that = static_cast<ExternalHolder*>(param);
+			auto& isolate = IsolateEnvironment::GetCurrent();
+			isolate.RemoveWeakCallback(&that->handle);
+			that->handle.Reset();
+			delete that;
+		}
+
+		static void WeakCallbackV8(const v8::WeakCallbackInfo<void>& info) {
+			WeakCallback(info.GetParameter());
+		}
+
+		v8::Persistent<v8::Value> handle;
+		Type data;
+};
+
+} // namespace detail
+
+/**
+ * Returns a v8::External with attached handle deletion
+ */
+template <class Type, class ...Args>
+auto MakeExternal(Args&&... args) {
+	return detail::ExternalHolder<Type>::New(std::forward<Args>(args)...);
+}
+
+}

package/dist/node_modules/isolated-vm/src/isolate/functor_runners.h

@@ -0,0 +1,97 @@
+#pragma once
+#include "util.h"
+#include "external_copy/error.h"
+#include "generic/error.h"
+
+namespace ivm {
+
+/**
+ * Helpers to run a function and catch the various exceptions defined above
+ */
+namespace FunctorRunners {
+
+template <typename F, typename T>
+inline void RunCallback(T& info, F fn) {
+	// This function is used when C++ code is invoked from a JS callback. We are given an instance of
+	// `FunctionCallbackInfo`, or `PropertyCallbackInfo` which is used to give the return value to v8.
+	// C++ exceptions will be caught, converted to JS exceptions, and then thrown back to JS.
+	try {
+		v8::Local<v8::Value> result = fn();
+		if (result.IsEmpty()) {
+			throw std::logic_error("Callback returned empty Local<> but did not set exception");
+		}
+		info.GetReturnValue().Set(result);
+	} catch (const detail::RuntimeErrorConstructible& cc_error) {
+		v8::Local<v8::Value> error = cc_error.ConstructError();
+		if (!error.IsEmpty()) {
+			v8::Isolate::GetCurrent()->ThrowException(error);
+		}
+	} catch (const RuntimeError& err) {
+	}
+}
+
+template <typename F1, typename F2>
+inline void RunCatchExternal(v8::Local<v8::Context> default_context, F1 fn1, F2 fn2) {
+	// This function will call `fn1()` and if that fails it will convert the caught error to an
+	// `ExternalCopy` and call `fn2(err)`
+	auto* isolate = v8::Isolate::GetCurrent();
+	v8::TryCatch try_catch{isolate};
+	try {
+		try {
+			fn1();
+		} catch (const RuntimeTypeError& cc_error) {
+			// The following errors are just various C++ strings with an error type
+			fn2(std::make_unique<ExternalCopyError>(ExternalCopyError::ErrorType::TypeError, cc_error.GetMessage().c_str(), cc_error.GetStackTrace()));
+		} catch (const RuntimeRangeError& cc_error) {
+			fn2(std::make_unique<ExternalCopyError>(ExternalCopyError::ErrorType::RangeError, cc_error.GetMessage().c_str(), cc_error.GetStackTrace()));
+		} catch (const RuntimeGenericError& cc_error) {
+			fn2(std::make_unique<ExternalCopyError>(ExternalCopyError::ErrorType::Error, cc_error.GetMessage().c_str(), cc_error.GetStackTrace()));
+		} catch (const detail::RuntimeErrorWithMessage& cc_error) {
+			fn2(std::make_unique<ExternalCopyError>(ExternalCopyError::ErrorType::Error, cc_error.GetMessage().c_str()));
+		} catch (const RuntimeError& cc_error) {
+			// If this is caught it means the error needs to be copied out of v8
+			assert(try_catch.HasCaught());
+			v8::Context::Scope context_scope{default_context};
+			fn2(ExternalCopy::CopyThrownValue(try_catch.Exception()));
+		}
+	} catch (...) {
+		if (try_catch.HasCaught()) {
+			try_catch.ReThrow();
+		}
+		throw;
+	}
+}
+
+template <typename F1, typename F2>
+inline void RunCatchValue(F1 fn1, F2 fn2) {
+	// This function will call `fn1()` and if that fails it will convert the caught error to a v8
+	// value and pass it to fn3().
+	//
+	// *Fatal errors are swallowed*
+	//
+	v8::TryCatch try_catch(v8::Isolate::GetCurrent());
+	try {
+		try {
+			fn1();
+		} catch (const FatalRuntimeError& cc_error) {
+			return;
+		} catch (const detail::RuntimeErrorConstructible& cc_error) {
+			// A C++ error thrown and needs to be internalized into v8
+			fn2(cc_error.ConstructError());
+		} catch (const RuntimeError& cc_error) {
+			// A JS error is waiting in the isolate
+			assert(try_catch.HasCaught());
+			v8::Local<v8::Value> error = try_catch.Exception();
+			try_catch.Reset();
+			fn2(error);
+		}
+	} catch (...) {
+		if (try_catch.HasCaught()) {
+			try_catch.ReThrow();
+		}
+		throw;
+	}
+}
+
+}; // namespace FunctorRunners
+}; // namespace ivm

package/dist/node_modules/isolated-vm/src/isolate/generic/array.h

@@ -0,0 +1,145 @@
+#pragma once
+#include "error.h"
+#include "handle_cast.h"
+#include <v8.h>
+#include <cstdint>
+
+namespace ivm {
+
+class ArrayRange {
+	public:
+		ArrayRange() = default;
+		ArrayRange(const ArrayRange&) = default;
+		ArrayRange(v8::Local<v8::Array> array, v8::Local<v8::Context> context) :
+			array{array}, context{context}, length{array->Length()} {}
+		~ArrayRange() = default;
+		auto operator=(const ArrayRange&) -> ArrayRange& = default;
+
+		auto begin() const {
+			return iterator{array, context, 0};
+		}
+
+		auto end() const {
+			return iterator{array, context, length};
+		}
+
+		class iterator {
+			public:
+				using iterator_category = std::random_access_iterator_tag;
+				using difference_type = int32_t;
+				using pointer = void;
+				using value_type = v8::Local<v8::Value>;
+				using reference = value_type;
+
+				iterator() = default;
+				iterator(const iterator&) = default;
+				iterator(v8::Local<v8::Array> array, v8::Local<v8::Context> context, uint32_t index) :
+					array{array}, context{context}, index{index} {}
+				~iterator() = default;
+				auto operator=(const iterator&) -> iterator& = default;
+
+				auto operator*() const {
+					return Unmaybe(array->Get(context, index));
+				}
+
+				auto operator==(const iterator& rhs) const {
+					return index == rhs.index;
+				}
+
+				auto operator<(const iterator& rhs) const {
+					return index < rhs.index;
+				}
+
+				auto operator-(const iterator& rhs) const -> difference_type {
+					return index - rhs.index;
+				}
+
+				auto operator+=(int val) -> iterator& {
+					index += val;
+					return *this;
+				}
+
+				// The following methods are boiler plate which invoke the above methods
+				decltype(auto) operator[](int index) const {
+					return *(*this + index);
+				}
+
+				auto operator!=(const iterator& rhs) const {
+					return !(*this == rhs);
+				}
+
+				auto operator>(const iterator& rhs) const {
+					return rhs < *this;
+				}
+
+				auto operator<=(const iterator& rhs) const {
+					return !(*this > rhs);
+				}
+
+				auto operator>=(const iterator& rhs) const {
+					return !(*this < rhs);
+				}
+
+				auto operator+(difference_type val) const -> iterator {
+					iterator copy{*this};
+					copy += val;
+					return copy;
+				}
+
+				auto operator-(difference_type val) const -> iterator {
+					return *this + -val;
+				}
+
+				auto operator++() -> iterator& {
+					return *this += 1;
+				}
+
+				auto operator-=(difference_type val) -> iterator& {
+					return *this += -val;
+				}
+
+				auto operator--() -> iterator& {
+					return *this -= 1;
+				}
+
+				auto operator++(int) -> iterator {
+					iterator copy{*this};
+					*this += 1;
+					return copy;
+				}
+
+				auto operator--(int) -> iterator {
+					iterator copy{*this};
+					*this -= 1;
+					return copy;
+				}
+
+			private:
+				v8::Local<v8::Array> array;
+				v8::Local<v8::Context> context;
+				uint32_t index = 0;
+		};
+
+	private:
+		v8::Local<v8::Array> array;
+		v8::Local<v8::Context> context;
+		uint32_t length = 0;
+};
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& arguments, HandleCastTag<ArrayRange> /*tag*/) {
+	if (value->IsArray()) {
+		return ArrayRange{value.As<v8::Array>(), arguments.context};
+	}
+	ParamIncorrect::Throw("an array");
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& arguments, HandleCastTag<v8::Maybe<ArrayRange>> /*tag*/) -> v8::Maybe<ArrayRange> {
+	if (value->IsNullOrUndefined()) {
+		return v8::Nothing<ArrayRange>();
+	} else if (value->IsArray()) {
+		return v8::Just<ArrayRange>(ArrayRange{value.As<v8::Array>(), arguments.context});
+	}
+	ParamIncorrect::Throw("an array");
+}
+
+} // namespace ivm