@dolthub/doltlite 0.10.0 → 0.10.6

package/README.md

@@ -147,6 +147,19 @@ db.exec("SELECT dolt_commit('-Am', 'my message')")
 | `doltCherryPick(hash)` | `void` | Cherry-pick a commit onto HEAD |
 | `doltRevert(ref?)` | `void` | Revert a commit (default: HEAD) |
 
+### `binPath()`
+
+Returns the absolute path to the bundled `doltlite` CLI binary for the current platform. Useful when a consumer wants to spawn the shell directly — e.g. for an interactive `db` subcommand — rather than driving everything through the Node bindings.
+
+```javascript
+import { binPath } from "@dolthub/doltlite"
+import { spawn } from "child_process"
+
+const child = spawn(binPath(), ["mydata.db"], { stdio: "inherit" })
+```
+
+Throws if no CLI build is bundled for the current platform/arch. (Upstream currently ships CLI tools for `linux-x64`, `darwin-arm64`, and `win32-x64`; the `.node` addon covers more platforms than the shell.)
+
 ## Building from source
 
 ```bash

package/binding.gyp

@@ -5,15 +5,18 @@
       "sources": [
         "amalgamation/doltlite_orig.c",
         "amalgamation/doltlite.c",
+        "amalgamation/blake3_sse2_impl.c",
+        "amalgamation/blake3_sse41_impl.c",
+        "amalgamation/blake3_avx2_impl.c",
+        "amalgamation/blake3_avx512_impl.c",
+        "amalgamation/blake3_neon_impl.c",
         "src/addon.cpp",
+        "src/bun_compat.cpp",
         "src/database.cpp",
         "src/statement.cpp"
       ],
       "include_dirs": [
         "amalgamation",
-        "doltlite-src",
-        "doltlite-src/src",
-        "doltlite-src/ext/blake3",
         "<!@(node -p \"require('node-addon-api').include\")"
       ],
       "defines": [

package/index.d.ts

@@ -6,6 +6,14 @@
  * changing their import. Dolt-specific methods are added under `dolt*` names.
  */
 
+/**
+ * Absolute path to the platform's `doltlite` CLI binary bundled in this
+ * package. Use it to spawn the shell (interactive or with a script piped
+ * via stdio). Throws if the binary isn't bundled for the current
+ * platform/arch.
+ */
+export function binPath(): string
+
 export interface ColumnInfo {
   name: string | null
   column: string | null

package/index.js

@@ -1,6 +1,7 @@
 "use strict"
 
 const path = require("path")
+const fs = require("fs")
 
 // Try a prebuilt binary first (shipped with published packages),
 // then fall back to a locally compiled build.
@@ -23,5 +24,24 @@ function loadAddon() {
   )
 }
 
+// Absolute path to the platform's `doltlite` CLI binary, shipped in the
+// package's prebuilds/ alongside the .node addon. Used by consumers (e.g.
+// opencode) that want to spawn an interactive shell or pipe SQL through
+// the doltlite shell. Throws if the binary isn't bundled for this platform.
+function binPath() {
+  const platform = process.platform
+  const arch = process.arch
+  const ext = platform === "win32" ? ".exe" : ""
+  const candidate = path.join(__dirname, "prebuilds", `${platform}-${arch}`, `doltlite${ext}`)
+  if (!fs.existsSync(candidate)) {
+    throw new Error(
+      `@dolthub/doltlite: no doltlite CLI binary bundled for ${platform}-${arch}.\n` +
+      `Expected at ${candidate}. File an issue at ` +
+      `https://github.com/dolthub/doltlite-node/issues`
+    )
+  }
+  return candidate
+}
+
 const { DatabaseSync, StatementSync } = loadAddon()
-module.exports = { DatabaseSync, StatementSync }
+module.exports = { DatabaseSync, StatementSync, binPath }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dolthub/doltlite",
-  "version": "0.10.0",
+  "version": "0.10.6",
   "description": "Node.js bindings for DoltLite — a SQLite fork with Git-style version control",
   "license": "Apache-2.0",
   "main": "index.js",

package/scripts/download.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 // Downloads the doltlite autoconf source tarball from GitHub releases and
-// builds a complete amalgamation from it.
+// builds a complete amalgamation from it, and bundles the matching doltlite
+// CLI binary for the current platform into prebuilds/${platform}-${arch}/
+// so that binPath() can return an absolute path.
 //
 // The autoconf tarball contains both sqlite3.c (the base SQLite amalgamation
 // with doltlite's storage patches) and the prolly tree + dolt SQL function
@@ -22,25 +24,23 @@ const outC      = path.join(amalgDir, "doltlite.c")
 const outH      = path.join(amalgDir, "doltlite.h")
 const srcRoot   = path.join(__dirname, "../doltlite-src")
 
