List artifacts that are deployed in a Gateway

Author: thivindu

platform-api/spec/impls/gateway-management/gateway-management.md

@@ -29,6 +29,7 @@ Gateway Management provides APIs for registering, managing, and deleting API gat
 | PUT | `/api/v1/gateways/{id}` | Update gateway | ✅ Implemented |
 | DELETE | `/api/v1/gateways/{id}` | Delete gateway | ✅ Implemented |
 | POST | `/api/v1/gateways/{id}/tokens` | Rotate gateway token | ✅ Implemented |
+| GET | `/api/v1/gateways/{id}/artifacts` | Get deployed artifacts | ✅ Implemented |
 | DELETE | `/api/v1/gateways/{id}/tokens/{tokenId}` | Revoke token | ⏳ Planned |
 
 ## Authentication & Authorization

platform-api/src/internal/constants/constants.go

@@ -64,3 +64,39 @@ var ValidGatewayFunctionalityType = map[string]bool{
 
 // DefaultGatewayFunctionalityType Default gateway functionality type for new gateways
 const DefaultGatewayFunctionalityType = GatewayFunctionalityTypeRegular
+
+// API Type Constants
+const (
+	APITypeHTTP       = "HTTP"
+	APITypeWS         = "WS"
+	APITypeSOAPToREST = "SOAPTOREST"
+	APITypeSOAP       = "SOAP"
+	APITypeGraphQL    = "GRAPHQL"
+	APITypeWebSub     = "WEBSUB"
+	APITypeSSE        = "SSE"
+	APITypeWebhook    = "WEBHOOK"
+	APITypeAsync      = "ASYNC"
+)
+
+// API SubType Constants
+const (
+	APISubTypeHTTP      = "REST"
+	APISubTypeGraphQL   = "GQL"
+	APISubTypeAsync     = "ASYNC"
+	APISubTypeWebSocket = "WEBSOCKET"
+	APISubTypeSOAP      = "SOAP"
+)
+
+// Artifact Type Constants
+const (
+	ArtifactTypeAPI        = "API"
+	ArtifactTypeMCP        = "MCP"
+	ArtifactTypeAPIProduct = "API_PRODUCT"
+)
+
+// ValidArtifactTypes Valid artifact types deployed to gateways
+var ValidArtifactTypes = map[string]bool{
+	ArtifactTypeAPI:        true,
+	ArtifactTypeMCP:        true,
+	ArtifactTypeAPIProduct: true,
+}

platform-api/src/internal/dto/gateway.go

@@ -90,3 +90,21 @@ type GatewayStatusListResponse struct {
 	List       []GatewayStatusResponse `json:"list"`
 	Pagination Pagination              `json:"pagination"`
 }
+
+// GatewayArtifact represents an artifact (API, MCP, API Product) deployed to a gateway
+type GatewayArtifact struct {
+	ID          string    `json:"id"`
+	Name        string    `json:"name"`
+	DisplayName string    `json:"displayName,omitempty"`
+	Type        string    `json:"type"`              // "API", "MCP", "API_PRODUCT"
+	SubType     string    `json:"subType,omitempty"` // For APIs: "REST", "ASYNC", "GQL"
+	CreatedAt   time.Time `json:"createdAt"`
+	UpdatedAt   time.Time `json:"updatedAt"`
+}
+
+// GatewayArtifactListResponse represents a paginated list of artifacts deployed to a gateway
+type GatewayArtifactListResponse struct {
+	Count      int               `json:"count"`
+	List       []GatewayArtifact `json:"list"`
+	Pagination Pagination        `json:"pagination"`
+}

platform-api/src/internal/handler/gateway.go

@@ -321,6 +321,51 @@ func (h *GatewayHandler) RotateToken(c *gin.Context) {
 	c.JSON(http.StatusCreated, response)
 }
 
+// GetGatewayArtifacts handles GET /api/v1/gateways/{gatewayId}/artifacts
+func (h *GatewayHandler) GetGatewayArtifacts(c *gin.Context) {
+	orgId, exists := middleware.GetOrganizationFromContext(c)
+	if !exists {
+		c.JSON(http.StatusUnauthorized, utils.NewErrorResponse(401, "Unauthorized",
+			"Organization claim not found in token"))
+		return
+	}
+
+	gatewayId := c.Param("gatewayId")
+	if gatewayId == "" {
+		c.JSON(http.StatusBadRequest, utils.NewErrorResponse(400, "Bad Request",
+			"Gateway ID is required"))
+		return
+	}
+
+	// Parse artifact type filter parameter
+	artifactType := c.Query("artifactType")
+	// Validate artifactType if provided
+	if artifactType != "" {
+		if !constants.ValidArtifactTypes[artifactType] {
+			c.JSON(http.StatusBadRequest, utils.NewErrorResponse(400, "Bad Request",
+				"Invalid artifact type. Valid values are: "+constants.ArtifactTypeAPI+", "+constants.ArtifactTypeMCP+
+					", "+constants.ArtifactTypeAPIProduct))
+			return
+		}
+	}
+
+	// Get paginated artifacts for the gateway
+	artifactListResponse, err := h.gatewayService.GetGatewayArtifacts(gatewayId, orgId, artifactType)
+	if err != nil {
+		if errors.Is(err, constants.ErrGatewayNotFound) {
+			c.JSON(http.StatusNotFound, utils.NewErrorResponse(404, "Not Found",
+				"Gateway not found"))
+			return
+		}
+		c.JSON(http.StatusInternalServerError, utils.NewErrorResponse(500, "Internal Server Error",
+			"Failed to get gateway artifacts"))
+		return
+	}
+
+	// Return paginated artifact list
+	c.JSON(http.StatusOK, artifactListResponse)
+}
+
 // RegisterRoutes registers gateway routes with the router
 func (h *GatewayHandler) RegisterRoutes(r *gin.Engine) {
 	gatewayGroup := r.Group("/api/v1/gateways")
@@ -331,6 +376,7 @@ func (h *GatewayHandler) RegisterRoutes(r *gin.Engine) {
 		gatewayGroup.PUT("/:gatewayId", h.UpdateGateway)
 		gatewayGroup.DELETE("/:gatewayId", h.DeleteGateway)
 		gatewayGroup.POST("/:gatewayId/tokens", h.RotateToken)
+		gatewayGroup.GET("/:gatewayId/artifacts", h.GetGatewayArtifacts)
 	}
 
 	gatewayStatusGroup := r.Group("/api/v1/status")

platform-api/src/internal/repository/api.go

@@ -266,6 +266,37 @@ func (r *APIRepo) GetAPIsByOrganizationID(orgID string, projectID *string) ([]*m
 	return apis, rows.Err()
 }
 
+// GetAPIsByGatewayID retrieves all APIs deployed to a specific gateway
+func (r *APIRepo) GetAPIsByGatewayID(gatewayID, organizationID string) ([]*model.API, error) {
+	query := `
+		SELECT a.uuid, a.name, a.display_name, a.type, a.created_at, a.updated_at
+		FROM apis a
+		INNER JOIN api_deployments ad ON a.uuid = ad.api_uuid
+		WHERE ad.gateway_uuid = ? AND a.organization_uuid = ?
+		ORDER BY a.created_at DESC
+	`
+
+	rows, err := r.db.Query(query, gatewayID, organizationID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var apis []*model.API
+	for rows.Next() {
+		api := &model.API{}
+		err := rows.Scan(
+			&api.ID, &api.Name, &api.DisplayName, &api.Type, &api.CreatedAt, &api.UpdatedAt,
+		)
+		if err != nil {
+			return nil, err
+		}
+		apis = append(apis, api)
+	}
+
+	return apis, nil
+}
+
 // UpdateAPI modifies an existing API
 func (r *APIRepo) UpdateAPI(api *model.API) error {
 	tx, err := r.db.Begin()

platform-api/src/internal/repository/interfaces.go

@@ -48,6 +48,7 @@ type APIRepository interface {
 	GetAPIByUUID(apiId string) (*model.API, error)
 	GetAPIsByProjectID(projectID string) ([]*model.API, error)
 	GetAPIsByOrganizationID(orgID string, projectID *string) ([]*model.API, error)
+	GetAPIsByGatewayID(gatewayID, organizationID string) ([]*model.API, error)
 	UpdateAPI(api *model.API) error
 	DeleteAPI(apiId string) error
 	CreateDeployment(deployment *model.APIDeployment) error

platform-api/src/internal/server/server.go

@@ -84,7 +84,7 @@ func StartPlatformAPIServer(cfg *config.Server) (*Server, error) {
 	projectService := service.NewProjectService(projectRepo, orgRepo, apiRepo)
 	gatewayEventsService := service.NewGatewayEventsService(wsManager)
 	apiService := service.NewAPIService(apiRepo, projectRepo, gatewayRepo, gatewayEventsService)
-	gatewayService := service.NewGatewayService(gatewayRepo, orgRepo)
+	gatewayService := service.NewGatewayService(gatewayRepo, orgRepo, apiRepo)
 	internalGatewayService := service.NewGatewayInternalAPIService(apiRepo, gatewayRepo, orgRepo)
 
 	// Initialize handlers

platform-api/src/internal/service/gateway.go

@@ -26,27 +26,31 @@ import (
 	"errors"
 	"fmt"
 	"platform-api/src/internal/constants"
+	"platform-api/src/internal/dto"
+	"platform-api/src/internal/model"
+	"platform-api/src/internal/repository"
+	"platform-api/src/internal/utils"
 	"regexp"
 	"strings"
 	"time"
 
 	"github.com/google/uuid"
-	"platform-api/src/internal/dto"
-	"platform-api/src/internal/model"
-	"platform-api/src/internal/repository"
 )
 
 // GatewayService handles gateway business logic
 type GatewayService struct {
 	gatewayRepo repository.GatewayRepository
 	orgRepo     repository.OrganizationRepository
+	apiRepo     repository.APIRepository
 }
 
 // NewGatewayService creates a new gateway service
-func NewGatewayService(gatewayRepo repository.GatewayRepository, orgRepo repository.OrganizationRepository) *GatewayService {
+func NewGatewayService(gatewayRepo repository.GatewayRepository, orgRepo repository.OrganizationRepository,
+	apiRepo repository.APIRepository) *GatewayService {
 	return &GatewayService{
 		gatewayRepo: gatewayRepo,
 		orgRepo:     orgRepo,
+		apiRepo:     apiRepo,
 	}
 }
 
@@ -469,6 +473,69 @@ func (s *GatewayService) UpdateGatewayActiveStatus(gatewayId string, isActive bo
 	return s.gatewayRepo.UpdateActiveStatus(gatewayId, isActive)
 }
 
+// GetGatewayArtifacts retrieves all artifacts (APIs) deployed to a specific gateway with pagination and optional type filtering
+func (s *GatewayService) GetGatewayArtifacts(gatewayID, orgID, artifactType string) (*dto.GatewayArtifactListResponse, error) {
+	// First validate that the gateway exists and belongs to the organization
+	gateway, err := s.gatewayRepo.GetByUUID(gatewayID)
+	if err != nil {
+		return nil, err
+	}
+	if gateway == nil {
+		return nil, constants.ErrGatewayNotFound
+	}
+	if gateway.OrganizationID != orgID {
+		return nil, constants.ErrGatewayNotFound
+	}
+
+	// Get all APIs deployed to this gateway
+	apis, err := s.apiRepo.GetAPIsByGatewayID(gatewayID, orgID)
+	if err != nil {
+		return nil, err
+	}
+
+	// Convert APIs to GatewayArtifact DTOs and apply type filtering
+	allArtifacts := make([]dto.GatewayArtifact, 0)
+	for _, api := range apis {
+		// Skip if artifactType filter is specified and doesn't match "API"
+		if artifactType != "" && artifactType != "API" {
+			continue
+		}
+
+		// Determine API subtype based on the type field using APIUtil
+		apiUtil := &utils.APIUtil{}
+		subType := apiUtil.GetAPISubType(api.Type)
+
+		artifact := dto.GatewayArtifact{
+			ID:          api.ID,
+			Name:        api.Name,
+			DisplayName: api.DisplayName,
+			Type:        "API",
+			SubType:     subType,
+			CreatedAt:   api.CreatedAt,
+			UpdatedAt:   api.UpdatedAt,
+		}
+		allArtifacts = append(allArtifacts, artifact)
+	}
+
+	// If filtering by MCP or API_PRODUCT, return empty list for now (future implementation)
+	if artifactType != "" && (artifactType == constants.ArtifactTypeMCP || artifactType == constants.ArtifactTypeAPIProduct) {
+		// For future implementation when MCP and API_PRODUCT are supported
+		allArtifacts = []dto.GatewayArtifact{}
+	}
+
+	listResponse := &dto.GatewayArtifactListResponse{
+		Count: len(allArtifacts),
+		List:  allArtifacts,
+		Pagination: dto.Pagination{
+			Total:  len(allArtifacts),
+			Offset: 0,
+			Limit:  len(allArtifacts),
+		},
+	}
+
+	return listResponse, nil
+}
+
 // validateGatewayInput validates gateway registration inputs
 func (s *GatewayService) validateGatewayInput(orgID, name, displayName, vhost, functionalityType string) error {
 	// Organization ID validation

platform-api/src/internal/utils/api.go

@@ -20,6 +20,7 @@ package utils
 import (
 	"fmt"
 	"gopkg.in/yaml.v3"
+	"platform-api/src/internal/constants"
 	"platform-api/src/internal/dto"
 	"platform-api/src/internal/model"
 )
@@ -715,6 +716,24 @@ func (u *APIUtil) policyModelToDTO(model *model.Policy) *dto.Policy {
 	}
 }
 
+// GetAPISubType determines the API subtype based on the API type using constants
+func (u *APIUtil) GetAPISubType(apiType string) string {
+	switch apiType {
+	case constants.APITypeHTTP:
+		return constants.APISubTypeHTTP
+	case constants.APITypeGraphQL:
+		return constants.APISubTypeGraphQL
+	case constants.APITypeAsync, constants.APITypeWebSub, constants.APITypeSSE, constants.APITypeWebhook:
+		return constants.APISubTypeAsync
+	case constants.APITypeWS:
+		return constants.APISubTypeWebSocket
+	case constants.APITypeSOAP, constants.APITypeSOAPToREST:
+		return constants.APISubTypeSOAP
+	default:
+		return constants.APISubTypeHTTP // Default to HTTP for unknown types
+	}
+}
+
 // GenerateAPIDeploymentYAML creates the deployment YAML from API data
 func (u *APIUtil) GenerateAPIDeploymentYAML(api *dto.API) (string, error) {
 	operationList := make([]dto.OperationRequest, 0)