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

package/dist/node_modules/isolated-vm/src/module/reference_handle.h

@@ -0,0 +1,106 @@
+#pragma once
+#include "isolate/remote_handle.h"
+#include "transferable.h"
+#include <v8.h>
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace ivm {
+namespace detail {
+
+/**
+ * Holds common data for ReferenceHandle and ReferenceHandleTransferable
+ */
+class ReferenceData {
+	friend class AccessorRunner;
+	public:
+		enum class TypeOf { Null, Undefined, Number, String, Boolean, Object, Function };
+
+		explicit ReferenceData(v8::Local<v8::Value> value, bool inherit = false);
+		ReferenceData(
+			std::shared_ptr<IsolateHolder> isolate,
+			RemoteHandle<v8::Value> reference,
+			RemoteHandle<v8::Context> context,
+			TypeOf type_of,
+			bool accessors,
+			bool inherit
+		);
+
+	protected:
+		std::shared_ptr<IsolateHolder> isolate;
+		RemoteHandle<v8::Value> reference;
+		RemoteHandle<v8::Context> context;
+		TypeOf type_of;
+		bool accessors;
+		bool inherit;
+};
+
+} // namespace detail
+
+/**
+ * This will be a reference to any v8 Value in any isolate.
+ */
+class ReferenceHandle : public TransferableHandle, public detail::ReferenceData {
+	friend class ApplyRunner;
+	friend class CopyRunner;
+	friend class AccessorRunner;
+	friend class GetRunner;
+	public:
+		using TypeOf = detail::ReferenceData::TypeOf;
+
+		template <class ...Args>
+		explicit ReferenceHandle(Args&&... args) : ReferenceData{std::forward<Args>(args)...} {}
+
+		static auto Definition() -> v8::Local<v8::FunctionTemplate>;
+		static auto New(v8::Local<v8::Value> value, v8::MaybeLocal<v8::Object> options)
+			-> std::unique_ptr<ReferenceHandle>;
+		auto TransferOut() -> std::unique_ptr<Transferable> final;
+
+		auto Deref(v8::MaybeLocal<v8::Object> maybe_options) -> v8::Local<v8::Value>;
+		auto DerefInto(v8::MaybeLocal<v8::Object> maybe_options) -> v8::Local<v8::Value>;
+		auto Release() -> v8::Local<v8::Value>;
+		auto TypeOfGetter() -> v8::Local<v8::Value>;
+
+		template <int async>
+		auto Apply(
+			v8::MaybeLocal<v8::Value> recv_handle,
+			v8::Maybe<ArrayRange> maybe_arguments,
+			v8::MaybeLocal<v8::Object> maybe_options
+		) -> v8::Local<v8::Value>;
+
+		template <int async>
+		auto Copy() -> v8::Local<v8::Value>;
+
+		template <int async>
+		auto Get(
+			v8::Local<v8::Value> key_handle,
+			v8::MaybeLocal<v8::Object> maybe_options
+		) -> v8::Local<v8::Value>;
+
+		template <int async>
+		auto Delete(v8::Local<v8::Value> key_handle) -> v8::Local<v8::Value>;
+
+		template <int async>
+		auto Set(
+			v8::Local<v8::Value> key_handle,
+			v8::Local<v8::Value> val_handle,
+			v8::MaybeLocal<v8::Object> maybe_options
+		) -> v8::Local<v8::Value>;
+
+	private:
+		void CheckDisposed() const;
+};
+
+/**
+ * Instances of this turn into a ReferenceHandle when they are transferred in
+ */
+class ReferenceHandleTransferable : public Transferable, public detail::ReferenceData {
+	public:
+		template <class ...Args>
+		explicit ReferenceHandleTransferable(Args&&... args) : ReferenceData{std::forward<Args>(args)...} {}
+
+		auto TransferIn() -> v8::Local<v8::Value> final;
+};
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/module/script_handle.cc

@@ -0,0 +1,107 @@
+#include "isolate/run_with_timeout.h"
+#include "isolate/three_phase_task.h"
+#include "context_handle.h"
+#include "script_handle.h"
+
+using namespace v8;
+
+namespace ivm {
+
+/**
+ * ScriptHandle implementation
+ */
+ScriptHandle::ScriptHandle(RemoteHandle<UnboundScript> script) :
+	script{std::move(script)} {}
+
+auto ScriptHandle::Definition() -> Local<FunctionTemplate> {
+	return Inherit<TransferableHandle>(MakeClass(
+		"Script", nullptr,
+		"release", MemberFunction<decltype(&ScriptHandle::Release), &ScriptHandle::Release>{},
+		"run", MemberFunction<decltype(&ScriptHandle::Run<1>), &ScriptHandle::Run<1>>{},
+		"runIgnored", MemberFunction<decltype(&ScriptHandle::Run<2>), &ScriptHandle::Run<2>>{},
+		"runSync", MemberFunction<decltype(&ScriptHandle::Run<0>), &ScriptHandle::Run<0>>{}
+	));
+}
+
+auto ScriptHandle::TransferOut() -> std::unique_ptr<Transferable> {
+	return std::make_unique<ScriptHandleTransferable>(script);
+}
+
+auto ScriptHandle::Release() -> Local<Value> {
+	script = {};
+	return Undefined(Isolate::GetCurrent());
+}
+
+/*
+ * Run this script in a given context
+ */
+struct RunRunner /* lol */ : public ThreePhaseTask {
+	RunRunner(
+		RemoteHandle<UnboundScript>& script,
+		ContextHandle& context_handle,
+		MaybeLocal<Object> maybe_options
+	) : context{context_handle.GetContext()} {
+		// Sanity check
+		if (!script) {
+			throw RuntimeGenericError("Script has been released");
+		}
+		if (script.GetIsolateHolder() != context.GetIsolateHolder()) {
+			throw RuntimeGenericError("Invalid context");
+		}
+
+		// Parse options
+		bool release = false;
+		Local<Object> options;
+		if (maybe_options.ToLocal(&options)) {
+			release = ReadOption<bool>(options, StringTable::Get().release, false);
+			timeout_ms = ReadOption<int32_t>(options, StringTable::Get().timeout, 0);
+		}
+		if (release) {
+			this->script = std::move(script);
+		} else {
+			this->script = script;
+		}
+		transfer_options = TransferOptions{maybe_options};
+	}
+
+	void Phase2() final {
+		// Enter script's context and run it
+		Local<Context> context_local = Deref(context);
+		Context::Scope context_scope{context_local};
+		Local<Script> script_handle = Deref(script)->BindToCurrentContext();
+		Local<Value> script_result = RunWithTimeout(timeout_ms, [&script_handle, &context_local]() {
+			return script_handle->Run(context_local);
+		});
+		result = OptionalTransferOut(script_result, transfer_options);
+	}
+
+	auto Phase3() -> Local<Value> final {
+		if (result) {
+			return result->TransferIn();
+		} else {
+			return Undefined(Isolate::GetCurrent()).As<Value>();
+		}
+	}
+
+	RemoteHandle<UnboundScript> script;
+	RemoteHandle<Context> context;
+	TransferOptions transfer_options;
+	std::unique_ptr<Transferable> result;
+	uint32_t timeout_ms = 0;
+};
+template <int async>
+auto ScriptHandle::Run(ContextHandle& context_handle, MaybeLocal<Object> maybe_options) -> Local<Value> {
+	return ThreePhaseTask::Run<async, RunRunner>(*script.GetIsolateHolder(), script, context_handle, maybe_options);
+}
+
+/**
+ * ScriptHandleTransferable implementation
+ */
+ScriptHandle::ScriptHandleTransferable::ScriptHandleTransferable(RemoteHandle<UnboundScript> script) :
+	script{std::move(script)} {}
+
+auto ScriptHandle::ScriptHandleTransferable::TransferIn() -> Local<Value> {
+	return ClassHandle::NewInstance<ScriptHandle>(script);
+};
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/module/script_handle.h

@@ -0,0 +1,37 @@
+#pragma once
+#include "isolate/remote_handle.h"
+#include "transferable.h"
+#include "transferable.h"
+#include <v8.h>
+#include <memory>
+
+namespace ivm {
+
+class ContextHandle;
+
+class ScriptHandle : public TransferableHandle {
+	public:
+		using DontFreezeInstance = void;
+
+		explicit ScriptHandle(RemoteHandle<v8::UnboundScript> script);
+		static auto Definition() -> v8::Local<v8::FunctionTemplate>;
+
+		auto TransferOut() -> std::unique_ptr<Transferable> final;
+
+		auto Release() -> v8::Local<v8::Value>;
+		template <int async>
+		auto Run(ContextHandle& context_handle, v8::MaybeLocal<v8::Object> maybe_options) -> v8::Local<v8::Value>;
+
+	private:
+		class ScriptHandleTransferable : public Transferable {
+			public:
+				explicit ScriptHandleTransferable(RemoteHandle<v8::UnboundScript> script);
+				auto TransferIn() -> v8::Local<v8::Value> final;
+			private:
+				RemoteHandle<v8::UnboundScript> script;
+		};
+
+		RemoteHandle<v8::UnboundScript> script;
+};
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/module/session_handle.cc

@@ -0,0 +1,173 @@
+#include "session_handle.h"
+#include "isolate/remote_handle.h"
+#include "isolate/util.h"
+
+using namespace v8;
+using namespace v8_inspector;
+using std::shared_ptr;
+using std::unique_ptr;
+
+namespace ivm {
+
+/**
+ * This class handles sending messages from the backend to the frontend
+ */
+class SessionImpl : public InspectorSession {
+	public:
+		shared_ptr<IsolateHolder> isolate; // This is the isolate that owns the session
+		RemoteHandle<Function> onNotification;
+		RemoteHandle<Function> onResponse;
+
+		explicit SessionImpl(IsolateEnvironment& isolate) : InspectorSession(isolate) {}
+
+	private:
+		// Helper
+		static auto bufferToString(StringBuffer& buffer) -> MaybeLocal<String> {
+			const StringView& view = buffer.string();
+			if (view.is8Bit()) {
+				return String::NewFromOneByte(Isolate::GetCurrent(), view.characters8(), NewStringType::kNormal, view.length());
+			} else {
+				return String::NewFromTwoByte(Isolate::GetCurrent(), view.characters16(), NewStringType::kNormal, view.length());
+			}
+		}
+
+		// These functions are invoked directly from v8
+		void sendResponse(int call_id, unique_ptr<StringBuffer> message) final {
+			if (!onResponse) {
+				return;
+			}
+			struct SendResponseTask : public Runnable {
+				int call_id;
+				unique_ptr<StringBuffer> message;
+				RemoteHandle<Function> onResponse;
+
+				SendResponseTask(
+					int call_id, unique_ptr<StringBuffer> message, RemoteHandle<Function> onResponse
+				) :	call_id(call_id), message(std::move(message)), onResponse(std::move(onResponse)) {}
+
+				void Run() final {
+					Isolate* isolate = Isolate::GetCurrent();
+					TryCatch try_catch(isolate);
+					Local<String> string;
+					if (bufferToString(*message).ToLocal(&string)) {
+						Local<Function> fn = Deref(onResponse);
+						Local<Value> argv[2];
+						argv[0] = Integer::New(isolate, call_id);
+						argv[1] = string;
+						try {
+							Unmaybe(fn->Call(isolate->GetCurrentContext(), Undefined(isolate), 2, argv));
+						} catch (const RuntimeError& err) {}
+					}
+				}
+			};
+			isolate->ScheduleTask(std::make_unique<SendResponseTask>(call_id, std::move(message), onResponse), false, true);
+		}
+
+		void sendNotification(unique_ptr<StringBuffer> message) final {
+			if (!onNotification) {
+				return;
+			}
+			struct SendNotificationTask : public Runnable {
+				unique_ptr<StringBuffer> message;
+				RemoteHandle<Function> onNotification;
+				SendNotificationTask(
+					unique_ptr<StringBuffer> message, RemoteHandle<Function> onNotification
+				) : message(std::move(message)), onNotification(std::move(onNotification)) {}
+
+				void Run() final {
+					Isolate* isolate = Isolate::GetCurrent();
+					TryCatch try_catch(isolate);
+					Local<String> string;
+					if (bufferToString(*message).ToLocal(&string)) {
+						Local<Function> fn = Deref(onNotification);
+						Local<Value> argv[1];
+						argv[0] = string;
+						try {
+							Unmaybe(fn->Call(isolate->GetCurrentContext(), Undefined(isolate), 1, argv));
+						} catch (const RuntimeError& err) {}
+					}
+				}
+			};
+			isolate->ScheduleTask(std::make_unique<SendNotificationTask>(std::move(message), onNotification), false, true);
+		}
+
+		void flushProtocolNotifications() final {}
+};
+
+/**
+ * SessionHandle implementation
+ */
+SessionHandle::SessionHandle(IsolateEnvironment& isolate) : session(std::make_shared<SessionImpl>(isolate)) {
+	session->isolate = IsolateEnvironment::GetCurrentHolder();
+}
+
+auto SessionHandle::Definition() -> Local<FunctionTemplate> {
+	return MakeClass(
+		"Session", nullptr,
+		"dispatchProtocolMessage", MemberFunction<decltype(&SessionHandle::DispatchProtocolMessage), &SessionHandle::DispatchProtocolMessage>{},
+		"dispose", MemberFunction<decltype(&SessionHandle::Dispose), &SessionHandle::Dispose>{},
+		"onNotification", MemberAccessor<
+			decltype(&SessionHandle::OnNotificationGetter), &SessionHandle::OnNotificationGetter,
+			decltype(&SessionHandle::OnNotificationSetter), &SessionHandle::OnNotificationSetter
+		>{},
+		"onResponse", MemberAccessor<
+			decltype(&SessionHandle::OnResponseGetter), &SessionHandle::OnResponseGetter,
+			decltype(&SessionHandle::OnResponseSetter), &SessionHandle::OnResponseSetter
+		>{}
+	);
+}
+
+void SessionHandle::CheckDisposed() {
+	if (!session) {
+		throw RuntimeGenericError("Session is dead");
+	}
+}
+
+/**
+ * JS API methods
+ */
+auto SessionHandle::DispatchProtocolMessage(Local<String> message) -> Local<Value> {
+	Isolate* isolate = Isolate::GetCurrent();
+	CheckDisposed();
+	String::Value v8_str{isolate, message};
+	session->DispatchBackendProtocolMessage(std::vector<uint16_t>(*v8_str, *v8_str + v8_str.length()));
+	return Undefined(isolate);
+}
+
+auto SessionHandle::Dispose() -> Local<Value> {
+	CheckDisposed();
+	session.reset();
+	return Undefined(Isolate::GetCurrent());
+}
+
+// .onNotification
+auto SessionHandle::OnNotificationGetter() -> Local<Value> {
+	CheckDisposed();
+	if (session->onNotification) {
+		return Deref(session->onNotification);
+	} else {
+		return Undefined(Isolate::GetCurrent());
+	}
+}
+
+void SessionHandle::OnNotificationSetter(Local<Function> value) {
+	CheckDisposed();
+	session->onNotification = RemoteHandle<Function>(value);
+}
+
+// .onResponse
+auto SessionHandle::OnResponseGetter() -> Local<Value> {
+	CheckDisposed();
+	if (session->onResponse) {
+		return Deref(session->onResponse);
+	} else {
+		return Undefined(Isolate::GetCurrent());
+	}
+}
+
+void SessionHandle::OnResponseSetter(Local<Function> value) {
+	CheckDisposed();
+	session->onResponse = RemoteHandle<Function>(value);
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/module/session_handle.h

@@ -0,0 +1,31 @@
+#pragma once
+#include <v8.h>
+#include "isolate/class_handle.h"
+#include "isolate/inspector.h"
+#include <memory>
+
+namespace ivm {
+
+/**
+ * This handle is given to the client and encapsulates an inspector session. Non-transferable.
+ */
+class SessionHandle : public ClassHandle {
+	private:
+		std::shared_ptr<class SessionImpl> session;
+
+	public:
+		using DontFreezePrototype = void;
+		using DontFreezeInstance = void;
+		explicit SessionHandle(IsolateEnvironment& isolate);
+		static auto Definition() -> v8::Local<v8::FunctionTemplate>;
+
+		void CheckDisposed();
+		auto DispatchProtocolMessage(v8::Local<v8::String> message) -> v8::Local<v8::Value>;
+		auto Dispose() -> v8::Local<v8::Value>;
+		auto OnNotificationGetter() -> v8::Local<v8::Value>;
+		void OnNotificationSetter(v8::Local<v8::Function> value);
+		auto OnResponseGetter() -> v8::Local<v8::Value>;
+		void OnResponseSetter(v8::Local<v8::Function> value);
+};
+
+} // namespace ivm