-// Skip if already built.
-if (fs.existsSync(outC) && fs.existsSync(outH)) {
-  process.exit(0)
+// Upstream dolthub/doltlite ships the CLI for these platform-arch pairs;
+// place the binary next to the .node addon so binPath() can return it.
+const CLI_TOOLS = {
+  "linux-x64":    { upstream: "linux-x64",  bin: "doltlite" },
+  "darwin-arm64": { upstream: "osx-arm64",  bin: "doltlite" },
+  "win32-x64":    { upstream: "win-x64",    bin: "doltlite.exe" },
 }
 
-const tarballUrl = `https://github.com/dolthub/doltlite/releases/download/v${version}/doltlite-autoconf-${version}.tar.gz`
-const tarballPath = path.join(__dirname, `../doltlite-autoconf-${version}.tar.gz`)
-
-console.log(`Downloading doltlite source v${version}...`)
-
 function download(url, dest, cb) {
   const file = fs.createWriteStream(dest)
-  function get(url) {
-    https.get(url, (res) => {
+  function get(u) {
+    https.get(u, (res) => {
       if (res.statusCode === 301 || res.statusCode === 302) {
         return get(res.headers.location)
       }
       if (res.statusCode !== 200) {
-        cb(new Error(`HTTP ${res.statusCode} downloading ${url}`))
+        cb(new Error(`HTTP ${res.statusCode} downloading ${u}`))
         return
       }
       res.pipe(file)
@@ -50,38 +50,79 @@ function download(url, dest, cb) {
   get(url)
 }
 
-download(tarballUrl, tarballPath, (err) => {
-  if (err) {
-    console.error("Failed to download doltlite source:", err.message)
-    process.exit(1)
-  }
+function fetchSource(cb) {
+  if (fs.existsSync(outC) && fs.existsSync(outH)) return cb()
 
-  try {
-    fs.rmSync(srcRoot, { recursive: true, force: true })
-    fs.mkdirSync(srcRoot, { recursive: true })
+  const tarballUrl = `https://github.com/dolthub/doltlite/releases/download/v${version}/doltlite-autoconf-${version}.tar.gz`
+  const tarballPath = path.join(__dirname, `../doltlite-autoconf-${version}.tar.gz`)
+  console.log(`Downloading doltlite source v${version}...`)
 
-    // Extract tarball — tar is available on Linux, macOS, and Windows 10+.
-    execSync(`tar xzf "${tarballPath}" -C "${srcRoot}"`, { stdio: "inherit" })
-    fs.unlinkSync(tarballPath)
+  download(tarballUrl, tarballPath, (err) => {
+    if (err) return cb(new Error(`Failed to download source: ${err.message}`))
+    try {
+      fs.rmSync(srcRoot, { recursive: true, force: true })
+      fs.mkdirSync(srcRoot, { recursive: true })
+      execSync(`tar xzf "${tarballPath}" -C "${srcRoot}"`, { stdio: "inherit" })
+      fs.unlinkSync(tarballPath)
 
-    // The tarball nests everything under doltlite-autoconf-${version}/.
-    // Flatten it so doltlite-src/src/ and doltlite-src/sqlite3.c are the
-    // canonical paths that build-amalgamation.js expects.
-    const entries = fs.readdirSync(srcRoot)
-    if (entries.length === 1 && fs.statSync(path.join(srcRoot, entries[0])).isDirectory()) {
-      const subdir = path.join(srcRoot, entries[0])
-      for (const f of fs.readdirSync(subdir)) {
-        fs.renameSync(path.join(subdir, f), path.join(srcRoot, f))
+      // The tarball nests under doltlite-autoconf-${version}/. Flatten so
+      // doltlite-src/src/ and doltlite-src/sqlite3.c are canonical.
+      const entries = fs.readdirSync(srcRoot)
+      if (entries.length === 1 && fs.statSync(path.join(srcRoot, entries[0])).isDirectory()) {
+        const subdir = path.join(srcRoot, entries[0])
+        for (const f of fs.readdirSync(subdir)) {
+          fs.renameSync(path.join(subdir, f), path.join(srcRoot, f))
+        }
+        fs.rmdirSync(subdir)
       }
-      fs.rmdirSync(subdir)
+      execSync(`node "${path.join(__dirname, "build-amalgamation.js")}"`, { stdio: "inherit" })
+      console.log("Source ready.")
+      cb()
+    } catch (e) {
+      cb(new Error(`Failed to prepare doltlite source: ${e.message}`))
     }
+  })
+}
 
-    // Build the complete amalgamation.
-    execSync(`node "${path.join(__dirname, "build-amalgamation.js")}"`, { stdio: "inherit" })
+function fetchCli(cb) {
+  const key = `${process.platform}-${process.arch}`
+  const meta = CLI_TOOLS[key]
+  if (!meta) {
+    console.log(`doltlite CLI: no upstream build for ${key}, skipping`)
+    return cb()
+  }
+  const prebuildDir = path.join(__dirname, "..", "prebuilds", key)
+  const binPath = path.join(prebuildDir, meta.bin)
+  if (fs.existsSync(binPath)) return cb()
+  fs.mkdirSync(prebuildDir, { recursive: true })
+
+  const url = `https://github.com/dolthub/doltlite/releases/download/v${version}/doltlite-tools-${meta.upstream}-${version}.zip`
+  const zipPath = path.join(__dirname, `../doltlite-tools-${meta.upstream}-${version}.zip`)
+  console.log(`Downloading doltlite CLI v${version} for ${key}...`)
+  download(url, zipPath, (err) => {
+    if (err) return cb(new Error(`Failed to download CLI: ${err.message}`))
+    try {
+      execSync(`unzip -jo "${zipPath}" "*/${meta.bin}" -d "${prebuildDir}"`, { stdio: "inherit" })
+      fs.unlinkSync(zipPath)
+      if (process.platform !== "win32") fs.chmodSync(binPath, 0o755)
+      cb()
+    } catch (e) {
+      cb(new Error(`Failed to extract CLI: ${e.message}`))
+    }
+  })
+}
 
-    console.log("Source ready.")
-  } catch (e) {
-    console.error("Failed to prepare doltlite source:", e.message)
+fetchSource((err) => {
+  if (err) {
+    console.error(err.message)
     process.exit(1)
   }
+  fetchCli((cliErr) => {
+    if (cliErr) {
+      // Non-fatal: the addon still builds and works; binPath() will throw
+      // if a consumer invokes it without the CLI present.
+      console.error(`doltlite CLI: ${cliErr.message} (addon will still build)`)
+    }
+    process.exit(0)
+  })
 })

package/src/addon.cpp

@@ -13,3 +13,8 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
 }
 
 NODE_API_MODULE(doltlite, Init)
+
+// C-linkage entry point used by src/bun_compat.cpp.
+extern "C" napi_value _doltlite_init(napi_env env, napi_value exports) {
+  return Init(Napi::Env(env), Napi::Object(env, exports));
+}

package/src/bun_compat.cpp

@@ -0,0 +1,16 @@
+#include <node_api.h>
+
+// Forward declaration of the init function defined in addon.cpp.
+extern "C" napi_value _doltlite_init(napi_env env, napi_value exports);
+
+// Provide napi_register_module_v1 for Bun's Worker loader on Node builds where
+// NAPI_MODULE uses constructor registration and doesn't export this symbol
+// (Node < ~22.12). On newer Node builds, NODE_API_MODULE in addon.cpp already
+// emits a strong napi_register_module_v1, which the linker will prefer over
+// this weak definition. MSVC doesn't support weak functions; skip it there
+// since Windows builds target Node 22+ which supplies the symbol via NAPI_MODULE.
+#if !defined(_MSC_VER)
+extern "C" __attribute__((weak)) napi_value napi_register_module_v1(napi_env env, napi_value exports) {
+  return _doltlite_init(env, exports);
+}
+#endif

package/src/statement.cpp

@@ -3,12 +3,21 @@
 #include "util.h"
 #include <vector>
 
-Napi::FunctionReference Statement::constructor_;
+// Per-env storage for the Statement constructor so re-loading in a Worker
+// thread doesn't overwrite the main thread's constructor reference.
+struct StatementEnvData {
+  Napi::FunctionReference constructor;
+};
+
+Napi::FunctionReference& Statement::GetConstructor(Napi::Env env) {
+  auto* data = env.GetInstanceData<StatementEnvData>();
+  return data->constructor;
+}
 
 // ── Factory (called from Database::Prepare) ──────────────────────────────────
 
 Napi::Object Statement::Create(Napi::Env env, Database* db, sqlite3_stmt* stmt) {
-  auto obj = constructor_.New({});
+  auto obj = GetConstructor(env).New({});
   auto* self = Napi::ObjectWrap<Statement>::Unwrap(obj);
   self->db_ = db;
   self->stmt_ = stmt;
@@ -173,8 +182,10 @@ Napi::Object Statement::Init(Napi::Env env, Napi::Object exports) {
     InstanceAccessor("sourceSQL",   &Statement::SourceSQLGetter,   nullptr),
     InstanceAccessor("expandedSQL", &Statement::ExpandedSQLGetter, nullptr),
   });
-  constructor_ = Napi::Persistent(ctor);
-  constructor_.SuppressDestruct();
+  auto* data = new StatementEnvData();
+  data->constructor = Napi::Persistent(ctor);
+  data->constructor.SuppressDestruct();
+  env.SetInstanceData<StatementEnvData>(data);
   exports.Set("StatementSync", ctor);
   return exports;
 }

package/src/statement.h

@@ -25,5 +25,5 @@ private:
   Napi::Value SourceSQLGetter(const Napi::CallbackInfo& info);
   Napi::Value ExpandedSQLGetter(const Napi::CallbackInfo& info);
 
-  static Napi::FunctionReference constructor_;
+  static Napi::FunctionReference& GetConstructor(Napi::Env env);
 };