STAC-24504: fix domain/layer mapping for topology inspect

Author: deontaljaard

cmd/topology/topology_inspect.go

@@ -154,15 +154,13 @@ type Component struct {
 	Properties  map[string]interface{} `json:"properties"`
 	Layer       map[string]interface{} `json:"layer"`
 	Domain      map[string]interface{} `json:"domain"`
-	Environment map[string]interface{} `json:"environment,omitempty"`
 	Link        string                 `json:"link"`
 }
 
 type ComponentMetadata struct {
 	ComponentTypes map[string]string
-	Layers         map[int64]string
-	Domains        map[int64]string
-	Environments   map[int64]string
+	Layers         map[string]string
+	Domains        map[string]string
 }
 
 // handleSnapshotError checks if the response is a typed error by examining the _type discriminator
@@ -255,31 +253,20 @@ func parseSnapshotResponse(
 // all metadata categories in a single loop.
 var metadataFieldMapping = []struct {
 	field  string
-	setter func(*ComponentMetadata, interface{}) error
+	setter func(*ComponentMetadata, interface{})
 }{
-	{"componentTypes", parseComponentTypesField},
-	{"layers", func(m *ComponentMetadata, val interface{}) error {
-		m.Layers = parseMetadataField(val)
-		return nil
-	}},
-	{"domains", func(m *ComponentMetadata, val interface{}) error {
-		m.Domains = parseMetadataField(val)
-		return nil
-	}},
-	{"environments", func(m *ComponentMetadata, val interface{}) error {
-		m.Environments = parseMetadataField(val)
-		return nil
-	}},
+	{"componentTypes", func(m *ComponentMetadata, val interface{}) { m.ComponentTypes = parseMetadataByIdentifier(val) }},
+	{"layers", func(m *ComponentMetadata, val interface{}) { m.Layers = parseMetadataByIdentifier(val) }},
+	{"domains", func(m *ComponentMetadata, val interface{}) { m.Domains = parseMetadataByIdentifier(val) }},
 }
 
-// parseMetadata extracts component type, layer, domain, and environment metadata
+// parseMetadata extracts component type, layer, and domain metadata
 // from the opaque Snapshot response using a table-driven approach.
 func parseMetadata(respMap map[string]interface{}) ComponentMetadata {
 	metadata := ComponentMetadata{
 		ComponentTypes: make(map[string]string),
-		Layers:         make(map[int64]string),
-		Domains:        make(map[int64]string),
-		Environments:   make(map[int64]string),
+		Layers:         make(map[string]string),
+		Domains:        make(map[string]string),
 	}
 
 	metadataMap, ok := respMap["metadata"].(map[string]interface{})
@@ -289,63 +276,32 @@ func parseMetadata(respMap map[string]interface{}) ComponentMetadata {
 
 	for _, mapping := range metadataFieldMapping {
 		if fieldValue, ok := metadataMap[mapping.field]; ok {
-			mapping.setter(&metadata, fieldValue) //nolint:errcheck
+			mapping.setter(&metadata, fieldValue)
 		}
 	}
 
 	return metadata
 }
 
-// parseComponentTypesField extracts component types from metadata, using identifier as key
-func parseComponentTypesField(m *ComponentMetadata, metadataValue interface{}) error {
-	if metadataValue == nil {
-		return nil
-	}
-
-	items, ok := metadataValue.([]interface{})
-	if !ok {
-		return nil
-	}
-
-	for _, item := range items {
-		if itemMap, ok := item.(map[string]interface{}); ok {
-			var key string
-			if identifier, ok := itemMap["identifier"].(string); ok {
-				key = identifier
-			} else {
-				continue
-			}
-
-			if name, ok := itemMap["name"].(string); ok {
-				m.ComponentTypes[key] = name
-			}
-		}
-	}
-
-	return nil
-}
-
-// parseMetadataField extracts id/name pairs from a metadata field.
-// Each item in the slice should have "id" and "name" fields.
-func parseMetadataField(metadataValue interface{}) map[int64]string {
-	result := make(map[int64]string)
+// parseMetadataByIdentifier extracts metadata items by identifier.
+func parseMetadataByIdentifier(metadataValue interface{}) map[string]string {
+	result := make(map[string]string)
 
 	if metadataValue == nil {
 		return result
 	}
 
-	// The JSON decoder produces []interface{} for arrays
 	items, ok := metadataValue.([]interface{})
 	if !ok {
 		return result
 	}
 
 	for _, item := range items {
 		if itemMap, ok := item.(map[string]interface{}); ok {
-			id, idOk := itemMap["id"].(float64)
+			identifier, idOk := itemMap["identifier"].(string)
 			name, nameOk := itemMap["name"].(string)
 			if idOk && nameOk {
-				result[int64(id)] = name
+				result[identifier] = name
 			}
 		}
 	}
@@ -400,10 +356,9 @@ func parseComponentFromMap(compMap map[string]interface{}, metadata ComponentMet
 		comp.Properties = propertiesRaw
 	}
 
-	// Parse layer, domain, and environment references
-	comp.Layer = parseComponentReference(compMap, "layer", metadata.Layers)
-	comp.Domain = parseComponentReference(compMap, "domain", metadata.Domains)
-	comp.Environment = parseComponentReference(compMap, "environment", metadata.Environments)
+	// Parse layer and domain references
+	comp.Layer = parseComponentReference(compMap, "layerIdentifier", metadata.Layers)
+	comp.Domain = parseComponentReference(compMap, "domainIdentifier", metadata.Domains)
 
 	// Build link
 	if len(comp.Identifiers) > 0 {
@@ -413,19 +368,18 @@ func parseComponentFromMap(compMap map[string]interface{}, metadata ComponentMet
 	return comp
 }
 
-// parseComponentReference extracts a reference field (layer, domain, or environment)
+// parseComponentReference extracts a reference field (layer or domain)
 // from a component and looks up its name in the provided metadata map.
-// Returns a map with "id" and "name" keys, or nil if the field is not present.
-func parseComponentReference(compMap map[string]interface{}, fieldName string, metadataMap map[int64]string) map[string]interface{} {
-	if refID, ok := compMap[fieldName].(float64); ok {
-		refIDInt := int64(refID)
+// Returns a map with "identifier" and "name" keys, or nil if the field is not present.
+func parseComponentReference(compMap map[string]interface{}, identifierFieldName string, metadataMap map[string]string) map[string]interface{} {
+	if refIdentifier, ok := compMap[identifierFieldName].(string); ok {
 		refName := "Unknown"
-		if name, found := metadataMap[refIDInt]; found {
+		if name, found := metadataMap[refIdentifier]; found {
 			refName = name
 		}
 		return map[string]interface{}{
-			"id":   refIDInt,
-			"name": refName,
+			"identifier": refIdentifier,
+			"name":       refName,
 		}
 	}
 	return nil

cmd/topology/topology_test_helper.go

@@ -12,13 +12,13 @@ func mockSnapshotResponse() sts.QuerySnapshotResult {
 			"_type": "ViewSnapshot",
 			"components": []interface{}{
 				map[string]interface{}{
-					"id":             float64(229404307680647),
-					"name":           "test-component",
-					"typeIdentifier": "urn:test:component-type:test",
-					"layer":          float64(186771622698247),
-					"domain":         float64(209616858431909),
-					"identifiers":    []interface{}{"urn:test:component:1"},
-					"tags":           []interface{}{"service.namespace:test"},
+					"id":               float64(229404307680647),
+					"name":             "test-component",
+					"typeIdentifier":   "urn:test:component-type:test",
+					"layerIdentifier":  "urn:test:layer:test",
+					"domainIdentifier": "urn:test:domain:test",
+					"identifiers":      []interface{}{"urn:test:component:1"},
+					"tags":             []interface{}{"service.namespace:test"},
 					"state": map[string]interface{}{
 						"healthState": "CRITICAL",
 					},
@@ -33,14 +33,14 @@ func mockSnapshotResponse() sts.QuerySnapshotResult {
 				},
 				"layers": []interface{}{
 					map[string]interface{}{
-						"id":   float64(186771622698247),
-						"name": "Test Layer",
+						"identifier": "urn:test:layer:test",
+						"name":       "Test Layer",
 					},
 				},
 				"domains": []interface{}{
 					map[string]interface{}{
-						"id":   float64(209616858431909),
-						"name": "Test Domain",
+						"identifier": "urn:test:domain:test",
+						"name":       "Test Domain",
 					},
 				},
 			},