Feat: Add service and application topology graph APIs based on discussion #1398

* feat(api): add GraphServices endpoint for service-level topology

Based on discussion #1398, use ServiceProviderMetadata and ServiceConsumerMetadata
to return provider/consumer application relations as graph nodes and edges for AntV G6.

* feat(api): add GraphApplications endpoint for application-level topology

Traverse provider/consumer service relations to build application-level graph.
Also add idx_service_consumer_service_key index to support efficient serviceKey queries.

* feat(api): add graph models (GraphNode, GraphEdge, GraphData) in pkg/console/model/graph.go

* feat(api): add ApplicationGraphReq, ServiceGraphReq and GetApplicationGraph, GetServiceGraph handlers

* feat(router): register /application/graph and /service/graph routes

* feat(api): fix error handling to use direct err pass-through instead of MeshNotFoundError

Author: ambiguous-pointer

pkg/console/handler/application.go

@@ -98,6 +98,23 @@ func ApplicationSearch(ctx consolectx.Context) gin.HandlerFunc {
 	}
 }
 
+func GetApplicationGraph(ctx consolectx.Context) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		req := model.NewApplicationGraphReq()
+		if err := c.ShouldBindQuery(req); err != nil {
+			util.HandleArgumentError(c, err)
+			return
+		}
+
+		resp, err := service.GraphApplications(ctx, req)
+		if err != nil {
+			util.HandleServiceError(c, err)
+			return
+		}
+		c.JSON(http.StatusOK, model.NewSuccessResp(resp))
+	}
+}
+
 func ApplicationConfigAccessLogPut(ctx consolectx.Context) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		appName := c.Query("appName")

pkg/console/handler/service.go

@@ -306,3 +306,22 @@ func ServiceConfigArgumentRoutePUT(ctx consolectx.Context) gin.HandlerFunc {
 		c.JSON(http.StatusOK, model.NewSuccessResp(nil))
 	}
 }
+
+// GetServiceGraph returns the service graph as graph data (nodes and edges) for visualization
+func GetServiceGraph(ctx consolectx.Context) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		req := &model.ServiceGraphReq{}
+		if err := c.ShouldBindQuery(req); err != nil {
+			c.JSON(http.StatusBadRequest, model.NewErrorResp(err.Error()))
+			return
+		}
+
+		resp, err := service.GraphServices(ctx, req)
+		if err != nil {
+			util.HandleServiceError(c, err)
+			return
+		}
+
+		c.JSON(http.StatusOK, model.NewSuccessResp(resp))
+	}
+}

pkg/console/model/application.go

@@ -189,6 +189,23 @@ func NewApplicationSearchReq() *ApplicationSearchReq {
 	}
 }
 
