package bridge import ( "context" "encoding/json" "errors" "fmt" "strings" git "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/git" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-forge-bridge/forgemsg" ) // Caller calls a seat's verb by its manifest key (`seat:.`) with a JSON body and returns its answer: the // bridge's process calls through the bus as its own principal, its tools bundle through the runtime (stdio.Ask). type Caller func(ctx context.Context, key string, body any) (json.RawMessage, error) // GitKey is the manifest key of a verb of the seat `git` (novox/hq design 47 *The seat `git`*): the bridge reaches the // forge through the seat alone and names no module that holds it. func GitKey(verb string) string { return "seat:" + git.Seat + "." + verb } // askGit calls one verb of the seat `git` and decodes its answer into A. An answer the contract cannot type, or one // that says an error, is the call's error: a failed read is never read as none (design 47 *A failed read answers an // error*). func askGit[A any](ctx context.Context, call Caller, verb string, in any) (A, error) { var a A raw, err := call(ctx, GitKey(verb), in) if err != nil { return a, fmt.Errorf("the seat git did not answer %s: %w", verb, err) } if err := json.Unmarshal(raw, &a); err != nil { return a, fmt.Errorf("the seat git's answer of %s is not its contract's: %w", verb, err) } var said struct { Error string `json:"error"` } _ = json.Unmarshal(raw, &said) if said.Error != "" { return a, fmt.Errorf("the seat git refused %s: %s", verb, said.Error) } return a, nil } // repository is `/`, as the seat names a repository. func repository(owner, repo string) string { return owner + "/" + repo } // TreesVia asks the seat `git` for a commit's trees (verb trees). func TreesVia(ctx context.Context, call Caller) Trees { return func(owner, repo, sha string) (string, map[string]string, error) { a, err := askGit[git.TreesAnswer](ctx, call, git.VerbTrees, git.TreesInput{Repository: repository(owner, repo), Commit: sha}) if err != nil { return "", nil, err } if a.Root == "" { return "", nil, fmt.Errorf("the seat git's trees of %s at %s name no root tree", repository(owner, repo), sha) } return a.Root, a.Trees, nil } } // FilesVia asks the seat `git` for one file at a ref (verb file). A file the seat says is absent is ErrNotFound; an // answer that says neither absent nor content is an error, never an empty file. func FilesVia(ctx context.Context, call Caller) Files { return func(owner, repo, path, ref string) ([]byte, error) { raw, err := call(ctx, GitKey(git.VerbFile), git.FileInput{Repository: repository(owner, repo), Path: path, Ref: ref}) if err != nil { return nil, fmt.Errorf("the seat git did not answer file: %w", err) } var a struct { git.FileAnswer Content *string `json:"content"` } if err := json.Unmarshal(raw, &a); err != nil { return nil, fmt.Errorf("the seat git's answer of file is not its contract's: %w", err) } switch { case a.Error != "": return nil, fmt.Errorf("the seat git refused file %s at %s: %s", path, ref, a.Error) case a.Absent: return nil, fmt.Errorf("%w: %s at %s in %s", ErrNotFound, path, ref, repository(owner, repo)) case a.Content == nil: return nil, fmt.Errorf("the seat git's file %s at %s says neither its content nor that it is absent", path, ref) } return []byte(*a.Content), nil } } // errNoAnswer is a read whose answer carries nothing the contract says it must. var errNoAnswer = errors.New("the seat git's answer carries nothing") // MergedMessage is the merged message of a merge into the branch base, asked again: built as the bridge builds the one // it writes on FORGE for the branch's move (MoveMessage), from the pull request's owner, repository, number, branch, head, // merge commit and base, which the seat git's verb pull answers. It reads the forge for every module directory (no kept // inputs). func MergedMessage(owner, repo string, number int, branch, head, merge, base string, trees Trees, files Files) (Message, error) { if number <= 0 || branch == "" || base == "" || !sha40.MatchString(head) { return Message{}, unreadable("bridge_merged_message", "%s#%d names no branch, base or 40-hex head", repository(owner, repo), number) } f := forgemsg.Forge{Kind: forgemsg.ForgeMerged, Repository: repository(owner, repo), Branch: branch, Number: number, Head: head, Merge: merge, Base: base} return landed(repository(owner, repo)+"#"+fmt.Sprint(number), f, merge, trees, files, nil) } // splitRepository is a `/` cut in two, refusing anything else. func splitRepository(repository string) (string, string, error) { owner, name, ok := strings.Cut(strings.TrimSpace(repository), "/") if !ok || owner == "" || name == "" || strings.Contains(name, "/") { return "", "", fmt.Errorf("repository %q is not /", repository) } return owner, name, nil }