chore: copy over types and builder from dep-graph-go

Author: thomasschafer

internal/depgraph/builder.go

@@ -0,0 +1,138 @@
+// TODO(uv): this is copied from the `dep-graph-go` library. We should open-source that code and import it here.
+package depgraph
+
+import (
+	"errors"
+	"fmt"
+)
+
+type Builder struct {
+	schemaVersion string
+	rootNodeID    string
+	rootPkgID     string
+	pkgManager    *PkgManager
+	pkgs          map[string]*Pkg
+	nodes         map[string]*Node
+}
+
+const (
+	schemaVersion = "1.3.0"
+	rootNodeID    = "root-node"
+)
+
+func NewBuilder(pkgManager *PkgManager, rootPkg *PkgInfo) (*Builder, error) {
+	if pkgManager == nil {
+		return nil, errors.New("cannot create builder without a package manager")
+	}
+
+	if rootPkg == nil {
+		rootPkg = &PkgInfo{
+			Name:    "_root",
+			Version: "0.0.0",
+		}
+	}
+
+	b := &Builder{
+		schemaVersion: schemaVersion,
+		pkgManager:    pkgManager,
+		rootNodeID:    rootNodeID,
+		rootPkgID:     getPkgID(rootPkg),
+		pkgs:          make(map[string]*Pkg),
+		nodes:         make(map[string]*Node),
+	}
+
+	b.addNode(b.rootNodeID, rootPkg)
+
+	return b, nil
+}
+
+func (b *Builder) Build() *DepGraph {
+	dg := &DepGraph{
+		SchemaVersion: b.schemaVersion,
+		PkgManager:    *b.pkgManager,
+		Pkgs:          b.GetPkgs(),
+		rootPkg:       b.pkgs[b.rootPkgID],
+		pkgIdx:        make(map[string]*Pkg),
+		Graph: Graph{
+			RootNodeID: b.rootNodeID,
+			Nodes:      make([]Node, 0, len(b.nodes)),
+		},
+	}
+
+	for nodeID, node := range b.nodes {
+		pkg := b.pkgs[node.PkgID]
+		dg.pkgIdx[pkg.ID] = pkg
+
+		dg.Graph.Nodes = append(dg.Graph.Nodes, Node{
+			NodeID: nodeID,
+			PkgID:  node.PkgID,
+			Deps:   node.Deps,
+		})
+	}
+
+	return dg
+}
+
+func (b *Builder) GetPkgManager() *PkgManager {
+	return b.pkgManager
+}
+
+func (b *Builder) GetPkgs() []Pkg {
+	pkgs := make([]Pkg, 0, len(b.pkgs))
+
+	for _, pkgInfo := range b.pkgs {
+		pkgs = append(pkgs, *pkgInfo)
+	}
+
+	return pkgs
+}
+
+func (b *Builder) GetRootNode() *Node {
+	return b.nodes[b.rootNodeID]
+}
+
+func (b *Builder) AddNode(nodeID string, pkgInfo *PkgInfo) *Node {
+	return b.addNode(nodeID, pkgInfo)
+}
+
+func (b *Builder) addNode(nodeID string, pkgInfo *PkgInfo) *Node {
+	if n, ok := b.nodes[nodeID]; ok {
+		return n
+	}
+	pkgID := getPkgID(pkgInfo)
+
+	b.pkgs[pkgID] = &Pkg{
+		ID:   pkgID,
+		Info: *pkgInfo,
+	}
+
+	b.nodes[nodeID] = &Node{
+		NodeID: nodeID,
+		PkgID:  pkgID,
+		Deps:   make([]Dependency, 0),
+	}
+
+	return b.nodes[nodeID]
+}
+
+func (b *Builder) ConnectNodes(parentNodeID, childNodeID string) error {
+	parentNode, ok := b.nodes[parentNodeID]
+	if !ok {
+		return fmt.Errorf("cound not find parent node %s", parentNodeID)
+	}
+
+	childNode, ok := b.nodes[childNodeID]
+	if !ok {
+		return fmt.Errorf("cound not find child node %s", childNodeID)
+	}
+
+	parentNode.Deps = append(parentNode.Deps, Dependency{
+		NodeID: childNode.NodeID,
+	})
+
+	return nil
+}
+
+func getPkgID(pkgInfo *PkgInfo) string {
+	return fmt.Sprintf("%s@%s", pkgInfo.Name, pkgInfo.Version)
+}

