@graphscope-neug/osx-arm64 0.1.3-alpha.1 → 0.2.0

package/CMakeLists.txt

@@ -60,9 +60,6 @@ target_include_directories(neug_node_bind PRIVATE
 add_dependencies(neug_node_bind neug_proto)
 
 set(NEUG_LIBRARIES neug)
-if (BUILD_HTTP_SERVER)
-    set(NEUG_LIBRARIES ${NEUG_LIBRARIES})
-endif()
 
 find_package(OpenSSL REQUIRED)
 target_link_libraries(neug_node_bind PRIVATE
@@ -96,16 +93,19 @@ if (APPLE)
 endif()
 
 # Set RPATH so neug_node_bind.node can find libneug.so / libneug.dylib
-# in the same directory (prebuilds/<platform>/). This is essential for
-# npm-distributed packages where the shared lib is bundled alongside the .node file.
-if (APPLE)
-  set_target_properties(neug_node_bind PROPERTIES
-    INSTALL_RPATH "@loader_path"
-    BUILD_WITH_INSTALL_RPATH TRUE
-  )
+# in the same directory (build/Release/<platform>/). Package builds retain
+# CMake's build-tree RPATHs until dependencies are bundled. Those paths identify
+# the exact libraries selected by the linker; the platform bundle step copies them
+# into the package and replaces non-portable RPATHs before npm pack runs.
+if(APPLE)
+  set(_neug_node_rpath "@loader_path")
 else()
-  set_target_properties(neug_node_bind PROPERTIES
-    INSTALL_RPATH "$ORIGIN"
-    BUILD_WITH_INSTALL_RPATH TRUE
-  )
+  set(_neug_node_rpath "$ORIGIN")
 endif()
+
+set_target_properties(neug_node_bind PROPERTIES
+  BUILD_RPATH "${_neug_node_rpath}"
+  INSTALL_RPATH "${_neug_node_rpath}"
+  BUILD_WITH_INSTALL_RPATH FALSE
+)
+set_property(TARGET neug APPEND PROPERTY BUILD_RPATH "${_neug_node_rpath}")

package/README.md

@@ -4,11 +4,26 @@
 
 Same system dependencies as NeuG (CMake >= 3.16, C++20 compiler), plus:
 
-- Node.js >= 18.0.0
+- Node.js >= 20.0.0
+- macOS package builds only: `delocate==0.13.0`
+- Linux package builds only: `ldd` and `patchelf==0.19.0`
+
+Install the macOS packaging dependency with:
+
+```bash
+python3 -m pip install delocate==0.13.0
+```
+
+On Linux, install `patchelf==0.19.0` from the system package manager or the
+[official releases](https://github.com/NixOS/patchelf/releases):
+
+```bash
+patchelf --version
+```
 
 ### Installing Node.js
 
-NeuG Node.js bindings require **Node.js >= 18.0.0** (N-API v8). Install via nvm:
+NeuG Node.js bindings require **Node.js >= 20.0.0** (N-API v8). Install via nvm:
 
 ```bash
 # Install nvm
@@ -21,11 +36,11 @@ source ~/.zshrc
 
 # Install Node.js LTS (v22)
 nvm install --lts && nvm use --lts
-# Or install a specific version (>= 18)
-nvm install 18 && nvm use 18
+# Or install a specific version (>= 20)
+nvm install 20 && nvm use 20
 
 # Verify
-node -v   # should be >= 18.0.0
+node -v   # should be >= 20.0.0
 npm -v
 ```
 
@@ -43,7 +58,6 @@ This will:
 2. Build the native addon via the main NeuG CMake project (`-DBUILD_NODEJS=ON`)
 3. Copy the resulting `neug_node_bind.node` to `build/Release/`
 
-
 ### Pack
 
 ```bash
@@ -53,16 +67,26 @@ make pack
 Create a self-contained, distributable npm package tarball (`.tgz`). This will:
 
 1. Build the native addon (same as `make build`)
-2. Copy prebuilt binaries into `prebuilds/<platform>/`:
+2. Copy NeuG's first-party binaries into `build/Release/<platform>/`:
    - `neug_node_bind.node` — the native addon
-   - `libneug.so` — core shared library
-   - `libmimalloc.so.2` — memory allocator
-3. Run `npm pack` to produce `neug-<version>.tgz`
+   - `libneug.so` / `libneug.dylib` — core shared library
+3. Collect the third-party libraries actually selected at link time:
+   - macOS uses `delocate-path` to copy them into `.dylibs/` and rewrite their
+     install names.
+   - Linux uses `ldd` to resolve the dependency closure, copies non-system
+     libraries into `.libs/`, and uses `patchelf` to set package-relative
+     `$ORIGIN` RPATHs.
+4. Print the bundled native dependencies for inspection.
+5. Run `npm pack` to produce `neug-<version>.tgz`
+
+Npm package builds always force `NEUG_PACKAGE_BUILD=ON` and
+`NEUG_NATIVE_ARCH=OFF`.
+For local source builds, use `NEUG_NATIVE_ARCH=ON make dev`.
 
 The resulting tarball can be installed without a C++ build environment:
 
 ```bash
-npm install ./neug-0.1.2.tgz
+npm install ./neug-0.2.0.tgz
 ```
 
  
@@ -83,7 +107,7 @@ node example.js
 
 
 ```js
-const { Database } = require('./lib');
+const { Database } = require('neug');
 
 // Open an in-memory database
 const db = new Database({ databasePath: '', mode: 'w' });
@@ -114,3 +138,30 @@ for (const row of result) {
 conn.close();
 db.close();
 ```
+
+## Explicit Transactions
+
+Since v0.2, the embedded Node.js `Connection` API supports explicit AP
+transactions. Auto-commit remains the default; begin a transaction only when
+multiple ordinary queries must share one private view and one final commit.
+
+```js
+const conn = db.connect();
+
+conn.beginTransaction();
+conn.execute("CREATE (p:person {id: 3, name: 'Carol'});");
+// Reads on this connection see the new vertex before publication.
+conn.execute('MATCH (p:person) RETURN p.name;');
+conn.commit();
+
+conn.beginTransaction({ readOnly: true });
+// This transaction pins one read view and rejects writes.
+conn.execute('MATCH (p:person) RETURN p.name;');
+conn.rollback();
+```
+
+`hasActiveTransaction` remains true after a failed statement because the
+connection is rollback-only. Call `rollback()` before issuing another query.
+Nested transactions, read-to-write upgrades, Cypher `BEGIN`/`COMMIT`/`ROLLBACK`,
+and explicit-transaction COPY, batch, index, checkpoint, procedure, and
+temporary-schema operations are not supported.

package/lib/connection.js

@@ -59,6 +59,64 @@ class Connection {
     }
   }
 
+  /**
+   * Whether this connection has an unfinished explicit transaction.
+   *
+   * The property remains true while a failed transaction is rollback-only.
+   * Call {@link rollback} before issuing another query.
+   *
+   * @returns {boolean}
+   */
+  get hasActiveTransaction() {
+    return this._isOpen && this._conn.hasActiveTransaction();
+  }
+
+  /**
+   * Begin an explicit embedded AP transaction.
+   *
+   * @param {{readOnly?: boolean}} [options={}] Transaction options.
+   * @param {boolean} [options.readOnly=false] Pin one read view and reject
+   *   writes. By default, the transaction uses a private COW write view.
+   * @throws {Error} If the connection is closed or already has an active
+   *   transaction.
+   */
+  beginTransaction(options = {}) {
+    this._ensureOpen('beginning a transaction');
+    if (
+      typeof options !== 'object' ||
+      options === null ||
+      Array.isArray(options)
+    ) {
+      throw new TypeError('Transaction options must be an object.');
+    }
+    const { readOnly = false } = options;
+    if (typeof readOnly !== 'boolean') {
+      throw new TypeError('options.readOnly must be a boolean.');
+    }
+    this._checkTransactionStatus(
+      'begin transaction',
+      this._conn.beginTransaction(readOnly)
+    );
+  }
+
+  /**
+   * Commit the active explicit transaction.
+   *
+   * A rollback-only transaction must be rolled back instead.
+   */
+  commit() {
+    this._ensureOpen('committing a transaction');
+    this._checkTransactionStatus('commit transaction', this._conn.commit());
+  }
+
+  /**
+   * Roll back the active explicit transaction and return to auto-commit mode.
+   */
+  rollback() {
+    this._ensureOpen('rolling back a transaction');
+    this._checkTransactionStatus('roll back transaction', this._conn.rollback());
+  }
+
   /**
    * Execute a cypher query on the database.
    *
@@ -81,12 +139,7 @@ class Connection {
    * );
    */
   execute(query, accessMode = '', parameters = null) {
-    if (!this._isOpen) {
-      throw new Error(
-        `Connection is closed. Please open the connection before executing queries. ` +
-        `Error code: ${ERR_CONNECTION_CLOSED}`
-      );
-    }
+    this._ensureOpen('executing queries');
 
     if (accessMode !== '' && !isAccessModeValid(accessMode.toLowerCase())) {
       throw new Error(
@@ -120,8 +173,27 @@ class Connection {
    * @returns {string} The schema as a string.
    */
   getSchema() {
+    this._ensureOpen('getting the schema');
     return this._conn.getSchema();
   }
+
+  _ensureOpen(action) {
+    if (!this._isOpen) {
+      throw new Error(
+        `Connection is closed. Please open the connection before ${action}. ` +
+        `Error code: ${ERR_CONNECTION_CLOSED}`
+      );
+    }
+  }
+
+  _checkTransactionStatus(action, status) {
+    if (status.code !== OK) {
+      throw new Error(
+        `Failed to ${action}. Error code: ${status.code}, Error Message: ` +
+        `${codeName(status.code)}: ${status.message}`
+      );
+    }
+  }
 }
 
 module.exports = { Connection };

package/lib/database.js

@@ -91,7 +91,6 @@ class Database {
 
     this._connections = [];
     this._asyncConnections = [];
-    this._serving = false;
 
     // Validate path
     const dbPath = databasePath !== null ? databasePath : '';
@@ -187,17 +186,12 @@ class Database {
    * Connect to the database and return a Connection object.
    *
    * @returns {Connection} A connection to the database.
-   * @throws {Error} If the database is closed or serving.
+   * @throws {Error} If the database is closed.
    */
   connect() {
     if (!this._database) {
       throw new Error('Database is closed.');
     }
-    if (this._serving) {
-      throw new Error(
-        'Cannot create connection while the database server is running.'
-      );
-    }
     const nativeConn = this._database.connect();
     const conn = new Connection(nativeConn);
     this._connections.push(conn);
@@ -208,79 +202,18 @@ class Database {
    * Connect to the database asynchronously.
    *
    * @returns {AsyncConnection} An async connection to the database.
-   * @throws {Error} If the database is closed or serving.
+   * @throws {Error} If the database is closed.
    */
   asyncConnect() {
     if (!this._database) {
       throw new Error('Database is closed.');
     }
-    if (this._serving) {
-      throw new Error(
-        'Cannot create async connection while the database server is running.'
-      );
-    }
     const nativeConn = this._database.connect();
     const asyncConn = new AsyncConnection(nativeConn);
     this._asyncConnections.push(asyncConn);
     return asyncConn;
   }
 
-  /**
-   * Start the database server for handling remote connections (TP mode).
-   *
-   * @param {Object} [options] - Server options.
-   * @param {number} [options.port=10000] - The port to listen on.
-   * @param {string} [options.host='localhost'] - The host to bind to.
-   * @param {boolean} [options.blocking=true] - Whether to block until server stops.
-   * @returns {string} The URI of the server.
-   */
-  serve(options = {}) {
-    const { port = 10000, host = 'localhost', blocking = true } = options;
-
-    // Check all connections are closed
-    for (const conn of this._connections) {
-      if (conn && conn.isOpen) {
-        throw new Error(
-          'Cannot start the server while there are open connections to the local database.'
-        );
-      }
-    }
-    for (const asyncConn of this._asyncConnections) {
-      if (asyncConn && asyncConn.isOpen) {
-        throw new Error(
-          'Cannot start the server while there are open async connections to the local database.'
-        );
-      }
-    }
-
-    if (this._serving) {
-      console.log('[neug] Database server is already running.');
-      return;
-    }
-    this._serving = true;
-    console.log(`[neug] Starting database server on ${host}:${port}.`);
-
-    try {
-      return this._database.serve(port, host, this._maxThreadNum, blocking);
-    } catch (e) {
-      this._serving = false;
-      throw e;
-    }
-  }
-
-  /**
-   * Stop the database server.
-   * @throws {Error} If the server is not running.
-   */
-  stopServing() {
-    if (!this._serving) {
-      throw new Error('Database server is not running.');
-    }
-    console.log('[neug] Stopping database server.');
-    this._database.stopServing();
-    this._serving = false;
-  }
-
   /**
    * Close the database connection and release all resources.
    */

package/lib/error-codes.js

@@ -29,7 +29,7 @@
 const { Code } = require('./proto/error_pb');
 
 // ---- Numeric error code constants (from error.proto Code enum) ----
-// General errors (1001-1017)
+// General errors (1001-1018)
 const OK                    = Code.OK;
 const ERR_PERMISSION        = Code.ERR_PERMISSION;
 const ERR_VERSION_MISMATCHED = Code.ERR_VERSION_MISMATCHED;
@@ -48,6 +48,7 @@ const ERR_IO_ERROR          = Code.ERR_IO_ERROR;
 const ERR_BAD_ENCODING      = Code.ERR_BAD_ENCODING;
 const ERR_INVALID_FILE      = Code.ERR_INVALID_FILE;
 const ERR_EXTENSION         = Code.ERR_EXTENSION;
+const ERR_NO_CHECKPOINT     = Code.ERR_NO_CHECKPOINT;
 
 // Network errors (2001-2007)
 const ERR_NETWORK           = Code.ERR_NETWORK;
@@ -122,6 +123,7 @@ module.exports = {
   ERR_BAD_ENCODING,
   ERR_INVALID_FILE,
   ERR_EXTENSION,
+  ERR_NO_CHECKPOINT,
   // Network errors
   ERR_NETWORK,
   ERR_SESSION_CLOSED,

package/lib/index.js

@@ -46,7 +46,6 @@ const { Database } = require('./database');
 const { Connection } = require('./connection');
 const { AsyncConnection } = require('./async-connection');
 const { QueryResult } = require('./query-result');
-const { Session } = require('./session');
 const { parseAndFormatResults, printResultsAsTable, parseEntry } = require('./format');
 const { version } = require('./version');
 const errorCodes = require('./error-codes');
@@ -56,7 +55,6 @@ module.exports = {
   Connection,
   AsyncConnection,
   QueryResult,
-  Session,
   parseAndFormatResults,
   printResultsAsTable,
   parseEntry,

package/lib/proto/error_pb.js

@@ -39,6 +39,7 @@ const Code = Object.create(
     [1015, 'ERR_BAD_ENCODING'],
     [1016, 'ERR_INVALID_FILE'],
     [1017, 'ERR_EXTENSION'],
+    [1018, 'ERR_NO_CHECKPOINT'],
     [2001, 'ERR_NETWORK'],
     [2002, 'ERR_SESSION_CLOSED'],
     [2003, 'ERR_CONNECTION_CLOSED'],
@@ -90,6 +91,7 @@ Code.ERR_IO_ERROR             = 1014;
 Code.ERR_BAD_ENCODING         = 1015;
 Code.ERR_INVALID_FILE         = 1016;
 Code.ERR_EXTENSION            = 1017;
+Code.ERR_NO_CHECKPOINT        = 1018;
 Code.ERR_NETWORK              = 2001;
 Code.ERR_SESSION_CLOSED       = 2002;
 Code.ERR_CONNECTION_CLOSED    = 2003;

package/lib/query-result.js

@@ -106,6 +106,18 @@ class QueryResult {
     this._result.close();
   }
 
+  /**
+   * Get the profile/explain result as a structured metrics object.
+   * @returns {{ total_elapsed_ms: number, total_output_rows: number, operators: Array }} Metrics object.
+   */
+  getProfileMetrics() {
+    const metrics = this._result.getProfileMetrics();
+    if (!metrics.operators) {
+      metrics.operators = [];
+    }
+    return metrics;
+  }
+
   /**
    * Make QueryResult iterable with for...of loops.
    * @returns {Iterator} An iterator over the result rows.

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@graphscope-neug/osx-arm64",
-  "version": "0.1.3-alpha.1",
+  "version": "0.2.0",
   "description": "NeuG Graph Database Node.js bindings - high performance embedded graph database with Cypher query support",
   "main": "lib/index.js",
+  "exports": "./lib/index.js",
   "scripts": {
-    "test": "for f in tests/test_*.js; do echo \"Running $f\"; node \"$f\" || exit 1; done"
+    "test": "node tests/test-shim.js"
   },
   "keywords": [
     "graph",
@@ -23,7 +24,7 @@
     "url": "git+https://github.com/alibaba/neug.git"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=20.0.0"
   },
   "dependencies": {
     "node-addon-api": "^7.0.0"

package/src/node_connection.cc

@@ -29,6 +29,21 @@
 
 namespace neug {
 
+namespace {
+
+Napi::Object StatusToJs(Napi::Env env, const Status& status) {
+  auto result = Napi::Object::New(env);
+  result.Set("code", Napi::Number::New(env, status.error_code()));
+  result.Set("message", Napi::String::New(env, status.error_message()));
+  return result;
+}
+
+Status ClosedConnectionStatus() {
+  return Status(StatusCode::ERR_CONNECTION_CLOSED, "Connection is closed.");
+}
+
+}  // namespace
+
 Napi::FunctionReference NodeConnection::constructor;
 
 Napi::Object NodeConnection::Init(Napi::Env env, Napi::Object exports) {
@@ -36,6 +51,11 @@ Napi::Object NodeConnection::Init(Napi::Env env, Napi::Object exports) {
       env, "NodeConnection",
       {
           InstanceMethod("execute", &NodeConnection::Execute),
+          InstanceMethod("beginTransaction", &NodeConnection::BeginTransaction),
+          InstanceMethod("commit", &NodeConnection::Commit),
+          InstanceMethod("rollback", &NodeConnection::Rollback),
+          InstanceMethod("hasActiveTransaction",
+                         &NodeConnection::HasActiveTransaction),
           InstanceMethod("getSchema", &NodeConnection::GetSchema),
           InstanceMethod("close", &NodeConnection::Close),
       });
@@ -81,7 +101,7 @@ Napi::Value NodeConnection::Execute(const Napi::CallbackInfo& info) {
   }
 
   // Parse parameters from JavaScript object
-  rapidjson::Document params_json;
+  rapidjson::Document params_json(rapidjson::kObjectType);
   if (info.Length() >= 3 && info[2].IsObject()) {
     Napi::Object params_obj = info[2].As<Napi::Object>();
     Napi::Array keys = params_obj.GetPropertyNames();
@@ -99,13 +119,53 @@ Napi::Value NodeConnection::Execute(const Napi::CallbackInfo& info) {
   return NodeQueryResult::NewInstance(env, std::move(query_result.value()));
 }
 
+Napi::Value NodeConnection::BeginTransaction(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() > 1 || (info.Length() == 1 && !info[0].IsBoolean())) {
+    Napi::TypeError::New(env, "readOnly must be a boolean")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  const bool read_only =
+      info.Length() == 1 && info[0].As<Napi::Boolean>().Value();
+  const auto status =
+      conn_ ? conn_->BeginTransaction(read_only ? TransactionMode::kReadOnly
+                                                : TransactionMode::kReadWrite)
+            : ClosedConnectionStatus();
+  return StatusToJs(env, status);
+}
+
+Napi::Value NodeConnection::Commit(const Napi::CallbackInfo& info) {
+  const auto status = conn_ ? conn_->Commit() : ClosedConnectionStatus();
+  return StatusToJs(info.Env(), status);
+}
+
+Napi::Value NodeConnection::Rollback(const Napi::CallbackInfo& info) {
+  const auto status = conn_ ? conn_->Rollback() : ClosedConnectionStatus();
+  return StatusToJs(info.Env(), status);
+}
+
+Napi::Value NodeConnection::HasActiveTransaction(
+    const Napi::CallbackInfo& info) {
+  return Napi::Boolean::New(info.Env(), conn_ && conn_->HasActiveTransaction());
+}
+
 Napi::Value NodeConnection::GetSchema(const Napi::CallbackInfo& info) {
-  return Napi::String::New(info.Env(), conn_->GetSchema());
+  Napi::Env env = info.Env();
+  try {
+    return Napi::String::New(env, conn_->GetSchema());
+  } catch (const neug::exception::Exception& e) {
+    Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+  } catch (const std::exception& e) {
+    Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+  }
+  return env.Null();
 }
 
 Napi::Value NodeConnection::Close(const Napi::CallbackInfo& info) {
   if (conn_) {
-    db_->RemoveConnection(conn_);
+    conn_->Close();
     conn_.reset();
   }
   return info.Env().Undefined();

package/src/node_connection.h

@@ -21,7 +21,7 @@
 #include <memory>
 #include <string>
 
-#include "neug/execution/common/types/value.h"
+#include "neug/common/types/value.h"
 #include "neug/main/connection.h"
 #include "neug/main/neug_db.h"
 #include "node_query_result.h"
@@ -43,6 +43,10 @@ class NodeConnection : public Napi::ObjectWrap<NodeConnection> {
   static Napi::FunctionReference constructor;
 
   Napi::Value Execute(const Napi::CallbackInfo& info);
+  Napi::Value BeginTransaction(const Napi::CallbackInfo& info);
+  Napi::Value Commit(const Napi::CallbackInfo& info);
+  Napi::Value Rollback(const Napi::CallbackInfo& info);
+  Napi::Value HasActiveTransaction(const Napi::CallbackInfo& info);
   Napi::Value GetSchema(const Napi::CallbackInfo& info);
   Napi::Value Close(const Napi::CallbackInfo& info);
 

package/src/node_database.cc

@@ -27,15 +27,13 @@ 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),
-          StaticMethod("cpuCount", &NodeDatabase::GetCpuCount),
-      });
+  Napi::Function func =
+      DefineClass(env, "NodeDatabase",
+                  {
+                      InstanceMethod("connect", &NodeDatabase::Connect),
+                      InstanceMethod("close", &NodeDatabase::Close),
+                      StaticMethod("cpuCount", &NodeDatabase::GetCpuCount),
+                  });
   constructor = Napi::Persistent(func);
   constructor.SuppressDestruct();
   exports.Set("NodeDatabase", func);
@@ -76,8 +74,10 @@ NodeDatabase::NodeDatabase(const Napi::CallbackInfo& info)
   }
 
   bool checkpoint_on_close = true;
-  if (opts.Has("checkpointOnClose") && opts.Get("checkpointOnClose").IsBoolean()) {
-    checkpoint_on_close = opts.Get("checkpointOnClose").As<Napi::Boolean>().Value();
+  if (opts.Has("checkpointOnClose") &&
+      opts.Get("checkpointOnClose").IsBoolean()) {
+    checkpoint_on_close =
+        opts.Get("checkpointOnClose").As<Napi::Boolean>().Value();
   }
 
   std::string buffer_strategy = "M_FULL";
@@ -95,8 +95,7 @@ NodeDatabase::NodeDatabase(const Napi::CallbackInfo& info)
              mode == "read-write") {
     mode_ = DBMode::READ_WRITE;
   } else {
-    Napi::Error::New(env, "Invalid mode: " + mode)
-        .ThrowAsJavaScriptException();
+    Napi::Error::New(env, "Invalid mode: " + mode).ThrowAsJavaScriptException();
     return;
   }
 
@@ -122,12 +121,6 @@ NodeDatabase::NodeDatabase(const Napi::CallbackInfo& info)
 
 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();
@@ -155,12 +148,6 @@ Napi::Value NodeDatabase::Connect(const Napi::CallbackInfo& info) {
 
 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();
@@ -168,77 +155,6 @@ Napi::Value NodeDatabase::Close(const Napi::CallbackInfo& info) {
   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();
-}
-
 Napi::Value NodeDatabase::GetCpuCount(const Napi::CallbackInfo& info) {
   long n = sysconf(_SC_NPROCESSORS_ONLN);
   if (n < 1) {

package/src/node_database.h

@@ -23,9 +23,6 @@
 #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 {
@@ -40,8 +37,6 @@ class NodeDatabase : public Napi::ObjectWrap<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;
@@ -51,9 +46,6 @@ class NodeDatabase : public Napi::ObjectWrap<NodeDatabase> {
   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

package/src/node_query_request.cc

@@ -18,7 +18,7 @@
 #include <sstream>
 #include <string>
 
-#include "neug/execution/common/types/value.h"
+#include "neug/common/types/value.h"
 #include "neug/main/query_request.h"
 #include "neug/utils/access_mode.h"
 #include "neug/utils/exception/exception.h"
@@ -64,8 +64,7 @@ rapidjson::Document napi_value_to_rapidjson_document(
   } 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>();
+    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);
@@ -141,7 +140,7 @@ Napi::Value NodeQueryRequest::SerializeRequest(const Napi::CallbackInfo& info) {
                     rapidjson::Value(access_mode.c_str(), allocator),
                     allocator);
 
-  rapidjson::Document params_doc;
+  rapidjson::Document params_doc(rapidjson::kObjectType);
   if (info.Length() >= 3 && info[2].IsObject()) {
     Napi::Object params_obj = info[2].As<Napi::Object>();
     Napi::Array keys = params_obj.GetPropertyNames();

package/src/node_query_result.cc

@@ -41,6 +41,8 @@ Napi::Object NodeQueryResult::Init(Napi::Env env, Napi::Object exports) {
           InstanceMethod("statusMessage", &NodeQueryResult::StatusMessage),
           InstanceMethod("getBoltResponse", &NodeQueryResult::GetBoltResponse),
           InstanceMethod("close", &NodeQueryResult::Close),
+          InstanceMethod("getProfileMetrics",
+                         &NodeQueryResult::GetProfileMetrics),
           StaticMethod("fromString", &NodeQueryResult::FromString),
       });
   constructor = Napi::Persistent(func);
@@ -216,8 +218,7 @@ Napi::Value FetchValueFromColumn(Napi::Env env, const neug::Array& column,
       size_t offset = col.offsets(index);
       Napi::Array arr = Napi::Array::New(env, list_size);
       for (uint32_t i = 0; i < list_size; ++i) {
-        arr.Set(i,
-                FetchValueFromColumn(env, col.elements(), offset + i));
+        arr.Set(i, FetchValueFromColumn(env, col.elements(), offset + i));
       }
       return arr;
     } else {
@@ -332,9 +333,8 @@ Napi::Value NodeQueryResult::StatusMessage(const Napi::CallbackInfo& info) {
 
 Napi::Value NodeQueryResult::GetBoltResponse(const Napi::CallbackInfo& info) {
   auto names = column_names();
-  return Napi::String::New(info.Env(),
-                           results_to_bolt_response(query_result_.response(),
-                                                    names));
+  return Napi::String::New(
+      info.Env(), results_to_bolt_response(query_result_.response(), names));
 }
 
 Napi::Value NodeQueryResult::Close(const Napi::CallbackInfo& info) {
@@ -344,6 +344,51 @@ Napi::Value NodeQueryResult::Close(const Napi::CallbackInfo& info) {
   return info.Env().Undefined();
 }
 
+Napi::Value NodeQueryResult::GetProfileMetrics(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::Object result = Napi::Object::New(env);
+
+  if (!query_result_.response().has_profile_result()) {
+    return result;
+  }
+
+  const auto& profile_result = query_result_.response().profile_result();
+
+  // Add aggregate metrics
+  result.Set("total_elapsed_ms",
+             Napi::Number::New(env, profile_result.total_elapsed_ms()));
+  result.Set("total_output_rows",
+             Napi::Number::New(
+                 env, static_cast<double>(profile_result.total_output_rows())));
+
+  // Convert operators to array of objects
+  Napi::Array operators_array =
+      Napi::Array::New(env, profile_result.operators_size());
+  for (int i = 0; i < profile_result.operators_size(); ++i) {
+    const auto& op = profile_result.operators(i);
+    Napi::Object op_obj = Napi::Object::New(env);
+
+    op_obj.Set("operator_id", Napi::Number::New(env, op.operator_id()));
+    op_obj.Set("parent_id", Napi::Number::New(env, op.parent_id()));
+    op_obj.Set("operator_name", Napi::String::New(env, op.operator_name()));
+    op_obj.Set("elapsed_ms", Napi::Number::New(env, op.elapsed_ms()));
+    op_obj.Set("output_rows",
+               Napi::Number::New(env, static_cast<double>(op.output_rows())));
+
+    // Convert child_ids repeated field to array
+    Napi::Array child_ids_array = Napi::Array::New(env, op.child_ids_size());
+    for (int j = 0; j < op.child_ids_size(); ++j) {
+      child_ids_array.Set(j, Napi::Number::New(env, op.child_ids(j)));
+    }
+    op_obj.Set("child_ids", child_ids_array);
+
+    operators_array.Set(i, op_obj);
+  }
+  result.Set("operators", operators_array);
+
+  return result;
+}
+
 Napi::Value NodeQueryResult::FromString(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   if (info.Length() < 1) {

package/src/node_query_result.h

@@ -60,6 +60,7 @@ class NodeQueryResult : public Napi::ObjectWrap<NodeQueryResult> {
   Napi::Value StatusMessage(const Napi::CallbackInfo& info);
   Napi::Value GetBoltResponse(const Napi::CallbackInfo& info);
   Napi::Value Close(const Napi::CallbackInfo& info);
+  Napi::Value GetProfileMetrics(const Napi::CallbackInfo& info);
   static Napi::Value FromString(const Napi::CallbackInfo& info);
 
   size_t index_{0};

package/lib/session.js

@@ -1,275 +0,0 @@
-/** 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.
- */
-
-'use strict';
-
-const http = require('http');
-const https = require('https');
-const { URL } = require('url');
-const { QueryResult } = require('./query-result');
-const { isAccessModeValid, validAccessModes } = require('./utils');
-const { ERR_NETWORK, ERR_SESSION_CLOSED } = require('./error-codes');
-
-// Load the native binding (unified loader handles prebuilds/ and build/)
-const nativeBinding = require('./binding');
-
-/**
- * Parse a timeout string to milliseconds.
- * @param {string|number} timeout - Timeout value (e.g., '10s', '500ms', or number of seconds).
- * @returns {number} Timeout in milliseconds.
- */
-function parseTimeout(timeout) {
-  if (typeof timeout === 'number') {
-    return timeout * 1000;
-  }
-  if (typeof timeout === 'string') {
-    if (timeout.endsWith('ms')) {
-      return parseInt(timeout.slice(0, -2), 10);
-    } else if (timeout.endsWith('s')) {
-      return parseInt(timeout.slice(0, -1), 10) * 1000;
-    }
-  }
-  return 10000; // default 10 seconds
-}
-
-/**
- * Make an HTTP request using Node.js built-in http/https modules.
- * @param {string} url - The URL to request.
- * @param {Object} options - Request options.
- * @param {string} [options.method='GET'] - HTTP method.
- * @param {string} [options.body] - Request body.
- * @param {number} [options.timeout=10000] - Timeout in milliseconds.
- * @returns {Promise<{statusCode: number, body: Buffer}>}
- */
-function httpRequest(url, options = {}) {
-  return new Promise((resolve, reject) => {
-    const parsedUrl = new URL(url);
-    const isHttps = parsedUrl.protocol === 'https:';
-    const lib = isHttps ? https : http;
-
-    const reqOptions = {
-      hostname: parsedUrl.hostname,
-      port: parsedUrl.port || (isHttps ? 443 : 80),
-      path: parsedUrl.pathname + parsedUrl.search,
-      method: options.method || 'GET',
-      timeout: options.timeout || 10000,
-      headers: options.headers || {},
-    };
-
-    const req = lib.request(reqOptions, (res) => {
-      const chunks = [];
-      res.on('data', (chunk) => chunks.push(chunk));
-      res.on('end', () => {
-        resolve({
-          statusCode: res.statusCode,
-          body: Buffer.concat(chunks),
-        });
-      });
-    });
-
-    req.on('error', reject);
-    req.on('timeout', () => {
-      req.destroy();
-      reject(new Error('Request timed out'));
-    });
-
-    if (options.body) {
-      req.write(options.body);
-    }
-    req.end();
-  });
-}
-
-/**
- * Session connects to a NeuG server and provides the same query interface as Connection.
- *
- * @example
- * // Start the server
- * const db = new Database({ databasePath: '/tmp/test.db', mode: 'w' });
- * db.serve({ port: 10000, host: 'localhost' });
- *
- * // In another process, connect via Session
- * const session = new Session({ endpoint: 'http://localhost:10000' });
- * const result = session.execute('MATCH (n) RETURN count(n)');
- * for (const row of result) {
- *   console.log(row);
- * }
- * session.close();
- */
-class Session {
-  /**
-   * @param {Object} [options] - Session options.
-   * @param {string} [options.endpoint='http://localhost:10000'] - The server endpoint URL.
-   * @param {string|number} [options.timeout='10s'] - Request timeout.
-   */
-  constructor(options = {}) {
-    const {
-      endpoint = 'http://localhost:10000',
-      timeout = '10s',
-    } = options;
-
-    this._endpoint = endpoint.replace(/\/+$/, '');
-    this._queryEndpoint = `${this._endpoint}/cypher`;
-    this._statusEndpoint = `${this._endpoint}/service_status`;
-    this._schemaEndpoint = `${this._endpoint}/schema`;
-    this._timeout = parseTimeout(timeout);
-    this._closed = false;
-
-    // Quick connectivity check
-    // (We do this synchronously-ish via the constructor, but it's fire-and-forget)
-    // For a proper async init, use Session.open() instead.
-  }
-
-  /**
-   * Open a session with connectivity check.
-   *
-   * @param {Object} [options] - Session options (same as constructor).
-   * @returns {Promise<Session>} A connected Session instance.
-   */
-  static async open(options = {}) {
-    const session = new Session(options);
-    // Wait for the server to be ready, same purpose as Python's
-    // implicit readiness via slower HTTP client startup.
-    const maxRetries = 5;
-    const retryDelayMs = 200;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-      try {
-        await session._checkConnection();
-        return session;
-      } catch (_) {
-        if (attempt < maxRetries - 1) {
-          await new Promise((r) => setTimeout(r, retryDelayMs));
-        }
-      }
-    }
-    // Return anyway — let actual queries surface the real error
-    return session;
-  }
-
-  /**
-   * Check connectivity to the server.
-   * @private
-   */
-  async _checkConnection() {
-    await httpRequest(this._statusEndpoint, {
-      method: 'GET',
-      timeout: this._timeout,
-    });
-  }
-
-  /**
-   * Close the session.
-   */
-  close() {
-    if (this._closed) {
-      console.warn('[neug] Session is already closed.');
-      return;
-    }
-    this._closed = true;
-  }
-
-  /**
-   * Execute a query on the NeuG server.
-   *
-   * @param {string} query - The cypher query string.
-   * @param {string} [accessMode=''] - The access mode.
-   * @param {Object} [parameters=null] - Query parameters.
-   * @returns {Promise<QueryResult>} The query result.
-   * @throws {Error} If the session is closed or the request fails.
-   */
-  async execute(query, accessMode = '', parameters = null) {
-    if (this._closed) {
-      throw new Error(
-        `Session is closed. Cannot execute query. Error code: ${ERR_SESSION_CLOSED}`
-      );
-    }
-
-    if (accessMode !== '' && !isAccessModeValid(accessMode.toLowerCase())) {
-      throw new Error(
-        `Invalid access_mode: ${accessMode}. Supported access modes are ` +
-        `[${validAccessModes.join(', ')}].`
-      );
-    }
-
-    // Build payload
-    const payload = JSON.stringify({
-      query,
-      access_mode: accessMode || 'update',
-      parameters: parameters || {},
-    });
-
-    let response;
-    try {
-      response = await httpRequest(this._queryEndpoint, {
-        method: 'POST',
-        body: payload,
-        timeout: this._timeout,
-        headers: {
-          'Content-Type': 'application/json',
-          'Content-Length': Buffer.byteLength(payload),
-        },
-      });
-    } catch (e) {
-      throw new Error(
-        `Could not execute query: ${query}. Error code: ${ERR_NETWORK}. ` +
-        `Details: ${e.message}`
-      );
-    }
-
-    if (response.statusCode !== 200) {
-      throw new Error(
-        `Failed to execute query: ${query}. Http code: ${response.statusCode}, ` +
-        `Response: ${response.body.toString()}`
-      );
-    }
-
-    // The response body is a protobuf-serialized QueryResponse.
-    // Use the native binding to deserialize it.
-    if (!nativeBinding || !nativeBinding.NodeQueryResult) {
-      throw new Error(
-        'Native binding is required for Session but was not loaded. ' +
-        'Please ensure the neug native addon is built and available.'
-      );
-    }
-    const nativeResult = nativeBinding.NodeQueryResult.fromString(response.body);
-    return new QueryResult(nativeResult);
-  }
-
-  /**
-   * Get the service status of the NeuG server.
-   * @returns {Promise<Object>} The server status as a JSON object.
-   */
-  async serviceStatus() {
-    const response = await httpRequest(this._statusEndpoint, {
-      method: 'GET',
-      timeout: this._timeout,
-    });
-    return JSON.parse(response.body.toString());
-  }
-
-  /**
-   * Get the schema of the NeuG database from the server.
-   * @returns {Promise<Object>} The schema as a JSON object.
-   */
-  async getSchema() {
-    const response = await httpRequest(this._schemaEndpoint, {
-      method: 'GET',
-      timeout: this._timeout,
-    });
-    return JSON.parse(response.body.toString());
-  }
-}
-
-module.exports = { Session };