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

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

@@ -0,0 +1,272 @@
+#pragma once
+#include <v8.h>
+#include "error.h"
+#include "extract_params.h"
+
+namespace ivm {
+namespace detail {
+
+// Helper to extract arguments out of function
+template <class Function>
+struct extract_arguments;
+
+template <class Function>
+struct extract_arguments<Function*> : extract_arguments<Function> {};
+
+template <class Return, class ...Args>
+struct extract_arguments<Return(Args...)> {
+	using arguments = std::tuple<Args...>;
+	static constexpr auto index_sequence = std::make_index_sequence<sizeof...(Args)>{};
+};
+
+template<class Class, class Return, class ...Args>
+struct extract_arguments<Return(Class::*)(Args...)> : extract_arguments<Return(Args...)> {};
+
+// Helper to turn Return(Class:*)(...) into Return(*)(Class&, ...)
+template <class Signature>
+struct unbind_member_function;
+
+template <>
+struct unbind_member_function<std::nullptr_t> {
+	using type = std::nullptr_t;
+	template <std::nullptr_t>
+	static constexpr auto invoke = nullptr;
+};
+
+template <class Return, class ...Args>
+struct unbind_member_function<Return(Args...)> {};
+
+template<class Class, class Return, class ...Args>
+struct unbind_member_function<Return(Class::*)(Args...)> {
+	using type = Return(*)(Class&, Args...);
+	template <Return(Class::*Function)(Args...)>
+	static inline auto invoke(Class& instance, Args... args) -> Return {
+		return (instance.*Function)(args...);
+	}
+};
+
+// Callbacks that return `void` will return this instead which lets us pass it as an argument
+struct VoidReturn {};
+inline auto HandleCastImpl(VoidReturn /*value*/, HandleCastArguments arguments, HandleCastTag<v8::Local<v8::Value>> /*tag*/) {
+	return v8::Undefined(arguments.isolate);
+}
+
+// Returns a `VoidReturn{}` from void functions, which is later converted to `undefined`. This
+// is needed because the return value from any function needs to be used as a parameter to
+// another function.
+template <class Function>
+inline auto InvokeWithoutVoid(
+	Function function,
+	typename std::enable_if<std::is_same<void, decltype(function())>::value>::type* /*conditional*/ = nullptr
+) {
+	function();
+	return VoidReturn{};
+}
+
+template <class Function>
+inline decltype(auto) InvokeWithoutVoid(
+	Function function,
+	typename std::enable_if<!std::is_same<void, decltype(function())>::value>::type* /*conditional*/ = nullptr
+) {
+	return function();
+}
+
+// The return value of C++ callbacks are run through this to forward the value to v8
+template <class Type>
+inline void Returner(Type return_value, const v8::FunctionCallbackInfo<v8::Value>& info) {
+	info.GetReturnValue().Set(HandleCast<v8::Local<v8::Value>>(return_value, info));
+}
+
+template <class Type>
+inline void Returner(Type return_value, v8::Local<v8::Name> /*name*/, const v8::PropertyCallbackInfo<v8::Value>& info) {
+	info.GetReturnValue().Set(HandleCast<v8::Local<v8::Value>>(return_value, info));
+}
+
+inline void Returner(
+	VoidReturn /*return_value*/,
+	v8::Local<v8::Name> /*name*/,
+	v8::Local<v8::Value> /*value*/,
+	const v8::PropertyCallbackInfo<void>& /*info*/
+) {}
+
+// This the main entry point for all parameterized v8 callbacks
+template <class Signature, Signature Function, int Offset, class ...Args>
+struct CallbackMaker {
+	// This is responsible for unpacking the arguments from the C++ function, invoking the param
+	// extracter on the v8 info descriptors, and passing the results to the C++ function
+	template <size_t ...Indices>
+	static inline void Spread(Args... args, std::index_sequence<Indices...> /*indices*/) {
+		using FnArgs = typename extract_arguments<Signature>::arguments;
+		return Returner(InvokeWithoutVoid([&]() {
+			// ParamExtractor is implemented as a struct which holds the arguments because earlier
+			// versions of gcc segfault on nested template packs
+			ParamExtractor<Offset, Args...> extractor{args...};
+			// try/catch is here instead of in ParamExtractor to avoid having to set up / tear down stack
+			// guard once per parameter
+			try {
+				extractor.CheckLength(static_cast<FnArgs*>(nullptr));
+				return Function(extractor.template Invoke<Indices, std::tuple_element_t<Indices, FnArgs>>()...);
+			} catch (const ParamIncorrect& ex) {
+				extractor.Caught(ex);
+			}
+		}), args...);
+	}
+
+	// Passed directly to v8
+	static void Callback(Args... args) {
+		RunBarrier([&]() {
+			Spread(args..., extract_arguments<Signature>::index_sequence);
+		});
+	}
+};
+
+template <int Offset, class ...Args>
+struct CallbackMaker<std::nullptr_t, nullptr, Offset, Args...> {
+	static constexpr std::nullptr_t Callback = nullptr;
+};
+
+// Base type for all native callback pointers
+template <class Type, class... Args>
+struct GenericCallback {
+	constexpr explicit GenericCallback(Type callback) : callback{callback} {}
+	const Type callback;
+
+	template <int Offset, class Signature, Signature Function>
+	static constexpr auto ToCallback() -> Type {
+		return CallbackMaker<Signature, Function, Offset, Args...>::Callback;
+	}
+};
+
+// Any callbacks in the form of `void callback(const v8::FunctionCallbackInfo<v8::Value>&)`
+struct FunctionCallbackImpl : GenericCallback<v8::FunctionCallback,
+		const v8::FunctionCallbackInfo<v8::Value>&> {
+	constexpr FunctionCallbackImpl(std::nullptr_t /*nullptr*/) : GenericCallback{nullptr}, length{0} {} // NOLINT(hicpp-explicit-conversions)
+	constexpr FunctionCallbackImpl(v8::FunctionCallback callback, int length) :
+		GenericCallback{callback}, length{length} {}
+	const int length;
+};
+
+// Functions meant to be called without a `this` parameter
+struct FreeFunctionHolder : FunctionCallbackImpl {
+	using FunctionCallbackImpl::FunctionCallbackImpl;
+};
+
+// Functions where `this` is castable into a native pointer
+struct MemberFunctionHolder : FunctionCallbackImpl {
+	using FunctionCallbackImpl::FunctionCallbackImpl;
+};
+
+// Member getters and setters
+struct MemberGetterHolder : GenericCallback<v8::AccessorNameGetterCallback,
+		v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Value>&> {
+	using GenericCallback::GenericCallback;
+};
+
+struct MemberSetterHolder : GenericCallback<v8::AccessorNameSetterCallback,
+		v8::Local<v8::Name>, v8::Local<v8::Value>, const v8::PropertyCallbackInfo<void>&> {
+	using GenericCallback::GenericCallback;
+};
+
+struct MemberAccessorHolder {
+	constexpr MemberAccessorHolder(MemberGetterHolder getter, MemberSetterHolder setter) : getter{getter}, setter{setter} {}
+	const MemberGetterHolder getter;
+	const MemberSetterHolder setter;
+};
+
+// Static getters and setters
+struct StaticGetterHolder : FreeFunctionHolder {
+	using FreeFunctionHolder::FreeFunctionHolder;
+};
+
+struct StaticSetterHolder : FreeFunctionHolder {
+	using FreeFunctionHolder::FreeFunctionHolder;
+};
+
+struct StaticAccessorHolder {
+	constexpr StaticAccessorHolder(StaticGetterHolder getter, StaticSetterHolder setter) : getter{getter}, setter{setter} {}
+	const StaticGetterHolder getter;
+	const StaticSetterHolder setter;
+};
+
+} // namespace detail
+
+// Public interfaces for implementation classes are kept separate to ensure there is a common
+// interface for all instances of this template. For example it's easier to accept
+// `detail::FreeFunctionHolder` as parameter vs `FreeFunction<..., ...>`.
+template <class Signature, Signature Function>
+struct FreeFunction : detail::FreeFunctionHolder {
+	using FreeFunctionHolder::FreeFunctionHolder;
+	constexpr FreeFunction() : FreeFunctionHolder{
+		ToCallback<0, Signature, Function>(),
+		std::tuple_size<typename detail::extract_arguments<Signature>::arguments>::value
+	} {}
+};
+
+template <class Signature, Signature Function>
+struct MemberFunction : detail::MemberFunctionHolder {
+	using MemberFunctionHolder::MemberFunctionHolder;
+	constexpr MemberFunction() : MemberFunctionHolder{
+		ToCallback<-1, typename Unbound::type, Unbound::template invoke<Function>>(),
+		std::tuple_size<typename detail::extract_arguments<Signature>::arguments>::value
+	} {}
+
+	private:
+		using Unbound = detail::unbind_member_function<Signature>;
+};
+
+template <class Signature, Signature Function>
+struct FreeFunctionWithData : detail::FreeFunctionHolder {
+	using FreeFunctionHolder::FreeFunctionHolder;
+	constexpr FreeFunctionWithData() : FreeFunctionHolder{
+		ToCallback<-2, Signature, Function>(),
+		std::tuple_size<typename detail::extract_arguments<Signature>::arguments>::value
+	} {}
+};
+
+template <
+	class GetterSignature, GetterSignature Getter,
+	class SetterSignature = std::nullptr_t, SetterSignature Setter = nullptr
+>
+struct MemberAccessor : detail::MemberAccessorHolder {
+	constexpr MemberAccessor() : MemberAccessorHolder{
+		detail::MemberGetterHolder{detail::MemberGetterHolder::ToCallback<
+			0, typename UnboundGetter::type, UnboundGetter::template invoke<Getter>
+		>()},
+		detail::MemberSetterHolder{detail::MemberSetterHolder::ToCallback<
+			0, typename UnboundSetter::type, UnboundSetter::template invoke<Setter>
+		>()}
+	} {}
+
+	private:
+		using UnboundGetter = detail::unbind_member_function<GetterSignature>;
+		using UnboundSetter = detail::unbind_member_function<SetterSignature>;
+};
+
+// gcc seems to have trouble explicitly substituting std::nullptr_t into these templates so this one
+// is partially specialized. Theoretically you could just remove this whole definition but I
+// wouldn't try it.
+template <class GetterSignature, GetterSignature Getter>
+struct MemberAccessor<GetterSignature, Getter, std::nullptr_t, nullptr> : detail::MemberAccessorHolder {
+	constexpr MemberAccessor() : MemberAccessorHolder{
+		detail::MemberGetterHolder{detail::MemberGetterHolder::ToCallback<
+			0, typename UnboundGetter::type, UnboundGetter::template invoke<Getter>
+		>()},
+		detail::MemberSetterHolder{nullptr}
+	} {}
+
+	private:
+		using UnboundGetter = detail::unbind_member_function<GetterSignature>;
+};
+
+template <
+	class GetterSignature, GetterSignature Getter,
+	class SetterSignature = std::nullptr_t, SetterSignature Setter = nullptr
+>
+struct StaticAccessor : detail::StaticAccessorHolder {
+	constexpr StaticAccessor() : StaticAccessorHolder{
+		detail::StaticGetterHolder{detail::StaticGetterHolder::ToCallback<0, GetterSignature, Getter>(), 0},
+		detail::StaticSetterHolder{detail::StaticSetterHolder::ToCallback<0, SetterSignature, Setter>(), 1}
+	} {}
+};
+
+} // namespace ivm

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

