@xyd-js/opencli2go 0.1.0-build.0

package/__fixtures__/2.crud/output/internal/runtime/runtime.go

@@ -0,0 +1,64 @@
+package runtime
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+// Request is a generic API request assembled by a generated command handler.
+type Request struct {
+	Method  string
+	Path    string
+	Query   url.Values
+	Headers http.Header
+	Body    []byte
+}
+
+// Do executes the request against the configured base URL (applying auth) and
+// prints the response body to stdout.
+func Do(ctx context.Context, req Request) error {
+	endpoint := strings.TrimRight(BaseURL(), "/") + req.Path
+	if len(req.Query) > 0 {
+		endpoint += "?" + req.Query.Encode()
+	}
+
+	var body io.Reader
+	if len(req.Body) > 0 {
+		body = bytes.NewReader(req.Body)
+	}
+
+	httpReq, err := http.NewRequestWithContext(ctx, req.Method, endpoint, body)
+	if err != nil {
+		return err
+	}
+	for key, values := range req.Headers {
+		for _, value := range values {
+			httpReq.Header.Add(key, value)
+		}
+	}
+	if len(req.Body) > 0 && httpReq.Header.Get("Content-Type") == "" {
+		httpReq.Header.Set("Content-Type", "application/json")
+	}
+	applyAuth(httpReq)
+
+	resp, err := http.DefaultClient.Do(httpReq)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	out, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+	fmt.Println(string(out))
+	if resp.StatusCode >= 400 {
+		return fmt.Errorf("request failed: %s", resp.Status)
+	}
+	return nil
+}

package/__fixtures__/2.crud/output/pkg/cmd/widgets.go

@@ -0,0 +1,178 @@
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/url"
+
+	"example.com/widgets-api/internal/runtime"
+	"github.com/urfave/cli/v3"
+)
+
+func NewWidgetsCommand() *cli.Command {
+	return &cli.Command{
+		Name: "widgets",
+		Commands: []*cli.Command{
+			&cli.Command{
+				Name: "list",
+				Usage: "List all widgets.",
+				Flags: []cli.Flag{
+					&cli.IntFlag{
+						Name: "limit",
+						Usage: "Maximum number of widgets to return.",
+					},
+					&cli.StringFlag{
+						Name: "status",
+						Usage: "Filter by status.",
+					},
+				},
+				Action: handleWidgetsList,
+			},
+			&cli.Command{
+				Name: "create",
+				Usage: "Create a widget.",
+				Flags: []cli.Flag{
+					&cli.StringFlag{
+						Name: "name",
+						Usage: "The widget name.",
+						Required: true,
+					},
+					&cli.StringFlag{
+						Name: "color",
+					},
+					&cli.StringSliceFlag{
+						Name: "tags",
+					},
+					&cli.BoolFlag{
+						Name: "enabled",
+					},
+					&cli.StringFlag{
+						Name: "config",
+					},
+				},
+				Action: handleWidgetsCreate,
+			},
+			&cli.Command{
+				Name: "retrieve",
+				Aliases: []string{
+					"get",
+				},
+				Usage: "Retrieve a widget.",
+				Action: handleWidgetsRetrieve,
+			},
+			&cli.Command{
+				Name: "update",
+				Usage: "Update a widget.",
+				Flags: []cli.Flag{
+					&cli.StringFlag{
+						Name: "name",
+					},
+					&cli.BoolFlag{
+						Name: "enabled",
+					},
+				},
+				Action: handleWidgetsUpdate,
+			},
+			&cli.Command{
+				Name: "delete",
+				Usage: "Delete a widget.",
+				Action: handleWidgetsDelete,
+			},
+		},
+	}
+}
+
+func handleWidgetsList(ctx context.Context, cmd *cli.Command) error {
+	path := "/widgets"
+	query := url.Values{}
+	if cmd.IsSet("limit") {
+		query.Set("limit", fmt.Sprint(cmd.Int("limit")))
+	}
+	if cmd.IsSet("status") {
+		query.Set("status", cmd.String("status"))
+	}
+	req := runtime.Request{
+		Method: "GET",
+		Path: path,
+		Query: query,
+	}
+	return runtime.Do(ctx, req)
+}
+
+func handleWidgetsCreate(ctx context.Context, cmd *cli.Command) error {
+	path := "/widgets"
+	body := map[string]any{}
+	if cmd.IsSet("name") {
+		body["name"] = cmd.String("name")
+	}
+	if cmd.IsSet("color") {
+		body["color"] = cmd.String("color")
+	}
+	if cmd.IsSet("tags") {
+		body["tags"] = cmd.StringSlice("tags")
+	}
+	if cmd.IsSet("enabled") {
+		body["enabled"] = cmd.Bool("enabled")
+	}
+	if cmd.IsSet("config") {
+		raw := cmd.String("config")
+		var v any
+		if err := json.Unmarshal([]byte(raw), &v); err != nil {
+			v = raw
+		}
+		body["config"] = v
+	}
+	bodyBytes, err := json.Marshal(body)
+	if err != nil {
+		return err
+	}
+	req := runtime.Request{
+		Method: "POST",
+		Path: path,
+		Body: bodyBytes,
+	}
+	return runtime.Do(ctx, req)
+}
+
+func handleWidgetsRetrieve(ctx context.Context, cmd *cli.Command) error {
+	widgetID := cmd.Args().Get(0)
+	path := "/widgets/" + url.PathEscape(widgetID)
+	req := runtime.Request{
+		Method: "GET",
+		Path: path,
+	}
+	return runtime.Do(ctx, req)
+}
+
+func handleWidgetsUpdate(ctx context.Context, cmd *cli.Command) error {
+	widgetID := cmd.Args().Get(0)
+	path := "/widgets/" + url.PathEscape(widgetID)
+	body := map[string]any{}
+	if cmd.IsSet("name") {
+		body["name"] = cmd.String("name")
+	}
+	if cmd.IsSet("enabled") {
+		body["enabled"] = cmd.Bool("enabled")
+	}
+	bodyBytes, err := json.Marshal(body)
+	if err != nil {
+		return err
+	}
+	req := runtime.Request{
+		Method: "PATCH",
+		Path: path,
+		Body: bodyBytes,
+	}
+	return runtime.Do(ctx, req)
+}
+
+func handleWidgetsDelete(ctx context.Context, cmd *cli.Command) error {
+	widgetID := cmd.Args().Get(0)
+	path := "/widgets/" + url.PathEscape(widgetID)
+	req := runtime.Request{
+		Method: "DELETE",
+		Path: path,
+	}
+	return runtime.Do(ctx, req)
+}

