@graphscope-neug/darwin-arm64 0.1.2

package/lib/database.js

@@ -0,0 +1,310 @@
+/** 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 os = require('os');
+const { Connection } = require('./connection');
+const { AsyncConnection } = require('./async-connection');
+const { readable } = require('./utils');
+const { version } = require('./version');
+const {
+  ERR_CONFIG_INVALID,
+  ERR_INVALID_ARGUMENT,
+  ERR_INVALID_PATH,
+} = require('./error-codes');
+
+// Load the native binding (unified loader handles prebuilds/ and build/)
+const nativeBinding = require('./binding');
+
+const ILLEGAL_CHARS = ['?', '*', '"', '<', '>', '|', ':', '\\'];
+const PURE_MEMORY_PATHS = [':memory', ':memory:'];
+const VALID_MODES = [
+  'r', 'read', 'w', 'rw', 'write',
+  'readwrite', 'read-write', 'read_write',
+  'read-only', 'read_only',
+];
+
+/**
+ * Database is the main entry point for the NeuG graph database.
+ *
+ * Use this class to open a database, create connections, and manage the database lifecycle.
+ *
+ * @example
+ * const { Database } = require('neug');
+ *
+ * const db = new Database({ databasePath: '/tmp/test.db', mode: 'w' });
+ * const conn = db.connect();
+ *
+ * conn.execute('CREATE (n:person {name: "Alice"})');
+ * const result = conn.execute('MATCH (n) RETURN n');
+ * for (const row of result) {
+ *   console.log(row);
+ * }
+ *
+ * conn.close();
+ * db.close();
+ */
+class Database {
+  /**
+   * Open a NeuG database.
+   *
+   * @param {Object} options - Database configuration options.
+   * @param {string|null} [options.databasePath=null] - Path to the database directory.
+   *   Empty string or null for in-memory mode.
+   * @param {string} [options.mode='read-write'] - Database access mode.
+   *   Supported: 'r', 'read', 'w', 'rw', 'write', 'readwrite', 'read-write', 'read-only'.
+   * @param {number} [options.maxThreadNum=0] - Maximum number of threads (0 = no limit).
+   * @param {boolean} [options.checkpointOnClose=true] - Whether to checkpoint on close.
+   * @param {string} [options.bufferStrategy='M_FULL'] - Buffer strategy:
+   *   'InMemory'/'M_FULL', 'SyncToFile'/'M_LAZY', 'HugePagePreferred'/'M_HUGE'.
+   */
+  constructor(options = {}) {
+    const {
+      databasePath = null,
+      mode = 'read-write',
+      maxThreadNum = 0,
+      checkpointOnClose = true,
+      bufferStrategy = 'M_FULL',
+    } = options;
+
+    this._connections = [];
+    this._asyncConnections = [];
+    this._serving = false;
+
+    // Validate path
+    const dbPath = databasePath !== null ? databasePath : '';
+    if (
+      typeof dbPath === 'string' &&
+      ILLEGAL_CHARS.some((ch) => dbPath.includes(ch)) &&
+      !PURE_MEMORY_PATHS.includes(dbPath)
+    ) {
+      throw new Error(
+        `Invalid path: database path '${dbPath}' contains illegal characters: ` +
+        `[${ILLEGAL_CHARS.join(', ')}]. Error code: ${ERR_INVALID_PATH}.`
+      );
+    }
+
+    // Validate mode
+    if (!VALID_MODES.includes(mode)) {
+      throw new Error(
+        `Invalid mode: ${mode}. Must be one of: ${VALID_MODES.join(', ')}. ` +
+        `Error code: ${ERR_INVALID_ARGUMENT}.`
+      );
+    }
+
+    // Validate maxThreadNum
+    if (maxThreadNum < 0) {
+      throw new Error(
+        `Invalid config: maxThreadNum: ${maxThreadNum}. Must be a non-negative integer. ` +
+        `Error code: ${ERR_CONFIG_INVALID}.`
+      );
+    }
+
+    const cpuCount = os.cpus().length;
+    if (maxThreadNum > cpuCount) {
+      throw new Error(
+        `Invalid argument: maxThreadNum: ${maxThreadNum}. ` +
+        `Must be less than or equal to CPU cores: ${cpuCount}. ` +
+        `Error code: ${ERR_INVALID_ARGUMENT}.`
+      );
+    }
+
+    // In-memory database cannot be opened in read-only mode
+    // NOTE: only null (i.e. databasePath not provided) is blocked;
+    // empty string '' is allowed, matching the Python binding behaviour.
+    if (
+      databasePath === null &&
+      ['r', 'read', 'read-only', 'read_only'].includes(mode)
+    ) {
+      throw new Error(
+        `Invalid mode: ${mode}. In-memory database cannot be opened in read-only mode. ` +
+        `Error code: ${ERR_INVALID_ARGUMENT}.`
+      );
+    }
+
+    this._dbPath = dbPath;
+    this._mode = mode;
+    this._maxThreadNum = maxThreadNum;
+
+    // Create the native database
+    this._database = new nativeBinding.NodeDatabase({
+      databasePath: dbPath,
+      maxThreadNum,
+      mode: readable(mode),
+      planner: 'gopt',
+      checkpointOnClose,
+      bufferStrategy,
+    });
+
+    if (!dbPath || dbPath.trim() === '') {
+      console.log(`[neug] Open in-memory database in ${readable(mode)} mode`);
+    } else {
+      console.log(`[neug] Open database ${dbPath} in ${mode} mode`);
+    }
+  }
+
+  /**
+   * Get the version of the database.
+   * @returns {string} The version string.
+   */
+  get version() {
+    return version;
+  }
+
+  /**
+   * Get the database mode.
+   * @returns {string} The mode string.
+   */
+  get mode() {
+    return this._mode;
+  }
+
+  /**
+   * 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.
+   */
+  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);
+    return conn;
+  }
+
+  /**
+   * Connect to the database asynchronously.
+   *
+   * @returns {AsyncConnection} An async connection to the database.
+   * @throws {Error} If the database is closed or serving.
+   */
+  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.
+   */
+  close() {
+    if (this._dbPath && this._dbPath.trim() !== '') {
+      console.log(`[neug] Closing database ${this._dbPath}.`);
+    }
+
+    // Close all connections
+    if (this._connections) {
+      for (const conn of this._connections) {
+        try {
+          conn.close();
+        } catch (e) {
+          console.warn(`[neug] Failed to close connection: ${e.message}`);
+        }
+      }
+    }
+
+    // Close all async connections
+    if (this._asyncConnections) {
+      for (const asyncConn of this._asyncConnections) {
+        try {
+          asyncConn.close();
+        } catch (e) {
+          console.warn(`[neug] Failed to close async connection: ${e.message}`);
+        }
+      }
+    }
+
+    if (this._database) {
+      this._database.close();
+      this._database = null;
+    }
+  }
+}
+
+module.exports = { Database };

