dalgo2ghingitdb

type BatchingGitHubDB ¶

type BatchingGitHubDB struct {
	// contains filtered or unexported fields
}

BatchingGitHubDB wraps a githubDB so that RunReadwriteTransaction buffers every tx.Set / tx.Insert / tx.Delete call inside the worker, then emits exactly one commit via the Git Data API when the worker returns nil.

Reads (Get, RunReadonlyTransaction, ExecuteQuery*) delegate to the underlying githubDB unchanged — they read the pre-tx state from remote and do not observe buffered writes (set-mode callers fetch matches in a separate read-only pass before opening the write tx, so this limitation does not affect them).

Use this in place of the per-file github DB when an operation may touch multiple records — `update --from --where`, `delete --from --where`, `update --from --all`, `delete --from --all`. Single-record operations already produce one commit through the Contents API and should keep using the plain githubDB.

func NewBatchingGitHubDB(cfg Config, def *ingitdb.Definition, commitMessage string) (*BatchingGitHubDB, error)

func (db BatchingGitHubDB) Adapter() dal.Adapter

func (db BatchingGitHubDB) ExecuteQueryToRecordsReader(ctx context.Context, query dal.Query) (dal.RecordsReader, error)

func (db BatchingGitHubDB) ExecuteQueryToRecordsetReader(ctx context.Context, query dal.Query, options ...recordset.Option) (dal.RecordsetReader, error)

func (db BatchingGitHubDB) Exists(ctx context.Context, key *dal.Key) (bool, error)

func (db BatchingGitHubDB) Get(ctx context.Context, record dal.Record) error

func (db BatchingGitHubDB) GetMulti(ctx context.Context, records []dal.Record) error

func (db BatchingGitHubDB) ID() string

func (db BatchingGitHubDB) RunReadonlyTransaction(ctx context.Context, f dal.ROTxWorker, options ...dal.TransactionOption) error

func (db *BatchingGitHubDB) RunReadwriteTransaction(ctx context.Context, f dal.RWTxWorker, options ...dal.TransactionOption) error

func (db BatchingGitHubDB) Schema() dal.Schema

type Config ¶

type Config struct {
	Owner string
	Repo  string
	Ref   string

	// Token is a static GitHub token (e.g. a classic/fine-grained PAT).
	// If TokenProvider is nil and Token is non-empty, Token is wrapped in
	// StaticTokenProvider automatically, preserving legacy behavior.
	Token string

	// TokenProvider, when set, supplies the token per request and takes
	// precedence over Token. Use it to inject rotating credentials such as
	// short-lived GitHub App installation tokens.
	TokenProvider TokenProvider

	APIBaseURL string
	HTTPClient *http.Client
}

Config defines connection settings for reading an inGitDB repository from GitHub.

type FileReader ¶

type FileReader interface {
	ReadFile(ctx context.Context, path string) (content []byte, found bool, err error)
	ListDirectory(ctx context.Context, dirPath string) (entries []string, err error)
}

FileReader reads repository files by path from GitHub.

func NewGitHubFileReader(cfg Config) (FileReader, error)

type TokenProvider ¶ added in v0.1.0

type TokenProvider interface {
	Token(ctx context.Context) (string, error)
}

TokenProvider supplies the GitHub token used to authorize API calls. It is invoked once per outgoing HTTP request, so implementations can rotate tokens (e.g. mint short-lived GitHub App installation tokens on demand) without rebuilding the adapter. Returning an empty token with a nil error sends the request unauthenticated (fine for public-repo reads).

See docs/roadmaps/ovdb-access-tokens-grants.md in sneat-co/backstage (Decision 3.4): the sneat-go backend injects a provider that mints 1-hour installation tokens with an in-memory cache; CLI/dev injects StaticTokenProvider with a PAT.

func StaticTokenProvider(token string) TokenProvider

type TokenProviderFunc ¶ added in v0.1.0

type TokenProviderFunc func(ctx context.Context) (string, error)

TokenProviderFunc adapts a plain function to the TokenProvider interface.

func (f TokenProviderFunc) Token(ctx context.Context) (string, error)

type TreeChange ¶

type TreeChange struct {
	Path    string
	Content []byte
}

TreeChange describes a single path modification within a tree. Content nil means "delete the file at Path"; non-nil Content means "set the file at Path to this content" (creating it if absent).

type TreeWriter ¶

type TreeWriter struct {
	// contains filtered or unexported fields
}

TreeWriter performs atomic multi-file commits on a remote GitHub repository via the Git Data API (blobs / trees / commits / refs). Unlike the per-file Contents API used by FileReader.writeFile / deleteFile (which each produce their own commit), TreeWriter bundles arbitrary file modifications into a single commit — satisfying spec REQ:one-commit-per-write for multi-file operations such as `drop collection`.

func NewTreeWriter(cfg Config) (*TreeWriter, error)

func (w *TreeWriter) CommitChanges(ctx context.Context, message string, changes []TreeChange) (string, error)

func (w *TreeWriter) ListFilesUnder(ctx context.Context, dir string) ([]string, error)