@@ -0,0 +1,140 @@
+#pragma once
+#include <stdexcept>
+#include <string>
+#include <v8.h>
+#include "isolate/v8_version.h"
+
+namespace ivm {
+
+/**
+ * JS + C++ exceptions, use with care
+ */
+
+// `RuntimeError` can be thrown when v8 already has an exception on deck
+class RuntimeError : public std::exception {};
+
+namespace detail {
+
+// `RuntimeErrorWithMessage` is a general error that has an error message with it
+class RuntimeErrorWithMessage : public RuntimeError {
+	public:
+		explicit RuntimeErrorWithMessage(std::string message) : message{std::move(message)} {}
+
+		auto GetMessage() const {
+			return message;
+		}
+
+	private:
+		std::string message;
+};
+
+// `RuntimeErrorConstructible` is a abstract error that can be imported back into v8
+class RuntimeErrorConstructible : public RuntimeErrorWithMessage {
+	using RuntimeErrorWithMessage::RuntimeErrorWithMessage;
+	public:
+		virtual auto ConstructError() const -> v8::Local<v8::Value> = 0;
+};
+
+// `RuntimeErrorWithConstructor` can be used to construct any of the `v8::Exception` errors
+#if V8_AT_LEAST(11, 9, 154)
+template <v8::Local<v8::Value> (*Error)(v8::Local<v8::String>, v8::Local<v8::Value>)>
+#else
+template <v8::Local<v8::Value> (*Error)(v8::Local<v8::String>)>
+#endif
+class RuntimeErrorWithConstructor : public RuntimeErrorConstructible {
+	using RuntimeErrorConstructible::RuntimeErrorConstructible;
+	public:
+		RuntimeErrorWithConstructor(const std::string& message, std::string stack_trace) :
+			RuntimeErrorConstructible{message}, stack_trace{std::move(stack_trace)} {}
+
+		auto ConstructError() const -> v8::Local<v8::Value> final {
+			v8::Isolate* isolate = v8::Isolate::GetCurrent();
+			v8::MaybeLocal<v8::String> maybe_message = v8::String::NewFromUtf8(isolate, GetMessage().c_str(), v8::NewStringType::kNormal);
+			v8::Local<v8::String> message_handle;
+			if (maybe_message.ToLocal(&message_handle)) {
+				v8::Local<v8::Object> error =
+#if V8_AT_LEAST(11, 9, 154)
+					Error(message_handle, {}).As<v8::Object>();
+#else
+					Error(message_handle).As<v8::Object>();
+#endif
+				if (!stack_trace.empty() && isolate->InContext()) {
+					std::string stack_str = std::string(GetMessage()) + stack_trace;
+					v8::MaybeLocal<v8::String> maybe_stack = v8::String::NewFromUtf8(isolate, stack_str.c_str(), v8::NewStringType::kNormal);
+					v8::MaybeLocal<v8::String> maybe_stack_symbol = v8::String::NewFromUtf8(isolate, "stack", v8::NewStringType::kNormal);
+					v8::Local<v8::String> stack;
+					v8::Local<v8::String> stack_symbol;
+					if (maybe_stack.ToLocal(&stack) && maybe_stack_symbol.ToLocal(&stack_symbol)) {
+						error->Set(isolate->GetCurrentContext(), stack_symbol, stack).IsJust();
+					}
+				}
+				return error;
+			}
+			// If the MaybeLocal is empty then I think v8 will have an exception on deck. I don't know if
+			// there's any way to assert() this though.
+			return {};
+		}
+
+		auto GetStackTrace() const -> std::string {
+			return stack_trace;
+		}
+
+	private:
+		std::string stack_trace;
+};
+
+}
+
+// `FatalRuntimeError` is for very bad situations when the isolate is now in an unknown state
+class FatalRuntimeError : public detail::RuntimeErrorWithMessage {
+	using RuntimeErrorWithMessage::RuntimeErrorWithMessage;
+};
+
+// These correspond to the given JS error types
+using RuntimeGenericError = detail::RuntimeErrorWithConstructor<v8::Exception::Error>;
+using RuntimeTypeError = detail::RuntimeErrorWithConstructor<v8::Exception::TypeError>;
+using RuntimeRangeError = detail::RuntimeErrorWithConstructor<v8::Exception::RangeError>;
+
+/**
+ * Convert a MaybeLocal<T> to Local<T> and throw an error if it's empty. Someone else should throw
+ * the v8 exception.
+ */
+template <class Type>
+auto Unmaybe(v8::Maybe<Type> handle) -> Type {
+	Type just;
+	if (handle.To(&just)) {
+		return just;
+	} else {
+		throw RuntimeError();
+	}
+}
+
+template <class Type>
+auto Unmaybe(v8::MaybeLocal<Type> handle) -> v8::Local<Type> {
+	v8::Local<Type> local;
+	if (handle.ToLocal(&local)) {
+		return local;
+	} else {
+		throw RuntimeError();
+	}
+}
+
+namespace detail {
+
+template <class Functor>
+inline void RunBarrier(Functor fn) {
+	// Runs a function and converts C++ errors to immediate v8 errors. Pretty much the same as
+	// `RunCallback` but with no return value.
+	try {
+		fn();
+	} catch (const FatalRuntimeError& cc_error) {
+		// Execution is terminating
+	} catch (const detail::RuntimeErrorConstructible& cc_error) {
+		v8::Isolate::GetCurrent()->ThrowException(cc_error.ConstructError());
+	} catch (const RuntimeError& cc_error) {
+		// A JS error is waiting in the isolate
+	}
+}
+
+} // namespace detail
+} // namespace ivm

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