package/lib/error-codes.js

@@ -0,0 +1,208 @@
+/** 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.
+ */
+
+/**
+ * Error codes mirror the protobuf `Code` enum defined in `proto/error.proto`.
+ * Provides both numeric constants and a reverse mapping from code to name.
+ *
+ * @module error-codes
+ */
+
+'use strict';
+
+// ---- Numeric error code constants (from error.proto Code enum) ----
+// General errors (1001-1017)
+const OK = 0;
+const ERR_PERMISSION = 1001;
+const ERR_VERSION_MISMATCHED = 1002;
+const ERR_DIRECTORY_NOT_EXIST = 1003;
+const ERR_DATABASE_LOCKED = 1004;
+const ERR_DISK_SPACE_EXHAUSTED = 1005;
+const ERR_CORRUPTION_DETECTED = 1006;
+const ERR_INVALID_PATH = 1007;
+const ERR_CONFIG_INVALID = 1008;
+const ERR_INVALID_ARGUMENT = 1009;
+const ERR_NOT_FOUND = 1010;
+const ERR_NOT_SUPPORTED = 1011;
+const ERR_INTERNAL_ERROR = 1012;
+const ERR_ILLEGAL_OPERATION = 1013;
+const ERR_IO_ERROR = 1014;
+const ERR_BAD_ENCODING = 1015;
+const ERR_INVALID_FILE = 1016;
+const ERR_EXTENSION = 1017;
+
+// Network errors (2001-2007)
+const ERR_NETWORK = 2001;
+const ERR_SESSION_CLOSED = 2002;
+const ERR_CONNECTION_CLOSED = 2003;
+const ERR_POOL_EXHAUSTED = 2004;
+const ERR_SERVICE_UNAVAILABLE = 2005;
+const ERR_LOAD_OVERFLOW = 2006;
+const ERR_CONNECTION_ERROR = 2007;
+
+// Query errors (3000-3007)
+const ERR_COMPILATION = 3000;
+const ERR_QUERY_EXECUTION = 3001;
+const ERR_QUERY_SYNTAX = 3002;
+const ERR_QUERY_TIMEOUT = 3003;
+const ERR_CONCURRENT_WRITE = 3004;
+const ERR_CODEGEN_ERROR = 3005;
+const ERR_EMPTY_RESULT = 3006;
+const ERR_NOT_INITIALIZED = 3007;
+
+// Transaction errors (4001-4003)
+const ERR_TX_STATE_CONFLICT = 4001;
+const ERR_WAL_WRITE_FAIL = 4002;
+const ERR_TX_TIMEOUT = 4003;
+
+// Schema errors (5001-5005)
+const ERR_SCHEMA_MISMATCH = 5001;
+const ERR_INVALID_SCHEMA = 5002;
+const ERR_TYPE_CONVERSION = 5003;
+const ERR_TYPE_OVERFLOW = 5004;
+const ERR_INDEX_ERROR = 5005;
+
+// Deployment errors (6001-6004)
+const ERR_PLATFORM_ABI = 6001;
+const ERR_PY_BIND_INIT = 6002;
+const ERR_ARCH_MISMATCH = 6003;
+const ERR_DEPLOY_DEPENDENCY = 6004;
+
+// Not implemented (7001)
+const ERR_NOT_IMPLEMENTED = 7001;
+
+// Unknown (9999)
+const ERR_UNKNOWN = 9999;
+
+// ---- Code enum: maps numeric code → name string ----
+const Code = {
+  [OK]: 'OK',
+  [ERR_PERMISSION]: 'ERR_PERMISSION',
+  [ERR_VERSION_MISMATCHED]: 'ERR_VERSION_MISMATCHED',
+  [ERR_DIRECTORY_NOT_EXIST]: 'ERR_DIRECTORY_NOT_EXIST',
+  [ERR_DATABASE_LOCKED]: 'ERR_DATABASE_LOCKED',
+  [ERR_DISK_SPACE_EXHAUSTED]: 'ERR_DISK_SPACE_EXHAUSTED',
+  [ERR_CORRUPTION_DETECTED]: 'ERR_CORRUPTION_DETECTED',
+  [ERR_INVALID_PATH]: 'ERR_INVALID_PATH',
+  [ERR_CONFIG_INVALID]: 'ERR_CONFIG_INVALID',
+  [ERR_INVALID_ARGUMENT]: 'ERR_INVALID_ARGUMENT',
+  [ERR_NOT_FOUND]: 'ERR_NOT_FOUND',
+  [ERR_NOT_SUPPORTED]: 'ERR_NOT_SUPPORTED',
+  [ERR_INTERNAL_ERROR]: 'ERR_INTERNAL_ERROR',
+  [ERR_ILLEGAL_OPERATION]: 'ERR_ILLEGAL_OPERATION',
+  [ERR_IO_ERROR]: 'ERR_IO_ERROR',
+  [ERR_BAD_ENCODING]: 'ERR_BAD_ENCODING',
+  [ERR_INVALID_FILE]: 'ERR_INVALID_FILE',
+  [ERR_EXTENSION]: 'ERR_EXTENSION',
+  [ERR_NETWORK]: 'ERR_NETWORK',
+  [ERR_SESSION_CLOSED]: 'ERR_SESSION_CLOSED',
+  [ERR_CONNECTION_CLOSED]: 'ERR_CONNECTION_CLOSED',
+  [ERR_POOL_EXHAUSTED]: 'ERR_POOL_EXHAUSTED',
+  [ERR_SERVICE_UNAVAILABLE]: 'ERR_SERVICE_UNAVAILABLE',
+  [ERR_LOAD_OVERFLOW]: 'ERR_LOAD_OVERFLOW',
+  [ERR_CONNECTION_ERROR]: 'ERR_CONNECTION_ERROR',
+  [ERR_COMPILATION]: 'ERR_COMPILATION',
+  [ERR_QUERY_EXECUTION]: 'ERR_QUERY_EXECUTION',
+  [ERR_QUERY_SYNTAX]: 'ERR_QUERY_SYNTAX',
+  [ERR_QUERY_TIMEOUT]: 'ERR_QUERY_TIMEOUT',
+  [ERR_CONCURRENT_WRITE]: 'ERR_CONCURRENT_WRITE',
+  [ERR_CODEGEN_ERROR]: 'ERR_CODEGEN_ERROR',
+  [ERR_EMPTY_RESULT]: 'ERR_EMPTY_RESULT',
+  [ERR_NOT_INITIALIZED]: 'ERR_NOT_INITIALIZED',
+  [ERR_TX_STATE_CONFLICT]: 'ERR_TX_STATE_CONFLICT',
+  [ERR_WAL_WRITE_FAIL]: 'ERR_WAL_WRITE_FAIL',
+  [ERR_TX_TIMEOUT]: 'ERR_TX_TIMEOUT',
+  [ERR_SCHEMA_MISMATCH]: 'ERR_SCHEMA_MISMATCH',
+  [ERR_INVALID_SCHEMA]: 'ERR_INVALID_SCHEMA',
+  [ERR_TYPE_CONVERSION]: 'ERR_TYPE_CONVERSION',
+  [ERR_TYPE_OVERFLOW]: 'ERR_TYPE_OVERFLOW',
+  [ERR_INDEX_ERROR]: 'ERR_INDEX_ERROR',
+  [ERR_PLATFORM_ABI]: 'ERR_PLATFORM_ABI',
+  [ERR_PY_BIND_INIT]: 'ERR_PY_BIND_INIT',
+  [ERR_ARCH_MISMATCH]: 'ERR_ARCH_MISMATCH',
+  [ERR_DEPLOY_DEPENDENCY]: 'ERR_DEPLOY_DEPENDENCY',
+  [ERR_NOT_IMPLEMENTED]: 'ERR_NOT_IMPLEMENTED',
+  [ERR_UNKNOWN]: 'ERR_UNKNOWN',
+};
+
+/**
+ * Get the name of an error code.
+ * @param {number} code - The numeric error code.
+ * @returns {string} The error code name, or 'ERR_UNKNOWN' if not found.
+ */
+function codeName(code) {
+  return Code[code] || 'ERR_UNKNOWN';
+}
+
+module.exports = {
+  // General errors
+  OK,
+  ERR_PERMISSION,
+  ERR_VERSION_MISMATCHED,
+  ERR_DIRECTORY_NOT_EXIST,
+  ERR_DATABASE_LOCKED,
+  ERR_DISK_SPACE_EXHAUSTED,
+  ERR_CORRUPTION_DETECTED,
+  ERR_INVALID_PATH,
+  ERR_CONFIG_INVALID,
+  ERR_INVALID_ARGUMENT,
+  ERR_NOT_FOUND,
+  ERR_NOT_SUPPORTED,
+  ERR_INTERNAL_ERROR,
+  ERR_ILLEGAL_OPERATION,
+  ERR_IO_ERROR,
+  ERR_BAD_ENCODING,
+  ERR_INVALID_FILE,
+  ERR_EXTENSION,
+  // Network errors
+  ERR_NETWORK,
+  ERR_SESSION_CLOSED,
+  ERR_CONNECTION_CLOSED,
+  ERR_POOL_EXHAUSTED,
+  ERR_SERVICE_UNAVAILABLE,
+  ERR_LOAD_OVERFLOW,
+  ERR_CONNECTION_ERROR,
+  // Query errors
+  ERR_COMPILATION,
+  ERR_QUERY_EXECUTION,
+  ERR_QUERY_SYNTAX,
+  ERR_QUERY_TIMEOUT,
+  ERR_CONCURRENT_WRITE,
+  ERR_CODEGEN_ERROR,
+  ERR_EMPTY_RESULT,
+  ERR_NOT_INITIALIZED,
+  // Transaction errors
+  ERR_TX_STATE_CONFLICT,
+  ERR_WAL_WRITE_FAIL,
+  ERR_TX_TIMEOUT,
+  // Schema errors
+  ERR_SCHEMA_MISMATCH,
+  ERR_INVALID_SCHEMA,
+  ERR_TYPE_CONVERSION,
+  ERR_TYPE_OVERFLOW,
+  ERR_INDEX_ERROR,
+  // Deployment errors
+  ERR_PLATFORM_ABI,
+  ERR_PY_BIND_INIT,
+  ERR_ARCH_MISMATCH,
+  ERR_DEPLOY_DEPENDENCY,
+  // Not implemented
+  ERR_NOT_IMPLEMENTED,
+  // Unknown
+  ERR_UNKNOWN,
+  // Code enum (code → name)
+  Code,
+  codeName,
+};

