Skip to content

Git designed for AI agents.

12.3 KB
Raw Blame
package sqlstore

import (
	"context"
	"database/sql"
	"errors"
	"fmt"
	"math"
	"slices"
	"strings"
	"time"

	"github.com/feder-cr/git-ai/internal/graft/changelog"
	"github.com/feder-cr/git-ai/internal/graft/corestore"
)

// CommitChangeset implements corestore.MetaStore.
func (s *Store) CommitChangeset(ctx context.Context, in corestore.ChangesetInput) (corestore.CommitResult, error) {
	var result corestore.CommitResult

	err := s.withTx(ctx, nil, func(tx *sql.Tx) error {
		result = corestore.CommitResult{}

		repo, err := s.selectRepository(ctx, tx, "repo_id = ?", []any{in.RepoID}, true)
		if err != nil {
			return err
		}

		result, err = s.commitChangeset(ctx, tx, &repo, in)
		return err
	})
	if err != nil {
		return corestore.CommitResult{}, err
	}

	return result, nil
}

// validateChangeset checks the input of a changeset before anything is read.
func validateChangeset(in corestore.ChangesetInput) error {
	if len(in.Updates) == 0 {
		return errors.New("storage core: changeset has no reference updates")
	}

	seen := make(map[string]struct{}, len(in.Updates))
	for _, u := range in.Updates {
		if u.Name == "" {
			return errors.New("storage core: reference update has an empty name")
		}
		if _, dup := seen[u.Name]; dup {
			return fmt.Errorf("storage core: reference %q is updated twice in one changeset", u.Name)
		}
		seen[u.Name] = struct{}{}

		switch u.Expect {
		case corestore.ExpectValue, corestore.ExpectAny:
		default:
			return fmt.Errorf("storage core: reference %q has an unknown expectation %d", u.Name, u.Expect)
		}

		// The target columns are text: Postgres refuses bytes that are not
		// UTF-8 and NUL bytes, so both dialects refuse such a target (a
		// symbolic reference to a name that is not UTF-8) instead of storing it
		// on SQLite only.
		if !storableText(string(u.New)) {
			return fmt.Errorf("storage core: new target %q of reference %q is not valid UTF-8 text", u.New, u.Name)
		}
	}

	return nil
}

// checkPackDeadline refuses, with ErrPackDeadline, the commit of a row that
// references an uploaded pack once the database clock reached the pack's write
// deadline (PackUpload.DBDeadline), and the commit of one without a deadline.
// Garbage collection deletes an unreferenced pack gc_grace after it observed it
// on the database clock, which is after the record read the deadline starts
// from: a row committed before the deadline is never a row whose pack is gone,
// whatever the writer's own clock did meanwhile (a suspended host, a paused
// VM).
func (s *Store) checkPackDeadline(ctx context.Context, tx *sql.Tx, deadline time.Time) error {
	if deadline.IsZero() {
		return errors.New("storage core: a row that references a pack must carry the pack's write deadline")
	}
	now, err := s.wallTime(ctx, tx)
	if err != nil {
		return err
	}
	if !now.Before(deadline) {
		return fmt.Errorf("storage core: commit at %s, after the pack's write deadline %s: %w", now.Format(time.RFC3339Nano), deadline.UTC().Format(time.RFC3339Nano), corestore.ErrPackDeadline)
	}
	return nil
}