+type ApplicationGraphReq struct {
+	coremodel.PageReq
+
+	AppName  string `form:"appName" json:"appName"`
+	Keywords string `form:"keywords" json:"keywords"`
+	Mesh     string `form:"mesh" json:"mesh"`
+}
+
+func NewApplicationGraphReq() *ApplicationGraphReq {
+	return &ApplicationGraphReq{
+		PageReq: coremodel.PageReq{
+			PageOffset: 0,
+			PageSize:   15,
+		},
+	}
+}
+
 type ApplicationSearchResp struct {
 	AppName          string   `json:"appName"`
 	DeployClusters   []string `json:"deployClusters"`

pkg/console/model/graph.go

@@ -0,0 +1,73 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package model
+
+import (
+	meshresource "github.com/apache/dubbo-admin/pkg/core/resource/apis/mesh/v1alpha1"
+
+	"github.com/apache/dubbo-admin/pkg/common/constants"
+)
+
+// GraphNode represents a node in the graph for AntV G6
+type GraphNode struct {
+	ID    string      `json:"id"`
+	Label string      `json:"label"`
+	Type  string      `json:"type"` // "application" or "service"
+	Rule  string      `json:"rule"` // "provider", "consumer", or ""
+	Data  interface{} `json:"data,omitempty"`
+}
+
+// GraphEdge represents an edge in the graph for AntV G6
+type GraphEdge struct {
+	Source string                 `json:"source"`
+	Target string                 `json:"target"`
+	Data   map[string]interface{} `json:"data,omitempty"` // Additional data for the edge
+}
+
+// GraphData represents the complete graph structure for AntV G6
+type GraphData struct {
+	Nodes []GraphNode `json:"nodes"`
+	Edges []GraphEdge `json:"edges"`
+}
+
+// CrossNode represents a node in the cross-linked list structure
+type CrossNode struct {
+	Instance *meshresource.InstanceResource
+	Next     *CrossNode // pointer to next node in the same row
+	Down     *CrossNode // pointer to next node in the same column
+}
+
+// CrossLinkedListGraph represents the cross-linked list structure as a directed graph
+type CrossLinkedListGraph struct {
+	Head *CrossNode
+	Rows int // number of rows
+	Cols int // number of columns
+}
+
+// ServiceGraphReq represents the request parameters for fetching the service graph
+type ServiceGraphReq struct {
+	Mesh        string `json:"mesh" form:"mesh" binding:"required"`
+	ServiceName string `json:"serviceName" form:"serviceName" binding:"required"`
+	Version     string `json:"version" form:"version"`
+	Group       string `json:"group" form:"group"`
+}
+
+// ServiceKey returns the unique service identifier
+func (s *ServiceGraphReq) ServiceKey() string {
+	return s.ServiceName + constants.ColonSeparator + s.Version + constants.ColonSeparator + s.Group
+}

pkg/console/router/router.go

@@ -60,6 +60,7 @@ func InitRouter(r *gin.Engine, ctx consolectx.Context) {
 		application.GET("/instance/info", handler.GetApplicationTabInstanceInfo(ctx))
 		application.GET("/service/form", handler.GetApplicationServiceForm(ctx))
 		application.GET("/search", handler.ApplicationSearch(ctx))
+		application.GET("/graph", handler.GetApplicationGraph(ctx))
 		{
 			applicationConfig := application.Group("/config")
 			applicationConfig.PUT("/operatorLog", handler.ApplicationConfigAccessLogPut(ctx))
@@ -103,8 +104,7 @@ func InitRouter(r *gin.Engine, ctx consolectx.Context) {
 		service.GET("/provider-instances", handler.GetServiceProviderInstances(ctx))
 		service.GET("/methods", handler.GetServiceMethodNames(ctx))
 		service.GET("/search", handler.SearchServices(ctx))
-		//service.GET("/detail", handler.GetServiceDetail(ctx))
-		//service.GET("/interfaces", handler.GetServiceInterfaces(ctx))
+		service.GET("/graph", handler.GetServiceGraph(ctx))
 	}
 
 	{

pkg/console/service/application.go

@@ -202,6 +202,140 @@ func getAppConsumeServiceInfo(ctx consolectx.Context, req *model.ApplicationServ
 	return pageResult, nil
 }
 
+// GraphApplications returns the application-level graph for a given application.
+// It collects provider and consumer service relations and transforms them into nodes and edges.
+// The current implementation is a simplified version (provider/consumer link traversal).
+func GraphApplications(ctx consolectx.Context, req *model.ApplicationGraphReq) (*model.GraphData, error) {
+
+	// Step 1: query all services provided by this application in the namespace.
+	providerServiceList, err := manager.ListByIndexes[*meshresource.ServiceProviderMetadataResource](
+		ctx.ResourceManager(),
+		meshresource.ServiceProviderMetadataKind,
+		[]index.IndexCondition{{IndexName: index.ByMeshIndex, Value: req.Mesh, Operator: index.Equals},
+			{IndexName: index.ByServiceProviderAppName, Value: req.AppName, Operator: index.Equals},
+		},
+	)
+	if err != nil {
+		// manager.ListByIndexes 内部已经有合适的 error 返回，直接透传即可
+		return nil, err
+	}
+
+	// Step 2: query all services consumed by this application in the namespace.
+	consumerServiceList, err := manager.ListByIndexes[*meshresource.ServiceConsumerMetadataResource](
+		ctx.ResourceManager(),
+		meshresource.ServiceConsumerMetadataKind,
+		[]index.IndexCondition{{IndexName: index.ByMeshIndex, Value: req.Mesh, Operator: index.Equals},
+			{IndexName: index.ByServiceConsumerAppName, Value: req.AppName, Operator: index.Equals},
+		},
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	// Step 3: build the graph nodes and edges from provider and consumer relations.
+	// providerAppSet and consumerAppSet track already-added application nodes.
+	providerAppSet := make(map[string]struct{})
+	consumerAppSet := make(map[string]struct{})
+
+	nodes := make([]model.GraphNode, 0)
+	edges := make([]model.GraphEdge, 0)
+	// init self node
+	nodes = append(nodes, model.GraphNode{
+		ID:    req.AppName,
+		Label: req.AppName,
+		Type:  "application",
+		Rule:  "", // self node doesn't have a rule
+		Data:  nil,
+	})
+	// 3.a: iterate over provided services, collect service nodes and consumer app nodes.
+	for _, provider := range providerServiceList {
+		if provider.Spec == nil {
+			continue
+		}
+
+		// For each provided service, find consuming applications and add them as nodes.
+		consumerAppServiceList, err := manager.ListByIndexes[*meshresource.ServiceConsumerMetadataResource](
+			ctx.ResourceManager(),
+			meshresource.ServiceConsumerMetadataKind,
+			[]index.IndexCondition{{IndexName: index.ByMeshIndex, Value: req.Mesh, Operator: index.Equals},
+				{IndexName: index.ByServiceConsumerServiceKey, Value: provider.Spec.ServiceName + ":" + provider.Spec.Version + ":" + provider.Spec.Group, Operator: index.Equals},
+			},
+		)
+		if err != nil {
+			logger.Errorf("failed to list consumer apps by provider service key, mesh: %s, serviceKey: %s, err: %s", req.Mesh, provider.Spec.ProviderAppName+":"+provider.Spec.Version+":"+provider.Spec.Group, err)
+			continue
+		}
+
+		for _, item := range consumerAppServiceList {
+			if item.Spec == nil {
+				continue
+			}
+			if _, ok := consumerAppSet[item.Spec.ConsumerAppName]; !ok {
+				consumerAppSet[item.Spec.ConsumerAppName] = struct{}{}
+				nodes = append(nodes, model.GraphNode{
+					ID:    item.Spec.ConsumerAppName,
+					Label: item.Spec.ConsumerAppName,
+					Type:  "application",
+					Rule:  constants.ConsumerSide,
+					Data:  nil,
+				})
+				edges = append(edges, model.GraphEdge{
+					Source: item.Spec.ConsumerAppName,
+					Target: provider.Spec.ProviderAppName,
+					Data:   nil,
+				})
+			}
+		}
+	}
+
+	// 3.b: iterate over consumed services, collect service nodes and provider app nodes.
+	for _, consumer := range consumerServiceList {
+		if consumer.Spec == nil {
+			continue
+		}
+
+		// For each consumed service, find providing applications and add them as nodes.
+		providerAppList, err := manager.ListByIndexes[*meshresource.ServiceProviderMetadataResource](
+			ctx.ResourceManager(),
+			meshresource.ServiceProviderMetadataKind,
+			[]index.IndexCondition{{IndexName: index.ByMeshIndex, Value: req.Mesh, Operator: index.Equals},
+				{IndexName: index.ByServiceProviderServiceKey, Value: consumer.Spec.ServiceName + ":" + consumer.Spec.Version + ":" + consumer.Spec.Group, Operator: index.Equals},
+			},
+		)
+		if err != nil {
+			logger.Errorf("failed to list consumer apps by provider service key, mesh: %s, serviceKey: %s, err: %s", req.Mesh, consumer.Spec.ConsumerAppName+":"+consumer.Spec.Version+":"+consumer.Spec.Group, err)
+			continue
+		}
+
+		for _, item := range providerAppList {
+			if item.Spec == nil {
+				continue
+			}
+			if _, ok := providerAppSet[item.Spec.ProviderAppName]; !ok {
+				providerAppSet[item.Spec.ProviderAppName] = struct{}{}
+				nodes = append(nodes, model.GraphNode{
+					ID:    item.Spec.ProviderAppName,
+					Label: item.Spec.ProviderAppName,
+					Type:  "application",
+					Rule:  constants.ProviderSide,
+					Data:  nil,
+				})
+				edges = append(edges, model.GraphEdge{
+					Source: consumer.Spec.ConsumerAppName,
+					Target: item.Spec.ProviderAppName,
+					Data:   nil,
+				})
+			}
+		}
+	}
+
+	// Step 4: assemble and return graph data (nodes + edges).
+	return &model.GraphData{
+		Nodes: nodes,
+		Edges: edges,
+	}, nil
+}
+
 func SearchApplications(ctx consolectx.Context, req *model.ApplicationSearchReq) (*model.SearchPaginationResult, error) {
 	if strutil.IsNotBlank(req.Keywords) {
 		appResList, err := SearchApplicationsByKeywords(ctx, &model.SearchReq{