package/lib/format.js

@@ -0,0 +1,131 @@
+/** 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';
+
+/**
+ * Parse an individual entry value to a display string.
+ *
+ * @param {*} entry - The value to parse (could be object, array, or primitive).
+ * @returns {string} The formatted string representation.
+ */
+function parseEntry(entry) {
+  if (entry === null || entry === undefined) {
+    return 'null';
+  }
+  if (typeof entry === 'object' && !Array.isArray(entry) && !(entry instanceof Date)) {
+    // Object: vertex, edge, property, map
+    const pairs = Object.entries(entry)
+      .map(([key, value]) => `${key}: ${parseEntry(value)}`)
+      .join(', ');
+    return `{${pairs}}`;
+  }
+  if (Array.isArray(entry)) {
+    // Array: path, list
+    return entry.map(parseEntry).join(', ');
+  }
+  // Primitives: bool, int, string, Date, float, etc.
+  return String(entry);
+}
+
+/**
+ * Calculate column widths for table formatting.
+ *
+ * @param {string[][]} rows - The table rows.
+ * @param {string[]} headers - The column headers.
+ * @returns {number[]} Array of column widths.
+ */
+function calculateColumnWidths(rows, headers) {
+  const widths = headers.map((h) => h.length);
+  for (const row of rows) {
+    for (let i = 0; i < row.length; i++) {
+      const cellLen = String(row[i] ?? '').length;
+      if (cellLen > widths[i]) {
+        widths[i] = cellLen;
+      }
+    }
+  }
+  return widths;
+}
+
+/**
+ * Print results as a grid-formatted table (similar to Python's tabulate with tablefmt='grid').
+ *
+ * @param {string[]} headers - The column headers.
+ * @param {string[][]} rows - The table rows.
+ */
+function printResultsAsTable(headers, rows) {
+  const widths = calculateColumnWidths(rows, headers);
+
+  // Build separator line: +------+------+
+  const separator = '+' + widths.map((w) => '-'.repeat(w + 2)).join('+') + '+';
+
+  // Build a row line: | val1 | val2 |
+  function formatRow(cells) {
+    return (
+      '| ' +
+      cells
+        .map((cell, i) => {
+          const s = String(cell ?? '');
+          return s.padEnd(widths[i]);
+        })
+        .join(' | ') +
+      ' |'
+    );
+  }
+
+  const lines = [];
+  lines.push(separator);
+  lines.push(formatRow(headers));
+  lines.push(separator);
+  for (const row of rows) {
+    lines.push(formatRow(row));
+  }
+  lines.push(separator);
+
+  console.log(lines.join('\n'));
+}
+
+/**
+ * Parse and format a QueryResult for printing.
+ *
+ * @param {import('./query-result').QueryResult} queryResult - The query result to format.
+ * @param {number} [maxRows=20] - Maximum number of rows to display.
+ */
+function parseAndFormatResults(queryResult, maxRows = 20) {
+  const headers = queryResult.columnNames();
+  const rows = [];
+
+  const totalRecords = queryResult.length();
+  let displayCount = Math.min(maxRows, totalRecords);
+
+  for (const record of queryResult) {
+    const currentRow = [];
+    for (const column of record) {
+      currentRow.push(parseEntry(column));
+    }
+    rows.push(currentRow);
+    displayCount--;
+    if (displayCount <= 0) break;
+  }
+
+  if (totalRecords > maxRows && rows.length > 0) {
+    rows.push(Array(headers.length).fill('...'));
+  }
+
+  printResultsAsTable(headers, rows);
+}
+
+module.exports = { parseEntry, printResultsAsTable, parseAndFormatResults };

package/lib/index.js

@@ -0,0 +1,66 @@
+/** 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.
+ */
+
+/**
+ * NeuG Node.js Bindings
+ *
+ * A high-performance embedded graph database with Cypher query support.
+ *
+ * @example
+ * const { Database } = require('neug');
+ *
+ * // Open an in-memory database
+ * const db = new Database({ mode: 'w' });
+ * const conn = db.connect();
+ *
+ * // Create schema
+ * conn.execute('CREATE (n:person {name: "Alice", age: 30})');
+ *
+ * // Query
+ * const result = conn.execute('MATCH (n) RETURN n');
+ * for (const row of result) {
+ *   console.log(row);
+ * }
+ *
+ * conn.close();
+ * db.close();
+ *
+ * @module neug
+ */
+
+'use strict';
+
+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');
+
+module.exports = {
+  Database,
+  Connection,
+  AsyncConnection,
+  QueryResult,
+  Session,
+  parseAndFormatResults,
+  printResultsAsTable,
+  parseEntry,
+  version,
+  // Error codes (mirrors protobuf Code enum)
+  ...errorCodes,
+};