beads/internal/storage/factory/factory.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

123 lines
4.3 KiB
Go

// Package factory provides functions for creating storage backends based on configuration.
package factory
import (
"context"
"fmt"
"time"
"github.com/steveyegge/beads/internal/configfile"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/storage/sqlite"
)
// BackendFactory is a function that creates a storage backend
type BackendFactory func(ctx context.Context, path string, opts Options) (storage.Storage, error)
// backendRegistry holds registered backend factories
var backendRegistry = make(map[string]BackendFactory)
// RegisterBackend registers a storage backend factory
func RegisterBackend(name string, factory BackendFactory) {
backendRegistry[name] = factory
}
// Options configures how the storage backend is opened
type Options struct {
ReadOnly bool
LockTimeout time.Duration
// Dolt server mode options (federation)
ServerMode bool // Connect to dolt sql-server instead of embedded
ServerHost string // Server host (default: 127.0.0.1)
ServerPort int // Server port (default: 3307)
ServerUser string // MySQL user (default: root)
Database string // Database name for Dolt server mode (default: beads)
OpenTimeout time.Duration // Advisory lock timeout for embedded dolt (0 = no lock)
}
// New creates a storage backend based on the backend type.
// For SQLite, path should be the full path to the .db file.
// For Dolt, path should be the directory containing the Dolt database.
func New(ctx context.Context, backend, path string) (storage.Storage, error) {
return NewWithOptions(ctx, backend, path, Options{})
}
// NewWithOptions creates a storage backend with the specified options.
func NewWithOptions(ctx context.Context, backend, path string, opts Options) (storage.Storage, error) {
switch backend {
case configfile.BackendSQLite, "":
if opts.ReadOnly {
if opts.LockTimeout > 0 {
return sqlite.NewReadOnlyWithTimeout(ctx, path, opts.LockTimeout)
}
return sqlite.NewReadOnly(ctx, path)
}
if opts.LockTimeout > 0 {
return sqlite.NewWithTimeout(ctx, path, opts.LockTimeout)
}
return sqlite.New(ctx, path)
default:
// Check if backend is registered (e.g., dolt with CGO)
if factory, ok := backendRegistry[backend]; ok {
return factory(ctx, path, opts)
}
// Provide helpful error for dolt on systems without CGO
if backend == configfile.BackendDolt {
return nil, fmt.Errorf("dolt backend requires CGO (not available on this build); use sqlite backend or install from pre-built binaries")
}
return nil, fmt.Errorf("unknown storage backend: %s (supported: sqlite, dolt)", backend)
}
}
// NewFromConfig creates a storage backend based on the metadata.json configuration.
// beadsDir is the path to the .beads directory.
func NewFromConfig(ctx context.Context, beadsDir string) (storage.Storage, error) {
return NewFromConfigWithOptions(ctx, beadsDir, Options{})
}
// NewFromConfigWithOptions creates a storage backend with options from metadata.json.
func NewFromConfigWithOptions(ctx context.Context, beadsDir string, opts Options) (storage.Storage, error) {
cfg, err := configfile.Load(beadsDir)
if err != nil {
return nil, fmt.Errorf("loading config: %w", err)
}
if cfg == nil {
cfg = configfile.DefaultConfig()
}
backend := cfg.GetBackend()
switch backend {
case configfile.BackendSQLite:
return NewWithOptions(ctx, backend, cfg.DatabasePath(beadsDir), opts)
case configfile.BackendDolt:
// Merge Dolt server mode config into options (config provides defaults, opts can override)
if cfg.IsDoltServerMode() {
opts.ServerMode = true
if opts.ServerHost == "" {
opts.ServerHost = cfg.GetDoltServerHost()
}
if opts.ServerPort == 0 {
opts.ServerPort = cfg.GetDoltServerPort()
}
if opts.ServerUser == "" {
opts.ServerUser = cfg.GetDoltServerUser()
}
if opts.Database == "" {
opts.Database = cfg.GetDoltDatabase()
}
}
return NewWithOptions(ctx, backend, cfg.DatabasePath(beadsDir), opts)
default:
return nil, fmt.Errorf("unknown storage backend in config: %s", backend)
}
}
// GetBackendFromConfig returns the backend type from metadata.json
func GetBackendFromConfig(beadsDir string) string {
cfg, err := configfile.Load(beadsDir)
if err != nil || cfg == nil {
return configfile.BackendSQLite
}
return cfg.GetBackend()
}