@@ -0,0 +1,145 @@
+#pragma once
+#include <string>
+#include <v8.h>
+#include "error.h"
+#include "handle_cast.h"
+
+namespace ivm {
+namespace detail {
+
+// Returns the name of the current function being called, used for error messages
+inline auto CalleeName(const v8::FunctionCallbackInfo<v8::Value>& info) -> std::string {
+	v8::Isolate* isolate = info.GetIsolate();
+	return std::string("`")+ *v8::String::Utf8Value{isolate, Unmaybe(info.Data()->ToString(isolate->GetCurrentContext()))}+ "`";
+}
+
+inline auto CalleeName(const v8::PropertyCallbackInfo<v8::Value>& info) -> std::string {
+	v8::Isolate* isolate = info.GetIsolate();
+	return std::string("`")+ *v8::String::Utf8Value{isolate, Unmaybe(info.Data()->ToString(isolate->GetCurrentContext()))}+ "`";
+}
+
+inline auto CalleeName(const v8::PropertyCallbackInfo<void>& info) -> std::string {
+	v8::Isolate* isolate = info.GetIsolate();
+	return std::string("`")+ *v8::String::Utf8Value{isolate, Unmaybe(info.Data()->ToString(isolate->GetCurrentContext()))}+ "`";
+}
+
+// Specifies the types which may be default constructed when missing from arguments
+template <class Type>
+struct IsEmptyHandleAllowed : std::false_type {};
+
+template <class Type>
+struct IsEmptyHandleAllowed<Type*> : std::true_type {};
+
+template <class Type>
+struct IsEmptyHandleAllowed<v8::Maybe<Type>> : std::true_type {};
+
+template <class Type>
+struct IsEmptyHandleAllowed<v8::MaybeLocal<Type>> : std::true_type {};
+
+// Statically counts the required arguments in a given callback function
+template <size_t Index, class ...Args>
+struct RequiredArguments;
+
+template <size_t Index, class Type, class ...Rest>
+struct RequiredArguments<Index, Type, Rest...> {
+	constexpr static size_t value = std::max(
+		IsEmptyHandleAllowed<Type>::value ? 0 : Index + 1,
+		RequiredArguments<Index + 1, Rest...>::value
+	);
+};
+
+template <size_t Index>
+struct RequiredArguments<Index> {
+    constexpr static size_t value = 0;
+};
+
+// Extracts parameters from various v8 call signatures
+template <int Index>
+inline auto ExtractParamImpl(const v8::FunctionCallbackInfo<v8::Value>& info) -> v8::Local<v8::Value> {
+	if (Index == -2) {
+		return info.Data();
+	} else if (Index == -1) {
+		return info.This();
+	} else {
+		return info[Index];
+	}
+}
+
+template <int Index>
+inline auto ExtractParamImpl(v8::Local<v8::Name> /*name*/, const v8::PropertyCallbackInfo<v8::Value>& info) -> v8::Local<v8::Value> {
+	static_assert(Index == 0, "Getter callback should have no parameters");
+	return info.This();
+}
+
+template <int Index>
+inline auto ExtractParamImpl(v8::Local<v8::Name> /*name*/, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) -> v8::Local<v8::Value> {
+	static_assert(Index < 2, "Setter callback should have exactly 1 parameter");
+	if (Index == 0) {
+		return info.This();
+	} else if (Index == 1) {
+		return value;
+	}
+}
+
+// Generic unpacker with empty checking
+template <int Offset, class ...Args>
+class ParamExtractor {
+	public:
+		explicit ParamExtractor(Args... args) : args{args...} {}
+
+		template <class ...Types>
+		inline void CheckLength(std::tuple<Types...>* /*tuple*/) {
+			size_t length = CalculateLength(std::get<sizeof...(Args) - 1>(args));
+			constexpr size_t required = RequiredArguments<0, Types...>::value;
+			if (length < required) {
+				// `this` counts as a parameter so adjust this count for the error message
+				constexpr int adjusted = static_cast<int>(required) + std::max(Offset, -1);
+				throw RuntimeTypeError{CalleeName()+ " requires at least "+ std::to_string(adjusted)+ (adjusted == 1 ? " parameter" : " parameters")};
+			}
+		}
+
+		template <int Index, class Type>
+		inline decltype(auto) Invoke() {
+			constexpr int AdjustedIndex = Index == 0 ? Offset : (std::max(-1, Offset) + Index);
+			ii = AdjustedIndex;
+			v8::Local<v8::Value> value = Extract<AdjustedIndex>(seq);
+			return HandleCast<Type>(value, std::get<sizeof...(Args) - 1>(args));
+		}
+
+		[[noreturn]] void Caught(const ParamIncorrect& ex) {
+			if (ii == -1) {
+				throw RuntimeTypeError{CalleeName()+ " requires `this` to be "+ ex.type};
+			} else {
+				throw RuntimeTypeError{CalleeName()+ " requires parameter "+ std::to_string(ii + 1)+ " to be "+ ex.type};
+			}
+		}
+
+	private:
+		auto CalleeName() {
+			return detail::CalleeName(std::get<sizeof...(Args) - 1>(args));
+		}
+
+		template <int Index, size_t ...Indices>
+		inline auto Extract(std::index_sequence<Indices...> /*indices*/) {
+			return ExtractParamImpl<Index>(std::get<Indices>(args)...);
+		}
+
+		static inline auto CalculateLength(const v8::FunctionCallbackInfo<v8::Value>& info) -> size_t {
+			return info.Length() + (Offset == 0 ? 0 : 1);
+		}
+
+		static inline auto CalculateLength(const v8::PropertyCallbackInfo<v8::Value>& /*info*/) -> size_t {
+			return 1; // `this`
+		}
+
+		static inline auto CalculateLength(const v8::PropertyCallbackInfo<void>& /*info*/) -> size_t {
+			return 2; // `this`, `value`
+		}
+
+		std::tuple<Args...> args;
+		int ii = 0;
+		static constexpr auto seq = std::make_index_sequence<sizeof...(Args)>{};
+};
+
+} // namespace detail
+} // namespace ivm