feat(server/v2): Add Swagger UI support for server/v2

server/v2/api/swagger/config.go

@@ -0,0 +1,41 @@
+package swagger
+
+import (
+    "fmt"
+    "net/http"
+
+    "cosmossdk.io/core/server"
+)
+
+const ServerName = "swagger"
+
+// Config defines the configuration for the Swagger UI server
+type Config struct {
+    Enable    bool            `toml:"enable" mapstructure:"enable"`
+    Address   string         `toml:"address" mapstructure:"address"`
+    Path      string         `toml:"path" mapstructure:"path"`
+    SwaggerUI http.FileSystem `toml:"-" mapstructure:"-"`
+}
+
+// DefaultConfig returns the default configuration
+func DefaultConfig() *Config {
+    return &Config{
+        Enable:  true,
+        Address: "localhost:8080",
+        Path:    "/swagger/",
+    }
+}
+
+// Validate checks the configuration
+func (c Config) Validate() error {
+    if c.Path == "" {
+        return fmt.Errorf("swagger path cannot be empty")
+    }
+    if c.Enable && c.SwaggerUI == nil {
+        return fmt.Errorf("swagger UI file system must be provided when enabled")
+    }
+    return nil
+}
+
+// CfgOption defines a function for configuring the settings
+type CfgOption func(*Config)

server/v2/api/swagger/doc.go

@@ -0,0 +1,47 @@
+/*
+Package swagger provides Swagger UI support for server/v2.
+
+Example usage:
+
+	import (
+		"cosmossdk.io/client/docs"
+		"cosmossdk.io/core/server"
+		"cosmossdk.io/log"
+		swaggerv2 "cosmossdk.io/server/v2/api/swagger"
+	)
+
+	// Create a logger
+	logger := log.NewLogger()
+
+	// Configure Swagger server
+	swaggerCfg := server.ConfigMap{
+		"swagger": map[string]any{
+			"enable":  true,
+			"address": "localhost:8080",
+			"path":    "/swagger/",
+		},
+	}
+
+	// Create new Swagger server with the default SDK Swagger UI
+	swaggerServer, err := swaggerv2.New[YourTxType](
+		logger.With(log.ModuleKey, "swagger"),
+		swaggerCfg,
+		swaggerv2.CfgOption(func(cfg *swaggerv2.Config) {
+			cfg.SwaggerUI = docs.SwaggerUI // Use the default SDK Swagger UI
+		}),
+	)
+	if err != nil {
+		// Handle error
+	}
+
+	// Add Swagger server to your application
+	app.AddServer(swaggerServer)
+
+The server will serve Swagger UI documentation at the configured path (default: /swagger/).
+Users can customize the configuration through the following options:
+  - enable: Enable/disable the Swagger server
+  - address: The address to listen on (default: localhost:8080)
+  - path: The path to serve Swagger UI at (default: /swagger/)
+  - SwaggerUI: The http.FileSystem containing Swagger UI files
+*/
+package swagger 

server/v2/api/swagger/handler.go

@@ -0,0 +1,72 @@
+package swagger
+
+import (
+    "io"
+    "net/http"
+    "path/filepath"
+    "strings"
+    "time"
+)
+
+type swaggerHandler struct {
+    swaggerFS http.FileSystem
+}
+
+func (h *swaggerHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+    // Set minimal CORS headers
+    w.Header().Set("Access-Control-Allow-Origin", "*")
+    w.Header().Set("Access-Control-Allow-Methods", "GET")
+
+    if r.Method == http.MethodOptions {
+        return
+    }
+
+    // Process the path
+    urlPath := strings.TrimPrefix(r.URL.Path, "/swagger")
+    if urlPath == "" || urlPath == "/" {
+        urlPath = "/index.html"
+    }
+
+    // Open the file
+    file, err := h.swaggerFS.Open(urlPath)
+    if err != nil {
+        http.Error(w, "File not found", http.StatusNotFound)
+        return
+    }
+    defer file.Close()
+
+    // Set the content-type
+    ext := filepath.Ext(urlPath)
+    if ct := getContentType(ext); ct != "" {
+        w.Header().Set("Content-Type", ct)
+    }
+
+    // Set caching headers
+    w.Header().Set("Cache-Control", "public, max-age=31536000")
+    w.Header().Set("Last-Modified", time.Now().UTC().Format(http.TimeFormat))
+
+    // Serve the file
+    http.ServeContent(w, r, urlPath, time.Now(), file.(io.ReadSeeker))
+}
+
+// getContentType returns the content-type for a file extension
+func getContentType(ext string) string {
+    switch strings.ToLower(ext) {
+    case ".html":
+        return "text/html"
+    case ".css":
+        return "text/css"
+    case ".js":
+        return "application/javascript"
+    case ".json":
+        return "application/json"
+    case ".png":
+        return "image/png"
+    case ".jpg", ".jpeg":
+        return "image/jpeg"
+    case ".svg":
+        return "image/svg+xml"
+    default:
+        return ""
+    }
+}

server/v2/api/swagger/server.go

