@encharm/cws 4.4.1 → 4.5.2

package/src/headers/24/node_sqlite.h

@@ -0,0 +1,270 @@
+#ifndef SRC_NODE_SQLITE_H_
+#define SRC_NODE_SQLITE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object.h"
+#include "node_mem.h"
+#include "sqlite3.h"
+#include "util.h"
+
+#include <map>
+#include <unordered_set>
+
+namespace node {
+namespace sqlite {
+
+class DatabaseOpenConfiguration {
+ public:
+  explicit DatabaseOpenConfiguration(std::string&& location)
+      : location_(std::move(location)) {}
+
+  inline const std::string& location() const { return location_; }
+
+  inline bool get_read_only() const { return read_only_; }
+
+  inline void set_read_only(bool flag) { read_only_ = flag; }
+
+  inline bool get_enable_foreign_keys() const { return enable_foreign_keys_; }
+
+  inline void set_enable_foreign_keys(bool flag) {
+    enable_foreign_keys_ = flag;
+  }
+
+  inline bool get_enable_dqs() const { return enable_dqs_; }
+
+  inline void set_enable_dqs(bool flag) { enable_dqs_ = flag; }
+
+  inline void set_timeout(int timeout) { timeout_ = timeout; }
+
+  inline int get_timeout() { return timeout_; }
+
+  inline void set_use_big_ints(bool flag) { use_big_ints_ = flag; }
+
+  inline bool get_use_big_ints() const { return use_big_ints_; }
+
+  inline void set_return_arrays(bool flag) { return_arrays_ = flag; }
+
+  inline bool get_return_arrays() const { return return_arrays_; }
+
+  inline void set_allow_bare_named_params(bool flag) {
+    allow_bare_named_params_ = flag;
+  }
+
+  inline bool get_allow_bare_named_params() const {
+    return allow_bare_named_params_;
+  }
+
+  inline void set_allow_unknown_named_params(bool flag) {
+    allow_unknown_named_params_ = flag;
+  }
+
+  inline bool get_allow_unknown_named_params() const {
+    return allow_unknown_named_params_;
+  }
+
+ private:
+  std::string location_;
+  bool read_only_ = false;
+  bool enable_foreign_keys_ = true;
+  bool enable_dqs_ = false;
+  int timeout_ = 0;
+  bool use_big_ints_ = false;
+  bool return_arrays_ = false;
+  bool allow_bare_named_params_ = true;
+  bool allow_unknown_named_params_ = false;
+};
+
+class StatementSync;
+class BackupJob;
+
+class DatabaseSync : public BaseObject {
+ public:
+  DatabaseSync(Environment* env,
+               v8::Local<v8::Object> object,
+               DatabaseOpenConfiguration&& open_config,
+               bool open,
+               bool allow_load_extension);
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Open(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsOpenGetter(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsTransactionGetter(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Prepare(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Exec(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Location(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void CustomFunction(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void AggregateFunction(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void CreateSession(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void ApplyChangeset(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void EnableLoadExtension(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void LoadExtension(const v8::FunctionCallbackInfo<v8::Value>& args);
+  void FinalizeStatements();
+  void RemoveBackup(BackupJob* backup);
+  void AddBackup(BackupJob* backup);
+  void FinalizeBackups();
+  void UntrackStatement(StatementSync* statement);
+  bool IsOpen();
+  bool use_big_ints() const { return open_config_.get_use_big_ints(); }
+  bool return_arrays() const { return open_config_.get_return_arrays(); }
+  bool allow_bare_named_params() const {
+    return open_config_.get_allow_bare_named_params();
+  }
+  bool allow_unknown_named_params() const {
+    return open_config_.get_allow_unknown_named_params();
+  }
+  sqlite3* Connection();
+
+  // In some situations, such as when using custom functions, it is possible
+  // that SQLite reports an error while JavaScript already has a pending
+  // exception. In this case, the SQLite error should be ignored. These methods
+  // enable that use case.
+  void SetIgnoreNextSQLiteError(bool ignore);
+  bool ShouldIgnoreSQLiteError();
+
+  SET_MEMORY_INFO_NAME(DatabaseSync)
+  SET_SELF_SIZE(DatabaseSync)
+
+ private:
+  bool Open();
+  void DeleteSessions();
+
+  ~DatabaseSync() override;
+  DatabaseOpenConfiguration open_config_;
+  bool allow_load_extension_;
+  bool enable_load_extension_;
+  sqlite3* connection_;
+  bool ignore_next_sqlite_error_;
+
+  std::set<BackupJob*> backups_;
+  std::set<sqlite3_session*> sessions_;
+  std::unordered_set<StatementSync*> statements_;
+
+  friend class Session;
+};
+
+class StatementSync : public BaseObject {
+ public:
+  StatementSync(Environment* env,
+                v8::Local<v8::Object> object,
+                BaseObjectPtr<DatabaseSync> db,
+                sqlite3_stmt* stmt);
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static BaseObjectPtr<StatementSync> Create(Environment* env,
+                                             BaseObjectPtr<DatabaseSync> db,
+                                             sqlite3_stmt* stmt);
+  static void All(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Iterate(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Get(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Run(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Columns(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SourceSQLGetter(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void ExpandedSQLGetter(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetAllowBareNamedParameters(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetAllowUnknownNamedParameters(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetReadBigInts(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetReturnArrays(const v8::FunctionCallbackInfo<v8::Value>& args);
+  void Finalize();
+  bool IsFinalized();
+
+  SET_MEMORY_INFO_NAME(StatementSync)
+  SET_SELF_SIZE(StatementSync)
+
+ private:
+  ~StatementSync() override;
+  BaseObjectPtr<DatabaseSync> db_;
+  sqlite3_stmt* statement_;
+  bool return_arrays_ = false;
+  bool use_big_ints_;
+  bool allow_bare_named_params_;
+  bool allow_unknown_named_params_;
+  std::optional<std::map<std::string, std::string>> bare_named_params_;
+  bool BindParams(const v8::FunctionCallbackInfo<v8::Value>& args);
+  bool BindValue(const v8::Local<v8::Value>& value, const int index);
+  v8::MaybeLocal<v8::Value> ColumnToValue(const int column);
+  v8::MaybeLocal<v8::Name> ColumnNameToName(const int column);
+
+  friend class StatementSyncIterator;
+};
+
+class StatementSyncIterator : public BaseObject {
+ public:
+  StatementSyncIterator(Environment* env,
+                        v8::Local<v8::Object> object,
+                        BaseObjectPtr<StatementSync> stmt);
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static BaseObjectPtr<StatementSyncIterator> Create(
+      Environment* env, BaseObjectPtr<StatementSync> stmt);
+  static void Next(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Return(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  SET_MEMORY_INFO_NAME(StatementSyncIterator)
+  SET_SELF_SIZE(StatementSyncIterator)
+
+ private:
+  ~StatementSyncIterator() override;
+  BaseObjectPtr<StatementSync> stmt_;
+  bool done_;
+};
+
+using Sqlite3ChangesetGenFunc = int (*)(sqlite3_session*, int*, void**);
+
+class Session : public BaseObject {
+ public:
+  Session(Environment* env,
+          v8::Local<v8::Object> object,
+          BaseObjectWeakPtr<DatabaseSync> database,
+          sqlite3_session* session);
+  ~Session() override;
+  template <Sqlite3ChangesetGenFunc sqliteChangesetFunc>
+  static void Changeset(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static BaseObjectPtr<Session> Create(Environment* env,
+                                       BaseObjectWeakPtr<DatabaseSync> database,
+                                       sqlite3_session* session);
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(Session)
+  SET_SELF_SIZE(Session)
+
+ private:
+  void Delete();
+  sqlite3_session* session_;
+  BaseObjectWeakPtr<DatabaseSync> database_;  // The Parent Database
+};
+
+class UserDefinedFunction {
+ public:
+  UserDefinedFunction(Environment* env,
+                      v8::Local<v8::Function> fn,
+                      DatabaseSync* db,
+                      bool use_bigint_args);
+  ~UserDefinedFunction();
+  static void xFunc(sqlite3_context* ctx, int argc, sqlite3_value** argv);
+  static void xDestroy(void* self);
+
+ private:
+  Environment* env_;
+  v8::Global<v8::Function> fn_;
+  DatabaseSync* db_;
+  bool use_bigint_args_;
+};
+
+}  // namespace sqlite
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_NODE_SQLITE_H_

package/src/headers/{18 → 24}/node_stat_watcher.h

@@ -39,7 +39,8 @@ class ExternalReferenceRegistry;
 
 class StatWatcher : public HandleWrap {
  public:
-  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> ctor);
   static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 
  protected:

package/src/headers/24/node_string.h

@@ -0,0 +1,101 @@
+// Bridges V8 Inspector generated code with the std::string used by the Node
+// Compare to V8 counterpart - deps/v8/src/inspector/string-util.h
+#ifndef SRC_INSPECTOR_NODE_STRING_H_
+#define SRC_INSPECTOR_NODE_STRING_H_
+
+#include <cstring>
+#include <sstream>
+#include <string>
+#include "crdtp/protocol_core.h"
+#include "util.h"
+#include "v8-inspector.h"
+
+namespace node::inspector::protocol {
+class Binary;
+}
+
+namespace crdtp {
+
+template <>
+struct ProtocolTypeTraits<std::string> {
+  static bool Deserialize(DeserializerState* state, std::string* value);
+  static void Serialize(const std::string& value, std::vector<uint8_t>* bytes);
+};
+
+template <>
+struct ProtocolTypeTraits<node::inspector::protocol::Binary> {
+  static bool Deserialize(DeserializerState* state,
+                          node::inspector::protocol::Binary* value);
+  static void Serialize(const node::inspector::protocol::Binary& value,
+                        std::vector<uint8_t>* bytes);
+};
+
+}  // namespace crdtp
+
+namespace node {
+namespace inspector {
+namespace protocol {
+
+class Value;
+
+using String = std::string;
+using StringBuilder = std::ostringstream;
+using ProtocolMessage = std::string;
+
+// Implements StringUtil methods used in `inspector_protocol/lib/`.
+// Refer to
+// https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/inspector/v8_inspector_string.h;l=40;drc=2b15d6974a49d3a14d3d67ae099a649d523a828d
+// for more details about the interface.
+struct StringUtil {
+  // Convert Utf16 in local endianness to Utf8 if needed.
+  static String StringViewToUtf8(v8_inspector::StringView view);
+  static String fromUTF16(const uint16_t* data, size_t length);
+
+  static String fromUTF8(const uint8_t* data, size_t length);
+  static String fromUTF16LE(const uint16_t* data, size_t length);
+  static const uint8_t* CharactersUTF8(const std::string_view s);
+  static size_t CharacterCount(const std::string_view s);
+
+  // Unimplemented. The generated code will fall back to CharactersUTF8().
+  inline static uint8_t* CharactersLatin1(const std::string_view s) {
+    return nullptr;
+  }
+  inline static const uint16_t* CharactersUTF16(const std::string_view s) {
+    return nullptr;
+  }
+};
+
+// A read-only sequence of uninterpreted bytes with reference-counted storage.
+class Binary {
+ public:
+  Binary() : bytes_(std::make_shared<std::vector<uint8_t>>()) {}
+
+  const uint8_t* data() const { return bytes_->data(); }
+  size_t size() const { return bytes_->size(); }
+
+  String toBase64() const;
+
+  static Binary concat(const std::vector<Binary>& binaries);
+
+  static Binary fromBase64(const String& base64, bool* success);
+  static Binary fromUint8Array(v8::Local<v8::Uint8Array> data);
+  static Binary fromSpan(const uint8_t* data, size_t size) {
+    return Binary::fromSpan(crdtp::span<uint8_t>(data, size));
+  }
+  static Binary fromSpan(crdtp::span<uint8_t> span) {
+    return Binary(
+        std::make_shared<std::vector<uint8_t>>(span.begin(), span.end()));
+  }
+
+ private:
+  std::shared_ptr<std::vector<uint8_t>> bytes_;
+
+  explicit Binary(std::shared_ptr<std::vector<uint8_t>> bytes)
+      : bytes_(bytes) {}
+};
+
+}  // namespace protocol
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_NODE_STRING_H_

package/src/headers/24/node_task_runner.h

@@ -0,0 +1,92 @@
+#ifndef SRC_NODE_TASK_RUNNER_H_
+#define SRC_NODE_TASK_RUNNER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_internals.h"
+#include "simdjson.h"
+#include "spawn_sync.h"
+#include "uv.h"
+
+#include <filesystem>
+#include <optional>
+#include <string_view>
+#include <tuple>
+
+namespace node::task_runner {
+
+using PositionalArgs = std::vector<std::string_view>;
+
+// ProcessRunner is the class responsible for running a process.
+// A class instance is created for each process to be run.
+// The class is responsible for spawning the process and handling its exit.
+// The class also handles the environment variables and arguments.
+class ProcessRunner {
+ public:
+  ProcessRunner(std::shared_ptr<InitializationResultImpl> result,
+                const std::filesystem::path& package_json_path,
+                std::string_view script_name,
+                std::string_view command,
+                std::string_view path_env_var,
+                const PositionalArgs& positional_args);
+  void Run();
+  static void ExitCallback(uv_process_t* req,
+                           int64_t exit_status,
+                           int term_signal);
+
+ private:
+  uv_loop_t* loop_ = uv_default_loop();
+  uv_process_t process_{};
+  uv_process_options_t options_{};
+  uv_stdio_container_t child_stdio[3]{};
+  std::shared_ptr<InitializationResultImpl> init_result;
+  std::vector<std::string> command_args_{};
+  std::vector<std::string> env_vars_{};
+  std::unique_ptr<char* []> env {};  // memory for options_.env
+  std::unique_ptr<char* []> arg {};  // memory for options_.args
+  std::string cwd;
+
+  // OnExit is the callback function that is called when the process exits.
+  void OnExit(int64_t exit_status, int term_signal);
+  void SetEnvironmentVariables();
+
+#ifdef _WIN32
+  std::string file_ = "cmd.exe";
+#else
+  std::string file_ = "/bin/sh";
+#endif  // _WIN32
+
+  // Represents the absolute path to the package.json file.
+  std::filesystem::path package_json_path_;
+  // Represents the name of the script that is being run.
+  std::string script_name_;
+  // Represents PATH environment variable that contains
+  // all subdirectory paths appended with node_modules/.bin suffix.
+  std::string path_env_var_;
+};
+
+// This function traverses up to the root directory.
+// While traversing up, if it finds a package.json file, it reads its content.
+// If it cannot find a package.json file, it returns std::nullopt.
+// Otherwise, it returns a tuple of:
+// - the path to the package.json file
+// - package.json file content
+// - `path_env_var` variable
+//
+// For example, on POSIX, it returns the following for `path_env_var`,
+// if the current directory is `/anonrig`:
+// `/anonrig/node_modules/.bin:/node_modules/.bin`
+std::optional<std::tuple<std::filesystem::path, std::string, std::string>>
+FindPackageJson(const std::filesystem::path& cwd);
+
+void RunTask(const std::shared_ptr<InitializationResultImpl>& result,
+             std::string_view command_id,
+             const PositionalArgs& positional_args);
+PositionalArgs GetPositionalArgs(const std::vector<std::string>& args);
+std::string EscapeShell(std::string_view command);
+
+}  // namespace node::task_runner
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_TASK_RUNNER_H_

package/src/headers/24/node_threadsafe_cow-inl.h

@@ -0,0 +1,54 @@
+#ifndef SRC_NODE_THREADSAFE_COW_INL_H_
+#define SRC_NODE_THREADSAFE_COW_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+namespace node {
+
+template <typename T>
+T* CopyOnWrite<T>::write() {
+  if (data_.use_count() > 1l) {
+    data_ = std::make_shared<T>(*data_);
+  }
+  return data_.get();
+}
+
+template <typename T>
+ThreadsafeCopyOnWrite<T>::Read::Read(const ThreadsafeCopyOnWrite<T>* cow)
+    : cow_(cow), lock_(cow->impl_->mutex) {}
+
+template <typename T>
+const T& ThreadsafeCopyOnWrite<T>::Read::operator*() const {
+  return cow_->impl_->data;
+}
+
+template <typename T>
+const T* ThreadsafeCopyOnWrite<T>::Read::operator->() const {
+  return &cow_->impl_->data;
+}
+
+template <typename T>
+ThreadsafeCopyOnWrite<T>::Write::Write(ThreadsafeCopyOnWrite<T>* cow)
+    : cow_(cow), impl_(cow->impl_.write()), lock_(impl_->mutex) {}
+
+template <typename T>
+T& ThreadsafeCopyOnWrite<T>::Write::operator*() {
+  return impl_->data;
+}
+
+template <typename T>
+T* ThreadsafeCopyOnWrite<T>::Write::operator->() {
+  return &impl_->data;
+}
+
+template <typename T>
+ThreadsafeCopyOnWrite<T>::Impl::Impl(const Impl& other) {
+  RwLock::ScopedReadLock lock(other.mutex);
+  data = other.data;
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_THREADSAFE_COW_INL_H_

package/src/headers/24/node_threadsafe_cow.h

@@ -0,0 +1,105 @@
+#ifndef SRC_NODE_THREADSAFE_COW_H_
+#define SRC_NODE_THREADSAFE_COW_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "util.h"
+#include "uv.h"
+
+#include <memory>   // std::shared_ptr<T>
+#include <utility>  // std::forward<T>
+
+namespace node {
+
+// Copy-on-write utility. Not threadsafe, i.e. there is no synchronization
+// of the copy operation with other operations.
+template <typename T>
+class CopyOnWrite final {
+ public:
+  template <typename... Args>
+  explicit CopyOnWrite(Args&&... args)
+      : data_(std::make_shared<T>(std::forward<Args>(args)...)) {}
+
+  CopyOnWrite(const CopyOnWrite<T>& other) = default;
+  CopyOnWrite& operator=(const CopyOnWrite<T>& other) = default;
+  CopyOnWrite(CopyOnWrite<T>&& other) = default;
+  CopyOnWrite& operator=(CopyOnWrite<T>&& other) = default;
+
+  const T* read() const { return data_.get(); }
+  T* write();
+
+  const T& operator*() const { return *read(); }
+  const T* operator->() const { return read(); }
+
+ private:
+  std::shared_ptr<T> data_;
+};
+
+// Threadsafe copy-on-write utility. Consumers need to use the Read and
+// Write helpers to access the target data structure.
+template <typename T>
+class ThreadsafeCopyOnWrite final {
+ private:
+  // Define this early since some of the public members depend on it
+  // and some compilers need it to be defined first in that case.
+  struct Impl {
+    explicit Impl(const T& data) : data(data) {}
+    explicit Impl(T&& data) : data(std::move(data)) {}
+
+    Impl(const Impl& other);
+    Impl& operator=(const Impl& other) = delete;
+    Impl(Impl&& other) = delete;
+    Impl& operator=(Impl&& other) = delete;
+
+    RwLock mutex;
+    T data;
+  };
+
+ public:
+  template <typename... Args>
+  ThreadsafeCopyOnWrite(Args&&... args)
+      : impl_(T(std::forward<Args>(args)...)) {}
+
+  ThreadsafeCopyOnWrite(const ThreadsafeCopyOnWrite<T>& other) = default;
+  ThreadsafeCopyOnWrite& operator=(const ThreadsafeCopyOnWrite<T>& other) =
+      default;
+  ThreadsafeCopyOnWrite(ThreadsafeCopyOnWrite<T>&& other) = default;
+  ThreadsafeCopyOnWrite& operator=(ThreadsafeCopyOnWrite<T>&& other) = default;
+
+  class Read {
+   public:
+    explicit Read(const ThreadsafeCopyOnWrite<T>* cow);
+
+    const T& operator*() const;
+    const T* operator->() const;
+
+   private:
+    const ThreadsafeCopyOnWrite<T>* cow_;
+    RwLock::ScopedReadLock lock_;
+  };
+
+  class Write {
+   public:
+    explicit Write(ThreadsafeCopyOnWrite<T>* cow);
+
+    T& operator*();
+    T* operator->();
+
+   private:
+    ThreadsafeCopyOnWrite<T>* cow_;
+    typename ThreadsafeCopyOnWrite<T>::Impl* impl_;
+    RwLock::ScopedLock lock_;
+  };
+
+  Read read() const { return Read(this); }
+  Write write() { return Write(this); }
+
+ private:
+  CopyOnWrite<Impl> impl_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_THREADSAFE_COW_H_