feat(api): add pagination to catalog access search and config tree traversal

Implements proper pagination by counting total results before applying limit/offset. Adds new ConfigTree function to build hierarchical config relationships including parents, children, and related configs.

Author: moshloop

query/config_access.go

@@ -36,10 +36,17 @@ func FindCatalogAccess(ctx context.Context, req CatalogAccessSearchRequest) (res
 		q = q.Where("config_id IN ?", configIDs)
 	}
 
-	if err := q.Find(&output.Access).Error; err != nil {
+	if err := q.Count(&output.Total).Error; err != nil {
+		return nil, err
+	}
+	if output.Total == 0 {
+		timer.Results(output.Access)
+		return &output, nil
+	}
+
+	if err := q.Limit(req.PageSize).Offset((req.Page - 1) * req.PageSize).Find(&output.Access).Error; err != nil {
 		return nil, err
 	}
-	output.Total = int64(len(output.Access))
 	timer.Results(output.Access)
 	return &output, nil
 }

query/config_tree.go

@@ -0,0 +1,242 @@
+package query
+
+import (
+	"strings"
+
+	"github.com/flanksource/duty/context"
+	"github.com/flanksource/duty/models"
+	"github.com/google/uuid"
+	"github.com/samber/lo"
+)
+
+type ConfigTreeNode struct {
+	models.ConfigItem `json:",inline"`
+	EdgeType          string            `json:"edgeType,omitempty"`
+	Relation          string            `json:"relation,omitempty"`
+	Children          []*ConfigTreeNode `json:"children,omitempty"`
+}
+
+type ConfigTreeOptions struct {
+	Direction RelationDirection
+	Incoming  RelationType
+	Outgoing  RelationType
+}
+
+func ConfigTree(ctx context.Context, configID uuid.UUID, opts ConfigTreeOptions) (*ConfigTreeNode, error) {
+	config, err := GetCachedConfig(ctx, configID.String())
+	if err != nil {
+		return nil, err
+	}
+	if config == nil {
+		return nil, nil
+	}
+
+	parents := resolveParentsFromPath(ctx, config)
+
+	childIDs, err := ExpandConfigChildren(ctx, []uuid.UUID{config.ID})
+	if err != nil {
+		return nil, err
+	}
+	childIDs = lo.Filter(childIDs, func(id uuid.UUID, _ int) bool { return id != config.ID })
+
+	var children []models.ConfigItem
+	if len(childIDs) > 0 {
+		children, err = GetConfigsByIDs(ctx, childIDs)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if opts.Direction == "" {
+		opts.Direction = All
+	}
+	relType := Hard
+	if opts.Incoming != "" {
+		relType = opts.Incoming
+	}
+	outType := Hard
+	if opts.Outgoing != "" {
+		outType = opts.Outgoing
+	}
+
+	related, err := GetRelatedConfigs(ctx, RelationQuery{
+		ID:       config.ID,
+		Relation: opts.Direction,
+		Incoming: relType,
+		Outgoing: outType,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return buildConfigTree(config, parents, children, related), nil
+}
+
+func resolveParentsFromPath(ctx context.Context, config *models.ConfigItem) []models.ConfigItem {
+	if config.Path == "" {
+		return nil
+	}
+	segments := strings.Split(config.Path, ".")
+	var parentIDs []uuid.UUID
+	for _, seg := range segments {
+		id, err := uuid.Parse(seg)
+		if err != nil || id == config.ID {
+			continue
+		}
+		parentIDs = append(parentIDs, id)
+	}
+	if len(parentIDs) == 0 {
+		return nil
+	}
+	items, err := GetConfigsByIDs(ctx, parentIDs)
+	if err != nil || len(items) == 0 {
+		return nil
+	}
+	byID := make(map[uuid.UUID]models.ConfigItem, len(items))
+	for _, ci := range items {
+		byID[ci.ID] = ci
+	}
+	var parents []models.ConfigItem
+	for _, id := range parentIDs {
+		if ci, ok := byID[id]; ok {
+			parents = append(parents, ci)
+		}
+	}
+	return parents
+}
+
+func ExpandConfigChildren(ctx context.Context, ids []uuid.UUID) ([]uuid.UUID, error) {
+	allIDs := make(map[uuid.UUID]struct{}, len(ids))
+	for _, id := range ids {
+		allIDs[id] = struct{}{}
+	}
+	for _, id := range ids {
+		var children []uuid.UUID
+		if err := ctx.DB().Raw("SELECT child_id FROM lookup_config_children(?, -1)", id.String()).
+			Scan(&children).Error; err != nil {
+			return nil, err
+		}
+		for _, child := range children {
+			allIDs[child] = struct{}{}
+		}
+	}
+	return lo.Keys(allIDs), nil
+}
+
+type ptrNode struct {
+	models.ConfigItem
+	edgeType string
+	relation string
+	children []*ptrNode
+}
+
+func buildConfigTree(config *models.ConfigItem, parents []models.ConfigItem, children []models.ConfigItem, related []RelatedConfig) *ConfigTreeNode {
+	nodes := make(map[uuid.UUID]*ptrNode)
+
+	for _, p := range parents {
+		nodes[p.ID] = &ptrNode{ConfigItem: p, edgeType: "parent"}
+	}
+
+	targetNode := &ptrNode{ConfigItem: *config, edgeType: "target"}
+	nodes[config.ID] = targetNode
+
+	if len(parents) > 0 {
+		for i := 0; i < len(parents)-1; i++ {
+			nodes[parents[i].ID].children = append(nodes[parents[i].ID].children, nodes[parents[i+1].ID])
+		}
+		nodes[parents[len(parents)-1].ID].children = append(nodes[parents[len(parents)-1].ID].children, targetNode)
+	}
+
+	for _, c := range children {
+		nodes[c.ID] = &ptrNode{ConfigItem: c, edgeType: "child"}
+	}
+	for _, c := range children {
+		parentID := lo.FromPtr(c.ParentID)
+		if parent, ok := nodes[parentID]; ok {
+			parent.children = append(parent.children, nodes[c.ID])
+		} else {
+			targetNode.children = append(targetNode.children, nodes[c.ID])
+		}
+	}
+
+	parentIDs := make(map[uuid.UUID]bool, len(parents))
+	for _, p := range parents {
+		parentIDs[p.ID] = true
+	}
+
+	for _, rc := range related {
+		if parentIDs[rc.ID] || rc.ID == config.ID {
+			continue
+		}
+		if _, exists := nodes[rc.ID]; !exists {
+			nodes[rc.ID] = &ptrNode{
+				ConfigItem: relatedToConfigItem(rc),
+				edgeType:   "related",
+				relation:   rc.Relation,
+			}
+		}
+	}
+
+	wired := make(map[uuid.UUID]bool)
+	for _, rc := range related {
+		if parentIDs[rc.ID] || rc.ID == config.ID || wired[rc.ID] {
+			continue
+		}
+		wired[rc.ID] = true
+		node := nodes[rc.ID]
+		if rc.Path != "" {
+			segments := strings.Split(rc.Path, ".")
+			if parentStr := segments[len(segments)-1]; parentStr != "" {
+				if pid, err := uuid.Parse(parentStr); err == nil {
+					if parent, ok := nodes[pid]; ok && parent != node && !parentIDs[pid] {
+						parent.children = append(parent.children, node)
+						continue
+					}
+				}
+			}
+		}
+		targetNode.children = append(targetNode.children, node)
+	}
+
+	var root *ptrNode
+	if len(parents) > 0 {
+		root = nodes[parents[0].ID]
+	} else {
+		root = targetNode
+	}
+
+	return toConfigTreeNode(root, make(map[*ptrNode]bool))
+}
+
+func toConfigTreeNode(n *ptrNode, visited map[*ptrNode]bool) *ConfigTreeNode {
+	result := &ConfigTreeNode{
+		ConfigItem: n.ConfigItem,
+		EdgeType:   n.edgeType,
+		Relation:   n.relation,
+	}
+	if visited[n] {
+		return result
+	}
+	visited[n] = true
+	for _, c := range n.children {
+		result.Children = append(result.Children, toConfigTreeNode(c, visited))
+	}
+	return result
+}
+
+func relatedToConfigItem(rc RelatedConfig) models.ConfigItem {
+	ci := models.ConfigItem{
+		ID: rc.ID,
+	}
+	ci.Name = &rc.Name
+	ci.Type = &rc.Type
+	ci.Tags = rc.Tags
+	ci.Status = rc.Status
+	ci.Health = rc.Health
+	ci.Path = rc.Path
+	ci.CreatedAt = rc.CreatedAt
+	ci.UpdatedAt = &rc.UpdatedAt
+	ci.DeletedAt = rc.DeletedAt
+	ci.AgentID = rc.AgentID
+	return ci
+}