cypherlite 2.0.0 → 2.1.0

package/index.js

@@ -1,20 +1,320 @@
-// Auto-generated loader for the CypherLite native addon.
-// This file loads the platform-specific .node binary.
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
 
-const { existsSync } = require('node:fs');
-const { join } = require('node:path');
+/* auto-generated by NAPI-RS */
 
-// Try to load the .node binary from the current directory.
-const localPath = join(__dirname, 'cypherlite.node');
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
 
-let nativeBinding;
+const { platform, arch } = process
 
-if (existsSync(localPath)) {
-  nativeBinding = require(localPath);
-} else {
-  throw new Error(
-    `Failed to load cypherlite native module. Expected at: ${localPath}`
-  );
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim()
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'cypherlite.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./cypherlite.android-arm64.node')
+          } else {
+            nativeBinding = require('cypherlite-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'cypherlite.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./cypherlite.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('cypherlite-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'cypherlite.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./cypherlite.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('cypherlite-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'cypherlite.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./cypherlite.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('cypherlite-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'cypherlite.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./cypherlite.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('cypherlite-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'cypherlite.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./cypherlite.darwin-universal.node')
+      } else {
+        nativeBinding = require('cypherlite-darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'cypherlite.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./cypherlite.darwin-x64.node')
+          } else {
+            nativeBinding = require('cypherlite-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'cypherlite.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./cypherlite.darwin-arm64.node')
+          } else {
+            nativeBinding = require('cypherlite-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'cypherlite.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./cypherlite.freebsd-x64.node')
+      } else {
+        nativeBinding = require('cypherlite-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'cypherlite.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./cypherlite.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('cypherlite-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'cypherlite.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./cypherlite.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('cypherlite-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'cypherlite.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./cypherlite.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('cypherlite-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'cypherlite.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./cypherlite.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('cypherlite-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'cypherlite.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./cypherlite.linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('cypherlite-linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'cypherlite.linux-arm-gnueabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./cypherlite.linux-arm-gnueabihf.node')
+            } else {
+              nativeBinding = require('cypherlite-linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'cypherlite.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./cypherlite.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('cypherlite-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'cypherlite.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./cypherlite.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('cypherlite-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
+        localFileExisted = existsSync(
+          join(__dirname, 'cypherlite.linux-s390x-gnu.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./cypherlite.linux-s390x-gnu.node')
+          } else {
+            nativeBinding = require('cypherlite-linux-s390x-gnu')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
 }
 
-module.exports = nativeBinding;
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { Database, open, CylResult, Transaction, version, features } = nativeBinding
+
+module.exports.Database = Database
+module.exports.open = open
+module.exports.CylResult = CylResult
+module.exports.Transaction = Transaction
+module.exports.version = version
+module.exports.features = features

package/lib.d.ts

@@ -0,0 +1,11 @@
+// Augmented type definitions for CypherLite Node.js bindings.
+// index.d.ts is auto-generated by napi-rs on each build;
+// this file adds the Symbol.iterator type applied at runtime by lib.js.
+
+export * from './index.js';
+
+declare module './index.js' {
+  interface CylResult extends Iterable<Record<string, any>> {
+    [Symbol.iterator](): Iterator<Record<string, any>>;
+  }
+}

package/lib.js

@@ -0,0 +1,19 @@
+'use strict';
+
+// Wrapper around the napi-rs auto-generated index.js entry point.
+// index.js is regenerated by `napi build --platform` and cannot be
+// modified directly. This file patches runtime behavior (Symbol.iterator)
+// and serves as the package entry point ("main" in package.json).
+// CJS is required here because index.js is CommonJS.
+
+const binding = require('./index.js');
+
+// Add Symbol.iterator to CylResult so for...of, spread, and
+// Array.from work on query results.
+binding.CylResult.prototype[Symbol.iterator] = function* () {
+  for (let i = 0; i < this.length; i++) {
+    yield this.row(i);
+  }
+};
+
+module.exports = binding;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "cypherlite",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Lightweight embedded graph database with Cypher query support",
-  "main": "index.js",
-  "types": "index.d.ts",
+  "main": "lib.js",
+  "types": "lib.d.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/Epsilondelta-ai/CypherLite.git"
@@ -21,13 +21,24 @@
     "graph-database",
     "napi-rs"
   ],
+  "files": [
+    "lib.js",
+    "lib.d.ts",
+    "index.js",
+    "index.d.ts",
+    "README.md",
+    "*.node"
+  ],
   "napi": {
     "name": "cypherlite",
-    "triples": {}
+    "triples": {
+      "defaults": true,
+      "additional": ["aarch64-unknown-linux-gnu"]
+    }
   },
   "scripts": {
-    "build": "napi build --release",
-    "build:debug": "napi build",
+    "build": "napi build --platform --release",
+    "build:debug": "napi build --platform",
     "test": "vitest run"
   },
   "devDependencies": {

package/Cargo.toml

@@ -1,28 +0,0 @@
-[package]
-name = "cypherlite-node"
-version = "2.0.0"
-edition = "2021"
-rust-version = "1.84"
-description = "Node.js bindings for CypherLite embedded graph database via napi-rs"
-publish = false
-
-[lib]
-crate-type = ["cdylib"]
-
-[features]
-default = ["temporal-core"]
-temporal-core = ["cypherlite-query/temporal-core", "cypherlite-core/temporal-core"]
-temporal-edge = ["temporal-core", "cypherlite-query/temporal-edge", "cypherlite-core/temporal-edge"]
-subgraph = ["temporal-edge", "cypherlite-query/subgraph", "cypherlite-core/subgraph"]
-hypergraph = ["subgraph", "cypherlite-query/hypergraph", "cypherlite-core/hypergraph"]
-full-temporal = ["hypergraph", "cypherlite-query/full-temporal", "cypherlite-core/full-temporal"]
-plugin = ["cypherlite-query/plugin", "cypherlite-core/plugin"]
-
-[dependencies]
-napi = { version = "2", features = ["napi9"] }
-napi-derive = "2"
-cypherlite-query = { version = "2.0.0", path = "../cypherlite-query" }
-cypherlite-core = { version = "2.0.0", path = "../cypherlite-core" }
-
-[build-dependencies]
-napi-build = "2"

package/__test__/index.spec.mjs

@@ -1,405 +0,0 @@
-// CypherLite Node.js bindings specification tests.
-//
-// These tests define the expected behavior of the napi-rs bindings.
-// They cover: version/features, database lifecycle, query execution,
-// parameter binding, transactions, result access, value types, and errors.
-
-import { describe, it, expect, afterEach } from 'vitest';
-import { tmpdir } from 'node:os';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-
-// The native module is loaded from the build output.
-import {
-  version,
-  features,
-  open,
-  Database,
-  CylResult,
-  Transaction,
-} from '../index.js';
-
-// Helper: create a temporary directory for each test.
-async function createTempDir() {
-  return mkdtemp(join(tmpdir(), 'cypherlite-node-test-'));
-}
-
-// Track temp dirs for cleanup.
-const tempDirs = [];
-
-afterEach(async () => {
-  for (const dir of tempDirs) {
-    await rm(dir, { recursive: true, force: true }).catch(() => {});
-  }
-  tempDirs.length = 0;
-});
-
-async function openTempDb(options) {
-  const dir = await createTempDir();
-  tempDirs.push(dir);
-  const dbPath = join(dir, 'test.cyl');
-  return open(dbPath, options);
-}
-
-// ============================================================
-// M1: Version and Features
-// ============================================================
-
-describe('version and features', () => {
-  it('should return a version string', () => {
-    const v = version();
-    expect(typeof v).toBe('string');
-    expect(v).toMatch(/^\d+\.\d+\.\d+$/);
-  });
-
-  it('should return a features string', () => {
-    const f = features();
-    expect(typeof f).toBe('string');
-    // At minimum, temporal-core should be present (default feature).
-    expect(f).toContain('temporal-core');
-  });
-});
-
-// ============================================================
-// M2: Database Lifecycle
-// ============================================================
-
-describe('database lifecycle', () => {
-  it('should open a database', async () => {
-    const db = await openTempDb();
-    expect(db).toBeInstanceOf(Database);
-    db.close();
-  });
-
-  it('should open with custom options', async () => {
-    const db = await openTempDb({ pageSize: 4096, cacheCapacity: 128 });
-    expect(db).toBeInstanceOf(Database);
-    db.close();
-  });
-
-  it('should report isClosed correctly', async () => {
-    const db = await openTempDb();
-    expect(db.isClosed).toBe(false);
-    db.close();
-    expect(db.isClosed).toBe(true);
-  });
-
-  it('should allow close to be called multiple times', async () => {
-    const db = await openTempDb();
-    db.close();
-    expect(() => db.close()).not.toThrow();
-  });
-
-  it('should throw on execute after close', async () => {
-    const db = await openTempDb();
-    db.close();
-    expect(() => db.execute("MATCH (n) RETURN n")).toThrow(/closed/i);
-  });
-});
-
-// ============================================================
-// M3: Query Execution
-// ============================================================
-
-describe('query execution', () => {
-  it('should execute CREATE and MATCH', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (n:Person {name: 'Alice', age: 30})");
-    const result = db.execute("MATCH (n:Person) RETURN n.name, n.age");
-    expect(result).toBeInstanceOf(CylResult);
-    expect(result.length).toBe(1);
-    const row = result.row(0);
-    expect(row['n.name']).toBe('Alice');
-    expect(row['n.age']).toBe(30);
-    db.close();
-  });
-
-  it('should return empty result for non-existent label', async () => {
-    const db = await openTempDb();
-    const result = db.execute("MATCH (n:Ghost) RETURN n");
-    expect(result.length).toBe(0);
-    db.close();
-  });
-
-  it('should execute with parameters', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (n:Person {name: 'Alice'})");
-    const result = db.execute(
-      "MATCH (n:Person) WHERE n.name = $name RETURN n.name",
-      { name: 'Alice' }
-    );
-    expect(result.length).toBe(1);
-    expect(result.row(0)['n.name']).toBe('Alice');
-    db.close();
-  });
-
-  it('should handle multiple rows', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (n:Person {name: 'Alice'})");
-    db.execute("CREATE (n:Person {name: 'Bob'})");
-    db.execute("CREATE (n:Person {name: 'Charlie'})");
-    const result = db.execute("MATCH (n:Person) RETURN n.name");
-    expect(result.length).toBe(3);
-    const names = result.toArray().map(r => r['n.name']).sort();
-    expect(names).toEqual(['Alice', 'Bob', 'Charlie']);
-    db.close();
-  });
-
-  it('should handle SET then MATCH', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (n:Person {name: 'Alice', age: 25})");
-    db.execute("MATCH (n:Person) SET n.age = 30");
-    const result = db.execute("MATCH (n:Person) RETURN n.age");
-    expect(result.row(0)['n.age']).toBe(30);
-    db.close();
-  });
-
-  it('should handle DETACH DELETE', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (a:Person {name: 'Alice'})-[:KNOWS]->(b:Person {name: 'Bob'})");
-    db.execute("MATCH (n:Person) DETACH DELETE n");
-    const result = db.execute("MATCH (n:Person) RETURN n");
-    expect(result.length).toBe(0);
-    db.close();
-  });
-});
-
-// ============================================================
-// M4: Transaction Support
-// ============================================================
-
-describe('transactions', () => {
-  it('should begin and commit a transaction', async () => {
-    const db = await openTempDb();
-    const tx = db.begin();
-    expect(tx).toBeInstanceOf(Transaction);
-    tx.execute("CREATE (n:Person {name: 'Alice'})");
-    tx.commit();
-    const result = db.execute("MATCH (n:Person) RETURN n.name");
-    expect(result.length).toBe(1);
-    expect(result.row(0)['n.name']).toBe('Alice');
-    db.close();
-  });
-
-  it('should begin and rollback a transaction', async () => {
-    const db = await openTempDb();
-    const tx = db.begin();
-    tx.execute("CREATE (n:Person {name: 'Bob'})");
-    tx.rollback();
-    // After rollback (Phase 2 no-op), data may still exist.
-    // The important thing is no error is thrown.
-    db.close();
-  });
-
-  it('should throw on execute after commit', async () => {
-    const db = await openTempDb();
-    const tx = db.begin();
-    tx.commit();
-    expect(() => tx.execute("CREATE (n:Person {name: 'X'})")).toThrow(/finished/i);
-    db.close();
-  });
-
-  it('should throw on execute after rollback', async () => {
-    const db = await openTempDb();
-    const tx = db.begin();
-    tx.rollback();
-    expect(() => tx.execute("CREATE (n:Person {name: 'X'})")).toThrow(/finished/i);
-    db.close();
-  });
-
-  it('should throw on double commit', async () => {
-    const db = await openTempDb();
-    const tx = db.begin();
-    tx.commit();
-    expect(() => tx.commit()).toThrow(/finished/i);
-    db.close();
-  });
-
-  it('should execute with params in transaction', async () => {
-    const db = await openTempDb();
-    const tx = db.begin();
-    tx.execute("CREATE (n:Person {name: 'Alice'})");
-    const result = tx.execute(
-      "MATCH (n:Person) WHERE n.name = $name RETURN n.name",
-      { name: 'Alice' }
-    );
-    expect(result.length).toBe(1);
-    tx.commit();
-    db.close();
-  });
-});
-
-// ============================================================
-// M5: Result and Row Access
-// ============================================================
-
-describe('result access', () => {
-  it('should expose column names', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (n:Person {name: 'Alice', age: 30})");
-    const result = db.execute("MATCH (n:Person) RETURN n.name, n.age");
-    const cols = result.columns;
-    expect(Array.isArray(cols)).toBe(true);
-    expect(cols).toContain('n.name');
-    expect(cols).toContain('n.age');
-    db.close();
-  });
-
-  it('should expose row count via length', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (n:Person {name: 'Alice'})");
-    db.execute("CREATE (n:Person {name: 'Bob'})");
-    const result = db.execute("MATCH (n:Person) RETURN n.name");
-    expect(result.length).toBe(2);
-    db.close();
-  });
-
-  it('should access individual row by index', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (n:Person {name: 'Alice', age: 30})");
-    const result = db.execute("MATCH (n:Person) RETURN n.name, n.age");
-    const row = result.row(0);
-    expect(typeof row).toBe('object');
-    expect(row['n.name']).toBe('Alice');
-    expect(row['n.age']).toBe(30);
-    db.close();
-  });
-
-  it('should throw on out-of-range row index', async () => {
-    const db = await openTempDb();
-    const result = db.execute("MATCH (n:Ghost) RETURN n");
-    expect(() => result.row(0)).toThrow(/out of range/i);
-    db.close();
-  });
-
-  it('should convert all rows via toArray', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (n:Person {name: 'Alice'})");
-    db.execute("CREATE (n:Person {name: 'Bob'})");
-    const result = db.execute("MATCH (n:Person) RETURN n.name");
-    const rows = result.toArray();
-    expect(Array.isArray(rows)).toBe(true);
-    expect(rows.length).toBe(2);
-    const names = rows.map(r => r['n.name']).sort();
-    expect(names).toEqual(['Alice', 'Bob']);
-    db.close();
-  });
-});
-
-// ============================================================
-// M6: Value Type Conversions
-// ============================================================
-
-describe('value types', () => {
-  it('should handle null values', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (n:Person {name: 'Alice'})");
-    const result = db.execute("MATCH (n:Person) RETURN n.name, n.email");
-    const row = result.row(0);
-    expect(row['n.name']).toBe('Alice');
-    // Missing property should be null.
-    expect(row['n.email']).toBeNull();
-    db.close();
-  });
-
-  it('should handle boolean values', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (n:Flag {active: true})");
-    const result = db.execute("MATCH (n:Flag) RETURN n.active");
-    expect(result.row(0)['n.active']).toBe(true);
-    db.close();
-  });
-
-  it('should handle integer values', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (n:Num {val: 42})");
-    const result = db.execute("MATCH (n:Num) RETURN n.val");
-    expect(result.row(0)['n.val']).toBe(42);
-    db.close();
-  });
-
-  it('should handle float values', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (n:Num {val: 3.14})");
-    const result = db.execute("MATCH (n:Num) RETURN n.val");
-    expect(result.row(0)['n.val']).toBeCloseTo(3.14);
-    db.close();
-  });
-
-  it('should handle string values', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (n:Text {val: 'hello world'})");
-    const result = db.execute("MATCH (n:Text) RETURN n.val");
-    expect(result.row(0)['n.val']).toBe('hello world');
-    db.close();
-  });
-
-  it('should handle node ID as BigInt', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (n:Person {name: 'Alice'})");
-    const result = db.execute("MATCH (n:Person) RETURN n");
-    const row = result.row(0);
-    // Node value should be a BigInt (node ID).
-    expect(typeof row['n']).toBe('bigint');
-    db.close();
-  });
-
-  it('should handle edge ID as BigInt', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (a:Person {name: 'A'})-[:KNOWS]->(b:Person {name: 'B'})");
-    const result = db.execute("MATCH ()-[r:KNOWS]->() RETURN r");
-    const row = result.row(0);
-    // Edge value should be a BigInt (edge ID).
-    expect(typeof row['r']).toBe('bigint');
-    db.close();
-  });
-
-  it('should handle parameter types (string, int, float, bool, null)', async () => {
-    const db = await openTempDb();
-    db.execute("CREATE (n:Item {name: 'test'})");
-    // String param
-    let result = db.execute(
-      "MATCH (n:Item) WHERE n.name = $v RETURN n.name",
-      { v: 'test' }
-    );
-    expect(result.length).toBe(1);
-    // Int param
-    db.execute("CREATE (n:Num {val: 42})");
-    result = db.execute(
-      "MATCH (n:Num) WHERE n.val = $v RETURN n.val",
-      { v: 42 }
-    );
-    expect(result.length).toBe(1);
-    db.close();
-  });
-});
-
-// ============================================================
-// Error Handling
-// ============================================================
-
-describe('error handling', () => {
-  it('should throw on invalid Cypher syntax', async () => {
-    const db = await openTempDb();
-    expect(() => db.execute("INVALID QUERY @#$")).toThrow();
-    db.close();
-  });
-
-  it('should throw on semantic error (undefined variable)', async () => {
-    const db = await openTempDb();
-    expect(() => db.execute("MATCH (n:Person) RETURN m.name")).toThrow();
-    db.close();
-  });
-
-  it('should include error message in thrown error', async () => {
-    const db = await openTempDb();
-    try {
-      db.execute("MATCH (n:Person RETURN n");
-      expect.unreachable('should have thrown');
-    } catch (e) {
-      expect(e.message).toBeTruthy();
-      expect(typeof e.message).toBe('string');
-    }
-    db.close();
-  });
-});

package/build.rs

@@ -1,5 +0,0 @@
-extern crate napi_build;
-
-fn main() {
-    napi_build::setup();
-}

package/src/database.rs

@@ -1,121 +0,0 @@
-// Database lifecycle and query execution for Node.js.
-
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex};
-
-use napi::Env;
-
-use cypherlite_core::DatabaseConfig;
-use cypherlite_query::api::CypherLite;
-
-use crate::error::{db_closed, mutex_poisoned, to_napi_error};
-use crate::result::CylResult;
-use crate::transaction::Transaction;
-use crate::value::convert_params;
-
-/// Options for opening a database.
-#[napi(object)]
-pub struct OpenOptions {
-    /// Page size in bytes (default: 4096).
-    pub page_size: Option<u32>,
-    /// Number of pages in the buffer pool cache (default: 256).
-    pub cache_capacity: Option<u32>,
-}
-
-/// The main CypherLite database handle for Node.js.
-#[napi]
-pub struct Database {
-    inner: Arc<Mutex<Option<CypherLite>>>,
-    in_transaction: Arc<AtomicBool>,
-}
-
-/// Open a CypherLite database at the given path.
-#[napi]
-pub fn open(path: String, options: Option<OpenOptions>) -> napi::Result<Database> {
-    let config = DatabaseConfig {
-        path: std::path::PathBuf::from(&path),
-        page_size: options.as_ref().and_then(|o| o.page_size).unwrap_or(4096),
-        cache_capacity: options
-            .as_ref()
-            .and_then(|o| o.cache_capacity)
-            .unwrap_or(256) as usize,
-        ..Default::default()
-    };
-    let db = CypherLite::open(config).map_err(to_napi_error)?;
-    Ok(Database {
-        inner: Arc::new(Mutex::new(Some(db))),
-        in_transaction: Arc::new(AtomicBool::new(false)),
-    })
-}
-
-#[napi]
-impl Database {
-    /// Execute a Cypher query string.
-    ///
-    /// Optional second argument provides named parameters as a plain object.
-    #[napi]
-    pub fn execute(
-        &self,
-        env: Env,
-        query: String,
-        params: Option<napi::JsObject>,
-    ) -> napi::Result<CylResult> {
-        if self.in_transaction.load(Ordering::SeqCst) {
-            return Err(napi::Error::from_reason(
-                "cannot execute on database while a transaction is active",
-            ));
-        }
-        let rust_params = convert_params(&env, params)?;
-        let mut guard = self.inner.lock().map_err(|_| mutex_poisoned())?;
-        let db = guard.as_mut().ok_or_else(db_closed)?;
-        let qr = if rust_params.is_empty() {
-            db.execute(&query).map_err(to_napi_error)?
-        } else {
-            db.execute_with_params(&query, rust_params)
-                .map_err(to_napi_error)?
-        };
-        Ok(CylResult::from_query_result(qr))
-    }
-
-    /// Close the database. Safe to call multiple times.
-    #[napi]
-    pub fn close(&self) -> napi::Result<()> {
-        let mut guard = self.inner.lock().map_err(|_| mutex_poisoned())?;
-        let _ = guard.take();
-        Ok(())
-    }
-
-    /// Check if the database is closed.
-    #[napi(getter, js_name = "isClosed")]
-    pub fn is_closed(&self) -> napi::Result<bool> {
-        let guard = self.inner.lock().map_err(|_| mutex_poisoned())?;
-        Ok(guard.is_none())
-    }
-
-    /// Begin a new transaction.
-    #[napi]
-    pub fn begin(&self) -> napi::Result<Transaction> {
-        // Check database is open.
-        {
-            let guard = self.inner.lock().map_err(|_| mutex_poisoned())?;
-            if guard.is_none() {
-                return Err(db_closed());
-            }
-        }
-
-        // Check no transaction is already active.
-        if self
-            .in_transaction
-            .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
-            .is_err()
-        {
-            return Err(napi::Error::from_reason("a transaction is already active"));
-        }
-
-        Ok(Transaction {
-            inner: Arc::clone(&self.inner),
-            in_transaction: Arc::clone(&self.in_transaction),
-            finished: false,
-        })
-    }
-}

package/src/error.rs

@@ -1,18 +0,0 @@
-// Error conversion from CypherLiteError to napi::Error.
-
-use cypherlite_core::CypherLiteError;
-
-/// Convert a CypherLiteError into a napi::Error suitable for throwing in JS.
-pub fn to_napi_error(e: CypherLiteError) -> napi::Error {
-    napi::Error::from_reason(e.to_string())
-}
-
-/// Create an error for a poisoned mutex.
-pub fn mutex_poisoned() -> napi::Error {
-    napi::Error::from_reason("internal error: mutex poisoned")
-}
-
-/// Create an error for a closed database.
-pub fn db_closed() -> napi::Error {
-    napi::Error::from_reason("database is closed")
-}

package/src/lib.rs

@@ -1,44 +0,0 @@
-// CypherLite Node.js Bindings via napi-rs.
-//
-// This crate exposes the CypherLite embedded graph database as a native
-// Node.js addon built with @napi-rs/cli.
-
-#[macro_use]
-extern crate napi_derive;
-
-pub mod database;
-pub mod error;
-pub mod result;
-pub mod transaction;
-pub mod value;
-
-/// Return the library version string.
-#[napi]
-pub fn version() -> String {
-    env!("CARGO_PKG_VERSION").to_string()
-}
-
-/// Return a comma-separated string of compiled feature flags.
-#[napi]
-pub fn features() -> String {
-    let mut flags = Vec::new();
-    if cfg!(feature = "temporal-core") {
-        flags.push("temporal-core");
-    }
-    if cfg!(feature = "temporal-edge") {
-        flags.push("temporal-edge");
-    }
-    if cfg!(feature = "subgraph") {
-        flags.push("subgraph");
-    }
-    if cfg!(feature = "hypergraph") {
-        flags.push("hypergraph");
-    }
-    if cfg!(feature = "full-temporal") {
-        flags.push("full-temporal");
-    }
-    if cfg!(feature = "plugin") {
-        flags.push("plugin");
-    }
-    flags.join(",")
-}

package/src/result.rs

@@ -1,87 +0,0 @@
-// Query result wrapper for Node.js.
-
-use cypherlite_query::api::QueryResult;
-use cypherlite_query::executor::Value;
-use napi::Env;
-
-use crate::value::rust_to_js;
-
-/// A query result containing columns and rows.
-///
-/// Row data is stored as Rust types and converted to JS on access.
-#[napi]
-pub struct CylResult {
-    columns: Vec<String>,
-    /// Each row is a Vec of Values in column order.
-    rows: Vec<Vec<Value>>,
-}
-
-impl CylResult {
-    /// Create from a Rust QueryResult.
-    pub fn from_query_result(qr: QueryResult) -> Self {
-        let columns = qr.columns;
-        let rows: Vec<Vec<Value>> = qr
-            .rows
-            .iter()
-            .map(|row| {
-                columns
-                    .iter()
-                    .map(|col| row.get(col).cloned().unwrap_or(Value::Null))
-                    .collect()
-            })
-            .collect();
-        Self { columns, rows }
-    }
-}
-
-#[napi]
-impl CylResult {
-    /// Column names as an array of strings.
-    #[napi(getter)]
-    pub fn columns(&self) -> Vec<String> {
-        self.columns.clone()
-    }
-
-    /// Number of rows in the result.
-    #[napi(getter)]
-    pub fn length(&self) -> u32 {
-        self.rows.len() as u32
-    }
-
-    /// Get a single row by index as a plain JS object.
-    #[napi]
-    pub fn row(&self, env: Env, index: u32) -> napi::Result<napi::JsObject> {
-        let idx = index as usize;
-        if idx >= self.rows.len() {
-            return Err(napi::Error::from_reason(format!(
-                "row index out of range: {} >= {}",
-                idx,
-                self.rows.len()
-            )));
-        }
-        self.row_to_object(&env, idx)
-    }
-
-    /// Convert all rows to an array of plain JS objects.
-    #[napi(js_name = "toArray")]
-    pub fn to_array(&self, env: Env) -> napi::Result<Vec<napi::JsObject>> {
-        let mut result = Vec::with_capacity(self.rows.len());
-        for i in 0..self.rows.len() {
-            result.push(self.row_to_object(&env, i)?);
-        }
-        Ok(result)
-    }
-}
-
-impl CylResult {
-    /// Build a JS object for a single row.
-    fn row_to_object(&self, env: &Env, row_idx: usize) -> napi::Result<napi::JsObject> {
-        let mut obj = env.create_object()?;
-        let row = &self.rows[row_idx];
-        for (i, col) in self.columns.iter().enumerate() {
-            let js_val = rust_to_js(env, &row[i])?;
-            obj.set_named_property(col, js_val)?;
-        }
-        Ok(obj)
-    }
-}

package/src/transaction.rs

@@ -1,85 +0,0 @@
-// Transaction wrapper for Node.js.
-
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex};
-
-use napi::Env;
-
-use cypherlite_query::api::CypherLite;
-
-use crate::error::{db_closed, mutex_poisoned, to_napi_error};
-use crate::result::CylResult;
-use crate::value::convert_params;
-
-/// A transaction wrapping CypherLite execute calls.
-///
-/// Shares the database Mutex with the parent Database object.
-#[napi]
-pub struct Transaction {
-    pub(crate) inner: Arc<Mutex<Option<CypherLite>>>,
-    pub(crate) in_transaction: Arc<AtomicBool>,
-    pub(crate) finished: bool,
-}
-
-impl Drop for Transaction {
-    fn drop(&mut self) {
-        // Auto-rollback: clear the transaction flag.
-        self.finish();
-    }
-}
-
-impl Transaction {
-    /// Mark this transaction as finished and clear the in_transaction flag.
-    fn finish(&mut self) {
-        if !self.finished {
-            self.finished = true;
-            self.in_transaction.store(false, Ordering::SeqCst);
-        }
-    }
-}
-
-#[napi]
-impl Transaction {
-    /// Execute a Cypher query within this transaction.
-    #[napi]
-    pub fn execute(
-        &mut self,
-        env: Env,
-        query: String,
-        params: Option<napi::JsObject>,
-    ) -> napi::Result<CylResult> {
-        if self.finished {
-            return Err(napi::Error::from_reason("transaction is already finished"));
-        }
-        let rust_params = convert_params(&env, params)?;
-        let mut guard = self.inner.lock().map_err(|_| mutex_poisoned())?;
-        let db = guard.as_mut().ok_or_else(db_closed)?;
-        let qr = if rust_params.is_empty() {
-            db.execute(&query).map_err(to_napi_error)?
-        } else {
-            db.execute_with_params(&query, rust_params)
-                .map_err(to_napi_error)?
-        };
-        Ok(CylResult::from_query_result(qr))
-    }
-
-    /// Commit the transaction.
-    #[napi]
-    pub fn commit(&mut self) -> napi::Result<()> {
-        if self.finished {
-            return Err(napi::Error::from_reason("transaction is already finished"));
-        }
-        self.finish();
-        Ok(())
-    }
-
-    /// Rollback the transaction (Phase 2: no-op at storage level).
-    #[napi]
-    pub fn rollback(&mut self) -> napi::Result<()> {
-        if self.finished {
-            return Err(napi::Error::from_reason("transaction is already finished"));
-        }
-        self.finish();
-        Ok(())
-    }
-}

