From 2c3323e22ec924b5993716bb0641596025310db3 Mon Sep 17 00:00:00 2001 From: Aditya Mukhopadhyay Date: Mon, 18 May 2026 07:09:18 +0530 Subject: [PATCH 1/6] =?UTF-8?q?docs(spec):=20repo=20split=20phase=202=20?= =?UTF-8?q?=E2=80=94=20Java,=20Android,=20Swift,=20C,=20template?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Spec for splitting remaining bindings out of the monorepo into independent project-minigraf repos, retiring minigraf-ffi, and updating cascade to dispatch to all four new binding repos. Co-Authored-By: Claude Sonnet 4.6 --- .../2026-05-18-repo-split-phase2-design.md | 184 ++++++++++++++++++ 1 file changed, 184 insertions(+) create mode 100644 docs/superpowers/specs/2026-05-18-repo-split-phase2-design.md diff --git a/docs/superpowers/specs/2026-05-18-repo-split-phase2-design.md b/docs/superpowers/specs/2026-05-18-repo-split-phase2-design.md new file mode 100644 index 0000000000..dfa1c04311 --- /dev/null +++ b/docs/superpowers/specs/2026-05-18-repo-split-phase2-design.md @@ -0,0 +1,184 @@ +# Repo Split Phase 2 — Java, Android, Swift, C, Template + +> **For agentic workers:** Use superpowers:subagent-driven-development or superpowers:executing-plans to implement this plan task-by-task. + +**Goal:** Split `minigraf-java`, `minigraf-android`, `minigraf-swift`, `minigraf-c`, and `minigraf-binding-template` out of the monorepo into independent repos under the `project-minigraf` org; retire `minigraf-ffi`; update cascade to dispatch to all four new binding repos. + +--- + +## Context + +Phase 1 of #231 split Python, Node, and WASM into separate repos. Phase 2 covers the remaining bindings. The key learnings from Phase 1: + +- Binding repos depend directly on the published `minigraf` core crate, **not** on `minigraf-ffi` +- `minigraf-ffi` cannot be used as a Rust library dependency for building new bindings — UniFFI scaffolding must live in the final cdylib crate. This makes it unsuitable as a published crate +- Each binding repo embeds its own copy of the UniFFI scaffolding source (`src/lib.rs` + `src/uniffi_bindgen.rs`) + +`minigraf-ffi` is therefore retired: all published versions yanked on crates.io, directory removed from monorepo. + +--- + +## Repos Created + +| Repo | Publishes to | Artifact coordinates | +|---|---|---| +| `minigraf-java` | Maven Central | `io.github.project-minigraf:minigraf-jvm:` | +| `minigraf-android` | Maven Central | `io.github.project-minigraf:minigraf-android:` | +| `minigraf-swift` | GitHub Release + SPM binary target | `MinigrafKit` xcframework zip | +| `minigraf-c` | GitHub Release | `minigraf-c--.(tar.gz\|zip)` | +| `minigraf-binding-template` | GitHub template repo (no publish) | — | + +--- + +## Per-Repo Structure + +All four binding repos share this skeleton: + +``` +/ +├── Cargo.toml # crate-type cdylib (+ staticlib for C) +│ # depends on minigraf = "" +├── src/ +│ ├── lib.rs # UniFFI scaffolding (Java/Android/Swift) or C wrapper (C) +│ └── uniffi_bindgen.rs # bindgen CLI entry point (Java/Android/Swift only) +├── / # described per-repo below +└── .github/workflows/ + ├── ci.yml # runs on every PR and push to main + └── release.yml # triggered by repository_dispatch: core-release +``` + +### minigraf-java + +- Lang tooling: `java/` — Gradle project containing generated Kotlin bindings and multi-platform natives in `src/main/resources/natives/{linux/x86_64,linux/aarch64,macos/universal,windows/x86_64}/` +- `ci.yml`: matrix on ubuntu-latest, ubuntu-24.04-arm, macos-14, windows-latest — `cargo test` + JUnit +- `release.yml`: receive `core-release` dispatch → update `minigraf` pin → commit + tag → build natives on 4-platform matrix → assemble fat JAR → publish via NMCP to Maven Central +- README covers: Maven/Gradle coordinates, quick start snippet, build-from-source instructions, cascade release notes + +### minigraf-android + +- Lang tooling: `android/` — Gradle project producing an AAR; JNI libs populated by CI via `cargo-ndk` +- `ci.yml`: cross-compile for `arm64-v8a`, `armeabi-v7a`, `x86_64` on ubuntu-latest; run instrumented unit tests +- `release.yml`: receive dispatch → update pin → commit + tag → `cargo-ndk` build for all Android ABIs → assemble AAR → publish to Maven Central via NMCP +- README covers: Gradle dependency snippet, permissions/min-SDK notes, build-from-source instructions + +### minigraf-swift + +- Lang tooling: `Sources/MinigrafKit/` (generated Swift bindings) + `Package.swift` (SPM manifest with binary target) +- `ci.yml`: macOS-14 only — build for iOS simulator, run Swift tests +- `release.yml`: receive dispatch → update pin → commit + tag → build `aarch64-apple-ios` + `aarch64-apple-ios-sim` → lipo/xcframework → zip + SHA256 → upload to GitHub Release → update `Package.swift` checksum → commit to `swift-releases` branch → tag `swift-v` +- README covers: Xcode SPM integration snippet, platforms supported (iOS 16+), build-from-source instructions + +### minigraf-c + +- Lang tooling: `include/minigraf.h` (cbindgen-generated, committed) + `cbindgen.toml` +- `ci.yml`: 4-platform matrix — `cargo test` + header drift check (`cbindgen` regenerate + diff) +- `release.yml`: receive dispatch → update pin → commit + tag → build `.so`/`.dylib`/`.dll` on 4-platform matrix → collect artifacts → create GitHub Release → upload archives +- README covers: download links per platform, C usage example, memory contract, build-from-source instructions + +### minigraf-binding-template + +- Marked as a GitHub template repository +- Contains: `Cargo.toml` (depends on `minigraf`, placeholder version `0.0.0`), `src/lib.rs` (UniFFI scaffolding with inline comments at every hook explaining what to customise), `src/uniffi_bindgen.rs`, `.github/workflows/ci.yml` (cargo test only), `README.md` +- README explains: the Phase 1/2 split pattern, why bindings depend on `minigraf` not `minigraf-ffi`, how to wire up `cascade.yml` dispatch, how to add language tooling + +--- + +## Release Flow (Data Flow) + +``` +v* tag pushed to monorepo + └─► release.yml publishes minigraf core to crates.io + └─► cascade.yml + ├─ publishes nothing (minigraf-ffi retired) + └─ dispatches core-release to: + minigraf-python, minigraf-node, minigraf-wasm ← Phase 1 + minigraf-java, minigraf-android, ← Phase 2 + minigraf-swift, minigraf-c + +Each binding repo (on core-release dispatch): + 1. Extract version from client_payload.version (e.g. v1.2.0 → 1.2.0) + 2. Pin minigraf = "1.2.0" in Cargo.toml + 3. Commit + push + tag v1.2.0 + 4. Run platform build matrix + 5. Publish artifact +``` + +**Failure isolation:** dispatch is fire-and-forget. A failure in one binding repo does not affect others. Each can be re-triggered via `workflow_dispatch` once fixed. + +--- + +## Cascade Update (monorepo) + +`cascade.yml` `dispatch-bindings` step becomes: + +```yaml +for REPO in minigraf-python minigraf-node minigraf-wasm \ + minigraf-java minigraf-android minigraf-swift minigraf-c; do + echo "Dispatching core-release to project-minigraf/$REPO @ $VERSION" + gh api repos/project-minigraf/$REPO/dispatches \ + -f event_type=core-release \ + -f "client_payload[version]=$VERSION" +done +``` + +The `publish-ffi` job is removed entirely (no FFI crate to publish). Its "wait for minigraf to be indexed on crates.io" polling step is moved into `dispatch-bindings` as a pre-flight (so binding repos don't try to `cargo add minigraf@` before crates.io has indexed it). `dispatch-bindings` no longer has a `needs:` dependency on any other job — it polls crates.io itself, then dispatches. + +--- + +## Monorepo Cleanup + +**Directories removed:** +- `minigraf-ffi/` (entire directory) +- `minigraf-swift/` (entire directory) +- `minigraf-c/` (entire directory) + +**Workflows removed:** +- `.github/workflows/java-ci.yml` +- `.github/workflows/java-release.yml` +- `.github/workflows/mobile.yml` +- `.github/workflows/c-ci.yml` +- `.github/workflows/c-release.yml` +- `.github/workflows/publish-ffi.yml` + +**`Cargo.toml` workspace:** +```toml +[workspace] +members = ["."] # minigraf-ffi and minigraf-c removed +exclude = ["fuzz"] +``` + +**`Package.swift`** (root): removed — lives in `minigraf-swift` repo. + +--- + +## minigraf-ffi Retirement + +1. Yank `minigraf-ffi 1.1.1` and `1.1.2` on crates.io with message: + > "This crate has been retired. Depend on `minigraf` directly. To build a new language binding, see https://github.com/project-minigraf/minigraf-binding-template" +2. Update `minigraf-ffi` README on crates.io (via a final yanked publish or docs.rs redirect) with the same tombstone notice. + +--- + +## Secrets Required per New Repo + +Each new binding repo needs these org-level or repo-level secrets configured in GitHub: + +| Secret | Used by | +|---|---| +| `MINIGRAF_RELEASE_TOKEN` | Receive `repository_dispatch` (write:actions scope) | +| `CENTRAL_TOKEN_USERNAME` | Maven Central publish (Java, Android) | +| `CENTRAL_TOKEN_PASSWORD` | Maven Central publish (Java, Android) | +| `GPG_SIGNING_KEY` | Maven Central publish (Java, Android) | +| `GPG_SIGNING_PASSWORD` | Maven Central publish (Java, Android) | + +`minigraf-swift` and `minigraf-c` only need `MINIGRAF_RELEASE_TOKEN` (GitHub Release uploads use `GITHUB_TOKEN`). + +--- + +## Testing Strategy + +- **Rust layer**: `cargo test` in CI on all supported platforms per repo +- **Java/Android**: JUnit tests in CI matrix; release workflow runs tests as pre-flight +- **Swift**: `swift test` on macOS-14 in CI; xcframework build verified on release +- **C**: `cargo test` + cbindgen header drift check in CI on all 4 platforms +- **Cascade integration**: verified manually after first release that all 7 repos receive dispatch and publish successfully From 2feaacdd502d0ede2210bb30750708a3c94604f9 Mon Sep 17 00:00:00 2001 From: Aditya Mukhopadhyay Date: Mon, 18 May 2026 07:58:44 +0530 Subject: [PATCH 2/6] =?UTF-8?q?docs(plan):=20repo=20split=20phase=202=20?= =?UTF-8?q?=E2=80=94=20Java,=20Android,=20Swift,=20C,=20template?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 8-task implementation plan: creates 5 new repos, updates cascade, cleans up monorepo, retires minigraf-ffi on crates.io. Co-Authored-By: Claude Sonnet 4.6 --- .../plans/2026-05-18-repo-split-phase2.md | 2070 +++++++++++++++++ 1 file changed, 2070 insertions(+) create mode 100644 docs/superpowers/plans/2026-05-18-repo-split-phase2.md diff --git a/docs/superpowers/plans/2026-05-18-repo-split-phase2.md b/docs/superpowers/plans/2026-05-18-repo-split-phase2.md new file mode 100644 index 0000000000..e2470be8a6 --- /dev/null +++ b/docs/superpowers/plans/2026-05-18-repo-split-phase2.md @@ -0,0 +1,2070 @@ +# Repo Split Phase 2 Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Split Java, Android, Swift, and C bindings out of the monorepo into four independent repos; create a `minigraf-binding-template` repo for contributors; retire `minigraf-ffi`; update cascade to dispatch to all four new binding repos. + +**Architecture:** Each new binding repo is a standalone Rust workspace that depends directly on the published `minigraf` core crate (not `minigraf-ffi`), plus the language-specific build tooling copied from the monorepo. On receiving a `core-release` repository_dispatch, each repo pins the new `minigraf` version in `Cargo.toml`, commits, tags, builds, and publishes independently. The monorepo then has its bindings-related source directories and workflows deleted; the cascade job is simplified to a single dispatch step. + +**Tech Stack:** Rust (UniFFI 0.31.1, cbindgen 0.29.2), Kotlin/Gradle/NMCP (Java + Android), Swift/Xcode (iOS), C/cbindgen, GitHub Actions, Maven Central (Java + Android), GitHub Releases (Swift + C). + +**Spec:** `docs/superpowers/specs/2026-05-18-repo-split-phase2-design.md` + +--- + +## Prerequisites + +Before starting, verify: + +1. `gh auth status` — authenticated to GitHub with a token that has `repo` and `admin:org` scope on `project-minigraf` +2. `cargo login` — authenticated to crates.io (needed for Task 8) +3. Monorepo is at `/home/aditya/workspaces/rustrover/minigraf` — all copy commands use this absolute path + +After creating each new repo (Tasks 1–5), configure these secrets in GitHub repo settings before the first release: + +| Repo | Secrets needed | +|---|---| +| minigraf-binding-template | none | +| minigraf-c | `MINIGRAF_RELEASE_TOKEN` | +| minigraf-java | `MINIGRAF_RELEASE_TOKEN`, `CENTRAL_TOKEN_USERNAME`, `CENTRAL_TOKEN_PASSWORD`, `GPG_SIGNING_KEY`, `GPG_SIGNING_PASSWORD` | +| minigraf-android | `MINIGRAF_RELEASE_TOKEN`, `CENTRAL_TOKEN_USERNAME`, `CENTRAL_TOKEN_PASSWORD`, `GPG_SIGNING_KEY`, `GPG_SIGNING_PASSWORD` | +| minigraf-swift | `MINIGRAF_RELEASE_TOKEN` | + +`MINIGRAF_RELEASE_TOKEN` is already configured as an org-level secret in `project-minigraf` — it should be inherited automatically. The Maven Central secrets must be added per-repo (or promoted to org-level). + +--- + +## File Map + +### New repos (created outside monorepo) + +**`project-minigraf/minigraf-binding-template`** +- Create: `Cargo.toml` +- Create: `src/lib.rs` +- Create: `src/uniffi_bindgen.rs` +- Create: `.github/workflows/ci.yml` +- Create: `README.md` + +**`project-minigraf/minigraf-c`** +- Create: `Cargo.toml` +- Copy: `src/lib.rs` ← `minigraf-c/src/lib.rs` +- Copy: `include/minigraf.h` ← `minigraf-c/include/minigraf.h` +- Modify: `cbindgen.toml` ← `minigraf-c/cbindgen.toml` (update paths + crate name) +- Create: `.github/workflows/ci.yml` +- Create: `.github/workflows/release.yml` +- Create: `README.md` + +**`project-minigraf/minigraf-java`** +- Create: `Cargo.toml` +- Copy: `src/lib.rs` ← `minigraf-ffi/src/lib.rs` +- Copy: `src/uniffi_bindgen.rs` ← `minigraf-ffi/src/uniffi_bindgen.rs` +- Copy: `java/` ← `minigraf-ffi/java/` (entire directory) +- Modify: `java/build.gradle.kts` (fix `repoRoot` path — one level up, not two) +- Create: `.github/workflows/ci.yml` +- Create: `.github/workflows/release.yml` +- Create: `README.md` + +**`project-minigraf/minigraf-android`** +- Create: `Cargo.toml` +- Copy: `src/lib.rs` ← `minigraf-ffi/src/lib.rs` +- Copy: `src/uniffi_bindgen.rs` ← `minigraf-ffi/src/uniffi_bindgen.rs` +- Copy: `android/` ← `minigraf-ffi/android/` (entire directory) +- Replace: `android/build.gradle.kts` (switch from GitHub Packages to Maven Central via NMCP; fix groupId) +- Create: `.github/workflows/ci.yml` +- Create: `.github/workflows/release.yml` +- Create: `README.md` + +**`project-minigraf/minigraf-swift`** +- Create: `Cargo.toml` +- Copy: `src/lib.rs` ← `minigraf-ffi/src/lib.rs` +- Copy: `src/uniffi_bindgen.rs` ← `minigraf-ffi/src/uniffi_bindgen.rs` +- Create: `Sources/MinigrafKit/.gitkeep` (populated by release CI) +- Create: `Package.swift` (URL updated from monorepo → minigraf-swift, path from `minigraf-swift/Sources/…` → `Sources/…`) +- Create: `.github/workflows/ci.yml` +- Create: `.github/workflows/release.yml` +- Create: `README.md` + +### Monorepo changes + +- Modify: `.github/workflows/cascade.yml` +- Delete: `.github/workflows/java-ci.yml` +- Delete: `.github/workflows/java-release.yml` +- Delete: `.github/workflows/mobile.yml` +- Delete: `.github/workflows/c-ci.yml` +- Delete: `.github/workflows/c-release.yml` +- Delete: `.github/workflows/publish-ffi.yml` +- Delete: `minigraf-ffi/` (entire directory) +- Delete: `minigraf-swift/` (entire directory) +- Delete: `minigraf-c/` (entire directory) +- Delete: `Package.swift` +- Modify: `Cargo.toml` (remove `minigraf-ffi` and `minigraf-c` from workspace members) + +--- + +## Task 1: Create minigraf-binding-template + +**Files:** +- Create: `Cargo.toml`, `src/lib.rs`, `src/uniffi_bindgen.rs`, `.github/workflows/ci.yml`, `README.md` + +- [ ] **Step 1: Create the GitHub repo** + +```bash +gh repo create project-minigraf/minigraf-binding-template \ + --public \ + --description "Template repo for building a new Minigraf language binding" \ + --clone +cd minigraf-binding-template +``` + +- [ ] **Step 2: Write Cargo.toml** + +```toml +[package] +name = "minigraf-binding-example" +version = "0.0.0" +edition = "2024" +publish = false +description = "Template for building a new Minigraf language binding" + +[lib] +name = "minigraf_ffi" +crate-type = ["cdylib"] + +[[bin]] +name = "uniffi-bindgen" +path = "src/uniffi_bindgen.rs" + +[dependencies] +# Pin to the exact released version. The release workflow updates this line. +minigraf = "1.1.1" +uniffi = { version = "0.31.1", features = ["cli"] } +thiserror = "2.0.18" +serde_json = "1.0.149" +anyhow = "1" + +[workspace] +members = ["."] +``` + +- [ ] **Step 3: Write src/uniffi_bindgen.rs** + +```bash +mkdir -p src +``` + +```rust +fn main() { + uniffi::uniffi_bindgen_main() +} +``` + +- [ ] **Step 4: Write src/lib.rs** + +This is the UniFFI scaffolding with comments at each extension point explaining what to customise for a new binding. + +```rust +//! Minigraf binding template — UniFFI scaffolding. +//! +//! CUSTOMISATION GUIDE: +//! 1. Rename the crate in Cargo.toml (name, description). +//! 2. Pin minigraf to the version you want to bind. +//! 3. Implement any extra error variants or wrapper types your language needs. +//! 4. Add your language tooling (e.g. java/, android/, Sources/, etc.). +//! 5. Wire up a release.yml that receives `core-release` dispatch from +//! the minigraf cascade and calls `cargo publish` / your language publisher. +//! +//! Why depend on `minigraf` directly and not `minigraf-ffi`? +//! UniFFI's `setup_scaffolding!()` macro generates extern "C" symbols in the +//! *final* cdylib crate. Re-exporting from a crate that already called it +//! causes duplicate symbol errors at link time. Always embed the scaffolding +//! in your own crate and depend on `minigraf` core. + +#![cfg_attr( + test, + allow( + clippy::unwrap_used, + clippy::expect_used, + clippy::panic, + clippy::indexing_slicing, + clippy::cast_possible_truncation, + clippy::cast_possible_wrap, + clippy::cast_sign_loss, + ) +)] + +use minigraf::{QueryResult, Value}; +use std::sync::{Arc, Mutex}; + +uniffi::setup_scaffolding!(); + +// ─── Error type ────────────────────────────────────────────────────────────── +// CUSTOMISE: add variants for any language-specific error categories. + +#[derive(Debug, thiserror::Error, uniffi::Error)] +pub enum MiniGrafError { + #[error("storage error: {msg}")] + Storage { msg: String }, + #[error("query error: {msg}")] + Query { msg: String }, + #[error("parse error: {msg}")] + Parse { msg: String }, + #[error("unknown error: {msg}")] + Other { msg: String }, +} + +impl From for MiniGrafError { + fn from(e: anyhow::Error) -> Self { + let full = format!("{e:#}").to_lowercase(); + let msg = e.to_string(); + if full.contains("parse") + || full.contains("unexpected") + || full.contains("expected token") + || full.contains("unknown command") + { + MiniGrafError::Parse { msg } + } else if full.contains("storage") || full.contains(" page") || full.contains("wal ") { + MiniGrafError::Storage { msg } + } else if full.contains("query") || full.contains(":find") || full.contains(":where") { + MiniGrafError::Query { msg } + } else { + MiniGrafError::Other { msg } + } + } +} + +// ─── Database object ───────────────────────────────────────────────────────── +// CUSTOMISE: add methods your language needs (e.g. async wrappers, transactions). + +#[derive(uniffi::Object)] +pub struct MiniGrafDb { + inner: Arc>, +} + +#[uniffi::export] +impl MiniGrafDb { + #[uniffi::constructor] + pub fn open(path: String) -> Result, MiniGrafError> { + let db = minigraf::Minigraf::open(&path).map_err(MiniGrafError::from)?; + Ok(Arc::new(Self { + inner: Arc::new(Mutex::new(db)), + })) + } + + #[uniffi::constructor] + pub fn open_in_memory() -> Result, MiniGrafError> { + let db = minigraf::Minigraf::in_memory().map_err(MiniGrafError::from)?; + Ok(Arc::new(Self { + inner: Arc::new(Mutex::new(db)), + })) + } + + pub fn execute(&self, datalog: String) -> Result { + let result = self + .inner + .lock() + .map_err(|_| MiniGrafError::Other { + msg: "mutex poisoned".into(), + })? + .execute(&datalog) + .map_err(MiniGrafError::from)?; + Ok(query_result_to_json(result)) + } + + pub fn checkpoint(&self) -> Result<(), MiniGrafError> { + self.inner + .lock() + .map_err(|_| MiniGrafError::Other { + msg: "mutex poisoned".into(), + })? + .checkpoint() + .map_err(MiniGrafError::from) + } +} + +// ─── JSON serialisation ─────────────────────────────────────────────────────── + +fn value_to_json(v: &Value) -> serde_json::Value { + use serde_json::Value as JVal; + match v { + Value::String(s) => JVal::String(s.clone()), + Value::Integer(i) => JVal::Number((*i).into()), + Value::Float(f) => serde_json::Number::from_f64(*f) + .map(JVal::Number) + .unwrap_or(JVal::Null), + Value::Boolean(b) => JVal::Bool(*b), + Value::Ref(uuid) => JVal::String(uuid.to_string()), + Value::Keyword(k) => JVal::String(k.clone()), + Value::Null => JVal::Null, + } +} + +fn query_result_to_json(result: QueryResult) -> String { + use serde_json::json; + let val = match result { + QueryResult::Transacted(tx_id) => json!({"transacted": tx_id}), + QueryResult::Retracted(tx_id) => json!({"retracted": tx_id}), + QueryResult::Ok => json!({"ok": true}), + QueryResult::QueryResults { vars, results } => { + let rows: Vec> = results + .iter() + .map(|row| row.iter().map(value_to_json).collect()) + .collect(); + json!({"variables": vars, "results": rows}) + } + }; + val.to_string() +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn open_in_memory_succeeds() { + MiniGrafDb::open_in_memory().expect("open_in_memory"); + } + + #[test] + fn execute_transact_returns_json() { + let db = MiniGrafDb::open_in_memory().expect("open"); + let json = db + .execute(r#"(transact [[:alice :name "Alice"]])"#.into()) + .expect("execute"); + let v: serde_json::Value = serde_json::from_str(&json).expect("valid json"); + assert!(v.get("transacted").is_some()); + } + + #[test] + fn execute_query_returns_results() { + let db = MiniGrafDb::open_in_memory().expect("open"); + db.execute(r#"(transact [[:alice :name "Alice"]])"#.into()) + .expect("transact"); + let json = db + .execute(r#"(query [:find ?n :where [?e :name ?n]])"#.into()) + .expect("query"); + let v: serde_json::Value = serde_json::from_str(&json).expect("valid json"); + assert_eq!(v["results"][0][0], "Alice"); + } +} +``` + +- [ ] **Step 5: Write .github/workflows/ci.yml** + +```bash +mkdir -p .github/workflows +``` + +```yaml +name: CI + +on: + push: + branches: [main] + pull_request: + +jobs: + test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: dtolnay/rust-toolchain@stable + - run: cargo test +``` + +- [ ] **Step 6: Write README.md** + +```markdown +# minigraf-binding-template + +Template repository for building a new [Minigraf](https://github.com/project-minigraf/minigraf) language binding. + +## What's in this repo + +| File | Purpose | +|---|---| +| `Cargo.toml` | Rust shim crate — depends on `minigraf` core, produces a cdylib | +| `src/lib.rs` | UniFFI scaffolding with comments at every extension point | +| `src/uniffi_bindgen.rs` | Entry point for the `uniffi-bindgen` CLI binary | +| `.github/workflows/ci.yml` | Starter CI — runs `cargo test` | + +## Creating a new binding + +1. Click **Use this template** on GitHub to create your repo under `project-minigraf/`. +2. Update `Cargo.toml`: rename the crate, pin `minigraf` to the version you're targeting. +3. Run `cargo test` to verify the Rust layer compiles and tests pass. +4. Add your language tooling (e.g. `java/`, `android/`, `Sources/`, etc.). +5. Generate language bindings with `uniffi-bindgen`: + ```bash + cargo build --release + cargo run --bin uniffi-bindgen -- generate \ + --library target/release/libminigraf_ffi. \ + --language \ + --out-dir / + ``` +6. Add a `release.yml` that receives the `core-release` repository_dispatch event from + the minigraf cascade, pins the new `minigraf` version in `Cargo.toml`, commits, tags, + and publishes your artifact. + +## Why not depend on `minigraf-ffi`? + +UniFFI's `setup_scaffolding!()` macro generates `extern "C"` symbols in the **final** cdylib +crate. Re-exporting from a crate that already called it causes duplicate symbol errors at +link time. Always embed the scaffolding in your own crate and depend on `minigraf` core +directly. See the existing binding repos (`minigraf-python`, `minigraf-java`, etc.) for +complete examples. + +## License + +MIT OR Apache-2.0 +``` + +- [ ] **Step 7: Verify tests pass** + +```bash +cargo test +``` + +Expected: all tests pass. + +- [ ] **Step 8: Enable template + commit + push** + +```bash +git add . +git commit -m "feat: initial minigraf binding template" +git push origin main +``` + +Then in the GitHub UI (or via `gh`): Settings → check "Template repository". + +```bash +gh api repos/project-minigraf/minigraf-binding-template \ + --method PATCH \ + -f is_template=true +``` + +--- + +## Task 2: Create minigraf-c repo + +**Files:** +- Create: `Cargo.toml`, `cbindgen.toml`, `src/lib.rs`, `include/minigraf.h` +- Create: `.github/workflows/ci.yml`, `.github/workflows/release.yml`, `README.md` + +The Rust source (`src/lib.rs`, `include/minigraf.h`) is copied verbatim from the monorepo. Only `Cargo.toml`, `cbindgen.toml`, and the workflows change. + +- [ ] **Step 1: Create the GitHub repo and clone it** + +```bash +gh repo create project-minigraf/minigraf-c \ + --public \ + --description "C bindings for Minigraf — stable C API with cbindgen-generated header" \ + --clone +cd minigraf-c +mkdir -p src include .github/workflows +``` + +- [ ] **Step 2: Write Cargo.toml** + +```toml +[package] +name = "minigraf-c-shim" +version = "0.0.0" +edition = "2024" +publish = false +description = "C bindings for Minigraf — stable C API with cbindgen-generated header" + +[lib] +# "minigraf" produces libminigraf.so / libminigraf.dylib / minigraf.dll directly +# without the rename step needed in the monorepo (which used name "minigraf-c"). +name = "minigraf" +crate-type = ["cdylib", "staticlib"] + +[dependencies] +# Pin to the exact released version. The release workflow updates this line. +minigraf = "1.1.1" +serde_json = "1.0" + +[workspace] +members = ["."] +``` + +- [ ] **Step 3: Copy src/lib.rs from monorepo** + +Copy `/home/aditya/workspaces/rustrover/minigraf/minigraf-c/src/lib.rs` verbatim to `src/lib.rs`. + +- [ ] **Step 4: Copy include/minigraf.h from monorepo** + +Copy `/home/aditya/workspaces/rustrover/minigraf/minigraf-c/include/minigraf.h` verbatim to `include/minigraf.h`. + +- [ ] **Step 5: Write cbindgen.toml** + +Updated from the monorepo version: crate name changes from `minigraf-c` to `minigraf-c-shim`, paths are now relative to the repo root. + +```toml +language = "C" +include_guard = "MINIGRAF_H" +autogen_warning = "/* DO NOT EDIT — generated by cbindgen. Run `cbindgen --config cbindgen.toml --crate minigraf-c-shim --output include/minigraf.h` to regenerate. */" +documentation = true +documentation_style = "c99" + +[export] +include = [ + "minigraf_open", + "minigraf_open_in_memory", + "minigraf_close", + "minigraf_execute", + "minigraf_string_free", + "minigraf_checkpoint", + "minigraf_last_error", + "MiniGrafDb", +] +``` + +- [ ] **Step 6: Verify tests pass** + +```bash +cargo test +``` + +Expected: 7 tests pass (open_in_memory_returns_non_null, execute_transact_returns_json, execute_query_returns_results, execute_invalid_datalog_returns_null_and_sets_error, checkpoint_returns_zero_on_success, string_free_null_is_safe, close_null_is_safe). + +- [ ] **Step 7: Write .github/workflows/ci.yml** + +Adapted from monorepo's `c-ci.yml`. Key changes: `-p minigraf-c` → removed (standalone workspace); `minigraf-c/cbindgen.toml` → `cbindgen.toml`; `--crate minigraf-c` → `--crate minigraf-c-shim`; `minigraf-c/include/minigraf.h` → `include/minigraf.h`. + +```yaml +name: CI + +on: + push: + branches: [main] + pull_request: + +jobs: + test: + name: C tests (${{ matrix.os }}) + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, ubuntu-24.04-arm, macos-14, windows-latest] + steps: + - uses: actions/checkout@v4 + - uses: dtolnay/rust-toolchain@stable + - run: cargo test -- --nocapture + + check-header-drift: + name: Verify minigraf.h is up to date + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: dtolnay/rust-toolchain@stable + - name: Install cbindgen + run: cargo install cbindgen --version 0.29.2 --locked + - name: Regenerate header + run: | + cbindgen --config cbindgen.toml \ + --crate minigraf-c-shim \ + --output /tmp/minigraf_generated.h + - name: Fail if header has drifted + run: | + diff include/minigraf.h /tmp/minigraf_generated.h || \ + (echo "minigraf.h is out of date — run cbindgen locally and commit the result" && exit 1) +``` + +- [ ] **Step 8: Write .github/workflows/release.yml** + +Adapted from monorepo's `c-release.yml`. Key changes: triggered by `repository_dispatch` instead of tag push; adds `prepare` job (updates Cargo.toml pin, commits, tags, creates GitHub Release); `build` job checks out the tag and builds; `-p minigraf-c` removed; `minigraf-c/include/minigraf.h` → `include/minigraf.h`; no more waiting for cargo-dist to create a release. + +```yaml +name: C Release + +on: + repository_dispatch: + types: [core-release] + workflow_dispatch: + inputs: + version: + description: 'Version tag (e.g. v1.2.0)' + required: true + +permissions: + contents: write + +jobs: + prepare: + name: Pin version, commit, tag, create release + runs-on: ubuntu-latest + outputs: + tag: ${{ steps.ver.outputs.tag }} + semver: ${{ steps.ver.outputs.semver }} + steps: + - uses: actions/checkout@v4 + with: + token: ${{ secrets.MINIGRAF_RELEASE_TOKEN }} + + - id: ver + run: | + V="${{ github.event.client_payload.version || github.event.inputs.version }}" + echo "tag=$V" >> "$GITHUB_OUTPUT" + echo "semver=${V#v}" >> "$GITHUB_OUTPUT" + + - name: Pin minigraf version in Cargo.toml + run: | + sed -i 's/^minigraf = "[^"]*"/minigraf = "${{ steps.ver.outputs.semver }}"/' Cargo.toml + + - name: Commit and push tag + run: | + git config user.name "github-actions[bot]" + git config user.email "github-actions[bot]@users.noreply.github.com" + git add Cargo.toml + git commit -m "chore: release ${{ steps.ver.outputs.tag }}" + git tag "${{ steps.ver.outputs.tag }}" + git push origin main --follow-tags + + - name: Create GitHub Release + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + gh release create "${{ steps.ver.outputs.tag }}" \ + --repo "$GITHUB_REPOSITORY" \ + --title "minigraf-c ${{ steps.ver.outputs.tag }}" \ + --notes "C bindings for minigraf ${{ steps.ver.outputs.tag }}. Download the library for your platform below." + + build: + name: Build C library (${{ matrix.os }}) + needs: prepare + runs-on: ${{ matrix.os }} + permissions: + contents: write + strategy: + fail-fast: false + matrix: + include: + - os: ubuntu-latest + target: x86_64-unknown-linux-gnu + artifact-name: linux-x86_64 + lib-name: libminigraf.so + - os: ubuntu-24.04-arm + target: aarch64-unknown-linux-gnu + artifact-name: linux-aarch64 + lib-name: libminigraf.so + - os: macos-14 + target: universal2 + artifact-name: macos-universal2 + lib-name: libminigraf.dylib + - os: windows-latest + target: x86_64-pc-windows-msvc + artifact-name: windows-x86_64 + lib-name: minigraf.dll + + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ needs.prepare.outputs.tag }} + + - uses: dtolnay/rust-toolchain@stable + with: + targets: ${{ matrix.target == 'universal2' && 'aarch64-apple-darwin x86_64-apple-darwin' || matrix.target }} + + - name: Build (universal2) + if: matrix.target == 'universal2' + run: | + cargo build --release --target aarch64-apple-darwin + cargo build --release --target x86_64-apple-darwin + lipo -create \ + target/aarch64-apple-darwin/release/libminigraf.dylib \ + target/x86_64-apple-darwin/release/libminigraf.dylib \ + -output ${{ matrix.lib-name }} + + - name: Build (Linux) + if: runner.os == 'Linux' + run: | + cargo build --release --target ${{ matrix.target }} + cp target/${{ matrix.target }}/release/libminigraf.so ${{ matrix.lib-name }} + + - name: Build (Windows) + if: runner.os == 'Windows' + run: | + cargo build --release --target ${{ matrix.target }} + copy target\${{ matrix.target }}\release\minigraf.dll ${{ matrix.lib-name }} + shell: pwsh + + - name: Package (unix) + if: runner.os != 'Windows' + run: | + tar czf minigraf-c-${{ needs.prepare.outputs.tag }}-${{ matrix.artifact-name }}.tar.gz \ + ${{ matrix.lib-name }} include/minigraf.h + + - name: Package (windows) + if: runner.os == 'Windows' + run: | + Compress-Archive -Path ${{ matrix.lib-name }},include\minigraf.h ` + -DestinationPath minigraf-c-${{ needs.prepare.outputs.tag }}-${{ matrix.artifact-name }}.zip + shell: pwsh + + - name: Upload to GitHub Release (unix) + if: runner.os != 'Windows' + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + gh release upload "${{ needs.prepare.outputs.tag }}" \ + minigraf-c-${{ needs.prepare.outputs.tag }}-${{ matrix.artifact-name }}.tar.gz \ + --repo "$GITHUB_REPOSITORY" --clobber + + - name: Upload to GitHub Release (windows) + if: runner.os == 'Windows' + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + gh release upload "${{ needs.prepare.outputs.tag }}" ` + "minigraf-c-${{ needs.prepare.outputs.tag }}-${{ matrix.artifact-name }}.zip" ` + --repo "$GITHUB_REPOSITORY" --clobber + shell: pwsh +``` + +- [ ] **Step 9: Write README.md** + +```markdown +# minigraf-c + +C bindings for [Minigraf](https://github.com/project-minigraf/minigraf) — zero-config, +single-file, embedded bi-temporal graph database. + +## Installation + +Download the pre-built library for your platform from the +[latest release](https://github.com/project-minigraf/minigraf-c/releases/latest): + +| Platform | Archive | +|---|---| +| Linux x86_64 | `minigraf-c--linux-x86_64.tar.gz` | +| Linux aarch64 | `minigraf-c--linux-aarch64.tar.gz` | +| macOS universal | `minigraf-c--macos-universal2.tar.gz` | +| Windows x86_64 | `minigraf-c--windows-x86_64.zip` | + +Each archive contains `libminigraf.{so|dylib|dll}` and `minigraf.h`. + +## Quick start + +```c +#include "minigraf.h" +#include + +int main(void) { + MiniGrafDb *db = minigraf_open_in_memory(); + char *result = minigraf_execute(db, "(transact [[:alice :name \"Alice\"]])"); + printf("%s\n", result); + minigraf_string_free(result); + minigraf_close(db); + return 0; +} +``` + +Compile: `cc -o example example.c -L. -lminigraf -Wl,-rpath,.` + +## Memory contract + +- Strings returned by `minigraf_execute` must be freed with `minigraf_string_free`. +- Databases must be closed with `minigraf_close`. +- Passing `NULL` to any function is safe (no-op or returns NULL/error). + +## API + +| Function | Description | +|---|---| +| `minigraf_open(path)` | Open a file-backed database | +| `minigraf_open_in_memory()` | Open an in-memory database | +| `minigraf_execute(db, datalog)` | Execute Datalog, returns JSON string | +| `minigraf_string_free(s)` | Free a string returned by `execute` | +| `minigraf_checkpoint(db)` | Flush WAL to disk; returns 0 on success | +| `minigraf_last_error(db)` | Return last error message (valid until next call) | +| `minigraf_close(db)` | Close the database and free all memory | + +## Building from source + +```bash +cargo build --release +# produces target/release/libminigraf.{so|dylib|dll} +``` + +Regenerate the header after changing the public API: +```bash +cbindgen --config cbindgen.toml --crate minigraf-c-shim --output include/minigraf.h +``` + +## License + +MIT OR Apache-2.0 +``` + +- [ ] **Step 10: Commit and push** + +```bash +git add . +git commit -m "feat: initial minigraf-c repo — C bindings split from monorepo" +git push origin main +``` + +--- + +## Task 3: Create minigraf-java repo + +**Files:** +- Create: `Cargo.toml`, `src/lib.rs`, `src/uniffi_bindgen.rs` +- Copy: `java/` directory from monorepo's `minigraf-ffi/java/` +- Modify: `java/build.gradle.kts` (fix `repoRoot`) +- Create: `.github/workflows/ci.yml`, `.github/workflows/release.yml`, `README.md` + +- [ ] **Step 1: Create the GitHub repo and clone it** + +```bash +gh repo create project-minigraf/minigraf-java \ + --public \ + --description "JVM binding for Minigraf — bi-temporal graph database" \ + --clone +cd minigraf-java +mkdir -p src .github/workflows +``` + +- [ ] **Step 2: Write Cargo.toml** + +```toml +[package] +name = "minigraf-java-shim" +version = "0.0.0" +edition = "2024" +publish = false +description = "JVM binding for Minigraf — bi-temporal graph database" + +[lib] +name = "minigraf_ffi" +crate-type = ["cdylib"] + +[[bin]] +name = "uniffi-bindgen" +path = "src/uniffi_bindgen.rs" + +[dependencies] +# Pin to the exact released version. The release workflow updates this line. +minigraf = "1.1.1" +uniffi = { version = "0.31.1", features = ["cli"] } +thiserror = "2.0.18" +serde_json = "1.0.149" +anyhow = "1" + +[workspace] +members = ["."] +``` + +- [ ] **Step 3: Copy src/lib.rs and src/uniffi_bindgen.rs from monorepo** + +```bash +cp /home/aditya/workspaces/rustrover/minigraf/minigraf-ffi/src/lib.rs src/lib.rs +cp /home/aditya/workspaces/rustrover/minigraf/minigraf-ffi/src/uniffi_bindgen.rs src/uniffi_bindgen.rs +``` + + +- [ ] **Step 4: Copy java/ directory from monorepo** + +```bash +cp -r /home/aditya/workspaces/rustrover/minigraf/minigraf-ffi/java ./java +``` + +- [ ] **Step 5: Fix repoRoot in java/build.gradle.kts** + +In the monorepo, `java/build.gradle.kts` computed the repo root as two levels up from the Gradle project dir (`minigraf-ffi/java/ → minigraf-ffi/ → monorepo root`). In the split repo, `java/` is one level below the repo root. + +Find this line in `java/build.gradle.kts`: + +```kotlin +val repoRoot = rootProject.projectDir.parentFile.parentFile.absolutePath +``` + +Replace with: + +```kotlin +val repoRoot = rootProject.projectDir.parentFile.absolutePath +``` + +- [ ] **Step 6: Verify Rust tests pass** + +```bash +cargo test +``` + +Expected: all tests pass (same test suite as minigraf-ffi/src/lib.rs). + +- [ ] **Step 7: Write .github/workflows/ci.yml** + +Adapted from monorepo's `java-ci.yml`. Key changes: `-p minigraf-ffi` → removed; `working-directory: minigraf-ffi/java` → `working-directory: java`. + +```yaml +name: CI + +on: + push: + branches: [main] + pull_request: + +jobs: + rust-test: + name: Rust tests (${{ matrix.os }}) + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, ubuntu-24.04-arm, macos-14, windows-latest] + steps: + - uses: actions/checkout@v4 + - uses: dtolnay/rust-toolchain@stable + - run: cargo test + + java-test: + name: Java tests + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: dtolnay/rust-toolchain@stable + - uses: actions/setup-java@v4 + with: + java-version: '17' + distribution: 'temurin' + - name: Build Rust library (release) + run: cargo build --release + - name: Generate Kotlin bindings + copy local native + working-directory: java + run: ./gradlew generateKotlinBindings copyLocalNative + - name: Run tests + working-directory: java + run: ./gradlew test +``` + +- [ ] **Step 8: Write .github/workflows/release.yml** + +Adapted from monorepo's `java-release.yml`. Key changes: triggered by `repository_dispatch`; adds `prepare` job (update Cargo.toml, commit, tag); `-p minigraf-ffi` → removed; all `minigraf-ffi/java/` paths → `java/`; `RESOURCES=minigraf-ffi/java/src/main/resources/natives` → `RESOURCES=java/src/main/resources/natives`; `working-directory: minigraf-ffi/java` → `working-directory: java`. + +```yaml +name: Java Release + +on: + repository_dispatch: + types: [core-release] + workflow_dispatch: + inputs: + version: + description: 'Version tag (e.g. v1.2.0)' + required: true + +jobs: + prepare: + name: Pin version, commit, tag + runs-on: ubuntu-latest + outputs: + tag: ${{ steps.ver.outputs.tag }} + semver: ${{ steps.ver.outputs.semver }} + steps: + - uses: actions/checkout@v4 + with: + token: ${{ secrets.MINIGRAF_RELEASE_TOKEN }} + + - id: ver + run: | + V="${{ github.event.client_payload.version || github.event.inputs.version }}" + echo "tag=$V" >> "$GITHUB_OUTPUT" + echo "semver=${V#v}" >> "$GITHUB_OUTPUT" + + - name: Pin minigraf version in Cargo.toml + run: | + sed -i 's/^minigraf = "[^"]*"/minigraf = "${{ steps.ver.outputs.semver }}"/' Cargo.toml + + - name: Commit and push tag + run: | + git config user.name "github-actions[bot]" + git config user.email "github-actions[bot]@users.noreply.github.com" + git add Cargo.toml + git commit -m "chore: release ${{ steps.ver.outputs.tag }}" + git tag "${{ steps.ver.outputs.tag }}" + git push origin main --follow-tags + + build-natives: + name: Build native (${{ matrix.target }}) + needs: prepare + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: + - os: ubuntu-latest + target: x86_64-unknown-linux-gnu + native-dir: linux/x86_64 + lib-name: libminigraf_ffi.so + - os: ubuntu-24.04-arm + target: aarch64-unknown-linux-gnu + native-dir: linux/aarch64 + lib-name: libminigraf_ffi.so + - os: macos-14 + target: universal2 + native-dir: macos/universal + lib-name: libminigraf_ffi.dylib + - os: windows-latest + target: x86_64-pc-windows-msvc + native-dir: windows/x86_64 + lib-name: minigraf_ffi.dll + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ needs.prepare.outputs.tag }} + + - uses: dtolnay/rust-toolchain@stable + with: + targets: ${{ matrix.target == 'universal2' && 'aarch64-apple-darwin x86_64-apple-darwin' || matrix.target }} + + - name: Build (universal2) + if: matrix.target == 'universal2' + run: | + cargo build --release --target aarch64-apple-darwin + cargo build --release --target x86_64-apple-darwin + lipo -create \ + target/aarch64-apple-darwin/release/libminigraf_ffi.dylib \ + target/x86_64-apple-darwin/release/libminigraf_ffi.dylib \ + -output libminigraf_ffi.dylib + + - name: Build (other) + if: matrix.target != 'universal2' + run: cargo build --release --target ${{ matrix.target }} + + - name: Upload native + uses: actions/upload-artifact@v4 + with: + name: native-${{ matrix.native-dir == 'linux/x86_64' && 'linux-x64' || matrix.native-dir == 'linux/aarch64' && 'linux-arm64' || matrix.native-dir == 'macos/universal' && 'macos' || 'windows' }} + path: | + ${{ matrix.target == 'universal2' && 'libminigraf_ffi.dylib' || format('target/{0}/release/{1}', matrix.target, matrix.lib-name) }} + + assemble-and-publish: + name: Assemble fat JAR and publish to Maven Central + needs: [prepare, build-natives] + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ needs.prepare.outputs.tag }} + + - uses: dtolnay/rust-toolchain@stable + + - uses: actions/setup-java@v4 + with: + java-version: '17' + distribution: 'temurin' + + - name: Download all natives + uses: actions/download-artifact@v4 + with: + pattern: native-* + path: natives-staging + merge-multiple: false + + - name: Copy natives into resources + run: | + RESOURCES=java/src/main/resources/natives + mkdir -p "$RESOURCES/linux/x86_64" "$RESOURCES/linux/aarch64" \ + "$RESOURCES/macos/universal" "$RESOURCES/windows/x86_64" + cp natives-staging/native-linux-x64/libminigraf_ffi.so "$RESOURCES/linux/x86_64/" + cp natives-staging/native-linux-arm64/libminigraf_ffi.so "$RESOURCES/linux/aarch64/" + cp natives-staging/native-macos/libminigraf_ffi.dylib "$RESOURCES/macos/universal/" + cp natives-staging/native-windows/minigraf_ffi.dll "$RESOURCES/windows/x86_64/" + + - name: Build Rust library for bindgen + run: cargo build --release + + - name: Generate Kotlin bindings + working-directory: java + run: ./gradlew generateKotlinBindings + + - name: Publish to Maven Central + working-directory: java + env: + CENTRAL_TOKEN_USERNAME: ${{ secrets.CENTRAL_TOKEN_USERNAME }} + CENTRAL_TOKEN_PASSWORD: ${{ secrets.CENTRAL_TOKEN_PASSWORD }} + GPG_SIGNING_KEY: ${{ secrets.GPG_SIGNING_KEY }} + GPG_SIGNING_PASSWORD: ${{ secrets.GPG_SIGNING_PASSWORD }} + RELEASE_VERSION: ${{ needs.prepare.outputs.semver }} + run: ./gradlew publishAllPublicationsToCentralPortal +``` + +- [ ] **Step 9: Write README.md** + +```markdown +# minigraf-java + +JVM binding for [Minigraf](https://github.com/project-minigraf/minigraf) — zero-config, +single-file, embedded bi-temporal graph database with Datalog queries. + +## Installation + +### Gradle (Kotlin DSL) + +```kotlin +dependencies { + implementation("io.github.project-minigraf:minigraf-jvm:1.1.1") +} +``` + +### Maven + +```xml + + io.github.project-minigraf + minigraf-jvm + 1.1.1 + +``` + +## Quick start + +```kotlin +import io.github.project_minigraf.minigraf.MiniGrafDb + +val db = MiniGrafDb.openInMemory() +val result = db.execute("""(transact [[:alice :name "Alice"]])""") +println(result) // {"transacted":1} +``` + +## Building from source + +Requires Rust stable toolchain and JDK 17. + +```bash +cargo build --release +cd java +./gradlew generateKotlinBindings copyLocalNative test +``` + +## License + +MIT OR Apache-2.0 +``` + +- [ ] **Step 10: Commit and push** + +```bash +git add . +git commit -m "feat: initial minigraf-java repo — JVM binding split from monorepo" +git push origin main +``` + +--- + +## Task 4: Create minigraf-android repo + +**Files:** +- Create: `Cargo.toml`, `src/lib.rs`, `src/uniffi_bindgen.rs` +- Copy: `android/` directory from monorepo's `minigraf-ffi/android/` +- Replace: `android/build.gradle.kts` (switch to Maven Central via NMCP) +- Create: `.github/workflows/ci.yml`, `.github/workflows/release.yml`, `README.md` + +- [ ] **Step 1: Create the GitHub repo and clone it** + +```bash +gh repo create project-minigraf/minigraf-android \ + --public \ + --description "Android binding for Minigraf — bi-temporal graph database" \ + --clone +cd minigraf-android +mkdir -p src .github/workflows +``` + +- [ ] **Step 2: Write Cargo.toml** + +```toml +[package] +name = "minigraf-android-shim" +version = "0.0.0" +edition = "2024" +publish = false +description = "Android binding for Minigraf — bi-temporal graph database" + +[lib] +name = "minigraf_ffi" +crate-type = ["cdylib"] + +[[bin]] +name = "uniffi-bindgen" +path = "src/uniffi_bindgen.rs" + +[dependencies] +# Pin to the exact released version. The release workflow updates this line. +minigraf = "1.1.1" +uniffi = { version = "0.31.1", features = ["cli"] } +thiserror = "2.0.18" +serde_json = "1.0.149" +anyhow = "1" + +[workspace] +members = ["."] +``` + +- [ ] **Step 3: Copy src/lib.rs and src/uniffi_bindgen.rs from monorepo** + +```bash +cp /home/aditya/workspaces/rustrover/minigraf/minigraf-ffi/src/lib.rs src/lib.rs +cp /home/aditya/workspaces/rustrover/minigraf/minigraf-ffi/src/uniffi_bindgen.rs src/uniffi_bindgen.rs +``` + +- [ ] **Step 4: Copy android/ directory from monorepo** + +```bash +cp -r /home/aditya/workspaces/rustrover/minigraf/minigraf-ffi/android ./android +``` + +- [ ] **Step 5: Replace android/build.gradle.kts** + +The existing file publishes to GitHub Packages with groupId `io.github.adityamukho`. Replace it entirely with NMCP-based Maven Central publishing under `io.github.project-minigraf`. + +```kotlin +plugins { + id("com.android.library") version "8.2.2" + id("maven-publish") + signing + id("com.gradleup.nmcp") version "0.0.8" +} + +android { + namespace = "io.github.project_minigraf.minigraf" + compileSdk = 34 + defaultConfig { + minSdk = 24 + targetSdk = 34 + } + sourceSets { + getByName("main") { + jniLibs.srcDirs("jniLibs") + java.srcDirs("src/main/java") + } + } + publishing { + singleVariant("release") + } +} + +afterEvaluate { + publishing { + publications { + create("release") { + from(components["release"]) + groupId = "io.github.project-minigraf" + artifactId = "minigraf-android" + version = System.getenv("RELEASE_VERSION") ?: "0.0.0-local" + + pom { + name.set("Minigraf Android") + description.set("Zero-config, single-file, embedded graph database with bi-temporal Datalog queries — Android bindings") + url.set("https://github.com/project-minigraf/minigraf-android") + licenses { + license { + name.set("MIT OR Apache-2.0") + url.set("https://github.com/project-minigraf/minigraf-android/blob/main/LICENSE-MIT") + } + } + developers { + developer { + id.set("adityamukho") + name.set("Aditya Mukhopadhyay") + } + } + scm { + connection.set("scm:git:git://github.com/project-minigraf/minigraf-android.git") + developerConnection.set("scm:git:ssh://github.com/project-minigraf/minigraf-android.git") + url.set("https://github.com/project-minigraf/minigraf-android") + } + } + } + } + } + + signing { + val signingKey = System.getenv("GPG_SIGNING_KEY") + val signingPassword = System.getenv("GPG_SIGNING_PASSWORD") + if (signingKey != null && signingPassword != null) { + useInMemoryPgpKeys(signingKey, signingPassword) + sign(publishing.publications["release"]) + } + } +} + +nmcp { + publish("release") { + username = System.getenv("CENTRAL_TOKEN_USERNAME") ?: "" + password = System.getenv("CENTRAL_TOKEN_PASSWORD") ?: "" + publicationType = "AUTOMATIC" + } +} +``` + +- [ ] **Step 6: Verify Rust tests pass** + +```bash +cargo test +``` + +Expected: all tests pass. + +- [ ] **Step 7: Write .github/workflows/ci.yml** + +Adapted from the Android half of monorepo's `mobile.yml`. Runs cross-compile + assemble as a smoke test on PRs. + +```yaml +name: CI + +on: + push: + branches: [main] + pull_request: + +jobs: + rust-test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: dtolnay/rust-toolchain@stable + - run: cargo test + + android-build: + name: Android cross-compile smoke test + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - uses: dtolnay/rust-toolchain@stable + with: + targets: aarch64-linux-android,armv7-linux-androideabi,x86_64-linux-android + + - name: Install cargo-ndk + run: cargo install cargo-ndk --locked + + - name: Set ANDROID_NDK_HOME + run: echo "ANDROID_NDK_HOME=$ANDROID_NDK_LATEST_HOME" >> $GITHUB_ENV + + - uses: actions/setup-java@v4 + with: + java-version: '17' + distribution: 'temurin' + + - name: Cross-compile Android targets + run: | + cargo ndk \ + -t arm64-v8a \ + -t armeabi-v7a \ + -t x86_64 \ + -o android/jniLibs \ + build --release + + - name: Generate Kotlin bindings + run: | + cargo run --bin uniffi-bindgen -- generate \ + --library target/aarch64-linux-android/release/libminigraf_ffi.so \ + --language kotlin \ + --out-dir android/src/main/java/ + + - name: Assemble AAR + run: cd android && ./gradlew assembleRelease +``` + +- [ ] **Step 8: Write .github/workflows/release.yml** + +Adapted from the Android half of monorepo's `mobile.yml`. Key changes: triggered by `repository_dispatch`; adds `prepare` job; `minigraf-ffi/android/` → `android/`; publishes to Maven Central instead of GitHub Packages. + +```yaml +name: Android Release + +on: + repository_dispatch: + types: [core-release] + workflow_dispatch: + inputs: + version: + description: 'Version tag (e.g. v1.2.0)' + required: true + +jobs: + prepare: + name: Pin version, commit, tag + runs-on: ubuntu-latest + outputs: + tag: ${{ steps.ver.outputs.tag }} + semver: ${{ steps.ver.outputs.semver }} + steps: + - uses: actions/checkout@v4 + with: + token: ${{ secrets.MINIGRAF_RELEASE_TOKEN }} + + - id: ver + run: | + V="${{ github.event.client_payload.version || github.event.inputs.version }}" + echo "tag=$V" >> "$GITHUB_OUTPUT" + echo "semver=${V#v}" >> "$GITHUB_OUTPUT" + + - name: Pin minigraf version in Cargo.toml + run: | + sed -i 's/^minigraf = "[^"]*"/minigraf = "${{ steps.ver.outputs.semver }}"/' Cargo.toml + + - name: Commit and push tag + run: | + git config user.name "github-actions[bot]" + git config user.email "github-actions[bot]@users.noreply.github.com" + git add Cargo.toml + git commit -m "chore: release ${{ steps.ver.outputs.tag }}" + git tag "${{ steps.ver.outputs.tag }}" + git push origin main --follow-tags + + build-and-publish: + name: Build AAR and publish to Maven Central + needs: prepare + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ needs.prepare.outputs.tag }} + + - uses: dtolnay/rust-toolchain@stable + with: + targets: aarch64-linux-android,armv7-linux-androideabi,x86_64-linux-android + + - name: Install cargo-ndk + run: cargo install cargo-ndk --locked + + - name: Set ANDROID_NDK_HOME + run: echo "ANDROID_NDK_HOME=$ANDROID_NDK_LATEST_HOME" >> $GITHUB_ENV + + - uses: actions/setup-java@v4 + with: + java-version: '17' + distribution: 'temurin' + + - name: Cross-compile Android targets + run: | + cargo ndk \ + -t arm64-v8a \ + -t armeabi-v7a \ + -t x86_64 \ + -o android/jniLibs \ + build --release + + - name: Generate Kotlin bindings + run: | + cargo run --bin uniffi-bindgen -- generate \ + --library target/aarch64-linux-android/release/libminigraf_ffi.so \ + --language kotlin \ + --out-dir android/src/main/java/ + + - name: Assemble AAR + run: cd android && ./gradlew assembleRelease + + - name: Publish to Maven Central + env: + CENTRAL_TOKEN_USERNAME: ${{ secrets.CENTRAL_TOKEN_USERNAME }} + CENTRAL_TOKEN_PASSWORD: ${{ secrets.CENTRAL_TOKEN_PASSWORD }} + GPG_SIGNING_KEY: ${{ secrets.GPG_SIGNING_KEY }} + GPG_SIGNING_PASSWORD: ${{ secrets.GPG_SIGNING_PASSWORD }} + RELEASE_VERSION: ${{ needs.prepare.outputs.semver }} + run: cd android && ./gradlew publishAllPublicationsToCentralPortal +``` + +- [ ] **Step 9: Write README.md** + +```markdown +# minigraf-android + +Android binding for [Minigraf](https://github.com/project-minigraf/minigraf) — zero-config, +single-file, embedded bi-temporal graph database with Datalog queries. + +## Installation + +```kotlin +dependencies { + implementation("io.github.project-minigraf:minigraf-android:1.1.1") +} +``` + +Minimum SDK: 24 (Android 7.0). Supports arm64-v8a, armeabi-v7a, x86_64. + +## Quick start + +```kotlin +import io.github.project_minigraf.minigraf.MiniGrafDb + +val db = MiniGrafDb.openInMemory() +val result = db.execute("""(transact [[:alice :name "Alice"]])""") +println(result) // {"transacted":1} +``` + +## Building from source + +Requires Rust stable toolchain, Android NDK, and JDK 17. + +```bash +cargo install cargo-ndk --locked +cargo ndk -t arm64-v8a -t armeabi-v7a -t x86_64 -o android/jniLibs build --release +cargo run --bin uniffi-bindgen -- generate \ + --library target/aarch64-linux-android/release/libminigraf_ffi.so \ + --language kotlin \ + --out-dir android/src/main/java/ +cd android && ./gradlew assembleRelease +``` + +## License + +MIT OR Apache-2.0 +``` + +- [ ] **Step 10: Commit and push** + +```bash +git add . +git commit -m "feat: initial minigraf-android repo — Android binding split from monorepo" +git push origin main +``` + +--- + +## Task 5: Create minigraf-swift repo + +**Files:** +- Create: `Cargo.toml`, `src/lib.rs`, `src/uniffi_bindgen.rs` +- Copy: `src/lib.rs`, `src/uniffi_bindgen.rs` from monorepo's `minigraf-ffi/src/` +- Create: `Sources/MinigrafKit/.gitkeep` +- Create: `Package.swift` (updated URLs and paths) +- Create: `.github/workflows/ci.yml`, `.github/workflows/release.yml`, `README.md` + +- [ ] **Step 1: Create the GitHub repo and clone it** + +```bash +gh repo create project-minigraf/minigraf-swift \ + --public \ + --description "Swift/iOS binding for Minigraf — bi-temporal graph database" \ + --clone +cd minigraf-swift +mkdir -p src Sources/MinigrafKit .github/workflows +``` + +- [ ] **Step 2: Write Cargo.toml** + +iOS requires staticlib (cdylib is not supported on iOS device). Keep both so the `uniffi-bindgen` binary (which runs on host) can also link dynamically. + +```toml +[package] +name = "minigraf-swift-shim" +version = "0.0.0" +edition = "2024" +publish = false +description = "Swift/iOS binding for Minigraf — bi-temporal graph database" + +[lib] +name = "minigraf_ffi" +crate-type = ["staticlib", "cdylib"] + +[[bin]] +name = "uniffi-bindgen" +path = "src/uniffi_bindgen.rs" + +[dependencies] +# Pin to the exact released version. The release workflow updates this line. +minigraf = "1.1.1" +uniffi = { version = "0.31.1", features = ["cli"] } +thiserror = "2.0.18" +serde_json = "1.0.149" +anyhow = "1" + +[workspace] +members = ["."] +``` + +- [ ] **Step 3: Copy src/lib.rs and src/uniffi_bindgen.rs from monorepo** + +```bash +cp /home/aditya/workspaces/rustrover/minigraf/minigraf-ffi/src/lib.rs src/lib.rs +cp /home/aditya/workspaces/rustrover/minigraf/minigraf-ffi/src/uniffi_bindgen.rs src/uniffi_bindgen.rs +``` + +- [ ] **Step 4: Create Sources/MinigrafKit/.gitkeep** + +The Swift sources are generated and committed by the release CI (to the `swift-releases` branch). The directory must exist on main so the `Package.swift` target path resolves. + +```bash +touch Sources/MinigrafKit/.gitkeep +``` + +- [ ] **Step 5: Write Package.swift** + +Updated from monorepo: URL points to `minigraf-swift` repo (not `minigraf`); path is `Sources/MinigrafKit` (not `minigraf-swift/Sources/MinigrafKit`). + +```swift +// swift-tools-version: 5.9 +import PackageDescription + +// This file is automatically updated by CI after each release. +// The URL and checksum below are updated to point to the latest .xcframework.zip. +let package = Package( + name: "MinigrafKit", + platforms: [ + .iOS(.v16), + ], + products: [ + .library( + name: "MinigrafKit", + targets: ["minigrafFFI", "MinigrafKit"] + ), + ], + targets: [ + .binaryTarget( + name: "minigrafFFI", + // Updated by CI: release.yml + url: "https://github.com/project-minigraf/minigraf-swift/releases/download/v1.1.1/MinigrafKit-v1.1.1.xcframework.zip", + checksum: "0000000000000000000000000000000000000000000000000000000000000000" + ), + .target( + name: "MinigrafKit", + dependencies: [.target(name: "minigrafFFI")], + path: "Sources/MinigrafKit" + ), + ] +) +``` + +- [ ] **Step 6: Verify Rust tests pass (on any platform)** + +```bash +cargo test +``` + +Expected: all tests pass. + +- [ ] **Step 7: Write .github/workflows/ci.yml** + +```yaml +name: CI + +on: + push: + branches: [main] + pull_request: + +jobs: + rust-test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: dtolnay/rust-toolchain@stable + - run: cargo test + + ios-build: + name: iOS simulator build smoke test + runs-on: macos-14 + steps: + - uses: actions/checkout@v4 + - uses: dtolnay/rust-toolchain@stable + with: + targets: aarch64-apple-ios-sim + - name: Build for iOS simulator + run: cargo build --target aarch64-apple-ios-sim --release +``` + +- [ ] **Step 8: Write .github/workflows/release.yml** + +Adapted from the iOS + swift-publish half of monorepo's `mobile.yml`. Key changes: triggered by `repository_dispatch`; adds `prepare` job; all xcframework artifact URLs updated to `minigraf-swift` repo; `Package.swift` path is now repo root (not monorepo root); `minigraf-swift/Sources/MinigrafKit` path → `Sources/MinigrafKit`; creates its own GitHub Release (no waiting for cargo-dist). + +```yaml +name: Swift Release + +on: + repository_dispatch: + types: [core-release] + workflow_dispatch: + inputs: + version: + description: 'Version tag (e.g. v1.2.0)' + required: true + +permissions: + contents: write + +jobs: + prepare: + name: Pin version, commit, tag + runs-on: ubuntu-latest + outputs: + tag: ${{ steps.ver.outputs.tag }} + semver: ${{ steps.ver.outputs.semver }} + steps: + - uses: actions/checkout@v4 + with: + token: ${{ secrets.MINIGRAF_RELEASE_TOKEN }} + + - id: ver + run: | + V="${{ github.event.client_payload.version || github.event.inputs.version }}" + echo "tag=$V" >> "$GITHUB_OUTPUT" + echo "semver=${V#v}" >> "$GITHUB_OUTPUT" + + - name: Pin minigraf version in Cargo.toml + run: | + sed -i 's/^minigraf = "[^"]*"/minigraf = "${{ steps.ver.outputs.semver }}"/' Cargo.toml + + - name: Commit and push tag + run: | + git config user.name "github-actions[bot]" + git config user.email "github-actions[bot]@users.noreply.github.com" + git add Cargo.toml + git commit -m "chore: release ${{ steps.ver.outputs.tag }}" + git tag "${{ steps.ver.outputs.tag }}" + git push origin main --follow-tags + + build-and-publish: + name: Build xcframework and publish + needs: prepare + runs-on: macos-latest + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ needs.prepare.outputs.tag }} + token: ${{ secrets.MINIGRAF_RELEASE_TOKEN }} + fetch-depth: 0 + + - uses: dtolnay/rust-toolchain@stable + with: + targets: aarch64-apple-ios,aarch64-apple-ios-sim + + - name: Build iOS device library + run: cargo build --target aarch64-apple-ios --release + + - name: Build iOS simulator library + run: cargo build --target aarch64-apple-ios-sim --release + + - name: Generate Swift bindings + run: | + mkdir -p Sources/MinigrafKit + cargo run --bin uniffi-bindgen -- generate \ + --library target/aarch64-apple-ios/release/libminigraf_ffi.a \ + --language swift \ + --out-dir Sources/MinigrafKit/ + + - name: Prepare headers for xcframework + run: | + mkdir -p includes + cp Sources/MinigrafKit/*.h includes/ 2>/dev/null || true + cp Sources/MinigrafKit/*.modulemap includes/ 2>/dev/null || true + + - name: Assemble xcframework + run: | + TAG="${{ needs.prepare.outputs.tag }}" + xcodebuild -create-xcframework \ + -library target/aarch64-apple-ios/release/libminigraf_ffi.a \ + -headers includes/ \ + -library target/aarch64-apple-ios-sim/release/libminigraf_ffi.a \ + -headers includes/ \ + -output "MinigrafKit.xcframework" + zip -r "MinigrafKit-${TAG}.xcframework.zip" MinigrafKit.xcframework + + - name: Create GitHub Release and upload xcframework + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + TAG="${{ needs.prepare.outputs.tag }}" + gh release create "$TAG" \ + --repo "$GITHUB_REPOSITORY" \ + --title "MinigrafKit $TAG" \ + --notes "Swift/iOS binding for minigraf $TAG." + gh release upload "$TAG" "MinigrafKit-${TAG}.xcframework.zip" \ + --repo "$GITHUB_REPOSITORY" + + - name: Compute checksum and update Package.swift + run: | + TAG="${{ needs.prepare.outputs.tag }}" + CHECKSUM=$(shasum -a 256 "MinigrafKit-${TAG}.xcframework.zip" | awk '{print $1}') + URL="https://github.com/${GITHUB_REPOSITORY}/releases/download/${TAG}/MinigrafKit-${TAG}.xcframework.zip" + sed -i '' \ + -e "s|url: \"https://github.com/.*/releases/download/.*/MinigrafKit-.*\\.xcframework\\.zip\"|url: \"${URL}\"|" \ + -e "s|checksum: \"[^\"]*\"|checksum: \"${CHECKSUM}\"|" \ + Package.swift + + - name: Commit Package.swift and Swift sources to swift-releases branch + env: + TAG: ${{ needs.prepare.outputs.tag }} + run: | + git config user.email "github-actions[bot]@users.noreply.github.com" + git config user.name "github-actions[bot]" + + TMPDIR_SWIFT=$(mktemp -d) + cp Package.swift "$TMPDIR_SWIFT/Package.swift" + cp -r Sources/MinigrafKit/ "$TMPDIR_SWIFT/MinigrafKit" + + if git fetch origin swift-releases 2>/dev/null; then + git checkout -fB swift-releases origin/swift-releases + else + git checkout --orphan swift-releases + git rm -rf . --quiet 2>/dev/null || true + fi + + cp "$TMPDIR_SWIFT/Package.swift" Package.swift + mkdir -p Sources/MinigrafKit/ + cp -r "$TMPDIR_SWIFT/MinigrafKit/." Sources/MinigrafKit/ + rm -rf "$TMPDIR_SWIFT" + + git add Package.swift Sources/MinigrafKit/ + git commit -m "chore(release): update Package.swift and Swift bindings for ${TAG}" \ + || echo "Nothing to commit" + git push origin swift-releases --force + + NEW_SHA=$(git rev-parse HEAD) + SWIFT_TAG="swift-${TAG}" + gh api "repos/${GITHUB_REPOSITORY}/git/refs" \ + -X POST \ + -f ref="refs/tags/${SWIFT_TAG}" \ + -f sha="$NEW_SHA" 2>/dev/null \ + || gh api "repos/${GITHUB_REPOSITORY}/git/refs/tags/${SWIFT_TAG}" \ + -X PATCH \ + -f sha="$NEW_SHA" \ + -F force=true + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} +``` + +- [ ] **Step 9: Write README.md** + +```markdown +# minigraf-swift + +Swift/iOS binding for [Minigraf](https://github.com/project-minigraf/minigraf) — zero-config, +single-file, embedded bi-temporal graph database with Datalog queries. + +## Installation + +### Swift Package Manager + +In Xcode: File → Add Package Dependencies → enter this repo URL. + +Or add to `Package.swift`: + +```swift +dependencies: [ + .package(url: "https://github.com/project-minigraf/minigraf-swift", from: "1.1.1") +] +``` + +> SPM resolves via the `swift-v` tag which points to the `swift-releases` branch +> containing the updated `Package.swift` and generated Swift sources. + +Requires iOS 16+. + +## Quick start + +```swift +import MinigrafKit + +let db = try MiniGrafDb.openInMemory() +let result = try db.execute(datalog: #"(transact [[:alice :name "Alice"]])"#) +print(result) // {"transacted":1} +``` + +## Building from source + +Requires Rust stable toolchain with iOS targets and Xcode. + +```bash +rustup target add aarch64-apple-ios aarch64-apple-ios-sim +cargo build --target aarch64-apple-ios --release +cargo build --target aarch64-apple-ios-sim --release +cargo run --bin uniffi-bindgen -- generate \ + --library target/aarch64-apple-ios/release/libminigraf_ffi.a \ + --language swift \ + --out-dir Sources/MinigrafKit/ +``` + +## License + +MIT OR Apache-2.0 +``` + +- [ ] **Step 10: Commit and push** + +```bash +git add . +git commit -m "feat: initial minigraf-swift repo — Swift/iOS binding split from monorepo" +git push origin main +``` + +--- + +## Task 6: Update monorepo cascade + +**Files:** +- Modify: `.github/workflows/cascade.yml` + +- [ ] **Step 1: Read the current cascade.yml** + +File: `/home/aditya/workspaces/rustrover/minigraf/.github/workflows/cascade.yml` + +- [ ] **Step 2: Replace cascade.yml with updated version** + +The `publish-ffi` job is removed entirely. `dispatch-bindings` now polls for minigraf core itself (moved from `publish-ffi`), then dispatches to all 7 repos. + +```yaml +name: Release Cascade + +on: + push: + tags: + - 'v[0-9]*.[0-9]*.[0-9]*' + +jobs: + dispatch-bindings: + name: Dispatch to binding repos + runs-on: ubuntu-latest + steps: + - name: Wait for minigraf to be indexed on crates.io + run: | + VERSION="${GITHUB_REF_NAME#v}" + echo "Waiting for minigraf@$VERSION on crates.io..." + FOUND=0 + for i in $(seq 1 18); do + STATUS=$(curl -s "https://crates.io/api/v1/crates/minigraf/$VERSION" \ + -H "User-Agent: minigraf-cascade/1.0" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('version',{}).get('num',''))" 2>/dev/null || echo "") + if [ "$STATUS" = "$VERSION" ]; then + echo "minigraf@$VERSION is live (attempt $i)" + FOUND=1 + break + fi + echo "Attempt $i/18: not yet available, waiting 10s..." + sleep 10 + done + if [ "$FOUND" != "1" ]; then + echo "ERROR: minigraf@$VERSION did not appear on crates.io within 3 minutes" + exit 1 + fi + + - name: Dispatch to binding repos + env: + GH_TOKEN: ${{ secrets.MINIGRAF_RELEASE_TOKEN }} + run: | + VERSION="${GITHUB_REF_NAME}" + for REPO in minigraf-python minigraf-node minigraf-wasm \ + minigraf-java minigraf-android minigraf-swift minigraf-c; do + echo "Dispatching core-release to project-minigraf/$REPO @ $VERSION" + gh api repos/project-minigraf/$REPO/dispatches \ + -f event_type=core-release \ + -f "client_payload[version]=$VERSION" + done +``` + +- [ ] **Step 3: Validate the YAML** + +```bash +cd /home/aditya/workspaces/rustrover/minigraf +python3 -c "import yaml; yaml.safe_load(open('.github/workflows/cascade.yml'))" && echo "YAML valid" +``` + +Expected: `YAML valid` + +- [ ] **Step 4: Commit** + +```bash +git add .github/workflows/cascade.yml +git commit -m "ci(cascade): remove publish-ffi job; dispatch to 7 binding repos" +``` + +--- + +## Task 7: Clean up monorepo + +**Files:** +- Delete: `minigraf-ffi/`, `minigraf-swift/`, `minigraf-c/`, `Package.swift` +- Delete: `java-ci.yml`, `java-release.yml`, `mobile.yml`, `c-ci.yml`, `c-release.yml`, `publish-ffi.yml` +- Modify: `Cargo.toml` + +- [ ] **Step 1: Remove binding source directories** + +```bash +cd /home/aditya/workspaces/rustrover/minigraf +git rm -r minigraf-ffi/ minigraf-swift/ minigraf-c/ Package.swift +``` + +- [ ] **Step 2: Remove workflow files** + +```bash +git rm \ + .github/workflows/java-ci.yml \ + .github/workflows/java-release.yml \ + .github/workflows/mobile.yml \ + .github/workflows/c-ci.yml \ + .github/workflows/c-release.yml \ + .github/workflows/publish-ffi.yml +``` + +- [ ] **Step 3: Update workspace members in Cargo.toml** + +Current `[workspace]` section (lines 1-4 of Cargo.toml): + +```toml +[workspace] +members = [".", "minigraf-ffi", "minigraf-c"] +exclude = ["fuzz"] +resolver = "2" +``` + +Replace with: + +```toml +[workspace] +members = ["."] +exclude = ["fuzz"] +resolver = "2" +``` + +- [ ] **Step 4: Verify the monorepo still builds and tests pass** + +```bash +cargo test +``` + +Expected: all existing tests pass (962 tests). No compilation errors. + +- [ ] **Step 5: Commit** + +```bash +git add Cargo.toml +git commit -m "chore(cleanup): remove binding directories and workflows — split to separate repos (#231)" +``` + +- [ ] **Step 6: Push** + +```bash +git push origin main +``` + +--- + +## Task 8: Retire minigraf-ffi on crates.io + +**Note:** `cargo yank` requires being logged in to crates.io with `cargo login`. Ensure the session has a valid token before running these commands. + +- [ ] **Step 1: Yank minigraf-ffi 1.1.1** + +```bash +cargo yank minigraf-ffi --version 1.1.1 \ + --message "This crate has been retired. Depend on \`minigraf\` directly. To build a new language binding, see https://github.com/project-minigraf/minigraf-binding-template" +``` + +Expected output: `Updating crates.io index` then `minigraf-ffi@1.1.1 is yanked` + +- [ ] **Step 2: Yank minigraf-ffi 1.1.2** + +```bash +cargo yank minigraf-ffi --version 1.1.2 \ + --message "This crate has been retired. Depend on \`minigraf\` directly. To build a new language binding, see https://github.com/project-minigraf/minigraf-binding-template" +``` + +Expected output: `minigraf-ffi@1.1.2 is yanked` + +- [ ] **Step 3: Verify on crates.io** + +Visit `https://crates.io/crates/minigraf-ffi` and confirm both versions show as yanked. The yank message should appear alongside each version. From fce761f48ca5282ec67d2f44372f76d2788f31c2 Mon Sep 17 00:00:00 2001 From: Aditya Mukhopadhyay Date: Mon, 18 May 2026 14:35:50 +0530 Subject: [PATCH 3/6] ci(cascade): remove publish-ffi job; dispatch to 7 binding repos --- .github/workflows/cascade.yml | 44 ++++------------------------------- 1 file changed, 5 insertions(+), 39 deletions(-) diff --git a/.github/workflows/cascade.yml b/.github/workflows/cascade.yml index a0df937c33..3b6dacf4ba 100644 --- a/.github/workflows/cascade.yml +++ b/.github/workflows/cascade.yml @@ -6,14 +6,10 @@ on: - 'v[0-9]*.[0-9]*.[0-9]*' jobs: - publish-ffi: - name: Publish minigraf-ffi to crates.io + dispatch-bindings: + name: Dispatch to binding repos runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 - - - uses: dtolnay/rust-toolchain@stable - - name: Wait for minigraf to be indexed on crates.io run: | VERSION="${GITHUB_REF_NAME#v}" @@ -35,43 +31,13 @@ jobs: exit 1 fi - - name: Publish minigraf-ffi - env: - CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }} - run: cargo publish -p minigraf-ffi - - - name: Wait for minigraf-ffi to be indexed on crates.io - run: | - VERSION="${GITHUB_REF_NAME#v}" - echo "Waiting for minigraf-ffi@$VERSION on crates.io..." - FOUND=0 - for i in $(seq 1 18); do - STATUS=$(curl -s "https://crates.io/api/v1/crates/minigraf-ffi/$VERSION" \ - -H "User-Agent: minigraf-cascade/1.0" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('version',{}).get('num',''))" 2>/dev/null || echo "") - if [ "$STATUS" = "$VERSION" ]; then - echo "minigraf-ffi@$VERSION is live (attempt $i)" - FOUND=1 - break - fi - echo "Attempt $i/18: not yet available, waiting 10s..." - sleep 10 - done - if [ "$FOUND" != "1" ]; then - echo "ERROR: minigraf-ffi@$VERSION did not appear on crates.io within 3 minutes" - exit 1 - fi - - dispatch-bindings: - name: Dispatch to binding repos - needs: publish-ffi - runs-on: ubuntu-latest - steps: - - name: Dispatch to Phase 1 binding repos + - name: Dispatch to binding repos env: GH_TOKEN: ${{ secrets.MINIGRAF_RELEASE_TOKEN }} run: | VERSION="${GITHUB_REF_NAME}" - for REPO in minigraf-python minigraf-node minigraf-wasm; do + for REPO in minigraf-python minigraf-node minigraf-wasm \ + minigraf-java minigraf-android minigraf-swift minigraf-c; do echo "Dispatching core-release to project-minigraf/$REPO @ $VERSION" gh api repos/project-minigraf/$REPO/dispatches \ -f event_type=core-release \ From 15605d0a5b350356eefbaec4af7314879dc2a4cd Mon Sep 17 00:00:00 2001 From: Aditya Mukhopadhyay Date: Mon, 18 May 2026 14:36:54 +0530 Subject: [PATCH 4/6] =?UTF-8?q?chore(cleanup):=20remove=20binding=20direct?= =?UTF-8?q?ories=20and=20workflows=20=E2=80=94=20split=20to=20separate=20r?= =?UTF-8?q?epos=20(#231)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .github/workflows/c-ci.yml | 49 --- .github/workflows/c-release.yml | 137 -------- .github/workflows/java-ci.yml | 40 --- .github/workflows/java-release.yml | 120 ------- .github/workflows/mobile.yml | 265 -------------- .github/workflows/publish-ffi.yml | 23 -- Cargo.toml | 2 +- Package.swift | 30 -- minigraf-c/Cargo.toml | 16 - minigraf-c/README.md | 86 ----- minigraf-c/cbindgen.toml | 17 - minigraf-c/include/minigraf.h | 36 -- minigraf-c/src/lib.rs | 298 ---------------- minigraf-ffi/Cargo.toml | 29 -- minigraf-ffi/README.md | 22 -- minigraf-ffi/android/build.gradle.kts | 45 --- .../android/gradle/wrapper/gradle-wrapper.jar | Bin 53638 -> 0 bytes .../gradle/wrapper/gradle-wrapper.properties | 7 - minigraf-ffi/android/gradlew | 132 ------- minigraf-ffi/android/gradlew.bat | 92 ----- minigraf-ffi/android/jniLibs/.gitkeep | 0 minigraf-ffi/android/settings.gradle.kts | 16 - .../android/src/main/AndroidManifest.xml | 2 - minigraf-ffi/android/src/main/java/.gitkeep | 0 minigraf-ffi/java/.gitignore | 3 - minigraf-ffi/java/README.md | 66 ---- minigraf-ffi/java/build.gradle.kts | 192 ---------- .../java/gradle/wrapper/gradle-wrapper.jar | Bin 43583 -> 0 bytes .../gradle/wrapper/gradle-wrapper.properties | 7 - minigraf-ffi/java/gradlew | 252 -------------- minigraf-ffi/java/gradlew.bat | 94 ----- minigraf-ffi/java/settings.gradle.kts | 1 - .../project_minigraf/minigraf/NativeLoader.kt | 57 --- .../project_minigraf/minigraf/BasicTest.kt | 69 ---- minigraf-ffi/src/lib.rs | 327 ------------------ minigraf-ffi/src/uniffi_bindgen.rs | 3 - minigraf-swift/Sources/MinigrafKit/.gitkeep | 0 37 files changed, 1 insertion(+), 2534 deletions(-) delete mode 100644 .github/workflows/c-ci.yml delete mode 100644 .github/workflows/c-release.yml delete mode 100644 .github/workflows/java-ci.yml delete mode 100644 .github/workflows/java-release.yml delete mode 100644 .github/workflows/mobile.yml delete mode 100644 .github/workflows/publish-ffi.yml delete mode 100644 Package.swift delete mode 100644 minigraf-c/Cargo.toml delete mode 100644 minigraf-c/README.md delete mode 100644 minigraf-c/cbindgen.toml delete mode 100644 minigraf-c/include/minigraf.h delete mode 100644 minigraf-c/src/lib.rs delete mode 100644 minigraf-ffi/Cargo.toml delete mode 100644 minigraf-ffi/README.md delete mode 100644 minigraf-ffi/android/build.gradle.kts delete mode 100755 minigraf-ffi/android/gradle/wrapper/gradle-wrapper.jar delete mode 100644 minigraf-ffi/android/gradle/wrapper/gradle-wrapper.properties delete mode 100755 minigraf-ffi/android/gradlew delete mode 100644 minigraf-ffi/android/gradlew.bat delete mode 100644 minigraf-ffi/android/jniLibs/.gitkeep delete mode 100644 minigraf-ffi/android/settings.gradle.kts delete mode 100644 minigraf-ffi/android/src/main/AndroidManifest.xml delete mode 100644 minigraf-ffi/android/src/main/java/.gitkeep delete mode 100644 minigraf-ffi/java/.gitignore delete mode 100644 minigraf-ffi/java/README.md delete mode 100644 minigraf-ffi/java/build.gradle.kts delete mode 100644 minigraf-ffi/java/gradle/wrapper/gradle-wrapper.jar delete mode 100644 minigraf-ffi/java/gradle/wrapper/gradle-wrapper.properties delete mode 100755 minigraf-ffi/java/gradlew delete mode 100644 minigraf-ffi/java/gradlew.bat delete mode 100644 minigraf-ffi/java/settings.gradle.kts delete mode 100644 minigraf-ffi/java/src/main/kotlin/io/github/project_minigraf/minigraf/NativeLoader.kt delete mode 100644 minigraf-ffi/java/src/test/kotlin/io/github/project_minigraf/minigraf/BasicTest.kt delete mode 100644 minigraf-ffi/src/lib.rs delete mode 100644 minigraf-ffi/src/uniffi_bindgen.rs delete mode 100644 minigraf-swift/Sources/MinigrafKit/.gitkeep diff --git a/.github/workflows/c-ci.yml b/.github/workflows/c-ci.yml deleted file mode 100644 index 7f8f8b7230..0000000000 --- a/.github/workflows/c-ci.yml +++ /dev/null @@ -1,49 +0,0 @@ -name: C CI - -on: - push: - branches: [main] - pull_request: - branches: [main] - -jobs: - test: - name: C tests (${{ matrix.os }}) - runs-on: ${{ matrix.os }} - strategy: - fail-fast: false - matrix: - os: [ubuntu-latest, ubuntu-24.04-arm, macos-14, windows-latest] - - steps: - - uses: actions/checkout@v4 - - - name: Install Rust toolchain - uses: dtolnay/rust-toolchain@stable - - - name: Run tests - run: cargo test -p minigraf-c -- --nocapture - - check-header-drift: - name: Verify minigraf.h is up to date - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v4 - - - name: Install Rust toolchain - uses: dtolnay/rust-toolchain@stable - - - name: Install cbindgen - run: cargo install cbindgen --version 0.29.2 --locked - - - name: Regenerate header - run: | - cbindgen --config minigraf-c/cbindgen.toml \ - --crate minigraf-c \ - --output /tmp/minigraf_generated.h - - - name: Fail if header has drifted - run: | - diff minigraf-c/include/minigraf.h /tmp/minigraf_generated.h || \ - (echo "minigraf.h is out of date — run cbindgen locally and commit the result" && exit 1) diff --git a/.github/workflows/c-release.yml b/.github/workflows/c-release.yml deleted file mode 100644 index 9e68a005ee..0000000000 --- a/.github/workflows/c-release.yml +++ /dev/null @@ -1,137 +0,0 @@ -name: C Release - -on: - push: - tags: - - 'v[0-9]*.[0-9]*.[0-9]*' - workflow_dispatch: - inputs: - tag: - description: 'Release tag to upload C artifacts to (e.g. "v0.24.0")' - required: false - type: string - -jobs: - build: - name: Build C library (${{ matrix.os }}) - runs-on: ${{ matrix.os }} - permissions: - contents: read - strategy: - fail-fast: false - matrix: - include: - - os: ubuntu-latest - target: x86_64-unknown-linux-gnu - artifact-name: linux-x86_64 - lib-name: libminigraf.so - src-lib: libminigraf_c.so - - os: ubuntu-24.04-arm - target: aarch64-unknown-linux-gnu - artifact-name: linux-aarch64 - lib-name: libminigraf.so - src-lib: libminigraf_c.so - - os: macos-14 - target: universal2 - artifact-name: macos-universal2 - lib-name: libminigraf.dylib - src-lib: libminigraf_c.dylib - - os: windows-latest - target: x86_64-pc-windows-msvc - artifact-name: windows-x86_64 - lib-name: minigraf.dll - src-lib: minigraf_c.dll - - steps: - - uses: actions/checkout@v4 - - - name: Install Rust toolchain - uses: dtolnay/rust-toolchain@stable - with: - targets: ${{ matrix.target == 'universal2' && 'aarch64-apple-darwin x86_64-apple-darwin' || matrix.target }} - - - name: Build (universal2) - if: matrix.target == 'universal2' - run: | - cargo build --release -p minigraf-c --target aarch64-apple-darwin - cargo build --release -p minigraf-c --target x86_64-apple-darwin - lipo -create \ - target/aarch64-apple-darwin/release/libminigraf_c.dylib \ - target/x86_64-apple-darwin/release/libminigraf_c.dylib \ - -output ${{ matrix.lib-name }} - - - name: Build (other) - if: matrix.target != 'universal2' - run: cargo build --release -p minigraf-c --target ${{ matrix.target }} - - - name: Rename and package (unix) - if: runner.os != 'Windows' && matrix.target != 'universal2' - run: | - cp target/${{ matrix.target }}/release/${{ matrix.src-lib }} ${{ matrix.lib-name }} - tar czf minigraf-c-${{ inputs.tag || github.ref_name }}-${{ matrix.artifact-name }}.tar.gz \ - ${{ matrix.lib-name }} minigraf-c/include/minigraf.h - - - name: Rename and package (universal2) - if: matrix.target == 'universal2' - run: | - tar czf minigraf-c-${{ inputs.tag || github.ref_name }}-${{ matrix.artifact-name }}.tar.gz \ - ${{ matrix.lib-name }} minigraf-c/include/minigraf.h - - - name: Rename and package (windows) - if: runner.os == 'Windows' - run: | - copy target\${{ matrix.target }}\release\${{ matrix.src-lib }} ${{ matrix.lib-name }} - Compress-Archive -Path ${{ matrix.lib-name }},minigraf-c\include\minigraf.h ` - -DestinationPath minigraf-c-${{ inputs.tag || github.ref_name }}-${{ matrix.artifact-name }}.zip - shell: pwsh - - - name: Upload artifact (unix) - if: runner.os != 'Windows' - uses: actions/upload-artifact@v4 - with: - name: c-release-${{ matrix.artifact-name }} - path: minigraf-c-${{ inputs.tag || github.ref_name }}-${{ matrix.artifact-name }}.tar.gz - - - name: Upload artifact (windows) - if: runner.os == 'Windows' - uses: actions/upload-artifact@v4 - with: - name: c-release-${{ matrix.artifact-name }} - path: minigraf-c-${{ inputs.tag || github.ref_name }}-${{ matrix.artifact-name }}.zip - - upload-to-release: - name: Upload artifacts to GitHub Release - needs: build - runs-on: ubuntu-latest - permissions: - contents: write - - steps: - - name: Download all artifacts - uses: actions/download-artifact@v4 - with: - pattern: c-release-* - path: artifacts - merge-multiple: true - - - name: Wait for GitHub Release to exist, then upload - env: - GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} - TAG: ${{ inputs.tag || github.ref_name }} - run: | - echo "Waiting for release $TAG to be created by cargo-dist..." - for i in $(seq 1 40); do - if gh release view "$TAG" --repo "$GITHUB_REPOSITORY" > /dev/null 2>&1; then - echo "Release found on attempt $i" - break - fi - echo "Attempt $i/40: release not yet available, waiting 15s..." - sleep 15 - done - if ! gh release view "$TAG" --repo "$GITHUB_REPOSITORY" > /dev/null 2>&1; then - echo "ERROR: Release $TAG not found after 40 attempts (10 minutes). Aborting." - exit 1 - fi - gh release upload "$TAG" artifacts/* \ - --repo "$GITHUB_REPOSITORY" \ - --clobber diff --git a/.github/workflows/java-ci.yml b/.github/workflows/java-ci.yml deleted file mode 100644 index 965dc68f0c..0000000000 --- a/.github/workflows/java-ci.yml +++ /dev/null @@ -1,40 +0,0 @@ -name: Java CI - -on: - push: - branches: [main] - pull_request: - branches: [main] - -jobs: - test: - name: Java tests (${{ matrix.os }}) - runs-on: ${{ matrix.os }} - strategy: - fail-fast: false - matrix: - os: [ubuntu-latest, ubuntu-24.04-arm, macos-14, windows-latest] - - steps: - - uses: actions/checkout@v4 - - - name: Install Rust toolchain - uses: dtolnay/rust-toolchain@stable - - - name: Set up JDK 17 - uses: actions/setup-java@v4 - with: - java-version: '17' - distribution: 'temurin' - - - name: Build Rust library (release) - run: cargo build --release -p minigraf-ffi - - - name: Generate Kotlin bindings + copy local native - working-directory: minigraf-ffi/java - run: | - ./gradlew generateKotlinBindings copyLocalNative - - - name: Run tests - working-directory: minigraf-ffi/java - run: ./gradlew test diff --git a/.github/workflows/java-release.yml b/.github/workflows/java-release.yml deleted file mode 100644 index 8bf089a1a7..0000000000 --- a/.github/workflows/java-release.yml +++ /dev/null @@ -1,120 +0,0 @@ -name: Java Release - -on: - push: - tags: - - 'v[0-9]*.[0-9]*.[0-9]*' - workflow_dispatch: - inputs: - tag: - description: 'Release tag to publish to Maven Central (e.g. "v0.23.0")' - required: false - type: string - -jobs: - build-natives: - name: Build native (${{ matrix.target }}) - runs-on: ${{ matrix.os }} - strategy: - fail-fast: false - matrix: - include: - - os: ubuntu-latest - target: x86_64-unknown-linux-gnu - native-dir: linux/x86_64 - lib-name: libminigraf_ffi.so - - os: ubuntu-24.04-arm - target: aarch64-unknown-linux-gnu - native-dir: linux/aarch64 - lib-name: libminigraf_ffi.so - - os: macos-14 - target: universal2 - native-dir: macos/universal - lib-name: libminigraf_ffi.dylib - - os: windows-latest - target: x86_64-pc-windows-msvc - native-dir: windows/x86_64 - lib-name: minigraf_ffi.dll - - steps: - - uses: actions/checkout@v4 - - - name: Install Rust toolchain - uses: dtolnay/rust-toolchain@stable - with: - targets: ${{ matrix.target == 'universal2' && 'aarch64-apple-darwin x86_64-apple-darwin' || matrix.target }} - - - name: Build native (universal2) - if: matrix.target == 'universal2' - run: | - cargo build --release -p minigraf-ffi --target aarch64-apple-darwin - cargo build --release -p minigraf-ffi --target x86_64-apple-darwin - lipo -create \ - target/aarch64-apple-darwin/release/libminigraf_ffi.dylib \ - target/x86_64-apple-darwin/release/libminigraf_ffi.dylib \ - -output libminigraf_ffi.dylib - - - name: Build native (other) - if: matrix.target != 'universal2' - run: cargo build --release -p minigraf-ffi --target ${{ matrix.target }} - - - name: Upload native - uses: actions/upload-artifact@v4 - with: - name: native-${{ matrix.native-dir == 'linux/x86_64' && 'linux-x64' || matrix.native-dir == 'linux/aarch64' && 'linux-arm64' || matrix.native-dir == 'macos/universal' && 'macos' || 'windows' }} - path: | - ${{ matrix.target == 'universal2' && 'libminigraf_ffi.dylib' || format('target/{0}/release/{1}', matrix.target, matrix.lib-name) }} - - assemble-and-publish: - name: Assemble fat JAR and publish to Maven Central - needs: build-natives - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v4 - - - name: Install Rust toolchain - uses: dtolnay/rust-toolchain@stable - - - name: Set up JDK 17 - uses: actions/setup-java@v4 - with: - java-version: '17' - distribution: 'temurin' - - - name: Download all natives - uses: actions/download-artifact@v4 - with: - pattern: native-* - path: natives-staging - merge-multiple: false - - - name: Copy natives into resources - run: | - RESOURCES=minigraf-ffi/java/src/main/resources/natives - mkdir -p "$RESOURCES/linux/x86_64" "$RESOURCES/linux/aarch64" \ - "$RESOURCES/macos/universal" "$RESOURCES/windows/x86_64" - cp natives-staging/native-linux-x64/libminigraf_ffi.so "$RESOURCES/linux/x86_64/" - cp natives-staging/native-linux-arm64/libminigraf_ffi.so "$RESOURCES/linux/aarch64/" - cp natives-staging/native-macos/libminigraf_ffi.dylib "$RESOURCES/macos/universal/" - cp natives-staging/native-windows/minigraf_ffi.dll "$RESOURCES/windows/x86_64/" - - - name: Build Rust library for bindgen (Linux x86_64) - run: cargo build --release -p minigraf-ffi - - - name: Generate Kotlin bindings - working-directory: minigraf-ffi/java - run: ./gradlew generateKotlinBindings - - - name: Publish to Maven Central - working-directory: minigraf-ffi/java - env: - CENTRAL_TOKEN_USERNAME: ${{ secrets.CENTRAL_TOKEN_USERNAME }} - CENTRAL_TOKEN_PASSWORD: ${{ secrets.CENTRAL_TOKEN_PASSWORD }} - GPG_SIGNING_KEY: ${{ secrets.GPG_SIGNING_KEY }} - GPG_SIGNING_PASSWORD: ${{ secrets.GPG_SIGNING_PASSWORD }} - RELEASE_VERSION: ${{ inputs.tag && (startsWith(inputs.tag, 'v') && inputs.tag || format('v{0}', inputs.tag)) || github.ref_name }} - run: | - # Strip leading 'v' so Gradle gets plain semver (e.g. "0.23.0") - export RELEASE_VERSION="${RELEASE_VERSION#v}" - ./gradlew publishAllPublicationsToCentralPortal diff --git a/.github/workflows/mobile.yml b/.github/workflows/mobile.yml deleted file mode 100644 index 769e1a7133..0000000000 --- a/.github/workflows/mobile.yml +++ /dev/null @@ -1,265 +0,0 @@ -name: Mobile Release Artifacts - -on: - push: - tags: - - 'v[0-9]*.[0-9]*.[0-9]*' - workflow_dispatch: - inputs: - tag: - description: 'Release tag to upload artifacts to (e.g. v0.21.0)' - required: true - -permissions: - contents: write - packages: write - -jobs: - # ── Android ────────────────────────────────────────────────────────────────── - - mobile-android: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - - - uses: dtolnay/rust-toolchain@stable - with: - targets: aarch64-linux-android,armv7-linux-androideabi,x86_64-linux-android - - - name: Install cargo-ndk - run: cargo install cargo-ndk --locked - - - name: Set ANDROID_NDK_HOME - run: echo "ANDROID_NDK_HOME=$ANDROID_NDK_LATEST_HOME" >> $GITHUB_ENV - - - name: Set up JDK 17 - uses: actions/setup-java@v4 - with: - java-version: '17' - distribution: 'temurin' - - - name: Cross-compile Android targets - run: | - cargo ndk \ - -t arm64-v8a \ - -t armeabi-v7a \ - -t x86_64 \ - -o minigraf-ffi/android/jniLibs \ - build --release -p minigraf-ffi - - - name: Generate Kotlin bindings - run: | - cargo run -p minigraf-ffi --bin uniffi-bindgen -- generate \ - --library target/aarch64-linux-android/release/libminigraf_ffi.so \ - --language kotlin \ - --out-dir minigraf-ffi/android/src/main/java/ - - - name: Assemble AAR - run: | - cd minigraf-ffi/android - ./gradlew assembleRelease - - - name: Rename artifact - run: | - TAG="${{ inputs.tag || github.ref_name }}" - cp minigraf-ffi/android/build/outputs/aar/minigraf-android-release.aar \ - "minigraf-android-${TAG}.aar" - - - uses: actions/upload-artifact@v4 - with: - name: minigraf-android - path: "minigraf-android-*.aar" - - # ── iOS ────────────────────────────────────────────────────────────────────── - - mobile-ios: - runs-on: macos-latest - steps: - - uses: actions/checkout@v4 - - - uses: dtolnay/rust-toolchain@stable - with: - targets: aarch64-apple-ios,aarch64-apple-ios-sim - - - name: Build iOS device library - run: cargo build --target aarch64-apple-ios --release -p minigraf-ffi - - - name: Build iOS simulator library - run: cargo build --target aarch64-apple-ios-sim --release -p minigraf-ffi - - - name: Generate Swift bindings - run: | - mkdir -p minigraf-swift/Sources/MinigrafKit - cargo run -p minigraf-ffi --bin uniffi-bindgen -- generate \ - --library target/aarch64-apple-ios/release/libminigraf_ffi.a \ - --language swift \ - --out-dir minigraf-swift/Sources/MinigrafKit/ - - - name: Prepare headers for xcframework - run: | - mkdir -p minigraf-swift/includes - cp minigraf-swift/Sources/MinigrafKit/*.h minigraf-swift/includes/ 2>/dev/null || true - cp minigraf-swift/Sources/MinigrafKit/*.modulemap minigraf-swift/includes/ 2>/dev/null || true - - - name: Assemble xcframework - run: | - TAG="${{ inputs.tag || github.ref_name }}" - xcodebuild -create-xcframework \ - -library target/aarch64-apple-ios/release/libminigraf_ffi.a \ - -headers minigraf-swift/includes/ \ - -library target/aarch64-apple-ios-sim/release/libminigraf_ffi.a \ - -headers minigraf-swift/includes/ \ - -output "MinigrafKit.xcframework" - zip -r "MinigrafKit-${TAG}.xcframework.zip" MinigrafKit.xcframework - - - uses: actions/upload-artifact@v4 - with: - name: minigraf-ios - path: "MinigrafKit-*.xcframework.zip" - - - uses: actions/upload-artifact@v4 - with: - name: swift-sources - path: minigraf-swift/Sources/MinigrafKit/ - - # ── Upload to release + GitHub Packages ────────────────────────────────────── - - release-upload-mobile: - needs: [mobile-android, mobile-ios] - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - with: - token: ${{ secrets.GITHUB_TOKEN }} - fetch-depth: 0 - - - uses: actions/download-artifact@v4 - with: - name: minigraf-android - path: artifacts/ - - - uses: actions/download-artifact@v4 - with: - name: minigraf-ios - path: artifacts/ - - - uses: actions/download-artifact@v4 - with: - name: swift-sources - path: minigraf-swift/Sources/MinigrafKit/ - - - name: Set up JDK 17 - uses: actions/setup-java@v4 - with: - java-version: '17' - distribution: 'temurin' - - - name: Wait for GitHub Release to exist - env: - GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} - TAG: ${{ inputs.tag || github.ref_name }} - run: | - echo "Waiting for release $TAG..." - for i in $(seq 1 40); do - if gh release view "$TAG" --repo "$GITHUB_REPOSITORY" > /dev/null 2>&1; then - echo "Release found on attempt $i" - break - fi - echo "Attempt $i/40: not yet, waiting 15s..." - sleep 15 - done - if ! gh release view "$TAG" --repo "$GITHUB_REPOSITORY" > /dev/null 2>&1; then - echo "ERROR: Release $TAG not found after 40 attempts (10 minutes). Aborting." - exit 1 - fi - - - name: Upload artifacts to GitHub Release - env: - GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} - TAG: ${{ inputs.tag || github.ref_name }} - run: | - gh release upload "$TAG" artifacts/* \ - --repo "$GITHUB_REPOSITORY" \ - --clobber - - - name: Compute xcframework checksum and update Package.swift - env: - TAG: ${{ inputs.tag || github.ref_name }} - run: | - XCFW_ZIP=$(ls artifacts/MinigrafKit-*.xcframework.zip) - CHECKSUM=$(shasum -a 256 "$XCFW_ZIP" | awk '{print $1}') - # The xcframework zip lives on the main release (TAG). - # Package.swift itself lives on the swift-releases branch tagged swift-TAG, - # so SPM consumers use the swift-TAG reference for the Swift package. - URL="https://github.com/${GITHUB_REPOSITORY}/releases/download/${TAG}/MinigrafKit-${TAG}.xcframework.zip" - sed -i \ - -e "s|url: \"https://github.com/.*/releases/download/.*/MinigrafKit-.*\\.xcframework\\.zip\"|url: \"${URL}\"|" \ - -e "s|checksum: \"[^\"]*\"|checksum: \"${CHECKSUM}\"|" \ - Package.swift - - - name: Publish AAR to GitHub Packages - env: - GITHUB_ACTOR: ${{ github.actor }} - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - run: | - TAG="${{ inputs.tag || github.ref_name }}" - export VERSION="${TAG#v}" - mkdir -p minigraf-ffi/android/build/outputs/aar/ - cp artifacts/minigraf-android-*.aar \ - minigraf-ffi/android/build/outputs/aar/minigraf-android-release.aar - cd minigraf-ffi/android - ./gradlew publishReleasePublicationToGitHubPackagesRepository - - - name: Commit Package.swift update and Swift sources, then create swift-TAG - env: - TAG: ${{ inputs.tag || github.ref_name }} - GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} - run: | - git config user.email "github-actions[bot]@users.noreply.github.com" - git config user.name "github-actions[bot]" - - # Save the files we intend to push (Package.swift already updated by sed, - # swift sources already downloaded by actions/download-artifact above). - TMPDIR_SWIFT=$(mktemp -d) - cp Package.swift "$TMPDIR_SWIFT/Package.swift" - cp -r minigraf-swift/Sources/MinigrafKit/ "$TMPDIR_SWIFT/MinigrafKit" - - # Switch to swift-releases branch so we only push Package.swift and Swift - # sources — not the full main HEAD (which includes workflow files, requiring - # `workflows` scope that GITHUB_TOKEN cannot be granted via permissions:). - if git fetch origin swift-releases 2>/dev/null; then - # -f: discard local changes (Package.swift modified by sed, swift sources - # untracked from artifact download) — we've already saved them to TMPDIR. - git checkout -fB swift-releases origin/swift-releases - else - # First-ever release: start a clean orphan branch with no history. - git checkout --orphan swift-releases - git rm -rf . --quiet 2>/dev/null || true - fi - - # Apply only the intended changes. - cp "$TMPDIR_SWIFT/Package.swift" Package.swift - mkdir -p minigraf-swift/Sources/MinigrafKit/ - cp -r "$TMPDIR_SWIFT/MinigrafKit/." minigraf-swift/Sources/MinigrafKit/ - rm -rf "$TMPDIR_SWIFT" - - git add Package.swift minigraf-swift/Sources/MinigrafKit/ - git commit -m "chore(release): update Package.swift and Swift bindings for ${TAG}" \ - || echo "Nothing to commit" - # Push to the unprotected swift-releases branch instead of main. - # SPM resolves packages by the swift-TAG (e.g. swift-v0.25.0) which points - # to this commit — the original TAG is left on the main branch so that all - # other language workflows (Python, Java, C, Node.js) can check out the - # full source tree. - git push origin swift-releases --force - NEW_SHA=$(git rev-parse HEAD) - # Create (or update) the swift-TAG reference on the swift-releases commit. - SWIFT_TAG="swift-${TAG}" - gh api "repos/${GITHUB_REPOSITORY}/git/refs" \ - -X POST \ - -f ref="refs/tags/${SWIFT_TAG}" \ - -f sha="$NEW_SHA" 2>/dev/null \ - || gh api "repos/${GITHUB_REPOSITORY}/git/refs/tags/${SWIFT_TAG}" \ - -X PATCH \ - -f sha="$NEW_SHA" \ - -F force=true diff --git a/.github/workflows/publish-ffi.yml b/.github/workflows/publish-ffi.yml deleted file mode 100644 index 39a8fd72b1..0000000000 --- a/.github/workflows/publish-ffi.yml +++ /dev/null @@ -1,23 +0,0 @@ -name: Publish minigraf-ffi - -# Triggered by a tag like ffi-v1.1.2 to publish only minigraf-ffi to crates.io. -# Used for patch releases that fix the FFI crate independently of the core. -on: - push: - tags: - - "ffi-v*" - -jobs: - publish: - name: cargo publish minigraf-ffi - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v4 - - - uses: dtolnay/rust-toolchain@stable - - - name: Publish minigraf-ffi - env: - CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }} - run: cargo publish -p minigraf-ffi diff --git a/Cargo.toml b/Cargo.toml index 8cc60a8de8..e1450792c1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,5 @@ [workspace] -members = [".", "minigraf-ffi", "minigraf-c"] +members = ["."] exclude = ["fuzz"] resolver = "2" diff --git a/Package.swift b/Package.swift deleted file mode 100644 index b7e3a570b3..0000000000 --- a/Package.swift +++ /dev/null @@ -1,30 +0,0 @@ -// swift-tools-version: 5.9 -import PackageDescription - -// This file is automatically updated by CI after each release. -// The URL and checksum below are updated to point to the latest .xcframework.zip. -let package = Package( - name: "MinigrafKit", - platforms: [ - .iOS(.v16), - ], - products: [ - .library( - name: "MinigrafKit", - targets: ["minigrafFFI", "MinigrafKit"] - ), - ], - targets: [ - .binaryTarget( - name: "minigrafFFI", - // Updated by CI: release-upload-mobile job - url: "https://github.com/project-minigraf/minigraf/releases/download/v1.0.0/MinigrafKit-v1.0.0.xcframework.zip", - checksum: "fe68cd03d7bd1c17d259d67dd8d951c823c96c593f1474f3a55ebc8c40ceb9da" - ), - .target( - name: "MinigrafKit", - dependencies: [.target(name: "minigrafFFI")], - path: "minigraf-swift/Sources/MinigrafKit" - ), - ] -) diff --git a/minigraf-c/Cargo.toml b/minigraf-c/Cargo.toml deleted file mode 100644 index 7f19ae4459..0000000000 --- a/minigraf-c/Cargo.toml +++ /dev/null @@ -1,16 +0,0 @@ -[package] -name = "minigraf-c" -version = "1.1.1" -edition = "2024" -description = "C bindings for Minigraf — stable C API with cbindgen-generated header" -publish = false - -[lib] -crate-type = ["cdylib", "staticlib"] - -[dependencies] -minigraf = { path = ".." } -serde_json = "1.0" - -[lints] -workspace = true diff --git a/minigraf-c/README.md b/minigraf-c/README.md deleted file mode 100644 index 59ce3d1427..0000000000 --- a/minigraf-c/README.md +++ /dev/null @@ -1,86 +0,0 @@ -# minigraf C bindings - -[![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue.svg)](https://github.com/project-minigraf/minigraf#license) - -> Embedded bi-temporal graph database — C header + prebuilt shared library - -Minigraf for C and any language with a C FFI. Distributed as platform tarballs containing `minigraf.h` and prebuilt shared and static libraries. - -## Install - -Download the platform tarball from [GitHub Releases](https://github.com/project-minigraf/minigraf/releases): - -```sh -# Linux x86_64 example -curl -L https://github.com/project-minigraf/minigraf/releases/download/v1.0.0/minigraf-c-v1.0.0-x86_64-unknown-linux-gnu.tar.gz | tar xz -``` - -Each archive contains: -- `include/minigraf.h` — stable C header (cbindgen-generated) -- `lib/libminigraf_c.so` (Linux) / `libminigraf_c.dylib` (macOS) / `minigraf_c.dll` (Windows) -- `lib/libminigraf_c.a` (Linux/macOS) / `minigraf_c.lib` (Windows) - -## Quick start - -```c -#include "minigraf.h" -#include -#include - -int main(void) { - char *err = NULL; - MiniGrafDb *db = minigraf_open("myapp.graph", &err); - if (!db) { fprintf(stderr, "open: %s\n", err); free(err); return 1; } - - char *result = minigraf_execute( - db, - "(transact [[:alice :person/name \"Alice\"] [:alice :person/age 30]])", - &err - ); - if (!result) { fprintf(stderr, "execute: %s\n", err); free(err); } - else { printf("%s\n", result); minigraf_string_free(result); } - - result = minigraf_execute( - db, - "(query [:find ?name :where [?e :person/name ?name]])", - &err - ); - if (!result) { fprintf(stderr, "execute: %s\n", err); free(err); } - else { printf("%s\n", result); minigraf_string_free(result); } - - minigraf_checkpoint(db, NULL); - minigraf_close(db); - return 0; -} -``` - -## Memory contract - -Mirrors SQLite: -- `minigraf_open` — caller owns the `MiniGrafDb*`; free with `minigraf_close` -- `minigraf_execute` — returns a heap-allocated JSON string; caller must free with `minigraf_string_free` -- Error strings (`char **err` out-param) are heap-allocated; caller frees with `free()` - -## API summary - -| Function | Description | -|---|---| -| `minigraf_open(path, err)` | Open or create a file-backed database | -| `minigraf_open_in_memory(err)` | Open an in-memory database | -| `minigraf_execute(db, datalog, err)` | Execute a Datalog command; returns JSON string | -| `minigraf_string_free(s)` | Free a string returned by `minigraf_execute` | -| `minigraf_checkpoint(db, err)` | Flush dirty pages to disk | -| `minigraf_close(db)` | Close the database | -| `minigraf_last_error()` | Get the last error message (thread-local) | - -See `include/minigraf.h` for the complete API. - -## Links - -- [Full C FFI integration guide](https://github.com/project-minigraf/minigraf/wiki/Use-Cases#c-ffi) -- [Repository](https://github.com/project-minigraf/minigraf) -- [Datalog Reference](https://github.com/project-minigraf/minigraf/wiki/Datalog-Reference) - -## License - -MIT OR Apache-2.0 diff --git a/minigraf-c/cbindgen.toml b/minigraf-c/cbindgen.toml deleted file mode 100644 index 50aec25dd4..0000000000 --- a/minigraf-c/cbindgen.toml +++ /dev/null @@ -1,17 +0,0 @@ -language = "C" -include_guard = "MINIGRAF_H" -autogen_warning = "/* DO NOT EDIT — generated by cbindgen. Run `cbindgen --config minigraf-c/cbindgen.toml --crate minigraf-c --output minigraf-c/include/minigraf.h` to regenerate. */" -documentation = true -documentation_style = "c99" - -[export] -include = [ - "minigraf_open", - "minigraf_open_in_memory", - "minigraf_close", - "minigraf_execute", - "minigraf_string_free", - "minigraf_checkpoint", - "minigraf_last_error", - "MiniGrafDb", -] diff --git a/minigraf-c/include/minigraf.h b/minigraf-c/include/minigraf.h deleted file mode 100644 index c87a3905d1..0000000000 --- a/minigraf-c/include/minigraf.h +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef MINIGRAF_H -#define MINIGRAF_H - -/* DO NOT EDIT — generated by cbindgen. Run `cbindgen --config minigraf-c/cbindgen.toml --crate minigraf-c --output minigraf-c/include/minigraf.h` to regenerate. */ - -#include -#include -#include -#include - -typedef struct MiniGrafDb MiniGrafDb; - -// Open a file-backed Minigraf database. Returns NULL on error. -struct MiniGrafDb *minigraf_open(const char *path); - -// Open an in-memory Minigraf database. Returns NULL on error. -struct MiniGrafDb *minigraf_open_in_memory(void); - -// Close a database and free all associated memory. -void minigraf_close(struct MiniGrafDb *handle); - -// Execute a Datalog string. Returns a JSON string on success (caller must free -// with `minigraf_string_free`), or NULL on error (call `minigraf_last_error`). -char *minigraf_execute(struct MiniGrafDb *handle, const char *datalog); - -// Free a string returned by `minigraf_execute`. -void minigraf_string_free(char *s); - -// Flush the WAL to the database file. Returns 0 on success, -1 on error. -int minigraf_checkpoint(struct MiniGrafDb *handle); - -// Return the last error message. Valid until the next call on the same handle. -// Returns NULL if no error has occurred. -const char *minigraf_last_error(struct MiniGrafDb *handle); - -#endif /* MINIGRAF_H */ diff --git a/minigraf-c/src/lib.rs b/minigraf-c/src/lib.rs deleted file mode 100644 index 56ac992d51..0000000000 --- a/minigraf-c/src/lib.rs +++ /dev/null @@ -1,298 +0,0 @@ -#![deny(unsafe_op_in_unsafe_fn)] -#![allow(clippy::not_unsafe_ptr_arg_deref)] -#![cfg_attr( - test, - allow( - clippy::unwrap_used, - clippy::expect_used, - clippy::panic, - clippy::indexing_slicing, - clippy::cast_possible_truncation, - clippy::cast_possible_wrap, - clippy::cast_sign_loss, - ) -)] - -use minigraf::{QueryResult, Value}; -use std::ffi::{CStr, CString}; -use std::os::raw::{c_char, c_int}; -use std::sync::Mutex; - -// ─── Handle ────────────────────────────────────────────────────────────────── - -pub struct MiniGrafDb { - db: Mutex, - last_error: Mutex>, -} - -impl MiniGrafDb { - fn set_error(&self, msg: String) { - if let Ok(mut guard) = self.last_error.lock() { - *guard = Some( - CString::new(msg).unwrap_or_else(|_| CString::new("error").unwrap_or_default()), - ); - } - } - - fn clear_error(&self) { - if let Ok(mut guard) = self.last_error.lock() { - *guard = None; - } - } -} - -// ─── Lifecycle ──────────────────────────────────────────────────────────────── - -/// Open a file-backed Minigraf database. Returns NULL on error. -#[unsafe(no_mangle)] -pub extern "C" fn minigraf_open(path: *const c_char) -> *mut MiniGrafDb { - if path.is_null() { - return std::ptr::null_mut(); - } - let path = match unsafe { CStr::from_ptr(path) }.to_str() { - Ok(s) => s, - Err(_) => return std::ptr::null_mut(), - }; - match minigraf::Minigraf::open(path) { - Ok(db) => Box::into_raw(Box::new(MiniGrafDb { - db: Mutex::new(db), - last_error: Mutex::new(None), - })), - Err(_) => std::ptr::null_mut(), - } -} - -/// Open an in-memory Minigraf database. Returns NULL on error. -#[unsafe(no_mangle)] -pub extern "C" fn minigraf_open_in_memory() -> *mut MiniGrafDb { - match minigraf::Minigraf::in_memory() { - Ok(db) => Box::into_raw(Box::new(MiniGrafDb { - db: Mutex::new(db), - last_error: Mutex::new(None), - })), - Err(_) => std::ptr::null_mut(), - } -} - -/// Close a database and free all associated memory. -#[unsafe(no_mangle)] -pub extern "C" fn minigraf_close(handle: *mut MiniGrafDb) { - if !handle.is_null() { - unsafe { drop(Box::from_raw(handle)) }; - } -} - -// ─── Execute ───────────────────────────────────────────────────────────────── - -/// Execute a Datalog string. Returns a JSON string on success (caller must free -/// with `minigraf_string_free`), or NULL on error (call `minigraf_last_error`). -#[unsafe(no_mangle)] -pub extern "C" fn minigraf_execute(handle: *mut MiniGrafDb, datalog: *const c_char) -> *mut c_char { - if handle.is_null() || datalog.is_null() { - return std::ptr::null_mut(); - } - let handle = unsafe { &*handle }; - let datalog = match unsafe { CStr::from_ptr(datalog) }.to_str() { - Ok(s) => s, - Err(_) => { - handle.set_error("invalid UTF-8 in datalog string".into()); - return std::ptr::null_mut(); - } - }; - - let db_guard = match handle.db.lock() { - Ok(g) => g, - Err(_) => { - handle.set_error("database lock poisoned".into()); - return std::ptr::null_mut(); - } - }; - let result = db_guard.execute(datalog); - drop(db_guard); - match result { - Ok(qr) => { - handle.clear_error(); - let json = query_result_to_json(qr); - match CString::new(json) { - Ok(s) => s.into_raw(), - Err(_) => { - handle.set_error("result JSON contained a null byte".into()); - std::ptr::null_mut() - } - } - } - Err(e) => { - handle.set_error(format!("{e:#}")); - std::ptr::null_mut() - } - } -} - -/// Free a string returned by `minigraf_execute`. -#[unsafe(no_mangle)] -pub extern "C" fn minigraf_string_free(s: *mut c_char) { - if !s.is_null() { - unsafe { drop(CString::from_raw(s)) }; - } -} - -// ─── Checkpoint ─────────────────────────────────────────────────────────────── - -/// Flush the WAL to the database file. Returns 0 on success, -1 on error. -#[unsafe(no_mangle)] -pub extern "C" fn minigraf_checkpoint(handle: *mut MiniGrafDb) -> c_int { - if handle.is_null() { - return -1; - } - let handle = unsafe { &*handle }; - let db_guard = match handle.db.lock() { - Ok(g) => g, - Err(_) => { - handle.set_error("database lock poisoned".into()); - return -1; - } - }; - match db_guard.checkpoint() { - Ok(_) => { - handle.clear_error(); - 0 - } - Err(e) => { - handle.set_error(format!("{e:#}")); - -1 - } - } -} - -// ─── Error ──────────────────────────────────────────────────────────────────── - -/// Return the last error message. Valid until the next call on the same handle. -/// Returns NULL if no error has occurred. -#[unsafe(no_mangle)] -pub extern "C" fn minigraf_last_error(handle: *mut MiniGrafDb) -> *const c_char { - if handle.is_null() { - return std::ptr::null(); - } - let handle = unsafe { &*handle }; - let guard = match handle.last_error.lock() { - Ok(g) => g, - Err(_) => return std::ptr::null(), - }; - match guard.as_ref() { - Some(s) => s.as_ptr(), - None => std::ptr::null(), - } -} - -// ─── JSON helpers ───────────────────────────────────────────────────────────── - -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_id) => { - serde_json::json!({"transacted": tx_id}) - } - QueryResult::Retracted(tx_id) => { - serde_json::json!({"retracted": tx_id}) - } - QueryResult::Ok => serde_json::json!({"ok": true}), - QueryResult::QueryResults { vars, results } => { - let rows: Vec> = results - .iter() - .map(|r| r.iter().map(value_to_json).collect()) - .collect(); - serde_json::json!({"variables": vars, "results": rows}) - } - }; - val.to_string() -} - -// ─── Tests ──────────────────────────────────────────────────────────────────── - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn open_in_memory_returns_non_null() { - let db = minigraf_open_in_memory(); - assert!(!db.is_null()); - minigraf_close(db); - } - - #[test] - fn execute_transact_returns_json() { - let db = minigraf_open_in_memory(); - let datalog = CString::new(r#"(transact [[:alice :name "Alice"]])"#).unwrap(); - let result = minigraf_execute(db, datalog.as_ptr()); - assert!(!result.is_null()); - let s = unsafe { CStr::from_ptr(result) }.to_str().unwrap(); - assert!(s.contains("transacted"), "expected transacted in: {s}"); - minigraf_string_free(result); - minigraf_close(db); - } - - #[test] - fn execute_query_returns_results() { - let db = minigraf_open_in_memory(); - let tx = CString::new(r#"(transact [[:alice :name "Alice"]])"#).unwrap(); - let r = minigraf_execute(db, tx.as_ptr()); - assert!(!r.is_null()); - minigraf_string_free(r); - - let q = CString::new("(query [:find ?n :where [?e :name ?n]])").unwrap(); - let result = minigraf_execute(db, q.as_ptr()); - assert!(!result.is_null()); - let s = unsafe { CStr::from_ptr(result) }.to_str().unwrap(); - assert!(s.contains("Alice"), "expected Alice in: {s}"); - minigraf_string_free(result); - minigraf_close(db); - } - - #[test] - fn execute_invalid_datalog_returns_null_and_sets_error() { - let db = minigraf_open_in_memory(); - let bad = CString::new("not valid datalog !!!").unwrap(); - let result = minigraf_execute(db, bad.as_ptr()); - assert!(result.is_null(), "expected NULL for invalid datalog"); - - let err = minigraf_last_error(db); - assert!(!err.is_null(), "expected non-NULL error"); - let msg = unsafe { CStr::from_ptr(err) }.to_str().unwrap(); - assert!(!msg.is_empty(), "expected non-empty error message"); - minigraf_close(db); - } - - #[test] - fn checkpoint_returns_zero_on_success() { - let db = minigraf_open_in_memory(); - let rc = minigraf_checkpoint(db); - assert_eq!(rc, 0); - minigraf_close(db); - } - - #[test] - fn string_free_null_is_safe() { - // Should not panic or crash - minigraf_string_free(std::ptr::null_mut()); - } - - #[test] - fn close_null_is_safe() { - minigraf_close(std::ptr::null_mut()); - } -} diff --git a/minigraf-ffi/Cargo.toml b/minigraf-ffi/Cargo.toml deleted file mode 100644 index f0cad516b8..0000000000 --- a/minigraf-ffi/Cargo.toml +++ /dev/null @@ -1,29 +0,0 @@ -[package] -name = "minigraf-ffi" -version = "1.1.2" -edition = "2024" -description = "UniFFI bridge for Minigraf — bi-temporal graph database" -license = "MIT OR Apache-2.0" -authors = ["Aditya Mukhopadhyay"] -repository = "https://github.com/project-minigraf/minigraf" -documentation = "https://docs.rs/minigraf-ffi" -readme = "README.md" -keywords = ["graph", "datalog", "bitemporal", "embedded", "database"] -categories = ["database-implementations", "embedded"] - -[lib] -crate-type = ["cdylib", "staticlib", "lib"] - -[[bin]] -name = "uniffi-bindgen" -path = "src/uniffi_bindgen.rs" - -[dependencies] -minigraf = { path = "..", version = "1.1.1" } -uniffi = { version = "0.31.1", features = ["cli"] } -thiserror = "2.0.18" -serde_json = "1.0.149" -anyhow = "1" - -[lints] -workspace = true diff --git a/minigraf-ffi/README.md b/minigraf-ffi/README.md deleted file mode 100644 index 9ed7aa8ebf..0000000000 --- a/minigraf-ffi/README.md +++ /dev/null @@ -1,22 +0,0 @@ -# minigraf-ffi - -UniFFI bridge crate for [Minigraf](https://github.com/project-minigraf/minigraf) — a zero-config, single-file, embedded graph database with bi-temporal Datalog queries. - -## Purpose - -This crate is the UniFFI bridge that language binding repos use to generate their native bindings. It is not intended to be used directly. - -## Language bindings - -Use the language-specific repo for your platform: - -| Language | Package | Repo | -|---|---|---| -| Python | [`minigraf` on PyPI](https://pypi.org/p/minigraf) | [minigraf-python](https://github.com/project-minigraf/minigraf-python) | -| Node.js | [`minigraf` on npm](https://www.npmjs.com/package/minigraf) | [minigraf-node](https://github.com/project-minigraf/minigraf-node) | -| Browser WASM | [`@minigraf/browser` on npm](https://www.npmjs.com/package/@minigraf/browser) | [minigraf-wasm](https://github.com/project-minigraf/minigraf-wasm) | -| WASI | [`@minigraf/wasi` on npm](https://www.npmjs.com/package/@minigraf/wasi) | [minigraf-wasm](https://github.com/project-minigraf/minigraf-wasm) | - -## License - -MIT OR Apache-2.0 diff --git a/minigraf-ffi/android/build.gradle.kts b/minigraf-ffi/android/build.gradle.kts deleted file mode 100644 index 3f03a00c17..0000000000 --- a/minigraf-ffi/android/build.gradle.kts +++ /dev/null @@ -1,45 +0,0 @@ -plugins { - id("com.android.library") version "8.2.2" - id("maven-publish") -} - -android { - namespace = "io.github.adityamukho.minigraf" - compileSdk = 34 - defaultConfig { - minSdk = 24 - targetSdk = 34 - } - sourceSets { - getByName("main") { - jniLibs.srcDirs("jniLibs") - java.srcDirs("src/main/java") - } - } - publishing { - singleVariant("release") - } -} - -afterEvaluate { - publishing { - publications { - create("release") { - from(components["release"]) - groupId = "io.github.adityamukho" - artifactId = "minigraf-android" - version = System.getenv("VERSION") ?: "0.0.0-local" - } - } - repositories { - maven { - name = "GitHubPackages" - url = uri("https://maven.pkg.github.com/project-minigraf/minigraf") - credentials { - username = System.getenv("GITHUB_ACTOR") ?: "" - password = System.getenv("GITHUB_TOKEN") ?: "" - } - } - } - } -} diff --git a/minigraf-ffi/android/gradle/wrapper/gradle-wrapper.jar b/minigraf-ffi/android/gradle/wrapper/gradle-wrapper.jar deleted file mode 100755 index 5ccda13e9cb94678ba179b32452cf3d60dc36353..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 53638 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