package/__fixtures__/3.nested/input.json

@@ -0,0 +1,196 @@
+{
+  "opencli": "1.0.0",
+  "info": {
+    "title": "stores-api",
+    "version": "1.0.0"
+  },
+  "x-openapi": {
+    "servers": [
+      "https://api.stores.test/v2"
+    ]
+  },
+  "commands": [
+    {
+      "name": "stores",
+      "commands": [
+        {
+          "name": "items",
+          "commands": [
+            {
+              "name": "list",
+              "description": "List items in a store.",
+              "arguments": [
+                {
+                  "name": "store-id",
+                  "required": true
+                }
+              ],
+              "options": [
+                {
+                  "name": "limit",
+                  "group": "query",
+                  "arguments": [
+                    {
+                      "name": "integer"
+                    }
+                  ]
+                }
+              ],
+              "x-openapi": {
+                "method": "get",
+                "path": "/stores/{store_id}/items",
+                "operationId": "listStoreItems",
+                "params": [
+                  {
+                    "in": "path",
+                    "name": "store_id",
+                    "from": "argument:store-id",
+                    "required": true
+                  },
+                  {
+                    "in": "query",
+                    "name": "limit",
+                    "from": "option:limit"
+                  }
+                ]
+              }
+            },
+            {
+              "name": "create",
+              "description": "Create an item in a store.",
+              "arguments": [
+                {
+                  "name": "store-id",
+                  "required": true
+                }
+              ],
+              "options": [
+                {
+                  "name": "sku",
+                  "group": "body",
+                  "required": true,
+                  "arguments": [
+                    {
+                      "name": "string"
+                    }
+                  ]
+                },
+                {
+                  "name": "quantity",
+                  "group": "body",
+                  "arguments": [
+                    {
+                      "name": "integer"
+                    }
+                  ]
+                }
+              ],
+              "x-openapi": {
+                "method": "post",
+                "path": "/stores/{store_id}/items",
+                "operationId": "createStoreItem",
+                "contentType": "application/json",
+                "params": [
+                  {
+                    "in": "path",
+                    "name": "store_id",
+                    "from": "argument:store-id",
+                    "required": true
+                  }
+                ],
+                "body": {
+                  "style": "flatten",
+                  "contentType": "application/json",
+                  "properties": [
+                    {
+                      "name": "sku",
+                      "from": "option:sku",
+                      "jsonPath": "sku",
+                      "encoding": "string",
+                      "required": true
+                    },
+                    {
+                      "name": "quantity",
+                      "from": "option:quantity",
+                      "jsonPath": "quantity",
+                      "encoding": "integer"
+                    }
+                  ]
+                }
+              }
+            },
+            {
+              "name": "retrieve",
+              "aliases": [
+                "get"
+              ],
+              "description": "Retrieve a store item.",
+              "arguments": [
+                {
+                  "name": "store-id",
+                  "required": true
+                },
+                {
+                  "name": "item-id",
+                  "required": true
+                }
+              ],
+              "x-openapi": {
+                "method": "get",
+                "path": "/stores/{store_id}/items/{item_id}",
+                "operationId": "retrieveStoreItem",
+                "params": [
+                  {
+                    "in": "path",
+                    "name": "store_id",
+                    "from": "argument:store-id",
+                    "required": true
+                  },
+                  {
+                    "in": "path",
+                    "name": "item_id",
+                    "from": "argument:item-id",
+                    "required": true
+                  }
+                ]
+              }
+            },
+            {
+              "name": "archive",
+              "description": "Archive a store item.",
+              "arguments": [
+                {
+                  "name": "store-id",
+                  "required": true
+                },
+                {
+                  "name": "item-id",
+                  "required": true
+                }
+              ],
+              "x-openapi": {
+                "method": "post",
+                "path": "/stores/{store_id}/items/{item_id}/archive",
+                "operationId": "archiveStoreItem",
+                "params": [
+                  {
+                    "in": "path",
+                    "name": "store_id",
+                    "from": "argument:store-id",
+                    "required": true
+                  },
+                  {
+                    "in": "path",
+                    "name": "item_id",
+                    "from": "argument:item-id",
+                    "required": true
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

package/__fixtures__/3.nested/output/cmd/stores-api/main.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"context"
+	"log"
+	"os"
+
+	"example.com/stores-api/pkg/cmd"
+	"github.com/urfave/cli/v3"
+)
+
+func main() {
+	app := &cli.Command{
+		Name: "stores-api",
+		Version: "1.0.0",
+		Commands: []*cli.Command{
+			cmd.NewStoresCommand(),
+		},
+	}
+	if err := app.Run(context.Background(), os.Args); err != nil {
+		log.Fatal(err)
+	}
+}

package/__fixtures__/3.nested/output/go.mod

@@ -0,0 +1,3 @@
+module example.com/stores-api
+
+go 1.22

package/__fixtures__/3.nested/output/internal/runtime/config.go

@@ -0,0 +1,19 @@
+package runtime
+
+import (
+	"net/http"
+	"os"
+)
+
+const defaultBaseURL = "https://api.stores.test/v2"
+
+// BaseURL returns the API base URL, overridable via STORES_API_BASE_URL.
+func BaseURL() string {
+	if v := os.Getenv("STORES_API_BASE_URL"); v != "" {
+		return v
+	}
+	return defaultBaseURL
+}
+
+// applyAuth attaches credentials read from the environment to the request.
+func applyAuth(req *http.Request) {}

package/__fixtures__/3.nested/output/internal/runtime/runtime.go

@@ -0,0 +1,64 @@
+package runtime
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+// Request is a generic API request assembled by a generated command handler.
+type Request struct {
+	Method  string
+	Path    string
+	Query   url.Values
+	Headers http.Header
+	Body    []byte
+}
+
+// Do executes the request against the configured base URL (applying auth) and
+// prints the response body to stdout.
+func Do(ctx context.Context, req Request) error {
+	endpoint := strings.TrimRight(BaseURL(), "/") + req.Path
+	if len(req.Query) > 0 {
+		endpoint += "?" + req.Query.Encode()
+	}
+
+	var body io.Reader
+	if len(req.Body) > 0 {
+		body = bytes.NewReader(req.Body)
+	}
+
+	httpReq, err := http.NewRequestWithContext(ctx, req.Method, endpoint, body)
+	if err != nil {
+		return err
+	}
+	for key, values := range req.Headers {
+		for _, value := range values {
+			httpReq.Header.Add(key, value)
+		}
+	}
+	if len(req.Body) > 0 && httpReq.Header.Get("Content-Type") == "" {
+		httpReq.Header.Set("Content-Type", "application/json")
+	}
+	applyAuth(httpReq)
+
+	resp, err := http.DefaultClient.Do(httpReq)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	out, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+	fmt.Println(string(out))
+	if resp.StatusCode >= 400 {
+		return fmt.Errorf("request failed: %s", resp.Status)
+	}
+	return nil
+}

package/__fixtures__/3.nested/output/pkg/cmd/stores.go

@@ -0,0 +1,120 @@
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/url"
+
+	"example.com/stores-api/internal/runtime"
+	"github.com/urfave/cli/v3"
+)
+
+func NewStoresCommand() *cli.Command {
+	return &cli.Command{
+		Name: "stores",
+		Commands: []*cli.Command{
+			&cli.Command{
+				Name: "items",
+				Commands: []*cli.Command{
+					&cli.Command{
+						Name: "list",
+						Usage: "List items in a store.",
+						Flags: []cli.Flag{
+							&cli.IntFlag{
+								Name: "limit",
+							},
+						},
+						Action: handleStoresItemsList,
+					},
+					&cli.Command{
+						Name: "create",
+						Usage: "Create an item in a store.",
+						Flags: []cli.Flag{
+							&cli.StringFlag{
+								Name: "sku",
+								Required: true,
+							},
+							&cli.IntFlag{
+								Name: "quantity",
+							},
+						},
+						Action: handleStoresItemsCreate,
+					},
+					&cli.Command{
+						Name: "retrieve",
+						Aliases: []string{
+							"get",
+						},
+						Usage: "Retrieve a store item.",
+						Action: handleStoresItemsRetrieve,
+					},
+					&cli.Command{
+						Name: "archive",
+						Usage: "Archive a store item.",
+						Action: handleStoresItemsArchive,
+					},
+				},
+			},
+		},
+	}
+}
+
+func handleStoresItemsList(ctx context.Context, cmd *cli.Command) error {
+	storeID := cmd.Args().Get(0)
+	path := "/stores/" + url.PathEscape(storeID) + "/items"
+	query := url.Values{}
+	if cmd.IsSet("limit") {
+		query.Set("limit", fmt.Sprint(cmd.Int("limit")))
+	}
+	req := runtime.Request{
+		Method: "GET",
+		Path: path,
+		Query: query,
+	}
+	return runtime.Do(ctx, req)
+}
+
+func handleStoresItemsCreate(ctx context.Context, cmd *cli.Command) error {
+	storeID := cmd.Args().Get(0)
+	path := "/stores/" + url.PathEscape(storeID) + "/items"
+	body := map[string]any{}
+	if cmd.IsSet("sku") {
+		body["sku"] = cmd.String("sku")
+	}
+	if cmd.IsSet("quantity") {
+		body["quantity"] = cmd.Int("quantity")
+	}
+	bodyBytes, err := json.Marshal(body)
+	if err != nil {
+		return err
+	}
+	req := runtime.Request{
+		Method: "POST",
+		Path: path,
+		Body: bodyBytes,
+	}
+	return runtime.Do(ctx, req)
+}
+
+func handleStoresItemsRetrieve(ctx context.Context, cmd *cli.Command) error {
+	storeID := cmd.Args().Get(0)
+	itemID := cmd.Args().Get(1)
+	path := "/stores/" + url.PathEscape(storeID) + "/items/" + url.PathEscape(itemID)
+	req := runtime.Request{
+		Method: "GET",
+		Path: path,
+	}
+	return runtime.Do(ctx, req)
+}
+
+func handleStoresItemsArchive(ctx context.Context, cmd *cli.Command) error {
+	storeID := cmd.Args().Get(0)
+	itemID := cmd.Args().Get(1)
+	path := "/stores/" + url.PathEscape(storeID) + "/items/" + url.PathEscape(itemID) + "/archive"
+	req := runtime.Request{
+		Method: "POST",
+		Path: path,
+	}
+	return runtime.Do(ctx, req)
+}