@graphscope-neug/linux-x64 0.1.2

package/src/node_connection.cc

@@ -0,0 +1,114 @@
+/** Copyright 2020 Alibaba Group Holding Limited.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * 	http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "node_connection.h"
+
+#include <memory>
+#include <string>
+
+#include "neug/execution/common/params_map.h"
+#include "neug/main/neug_db.h"
+#include "neug/utils/exception/exception.h"
+#include "neug/utils/pb_utils.h"
+#include "neug/utils/yaml_utils.h"
+#include "node_query_request.h"
+
+#include <rapidjson/document.h>
+
+namespace neug {
+
+Napi::FunctionReference NodeConnection::constructor;
+
+Napi::Object NodeConnection::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func = DefineClass(
+      env, "NodeConnection",
+      {
+          InstanceMethod("execute", &NodeConnection::Execute),
+          InstanceMethod("getSchema", &NodeConnection::GetSchema),
+          InstanceMethod("close", &NodeConnection::Close),
+      });
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+  exports.Set("NodeConnection", func);
+  return exports;
+}
+
+NodeConnection::NodeConnection(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<NodeConnection>(info), db_(nullptr), conn_(nullptr) {}
+
+void NodeConnection::SetConnection(NeugDB* db,
+                                   std::shared_ptr<Connection> conn) {
+  db_ = db;
+  conn_ = std::move(conn);
+  if (!conn_) {
+    THROW_RUNTIME_ERROR("Connection is null");
+  }
+}
+
+Napi::Object NodeConnection::NewInstance(Napi::Env env, NeugDB& db,
+                                         std::shared_ptr<Connection> conn) {
+  Napi::Object obj = constructor.New({});
+  NodeConnection* wrapped = Napi::ObjectWrap<NodeConnection>::Unwrap(obj);
+  wrapped->SetConnection(&db, std::move(conn));
+  return obj;
+}
+
+Napi::Value NodeConnection::Execute(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsString()) {
+    Napi::TypeError::New(env, "Query string required")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::string query_string = info[0].As<Napi::String>().Utf8Value();
+  std::string access_mode = "";
+  if (info.Length() >= 2 && info[1].IsString()) {
+    access_mode = info[1].As<Napi::String>().Utf8Value();
+  }
+
+  // Parse parameters from JavaScript object
+  rapidjson::Document params_json;
+  if (info.Length() >= 3 && info[2].IsObject()) {
+    Napi::Object params_obj = info[2].As<Napi::Object>();
+    Napi::Array keys = params_obj.GetPropertyNames();
+    for (uint32_t i = 0; i < keys.Length(); ++i) {
+      std::string key = keys.Get(i).As<Napi::String>().Utf8Value();
+      Napi::Value value = params_obj.Get(key);
+      NodeParameterSerializer::SerializeParameter(params_json, key, value);
+    }
+  }
+
+  auto query_result = conn_->Query(query_string, access_mode, params_json);
+  if (!query_result) {
+    return NodeQueryResult::NewInstanceFromStatus(env, query_result.error());
+  }
+  return NodeQueryResult::NewInstance(env, std::move(query_result.value()));
+}
+
+Napi::Value NodeConnection::GetSchema(const Napi::CallbackInfo& info) {
+  return Napi::String::New(info.Env(), conn_->GetSchema());
+}
+
+Napi::Value NodeConnection::Close(const Napi::CallbackInfo& info) {
+  if (conn_) {
+    db_->RemoveConnection(conn_);
+    conn_.reset();
+  }
+  return info.Env().Undefined();
+}
+
+}  // namespace neug

package/src/node_connection.h

@@ -0,0 +1,55 @@
+/** Copyright 2020 Alibaba Group Holding Limited.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * 	http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TOOLS_NODEJS_BIND_SRC_NODE_CONNECTION_H_
+#define TOOLS_NODEJS_BIND_SRC_NODE_CONNECTION_H_
+
+#include <napi.h>
+
+#include <memory>
+#include <string>
+
+#include "neug/execution/common/types/value.h"
+#include "neug/main/connection.h"
+#include "neug/main/neug_db.h"
+#include "node_query_result.h"
+
+namespace neug {
+
+class NodeConnection : public Napi::ObjectWrap<NodeConnection> {
+ public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  static Napi::Object NewInstance(Napi::Env env, NeugDB& db,
+                                  std::shared_ptr<Connection> conn);
+
+  NodeConnection(const Napi::CallbackInfo& info);
+  ~NodeConnection() = default;
+
+  void SetConnection(NeugDB* db, std::shared_ptr<Connection> conn);
+
+ private:
+  static Napi::FunctionReference constructor;
+
+  Napi::Value Execute(const Napi::CallbackInfo& info);
+  Napi::Value GetSchema(const Napi::CallbackInfo& info);
+  Napi::Value Close(const Napi::CallbackInfo& info);
+
+  NeugDB* db_{nullptr};
+  std::shared_ptr<Connection> conn_;
+};
+
+}  // namespace neug
+
+#endif  // TOOLS_NODEJS_BIND_SRC_NODE_CONNECTION_H_

package/src/node_database.cc

@@ -0,0 +1,254 @@
+/** Copyright 2020 Alibaba Group Holding Limited.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * 	http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "node_database.h"
+
+#include <string>
+
+#include "neug/config.h"
+#include "neug/utils/exception/exception.h"
+
+namespace neug {
+
+Napi::FunctionReference NodeDatabase::constructor;
+
+Napi::Object NodeDatabase::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func = DefineClass(
+      env, "NodeDatabase",
+      {
+          InstanceMethod("connect", &NodeDatabase::Connect),
+          InstanceMethod("close", &NodeDatabase::Close),
+          InstanceMethod("serve", &NodeDatabase::Serve),
+          InstanceMethod("stopServing", &NodeDatabase::StopServing),
+      });
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+  exports.Set("NodeDatabase", func);
+  return exports;
+}
+
+NodeDatabase::NodeDatabase(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<NodeDatabase>(info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsObject()) {
+    Napi::TypeError::New(env, "Options object required")
+        .ThrowAsJavaScriptException();
+    return;
+  }
+
+  Napi::Object opts = info[0].As<Napi::Object>();
+
+  // Parse options
+  std::string database_path = "";
+  if (opts.Has("databasePath") && opts.Get("databasePath").IsString()) {
+    database_path = opts.Get("databasePath").As<Napi::String>().Utf8Value();
+  }
+
+  int32_t max_thread_num = 0;
+  if (opts.Has("maxThreadNum") && opts.Get("maxThreadNum").IsNumber()) {
+    max_thread_num = opts.Get("maxThreadNum").As<Napi::Number>().Int32Value();
+  }
+
+  std::string mode = "r";
+  if (opts.Has("mode") && opts.Get("mode").IsString()) {
+    mode = opts.Get("mode").As<Napi::String>().Utf8Value();
+  }
+
+  std::string planner = "gopt";
+  if (opts.Has("planner") && opts.Get("planner").IsString()) {
+    planner = opts.Get("planner").As<Napi::String>().Utf8Value();
+  }
+
+  bool checkpoint_on_close = true;
+  if (opts.Has("checkpointOnClose") && opts.Get("checkpointOnClose").IsBoolean()) {
+    checkpoint_on_close = opts.Get("checkpointOnClose").As<Napi::Boolean>().Value();
+  }
+
+  std::string buffer_strategy = "M_FULL";
+  if (opts.Has("bufferStrategy") && opts.Get("bufferStrategy").IsString()) {
+    buffer_strategy = opts.Get("bufferStrategy").As<Napi::String>().Utf8Value();
+  }
+
+  // Parse mode
+  neug::DBMode mode_;
+  if (mode == "read" || mode == "r" || mode == "read-only" ||
+      mode == "read_only") {
+    mode_ = DBMode::READ_ONLY;
+  } else if (mode == "read_write" || mode == "rw" || mode == "w" ||
+             mode == "wr" || mode == "write" || mode == "readwrite" ||
+             mode == "read-write") {
+    mode_ = DBMode::READ_WRITE;
+  } else {
+    Napi::Error::New(env, "Invalid mode: " + mode)
+        .ThrowAsJavaScriptException();
+    return;
+  }
+
+  db_dir_ = database_path;
+  database = std::make_unique<NeugDB>();
+  NeugDBConfig config(db_dir_, max_thread_num);
+  config.mode = mode_;
+  config.planner_kind = planner;
+  config.checkpoint_on_close = checkpoint_on_close;
+  try {
+    config.memory_level = ParseBufferStrategy(buffer_strategy);
+    database->Open(config);
+  } catch (const neug::exception::Exception& e) {
+    Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+    database.reset();
+    return;
+  } catch (const std::exception& e) {
+    Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+    database.reset();
+    return;
+  }
+}
+
+NodeDatabase::~NodeDatabase() {
+  std::lock_guard<std::recursive_mutex> lock(mtx_);
+#ifdef BUILD_HTTP_SERVER
+  if (service_) {
+    service_->Stop();
+    service_.reset();
+  }
+#endif
+  if (database) {
+    database->Close();
+    database.reset();
+  }
+}
+
+Napi::Value NodeDatabase::Connect(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (!database) {
+    Napi::Error::New(env, "Database is not initialized.")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  try {
+    auto conn = database->Connect();
+    return NodeConnection::NewInstance(env, *database, conn);
+  } catch (const neug::exception::Exception& e) {
+    Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+    return env.Null();
+  } catch (const std::exception& e) {
+    Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+}
+
+Napi::Value NodeDatabase::Close(const Napi::CallbackInfo& info) {
+  std::lock_guard<std::recursive_mutex> lock(mtx_);
+#ifdef BUILD_HTTP_SERVER
+  if (service_) {
+    service_->Stop();
+    service_.reset();
+  }
+#endif
+  if (database) {
+    database->Close();
+    database.reset();
+  }
+  return info.Env().Undefined();
+}
+
+Napi::Value NodeDatabase::Serve(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+#ifdef BUILD_HTTP_SERVER
+  if (!database) {
+    Napi::Error::New(env, "Database is not initialized.")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  if (service_) {
+    Napi::Error::New(env, "Server is already running.")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  int port = 10000;
+  std::string host = "localhost";
+  int32_t num_thread = 0;
+  bool blocking = false;
+
+  if (info.Length() >= 1 && info[0].IsNumber()) {
+    port = info[0].As<Napi::Number>().Int32Value();
+  }
+  if (info.Length() >= 2 && info[1].IsString()) {
+    host = info[1].As<Napi::String>().Utf8Value();
+  }
+  if (info.Length() >= 3 && info[2].IsNumber()) {
+    num_thread = info[2].As<Napi::Number>().Int32Value();
+  }
+  if (info.Length() >= 4 && info[3].IsBoolean()) {
+    blocking = info[3].As<Napi::Boolean>().Value();
+  }
+
+  std::lock_guard<std::recursive_mutex> lock(mtx_);
+  database->Close();
+  database->Open(database->config());
+
+  neug::ServiceConfig config;
+  config.query_port = port;
+  config.host_str = host;
+  config.shard_num =
+      (num_thread == 0) ? std::thread::hardware_concurrency() : num_thread;
+#ifdef __APPLE__
+  if (host == "localhost") {
+    config.host_str = "127.0.0.1";
+  }
+#endif
+
+  service_ = std::make_unique<neug::NeugDBService>(*database, config);
+  if (blocking) {
+    service_->run_and_wait_for_exit();
+    return Napi::String::New(env, "");
+  }
+  return Napi::String::New(env, service_->Start());
+#else
+  Napi::Error::New(env, "HTTP server is not enabled in this build.")
+      .ThrowAsJavaScriptException();
+  return env.Null();
+#endif
+}
+
+Napi::Value NodeDatabase::StopServing(const Napi::CallbackInfo& info) {
+  std::lock_guard<std::recursive_mutex> lock(mtx_);
+#ifdef BUILD_HTTP_SERVER
+  if (service_) {
+    service_->Stop();
+    service_.reset();
+  }
+#endif
+  return info.Env().Undefined();
+}
+
+MemoryLevel NodeDatabase::ParseBufferStrategy(const std::string& level) {
+  if (level == "InMemory" || level == "inmemory" || level == "in_memory" ||
+      level == "M_FULL") {
+    return MemoryLevel::kInMemory;
+  } else if (level == "SyncToFile" || level == "synctofile" ||
+             level == "sync_to_file" || level == "M_LAZY") {
+    return MemoryLevel::kSyncToFile;
+  } else if (level == "HugePagePreferred" || level == "hugepagepreferred" ||
+             level == "huge_page_preferred" || level == "M_HUGE") {
+    return MemoryLevel::kHugePagePreferred;
+  } else {
+    THROW_INVALID_ARGUMENT_EXCEPTION("Invalid memory level: " + level);
+  }
+}
+
+}  // namespace neug

package/src/node_database.h

@@ -0,0 +1,60 @@
+/** Copyright 2020 Alibaba Group Holding Limited.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * 	http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TOOLS_NODEJS_BIND_SRC_NODE_DATABASE_H_
+#define TOOLS_NODEJS_BIND_SRC_NODE_DATABASE_H_
+
+#include <napi.h>
+
+#include <memory>
+#include <mutex>
+#include <string>
+
+#include "neug/main/neug_db.h"
+#ifdef BUILD_HTTP_SERVER
+#include "neug/server/neug_db_service.h"
+#endif
+#include "node_connection.h"
+
+namespace neug {
+
+class NodeDatabase : public Napi::ObjectWrap<NodeDatabase> {
+ public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+  NodeDatabase(const Napi::CallbackInfo& info);
+  ~NodeDatabase();
+
+  Napi::Value Connect(const Napi::CallbackInfo& info);
+  Napi::Value Close(const Napi::CallbackInfo& info);
+  Napi::Value Serve(const Napi::CallbackInfo& info);
+  Napi::Value StopServing(const Napi::CallbackInfo& info);
+
+ private:
+  static Napi::FunctionReference constructor;
+
+  MemoryLevel ParseBufferStrategy(const std::string& level);
+
+  std::recursive_mutex mtx_;
+  std::string db_dir_;
+  std::unique_ptr<NeugDB> database;
+#ifdef BUILD_HTTP_SERVER
+  std::unique_ptr<NeugDBService> service_;
+#endif
+};
+
+}  // namespace neug
+
+#endif  // TOOLS_NODEJS_BIND_SRC_NODE_DATABASE_H_

package/src/node_query_request.cc

@@ -0,0 +1,162 @@
+/** Copyright 2020 Alibaba Group Holding Limited.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * 	http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "node_query_request.h"
+
+#include <sstream>
+#include <string>
+
+#include "neug/execution/common/types/value.h"
+#include "neug/main/query_request.h"
+#include "neug/utils/access_mode.h"
+#include "neug/utils/exception/exception.h"
+#include "neug/utils/property/types.h"
+#include "neug/utils/serialization/in_archive.h"
+
+#include <rapidjson/document.h>
+#include <rapidjson/stringbuffer.h>
+#include <rapidjson/writer.h>
+
+namespace neug {
+
+Napi::FunctionReference NodeQueryRequest::constructor;
+
+rapidjson::Document napi_value_to_rapidjson_document(
+    const Napi::Value& val, rapidjson::Document::AllocatorType& allocator) {
+  rapidjson::Document doc(&allocator);
+
+  if (val.IsNull() || val.IsUndefined()) {
+    doc.SetNull();
+  } else if (val.IsBoolean()) {
+    doc.SetBool(val.As<Napi::Boolean>().Value());
+  } else if (val.IsNumber()) {
+    Napi::Number num = val.As<Napi::Number>();
+    double d = num.DoubleValue();
+    // Check if it's an integer
+    if (d == static_cast<double>(static_cast<int64_t>(d))) {
+      doc.SetInt64(static_cast<int64_t>(d));
+    } else {
+      doc.SetDouble(d);
+    }
+  } else if (val.IsString()) {
+    std::string s = val.As<Napi::String>().Utf8Value();
+    doc.SetString(s.c_str(), s.length(), allocator);
+  } else if (val.IsArray()) {
+    Napi::Array arr = val.As<Napi::Array>();
+    doc.SetArray();
+    for (uint32_t i = 0; i < arr.Length(); ++i) {
+      rapidjson::Document element_doc =
+          napi_value_to_rapidjson_document(arr.Get(i), allocator);
+      doc.PushBack(element_doc, allocator);
+    }
+  } else if (val.IsDate()) {
+    // Convert Date to ISO string
+    Napi::Object date_obj = val.As<Napi::Object>();
+    Napi::Function to_iso =
+        date_obj.Get("toISOString").As<Napi::Function>();
+    std::string iso_str =
+        to_iso.Call(date_obj, {}).As<Napi::String>().Utf8Value();
+    doc.SetString(iso_str.c_str(), iso_str.length(), allocator);
+  } else if (val.IsObject()) {
+    // Serialize plain object as JSON object
+    Napi::Object obj = val.As<Napi::Object>();
+    Napi::Array keys = obj.GetPropertyNames();
+    doc.SetObject();
+    for (uint32_t i = 0; i < keys.Length(); ++i) {
+      std::string key = keys.Get(i).As<Napi::String>().Utf8Value();
+      rapidjson::Document val_doc =
+          napi_value_to_rapidjson_document(obj.Get(key), allocator);
+      rapidjson::Value json_key;
+      json_key.SetString(key.c_str(), key.length(), allocator);
+      doc.AddMember(json_key, val_doc, allocator);
+    }
+  } else {
+    throw std::invalid_argument(
+        "Unsupported parameter type for serialization.");
+  }
+  return doc;
+}
+
+void NodeParameterSerializer::SerializeParameter(rapidjson::Document& doc,
+                                                 const std::string& key,
+                                                 const Napi::Value& parameter) {
+  if (doc.IsNull()) {
+    doc.SetObject();
+  }
+  auto& allocator = doc.GetAllocator();
+  rapidjson::Value json_key;
+  json_key.SetString(key.c_str(), key.length(), allocator);
+  rapidjson::Document json_value =
+      napi_value_to_rapidjson_document(parameter, allocator);
+  doc.AddMember(json_key, json_value, allocator);
+}
+
+Napi::Object NodeQueryRequest::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func = DefineClass(
+      env, "NodeQueryRequest",
+      {
+          StaticMethod("serializeRequest", &NodeQueryRequest::SerializeRequest),
+      });
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+  exports.Set("NodeQueryRequest", func);
+  return exports;
+}
+
+NodeQueryRequest::NodeQueryRequest(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<NodeQueryRequest>(info) {}
+
+Napi::Value NodeQueryRequest::SerializeRequest(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsString()) {
+    Napi::TypeError::New(env, "Query string required")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::string query = info[0].As<Napi::String>().Utf8Value();
+  std::string access_mode = "update";
+  if (info.Length() >= 2 && info[1].IsString()) {
+    access_mode = info[1].As<Napi::String>().Utf8Value();
+  }
+
+  rapidjson::Document req_doc(rapidjson::kObjectType);
+  auto& allocator = req_doc.GetAllocator();
+  req_doc.AddMember("query", rapidjson::Value(query.c_str(), allocator),
+                    allocator);
+  req_doc.AddMember("access_mode",
+                    rapidjson::Value(access_mode.c_str(), allocator),
+                    allocator);
+
+  rapidjson::Document params_doc;
+  if (info.Length() >= 3 && info[2].IsObject()) {
+    Napi::Object params_obj = info[2].As<Napi::Object>();
+    Napi::Array keys = params_obj.GetPropertyNames();
+    for (uint32_t i = 0; i < keys.Length(); ++i) {
+      std::string key = keys.Get(i).As<Napi::String>().Utf8Value();
+      NodeParameterSerializer::SerializeParameter(params_doc, key,
+                                                  params_obj.Get(key));
+    }
+  }
+  req_doc.AddMember("parameters", params_doc, allocator);
+
+  rapidjson::StringBuffer buffer;
+  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
+  req_doc.Accept(writer);
+  return Napi::String::New(env, buffer.GetString());
+}
+
+}  // namespace neug

package/src/node_query_request.h

@@ -0,0 +1,47 @@
+/** Copyright 2020 Alibaba Group Holding Limited.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * 	http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <napi.h>
+
+#include <string>
+
+#include <rapidjson/document.h>
+
+namespace neug {
+
+/**
+ * A helper struct for serializing parameters from NAPI objects to JSON strings.
+ */
+struct NodeParameterSerializer {
+  static void SerializeParameter(rapidjson::Document& doc,
+                                 const std::string& key,
+                                 const Napi::Value& parameter);
+};
+
+class NodeQueryRequest : public Napi::ObjectWrap<NodeQueryRequest> {
+ public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+  NodeQueryRequest(const Napi::CallbackInfo& info);
+
+ private:
+  static Napi::FunctionReference constructor;
+
+  static Napi::Value SerializeRequest(const Napi::CallbackInfo& info);
+};
+
+}  // namespace neug