i1O>I_eGKr^&y;^hm-V94&lC5U~@}s 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 GfBiq '} - case $link in #( - /*) app_path=$link ;; #( absolute - *) app_path=$APP_HOME$link ;; #( relative - esac -done - -# This is reliable if the script is in the same directory as gradlew. -APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit - -APP_NAME="Gradle" -APP_BASE_NAME=${0##*/} - -# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. -DEFAULT_JVM_OPTS='-Xmx64m -Xms64m' - -# Use the maximum available, or set MAX_FD != -1 to use that value. -MAX_FD=maximum - -warn () { - echo "$*" -} - -die () { - echo - echo "$*" - echo - exit 1 -} - -# OS specific support (must be 'true' or 'false'). -cygwin=false -msys=false -darwin=false -nonstop=false -case "$( uname )" in #( - CYGWIN* ) cygwin=true ;; #( - Darwin* ) darwin=true ;; #( - MSYS* | MINGW* ) msys=true ;; #( - NONSTOP* ) nonstop=true ;; -esac - -CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar - -# Determine the Java command to use to start the JVM. -if [ -n "$JAVA_HOME" ] ; then - if [ -x "$JAVA_HOME/jre/sh/java" ] ; then - # IBM's JDK on AIX uses strange locations for the executables - JAVA_EXE=$JAVA_HOME/jre/sh/java - else - JAVA_EXE=$JAVA_HOME/bin/java - fi - if [ ! -x "$JAVA_EXE" ] ; then - die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME - -Please set the JAVA_HOME variable in your environment to match the -location of your Java installation." - fi -else - JAVA_EXE=java - if ! command -v java >/dev/null 2>&1 - then - die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. - -Please set the JAVA_HOME variable in your environment or add the location of your java binary to your PATH." - fi -fi - -# Increase the maximum file descriptors if we can. -if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then - case $MAX_FD in #( - max*) - # In POSIX sh, ulimit -H is undefined. That's why the various target - # platforms to use `ulimit -H` instead of `ulimit -Sh`. - # shellcheck disable=SC2039,SC3045 - MAX_FD=$( ulimit -H -n ) || - warn "Could not query maximum file descriptor limit" - ;; - esac - case $MAX_FD in #( - '' | soft) :;; #( - *) - # In POSIX sh, ulimit -n is undefined. That's why the various target - # platforms to use `ulimit -n` instead of `ulimit -n`. - # shellcheck disable=SC2039,SC3045 - ulimit -n "$MAX_FD" || - warn "Could not set maximum file descriptor count: $MAX_FD" - ;; - esac -fi - -exec "$JAVA_EXE" \ - $DEFAULT_JVM_OPTS \ - $JAVA_OPTS \ - $GRADLE_OPTS \ - "-Dorg.gradle.appname=$APP_BASE_NAME" \ - -classpath "$CLASSPATH" \ - org.gradle.wrapper.GradleWrapperMain \ - "$@" diff --git a/minigraf-ffi/android/gradlew.bat b/minigraf-ffi/android/gradlew.bat deleted file mode 100644 index 25da30dbde..0000000000 --- a/minigraf-ffi/android/gradlew.bat +++ /dev/null @@ -1,92 +0,0 @@ -@rem -@rem Copyright 2015 the original author or authors. -@rem -@rem Licensed under the Apache License, Version 2.0 (the "License"); -@rem you may not use this file except in compliance with the License. -@rem You may obtain a copy of the License at -@rem -@rem https://www.apache.org/licenses/LICENSE-2.0 -@rem -@rem Unless required by applicable law or agreed to in writing, software -@rem distributed under the License is distributed on an "AS IS" BASIS, -@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -@rem See the License for the specific language governing permissions and -@rem limitations under the License. -@rem - -@if "%DEBUG%"=="" @echo off -@rem ########################################################################## -@rem -@rem Gradle startup script for Windows -@rem -@rem ########################################################################## - -@rem Set local scope for the variables with windows NT shell -if "%OS%"=="Windows_NT" setlocal - -set DIRNAME=%~dp0 -if "%DIRNAME%"=="" set DIRNAME=. -@rem This is normally unused -set APP_BASE_NAME=%~n0 -set APP_HOME=%DIRNAME% - -@rem Resolve any "." and ".." in APP_HOME to make it shorter. -for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi - -@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. -set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" - -@rem Find java.exe -if defined JAVA_HOME goto findJavaFromJavaHome - -set JAVA_EXE=java.exe -%JAVA_EXE% -version >NUL 2>&1 -if %ERRORLEVEL% equ 0 goto execute - -echo. 1>&2 -echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 -echo. 1>&2 -echo Please set the JAVA_HOME variable in your environment to match the 1>&2 -echo location of your Java installation. 1>&2 - -goto fail - -:findJavaFromJavaHome -set JAVA_HOME=%JAVA_HOME:"=% -set JAVA_EXE=%JAVA_HOME%/bin/java.exe - -if exist "%JAVA_EXE%" goto execute - -echo. 1>&2 -echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 -echo. 1>&2 -echo Please set the JAVA_HOME variable in your environment to match the 1>&2 -echo location of your Java installation. 1>&2 - -goto fail - -:execute -@rem Setup the command line - -set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar - - -@rem Execute Gradle -"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* - -:end -@rem End local scope for the variables with windows NT shell -if %ERRORLEVEL% equ 0 goto mainEnd - -:fail -rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of -rem the _cmd.exe /c_ return code! -set EXIT_CODE=%ERRORLEVEL% -if %EXIT_CODE% equ 0 set EXIT_CODE=1 -if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% -exit /b %EXIT_CODE% - -:mainEnd -if "%OS%"=="Windows_NT" endlocal - -:omega diff --git a/minigraf-ffi/android/jniLibs/.gitkeep b/minigraf-ffi/android/jniLibs/.gitkeep deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/minigraf-ffi/android/settings.gradle.kts b/minigraf-ffi/android/settings.gradle.kts deleted file mode 100644 index e975534d83..0000000000 --- a/minigraf-ffi/android/settings.gradle.kts +++ /dev/null @@ -1,16 +0,0 @@ -pluginManagement { - repositories { - google() - mavenCentral() - gradlePluginPortal() - } -} -dependencyResolutionManagement { - repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS) - repositories { - google() - mavenCentral() - } -} - -rootProject.name = "minigraf-android" diff --git a/minigraf-ffi/android/src/main/AndroidManifest.xml b/minigraf-ffi/android/src/main/AndroidManifest.xml deleted file mode 100644 index b2d3ea1235..0000000000 --- a/minigraf-ffi/android/src/main/AndroidManifest.xml +++ /dev/null @@ -1,2 +0,0 @@ - - diff --git a/minigraf-ffi/android/src/main/java/.gitkeep b/minigraf-ffi/android/src/main/java/.gitkeep deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/minigraf-ffi/java/.gitignore b/minigraf-ffi/java/.gitignore deleted file mode 100644 index f4f4fbce0f..0000000000 --- a/minigraf-ffi/java/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -.gradle/ -build/ -src/main/resources/natives/ diff --git a/minigraf-ffi/java/README.md b/minigraf-ffi/java/README.md deleted file mode 100644 index a9247568f4..0000000000 --- a/minigraf-ffi/java/README.md +++ /dev/null @@ -1,66 +0,0 @@ -# minigraf-jvm - -[![Maven Central](https://img.shields.io/maven-central/v/io.github.adityamukho/minigraf-jvm.svg)](https://central.sonatype.com/artifact/io.github.adityamukho/minigraf-jvm) -[![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue.svg)](https://github.com/project-minigraf/minigraf#license) - -> Embedded bi-temporal graph database for Java/Kotlin — Datalog queries, time travel, fat JAR with embedded natives - -Minigraf for Java and Kotlin on the desktop JVM. Fat JAR with embedded native libraries for Linux x86_64/aarch64, macOS universal2, and Windows x86_64. No Rust toolchain required. - -## Install - -### Gradle (Kotlin DSL) - -```kotlin -dependencies { - implementation("io.github.adityamukho:minigraf-jvm:1.0.0") -} -``` - -### Maven - -```xml - - io.github.adityamukho - minigraf-jvm - 1.0.0 - -``` - -## Quick start - -```kotlin -import io.github.adityamukho.minigraf.MiniGrafDb -import org.json.JSONObject - -// File-backed database -val db = MiniGrafDb.open("/path/to/myapp.graph") - -// In-memory database (ephemeral / testing) -val mem = MiniGrafDb.openInMemory() - -// Transact facts -db.execute("""(transact [[:alice :person/name "Alice"] [:alice :person/age 30]])""") - -// Query with Datalog -val json = JSONObject(db.execute( - "(query [:find ?name ?age :where [?e :person/name ?name] [?e :person/age ?age]])" -)) -// json.getJSONArray("results").getJSONArray(0).getString(0) == "Alice" - -// Time travel — state as of transaction 1 -val snap = db.execute("(query [:find ?age :as-of 1 :where [:alice :person/age ?age]])") - -// Flush dirty pages to disk -db.checkpoint() -``` - -## Links - -- [Full Java/JVM integration guide](https://github.com/project-minigraf/minigraf/wiki/Use-Cases#java--jvm) -- [Repository](https://github.com/project-minigraf/minigraf) -- [Datalog Reference](https://github.com/project-minigraf/minigraf/wiki/Datalog-Reference) - -## License - -MIT OR Apache-2.0 diff --git a/minigraf-ffi/java/build.gradle.kts b/minigraf-ffi/java/build.gradle.kts deleted file mode 100644 index 0e7d216bcc..0000000000 --- a/minigraf-ffi/java/build.gradle.kts +++ /dev/null @@ -1,192 +0,0 @@ -import java.io.File - -plugins { - kotlin("jvm") version "2.0.21" - `maven-publish` - signing - `java-library` - // New Sonatype Central Portal publisher (replaces EOL OSSRH / s01.oss.sonatype.org) - id("com.gradleup.nmcp") version "0.0.8" -} - -group = "io.github.project-minigraf" -version = System.getenv("RELEASE_VERSION") ?: "1.0.0" - -repositories { - mavenCentral() -} - -dependencies { - // JNA is required at runtime by UniFFI-generated Kotlin bindings (com.sun.jna.*) - implementation("net.java.dev.jna:jna:5.14.0") - testImplementation(kotlin("test")) - testImplementation("org.junit.jupiter:junit-jupiter:5.11.0") - testRuntimeOnly("org.junit.platform:junit-platform-launcher") - testImplementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.17.0") -} - -tasks.test { - useJUnitPlatform() -} - -kotlin { - jvmToolchain(17) -} - -// ── uniffi-bindgen codegen ───────────────────────────────────────────────── - -val repoRoot = rootProject.projectDir.parentFile.parentFile.absolutePath - -val buildUniffiBindgen by tasks.registering(Exec::class) { - group = "codegen" - description = "Compile the uniffi-bindgen binary" - workingDir = File(repoRoot) - commandLine("cargo", "build", "--release", "--bin", "uniffi-bindgen", - "--manifest-path", "$repoRoot/minigraf-ffi/Cargo.toml") -} - -val libExt = when { - System.getProperty("os.name").lowercase().contains("windows") -> "dll" - System.getProperty("os.name").lowercase().contains("mac") -> "dylib" - else -> "so" -} -val libPrefix = if (System.getProperty("os.name").lowercase().contains("windows")) "" else "lib" -val libPath = "$repoRoot/target/release/${libPrefix}minigraf_ffi.$libExt" - -// Generated sources go to build/generated/uniffi so Gradle can track them -// as task outputs and wire them into the compile classpath automatically. -val generatedSourcesDir = layout.buildDirectory.dir("generated/uniffi") - -val generateKotlinBindings by tasks.registering(Exec::class) { - group = "codegen" - description = "Generate Kotlin bindings from UniFFI" - dependsOn(buildUniffiBindgen) - workingDir = File(repoRoot) - inputs.file(libPath) - outputs.dir(generatedSourcesDir) - commandLine( - "$repoRoot/target/release/uniffi-bindgen", - "generate", "--library", libPath, - "--language", "kotlin", - "--no-format", - "--out-dir", generatedSourcesDir.get().asFile.absolutePath - ) - // After generation, patch findLibraryName() to extract the native and set the - // libraryOverride property before JNA tries to resolve the library by name. - // findLibraryName() is called from every Native.register() invocation, so this - // fires regardless of which object (UniffiLib / IntegrityCheckingUniffiLib) is - // initialised first. NativeLoader.load() is idempotent. - doLast { - generatedSourcesDir.get().asFile - .walkTopDown().filter { it.extension == "kt" }.forEach { file -> - val patched = file.readText() - .replace( - "private fun findLibraryName(componentName: String): String {", - "private fun findLibraryName(componentName: String): String {\n io.github.project_minigraf.minigraf.NativeLoader.load()" - ) - file.writeText(patched) - } - } -} - -// Register the generated dir as a Kotlin source set and wire explicit task dependencies -// so Gradle knows compileKotlin must wait for codegen to finish. -sourceSets.main { - kotlin.srcDir(generatedSourcesDir) -} -tasks.named("compileKotlin") { dependsOn(generateKotlinBindings) } -tasks.named("compileTestKotlin") { dependsOn(generateKotlinBindings) } -// Wire all archive tasks (sourcesJar, kotlinSourcesJar, javadocJar, etc.) to codegen. -// Using withType avoids a hard-coded task name that may differ -// across Kotlin / java-library plugin versions. -tasks.withType().configureEach { - dependsOn(generateKotlinBindings) -} - -// ── native resources ─────────────────────────────────────────────────────── -// In CI the natives are copied in by the release workflow before Gradle runs. -// Locally, copy the current platform's native from target/release/. - -val copyLocalNative by tasks.registering(Copy::class) { - group = "codegen" - description = "Copy local platform native into resources (dev only)" - val os = System.getProperty("os.name").lowercase() - val arch = System.getProperty("os.arch").lowercase() - val (osKey, nativeName) = when { - "linux" in os && ("aarch64" in arch || "arm64" in arch) -> - "linux/aarch64" to "libminigraf_ffi.so" - "linux" in os -> "linux/x86_64" to "libminigraf_ffi.so" - "mac" in os -> "macos/universal" to "libminigraf_ffi.dylib" - "windows" in os -> "windows/x86_64" to "minigraf_ffi.dll" - else -> throw GradleException("Unsupported platform: $os $arch") - } - from(File("$repoRoot/target/release/$nativeName")) - into(File("$projectDir/src/main/resources/natives/$osKey")) -} - -// ── publishing ───────────────────────────────────────────────────────────── - -java { - withSourcesJar() - withJavadocJar() -} - -publishing { - publications { - create("release") { - from(components["java"]) - groupId = "io.github.project-minigraf" - artifactId = "minigraf-jvm" - version = project.version.toString() - - pom { - name.set("Minigraf JVM") - description.set("Zero-config, single-file, embedded graph database with bi-temporal Datalog queries — JVM bindings") - url.set("https://github.com/project-minigraf/minigraf") - licenses { - license { - name.set("MIT OR Apache-2.0") - url.set("https://github.com/project-minigraf/minigraf/blob/main/LICENSE-MIT") - } - } - developers { - developer { - id.set("adityamukho") - name.set("Aditya Mukhopadhyay") - } - } - scm { - connection.set("scm:git:git://github.com/project-minigraf/minigraf.git") - developerConnection.set("scm:git:ssh://github.com/project-minigraf/minigraf.git") - url.set("https://github.com/project-minigraf/minigraf") - } - } - } - } -} - -// ── Sonatype Central Portal publishing ──────────────────────────────────── -// Uses com.gradleup.nmcp which POSTs a bundle to central.sonatype.com/api/v1/publisher/upload. -// Credentials are a *token* pair generated at https://central.sonatype.com → Account → Generate User Token. -// Set CENTRAL_TOKEN_USERNAME and CENTRAL_TOKEN_PASSWORD as GitHub Actions secrets. -// publishingType = "USER_MANAGED" means you click "Publish" in the portal UI after validation. -// Change to "AUTOMATIC" to publish without that manual step. -nmcp { - // "release" must match the publication name in publishing { publications { create("release") { } } } - // publicationType = "USER_MANAGED" means you click Publish in the portal UI after validation; - // change to "AUTOMATIC" to release without that manual step. - publish("release") { - username = System.getenv("CENTRAL_TOKEN_USERNAME") ?: "" - password = System.getenv("CENTRAL_TOKEN_PASSWORD") ?: "" - publicationType = "AUTOMATIC" - } -} - -signing { - val signingKey = System.getenv("GPG_SIGNING_KEY") - val signingPassword = System.getenv("GPG_SIGNING_PASSWORD") - if (signingKey != null && signingPassword != null) { - useInMemoryPgpKeys(signingKey, signingPassword) - sign(publishing.publications["release"]) - } -} diff --git a/minigraf-ffi/java/gradle/wrapper/gradle-wrapper.jar b/minigraf-ffi/java/gradle/wrapper/gradle-wrapper.jar deleted file mode 100644 index a4b76b9530d66f5e68d973ea569d8e19de379189..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 43583 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 yu?e%!_ptzGB|8GrCfu%p?(_ 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 GZ~q4|mN%#X diff --git a/minigraf-ffi/java/gradle/wrapper/gradle-wrapper.properties b/minigraf-ffi/java/gradle/wrapper/gradle-wrapper.properties deleted file mode 100644 index 94113f200e..0000000000 --- a/minigraf-ffi/java/gradle/wrapper/gradle-wrapper.properties +++ /dev/null @@ -1,7 +0,0 @@ -distributionBase=GRADLE_USER_HOME -distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-8.11-bin.zip -networkTimeout=10000 -validateDistributionUrl=true -zipStoreBase=GRADLE_USER_HOME -zipStorePath=wrapper/dists diff --git a/minigraf-ffi/java/gradlew b/minigraf-ffi/java/gradlew deleted file mode 100755 index d95bf6131d..0000000000 --- a/minigraf-ffi/java/gradlew +++ /dev/null @@ -1,252 +0,0 @@ -#!/bin/sh - -# -# Copyright © 2015-2021 the original authors. -# -# 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 -# -# https://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. -# -# SPDX-License-Identifier: Apache-2.0 -# - -############################################################################## -# -# Gradle start up script for POSIX generated by Gradle. -# -# Important for running: -# -# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is -# noncompliant, but you have some other compliant shell such as ksh or -# bash, then to run this script, type that shell name before the whole -# command line, like: -# -# ksh Gradle -# -# Busybox and similar reduced shells will NOT work, because this script -# requires all of these POSIX shell features: -# * functions; -# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», -# «${var#prefix}», «${var%suffix}», and «$( cmd )»; -# * compound commands having a testable exit status, especially «case»; -# * various built-in commands including «command», «set», and «ulimit». -# -# Important for patching: -# -# (2) This script targets any POSIX shell, so it avoids extensions provided -# by Bash, Ksh, etc; in particular arrays are avoided. -# -# The "traditional" practice of packing multiple parameters into a -# space-separated string is a well documented source of bugs and security -# problems, so this is (mostly) avoided, by progressively accumulating -# options in "$@", and eventually passing that to Java. -# -# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, -# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; -# see the in-line comments for details. -# -# There are tweaks for specific operating systems such as AIX, CygWin, -# Darwin, MinGW, and NonStop. -# -# (3) This script is generated from the Groovy template -# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt -# within the Gradle project. -# -# You can find Gradle at https://github.com/gradle/gradle/. -# -############################################################################## - -# Attempt to set APP_HOME - -# Resolve links: $0 may be a link -app_path=$0 - -# Need this for daisy-chained symlinks. -while - APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path - [ -h "$app_path" ] -do - ls=$( ls -ld "$app_path" ) - link=${ls#*' -> '} - case $link in #( - /*) app_path=$link ;; #( - *) app_path=$APP_HOME$link ;; - esac -done - -# This is normally unused -# shellcheck disable=SC2034 -APP_BASE_NAME=${0##*/} -# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) -APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s -' "$PWD" ) || exit - -# Use the maximum available, or set MAX_FD != -1 to use that value. -MAX_FD=maximum - -warn () { - echo "$*" -} >&2 - -die () { - echo - echo "$*" - echo - exit 1 -} >&2 - -# OS specific support (must be 'true' or 'false'). -cygwin=false -msys=false -darwin=false -nonstop=false -case "$( uname )" in #( - CYGWIN* ) cygwin=true ;; #( - Darwin* ) darwin=true ;; #( - MSYS* | MINGW* ) msys=true ;; #( - NONSTOP* ) nonstop=true ;; -esac - -CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar - - -# Determine the Java command to use to start the JVM. -if [ -n "$JAVA_HOME" ] ; then - if [ -x "$JAVA_HOME/jre/sh/java" ] ; then - # IBM's JDK on AIX uses strange locations for the executables - JAVACMD=$JAVA_HOME/jre/sh/java - else - JAVACMD=$JAVA_HOME/bin/java - fi - if [ ! -x "$JAVACMD" ] ; then - die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME - -Please set the JAVA_HOME variable in your environment to match the -location of your Java installation." - fi -else - JAVACMD=java - if ! command -v java >/dev/null 2>&1 - then - die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. - -Please set the JAVA_HOME variable in your environment to match the -location of your Java installation." - fi -fi - -# Increase the maximum file descriptors if we can. -if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then - case $MAX_FD in #( - max*) - # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. - # shellcheck disable=SC2039,SC3045 - MAX_FD=$( ulimit -H -n ) || - warn "Could not query maximum file descriptor limit" - esac - case $MAX_FD in #( - '' | soft) :;; #( - *) - # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. - # shellcheck disable=SC2039,SC3045 - ulimit -n "$MAX_FD" || - warn "Could not set maximum file descriptor limit to $MAX_FD" - esac -fi - -# Collect all arguments for the java command, stacking in reverse order: -# * args from the command line -# * the main class name -# * -classpath -# * -D...appname settings -# * --module-path (only if needed) -# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. - -# For Cygwin or MSYS, switch paths to Windows format before running java -if "$cygwin" || "$msys" ; then - APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) - CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) - - JAVACMD=$( cygpath --unix "$JAVACMD" ) - - # Now convert the arguments - kludge to limit ourselves to /bin/sh - for arg do - if - case $arg in #( - -*) false ;; # don't mess with options #( - /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath - [ -e "$t" ] ;; #( - *) false ;; - esac - then - arg=$( cygpath --path --ignore --mixed "$arg" ) - fi - # Roll the args list around exactly as many times as the number of - # args, so each arg winds up back in the position where it started, but - # possibly modified. - # - # NB: a `for` loop captures its iteration list before it begins, so - # changing the positional parameters here affects neither the number of - # iterations, nor the values presented in `arg`. - shift # remove old arg - set -- "$@" "$arg" # push replacement arg - done -fi - - -# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. -DEFAULT_JVM_OPTS='-Dfile.encoding=UTF-8 "-Xmx64m" "-Xms64m"' - -# Collect all arguments for the java command: -# * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, -# and any embedded shellness will be escaped. -# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be -# treated as '${Hostname}' itself on the command line. - -set -- \ - "-Dorg.gradle.appname=$APP_BASE_NAME" \ - -classpath "$CLASSPATH" \ - org.gradle.wrapper.GradleWrapperMain \ - "$@" - -# Stop when "xargs" is not available. -if ! command -v xargs >/dev/null 2>&1 -then - die "xargs is not available" -fi - -# Use "xargs" to parse quoted args. -# -# With -n1 it outputs one arg per line, with the quotes and backslashes removed. -# -# In Bash we could simply go: -# -# readarray ARGS < <( xargs -n1 <<<"$var" ) && -# set -- "${ARGS[@]}" "$@" -# -# but POSIX shell has neither arrays nor command substitution, so instead we -# post-process each arg (as a line of input to sed) to backslash-escape any -# character that might be a shell metacharacter, then use eval to reverse -# that process (while maintaining the separation between arguments), and wrap -# the whole thing up as a single "set" statement. -# -# This will of course break if any of these variables contains a newline or -# an unmatched quote. -# - -eval "set -- $( - printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | - xargs -n1 | - sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | - tr '\n' ' ' - )" '"$@"' - -exec "$JAVACMD" "$@" diff --git a/minigraf-ffi/java/gradlew.bat b/minigraf-ffi/java/gradlew.bat deleted file mode 100644 index 640d68685c..0000000000 --- a/minigraf-ffi/java/gradlew.bat +++ /dev/null @@ -1,94 +0,0 @@ -@rem -@rem Copyright 2015 the original author or authors. -@rem -@rem Licensed under the Apache License, Version 2.0 (the "License"); -@rem you may not use this file except in compliance with the License. -@rem You may obtain a copy of the License at -@rem -@rem https://www.apache.org/licenses/LICENSE-2.0 -@rem -@rem Unless required by applicable law or agreed to in writing, software -@rem distributed under the License is distributed on an "AS IS" BASIS, -@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -@rem See the License for the specific language governing permissions and -@rem limitations under the License. -@rem -@rem SPDX-License-Identifier: Apache-2.0 -@rem - -@if "%DEBUG%"=="" @echo off -@rem ########################################################################## -@rem -@rem Gradle startup script for Windows -@rem -@rem ########################################################################## - -@rem Set local scope for the variables with windows NT shell -if "%OS%"=="Windows_NT" setlocal - -set DIRNAME=%~dp0 -if "%DIRNAME%"=="" set DIRNAME=. -@rem This is normally unused -set APP_BASE_NAME=%~n0 -set APP_HOME=%DIRNAME% - -@rem Resolve any "." and ".." in APP_HOME to make it shorter. -for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi - -@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. -set DEFAULT_JVM_OPTS=-Dfile.encoding=UTF-8 "-Xmx64m" "-Xms64m" - -@rem Find java.exe -if defined JAVA_HOME goto findJavaFromJavaHome - -set JAVA_EXE=java.exe -%JAVA_EXE% -version >NUL 2>&1 -if %ERRORLEVEL% equ 0 goto execute - -echo. 1>&2 -echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 -echo. 1>&2 -echo Please set the JAVA_HOME variable in your environment to match the 1>&2 -echo location of your Java installation. 1>&2 - -goto fail - -:findJavaFromJavaHome -set JAVA_HOME=%JAVA_HOME:"=% -set JAVA_EXE=%JAVA_HOME%/bin/java.exe - -if exist "%JAVA_EXE%" goto execute - -echo. 1>&2 -echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 -echo. 1>&2 -echo Please set the JAVA_HOME variable in your environment to match the 1>&2 -echo location of your Java installation. 1>&2 - -goto fail - -:execute -@rem Setup the command line - -set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar - - -@rem Execute Gradle -"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* - -:end -@rem End local scope for the variables with windows NT shell -if %ERRORLEVEL% equ 0 goto mainEnd - -:fail -rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of -rem the _cmd.exe /c_ return code! -set EXIT_CODE=%ERRORLEVEL% -if %EXIT_CODE% equ 0 set EXIT_CODE=1 -if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% -exit /b %EXIT_CODE% - -:mainEnd -if "%OS%"=="Windows_NT" endlocal - -:omega diff --git a/minigraf-ffi/java/settings.gradle.kts b/minigraf-ffi/java/settings.gradle.kts deleted file mode 100644 index 5b5f43bb56..0000000000 --- a/minigraf-ffi/java/settings.gradle.kts +++ /dev/null @@ -1 +0,0 @@ -rootProject.name = "minigraf-jvm" diff --git a/minigraf-ffi/java/src/main/kotlin/io/github/project_minigraf/minigraf/NativeLoader.kt b/minigraf-ffi/java/src/main/kotlin/io/github/project_minigraf/minigraf/NativeLoader.kt deleted file mode 100644 index 37ecd22358..0000000000 --- a/minigraf-ffi/java/src/main/kotlin/io/github/project_minigraf/minigraf/NativeLoader.kt +++ /dev/null @@ -1,57 +0,0 @@ -package io.github.project_minigraf.minigraf - -import java.io.File -import java.nio.file.Files - -/** - * Extracts the platform-appropriate native library from JAR resources and loads it. - * Call [load] before using any Minigraf class. It is idempotent. - */ -object NativeLoader { - @Volatile private var loaded = false - - @Synchronized - fun load() { - if (loaded) return - - val os = System.getProperty("os.name").lowercase() - val arch = System.getProperty("os.arch").lowercase() - - val (osKey, libName) = when { - "linux" in os && ("aarch64" in arch || "arm64" in arch) -> - "linux/aarch64" to "libminigraf_ffi.so" - "linux" in os -> - "linux/x86_64" to "libminigraf_ffi.so" - "mac" in os -> - "macos/universal" to "libminigraf_ffi.dylib" - "windows" in os -> - "windows/x86_64" to "minigraf_ffi.dll" - else -> throw UnsupportedOperationException( - "Unsupported platform: $os / $arch. " + - "Please file an issue at https://github.com/project-minigraf/minigraf" - ) - } - - val resourcePath = "/natives/$osKey/$libName" - val stream = NativeLoader::class.java.getResourceAsStream(resourcePath) - ?: throw UnsatisfiedLinkError( - "Native library not found in JAR: $resourcePath. " + - "Ensure you are using the correct platform JAR." - ) - - val tmpDir = Files.createTempDirectory("minigraf_native") - tmpDir.toFile().deleteOnExit() - val dest = tmpDir.resolve(libName).toFile() - dest.deleteOnExit() - - stream.use { src -> - dest.outputStream().use { dst -> src.copyTo(dst) } - } - - // JNA's Native.register() uses findLibraryName() which reads this property. - // Providing an absolute path causes JNA to dlopen/LoadLibrary directly from - // the temp file, bypassing the system library search path. - System.setProperty("uniffi.component.minigraf_ffi.libraryOverride", dest.absolutePath) - loaded = true - } -} diff --git a/minigraf-ffi/java/src/test/kotlin/io/github/project_minigraf/minigraf/BasicTest.kt b/minigraf-ffi/java/src/test/kotlin/io/github/project_minigraf/minigraf/BasicTest.kt deleted file mode 100644 index 01f0eae75c..0000000000 --- a/minigraf-ffi/java/src/test/kotlin/io/github/project_minigraf/minigraf/BasicTest.kt +++ /dev/null @@ -1,69 +0,0 @@ -package io.github.project_minigraf.minigraf - -import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper -import com.fasterxml.jackson.module.kotlin.readValue -import org.junit.jupiter.api.Test -import org.junit.jupiter.api.assertThrows -import java.io.File -import kotlin.test.assertEquals -import kotlin.test.assertNotNull -import kotlin.test.assertTrue - -// MiniGrafDb and MiniGrafException are generated by uniffi-bindgen into -// src/main/kotlin/uniffi/minigraf_ffi/. They are imported transitively. -// The exact generated package path is uniffi.minigraf_ffi — adjust if different. -import uniffi.minigraf_ffi.MiniGrafDb -import uniffi.minigraf_ffi.MiniGrafException - -private val mapper = jacksonObjectMapper() - -class BasicTest { - - @Test - fun testOpenInMemory() { - val db = MiniGrafDb.openInMemory() - assertNotNull(db) - } - - @Test - fun testTransactAndQuery() { - val db = MiniGrafDb.openInMemory() - val txJson = db.execute("""(transact [[:alice :name "Alice"]])""") - val tx: Map = mapper.readValue(txJson) - assertTrue(tx.containsKey("transacted"), "expected transacted key") - - val queryJson = db.execute("(query [:find ?n :where [?e :name ?n]])") - val qr: Map = mapper.readValue(queryJson) - @Suppress("UNCHECKED_CAST") - val results = qr["results"] as List> - assertEquals("Alice", results[0][0]) - } - - @Test - fun testInvalidDatalogThrows() { - val db = MiniGrafDb.openInMemory() - assertThrows { - db.execute("not valid datalog !!!") - } - } - - @Test - fun testFileBacked() { - val tmp = File.createTempFile("minigraf_jvm_test", ".graph") - tmp.deleteOnExit() - val walFile = File(tmp.absolutePath + ".wal") - walFile.deleteOnExit() - - val db = MiniGrafDb.open(tmp.absolutePath) - db.execute("""(transact [[:bob :name "Bob"]])""") - db.checkpoint() - db.destroy() // UniFFI frees the Arc reference - - val db2 = MiniGrafDb.open(tmp.absolutePath) - val queryJson = db2.execute("(query [:find ?n :where [?e :name ?n]])") - val qr: Map = mapper.readValue(queryJson) - @Suppress("UNCHECKED_CAST") - val results = qr["results"] as List> - assertEquals("Bob", results[0][0]) - } -} diff --git a/minigraf-ffi/src/lib.rs b/minigraf-ffi/src/lib.rs deleted file mode 100644 index 643810b3a7..0000000000 --- a/minigraf-ffi/src/lib.rs +++ /dev/null @@ -1,327 +0,0 @@ -#![cfg_attr( - test, - allow( - clippy::unwrap_used, - clippy::expect_used, - clippy::panic, - clippy::indexing_slicing, - clippy::cast_possible_truncation, - clippy::cast_possible_wrap, - clippy::cast_sign_loss, - ) -)] - -use minigraf::{QueryResult, Value}; -use std::sync::{Arc, Mutex}; - -uniffi::setup_scaffolding!(); - -// ─── Error type ────────────────────────────────────────────────────────────── - -#[derive(Debug, thiserror::Error, uniffi::Error)] -pub enum MiniGrafError { - #[error("storage error: {msg}")] - Storage { msg: String }, - #[error("query error: {msg}")] - Query { msg: String }, - #[error("parse error: {msg}")] - Parse { msg: String }, - #[error("unknown error: {msg}")] - Other { msg: String }, -} - -// ─── anyhow::Error → MiniGrafError conversion ──────────────────────────────── - -impl From for MiniGrafError { - fn from(e: anyhow::Error) -> Self { - let full = format!("{e:#}").to_lowercase(); - let msg = e.to_string(); - if full.contains("parse") - || full.contains("unexpected") - || full.contains("expected token") - || full.contains("unknown command") - { - MiniGrafError::Parse { msg } - } else if full.contains("storage") || full.contains(" page") || full.contains("wal ") { - MiniGrafError::Storage { msg } - } else if full.contains("query") || full.contains(":find") || full.contains(":where") { - MiniGrafError::Query { msg } - } else { - MiniGrafError::Other { msg } - } - } -} - -// ─── MiniGrafDb ────────────────────────────────────────────────────────────── - -#[derive(uniffi::Object)] -pub struct MiniGrafDb { - inner: Arc>, -} - -#[uniffi::export] -impl MiniGrafDb { - #[uniffi::constructor] - pub fn open(path: String) -> Result, MiniGrafError> { - let db = minigraf::Minigraf::open(&path).map_err(MiniGrafError::from)?; - Ok(Arc::new(Self { - inner: Arc::new(Mutex::new(db)), - })) - } - - #[uniffi::constructor] - pub fn open_in_memory() -> Result, MiniGrafError> { - let db = minigraf::Minigraf::in_memory().map_err(MiniGrafError::from)?; - Ok(Arc::new(Self { - inner: Arc::new(Mutex::new(db)), - })) - } - - pub fn execute(&self, datalog: String) -> Result { - let result = self - .inner - .lock() - .map_err(|_| MiniGrafError::Other { - msg: "mutex poisoned".into(), - })? - .execute(&datalog) - .map_err(MiniGrafError::from)?; - Ok(query_result_to_json(result)) - } - - pub fn checkpoint(&self) -> Result<(), MiniGrafError> { - self.inner - .lock() - .map_err(|_| MiniGrafError::Other { - msg: "mutex poisoned".into(), - })? - .checkpoint() - .map_err(MiniGrafError::from) - } -} - -// ─── JSON serialisation (internal helpers) ─────────────────────────────────── - -fn value_to_json(v: &Value) -> serde_json::Value { - use serde_json::Value as JVal; - match v { - Value::String(s) => JVal::String(s.clone()), - Value::Integer(i) => JVal::Number((*i).into()), - Value::Float(f) => serde_json::Number::from_f64(*f) - .map(JVal::Number) - .unwrap_or(JVal::Null), - Value::Boolean(b) => JVal::Bool(*b), - Value::Ref(uuid) => JVal::String(uuid.to_string()), - Value::Keyword(k) => JVal::String(k.clone()), - Value::Null => JVal::Null, - } -} - -fn query_result_to_json(result: QueryResult) -> String { - use serde_json::json; - let val = match result { - QueryResult::Transacted(tx_id) => { - json!({"transacted": tx_id}) - } - QueryResult::Retracted(tx_id) => { - json!({"retracted": tx_id}) - } - QueryResult::Ok => json!({"ok": true}), - QueryResult::QueryResults { vars, results } => { - let rows: Vec> = results - .iter() - .map(|row| row.iter().map(value_to_json).collect()) - .collect(); - json!({"variables": vars, "results": rows}) - } - }; - val.to_string() -} - -// ─── Tests ─────────────────────────────────────────────────────────────────── - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn value_to_json_string() { - let v = Value::String("hello".into()); - let j = value_to_json(&v); - assert_eq!(j, serde_json::Value::String("hello".into())); - } - - #[test] - fn value_to_json_integer() { - let v = Value::Integer(42); - let j = value_to_json(&v); - assert_eq!(j, serde_json::json!(42)); - } - - #[test] - fn value_to_json_null() { - let j = value_to_json(&Value::Null); - assert_eq!(j, serde_json::Value::Null); - } - - #[test] - fn query_result_to_json_transacted() { - let json = query_result_to_json(QueryResult::Transacted(12345)); - let v: serde_json::Value = serde_json::from_str(&json).expect("valid json"); - assert_eq!(v["transacted"], serde_json::json!(12345)); - } - - #[test] - fn query_result_to_json_query_results() { - let result = QueryResult::QueryResults { - vars: vec!["?name".into()], - results: vec![vec![Value::String("Alice".into())]], - }; - let json = query_result_to_json(result); - let v: serde_json::Value = serde_json::from_str(&json).expect("valid json"); - assert_eq!(v["variables"][0], "?name"); - assert_eq!(v["results"][0][0], "Alice"); - } - - #[test] - fn query_result_to_json_ok() { - let json = query_result_to_json(QueryResult::Ok); - let v: serde_json::Value = serde_json::from_str(&json).expect("valid json"); - assert_eq!(v["ok"], serde_json::json!(true)); - } - - #[test] - fn value_to_json_float_finite() { - let j = value_to_json(&Value::Float(3.14)); - assert_eq!(j, serde_json::json!(3.14)); - } - - #[test] - fn value_to_json_float_nan() { - let j = value_to_json(&Value::Float(f64::NAN)); - assert_eq!(j, serde_json::Value::Null); - } - - #[test] - fn value_to_json_float_infinity() { - let j = value_to_json(&Value::Float(f64::INFINITY)); - assert_eq!(j, serde_json::Value::Null); - } - - #[test] - fn value_to_json_boolean() { - assert_eq!( - value_to_json(&Value::Boolean(true)), - serde_json::json!(true) - ); - assert_eq!( - value_to_json(&Value::Boolean(false)), - serde_json::json!(false) - ); - } - - #[test] - fn value_to_json_ref() { - let id = minigraf::EntityId::new_v4(); - let j = value_to_json(&Value::Ref(id)); - assert_eq!(j, serde_json::Value::String(id.to_string())); - } - - #[test] - fn value_to_json_keyword() { - let j = value_to_json(&Value::Keyword(":status/active".into())); - assert_eq!(j, serde_json::Value::String(":status/active".into())); - } - - #[test] - fn query_result_to_json_retracted() { - let json = query_result_to_json(QueryResult::Retracted(99)); - let v: serde_json::Value = serde_json::from_str(&json).expect("valid json"); - assert_eq!(v["retracted"], serde_json::json!(99)); - } - - #[test] - fn open_in_memory_succeeds() { - MiniGrafDb::open_in_memory().expect("open_in_memory"); - } - - #[test] - fn execute_transact_returns_json() { - let db = MiniGrafDb::open_in_memory().expect("open"); - let json = db - .execute(r#"(transact [[:alice :name "Alice"]])"#.into()) - .expect("execute"); - let v: serde_json::Value = serde_json::from_str(&json).expect("valid json"); - assert!(v.get("transacted").is_some(), "expected transacted key"); - } - - #[test] - fn execute_query_returns_results() { - let db = MiniGrafDb::open_in_memory().expect("open"); - db.execute(r#"(transact [[:alice :name "Alice"]])"#.into()) - .expect("transact"); - let json = db - .execute(r#"(query [:find ?n :where [?e :name ?n]])"#.into()) - .expect("query"); - let v: serde_json::Value = serde_json::from_str(&json).expect("valid json"); - assert_eq!(v["variables"][0], "?n"); - assert_eq!(v["results"][0][0], "Alice"); - } - - #[test] - fn execute_invalid_datalog_returns_parse_error() { - let db = MiniGrafDb::open_in_memory().expect("open"); - // Illegal characters trigger tokenizer-level parse error - let result = db.execute("not valid datalog at all !!!".into()); - assert!( - matches!(result, Err(MiniGrafError::Parse { .. })), - "expected Parse error for illegal characters" - ); - } - - #[test] - fn execute_unknown_command_returns_parse_error() { - let db = MiniGrafDb::open_in_memory().expect("open"); - // Structurally valid tokens but unknown command — should also route to Parse - let result = db.execute("(unknown-command [])".into()); - assert!( - matches!(result, Err(MiniGrafError::Parse { .. })), - "expected Parse error for unknown command" - ); - } - - #[test] - fn open_file_backed_roundtrip() { - let dir = std::env::temp_dir(); - let path = dir.join("minigraf_ffi_test.graph"); - // Clean up any leftover file from a previous run - let _ = std::fs::remove_file(&path); - let path_str = path.to_str().expect("utf8 path").to_string(); - - { - let db = MiniGrafDb::open(path_str.clone()).expect("open"); - db.execute(r#"(transact [[:alice :name "Alice"]])"#.into()) - .expect("transact"); - db.checkpoint().expect("checkpoint"); - } - - // Re-open and verify fact persisted - let db2 = MiniGrafDb::open(path_str).expect("re-open"); - let json = db2 - .execute(r#"(query [:find ?n :where [?e :name ?n]])"#.into()) - .expect("query"); - let v: serde_json::Value = serde_json::from_str(&json).expect("valid json"); - assert_eq!(v["results"][0][0], "Alice"); - - // Clean up - let _ = std::fs::remove_file(path); - let wal = dir.join("minigraf_ffi_test.graph.wal"); - let _ = std::fs::remove_file(wal); - } - - #[test] - fn checkpoint_in_memory_succeeds() { - let db = MiniGrafDb::open_in_memory().expect("open"); - db.checkpoint().expect("checkpoint on in-memory db"); - } -} diff --git a/minigraf-ffi/src/uniffi_bindgen.rs b/minigraf-ffi/src/uniffi_bindgen.rs deleted file mode 100644 index f6cff6cf1d..0000000000 --- a/minigraf-ffi/src/uniffi_bindgen.rs +++ /dev/null @@ -1,3 +0,0 @@ -fn main() { - uniffi::uniffi_bindgen_main() -} diff --git a/minigraf-swift/Sources/MinigrafKit/.gitkeep b/minigraf-swift/Sources/MinigrafKit/.gitkeep deleted file mode 100644 index e69de29bb2..0000000000 From 89bc4b633ef541b459cc3f34b1a1bc0b2a46a502 Mon Sep 17 00:00:00 2001 From: Aditya Mukhopadhyay Date: Mon, 18 May 2026 14:37:43 +0530 Subject: [PATCH 5/6] chore: remove stale minigraf-ffi profile override from Cargo.toml --- Cargo.toml | 5 ----- 1 file changed, 5 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index e1450792c1..5d49321844 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -95,11 +95,6 @@ strip = "symbols" opt-level = "z" # uniffi-bindgen reads UNIFFI_META symbols from .symtab (not .dynsym). -# strip = "symbols" removes .symtab from ELF shared libraries on Linux, -# making symbol extraction silently produce no output. -# Override strip to "none" for the FFI crate so the symbols remain. -[profile.release.package.minigraf-ffi] -strip = "none" [profile.bench] strip = "none" From 5d7febe95ed95a6e25661cd7f5d35dc6ad2e1d85 Mon Sep 17 00:00:00 2001 From: Aditya Mukhopadhyay Date: Mon, 18 May 2026 14:44:13 +0530 Subject: [PATCH 6/6] =?UTF-8?q?ci:=20remove=20ffi-check=20job=20from=20rus?= =?UTF-8?q?t.yml=20=E2=80=94=20minigraf-ffi=20removed=20from=20workspace?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .github/workflows/rust.yml | 9 --------- 1 file changed, 9 deletions(-) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 32b780c1fd..525cda8610 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -27,15 +27,6 @@ jobs: - name: Run tests run: cargo test --verbose - ffi-check: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v3 - - name: Check FFI crate compiles - run: cargo check -p minigraf-ffi - - name: Run FFI native tests - run: cargo test -p minigraf-ffi - docs-check: runs-on: ubuntu-latest steps: