The delivery repository's contracts and SDK live under modules/ as mesh-delivery-contracts and mesh-delivery-sdk, their Go module paths renamed to match the folders (the TypeScript names already did), and every importer in mesh-delivery, mesh-catalog, mesh-host, mesh-tools and mesh-sdk follows in the same group: a design as it should be, one path per module, checked by the group's check building every importer. Builds: design 47 G §427, §88 Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
85 lines
3.0 KiB
Go
85 lines
3.0 KiB
Go
package index
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"path"
|
|
"strings"
|
|
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshcatalogclient"
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog"
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-forge-bridge/forgemsg"
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/trunk"
|
|
)
|
|
|
|
// From R4e the indexer lists a repository's modules from what it holds itself (novox/hq ADR 0501 clause 6, issue 1851):
|
|
// a merged message's manifests name the modules of the merge, and the modules bucket names the modules it wrote before,
|
|
// with their repository and directory. The controller's build records name none of them (ADR 0453 clause 5 keeps only
|
|
// the builder's own input from them until R4g, builds.go).
|
|
|
|
// manifestModule is the module a manifest names itself (its `module`), or "" when it names none or is not JSON. Only the
|
|
// name is read here; the manifest is read whole by the catalogue's parser (inputs.go).
|
|
func manifestModule(raw string) string {
|
|
var m struct {
|
|
Module string `json:"module"`
|
|
}
|
|
if json.Unmarshal([]byte(raw), &m) != nil {
|
|
return ""
|
|
}
|
|
return m.Module
|
|
}
|
|
|
|
// heldModules are the values the modules bucket holds, by key (the module's name). A value that is not a module is left
|
|
// out and said.
|
|
func (ix *Indexer) heldModules(ctx context.Context) (map[string]meshcatalog.ModulesByModuleValue, error) {
|
|
out := map[string]meshcatalog.ModulesByModuleValue{}
|
|
if ix.Modules == nil {
|
|
return out, nil
|
|
}
|
|
keys, err := ix.Modules.Keys(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("listing the modules: %w", err)
|
|
}
|
|
for _, key := range keys {
|
|
value, _, found, err := ix.Modules.Get(ctx, key)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("modules.%s: %w", key, err)
|
|
}
|
|
if !found {
|
|
continue
|
|
}
|
|
m, err := meshcatalogclient.DecodeModule(value)
|
|
if err != nil {
|
|
ix.logf("modules.%s holds what is not a module, left: %v", key, err)
|
|
continue
|
|
}
|
|
out[key] = m
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// moduleAt is the module whose directory in the repository is dir, as the modules bucket holds it.
|
|
func moduleAt(held map[string]meshcatalog.ModulesByModuleValue, repository, dir string) (string, bool) {
|
|
want := pathOf(strings.Trim(dir, "/"))
|
|
for name, m := range held {
|
|
if m.Path == want && trunk.SameRepository(m.Repository, repository) {
|
|
return name, true
|
|
}
|
|
}
|
|
return "", false
|
|
}
|
|
|
|
// moduleOfDir is the module of a changed directory of a pull request: the module its manifest in the message names, else
|
|
// the one the modules bucket holds at that directory of the repository, else the directory's last element (the
|
|
// catalogue's rule for nearly every manifest).
|
|
func moduleOfDir(held map[string]meshcatalog.ModulesByModuleValue, f forgemsg.Forge, dir string) string {
|
|
if name := manifestModule(f.Manifests[dir]); name != "" {
|
|
return name
|
|
}
|
|
if name, ok := moduleAt(held, f.Repository, dir); ok {
|
|
return name
|
|
}
|
|
return path.Base(strings.Trim(dir, "/"))
|
|
}
|