@@ -0,0 +1,110 @@
+package swagger
+
+import (
+    "context"
+    "fmt"
+    "net/http"
+
+    "cosmossdk.io/core/server"
+    "cosmossdk.io/core/transaction"
+    "cosmossdk.io/log"
+    serverv2 "cosmossdk.io/server/v2"
+)
+
+var (
+    _ serverv2.ServerComponent[transaction.Tx] = (*Server[transaction.Tx])(nil)
+    _ serverv2.HasConfig                       = (*Server[transaction.Tx])(nil)
+)
+
+// Server represents a Swagger UI server
+type Server[T transaction.Tx] struct {
+    logger     log.Logger
+    config     *Config
+    cfgOptions []CfgOption
+    server     *http.Server
+}
+
+// New creates a new Swagger UI server
+func New[T transaction.Tx](
+    logger log.Logger,
+    cfg server.ConfigMap,
+    cfgOptions ...CfgOption,
+) (*Server[T], error) {
+    srv := &Server[T]{
+        logger:     logger.With(log.ModuleKey, ServerName),
+        cfgOptions: cfgOptions,
+    }
+
+    serverCfg := srv.Config().(*Config)
+    if len(cfg) > 0 {
+        if err := serverv2.UnmarshalSubConfig(cfg, srv.Name(), &serverCfg); err != nil {
+            return nil, fmt.Errorf("failed to unmarshal config: %w", err)
+        }
+    }
+    srv.config = serverCfg
+
+    if err := srv.config.Validate(); err != nil {
+        return nil, err
+    }
+
+    mux := http.NewServeMux()
+    mux.Handle(srv.config.Path, &swaggerHandler{
+        swaggerFS: srv.config.SwaggerUI,
+    })
+
+    srv.server = &http.Server{
+        Addr:    srv.config.Address,
+        Handler: mux,
+    }
+
+    return srv, nil
+}
+
+// NewWithConfigOptions creates a new server with configuration options
+func NewWithConfigOptions[T transaction.Tx](opts ...CfgOption) *Server[T] {
+    return &Server[T]{
+        cfgOptions: opts,
+    }
+}
+
+// Name returns the server's name
+func (s *Server[T]) Name() string {
+    return ServerName
+}
+
+// Config returns the server configuration
+func (s *Server[T]) Config() any {
+    if s.config == nil || s.config.Address == "" {
+        cfg := DefaultConfig()
+        for _, opt := range s.cfgOptions {
+            opt(cfg)
+        }
+        return cfg
+    }
+    return s.config
+}
+
+// Start starts the server
+func (s *Server[T]) Start(ctx context.Context) error {
+    if !s.config.Enable {
+        s.logger.Info(fmt.Sprintf("%s server is disabled via config", s.Name()))
+        return nil
+    }
+
+    s.logger.Info("starting swagger server...", "address", s.config.Address)
+    if err := s.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+        return fmt.Errorf("failed to start swagger server: %w", err)
+    }
+
+    return nil
+}
+
+// Stop stops the server
+func (s *Server[T]) Stop(ctx context.Context) error {
+    if !s.config.Enable {
+        return nil
+    }
+
+    s.logger.Info("stopping swagger server...", "address", s.config.Address)
+    return s.server.Shutdown(ctx)
+}

simapp/v2/app.go

@@ -184,6 +184,7 @@ func NewSimApp[T transaction.Tx](
 	if err = app.LoadLatest(); err != nil {
 		return nil, err
 	}
+
 	return app, nil
 }
 

simapp/v2/simdv2/cmd/commands.go

@@ -38,6 +38,8 @@ import (
 	genutilcli "github.com/cosmos/cosmos-sdk/x/genutil/client/cli"
 	genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types"
 	v2 "github.com/cosmos/cosmos-sdk/x/genutil/v2/cli"
+	"cosmossdk.io/client/docs"
+	swaggerv2 "cosmossdk.io/server/v2/api/swagger"
 )
 
 // CommandDependencies is a struct that contains all the dependencies needed to initialize the root command.
@@ -92,6 +94,7 @@ func InitRootCmd[T transaction.Tx](
 			&telemetry.Server[T]{},
 			&rest.Server[T]{},
 			&grpcgateway.Server[T]{},
+			&swaggerv2.Server[T]{},
 		)
 	}
 
@@ -163,6 +166,18 @@ func InitRootCmd[T transaction.Tx](
 	}
 	registerGRPCGatewayRoutes[T](deps, grpcgatewayServer)
 
+	// Create Swagger server
+	swaggerServer, err := swaggerv2.New[T](
+		logger.With(log.ModuleKey, "swagger"),
+		deps.GlobalConfig,
+		swaggerv2.CfgOption(func(cfg *swaggerv2.Config) {
+			cfg.SwaggerUI = docs.SwaggerUI
+		}),
+	)
+	if err != nil {
+		return nil, err
+	}
+
 	// wire server commands
 	return serverv2.AddCommands[T](
 		rootCmd,
@@ -176,6 +191,7 @@ func InitRootCmd[T transaction.Tx](
 		telemetryServer,
 		restServer,
 		grpcgatewayServer,
+		swaggerServer,
 	)
 }