Rebase of PR #4601 (feat/choose-your-own-backend) onto current origin/main, squashed to a single commit because the original 73-commit history built and then removed the uowStore derisk spike incrementally, which does not replay cleanly over the 125 commits main has since advanced (notably #4679, the ready-work counts fix, which merged to main and is now inherited rather than re-applied). The full pre-rebase history remains on the original branch tip for reference. Contents (multi-backend feature + the six review follow-ups): - bd init --backend=postgres|mysql|sqlite provisioning behind the Dolt-parity seam; the three SQL backends share *sqlkit.Store over pluggable dialects and carry a generated typed-unsupported shell for the non-core surface. - Passwords in init DSNs are redacted before persisting to metadata.json (driver parser + re-parse verification), with a negative-test matrix proving no secret survives (pgdialect + mysql). - The uowStore derisk spike and its report artifacts are removed; the shell generator now lives in internal/storage/unsupportedgen (neutral name). - Compile-time guard `var _ storage.DoltStorage = (*Store)(nil)` on each backend plus a regen-idempotence test keep the generated skip lists honest. - sqlkit exposes CountReadyWork so every SQL backend satisfies storage.ReadyWorkCounter and inherits the shared page-pushed ready-counts path. - Commercial/product names scrubbed from the feature's own code for vendor neutrality. Rebase reconciliations: adopted main's metadata-load hardening in the store factories alongside the backend dispatch; combined the config interface (GetMetadata + ReconcileVersion) and the conformance registrations (ReadyCounts + Claim/lease); took main's versions of the shared-infra concurrency (uow doltserver_tx) and delete-cascade (domain/issue_delete) evolutions; implemented the interface's new UnclaimIssue on sqlkit (delegating to issueops) and added it to the skip lists. Verified: go build (cgo + CGO_ENABLED=0) and go vet clean; unit tests (sqlbuild/issueops/pgdialect/mysql/unsupportedgen) and the SQLite conformance suite green (RunAll, incl. ReadyCounts equivalence and Claim/lease on the real sqlkit backend). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
328 lines
11 KiB
Go
328 lines
11 KiB
Go
package sqlkit
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
|
|
"github.com/steveyegge/beads/internal/config"
|
|
"github.com/steveyegge/beads/internal/storage/domain"
|
|
"github.com/steveyegge/beads/internal/storage/issueops"
|
|
"github.com/steveyegge/beads/internal/types"
|
|
)
|
|
|
|
// This file fills in the capability surface the CLI verbs reach but the earlier
|
|
// implement-set left as typed-unsupported stubs on the backend shell. Every
|
|
// method is a thin delegation to the backend-neutral issueops layer, mirroring
|
|
// the internal/storage/dolt/*.go bodies with the Dolt residue (DOLT_ADD/COMMIT,
|
|
// per-lifetime caches, the wisp-batch write-timeout workaround) dropped: wisps
|
|
// live in the same database here, so a single *sql.Tx serves every table and
|
|
// issueops does its own wisp partitioning internally.
|
|
|
|
// --- blocking / newly-unblocked reads ---
|
|
|
|
// IsBlocked reports whether an issue is blocked by open dependencies, returning
|
|
// the blocker IDs.
|
|
func (s *Store) IsBlocked(ctx context.Context, issueID string) (bool, []string, error) {
|
|
var blocked bool
|
|
var blockers []string
|
|
err := s.withReadTx(ctx, func(tx *sql.Tx) error {
|
|
var e error
|
|
blocked, blockers, e = issueops.IsBlockedInTx(ctx, tx, issueID)
|
|
return e
|
|
})
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
return blocked, blockers, nil
|
|
}
|
|
|
|
// GetNewlyUnblockedByClose finds issues that become unblocked when closedIssueID
|
|
// is closed.
|
|
func (s *Store) GetNewlyUnblockedByClose(ctx context.Context, closedIssueID string) ([]*types.Issue, error) {
|
|
var result []*types.Issue
|
|
err := s.withReadTx(ctx, func(tx *sql.Tx) error {
|
|
var e error
|
|
result, e = issueops.GetNewlyUnblockedByCloseInTx(ctx, tx, closedIssueID)
|
|
return e
|
|
})
|
|
return result, err
|
|
}
|
|
|
|
// --- claim / delete / child-id writes ---
|
|
|
|
// ClaimIssue atomically claims an issue (assignee=actor, status=in_progress)
|
|
// only if it is currently unassigned. Runs in a mutation tx so the claim and its
|
|
// is_blocked reprojection commit atomically.
|
|
func (s *Store) ClaimIssue(ctx context.Context, id string, actor string) error {
|
|
return s.withMutationTx(ctx, func(tx *sql.Tx) error {
|
|
_, err := issueops.ClaimIssueInTx(ctx, tx, id, actor)
|
|
return err
|
|
})
|
|
}
|
|
|
|
// UnclaimIssue releases a claim (clears assignee, returns to open) in a mutation
|
|
// tx so the change and its is_blocked reprojection commit atomically.
|
|
func (s *Store) UnclaimIssue(ctx context.Context, id string, actor string) error {
|
|
return s.withMutationTx(ctx, func(tx *sql.Tx) error {
|
|
return issueops.UnclaimIssueInTx(ctx, tx, id, actor)
|
|
})
|
|
}
|
|
|
|
// ClaimReadyIssue atomically claims the first ready issue matching filter, or
|
|
// returns (nil, nil) when nothing is ready.
|
|
func (s *Store) ClaimReadyIssue(ctx context.Context, filter types.WorkFilter, actor string) (*types.Issue, error) {
|
|
var claimed *types.Issue
|
|
err := s.withMutationTx(ctx, func(tx *sql.Tx) error {
|
|
var e error
|
|
claimed, e = issueops.ClaimReadyIssueInTx(ctx, tx, filter, actor)
|
|
return e
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return claimed, nil
|
|
}
|
|
|
|
// DeleteIssues deletes multiple issues in a single transaction. issueops does
|
|
// its own wisp partitioning and cascade/force/orphan handling, so all IDs go
|
|
// straight through — dolt's outer wisp-batch loop is a write-timeout workaround
|
|
// that does not apply here. The partial result is preserved alongside an error
|
|
// so OrphanedIssues survives the non-cascade/non-force rejection path.
|
|
func (s *Store) DeleteIssues(ctx context.Context, ids []string, cascade bool, force bool, dryRun bool) (*types.DeleteIssuesResult, error) {
|
|
if len(ids) == 0 {
|
|
return &types.DeleteIssuesResult{}, nil
|
|
}
|
|
var result *types.DeleteIssuesResult
|
|
err := s.withMutationTx(ctx, func(tx *sql.Tx) error {
|
|
r, e := issueops.DeleteIssuesInTx(ctx, tx, ids, cascade, force, dryRun)
|
|
result = r
|
|
return e
|
|
})
|
|
return result, err
|
|
}
|
|
|
|
// GetNextChildID returns the next available child ID for a parent, seeding and
|
|
// bumping the child_counters row in the same tx.
|
|
func (s *Store) GetNextChildID(ctx context.Context, parentID string) (string, error) {
|
|
var childID string
|
|
err := s.withMutationTx(ctx, func(tx *sql.Tx) error {
|
|
var e error
|
|
childID, e = issueops.GetNextChildIDTx(ctx, tx, parentID)
|
|
return e
|
|
})
|
|
return childID, err
|
|
}
|
|
|
|
// --- custom statuses / types (uncached; the dolt cache is only an optimization) ---
|
|
|
|
// GetCustomStatusesDetailed returns the configured custom statuses with their
|
|
// full definitions.
|
|
func (s *Store) GetCustomStatusesDetailed(ctx context.Context) ([]types.CustomStatus, error) {
|
|
// Read the normalized custom_statuses table (ORDER BY name), matching the
|
|
// embedded-Dolt reference — SetConfig("status.custom") keeps it in sync. On a tx
|
|
// error fall back to config.yaml exactly as dolt does.
|
|
var result []types.CustomStatus
|
|
err := s.withReadTx(ctx, func(tx *sql.Tx) error {
|
|
var e error
|
|
result, e = issueops.ResolveCustomStatusesDetailedInTx(ctx, tx)
|
|
return e
|
|
})
|
|
if err != nil {
|
|
if yamlStatuses := config.GetCustomStatusesFromYAML(); len(yamlStatuses) > 0 {
|
|
return issueops.ParseStatusFallback(yamlStatuses), nil
|
|
}
|
|
return nil, nil
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
// GetCustomStatuses returns the configured custom status names.
|
|
func (s *Store) GetCustomStatuses(ctx context.Context) ([]string, error) {
|
|
detailed, err := s.GetCustomStatusesDetailed(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return types.CustomStatusNames(detailed), nil
|
|
}
|
|
|
|
// GetCustomTypes returns the configured custom issue-type values.
|
|
func (s *Store) GetCustomTypes(ctx context.Context) ([]string, error) {
|
|
// Read the normalized custom_types table (ORDER BY name), matching the embedded-Dolt
|
|
// reference; SetConfig("types.custom") keeps it in sync. Fall back to config.yaml on a
|
|
// tx error, as dolt does.
|
|
var result []string
|
|
err := s.withReadTx(ctx, func(tx *sql.Tx) error {
|
|
var e error
|
|
result, e = issueops.ResolveCustomTypesInTx(ctx, tx)
|
|
return e
|
|
})
|
|
if err != nil {
|
|
if yamlTypes := config.GetCustomTypesFromYAML(); len(yamlTypes) > 0 {
|
|
return yamlTypes, nil
|
|
}
|
|
return nil, err
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
// --- infra types ---
|
|
|
|
// GetInfraTypes returns the infrastructure type names (routed to the wisps
|
|
// table). issueops resolves DB config → config.yaml → defaults; on a tx error it
|
|
// yields nil, in which case we fall back to YAML-then-defaults exactly as dolt
|
|
// does. These signatures have no error channel, so a silent nil here would let
|
|
// `bd wisp gc` hard-delete protected infra beads — hence the explicit fallback.
|
|
func (s *Store) GetInfraTypes(ctx context.Context) map[string]bool {
|
|
var result map[string]bool
|
|
if err := s.withReadTx(ctx, func(tx *sql.Tx) error {
|
|
result = issueops.ResolveInfraTypesInTx(ctx, tx)
|
|
return nil
|
|
}); err != nil || result == nil {
|
|
var typeList []string
|
|
if yamlTypes := config.GetInfraTypesFromYAML(); len(yamlTypes) > 0 {
|
|
typeList = yamlTypes
|
|
} else {
|
|
typeList = domain.DefaultInfraTypes()
|
|
}
|
|
result = make(map[string]bool, len(typeList))
|
|
for _, t := range typeList {
|
|
result[t] = true
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
// IsInfraTypeCtx reports whether t is a configured infrastructure type.
|
|
func (s *Store) IsInfraTypeCtx(ctx context.Context, t types.IssueType) bool {
|
|
return s.GetInfraTypes(ctx)[string(t)]
|
|
}
|
|
|
|
// --- metadata / config ---
|
|
|
|
// GetMetadata reads a metadata value ("" when absent).
|
|
func (s *Store) GetMetadata(ctx context.Context, key string) (string, error) {
|
|
var value string
|
|
err := s.withReadTx(ctx, func(tx *sql.Tx) error {
|
|
var e error
|
|
value, e = issueops.GetMetadataInTx(ctx, tx, key)
|
|
return e
|
|
})
|
|
return value, err
|
|
}
|
|
|
|
// SetMetadata writes a metadata value. Metadata cannot change is_blocked, so
|
|
// this uses a plain write tx.
|
|
func (s *Store) SetMetadata(ctx context.Context, key, value string) error {
|
|
return s.withWriteTx(ctx, func(tx *sql.Tx) error {
|
|
return issueops.SetMetadataInTx(ctx, tx, key, value)
|
|
})
|
|
}
|
|
|
|
// DeleteConfig removes a config value.
|
|
func (s *Store) DeleteConfig(ctx context.Context, key string) error {
|
|
return s.withWriteTx(ctx, func(tx *sql.Tx) error {
|
|
return issueops.DeleteConfigInTx(ctx, tx, key)
|
|
})
|
|
}
|
|
|
|
// --- batch reads (permanent + wisp mixed-table union handled inside issueops) ---
|
|
|
|
// GetBlockingInfoForIssues returns the blocked-by, blocks, and parent maps for a
|
|
// set of issue IDs.
|
|
func (s *Store) GetBlockingInfoForIssues(ctx context.Context, issueIDs []string) (
|
|
blockedByMap map[string][]string,
|
|
blocksMap map[string][]string,
|
|
parentMap map[string]string,
|
|
err error,
|
|
) {
|
|
err = s.withReadTx(ctx, func(tx *sql.Tx) error {
|
|
var txErr error
|
|
blockedByMap, blocksMap, parentMap, txErr = issueops.GetBlockingInfoForIssuesInTx(ctx, tx, issueIDs)
|
|
return txErr
|
|
})
|
|
return
|
|
}
|
|
|
|
// GetDependencyCounts returns dependency/dependent counts for multiple issues.
|
|
func (s *Store) GetDependencyCounts(ctx context.Context, issueIDs []string) (map[string]*types.DependencyCounts, error) {
|
|
var result map[string]*types.DependencyCounts
|
|
err := s.withReadTx(ctx, func(tx *sql.Tx) error {
|
|
var e error
|
|
result, e = issueops.GetDependencyCountsInTx(ctx, tx, issueIDs)
|
|
return e
|
|
})
|
|
return result, err
|
|
}
|
|
|
|
// GetCommentCounts returns the comment count for each issue in a single batch.
|
|
func (s *Store) GetCommentCounts(ctx context.Context, issueIDs []string) (map[string]int, error) {
|
|
var result map[string]int
|
|
err := s.withReadTx(ctx, func(tx *sql.Tx) error {
|
|
var e error
|
|
result, e = issueops.GetCommentCountsInTx(ctx, tx, issueIDs)
|
|
return e
|
|
})
|
|
return result, err
|
|
}
|
|
|
|
// GetLabelsForIssues returns the labels for each issue in a single batch.
|
|
func (s *Store) GetLabelsForIssues(ctx context.Context, issueIDs []string) (map[string][]string, error) {
|
|
var result map[string][]string
|
|
err := s.withReadTx(ctx, func(tx *sql.Tx) error {
|
|
var e error
|
|
result, e = issueops.GetLabelsForIssuesInTx(ctx, tx, issueIDs)
|
|
return e
|
|
})
|
|
return result, err
|
|
}
|
|
|
|
// GetCommentsForIssues returns the comments for each issue in a single batch.
|
|
func (s *Store) GetCommentsForIssues(ctx context.Context, issueIDs []string) (map[string][]*types.Comment, error) {
|
|
var result map[string][]*types.Comment
|
|
err := s.withReadTx(ctx, func(tx *sql.Tx) error {
|
|
var e error
|
|
result, e = issueops.GetCommentsForIssuesInTx(ctx, tx, issueIDs)
|
|
return e
|
|
})
|
|
return result, err
|
|
}
|
|
|
|
// GetDependencyRecords returns the raw dependency rows for a single issue.
|
|
// Delegates to the batch helper, which partitions wisp vs permanent IDs and
|
|
// resolves targets via the split physical columns internally.
|
|
func (s *Store) GetDependencyRecords(ctx context.Context, issueID string) ([]*types.Dependency, error) {
|
|
var deps []*types.Dependency
|
|
err := s.withReadTx(ctx, func(tx *sql.Tx) error {
|
|
byID, e := issueops.GetDependencyRecordsForIssuesInTx(ctx, tx, []string{issueID})
|
|
if e != nil {
|
|
return e
|
|
}
|
|
deps = byID[issueID]
|
|
return nil
|
|
})
|
|
return deps, err
|
|
}
|
|
|
|
// GetDependencyRecordsForIssues returns the raw dependency rows for multiple
|
|
// issues.
|
|
func (s *Store) GetDependencyRecordsForIssues(ctx context.Context, issueIDs []string) (map[string][]*types.Dependency, error) {
|
|
var result map[string][]*types.Dependency
|
|
err := s.withReadTx(ctx, func(tx *sql.Tx) error {
|
|
var e error
|
|
result, e = issueops.GetDependencyRecordsForIssuesInTx(ctx, tx, issueIDs)
|
|
return e
|
|
})
|
|
return result, err
|
|
}
|
|
|
|
// DetectCycles finds circular dependencies across both the permanent and wisp
|
|
// dependency tables.
|
|
func (s *Store) DetectCycles(ctx context.Context) ([][]*types.Issue, error) {
|
|
var result [][]*types.Issue
|
|
err := s.withReadTx(ctx, func(tx *sql.Tx) error {
|
|
var e error
|
|
result, e = issueops.DetectCyclesInTx(ctx, tx)
|
|
return e
|
|
})
|
|
return result, err
|
|
}
|