godolt

godolt

godolt wraps Dolt's operational surface for Go programs, following the gogit precedent — a standalone, dependency-light service-integration module.

Design: SQL-first. The primary workload is many concurrent sessions against dolt sql-server (the embedded driver sustains only one stable connection and is not a target), so version-control verbs — remotes, push, pull, fetch, active branch — run as Dolt stored procedures over the same MySQL wire as queries. The caller supplies the *sql.DB and godolt adds zero driver dependencies. The few operations that cannot run over the wire — clone/init bootstrap, server lifecycle, backups — shell out to the dolt CLI.

db, _ := sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/mydb")
client := godolt.New(db)

if err := client.RemoteAdd(ctx, "origin", "file:///path/to/remote"); err != nil {
    log.Fatal(err)
}
msg, err := client.Push(ctx, "origin", "main")

Library Features

Installation

go get github.com/grokify/godolt

Usage

SQL-wire operations (the primary workload)

import (
	"context"
	"database/sql"

	"github.com/grokify/godolt"
	_ "github.com/go-sql-driver/mysql"
)

db, err := sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/mydb")
if err != nil {
	log.Fatal(err)
}
client := godolt.New(db)

ctx := context.Background()
if err := client.RemoteAdd(ctx, "origin", "file:///path/to/remote"); err != nil {
	log.Fatal(err)
}

remotes, err := client.Remotes(ctx)

msg, err := client.Push(ctx, "origin", "main")

// Push is fast-forward-only: a remote with commits the local branch
// doesn't have rejects the push (error contains "non-fast-forward").
// Pull to fetch and merge before pushing again.
result, err := client.Pull(ctx, "origin", "main")
if result.Conflicts > 0 {
	// Merge completed; resolve dolt_conflicts_<table> rows before pushing.
}

branch, err := client.ActiveBranch(ctx)

Application store pattern (server lifecycle + commits)

The pattern shared by visionstudio, omniroadmap, and uiforge: ensure a long-lived local dolt sql-server over a data directory, create the app's database, connect with Ent (or any MySQL client), and wrap write runs in Dolt commits.

// Ensure a shared local server is running (launches detached if not).
if err := godolt.EnsureServer("/path/to/data", 13307); err != nil {
	log.Fatal(err)
}

// Create the database if needed, connecting server-wide first.
dsn := godolt.EnsureParseTime(godolt.LocalDSN(13307, "myapp"))
base, dbName, err := godolt.SplitDSN(dsn)
if err != nil {
	log.Fatal(err)
}
serverDB, err := sql.Open("mysql", base)
if err != nil {
	log.Fatal(err)
}
if err := godolt.CreateDatabase(ctx, serverDB, dbName); err != nil {
	log.Fatal(err)
}
_ = serverDB.Close()

// Connect to the database and wrap work in a Dolt commit.
db, err := sql.Open("mysql", dsn)
if err != nil {
	log.Fatal(err)
}
client := godolt.New(db)
// ... write rows ...
hash, err := client.CommitAll(ctx, "sync run 2026-08-19")
if err != nil {
	log.Fatal(err)
}
if hash == "" {
	// Clean working set — nothing to commit.
}

Cold path: bootstrap and backups

if !godolt.Available() {
	log.Fatal("dolt CLI not found on PATH")
}

if err := godolt.InitDir(ctx, "/path/to/db", "my-service", "my-service@local"); err != nil {
	log.Fatal(err)
}

if err := godolt.Clone(ctx, "file:///path/to/remote", "/path/to/clone"); err != nil {
	log.Fatal(err)
}

if err := godolt.BackupAdd(ctx, "/path/to/db", "spike", "file:///path/to/backup"); err != nil {
	log.Fatal(err)
}
if err := godolt.BackupSync(ctx, "/path/to/db", "spike"); err != nil {
	log.Fatal(err)
}

Documentation

Full docs, including release notes, are published at grokify.github.io/godolt.

License

MIT