// commitChangeset records a changeset in the open transaction tx, for the
// locked repository repo, and advances repo to the new sequences. It is shared
// by CommitChangeset and the initial changeset of RegisterRepository.
//
// It returns *corestore.ErrRefConflict, writing nothing, when an expectation
// fails and in.Force is not set.
func (s *Store) commitChangeset(ctx context.Context, tx *sql.Tx, repo *repoState, in corestore.ChangesetInput) (corestore.CommitResult, error) {
	if err := validateChangeset(in); err != nil {
		return corestore.CommitResult{}, err
	}

	names := make([]string, len(in.Updates))
	for i, u := range in.Updates {
		names[i] = u.Name
	}

	current, err := s.currentTargets(ctx, tx, repo.id, names)
	if err != nil {
		return corestore.CommitResult{}, err
	}

	var (
		conflicts []corestore.RefConflict
		effective []corestore.AppliedUpdate
	)
	for _, u := range in.Updates {
		actual := current[u.Name]

		if u.Expect == corestore.ExpectValue && actual != u.Old {
			conflicts = append(conflicts, corestore.RefConflict{Name: u.Name, Expected: u.Old, Actual: actual})
		}

		if actual != u.New {
			effective = append(effective, corestore.AppliedUpdate{Name: u.Name, Old: actual, New: u.New})
		}
	}

	if len(conflicts) > 0 && !in.Force {
		return corestore.CommitResult{}, &corestore.ErrRefConflict{Conflicts: conflicts}
	}
	if !in.Force {
		if err := s.refuseReleasedRoots(ctx, tx, repo.id, effective); err != nil {
			return corestore.CommitResult{}, err
		}
	}

	if len(effective) == 0 {
		return corestore.CommitResult{NoOp: true, Conflicts: conflicts}, nil
	}

	now := time.Now().UTC()
	seq := repo.headSeq + 1
	forced := in.Force && len(conflicts) > 0

	var packKey any
	if in.PackKey != "" {
		if err := s.checkPackDeadline(ctx, tx, in.PackDeadline); err != nil {
			return corestore.CommitResult{}, err
		}
		packKey = in.PackKey
	}

	if _, err := tx.ExecContext(ctx, s.bind(`
		INSERT INTO graft_changesets (repo_id, seq, operation, actor, node_id, pack_key, pack_bytes, forced, created_at)
		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
	`), repo.id, int64(seq), validUTF8(in.Operation), validUTF8(in.Actor), validUTF8(in.NodeID),
		packKey, in.PackBytes, forced, s.timeArg(now)); err != nil {
		return corestore.CommitResult{}, fmt.Errorf("insert changeset: %w", err)
	}

	for ordinal, u := range effective {
		if _, err := tx.ExecContext(ctx, s.bind(`
			INSERT INTO graft_changeset_refs (repo_id, seq, ordinal, name, old_target, new_target)
			VALUES (?, ?, ?, ?, ?, ?)
		`), repo.id, int64(seq), ordinal, bytesArg([]byte(u.Name)), targetArg(u.Old), targetArg(u.New)); err != nil {
			return corestore.CommitResult{}, fmt.Errorf("insert changeset reference: %w", err)
		}

		if u.New == "" {
			_, err = tx.ExecContext(ctx, s.bind("DELETE FROM graft_refs WHERE repo_id = ? AND name = ?"),
				repo.id, bytesArg([]byte(u.Name)))
		} else {
			_, err = tx.ExecContext(ctx, s.bind(`
				INSERT INTO graft_refs (repo_id, name, target, seq)
				VALUES (?, ?, ?, ?)
				ON CONFLICT (repo_id, name) DO UPDATE SET
					target = excluded.target,
					seq = excluded.seq
			`), repo.id, bytesArg([]byte(u.Name)), string(u.New), int64(seq))
		}
		if err != nil {
			return corestore.CommitResult{}, fmt.Errorf("update reference %q: %w", u.Name, err)
		}
	}

	var entries []changelog.Entry
	if in.Changelog != nil {
		entries = buildChangelogEntries(repo, in.Changelog, now, effective)
		if err := insertChangelog(ctx, s, tx, repo.id, entries); err != nil {
			return corestore.CommitResult{}, err
		}
		if n := len(entries); n > 0 {
			repo.logSeq = entries[n-1].Sequence
		}
	}

	repo.headSeq = seq

	if _, err := tx.ExecContext(ctx, s.bind("UPDATE graft_repositories SET head_seq = ?, log_seq = ? WHERE repo_id = ?"),
		int64(repo.headSeq), int64(repo.logSeq), repo.id); err != nil {
		return corestore.CommitResult{}, fmt.Errorf("update repository sequences: %w", err)
	}

	return corestore.CommitResult{
		Seq:       seq,
		Forced:    forced,
		Conflicts: conflicts,
		Updates:   effective,
		Changelog: entries,
	}, nil
}

// buildChangelogEntries returns the changelog entries of the effective updates
// of a changeset: one per branch or tag that is not symbolic, with the
// sequences that follow repo's last changelog sequence.
func buildChangelogEntries(repo *repoState, meta *changelog.Meta, now time.Time, updates []corestore.AppliedUpdate) []changelog.Entry {
	zero := zeroOID(repo.objectFormat)

	recordedAt := meta.RecordedAt
	if recordedAt.IsZero() {
		recordedAt = now
	}
	recordedAt = recordedAt.UTC()

	var entries []changelog.Entry
	seq := repo.logSeq
	for _, u := range updates {
		if !corestore.IsChangelogRef(u.Name) || u.Old.IsSymbolic() || u.New.IsSymbolic() {
			continue
		}

		seq++

		oldOID := string(u.Old)
		if oldOID == "" {
			oldOID = zero
		}
		newOID := string(u.New)
		if newOID == "" {
			newOID = zero
		}

		entries = append(entries, changelog.Entry{
			Sequence:         seq,
			Reference:        u.Name,
			OldOID:           oldOID,
			NewOID:           newOID,
			Operation:        validUTF8(meta.Operation),
			Actor:            validUTF8(meta.Actor),
			RecordedAt:       recordedAt,
			Rewritten:        meta.Rewritten,
			Members:          slices.Clone(meta.Members),
			MembersTruncated: meta.MembersTruncated,
			Lands:            changelog.LandsOf(*meta, u.Name),
			LandInvocation:   changelog.LandInvocationOf(*meta, u.Name),
		})
	}

	return entries
}

