beads/internal/storage/dolt/versioned.go
beads/crew/emma 2137693dad revert: restore embedded Dolt mode (was only supposed to be removed from Gas Town)
Revert commits e5330641 and 0df41523 which removed embedded Dolt mode
from the beads codebase. The embedded Dolt removal was only intended for
Gas Town, not for Beads.

Restores:
- dolthub/driver dependency and embedded connection path
- Advisory flock (AccessLock) for concurrent process protection
- Embedded connector lifecycle management in DoltStore
- All CGO build tags across ~45 files
- Vendored go-icu-regex library
- nocgo stub files for non-CGO builds
- Bootstrap and embedded_uow helpers
- factory_dolt_test.go and dolt_singleprocess_test.go

Merge conflict resolutions:
- store.go: TCP fail-fast check wrapped inside if cfg.ServerMode
- store.go: backtick-quoting for embedded CREATE DATABASE (prefix-based names)
- perf_dolt.go: port references updated from 3306 to 3307
- ci.yml: restored continue-on-error for Nix (dolthub/driver requires Go 1.25.6+)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Executed-By: beads/crew/emma
Rig: beads
Role: crew
2026-02-07 21:21:24 -08:00

269 lines
7.8 KiB
Go

//go:build cgo
package dolt
import (
"context"
"fmt"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/types"
)
// Ensure DoltStore implements VersionedStorage at compile time.
var _ storage.VersionedStorage = (*DoltStore)(nil)
// History returns the complete version history for an issue.
// Implements storage.VersionedStorage.
func (s *DoltStore) History(ctx context.Context, issueID string) ([]*storage.HistoryEntry, error) {
internal, err := s.GetIssueHistory(ctx, issueID)
if err != nil {
return nil, err
}
// Convert internal representation to interface type
entries := make([]*storage.HistoryEntry, len(internal))
for i, h := range internal {
entries[i] = &storage.HistoryEntry{
CommitHash: h.CommitHash,
Committer: h.Committer,
CommitDate: h.CommitDate,
Issue: h.Issue,
}
}
return entries, nil
}
// AsOf returns the state of an issue at a specific commit hash or branch ref.
// Implements storage.VersionedStorage.
func (s *DoltStore) AsOf(ctx context.Context, issueID string, ref string) (*types.Issue, error) {
return s.GetIssueAsOf(ctx, issueID, ref)
}
// Diff returns changes between two commits/branches.
// Implements storage.VersionedStorage.
func (s *DoltStore) Diff(ctx context.Context, fromRef, toRef string) ([]*storage.DiffEntry, error) {
// Validate refs to prevent SQL injection
if err := validateRef(fromRef); err != nil {
return nil, fmt.Errorf("invalid fromRef: %w", err)
}
if err := validateRef(toRef); err != nil {
return nil, fmt.Errorf("invalid toRef: %w", err)
}
// Query issue-level diffs using dolt_diff table function
// Syntax: dolt_diff(from_ref, to_ref, 'table_name')
// Note: refs are validated above
// nolint:gosec // G201: refs validated by validateRef()
query := fmt.Sprintf(`
SELECT
COALESCE(from_id, '') as from_id,
COALESCE(to_id, '') as to_id,
diff_type,
from_title, to_title,
from_description, to_description,
from_status, to_status,
from_priority, to_priority
FROM dolt_diff('%s', '%s', 'issues')
`, fromRef, toRef)
rows, err := s.db.QueryContext(ctx, query)
if err != nil {
return nil, fmt.Errorf("failed to get diff: %w", err)
}
defer rows.Close()
var entries []*storage.DiffEntry
for rows.Next() {
var fromID, toID, diffType string
var fromTitle, toTitle, fromDesc, toDesc, fromStatus, toStatus *string
var fromPriority, toPriority *int
if err := rows.Scan(&fromID, &toID, &diffType,
&fromTitle, &toTitle,
&fromDesc, &toDesc,
&fromStatus, &toStatus,
&fromPriority, &toPriority); err != nil {
return nil, fmt.Errorf("failed to scan diff: %w", err)
}
entry := &storage.DiffEntry{
DiffType: diffType,
}
// Determine issue ID (use to_id for added, from_id for removed, either for modified)
if toID != "" {
entry.IssueID = toID
} else {
entry.IssueID = fromID
}
// Build old value for modified/removed
if diffType != "added" && fromID != "" {
entry.OldValue = &types.Issue{
ID: fromID,
}
if fromTitle != nil {
entry.OldValue.Title = *fromTitle
}
if fromDesc != nil {
entry.OldValue.Description = *fromDesc
}
if fromStatus != nil {
entry.OldValue.Status = types.Status(*fromStatus)
}
if fromPriority != nil {
entry.OldValue.Priority = *fromPriority
}
}
// Build new value for modified/added
if diffType != "removed" && toID != "" {
entry.NewValue = &types.Issue{
ID: toID,
}
if toTitle != nil {
entry.NewValue.Title = *toTitle
}
if toDesc != nil {
entry.NewValue.Description = *toDesc
}
if toStatus != nil {
entry.NewValue.Status = types.Status(*toStatus)
}
if toPriority != nil {
entry.NewValue.Priority = *toPriority
}
}
entries = append(entries, entry)
}
return entries, rows.Err()
}
// ListBranches returns the names of all branches.
// Implements storage.VersionedStorage.
func (s *DoltStore) ListBranches(ctx context.Context) ([]string, error) {
rows, err := s.db.QueryContext(ctx, "SELECT name FROM dolt_branches ORDER BY name")
if err != nil {
return nil, fmt.Errorf("failed to list branches: %w", err)
}
defer rows.Close()
var branches []string
for rows.Next() {
var name string
if err := rows.Scan(&name); err != nil {
return nil, fmt.Errorf("failed to scan branch: %w", err)
}
branches = append(branches, name)
}
return branches, rows.Err()
}
// GetCurrentCommit returns the hash of the current HEAD commit.
// Implements storage.VersionedStorage.
func (s *DoltStore) GetCurrentCommit(ctx context.Context) (string, error) {
var hash string
err := s.db.QueryRowContext(ctx, "SELECT DOLT_HASHOF('HEAD')").Scan(&hash)
if err != nil {
return "", fmt.Errorf("failed to get current commit: %w", err)
}
return hash, nil
}
// GetConflicts returns any merge conflicts in the current state.
// Implements storage.VersionedStorage.
func (s *DoltStore) GetConflicts(ctx context.Context) ([]storage.Conflict, error) {
internal, err := s.GetInternalConflicts(ctx)
if err != nil {
return nil, err
}
conflicts := make([]storage.Conflict, 0, len(internal))
for _, c := range internal {
conflicts = append(conflicts, storage.Conflict{
Field: c.TableName,
})
}
return conflicts, nil
}
// ExportChanges represents the result of GetChangesSinceExport.
type ExportChanges struct {
Entries []*storage.DiffEntry // Changes since the export commit
NeedsFullExport bool // True if fromCommit is invalid/GC'd
}
// GetChangesSinceExport returns changes since a specific commit hash.
// If the commit hash is invalid or has been garbage collected, it returns
// NeedsFullExport=true to indicate a full export is required.
func (s *DoltStore) GetChangesSinceExport(ctx context.Context, fromCommit string) (*ExportChanges, error) {
// Empty commit means this is the first export
if fromCommit == "" {
return &ExportChanges{NeedsFullExport: true}, nil
}
// Validate the ref format
if err := validateRef(fromCommit); err != nil {
return &ExportChanges{NeedsFullExport: true}, nil
}
// Check if the commit exists
exists, err := s.CommitExists(ctx, fromCommit)
if err != nil {
return nil, fmt.Errorf("failed to check commit existence: %w", err)
}
if !exists {
return &ExportChanges{NeedsFullExport: true}, nil
}
// Get current HEAD commit to check if we're already at fromCommit
currentCommit, err := s.GetCurrentCommit(ctx)
if err != nil {
return nil, fmt.Errorf("failed to get current commit: %w", err)
}
// If fromCommit equals HEAD, there are no changes.
// Note: This also avoids a nil pointer panic in the embedded Dolt driver
// when querying dolt_diff with identical from/to refs.
if fromCommit == currentCommit {
return &ExportChanges{Entries: nil}, nil
}
// Get the diff from that commit to HEAD
entries, err := s.Diff(ctx, fromCommit, "HEAD")
if err != nil {
return nil, fmt.Errorf("failed to get diff: %w", err)
}
return &ExportChanges{Entries: entries}, nil
}
// CommitExists checks whether a commit hash exists in the repository.
// Returns false for empty strings, malformed input, or non-existent commits.
func (s *DoltStore) CommitExists(ctx context.Context, commitHash string) (bool, error) {
// Empty string is not a valid commit
if commitHash == "" {
return false, nil
}
// Validate format to reject malformed input
if err := validateRef(commitHash); err != nil {
return false, nil
}
// Query dolt_log to check if the commit exists.
// Supports both full hashes and short prefixes (like git's short SHA).
// The exact match handles full hashes; LIKE handles prefixes.
var count int
err := s.db.QueryRowContext(ctx, `
SELECT COUNT(*) FROM dolt_log
WHERE commit_hash = ? OR commit_hash LIKE ?
`, commitHash, commitHash+"%").Scan(&count)
if err != nil {
return false, fmt.Errorf("failed to check commit existence: %w", err)
}
return count > 0, nil
}