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

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

package/README.md

@@ -62,7 +62,7 @@ Create a self-contained, distributable npm package tarball (`.tgz`). This will:
 The resulting tarball can be installed without a C++ build environment:
 
 ```bash
-npm install ./neug-0.1.2.tgz
+npm install ./neug-0.1.3.tgz
 ```
 
  

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphscope-neug/osx-arm64",
-  "version": "0.1.3-alpha.1",
+  "version": "0.1.3",
   "description": "NeuG Graph Database Node.js bindings - high performance embedded graph database with Cypher query support",
   "main": "lib/index.js",
   "scripts": {

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/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 };