mesh-sdk/go/buildstep/trees.go

package buildstep

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"git.novox.be/novox/mesh-sdk/go/forgekey"
)

// ModuleTree is what a merge holds of one module directory: its tree id, the sha256 of its module.json and the sha256
// of each lock file it has (go.sum, package-lock.json), from which the checker and the indexer take the module's inputs
// (novox/hq ADR 0484 clause 3).
type ModuleTree struct {
	Tree     string            `json:"tree"`
	Manifest string            `json:"manifest"`
	Locks    map[string]string `json:"locks,omitempty"`
}

var lockFiles = []string{"go.sum", "package-lock.json"}

// ModuleTrees are the trees, in commit, of every directory of the workspace dir that holds a module.json, by directory
// (the repository's root is "."). The workspace is at commit, so the manifests and the lock files are read from it. env is
// the environment git runs with (nil for none). Both build modules' fetch steps answer it for a merge.
func ModuleTrees(ctx context.Context, run forgekey.Runner, env []string, dir, commit string) (map[string]ModuleTree, error) {
	r := run(ctx, env, "git", "-C", dir, "ls-files", "--", "module.json", "*/module.json")
	if r.Status != 0 || r.Err != "" {
		return nil, fmt.Errorf("git ls-files: %s", firstLine(r.Err+" "+r.Stderr))
	}
	trees := map[string]ModuleTree{}
	for _, l := range strings.Split(r.Stdout, "\n") {
		if l = strings.TrimSpace(l); l == "" {
			continue
		}
		mdir := filepath.ToSlash(filepath.Dir(l))
		spec := commit + ":" + mdir
		if mdir == "." {
			spec = commit + "^{tree}"
		}
		t := run(ctx, env, "git", "-C", dir, "rev-parse", spec)
		if t.Status != 0 || t.Err != "" {
			return nil, fmt.Errorf("git rev-parse %s: %s", spec, firstLine(t.Err+" "+t.Stderr))
		}
		mt := ModuleTree{Tree: strings.TrimSpace(t.Stdout)}
		raw, err := os.ReadFile(filepath.Join(dir, filepath.FromSlash(l)))
		if err != nil {
			return nil, err
		}
		mt.Manifest = sha256Hex(raw)
		for _, lock := range lockFiles {
			if raw, err := os.ReadFile(filepath.Join(dir, filepath.FromSlash(mdir), lock)); err == nil {
				if mt.Locks == nil {
					mt.Locks = map[string]string{}
				}
				mt.Locks[lock] = sha256Hex(raw)
			}
		}
		trees[mdir] = mt
	}
	return trees, nil
}

func sha256Hex(b []byte) string { h := sha256.Sum256(b); return hex.EncodeToString(h[:]) }