package bridge import ( "context" "encoding/json" "fmt" "strings" git "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/git" ) // 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 } // 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 }