package/src/value.rs

@@ -1,136 +0,0 @@
-// Value conversion between Rust executor::Value and JavaScript values.
-
-use cypherlite_query::executor::Value;
-use napi::{Env, JsObject, JsUnknown, ValueType};
-
-/// Create a JS BigInt from a u64 entity ID.
-fn u64_to_bigint(env: &Env, id: u64) -> napi::Result<JsUnknown> {
-    // Node IDs are unsigned; create_bigint_from_words takes (sign, words).
-    let (sign, words) = if (id as i64) < 0 {
-        (true, vec![id])
-    } else {
-        (false, vec![id])
-    };
-    env.create_bigint_from_words(sign, words)?.into_unknown()
-}
-
-/// Convert a Rust Value to a JavaScript value.
-pub fn rust_to_js(env: &Env, val: &Value) -> napi::Result<JsUnknown> {
-    match val {
-        Value::Null => Ok(env.get_null()?.into_unknown()),
-        Value::Bool(b) => Ok(env.get_boolean(*b)?.into_unknown()),
-        Value::Int64(i) => Ok(env.create_int64(*i)?.into_unknown()),
-        Value::Float64(f) => Ok(env.create_double(*f)?.into_unknown()),
-        Value::String(s) => Ok(env.create_string(s)?.into_unknown()),
-        Value::Bytes(b) => {
-            let buf = env.create_buffer_with_data(b.clone())?;
-            Ok(buf.into_unknown())
-        }
-        Value::List(items) => {
-            let mut arr = env.create_array_with_length(items.len())?;
-            for (i, item) in items.iter().enumerate() {
-                let js_val = rust_to_js(env, item)?;
-                arr.set_element(i as u32, js_val)?;
-            }
-            Ok(arr.into_unknown())
-        }
-        Value::Node(id) => u64_to_bigint(env, id.0),
-        Value::Edge(id) => u64_to_bigint(env, id.0),
-        Value::DateTime(ms) => Ok(env.create_int64(*ms)?.into_unknown()),
-        #[cfg(feature = "subgraph")]
-        Value::Subgraph(id) => u64_to_bigint(env, id.0),
-        #[cfg(feature = "hypergraph")]
-        Value::Hyperedge(id) => u64_to_bigint(env, id.0),
-        #[cfg(feature = "hypergraph")]
-        Value::TemporalNode(id, ms) => {
-            // Return as a plain object with nodeId and timestamp fields.
-            let mut obj = env.create_object()?;
-            let bigint = u64_to_bigint(env, id.0)?;
-            obj.set_named_property("nodeId", bigint)?;
-            obj.set_named_property("timestamp", env.create_int64(*ms)?)?;
-            Ok(obj.into_unknown())
-        }
-    }
-}
-
-/// Convert a JavaScript value to a Rust Value.
-#[allow(clippy::only_used_in_recursion)]
-pub fn js_to_rust(env: &Env, val: JsUnknown) -> napi::Result<Value> {
-    match val.get_type()? {
-        ValueType::Null | ValueType::Undefined => Ok(Value::Null),
-        ValueType::Boolean => {
-            let b = val.coerce_to_bool()?.get_value()?;
-            Ok(Value::Bool(b))
-        }
-        ValueType::Number => {
-            let n = val.coerce_to_number()?;
-            let f = n.get_double()?;
-            // If the number is an integer (no fractional part and within i64 range),
-            // store as Int64 for better compatibility with Cypher integer semantics.
-            if f.fract() == 0.0 && f >= i64::MIN as f64 && f <= i64::MAX as f64 {
-                Ok(Value::Int64(f as i64))
-            } else {
-                Ok(Value::Float64(f))
-            }
-        }
-        ValueType::String => {
-            let s = val.coerce_to_string()?.into_utf8()?;
-            Ok(Value::String(s.as_str()?.to_string()))
-        }
-        ValueType::BigInt => {
-            let mut bigint = unsafe { val.cast::<napi::JsBigInt>() };
-            let (signed, value) = bigint.get_words()?;
-            // Simple conversion: take the first word as u64, apply sign.
-            let raw = value.first().copied().unwrap_or(0);
-            let result = if signed { -(raw as i64) } else { raw as i64 };
-            Ok(Value::Int64(result))
-        }
-        ValueType::Object => {
-            // Check if it is an array.
-            let obj: JsObject = unsafe { val.cast() };
-            if obj.is_array()? {
-                let len = obj.get_array_length()?;
-                let mut items = Vec::with_capacity(len as usize);
-                for i in 0..len {
-                    let elem: JsUnknown = obj.get_element(i)?;
-                    items.push(js_to_rust(env, elem)?);
-                }
-                return Ok(Value::List(items));
-            }
-            // Check if it is a Buffer.
-            if obj.is_buffer()? {
-                let unknown = obj.into_unknown();
-                let buf = napi::JsBuffer::try_from(unknown)?;
-                let data = buf.into_value()?;
-                return Ok(Value::Bytes(data.to_vec()));
-            }
-            Err(napi::Error::from_reason(
-                "cannot convert JS object to CypherLite value",
-            ))
-        }
-        _ => Err(napi::Error::from_reason(format!(
-            "cannot convert JS type {:?} to CypherLite value",
-            val.get_type()?
-        ))),
-    }
-}
-
-/// Convert a JS object of params ({ key: value, ... }) to a HashMap.
-pub fn convert_params(
-    env: &Env,
-    params: Option<JsObject>,
-) -> napi::Result<std::collections::HashMap<String, Value>> {
-    let Some(obj) = params else {
-        return Ok(std::collections::HashMap::new());
-    };
-    let keys = obj.get_property_names()?;
-    let len = keys.get_array_length()?;
-    let mut map = std::collections::HashMap::with_capacity(len as usize);
-    for i in 0..len {
-        let key: napi::JsString = keys.get_element(i)?;
-        let key_str = key.into_utf8()?.as_str()?.to_string();
-        let val: JsUnknown = obj.get_named_property(&key_str)?;
-        map.insert(key_str, js_to_rust(env, val)?);
-    }
-    Ok(map)
-}

package/vitest.config.mjs

@@ -1,8 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    include: ['__test__/**/*.spec.{js,mjs,ts}'],
-    testTimeout: 30000,
-  },
-});