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

package/dist/node_modules/isolated-vm/src/external_copy/external_copy.h

@@ -0,0 +1,117 @@
+#pragma once
+#include <v8.h>
+#include <atomic>
+#include <cstdint>
+#include <cstdlib>
+#include <memory>
+#include <vector>
+
+#include "isolate/generic/array.h"
+#include "isolate/allocator.h"
+#include "isolate/transferable.h"
+#include "isolate/util.h"
+#include "lib/lockable.h"
+
+namespace ivm {
+
+using handle_vector_t = std::vector<v8::Local<v8::Value>>;
+using transferable_vector_t = std::vector<std::unique_ptr<Transferable>>;
+using array_buffer_vector_t = std::vector<std::unique_ptr<class ExternalCopyArrayBuffer>>;
+using shared_buffer_vector_t = std::vector<std::unique_ptr<class ExternalCopySharedArrayBuffer>>;
+
+class ExternalCopy : public Transferable {
+	public:
+		ExternalCopy() = default;
+		ExternalCopy(const ExternalCopy&) = delete;
+		auto operator= (const ExternalCopy&) = delete;
+		~ExternalCopy() override;
+
+		/**
+		 * `Copy` may throw a v8 exception if JSON.stringify(value) throws
+		 */
+		static auto Copy(
+			v8::Local<v8::Value> value,
+			bool transfer_out = false,
+			ArrayRange transfer_list = {}
+		) -> std::unique_ptr<ExternalCopy>;
+
+		/**
+		 * If you give this a primitive v8::Value (except Symbol) it will return a ExternalCopy for you.
+		 * Otherwise it returns nullptr. This is used to automatically move simple values between
+		 * isolates where it is possible to do so perfectly.
+		 */
+		static auto CopyIfPrimitive(v8::Local<v8::Value> value) -> std::unique_ptr<ExternalCopy>;
+		static auto CopyThrownValue(v8::Local<v8::Value> value) -> std::unique_ptr<ExternalCopy>;
+
+		static auto TotalExternalSize() -> int;
+
+		auto CopyIntoCheckHeap(bool transfer_in = false) -> v8::Local<v8::Value>;
+		virtual auto CopyInto(bool transfer_in = false) -> v8::Local<v8::Value> = 0;
+		auto Size() const -> int { return size; }
+		auto TransferIn() -> v8::Local<v8::Value> final { return CopyIntoCheckHeap(); }
+
+	protected:
+		explicit ExternalCopy(int size);
+		ExternalCopy(ExternalCopy&& that) noexcept;
+		auto operator= (ExternalCopy&& that) noexcept -> ExternalCopy&;
+
+		void UpdateSize(int size);
+
+	private:
+		int size = 0;
+};
+
+/**
+ * Base class for ArrayBuffer and SharedArrayBuffer
+ */
+class ExternalCopyAnyBuffer : public ExternalCopy {
+	public:
+		explicit ExternalCopyAnyBuffer(std::shared_ptr<v8::BackingStore> backing_store) :
+			backing_store{std::move(backing_store)} {}
+		auto Acquire() const -> std::shared_ptr<v8::BackingStore> { return *backing_store.read(); }
+
+	protected:
+		lockable_t<std::shared_ptr<v8::BackingStore>> backing_store;
+};
+
+/**
+ * ArrayBuffer instances
+ */
+class ExternalCopyArrayBuffer : public ExternalCopyAnyBuffer {
+	public:
+		using ExternalCopyAnyBuffer::ExternalCopyAnyBuffer;
+		ExternalCopyArrayBuffer(const void* data, size_t length);
+		explicit ExternalCopyArrayBuffer(v8::Local<v8::ArrayBuffer> handle);
+
+		static auto Transfer(v8::Local<v8::ArrayBuffer> handle) -> std::unique_ptr<ExternalCopyArrayBuffer>;
+		auto CopyInto(bool transfer_in = false) -> v8::Local<v8::Value> final;
+};
+
+/**
+ * SharedArrayBuffer instances
+ */
+class ExternalCopySharedArrayBuffer : public ExternalCopyAnyBuffer {
+	public:
+		explicit ExternalCopySharedArrayBuffer(v8::Local<v8::SharedArrayBuffer> handle);
+
+		auto CopyInto(bool transfer_in = false) -> v8::Local<v8::Value> final;
+};
+
+/**
+ * All types of TypedArray views w/ underlying buffer handle
+ */
+class ExternalCopyArrayBufferView : public ExternalCopy {
+	public:
+		enum class ViewType { Uint8, Uint8Clamped, Int8, Uint16, Int16, Uint32, Int32, Float32, Float64, BigInt64, BigUint64, DataView };
+
+	private:
+		std::unique_ptr<ExternalCopyAnyBuffer> buffer;
+		ViewType type;
+		size_t byte_offset, byte_length;
+
+	public:
+		ExternalCopyArrayBufferView(std::unique_ptr<ExternalCopyAnyBuffer> buffer, ViewType type, size_t byte_offset, size_t byte_length);
+		auto CopyInto(bool transfer_in = false) -> v8::Local<v8::Value> final;
+};
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/external_copy/serializer.cc

@@ -0,0 +1,85 @@
+#include "serializer.h"
+#include "isolate/allocator.h"
+
+using namespace v8;
+namespace ivm {
+
+/**
+ * ExternalCopySerialized implementation
+ */
+ExternalCopySerialized::ExternalCopySerialized(Local<Value> value, ArrayRange transfer_list) :
+BaseSerializer{[&](ValueSerializer& serializer, Local<Context> context) {
+	// Mark ArrayBuffers as transferred, but don't actually transfer yet otherwise it will invalidate
+	// array views before they are transferred
+	int ii = 0;
+	for (auto handle : transfer_list) {
+		if (handle->IsArrayBuffer()) {
+			serializer.TransferArrayBuffer(ii++, handle.As<ArrayBuffer>());
+		} else {
+			throw RuntimeTypeError("Non-ArrayBuffer passed in `transferList`");
+		}
+	}
+
+	// Serialize object and save
+	serializer.WriteHeader();
+	Unmaybe(serializer.WriteValue(context, value));
+}} {
+
+	// Transfer ArrayBuffers
+	for (auto handle : transfer_list) {
+		array_buffers.emplace_back(ExternalCopyArrayBuffer::Transfer(handle.As<ArrayBuffer>()));
+	}
+}
+
+auto ExternalCopySerialized::CopyInto(bool transfer_in) -> Local<Value> {
+	Local<Value> value;
+
+	Deserialize([&](ValueDeserializer& deserializer, Local<Context> context) {
+		// Transfer ArrayBuffers
+		for (unsigned ii = 0; ii < array_buffers.size(); ++ii) {
+			deserializer.TransferArrayBuffer(ii, array_buffers[ii]->CopyIntoCheckHeap(transfer_in).As<ArrayBuffer>());
+		}
+
+		// Deserialize object
+		Unmaybe(deserializer.ReadHeader(context));
+		return deserializer.ReadValue(context).ToLocal(&value);
+	});
+
+	return value;
+}
+
+/**
+ * SerializedVector implementation
+ */
+SerializedVector::SerializedVector(const v8::FunctionCallbackInfo<v8::Value>& info) :
+BaseSerializer([&](ValueSerializer& serializer, Local<Context> context) {
+	int length = info.Length();
+	serializer.WriteUint32(length);
+	for (int ii = 0; ii < length; ++ii) {
+		Unmaybe(serializer.WriteValue(context, info[ii]));
+	}
+}) {}
+
+auto SerializedVector::CopyIntoAsVector() -> std::vector<Local<Value>> {
+	std::vector<Local<Value>> result;
+	Deserialize([&](ValueDeserializer& deserializer, Local<Context> context) {
+		// Read length
+		uint32_t length;
+		Unmaybe(deserializer.ReadHeader(context));
+		if (!deserializer.ReadUint32(&length)) {
+			throw RuntimeGenericError("Invalid arguments payload");
+		}
+
+		// Read arguments
+		result.resize(length);
+		for (unsigned ii = 0; ii < length; ++ii) {
+			if (!deserializer.ReadValue(context).ToLocal(&result[ii])) {
+				return false;
+			}
+		}
+		return true;
+	});
+	return result;
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/external_copy/serializer.h

@@ -0,0 +1,136 @@
+#pragma once
+#include "external_copy.h"
+#include "isolate/environment.h"
+#include <deque>
+#include <memory>
+#include <vector>
+
+namespace ivm {
+namespace detail {
+
+class SerializationDelegateBase {
+	public:
+		SerializationDelegateBase(
+			std::deque<std::unique_ptr<Transferable>>& transferables,
+			std::deque<v8::CompiledWasmModule>& wasm_modules
+		) : transferables{transferables}, wasm_modules{wasm_modules} {}
+
+	protected:
+		std::deque<std::unique_ptr<Transferable>>& transferables;
+		std::deque<v8::CompiledWasmModule>& wasm_modules;
+};
+
+class SerializerDelegate : public SerializationDelegateBase, public v8::ValueSerializer::Delegate {
+	public:
+		using SerializationDelegateBase::SerializationDelegateBase;
+
+		void SetSerializer(v8::ValueSerializer* serializer) { this->serializer = serializer; }
+		void ThrowDataCloneError(v8::Local<v8::String> message) final;
+
+		auto GetSharedArrayBufferId(
+			v8::Isolate* isolate, v8::Local<v8::SharedArrayBuffer> shared_array_buffer) -> v8::Maybe<uint32_t> final;
+		auto GetWasmModuleTransferId(
+			v8::Isolate* isolate, v8::Local<v8::WasmModuleObject> module) -> v8::Maybe<uint32_t> final;
+		auto WriteHostObject(v8::Isolate* isolate, v8::Local<v8::Object> object) -> v8::Maybe<bool> final;
+
+	private:
+		v8::ValueSerializer* serializer = nullptr;
+};
+
+class DeserializerDelegate : public SerializationDelegateBase, public v8::ValueDeserializer::Delegate {
+	public:
+		using SerializationDelegateBase::SerializationDelegateBase;
+
+		void SetDeserializer(v8::ValueDeserializer* deserializer) { this->deserializer = deserializer; }
+
+		auto GetSharedArrayBufferFromId(
+			v8::Isolate* isolate, uint32_t clone_id) -> v8::MaybeLocal<v8::SharedArrayBuffer> final;
+		auto GetWasmModuleFromId(
+			v8::Isolate* isolate, uint32_t transfer_id) -> v8::MaybeLocal<v8::WasmModuleObject> final;
+		auto ReadHostObject(v8::Isolate* isolate) -> v8::MaybeLocal<v8::Object> final;
+
+	private:
+		v8::ValueDeserializer* deserializer = nullptr;
+};
+
+} // namespace detail
+
+/**
+ * Abstract serializer which manages boilerplate and lifecycle management of the serialized blob
+ */
+class BaseSerializer {
+	protected:
+		template <class Fn>
+		explicit BaseSerializer(Fn fn) {
+			// Initialize serializer and delegate
+			auto* isolate = v8::Isolate::GetCurrent();
+			auto context = isolate->GetCurrentContext();
+			detail::SerializerDelegate delegate{transferables, wasm_modules};
+			v8::ValueSerializer serializer{isolate, &delegate};
+			delegate.SetSerializer(&serializer);
+
+			// Run serialization
+			serializer.WriteHeader();
+			fn(serializer, context);
+
+			// Save to buffer
+			auto serialized_data = serializer.Release();
+			buffer = {serialized_data.first, std::free};
+			size = serialized_data.second;
+		}
+
+		template <class Fn>
+		auto Deserialize(Fn fn) {
+			// Initialize deserializer and delegate
+			auto* isolate = v8::Isolate::GetCurrent();
+			auto context = isolate->GetCurrentContext();
+			detail::DeserializerDelegate delegate{transferables, wasm_modules};
+			v8::ValueDeserializer deserializer{isolate, buffer.get(), size, &delegate};
+			delegate.SetDeserializer(&deserializer);
+
+			// Watch for allocation errors
+			auto* allocator = IsolateEnvironment::GetCurrent().GetLimitedAllocator();
+			int failures = allocator == nullptr ? 0 : allocator->GetFailureCount();
+			Unmaybe(deserializer.ReadHeader(context));
+
+			// Run implementation
+			if (!fn(deserializer, context)) {
+				// ValueDeserializer throws an unhelpful message when it fails to allocate an ArrayBuffer, so
+				// detect that case here and throw an appropriate message.
+				if (allocator != nullptr && allocator->GetFailureCount() != failures) {
+					throw RuntimeRangeError("Array buffer allocation failed");
+				} else {
+					throw RuntimeError();
+				}
+			}
+		}
+
+	private:
+		std::unique_ptr<uint8_t, decltype(std::free)*> buffer = {nullptr, std::free};
+		std::deque<std::unique_ptr<Transferable>> transferables;
+		std::deque<v8::CompiledWasmModule> wasm_modules;
+		size_t size;
+};
+
+/**
+ * Single serialized value compatible with `Transferable`
+ */
+class ExternalCopySerialized : public BaseSerializer, public ExternalCopy {
+	public:
+		ExternalCopySerialized(v8::Local<v8::Value> value, ArrayRange transfer_list);
+		auto CopyInto(bool transfer_in = false) -> v8::Local<v8::Value> final;
+
+	private:
+		std::vector<std::unique_ptr<ExternalCopyArrayBuffer>> array_buffers;
+};
+
+class SerializedVector : public BaseSerializer {
+	public:
+		explicit SerializedVector(const v8::FunctionCallbackInfo<v8::Value>& info);
+		auto CopyIntoAsVector() -> std::vector<v8::Local<v8::Value>>;
+
+	private:
+		std::vector<std::unique_ptr<ExternalCopyArrayBuffer>> array_buffers;
+};
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/external_copy/serializer_nortti.cc

@@ -0,0 +1,73 @@
+#include "serializer.h"
+#include "isolate/functor_runners.h"
+#include "module/transferable.h"
+
+/**
+ * This file is compiled *without* runtime type information, which matches the nodejs binary and
+ * allows the serializer delegates to resolve correctly.
+ */
+
+using namespace v8;
+
+namespace ivm::detail {
+
+void SerializerDelegate::ThrowDataCloneError(Local<String> message) {
+	Isolate::GetCurrent()->ThrowException(Exception::TypeError(message));
+}
+
+auto SerializerDelegate::GetSharedArrayBufferId(
+		Isolate* /*isolate*/, Local<SharedArrayBuffer> shared_array_buffer) -> Maybe<uint32_t> {
+	auto result = Nothing<uint32_t>();
+	detail::RunBarrier([&]() {
+		transferables.emplace_back(std::make_unique<ExternalCopySharedArrayBuffer>(shared_array_buffer));
+		result = Just<uint32_t>(transferables.size() - 1);
+	});
+	return result;
+}
+
+auto SerializerDelegate::GetWasmModuleTransferId(
+		Isolate* /*isolate*/, Local<WasmModuleObject> module) -> Maybe<uint32_t> {
+	auto result = Just<uint32_t>(wasm_modules.size());
+	wasm_modules.emplace_back(module->GetCompiledModule());
+	return result;
+}
+
+auto SerializerDelegate::WriteHostObject(Isolate* /*isolate*/, Local<Object> object) -> Maybe<bool> {
+	auto result = Nothing<bool>();
+	detail::RunBarrier([&]() {
+		serializer->WriteUint32(transferables.size());
+		transferables.emplace_back(TransferOut(object));
+		result = Just(true);
+	});
+	return result;
+}
+
+auto DeserializerDelegate::ReadHostObject(Isolate* /*isolate*/) -> MaybeLocal<Object> {
+	MaybeLocal<Object> result;
+	detail::RunBarrier([&]() {
+		uint32_t ii;
+		assert(deserializer->ReadUint32(&ii));
+		result = transferables[ii]->TransferIn().As<Object>();
+	});
+	return result;
+}
+
+auto DeserializerDelegate::GetSharedArrayBufferFromId(
+		Isolate* /*isolate*/, uint32_t clone_id) -> MaybeLocal<SharedArrayBuffer> {
+	MaybeLocal<SharedArrayBuffer> result;
+	detail::RunBarrier([&]() {
+		result = transferables[clone_id]->TransferIn().As<SharedArrayBuffer>();
+	});
+	return result;
+}
+
+auto DeserializerDelegate::GetWasmModuleFromId(
+		Isolate* isolate, uint32_t transfer_id) -> MaybeLocal<WasmModuleObject> {
+	MaybeLocal<WasmModuleObject> result;
+	detail::RunBarrier([&]() {
+		result = WasmModuleObject::FromCompiledModule(isolate, wasm_modules[transfer_id]);
+	});
+	return result;
+}
+
+} // namespace ivm::detail

package/dist/node_modules/isolated-vm/src/external_copy/string.cc

@@ -0,0 +1,124 @@
+#include "isolate/environment.h"
+#include "./string.h"
+#include <cstring>
+
+using namespace v8;
+
+namespace ivm {
+namespace {
+
+/**
+ * Helper classes passed to v8 so we can reuse the same externally allocated memory for strings
+ * between different isolates
+ */
+class ExternalString final : public v8::String::ExternalStringResource {
+	public:
+		explicit ExternalString(std::shared_ptr<std::vector<char>> value) : value{std::move(value)} {
+			IsolateEnvironment::GetCurrent().AdjustExtraAllocatedMemory(this->value->size());
+		}
+
+		ExternalString(const ExternalString&) = delete;
+
+		~ExternalString() final {
+			auto* environment = Executor::GetCurrentEnvironment();
+			if (environment != nullptr) {
+				environment->AdjustExtraAllocatedMemory(-static_cast<int>(this->value->size()));
+			}
+		}
+
+		auto operator= (const ExternalString&) = delete;
+
+		auto data() const -> const uint16_t* final {
+			return reinterpret_cast<uint16_t*>(value->data());
+		}
+
+		auto length() const -> size_t final {
+			return value->size() >> 1;
+		}
+
+	private:
+		std::shared_ptr<std::vector<char>> value;
+};
+
+class ExternalStringOneByte final : public v8::String::ExternalOneByteStringResource {
+	public:
+		explicit ExternalStringOneByte(std::shared_ptr<std::vector<char>> value) : value{std::move(value)} {
+			IsolateEnvironment::GetCurrent().AdjustExtraAllocatedMemory(this->value->size());
+		}
+
+		ExternalStringOneByte(const ExternalStringOneByte&) = delete;
+
+		~ExternalStringOneByte() final {
+			auto* environment = Executor::GetCurrentEnvironment();
+			if (environment != nullptr) {
+				environment->AdjustExtraAllocatedMemory(-static_cast<int>(this->value->size()));
+			}
+		}
+
+		auto operator= (const ExternalStringOneByte&) = delete;
+
+		auto data() const -> const char* final {
+			return value->data();
+		}
+
+		auto length() const -> size_t final {
+			return value->size();
+		}
+
+	private:
+		std::shared_ptr<std::vector<char>> value;
+};
+
+} // anonymous namespace
+
+/**
+ * ExternalCopyString implementation
+ */
+ExternalCopyString::ExternalCopyString(Local<String> string) :
+		ExternalCopy{static_cast<int>((string->Length() << (string->IsOneByte() ? 0 : 1)) + sizeof(ExternalCopyString))} {
+	if (string->IsOneByte()) {
+		one_byte = true;
+		value = std::make_shared<std::vector<char>>(string->Length());
+		string->WriteOneByte(
+			Isolate::GetCurrent(),
+			reinterpret_cast<uint8_t*>(value->data()), 0, -1, String::WriteOptions::NO_NULL_TERMINATION
+		);
+	} else {
+		one_byte = false;
+		value = std::make_shared<std::vector<char>>(string->Length() << 1);
+		string->Write(
+			Isolate::GetCurrent(),
+			reinterpret_cast<uint16_t*>(value->data()), 0, -1, String::WriteOptions::NO_NULL_TERMINATION
+		);
+	}
+}
+
+ExternalCopyString::ExternalCopyString(const char* string) :
+	value{std::make_shared<std::vector<char>>(string, string + strlen(string))}, one_byte{true} {}
+
+ExternalCopyString::ExternalCopyString(const std::string& string) :
+	value{std::make_shared<std::vector<char>>(string.begin(), string.end())}, one_byte{true} {}
+
+auto ExternalCopyString::CopyInto(bool /*transfer_in*/) -> Local<Value> {
+	if (value->size() < 1024) {
+		// Strings under 1kb will be internal v8 strings. I didn't experiment with this at all, but it
+		// seems self-evident that there's some byte length under which it doesn't make sense to create
+		// an external string so I picked 1kb.
+		if (one_byte) {
+			return Unmaybe(String::NewFromOneByte(Isolate::GetCurrent(),
+				reinterpret_cast<uint8_t*>(value->data()), NewStringType::kNormal, value->size()));
+		} else {
+			return Unmaybe(String::NewFromTwoByte(Isolate::GetCurrent(),
+				reinterpret_cast<uint16_t*>(value->data()), NewStringType::kNormal, value->size() >> 1));
+		}
+	} else {
+		// External strings can save memory and/or copies
+		if (one_byte) {
+			return Unmaybe(String::NewExternalOneByte(Isolate::GetCurrent(), new ExternalStringOneByte(value)));
+		} else {
+			return Unmaybe(String::NewExternalTwoByte(Isolate::GetCurrent(), new ExternalString(value)));
+		}
+	}
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/external_copy/string.h

@@ -0,0 +1,28 @@
+#pragma once
+#include "external_copy.h"
+#include <memory>
+#include <vector>
+
+namespace ivm {
+
+class ExternalCopyString final : public ExternalCopy {
+	public:
+		ExternalCopyString() = default;
+		explicit ExternalCopyString(v8::Local<v8::String> string);
+		explicit ExternalCopyString(const char* string);
+		explicit ExternalCopyString(const std::string& string);
+		ExternalCopyString(const ExternalCopyString&) = delete;
+		ExternalCopyString(ExternalCopyString&& that) = default;
+		~ExternalCopyString() final = default;
+		auto operator= (const ExternalCopyString&) -> ExternalCopyString& = delete;
+		auto operator= (ExternalCopyString&& that) noexcept -> ExternalCopyString& = default;
+
+		explicit operator bool() const { return static_cast<bool>(value); }
+		auto CopyInto(bool transfer_in = false) -> v8::Local<v8::Value> final;
+
+	private:
+		std::shared_ptr<std::vector<char>> value;
+		bool one_byte = false;
+};
+
+} // namespace ivm

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

@@ -0,0 +1,32 @@
+#pragma once
+#include <v8.h>
+#include <memory>
+#include "v8_version.h"
+
+namespace ivm {
+
+class LimitedAllocator : public v8::ArrayBuffer::Allocator {
+	private:
+		class IsolateEnvironment& env;
+		size_t limit;
+		size_t v8_heap;
+		size_t next_check;
+		int failures = 0;
+
+
+	public:
+		auto Check(size_t length) -> bool;
+		explicit LimitedAllocator(class IsolateEnvironment& env, size_t limit);
+		auto Allocate(size_t length) -> void* final;
+		auto AllocateUninitialized(size_t length) -> void* final;
+		void Free(void* data, size_t length) final;
+		auto Reallocate(void* data, size_t old_length, size_t new_length) -> void* final;
+
+		// This is used by ExternalCopy when an ArrayBuffer is transferred. The memory is not freed but
+		// we should no longer count it against the isolate
+		void AdjustAllocatedSize(ptrdiff_t length);
+		auto GetFailureCount() const -> int;
+		void Track(v8::Local<v8::Object> handle, size_t size);
+};
+
+} // namespace ivm