// currentTargets returns the current targets of the named references of the
// repository. Absent references are missing from the map.
func (s *Store) currentTargets(ctx context.Context, q querier, repoID int64, names []string) (map[string]corestore.Target, error) {
	current := make(map[string]corestore.Target, len(names))

	for start := 0; start < len(names); start += maxNamesPerQuery {
		chunk := names[start:min(start+maxNamesPerQuery, len(names))]

		args := make([]any, 0, len(chunk)+1)
		args = append(args, repoID)
		placeholders := make([]string, len(chunk))
		for i, name := range chunk {
			placeholders[i] = "?"
			args = append(args, bytesArg([]byte(name)))
		}

		query := "SELECT name, target FROM graft_refs WHERE repo_id = ? AND name IN (" + strings.Join(placeholders, ", ") + ")"
		if err := readReferences(ctx, s, q, query, args, current); err != nil {
			return nil, err
		}
	}

	return current, nil
}

// readReferences runs a query of (name, target) rows and adds them to refs.
func readReferences(ctx context.Context, s *Store, q querier, query string, args []any, refs map[string]corestore.Target) error {
	rows, err := q.QueryContext(ctx, s.bind(query), args...)
	if err != nil {
		return fmt.Errorf("read references: %w", err)
	}
	defer rows.Close()

	for rows.Next() {
		var name []byte
		var target string
		if err := rows.Scan(&name, &target); err != nil {
			return fmt.Errorf("scan reference: %w", err)
		}
		refs[string(name)] = corestore.Target(target)
	}

	return rows.Err()
}

// ListChangesets implements corestore.MetaStore.
func (s *Store) ListChangesets(ctx context.Context, repoID int64, after, upTo uint64) ([]corestore.Changeset, error) {
	// The sequences are BIGINT: no sequence is above math.MaxInt64.
	if after >= math.MaxInt64 {
		return nil, nil
	}
	upTo = min(upTo, math.MaxInt64)
	if upTo <= after {
		return nil, nil
	}

	var changesets []corestore.Changeset
	err := s.withReadTx(ctx, func(tx *sql.Tx) error {
		changesets = nil

		rows, err := tx.QueryContext(ctx, s.bind(`
			SELECT seq, operation, actor, node_id, pack_key, pack_bytes, forced, created_at
			FROM graft_changesets
			WHERE repo_id = ? AND seq > ? AND seq <= ?
			ORDER BY seq
		`), repoID, int64(after), int64(upTo))
		if err != nil {
			return fmt.Errorf("list changesets: %w", err)
		}

		index := map[uint64]int{}
		for rows.Next() {
			var (
				seq        int64
				cs         corestore.Changeset
				packKey    sql.NullString
				createdRaw any
			)
			if err := rows.Scan(&seq, &cs.Operation, &cs.Actor, &cs.NodeID, &packKey, &cs.PackBytes, &cs.Forced, &createdRaw); err != nil {
				rows.Close()
				return fmt.Errorf("scan changeset: %w", err)
			}

			cs.RepoID = repoID
			cs.Seq = uint64(seq)
			cs.PackKey = packKey.String
			cs.CreatedAt, err = scanTime(createdRaw)
			if err != nil {
				rows.Close()
				return err
			}

			index[cs.Seq] = len(changesets)
			changesets = append(changesets, cs)
		}
		if err := rows.Err(); err != nil {
			rows.Close()
			return fmt.Errorf("list changesets: %w", err)
		}
		rows.Close()

		refRows, err := tx.QueryContext(ctx, s.bind(`
			SELECT seq, name, old_target, new_target
			FROM graft_changeset_refs
			WHERE repo_id = ? AND seq > ? AND seq <= ?
			ORDER BY seq, ordinal
		`), repoID, int64(after), int64(upTo))
		if err != nil {
			return fmt.Errorf("list changeset references: %w", err)
		}
		defer refRows.Close()

		for refRows.Next() {
			var (
				seq      int64
				name     []byte
				oldValue sql.NullString
				newValue sql.NullString
			)
			if err := refRows.Scan(&seq, &name, &oldValue, &newValue); err != nil {
				return fmt.Errorf("scan changeset reference: %w", err)
			}

			i, ok := index[uint64(seq)]
			if !ok {
				return fmt.Errorf("changeset reference of unknown sequence %d", seq)
			}

			changesets[i].Updates = append(changesets[i].Updates, corestore.AppliedUpdate{
				Name: string(name),
				Old:  corestore.Target(oldValue.String),
				New:  corestore.Target(newValue.String),
			})
		}

		return refRows.Err()
	})
	if err != nil {
		return nil, err
	}

	return changesets, nil
}