git

type Actor struct {
	Principal  string
	Credential string
	// Source is "push" or "op".
	Source string
	// Stack is the stack whose op moved the ref ("" for a push).
	Stack string
}

type ErrRefMoved struct {
	Name    plumbing.ReferenceName
	Current plumbing.Hash
}

type Limits struct {
	// MaxPackBytes caps one request body (a push's pack, a fetch's haves).
	MaxPackBytes int64
	// MaxObjectBytes caps one object (a file's bytes).
	MaxObjectBytes int64
	// MaxObjects caps the objects in one pack.
	MaxObjects int
	// MaxRepoBytes caps a repository's stored objects, the new ones included.
	MaxRepoBytes int64
	// TextOnly refuses a blob that is not valid UTF-8 (or holds a NUL), a
	// symlink, an executable and a submodule.
	TextOnly bool
}

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

type Meta struct {
	ID        string
	Tenant    string
	Name      string
	Principal string
	CreatedBy string
	// PolicyPush is "stack" (a push is accepted only when the tenant's
	// `_git` stack answers ok) or "open" (no lane).
	PolicyPush string
}

type Ref struct {
	Name plumbing.ReferenceName
	Hash plumbing.Hash
}

type RefUpdate struct {
	Name plumbing.ReferenceName
	Old  plumbing.Hash
	New  plumbing.Hash
}

type Repo interface {
	storer.EncodedObjectStorer

	// Meta describes the repository.
	Meta() Meta
	// Head is the ref HEAD points at (refs/heads/main): what a clone checks
	// out, and the branch a push may not delete.
	Head() plumbing.ReferenceName
	// Refs lists every ref, sorted by name.
	Refs(ctx context.Context) ([]Ref, error)
	// UpdateRefs moves refs by compare-and-swap: every update's Old must be
	// the ref's current value (plumbing.ZeroHash for a ref that does not
	// exist), or nothing moves and the first mismatch is returned as
	// *ErrRefMoved. A zero New deletes the ref.
	UpdateRefs(ctx context.Context, updates []RefUpdate, by Actor) error
	// Stage opens a staging area for one push: the pack's objects land
	// there, are checked, and only the reachable ones are kept.
	Stage() Staging
}

type RepoLoader interface {
	Open(ctx context.Context, tenant, name string) (repo Repo, found bool, err error)
}

type Staging interface {
	storer.EncodedObjectStorer

	// Staged lists the objects the pack delivered.
	Staged() []plumbing.Hash
	// Commit keeps exactly the listed objects (those reachable from the
	// refs the push moves); the rest are dropped. ErrRepoTooLarge when the
	// repository would pass its cap.
	Commit(ctx context.Context, keep []plumbing.Hash) error
}

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