Add support for urfave/cli (#1)

Author: lispyclouds

README.md

@@ -8,7 +8,7 @@ Read the detailed [blogpost](https://zuplo.com/blog/2025/02/02/generate-cli-from
 Go is a fantastic language to build CLI tooling, specially the ones for interacting with an API server. `<your tool>ctl` anyone?
 But if you're tired of building bespoke CLIs everytime or think that the swagger codegen isn't just good enough or don't quite subscribe to the idea of codegen in general (like me!), look no further.
 
-What if you can influence the CLI behaviour from the server? This enables you to bootstrap your [cobra](https://cobra.dev/) CLI tooling from an [OpenAPI](https://swagger.io/specification/) spec. Checkout [Wendy](https://bob-cd.github.io/cli/#wendy) as an example of a full CLI project made using climate.
+What if you can influence the CLI behaviour from the server? This enables you to bootstrap your [cobra](https://cobra.dev/) or [urfave/cli](https://cli.urfave.org/) CLI tooling from an [OpenAPI](https://swagger.io/specification/) spec. Checkout [Wendy](https://bob-cd.github.io/cli/#wendy) as an example of a full CLI project made using climate.
 
 ## Getting started
 
@@ -53,25 +53,41 @@ Load the spec:
 model, err := climate.LoadFileV3("api.yaml") // or climate.LoadV3 with []byte
 ```
 
-Define a cobra root command:
+Define a root command:
 
 ```go
+// Cobra
 rootCmd := &cobra.Command{
 	Use:   "calc",
 	Short: "My Calc",
 	Long:  "My Calc powered by OpenAPI",
 }
+
+// urfave/cli
+rootCmd := &cli.Command{
+	Name:        "calc",
+	Description: "My Calc",
+}
 ```
 
 Define one or more handler functions of the following signature:
 
 ```go
+// Cobra
 func handler(opts *cobra.Command, args []string, data climate.HandlerData) error {
 	slog.Info("called!", "data", fmt.Sprintf("%+v", data))
 	err := doSomethingUseful(data)
 
 	return err
 }
+
+// urfave/cli
+func handler(opts *cli.Command, args []string, data climate.HandlerData) error {
+	slog.Info("called!", "data", fmt.Sprintf("%+v", data))
+	err := doSomethingUseful(data)
+
+	return err
+}
 ```
 
 #### Handler Data
@@ -86,7 +102,11 @@ This can be used to query the params from the command mostly in a type safe mann
 // to get all the int path params
 for _, param := range data.PathParams {
 	if param.Type == climate.Integer {
+        // Cobra
 		value, _ := opts.Flags().GetInt(param.Name)
+
+        // urfave/cli
+		value, _ := opts.Int(param.Name)
 	}
 }
 ```
@@ -105,15 +125,23 @@ handlers := map[string]Handler{
 Bootstrap the root command:
 
 ```go
-err := climate.BootstrapV3(rootCmd, *model, handlers)
+// Cobra
+err := climate.BootstrapV3Cobra(rootCmd, *model, handlers)
+
+// urfave/cli
+err := climate.BootstrapV3UrfaveCli(rootCmd, *model, handlers)
 ```
 
 Continue adding more commands and/or execute:
 
 ```go
 // add more commands not from the spec
 
+// Cobra
 rootCmd.Execute()
+
+// urfave/cli
+rootCmd.Run(context.TODO(), os.Args)
 ```
 
 Sample output:

lib.go cobra.golib.go renamed to cobra.go

@@ -10,84 +10,16 @@ package climate
 import (
 	"fmt"
 	"log/slog"
-	"os"
 	"regexp"
 	"strconv"
 
 	"github.com/pb33f/libopenapi"
 	v3 "github.com/pb33f/libopenapi/datamodel/high/v3"
-	"github.com/pb33f/libopenapi/orderedmap"
 	"github.com/spf13/cobra"
-	"go.yaml.in/yaml/v4"
 )
 
-// Currently supported OpenAPI types
-type OpenAPIType string
-
-const (
-	String  OpenAPIType = "string"
-	Number  OpenAPIType = "number"
-	Integer OpenAPIType = "integer"
-	Boolean OpenAPIType = "boolean"
-)
-
-// Metadata for all parameters
-type ParamMeta struct {
-	Name string
-	Type OpenAPIType
-}
-
-// Data passed into each handler
-type HandlerData struct {
-	Method           string      // the HTTP method
-	Path             string      // the path with the path params filled in
-	PathParams       []ParamMeta // List of path params
-	QueryParams      []ParamMeta // List of query params
-	HeaderParams     []ParamMeta // List of header params
-	CookieParams     []ParamMeta // List of cookie params
-	RequestBodyParam *ParamMeta  // The optional request body
-}
-
-// The handler signature
 type Handler func(opts *cobra.Command, args []string, data HandlerData) error
-
-type extensions struct {
-	hidden  bool
-	aliases []string
-	group   string
-	ignored bool
-	name    string
-}
-
-func parseExtensions(exts *orderedmap.Map[string, *yaml.Node]) (*extensions, error) {
-	ex := extensions{}
-	aliases := []string{}
-
-	for ext, val := range exts.FromOldest() {
-		var opts any
-		if err := val.Decode(&opts); err != nil {
-			return nil, err
-		}
-
-		switch ext {
-		case "x-cli-hidden":
-			ex.hidden = opts.(bool)
-		case "x-cli-aliases":
-			for _, alias := range opts.([]any) {
-				aliases = append(aliases, alias.(string))
-			}
-			ex.aliases = aliases
-		case "x-cli-group":
-			ex.group = opts.(string)
-		case "x-cli-ignored":
-			ex.ignored = opts.(bool)
-		case "x-cli-name":
-			ex.name = opts.(string)
-		}
-	}
-
-	return &ex, nil
-}
+type HandlerCobra Handler
 
 func addParams(cmd *cobra.Command, op *v3.Operation, handlerData *HandlerData) {
 	var (
@@ -99,13 +31,7 @@ func addParams(cmd *cobra.Command, op *v3.Operation, handlerData *HandlerData) {
 	flags := cmd.Flags()
 
 	for _, param := range op.Parameters {
-		schema := param.Schema.Schema()
-		t := String
-		if schema != nil {
-			t = OpenAPIType(schema.Type[0])
-		} else {
-			slog.Warn("No type set for param, defaulting to string", "param", param.Name, "id", op.OperationId)
-		}
+		t := getParamType(param, op)
 
 		switch t {
 		case String:
@@ -122,6 +48,7 @@ func addParams(cmd *cobra.Command, op *v3.Operation, handlerData *HandlerData) {
 			continue
 		}
 
+		// TODO: Extract commom
 		meta := ParamMeta{Name: param.Name, Type: t}
 		switch param.In {
 		case "path":
@@ -145,48 +72,32 @@ func addParams(cmd *cobra.Command, op *v3.Operation, handlerData *HandlerData) {
 	handlerData.CookieParams = cookieParams
 }
 
-func addRequestBody(cmd *cobra.Command, op *v3.Operation, handlerData *HandlerData) error {
-	if body := op.RequestBody; body != nil {
-		// TODO: hammock on ways to handle the req bodies. Maybe take in a stdin?
-		bExts, err := parseExtensions(body.Extensions)
-		if err != nil {
-			return err
-		}
-
-		paramName := "climate-data"
-		if altName := bExts.name; altName != "" {
-			paramName = altName
-		} else {
-			slog.Warn(
-				fmt.Sprintf("No name set of requestBody, defaulting to %s", paramName),
-				"id",
-				op.OperationId,
-			)
-		}
+func addRequestBodyCobra(cmd *cobra.Command, op *v3.Operation, handlerData *HandlerData) error {
+	name, desc, required, err := makeRequestBody(op, handlerData)
+	if err != nil {
+		return err
+	}
 
-		// TODO: Handle all the different MIME types and schemas from body.Content
-		// maybe assert the shape if mime is json and schema is an object
-		// Treats all request body content as a string as of now
-		handlerData.RequestBodyParam = &ParamMeta{Name: paramName, Type: String}
-		cmd.Flags().String(paramName, "", body.Description)
+	cmd.Flags().String(name, "", desc)
 
-		if req := body.Required; req != nil && *req {
-			cmd.MarkFlagRequired(paramName)
-		}
+	if required {
+		cmd.MarkFlagRequired(name)
 	}
 
 	return nil
 }
 
-func interpolatePath(cmd *cobra.Command, h *HandlerData) error {
+func interpolatePathCobra(cmd *cobra.Command, h *HandlerData) error {
+	// TODO: Extract commom
+	flags := cmd.Flags()
+
 	for _, param := range h.PathParams {
 		pattern, err := regexp.Compile(fmt.Sprintf("({%s})+", param.Name))
 		if err != nil {
 			return err
 		}
 
 		var value string
-		flags := cmd.Flags()
 
 		switch param.Type {
 		case String:
@@ -208,33 +119,8 @@ func interpolatePath(cmd *cobra.Command, h *HandlerData) error {
 	return nil
 }
 
-// Loads and verifies an OpenAPI spec frpm an array of bytes
-func LoadV3(data []byte) (*libopenapi.DocumentModel[v3.Document], error) {
-	document, err := libopenapi.NewDocument(data)
-	if err != nil {
-		return nil, err
-	}
-
-	model, err := document.BuildV3Model()
-	if err != nil {
-		return nil, fmt.Errorf("Cannot create v3 model: %e", err)
-	}
-
-	return model, nil
-}
-
-// Loads and verifies an OpenAPI spec from a file path
-func LoadFileV3(path string) (*libopenapi.DocumentModel[v3.Document], error) {
-	data, err := os.ReadFile(path)
-	if err != nil {
-		return nil, err
-	}
-
-	return LoadV3(data)
-}
-
 // Bootstraps a cobra.Command with the loaded model and a handler map
-func BootstrapV3(rootCmd *cobra.Command, model libopenapi.DocumentModel[v3.Document], handlers map[string]Handler) error {
+func BootstrapV3Cobra(rootCmd *cobra.Command, model libopenapi.DocumentModel[v3.Document], handlers map[string]Handler) error {
 	cmdGroups := make(map[string][]cobra.Command)
 
 	for path, item := range model.Model.Paths.PathItems.FromOldest() {
@@ -251,7 +137,7 @@ func BootstrapV3(rootCmd *cobra.Command, model libopenapi.DocumentModel[v3.Docum
 
 			hData := HandlerData{Method: method, Path: path}
 			addParams(&cmd, op, &hData)
-			if err := addRequestBody(&cmd, op, &hData); err != nil {
+			if err := addRequestBodyCobra(&cmd, op, &hData); err != nil {
 				return err
 			}
 
@@ -268,7 +154,7 @@ func BootstrapV3(rootCmd *cobra.Command, model libopenapi.DocumentModel[v3.Docum
 				cmd.Short = op.Summary
 			}
 			cmd.RunE = func(opts *cobra.Command, args []string) error {
-				if err := interpolatePath(&cmd, &hData); err != nil {
+				if err := interpolatePathCobra(&cmd, &hData); err != nil {
 					return err
 				}
 
@@ -307,3 +193,11 @@ func BootstrapV3(rootCmd *cobra.Command, model libopenapi.DocumentModel[v3.Docum
 
 	return nil
 }
+
+// Bootstraps a cobra.Command with the loaded model and a handler map
+//
+// Deprecated: Will be kept for backwards compatibility.
+// Use BootstrapV3Cobra instead.
+func BootstrapV3(rootCmd *cobra.Command, model libopenapi.DocumentModel[v3.Document], handlers map[string]Handler) error {
+	return BootstrapV3Cobra(rootCmd, model, handlers)
+}

lib_test.go cobra_test.golib_test.go renamed to cobra_test.go

@@ -7,11 +7,6 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestLoadFileV3(t *testing.T) {
-	_, err := LoadFileV3("api.yaml")
-	assert.NoError(t, err)
-}
-
 func TestInterpolatePath(t *testing.T) {
 	cmd := cobra.Command{}
 	hData := HandlerData{
@@ -30,7 +25,7 @@ func TestInterpolatePath(t *testing.T) {
 	cmd.Flags().Float64("baz", 420.69, "baz usage")
 	cmd.Flags().Bool("quxx", false, "quxx usage")
 
-	err := interpolatePath(&cmd, &hData)
+	err := interpolatePathCobra(&cmd, &hData)
 	assert.NoError(t, err)
 
 	assert.Equal(t, hData.Path, "/path/yes/to/420/with/420.69/and/false/together")
@@ -72,7 +67,7 @@ func assertCmdTree(t *testing.T, cmd *cobra.Command, assertConf map[string]map[s
 	}
 }
 
-func TestBootstrapV3(t *testing.T) {
+func TestBootstrapV3Cobra(t *testing.T) {
 	model, err := LoadFileV3("api.yaml")
 	assert.NoError(t, err)
 
@@ -97,7 +92,7 @@ func TestBootstrapV3(t *testing.T) {
 		"GetInfo":     handler,
 	}
 
-	err = BootstrapV3(rootCmd, *model, handlers)
+	err = BootstrapV3Cobra(rootCmd, *model, handlers)
 	assert.NoError(t, err)
 
 	var noAlias []string
@@ -168,5 +163,6 @@ func TestBootstrapV3(t *testing.T) {
 		"--req-body",
 		"the string body",
 	})
-	rootCmd.Execute()
+
+	assert.NoError(t, rootCmd.Execute())
 }