minigraf 0.22.0

package/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "minigraf-node"
+version = "0.25.0"
+edition = "2024"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+napi = { version = "2.16", features = ["napi6"] }
+napi-derive = "2.16"
+minigraf = { path = ".." }
+serde_json = "1.0"
+
+[build-dependencies]
+napi-build = "2.1"

package/build.rs

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

package/index.d.ts

@@ -0,0 +1,9 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class MiniGrafDb {
+  constructor(path: string)
+  static inMemory(): MiniGrafDb
+  execute(datalog: string): string
+  checkpoint(): void
+}

package/index.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const { platform, arch } = process
+
+let nativeBinding = null
+const loadErrors = []
+
+if (platform === 'linux') {
+  if (arch === 'x64') {
+    try { nativeBinding = require('@minigraf/linux-x64-gnu') }
+    catch (e) { loadErrors.push(e) }
+  } else if (arch === 'arm64') {
+    try { nativeBinding = require('@minigraf/linux-arm64-gnu') }
+    catch (e) { loadErrors.push(e) }
+  }
+} else if (platform === 'darwin') {
+  try { nativeBinding = require('@minigraf/darwin-universal') }
+  catch (e) { loadErrors.push(e) }
+} else if (platform === 'win32') {
+  if (arch === 'x64') {
+    try { nativeBinding = require('@minigraf/win32-x64-msvc') }
+    catch (e) { loadErrors.push(e) }
+  }
+}
+
+if (!nativeBinding) {
+  const errorMessages = loadErrors.map(e => e.message).join('\n')
+  throw new Error(
+    `Failed to load native Minigraf addon for ${platform}-${arch}.\n` +
+    `This platform may not be supported yet.\n` +
+    (errorMessages ? `Errors:\n${errorMessages}` : '')
+  )
+}
+
+module.exports = nativeBinding

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "minigraf",
+  "version": "0.22.0",
+  "description": "Zero-config, single-file, embedded graph database with bi-temporal Datalog queries",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/adityamukho/minigraf.git"
+  },
+  "keywords": [
+    "graph",
+    "datalog",
+    "bitemporal",
+    "embedded",
+    "database"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "napi": {
+    "name": "minigraf",
+    "triples": {
+      "defaults": true,
+      "additional": [
+        "aarch64-unknown-linux-gnu",
+        "universal-apple-darwin"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "napi build --platform --release",
+    "test": "node --test test/basic.test.mjs"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^2.18.0"
+  },
+  "optionalDependencies": {
+    "@minigraf/linux-x64-gnu": "0.25.0",
+    "@minigraf/linux-arm64-gnu": "0.25.0",
+    "@minigraf/darwin-universal": "0.25.0",
+    "@minigraf/win32-x64-msvc": "0.25.0"
+  }
+}

package/packages/@minigraf/darwin-universal/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@minigraf/darwin-universal",
+  "version": "0.22.0",
+  "description": "Zero-config, single-file, embedded graph database with bi-temporal Datalog queries (macOS universal)",
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "main": "minigraf.darwin-universal.node",
+  "files": [
+    "minigraf.darwin-universal.node"
+  ],
+  "license": "MIT OR Apache-2.0",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/packages/@minigraf/linux-arm64-gnu/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@minigraf/linux-arm64-gnu",
+  "version": "0.22.0",
+  "description": "Zero-config, single-file, embedded graph database with bi-temporal Datalog queries (Linux arm64 GNU)",
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "libc": [
+    "glibc"
+  ],
+  "main": "minigraf.linux-arm64-gnu.node",
+  "files": [
+    "minigraf.linux-arm64-gnu.node"
+  ],
+  "license": "MIT OR Apache-2.0",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/packages/@minigraf/linux-x64-gnu/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@minigraf/linux-x64-gnu",
+  "version": "0.22.0",
+  "description": "Zero-config, single-file, embedded graph database with bi-temporal Datalog queries (Linux x64 GNU)",
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "libc": [
+    "glibc"
+  ],
+  "main": "minigraf.linux-x64-gnu.node",
+  "files": [
+    "minigraf.linux-x64-gnu.node"
+  ],
+  "license": "MIT OR Apache-2.0",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/packages/@minigraf/win32-x64-msvc/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@minigraf/win32-x64-msvc",
+  "version": "0.22.0",
+  "description": "Zero-config, single-file, embedded graph database with bi-temporal Datalog queries (Windows x64 MSVC)",
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "main": "minigraf.win32-x64-msvc.node",
+  "files": [
+    "minigraf.win32-x64-msvc.node"
+  ],
+  "license": "MIT OR Apache-2.0",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/lib.rs

@@ -0,0 +1,91 @@
+#![deny(clippy::all)]
+
+use minigraf::{QueryResult, Value};
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+use std::sync::{Arc, Mutex};
+
+// ─── Value → JSON ─────────────────────────────────────────────────────────────
+
+fn value_to_json(v: &Value) -> serde_json::Value {
+    use serde_json::Value as J;
+    match v {
+        Value::String(s) => J::String(s.clone()),
+        Value::Integer(i) => serde_json::json!(i),
+        Value::Float(f) => serde_json::Number::from_f64(*f)
+            .map(J::Number)
+            .unwrap_or(J::Null),
+        Value::Boolean(b) => J::Bool(*b),
+        Value::Ref(u) => J::String(u.to_string()),
+        Value::Keyword(k) => J::String(k.clone()),
+        Value::Null => J::Null,
+    }
+}
+
+fn query_result_to_json(result: QueryResult) -> String {
+    let val = match result {
+        QueryResult::Transacted(tx) => serde_json::json!({"transacted": tx}),
+        QueryResult::Retracted(tx) => serde_json::json!({"retracted": tx}),
+        QueryResult::Ok => serde_json::json!({"ok": true}),
+        QueryResult::QueryResults { vars, results } => {
+            let rows: Vec<Vec<serde_json::Value>> = results
+                .iter()
+                .map(|r| r.iter().map(value_to_json).collect())
+                .collect();
+            serde_json::json!({"variables": vars, "results": rows})
+        }
+    };
+    val.to_string()
+}
+
+// ─── MiniGrafDb ───────────────────────────────────────────────────────────────
+
+#[napi]
+pub struct MiniGrafDb {
+    inner: Arc<Mutex<minigraf::Minigraf>>,
+}
+
+#[napi]
+impl MiniGrafDb {
+    /// Open a file-backed database. Throws on error.
+    #[napi(constructor)]
+    pub fn new(path: String) -> Result<Self> {
+        let db = minigraf::Minigraf::open(&path)
+            .map_err(|e| Error::new(Status::GenericFailure, e.to_string()))?;
+        Ok(Self {
+            inner: Arc::new(Mutex::new(db)),
+        })
+    }
+
+    /// Open an in-memory database. Throws on error.
+    #[napi(factory)]
+    pub fn in_memory() -> Result<Self> {
+        let db = minigraf::Minigraf::in_memory()
+            .map_err(|e| Error::new(Status::GenericFailure, e.to_string()))?;
+        Ok(Self {
+            inner: Arc::new(Mutex::new(db)),
+        })
+    }
+
+    /// Execute a Datalog string. Returns a JSON string. Throws on error.
+    #[napi]
+    pub fn execute(&self, datalog: String) -> Result<String> {
+        let result = self
+            .inner
+            .lock()
+            .map_err(|_| Error::new(Status::GenericFailure, "mutex poisoned"))?
+            .execute(&datalog)
+            .map_err(|e| Error::new(Status::GenericFailure, e.to_string()))?;
+        Ok(query_result_to_json(result))
+    }
+
+    /// Flush the WAL to disk. Throws on error.
+    #[napi]
+    pub fn checkpoint(&self) -> Result<()> {
+        self.inner
+            .lock()
+            .map_err(|_| Error::new(Status::GenericFailure, "mutex poisoned"))?
+            .checkpoint()
+            .map_err(|e| Error::new(Status::GenericFailure, e.to_string()))
+    }
+}

package/test/basic.test.mjs

@@ -0,0 +1,49 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { MiniGrafDb } from '../index.js'
+
+test('open in-memory database', () => {
+  const db = MiniGrafDb.inMemory()
+  assert.ok(db, 'expected non-null db')
+})
+
+test('transact and query', () => {
+  const db = MiniGrafDb.inMemory()
+  const txJson = db.execute('(transact [[:alice :name "Alice"]])')
+  const tx = JSON.parse(txJson)
+  assert.ok('transacted' in tx, 'expected transacted key')
+
+  const queryJson = db.execute('(query [:find ?n :where [?e :name ?n]])')
+  const qr = JSON.parse(queryJson)
+  assert.equal(qr.results[0][0], 'Alice')
+})
+
+test('invalid datalog throws', () => {
+  const db = MiniGrafDb.inMemory()
+  assert.throws(() => db.execute('not valid datalog !!!'))
+})
+
+test('file-backed roundtrip', async (t) => {
+  const os = await import('node:os')
+  const path = await import('node:path')
+  const fs = await import('node:fs')
+
+  const tmpDir = os.default.tmpdir()
+  const dbPath = path.default.join(tmpDir, `minigraf_node_test_${Date.now()}.graph`)
+  const walPath = dbPath + '.wal'
+
+  t.after(() => {
+    try { fs.default.unlinkSync(dbPath) } catch {}
+    try { fs.default.unlinkSync(walPath) } catch {}
+  })
+
+  {
+    const db = new MiniGrafDb(dbPath)
+    db.execute('(transact [[:bob :name "Bob"]])')
+    db.checkpoint()
+  }
+
+  const db2 = new MiniGrafDb(dbPath)
+  const qr = JSON.parse(db2.execute('(query [:find ?n :where [?e :name ?n]])'))
+  assert.equal(qr.results[0][0], 'Bob')
+})