internal/depgraph/depgraph.go

@@ -0,0 +1,139 @@
+// TODO(uv): this is copied from the `dep-graph-go` library. We should open-source that code and import it here.
+package depgraph
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+type (
+	DepGraph struct {
+		SchemaVersion string     `json:"schemaVersion"`
+		PkgManager    PkgManager `json:"pkgManager"`
+		Pkgs          []Pkg      `json:"pkgs"`
+		Graph         Graph      `json:"graph"`
+
+		rootPkg *Pkg            `json:"-"`
+		pkgIdx  map[string]*Pkg `json:"-"`
+	}
+
+	PkgManager struct {
+		Name         string       `json:"name"`
+		Version      string       `json:"version,omitempty"`
+		Repositories []Repository `json:"repositories,omitempty"`
+	}
+
+	Repository struct {
+		Alias string `json:"alias"`
+	}
+
+	Pkg struct {
+		ID   string  `json:"id"`
+		Info PkgInfo `json:"info"`
+	}
+
+	PkgInfo struct {
+		Name       string `json:"name"`
+		Version    string `json:"version,omitempty"`
+		PackageURL string `json:"purl,omitempty"`
+	}
+
+	Graph struct {
+		RootNodeID string `json:"rootNodeId"`
+		Nodes      []Node `json:"nodes"`
+	}
+
+	Node struct {
+		NodeID string       `json:"nodeId"`
+		PkgID  string       `json:"pkgId"`
+		Info   *NodeInfo    `json:"info,omitempty"`
+		Deps   []Dependency `json:"deps"`
+	}
+
+	NodeInfo struct {
+		VersionProvenance *VersionProvenance `json:"versionProvenance,omitempty"`
+		Labels            map[string]string  `json:"labels,omitempty"`
+	}
+
+	Dependency struct {
+		NodeID string `json:"nodeId"`
+	}
+
+	VersionProvenance struct {
+		Type     string    `json:"type"`
+		Location string    `json:"location"`
+		Property *Property `json:"property,omitempty"`
+	}
+
+	Property struct {
+		Name string `json:"name"`
+	}
+)
+
+func New() *DepGraph {
+	return &DepGraph{
+		Pkgs: make([]Pkg, 0),
+		Graph: Graph{
+			Nodes: make([]Node, 0),
+		},
+	}
+}
+
+func UnmarshalJSON(data []byte) (*DepGraph, error) {
+	dg := new(DepGraph)
+	dec := json.NewDecoder(bytes.NewReader(data))
+	dec.DisallowUnknownFields()
+
+	if err := dec.Decode(&dg); err != nil {
+		return nil, fmt.Errorf("could not decode DepGraph: %w", err)
+	}
+
+	return dg, nil
+}
+
+func (dg *DepGraph) MarshalJSON() ([]byte, error) {
+	data, err := json.Marshal(*dg)
+	if err != nil {
+		return nil, fmt.Errorf("could not encode DepGraph: %w", err)
+	}
+	return data, nil
+}
+
+func (dg *DepGraph) GetRootPkg() *Pkg {
+	if dg.rootPkg != nil {
+		return dg.rootPkg
+	}
+
+	for _, dep := range dg.Graph.Nodes {
+		if dep.NodeID != dg.Graph.RootNodeID {
+			continue
+		}
+
+		for _, pkg := range dg.Pkgs {
+			if pkg.ID != dep.PkgID {
+				continue
+			}
+
+			dg.rootPkg = &pkg
+			break
+		}
+	}
+
+	return dg.rootPkg
+}
+
+func (dg *DepGraph) GetPkg(id string) (*Pkg, bool) {
+	if dg.pkgIdx == nil {
+		dg.pkgIdx = make(map[string]*Pkg)
+		for _, pkg := range dg.Pkgs {
+			dg.pkgIdx[pkg.ID] = &pkg
+		}
+	}
+
+	if pkg, ok := dg.pkgIdx[id]; ok {
+		return pkg, ok
+	}
+
+	return nil, false
+}